Christophe GeuzaineGetDP uses three kinds of numeric variables: parser variables, run-time variables and ONELAB parameters.
Parser variables
Parser variables are created when the input .pro files are parsed, once at the beginning of a calculation. Such variables cannot be changed at run-time during a calculation, i.e. during pre-processing (Constraint evaluations), processing (Resolution operations) or post-processing (PostOperation operations). Parser variables are the most common in GetDP .pro files. They involve the least overhead at run-time, as their value is computed once, when the .pro file is read. They can be defined (almost) anywhere in .pro files, i.e. outside or inside objects like Function or Resolution.
In the following example a, b and c are parser variables; they can be used to create lists and strings like d() and e (which are also parser variables), or within functions like f[] (which will only be evaluated at run-time):
a = 1;
b = Sin[2*Pi/4] - a;
Function{
c = (b < 1) ? -4e6 : 2.2e2;
d() = {a,b,c};
e = Sprintf["string %g", c];
f[] = a + b + c;
If(c > 1) // this test is performed at parse time
Printf["c is greater than 1"]; // print message at parse time
Else
Printf["c is not greater than 1"];
EndIf
}Run-time variables
Run-time variables are created at run-time during pre-processing, processing or post-processing, through the run-time evaluation of expressions (e.g. in functions). Such variables can be used to handle dynamic cases that can not be predicted at parse time. Run-time variables begin with a dollar sign $. Their value can be set or retrieved in any expression, e.g. when a function is called or in a Formulation term, or in the Evaluate, While, Test, etc., operations in a Resolution. They can be set in expressions either with a simple affectation (=) or with the SetVariable function; their value can be retrieved either directly or using the GetVariable function. Both SetVariable and GetVariable allow to construct dynamic variable names, by appending suffixes dynamically depending on their extra arguments. Contrary to parser variables, which can only store real numbers, run-time variables can hold any fundamental GetDP value type: real, complex or multi-harmonic scalars (1 component), vectors (3 components) and tensors (3, 6 or 9 components).
Some run-time variables (“current values”) are read-only and are only modified by built-in GetDP algorithms or functions, like $Time or $TimeStep.
In the following example the run-time variable $a is set in two different ways in functions; the run-time variables $b_1, $b_2, ... are dynamically created and used depending on the index of the quadrature point in a formulation term (using the built-in function GetQuadraturePointIndex[]); and the run-time variable $c is set using the Evaluate operation in a Resolution or by storing the result of a PostOperation:
Function{
f[] = ($a = 2);
g[] = (SetVariable[2]{$a});
}
Formulation{
...
Equation{
Integral{ [ SetVariable[{u}, QuadraturePointIndex[]]{$b} * Dof{d u} , {d u}]; ... }
Integral{ [ 0.5 * GetVariable[QuadraturePointIndex[]]{$b} , {u}]; ... }
}
}
Resolution{
...
Operation{
Evaluate[ $c = 0.3 ];
While[ $c < 0.9 ]{
Evaluate[ $c = $c + 0.1 ];
}
Test[ $c > 1 ]{ // test performed at run-time
Print[{$c}, Format "$c = %g is greater than 1"]; // run-time message
}
}
}
PostOperation{
...
Operation{
Print[u, OnPoint {1,0,0}, StoreInVariable $c];
}
}Other built-in functions like ElementNum[] can be used to create a cache of evaluated expressions, per element and per quadrature point, to speed up calculations.
ONELAB parameters
ONELAB parameters are exchanged with a ONELAB server, and can thus be exchanged with other ONELAB clients connected to the same server. ONELAB parameters can be created or accessed both at parse time (using the parser commands DefineNumber, DefineConstant, GetNumber and SetNumber) or at run-time (using the functions GetNumberRunTime and SetNumberRunTime). ONELAB parameters potentially involve the most overhead, as they can be exchanged e.g. over a network through a TCP-IP socket.