# Management of Equations¶

When you read solution files with an object of class *Reader*, then you
get a *Base* containing the variables stored in the files. You may want
to compute some other variables depending on these latter variables.

You can set **equations** in Antares. From the user point of view, an
equation is a statement with the equals sign “=” that connects a
variable name on the left-hand side and an expression on the right-hand
side. If you go deeper in the library implementation, then the equation
is strictly speaking a function. The latter concept is much more
powerful than the first one in terms of complexity you can address.

But, in this tutorial, only the user-defined equation are introduced. You can also refer to http://cerfacs.fr/antares/src/tutorial/equations.html

```
import numpy as np
import antares
nnx, nny = (3, 2)
x_lst = np.linspace(0., 2., nnx)
y_lst = np.linspace(0., 1., nny)
xco, yco = np.meshgrid(x_lst, y_lst, indexing='ij')
base = antares.Base()
zone1 = base['0'] = antares.Zone()
zone1.shared['x'] = xco
zone1.shared['y'] = yco
instant = zone1['0'] = antares.Instant()
instant[('rho', 'node')] = np.ones(xco.shape)*1.2
instant['E'] = np.ones(xco.shape)*135000
base.show()
```

This is one way to create variables with antares. You can do it yourself with numpy arrays.

Before going further on, we have to introduce the notion of antares
**computer**. A computer is used to compute variables thanks to python
user-defined functions, and more specifically thanks to user-defined
equations for this tutorial.

By default, each *Instant* owns a **computer**. The computer contains
the equations and it will use the appropriate equation when asked.

So, we want to define a statement like

<variable name> = <mathematical expression>

The mathematical expression is composed of operators and variable names.
The variable names must be contained in *Instant* objects or defined
with an equation. The equations may use the following operators, symbols
and predefined mathematical functions:

’**‘,’/‘,’*‘,’+‘,’-‘,’,‘,’>‘,’<‘, ’abs(’, ‘angle(’, ‘arccos(’, ‘arcsin(’, ‘unwrap(’, ‘arctan2(’, ‘arctan(’, ‘conj(’, ‘cosh(’, ‘cos(’, ‘exp(’, ‘imag(’, ‘log(’, ‘log10(’, ‘max(’, ‘min(’, ‘mean(’, ‘maximum(’, ‘minimum(’, ‘ones(’, ‘real(’, ‘sign(’, ‘sinh(’, ‘sin(’, ‘sqrt(’, ‘tanh(’, ‘tan(’, ‘zeros(’, ‘(’, ‘)’

If you want to use the equation on the whole base, which is very often
the case, then set the equation with the method *set_formula()*. Then,
you can compute the variable you just have defined with the method
*compute()* of the *Base* class.

```
base.set_formula('rho_u = rho * 320')
base.compute('rho_u')
print(base[0][0])
print(base[0][0]['rho_u'])
```

When an equation is computed, the defined variable name appears in the
list of variables of the *Instant* objects.

You can also directly use the method *compute()* of the *Base* class.

```
base.compute('u = rho_u / rho')
print(base[0][0])
print(base[0][0]['u'])
```

Variables in *Instant* are always taken as is. Be careful if you change
the equations.

```
print('rho_u = ', base[0][0]['rho_u'])
print('Change formula')
base.set_formula('rho_u = rho * 310')
print(base[0][0]['rho_u'])
print('Compute formula')
base.compute('rho_u = rho * 310')
print(base[0][0]['rho_u'])
```

By default, intermediary variables are stored in the computer. They are not put in the Instant. Then, if you asked to compute the variable again, it will give you back the stored value.

You may want to reset the value of the variable.

```
base.set_formula('psta = rho*(E-Ec)*(gamma-1.)')
base.set_formula('Ec = u**2 / 3.')
gamma = 1.4
base.set_formula('gamma = %f'%gamma)
base.compute('psta')
print(base[0][0])
print(base[0][0]['psta'])
```

Oh I made a mistake in the kinetic energy equations.

```
base.set_formula('Ec = u**2 / 2.')
base.compute('psta')
print(base[0][0]['psta'])
```

The kinetic energy Ec is stored in the computer object and is reused (by default).

```
base.compute('psta', reset=False)
print(base[0][0]['psta'])
base.compute('psta', reset=True)
print(base[0][0]['psta'])
```

You could also not have stored the value of the variable at the first computation.

```
base.compute('psta', store=False)
```

All the previous methods are also available for `zone`

and `instant`

objects.

If you want to use the computing system in an Antares python script, you
may choose the **modeling** of the computer.A modeling is basically a
set of equations. The equations may be given a priori in python files as
with the modeling **internal** or given in a script with the function
:meth:`antares.Base.set_formula`

.**internal** is a very basic
modeling that is provided by Antares.

If you do not want to use any available modeling, then you can set your own temporary formula.

Modeling ########

```
base.set_computer_model('internal')
```

A modeling is basically a set of equations.

The equations may be given a priori in python files as with the modeling internal or given in a script with the function antares.Base.set_formula().

**internal**is a very basic modeling that is provided by Antares.

Let’s see what it contains

http://cerfacs.fr/antares/src/eqmanager/internal.html

```
base[0][0]['z'] = base[0][0]['x']
print(base[0][0])
base.compute('theta')
print(base[0][0])
```

Note that the variable **theta** is now in the Instant

Note the position of **theta** in the variables

**theta** computed from shared variables goes into the shared Instant

If you do not want to use any available modeling, then you can set your own temporary formula.

(you cannot save them yet)

By default, each Instant owns a computer.

A

**computer**is an object used to compute variables thanks to python user-defined functions.

If you want to use the computing system in an Antares python script, you may choose the modeling of the computer.

You can give your own equations before installing Antares.

see the default file antares/eqmanager/internal/equations.py

create a directory with the name of your modeling: *mkdir
antares/eqmanager/mymodeling*

put a file equations.py in this directory: see the structure from the
modeling **internal**