Equation Manager¶

Python module for an equation manager.

Detailed Class Documentation¶

class antares.eqmanager.kernel.eqmanager.EqManager(modeling)¶

Class of Equation Manager.

Kernel of formula management.

__init__(modeling)¶

Constructor.

Parameters:

modeling (str) – The name of a set of equations. This modeling contains equations that can be found in the directory that has the same name under the directory named formula. eg: the modeling internal must be in the directory formula

Variables:

_models (dict) – The dictionary that contains all modeling. A modeling is a dictionary with the key files. The value of the key files is a list of filenames (without extension) in which the functions are defined.
_results (dict) – Store the result of each computed formula to avoid recomputation.
_functions (dict) –
The function dictionary has keys functions and args. The value of the key functions is a python function object. The value of the key args is a list of input names that are the arguments of the function.
```
ex: {'c':  {'function': <function ...>,
            'args': ['ro', 'psta', 'gamma']}}.
```

model¶

Store the current modeling of the computer.

Type:: str or None

results(name)¶

Return the result of the formula.

Parameters:: name (str) – The name of a variable.

remove_result(elt)¶

Remove an element from the stored results.

Parameters:: elt (tuple(str, str)) – Formated variable name.

remove_results(safe=None)¶

Remove all the stored results except those given as args.

Parameters:: safe (list(tuple(str, str))) – Protected variable names.

add_located_input(inputs)¶

Add inputs that will be used in a known formula.

Parameters:: inputs (dict) – Set of items to consider as inputs.

ex: inputs = {(‘ro’, ‘node’): array([ 1.3, 1.3]),: (‘roE’, ‘node’): array([ 253312.5, 259812.5])}

add_input(**kwargs)¶

Add an input that will be used in a known formula.

Parameters:: inputs (depend on each value.) – Set of items to consider as inputs.

get_str_computed_formulae()¶: Return a string with known formulae.

get_list_computed_formulae()¶: Return the list of computed formulae.

get_str_formula_names()¶: Return a string with known formula names.

get_list_formula_names()¶: Return the list of known formula names.

get_formula_name_synonyms()¶: Return the synonyms of known formula names.

get_computable_formulae()¶: Return a string with computable formulae.

change_model(modeling, species_database=None, addons=None)¶

Change the modeling of the equation manager.

Parameters:

modeling (str) – The name of a set of equations.
addons (list(str)) – The names of additional files for equations.

set_formula(formula)¶

Set a new formula in the modeling.

Parameters:: formula (str) – The name of the new formula.

Operations available are in _numpy_operators.

add_function(new_func)¶

Set a new function in the modeling.

Parameters:: new_func (func) – a python function.

compute(variable)¶

Get the result of the given variable.

Launch computation if needed.

Parameters:: variable (tuple(str, str)) – The name and the location of the variable to compute.
Returns:: The value of the formula.
Return type:: Depending on the formula.

_handle_syn(missing_var, loc)¶

Perform operations to use synonyms of input variables.

Parameters:

missing_var (list(var)) – The name of variables that have not been found so far.
loc (str in ['node', 'cell']) – The location of the variables.

Returns:

True if no variables are missing (false otherwise).

Return type:

bool

_check_formula(formula, checked_vars=None)¶

Check if all dependencies of the given formula are available.

Parameters:: formula (function or str) – The formula function or the formula name to be checked.
Returns:: True if the formula can be computed (false otherwise), and the missing formula/var values.
Return type:: bool, list(str)

_compute(formula, loc)¶

Return the value of the given formula computation.

Launch computation of dependencies if needed.

Parameters:

formula (:obj: function) – The formula to compute.
loc (str in ['node', 'cell']) – The location of the variable.

Returns:

The value of the computation.

Return type:

Depending on the formula.

_store_function(name, obj)¶

Store the function object in the dictionary.

Parameters:

name (str) – Name of the function.
obj (:obj:function) – Function object.
container (dict) – Dictionary of functions.

_create_function_from_string(equation)¶

Create a function object from a string.

Parameters:: equation (str) – The literal expression of the equation.

_find_var_and_symbols(equation)¶

Find variables and symbols needed by the equation.

Parameters:: equation (str) – The literal expression of the equation.

_load_species_data(needed_vars)¶

Load species database.

Parameters:: needed_vars (list(str)) – Names of variables.

_get_all_formula_dependencies(formula)¶

Get all dependencies of the formula.

Parameters:: formula (str) – The formula name.
Returns:: The list of variables used to compute the formula.
Return type:: list(str)

Equation Modeling¶

Python module for the modeling of equations.

A modeling is defined as a set of equations governing a flow or any other physical phenomenon.

As example, you can defined a modeling incompressible that will contain all the equations you choose to define this physics.

Equation files¶

Functions of a particular modeling are defined in files in a path associated this modeling. e.g.: equations.py in formula/internal contains the functions associated to the modeling internal.

Functions¶

Each function defines a variable or a set of variables.

If it is a single variable, then the name of the function is the name of the variable.

e.g.:

def u(rhou, rho):
    return rhou/rho

If it is a set of variables, then the name of the function is simply a name.

e.g.:

def cons_abs(rhov, rhow):
    return {'rhov': rhov,
            'rhow': rhow}

The body of the function can be as complex as you want. You can query databases, read files, perform Newton algorithms, etc.

The arguments of the function are either variable names or function names.

Detailed Class Documentation¶

class antares.eqmanager.kernel.eqmodeling.EqModeling¶

Class of EqModeling.

This class reads and stores all modeling available.

__init__()¶

Constructor.

Variables:: _models (dict) – Store all modeling information. The dictionary that contains all equation modeling. A particular modeling is a dictionary with the keys files. The value of the key files is a list of filenames (without extension) in which the functions are defined.

_load_formula()¶

Read all formula files (python files).

Read all files that include a function definition.

Return models:: The dictionary that contains all equation modeling.

A modeling is a dictionary with the key files. The value of the key files is a list of filenames (without extension) in which the functions are defined.
A modeling has also key functions and synonyms. The value of the key functions is a dictionary with the keys corresponding to the name of each function of the modeling. Each function name corresponds to a dictionary with a key function and a value of a function object. The value of the key synonyms is a dictionary with the keys corresponding to the name of each variable that have been chosen to write the equations of the modeling. Each variable name corresponds to a dictionary of synonyms.
A modeling may also have a key addons. The value of the key addons is a dictionary with the keys corresponding to the name of each file in the addons repository of the modeling. Each file name corresponds to a dictionary with names of functions as keys and function objects as values.

Rtype models:: dict

{'compressible':
    {'files': ['equations', 'complement_1'],
     'functions': {'c': {'function': <function c at 0x>},
                   'Cp': {'function': <function Cp at 0x>},
                   'E': {'function': <function E at 0x>}},
     'addons': {'kl': {'k': <function k at 0x>},
                       'l': <function l at 0x>},
                'spalart': {'nut': <function nut at 0x>}}}},
 'incompressible':
    {'files': ['equations'],
     'functions': {'c': {'function': <function c at 0x>},
                   'u': {'function': <function u at 0x>}}}}

List of Available Equation Modelings¶