GetDP 1.2: Types for objects

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 4. Types for objects

This chapter presents the complete list of choices associated with metasyntactic variables introduced for the ten GetDP objects.

> 4.1 Types for `Group` |  |
> 4.2 Types for `Function` |  |
> 4.3 Types for `Constraint` |  |
> 4.4 Types for `FunctionSpace` |  |
> 4.5 Types for `Jacobian` |  |
> 4.6 Types for `Integration` |  |
> 4.7 Types for `Formulation` |  |
> 4.8 Types for `Resolution` |  |
> 4.9 Types for `PostProcessing` |  |
> 4.10 Types for `PostOperation` |  |

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 4.1 Types for `Group`

Types in

    group-type [ R1 <, group-sub-type R2 > ]

`group-type < group-sub-type >`:

`Region`
  Regions in R1.

`Global`
  Regions in R1 (variant of `Region` used with global `BasisFunction`s `BF_Global` and `BF_dGlobal`).

`NodesOf`
  Nodes of elements of R1

  < `Not`: but not those of R2 >.

`EdgesOf`
  Edges of elements of R1

  < `Not`: but not those of R2 >.

`FacetsOf`
  Facets of elements of R1

  < `Not`: but not those of R2 >.

`VolumesOf`
  Volumes of elements of R1

  < `Not`: but not those of R2 >.

`ElementsOf`
  Elements of regions in R1

  < `OnOneSideOf`: only elements on one side of R2) >.

`GroupsOfNodesOf`
  Groups of nodes of elements of R1 (a group is associated with each region).

`GroupsOfEdgesOf`
  Groups of edges of elements of R1 (a group is associated with each region).

  < `InSupport`: in a support R2 being a group of type `ElementOf`, i.e., containing elements >.

`GroupsOfEdgesOnNodesOf`
  Groups of edges incident to nodes of elements of R1 (a group is associated with each node).

  < `Not`: but not those of R2) >.

`EdgesOfTreeIn`
  Edges of a tree of edges of R1

  < `StartingOn`: a complete tree is first built on R2 >.

`FacetsOfTreeIn`
  Facets of a tree of facets of R1

  < `StartingOn`: a complete tree is first built on R2 >.

`DualNodesOf`
  Dual nodes of elements of R1.

`DualEdgesOf`
  Dual edges of elements of R1.

`DualFacetsOf`
  Dual facets of elements of R1.

`DualVolumesOf`
  Dual volumes of elements of R1.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 4.2 Types for `Function`

> 4.2.1 Math functions |  |
> 4.2.2 Extended math functions |  |
> 4.2.3 Green functions |  |
> 4.2.4 Type manipulation functions |  |
> 4.2.5 Coordinate functions |  |
> 4.2.6 Miscellaneous functions |  |

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 4.2.1 Math functions

The following functions are the equivalent of the functions of the C math library, and always return real-valued expressions. These are the only functions allowed in constant expressions (expression-cst, see 2.2 Constants).

math-function-id:

`Exp`
  `[expression]`

  Exponential function: e^expression.

`Log`
  `[expression]`

  Natural logarithm: ln(expression), expression>0.

`Log10`
  `[expression]`

  Base 10 logarithm: log10(expression), expression>0.

`Sqrt`
  `[expression]`

  Square root, expression>=0.

`Sin`
  `[expression]`

  Sine of expression.

`Asin`
  `[expression]`

  Arc sine (inverse sine) of expression in [-Pi/2,Pi/2], expression in [-1,1].

`Cos`
  `[expression]`

  Cosine of expression.

`Acos`
  `[expression]`

  Arc cosine (inverse cosine) of expression in [0,Pi], expression in [-1,1].

`Tan`
  `[expression]`

  Tangent of expression.

`Atan`
  `[expression]`

  Arc tangent (inverse tangent) of expression in [-Pi/2,Pi/2].

`Atan2`
  `[expression,expression]`

  Arc tangent (inverse tangent) of the first expression divided by the second, in [-Pi,Pi].

`Sinh`
  `[expression]`

  Hyperbolic sine of expression.

`Cosh`
  `[expression]`

  Hyperbolic cosine of expression.

`Tanh`
  `[expression]`

  Hyperbolic tangent of expression.

`Fabs`
  `[expression]`

  Absolute value of expression.

`Fmod`
  `[expression,expression]`

  Remainder of the division of the first expression by the second, with the sign of the first.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 4.2.2 Extended math functions

extended-math-function-id:

`Cross`
  `[expression,expression]`

  Cross product of the two arguments; expression must be a vector.

`Hypot`
  `[expression,expression]`

  Square root of the sum of the squares of its arguments.

`Norm`
  `[expression]`

  Absolute value if expression is a scalar; euclidian norm if expression is a vector.

`SquNorm`
  `[expression]`

  Square norm: `Norm[expression]^2`.

`Unit`
  `[expression]`

  Normalization: `expression/Norm[expression]`. Returns 0 if the norm is smaller than 1.e-30.

`Transpose`
  `[expression]`

  Transposition; expression must be a tensor.

`TTrace`
  `[expression]`

  Trace; expression must be a tensor.

`F_Cos_wt_p`
  `[]{expression-cst,expression-cst}`

  The first parameter represents the angular frequency and the second represents the phase. If the type of the current system is `Real`, `F_Cos_wt_p[]{w,p}` is identical to `Cos[w*$Time+p]`. If the type of the current system is `Complex`, it is identical to `Complex[Cos[w],Sin[w]]`.

`F_Sin_wt_p`
  `[]{expression-cst,expression-cst}`

  The first parameter represents the angular frequency and the second represents the phase. If the type of the current system is `Real`, `F_Sin_wt_p[]{w,p}` is identical to `Sin[w*$Time+p]`. If the type of the current system is `Complex`, it is identical to `Complex[Sin[w],-Cos[w]]`.

`F_Period`
  `[expression]{expression-cst}`

  `Fmod[expression,expression-cst]` `+` `(expression<0 ? expression-cst : 0)`; the result is always in [0,expression-cst[.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 4.2.3 Green functions

The Green functions are only used in integral quantities (see section 3.7 `Formulation`: building equations). The first parameter represents the dimension of the problem:

- `1D`: `r = Fabs[$X-$XS]`
- `2D`: `r = Sqrt[($X-$XS)^2+($Y-$YS)^2]`
- `3D`: `r = Sqrt[($X-$XS)^2+($Y-$YS)^2+($Z-$ZS)^2]`

The triplets of values given in the definitions below correspond to the `1D`, `2D` and `3D` cases.

green-function-id:

`Laplace`
  `[]{expression-cst}`

  `r/2`, `1/(2*Pi)*ln(1/r)`, `1/(4*Pi*r)`.

`GradLaplace`
  `[]{expression-cst}`

  Gradient of `Laplace` relative to the destination point (`$X`, `$Y`, `$Z`).

`Helmholtz`
  `[]{expression-cst, expression-cst}`

  `exp(j*k0*r)/(4*Pi*r)`, where `k0` is given by the second parameter.

`GradHelmholtz`
  `[]{expression-cst, expression-cst}`

  Gradient of `Helmholtz` relative to the destination point (`$X`, `$Y`, `$Z`).

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 4.2.4 Type manipulation functions

type-function-id:

`Complex`
  `[expression-list]`

  Creates a (multi-harmonic) complex expression from an number of real-valued expressions. The number of expressions in expression-list must be even.

`Re`
  `[expression]`

  Takes the real part of a complex-valued expression.

`Im`
  `[expression]`

  Takes the imaginary part of a complex-valued expression.

`Vector`
  `[expression,expression,expression]`

  Creates a vector from 3 scalars.

`Tensor`
  `[expression,expression,expression,expression,expression,expression,`

  `expression,expression,expression]`

  Creates a second-rank tensor of order 3 from 9 scalars.

`TensorV`
  `[expression,expression,expression]`

  Creates a second-rank tensor of order 3 from 3 vectors.

`TensorSym`
  `[expression,expression,expression,expression,expression,expression]`

  Creates a symmetrical second-rank tensor of order 3 from 6 scalars.

`TensorDiag`
  `[expression,expression,expression]`

  Creates a diagonal second-rank tensor of order 3 from 3 scalars.

`CompX`
  `[expression]`

  Gets the X component of a vector.

`CompY`
  `[expression]`

  Gets the Y component of a vector.

`CompZ`
  `[expression]`

  Gets the Z component of a vector.

`CompXX`
  `[expression]`

  Gets the XX component of a tensor.

`CompXY`
  `[expression]`

  Gets the XY component of a tensor.

`CompXZ`
  `[expression]`

  Gets the XZ component of a tensor.

`CompYX`
  `[expression]`

  Gets the YX component of a tensor.

`CompYY`
  `[expression]`

  Gets the YY component of a tensor.

`CompYZ`
  `[expression]`

  Gets the YZ component of a tensor.

`CompZX`
  `[expression]`

  Gets the ZX component of a tensor.

`CompZY`
  `[expression]`

  Gets the ZY component of a tensor.

`CompZZ`
  `[expression]`

  Gets the ZZ component of a tensor.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 4.2.5 Coordinate functions

coord-function-id:

`X`
  `[]`

  Gets the X coordinate.

`Y`
  `[]`

  Gets the Y coordinate.

`Z`
  `[]`

  Gets the Z coordinate.

`XYZ`
  `[]`

  Gets X, Y and Z in a vector.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 4.2.6 Miscellaneous functions

misc-function-id:

`Printf`
  `[expression]`

  Prints the value of expression when evaluated.

`Normal`
  `[]`

  Computes the normal to the element.

`NormalSource`
  `[]`

  Computes the normal to the source element (only valid in a quantity of Integral type).

`F_CompElementNum`
  `[]`

  Returns 0 if the current element and the current source element are identical.

`InterpolationLinear`
  `[]{expression-cst-list}`

  Linear interpolation of points. The number of constant expressions in expression-cst-list must be even.

`dInterpolationLinear`
  `[]{expression-cst-list}`

  Derivative of linear interpolation of points. The number of constant expressions in expression-cst-list must be even.

`InterpolationAkima`
  `[]{expression-cst-list}`

  Akima interpolation of points. The number of constant expressions in expression-cst-list must be even.

`dInterpolationAkima`
  `[]{expression-cst-list}`

  Derivative of Akima interpolation of points. The number of constant expressions in expression-cst-list must be even.

`Order`
  `[quantity]`

  Returns the interpolation order of the quantity.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 4.3 Types for `Constraint`

constraint-type:

`Assign`
  To assign a value (e.g., for boundary condition).

`Init`
  To give an initial value (e.g., initial value in a time analysis).

`AssignFromResolution`
  To assign a value to be computed by a pre-resolution.

`InitFromResolution`
  To give an initial value to be computed by a pre-resolution.

`Network`
  To describe the node connections of branches in a network.

`Link`
  To define links between degrees of freedom in the constrained region with degrees of freedom in a "reference" region, with some coefficient. For example, to link the degrees of freedom in the contrained region `Left` with the degrees of freedom in the reference region `Right`, located 1 unit to the right of the region `Left` along the X-axis, with the coeficient `-1`, one could write:

      { Name periodic;
        Case {
          { Region Left; Type Link ; RegionRef Right;
            Coefficient -1; Function Vector[$X+Pi,$Y,$Z] ;
          }
        }
      }

  In this example, `Function` defines the mapping that translates the geometrical elements in the region `Left` by 1 along the X-axis, so that they correspond with the elements in the region `Right`. For this mapping to work, the meshes of `Left` and `Right` must be identical.

`LinkCplx`
  To define complex-valued links between degrees of freedom. The syntax is the same as for constraints of type `Link`, but `Coeficient` can be complex.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 4.4 Types for `FunctionSpace`

function-space-type:

`Form0`
  0-form, i.e., scalar field of potential type.

`Form1`
  1-form, i.e., curl-conform field (associated with a curl).

`Form2`
  2-form, i.e., div-conform field (associated with a divergence).

`Form3`
  3-form, i.e., scalar field of density type.

`Form1P`
  1-form perpendicular to the z=0 plane, i.e., perpendicular curl-conform field (associated with a curl).

`Form2P`
  2-form in the z=0 plane, i.e., parallel div-conform field (associated with a divergence).

`Scalar`
  Scalar field.

`Vector`
  Vector field.

basis-function-type:

`BF_Node`
  Nodal function (on `NodesOf`, value `Form0`).

`BF_Edge`
  Edge function (on `EdgesOf`, value `Form1`).

`BF_Facet`
  Facet function (on `FacetsOf`, value `Form2`).

`BF_Volume`
  Volume function (on `VolumesOf`, value `Form3`).

`BF_GradNode`
  Gradient of nodal function (on `NodesOf`, value `Form1`).

`BF_CurlEdge`
  Curl of edge function (on `EdgesOf`, value `Form2`).

`BF_DivFacet`
  Divergence of facet function (on `FacetsOf`, value `Form3`).

`BF_GroupOfNodes`
  Sum of nodal functions (on `GroupsOfNodesOf`, value `Form0`).

`BF_GradGroupOfNodes`
  Gradient of sum of nodal functions (on `GroupsOfNodesOf`, value `Form1`).

`BF_GroupOfEdges`
  Sum of edge functions (on `GroupsOfEdgesOf`, value `Form1`).

`BF_CurlGroupOfEdges`
  Curl of sum of edge functions (on `GroupsOfEdgesOf`, value `Form2`).

`BF_PerpendicularEdge`
  1-form (0, 0, `BF_Node`) (on `NodesOf`, value `Form1P`).

`BF_CurlPerpendicularEdge`
  Curl of 1-form (0, 0, `BF_Node`) (on `NodesOf`, value `Form2P`).

`BF_GroupOfPerpendicularEdge`
  Sum of 1-forms (0, 0, `BF_Node`) (on `NodesOf`, value `Form1P`).

`BF_CurlGroupOfPerpendicularEdge`
  Curl of sum of 1-forms (0, 0, `BF_Node`) (on `NodesOf`, value `Form2P`).

`BF_PerpendicularFacet`
  2-form (90 degree rotation of `BF_Edge`) (on `EdgesOf`, value `Form2P`).

`BF_DivPerpendicularFacet`
  Div of 2-form (90 degree rotation of `BF_Edge`) (on `EdgesOf`, value `Form3`).

`BF_Region`
  Unit value 1 (on `Region`, value `Scalar`).

`BF_RegionX`
  Unit vector (1, 0, 0) (on `Region`, value `Vector`).

`BF_RegionY`
  Unit vector (0, 1, 0) (on `Region`, value `Vector`).

`BF_RegionZ`
  Unit vector (0, 0, 1) (on `Region`, value `Vector`).

`BF_Global`
  Global pre-computed quantity (on `Global`, value depends on parameters).

`BF_dGlobal`
  Exterior derivative of global pre-computed quantity (on `Global`, value depends on parameters).

`BF_NodeX`
  Vector (`BF_Node`, 0, 0) (on `NodesOf`, value `Vector`).

`BF_NodeY`
  Vector (0, `BF_Node`, 0) (on `NodesOf`, value `Vector`).

`BF_NodeZ`
  Vector (0, 0, `BF_Node`) (on `NodesOf`, value `Vector`).

`BF_Zero`
  Zero value 0 (on all regions, value `Scalar`).

`BF_One`
  Unit value 1 (on all regions, value `Scalar`).

global-quantity-type:

`AliasOf`
  Another name for a name of coefficient of basis function.

`AssociatedWith`
  A global quantity associated with a name of coefficient of basis function, and therefore with this basis function.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 4.5 Types for `Jacobian`

jacobian-type:

`Vol`
  Volume Jacobian, for n-D regions in n-D geometries, n = 1, 2 or 3.

`Sur`
  Surface Jacobian, for (n-1)-D regions in n-D geometries, n = 1, 2 or 3.

`Lin`
  Line Jacobian, for (n-2)-D regions in n-D geometries, n = 2 or 3.

`VolAxi`
  Axisymmetrical volume Jacobian (1st type: r), for 2-D regions in axisymmetrical geometries.

`SurAxi`
  Axisymmetrical surface Jacobian (1st type: r), for 1-D regions in axisymmetrical geometries.

`VolAxiSqu`
  Axisymmetrical volume Jacobian (2nd type: r^2), for 2-D regions in axisymmetrical geometries.

`VolSphShell`
  Volume Jacobian with spherical shell transformation, for n-D regions in n-D geometries, n = 2 or 3.

  Parameters: radius-internal, radius-external <, center-X, center-Y, center-Z, power, 1/infinity >.

`VolAxiSphShell`
  Same as `VolAxi`, but with spherical shell transformation.

  Parameters: radius-internal, radius-external <, center-X, center-Y, center-Z, power, 1/infinity >.

`VolAxiSquSphShell`
  Same as `VolAxiSqu`, but with spherical shell transformation.

  Parameters: radius-internal, radius-external <, center-X, center-Y, center-Z, power, 1/infinity >.

`VolRectShell`
  Volume Jacobian with rectangular shell transformation, for n-D regions in n-D geometries, n = 2 or 3.

  Parameters: radius-internal, radius-external <, direction, center-X, center-Y, center-Z, power, 1/infinity >.

`VolAxiRectShell`
  Same as `VolAxi`, but with rectangular shell transformation.

  Parameters: radius-internal, radius-external <, direction, center-X, center-Y, center-Z, power, 1/infinity >.

`VolAxiSquRectShell`
  Same as `VolAxiSqu`, but with rectangular shell transformation.

  Parameters: radius-internal, radius-external <, direction, center-X, center-Y, center-Z, power, 1/infinity >.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 4.6 Types for `Integration`

integration-type:

`Gauss`
  Numerical Gauss integration.

`GaussLegendre`
  Numerical Gauss integration obtained by application of a multiplicative rule on the one-dimensional Gauss integration.

element-type:

`Line`
  Line (2 nodes, 1 edge, 1 volume) (#1).

`Triangle`
  Triangle (3 nodes, 3 edges, 1 facet, 1 volume) (#2).

`Quadrangle`
  Quadrangle (4 nodes, 4 edges, 1 facet, 1 volume) (#3).

`Tetrahedron`
  Tetrahedron (4 nodes, 6 edges, 4 facets, 1 volume) (#4).

`Hexahedron`
  Hexahedron (8 nodes, 12 edges, 6 facets, 1 volume) (#5).

`Prism`
  Prism (6 nodes, 9 edges, 5 facets, 1 volume) (#6).

`Pyramid`
  Pyramid (5 nodes, 8 edges, 5 facets, 1 volume) (#7).

`Point`
  Point (1 node) (#15).

Note:

1. n in (#n) is the type number of the element (see section 8.1 Input file format).

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 4.7 Types for `Formulation`

formulation-type:

`FemEquation`
  Finite element method formulation (all methods of moments, integral methods).

local-term-type:

`Galerkin`
  Integral of Galerkin type.

`deRham`
  deRham projection (collocation).

quantity-type:

`Local`
  Local quantity defining a field in a function space. In case a subspace is considered, its identifier has to be given between the brackets following the `NameOfSpace function-space-id`.

`Global`
  Global quantity defining a global quantity from a function space. The identifier of this quantity has to be given between the brackets following the `NameOfSpace function-space-id`.

`Integral`
  Integral quantity obtained by the integration of a `LocalQuantity` before its use in an `Equation` term.

term-op-type:

`Dt`
  Time derivative applied to the whole term of the equation.

`DtDof`
  Time derivative applied only to the `Dof{}` term of the equation.

`DtDt`
  Time derivative of 2nd order applied to the whole term of the equation.

`DtDtDof`
  Time derivative of 2nd order applied only to the `Dof{}` term of the equation.

`JacNL`
  Jacobian term to be assembled in the Jacobian matrix for nonlinear analysis.

`NeverDt`
  No time scheme applied to the term (e.g., Theta is always 1 even if a theta scheme is applied).

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 4.8 Types for `Resolution`

resolution-op:

`Generate`
  `[system-id]`

  Generate the system of equations system-id.

`Solve`
  `[system-id]`

  Solve the system of equations system-id.

`GenerateJac`
  `[system-id]`

  Generate the system of equations system-id using a jacobian matrix (of which the unknowns are corrections dx of the current solution x).

`SolveJac`
  `[system-id]`

  Solve the system of equations system-id using a jacobian matrix (of which the unknowns are corrections dx of the current solution x). Then, Increment the solution (x=x+dx) and compute the relative error dx/x.

`GenerateSeparate`
  `[system-id]`

  Generate iteration matrices separately for system system-id. It is destined to be used with `Update` in order to create more efficiently the actual system to solve (this is only useful in linear transient problems with one single excitation) or with `EigenSolve` in order to generate the matrices of a (generalized) eigenvalue problem.

`GenerateOnly`
  `[system-id, expression-cst-list]`

  Not documented yet.

`GenerateOnlyJac`
  `[system-id, expression-cst-list]`

  Not documented yet.

`Update`
  `[system-id, expression]`

  Update the system of equations system-id (built from iteration matrices generated separately with `GenerateSeparate`) with expression

`UpdateConstraint`
  `[system-id, group-id, constraint-type]`

  Not documented yet.

`InitSolution`
  `[system-id]`

  Initialize the solution of system-id to zero (default) or to the values given in a `Constraint` of `Init` type.

`SaveSolution`
  `[system-id]`

  Save the solution of the system of equations system-id.

`SaveSolutions`
  `[system-id]`

  Save all the solutions available for the system of equations system-id. This should be used with algorithms that generate more than one solution at once, e.g., `EigenSolve` or `FourierTransform`.

`TransferSolution`
  `[system-id]`

  Transfer the solution of system system-id, as an `Assign` constraint, to the system of equations defined with a `DestinationSystem` command. This is used with the `AssignFromResolution` constraint type (see section 4.3 Types for `Constraint`).

`TransferInitSolution`
  `[system-id]`

  Transfer the solution of system system-id, as an `Init` constraint, to the system of equations defined with a `DestinationSystem` command. This is used with the `InitFromResolution` constraint type (see section 4.3 Types for `Constraint`).

`Evaluate`
  `[expression]`

  Evaluate expression.

`SetTime`
  `[expression]`

  Change the current time.

`SetFrequency`
  `[system-id, expression]`

  Change the frequency of system system-id.

`SystemCommand`
  `[expression-char]`

  Execute the system command given by expression-char.

`If`
  `[expression] { resolution-op }`

  If expression is true (nonzero), perform the operations in resolution-op.

`If`
  `[expression] { resolution-op }`
`Else`
  `{ resolution-op }`

  If expression is true (nonzero), perform the operations in the first resolution-op, else perform the operations in the second resolution-op.

`Break`

  Not implemented yet.

`Print`
  `[ { expression-list }, < File expression-char > ]`

  Print the expressions listed in expression-list.

`Print`
  `[ system-id <, File expression-char > <, { expression-cst-list } >`
  `<, TimeStep { expression-cst-list } >]`

  Print the system system-id. If the expression-cst-list is given, print only the values of the degrees of freedom given in that list. If the `TimeStep` option is present, limit the printing to the selected time steps.

`EigenSolve`
  `[system-id, expression-cst, expression-cst, expression-cst]`

  Eigenvalue/eigenvector computation using Arpack. The parameters are: the system (which has to be generated with `GenerateSeparate[]`), the number of eigenvalues/eigenvectors to compute and the real and imaginary spectral shift (around which to look for eigenvalues).

`Lanczos`
  `[system-id, expression-cst, { expression-cst-list } , expression-cst]`

  Eigenvalue/eigenvector computation using the Lanczos algorithm. The parameters are: the system (which has to be generated with `GenerateSeparate[]`), the size of the Lanczos space, the indices of the eigenvalues/eigenvectors to store, the spectral shift. This routine is deprecated: use `EigenSolve` instead.

`FourierTransform`
  `[system-id, system-id, { expression-cst-list }]`

  On-the-fly computation of a discrete Fourier transform. The parameters are: the (time domain) system, the destination system in which the result of the Fourier tranform is to be saved (it should be declared with `Type Complex`), the list of frequencies to consider in the discrete Fourier transform.

`TimeLoopTheta`
  `[expression-cst,expression-cst,expression,expression-cst]` `{ resolution-op }`

  Time loop of a theta scheme. The parameters are: the initial time, the end time, the time step and the theta parameter (e.g., 1 for implicit Euler, 0.5 for Crank-Nicholson).

`TimeLoopNewmark`
  `[expression-cst,expression-cst,expression,expression-cst,expression-cst]`
  { resolution-op }

  Time loop of a Newmark scheme. The parameters are: the initial time, the end time, the time step, the beta and the gamma parameter.

`IterativeLoop`
  `[expression-cst,expression,expression-cst<,expression-cst>]` { resolution-op }

  Iterative loop for nonlinear analysis. The parameters are: the maximum number of iterations (if no convergence), the relaxation factor (multiplies the iterative correction dx) and the relative error to achieve. The optional parameter is a flag for testing purposes.

`PostOperation`
  `[post-operation-id]`

  Perform the specified `PostOperation`.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 4.9 Types for `PostProcessing`

post-value:

`Local`
  { local-value }

  To compute a local quantity.

`Integral`
  { integral-value }

  To integrate the expression over each element.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 4.10 Types for `PostOperation`

print-support:

`OnElementsOf`
  group-def

  To compute a quantity on the elements belonging to the region group-def, where the solution was computed during the processing stage.

`OnRegion`
  group-def

  To compute a global quantity associated with the region group-def.

`OnGlobal`
  To compute a global integral quantity, with no associated region.

`OnSection`
  { { expression-cst-list } { expression-cst-list } { expression-cst-list } }

  To compute a quantity on a section of the mesh defined by three points (i.e., on the intersection of the mesh with a cutting a plane, specified by three points). Each expression-cst-list must contain exactly three elements (the coordinates of the points).

`OnGrid`
  group-def

  To compute a quantity in elements of a mesh which differs from the real support of the solution. `OnGrid group-def` differs from `OnElementsOf group-def` by the reinterpolation that must be performed.

`OnGrid`
  `{ expression, expression, expression }`
  `{ expression-cst-list-item | { expression-cst-list } ,`
  `expression-cst-list-item | { expression-cst-list } ,`
  `expression-cst-list-item | { expression-cst-list } }`

  To compute a quantity on a parametric grid. The three expressions represent the three cartesian coordinates x, y and z, and can be functions of the current values `$A`, `$B` and `$C`. The values for `$A`, `$B` and `$C` are specified by each expression-cst-list-item or expression-cst-list. For example, `OnGrid {Cos[$A], Sin[$A], 0} { 0:2*Pi:Pi/180, 0, 0 }` will compute the quantity on 360 points equally distributed on a circle in the z=0 plane, and centered on the origin.

`OnPoint`
  { expression-cst-list }

  To compute a quantity at a point. The expression-cst-list must contain exactly three elements (the coordinates of the point).

`OnLine`
  { { expression-cst-list } { expression-cst-list } } { expression-cst }

  To compute a quantity along a line (given by its two end points), with an associated number of divisions equal to expression-cst. The interpolation points on the line are equidistant. Each expression-cst-list must contain exactly three elements (the coordinates of the points).

`OnPlane`
  { { expression-cst-list } { expression-cst-list } { expression-cst-list } }
  `{ expression-cst, expression-cst }`

  To compute a quantity on a plane (specified by three points), with an associated number of divisions equal to each expression-cst along both generating directions. Each expression-cst-list must contain exactly three elements (the coordinates of the points).

`OnBox`
  { { expression-cst-list } { expression-cst-list } { expression-cst-list }
  `{ expression-cst-list } } { expression-cst, expression-cst, expression-cst }`

  To compute a quantity in a box (specified by four points), with an associated number of divisions equal to each expression-cst along the three generating directions. Each expression-cst-list must contain exactly three elements (the coordinates of the points).

print-option:

`File`
  `expression-char`

  Outputs the result in a file named expression-char.

`File`
  `> expression-char`

  Same as `File expression-char`, except that, if several `File > expression-char` options appear in the same `PostOperation`, the results are concatenated in the file expression-char.

`File`
  `>> expression-char`

  Appends the result to a file named expression-char.

`Depth`
  expression-cst

  Recursive division of the elements if expression-cst is greater than zero, derefinement if expression-cst is smaller than zero. If expression-cst is equal to zero, evaluation at the barycenter of the elements.

`Skin`
  Computes the result on the boundary of the region.

`Smoothing`
  Smoothes the solution at the nodes.

`HarmonicToTime`
  expression-cst

  Converts a harmonic solution into a time-dependent one (with expression-cst steps).

`Dimension`
  expression-cst

  Forces the dimension of the elements to consider in an element search. Specifies the problem dimension during an adaptation (h- or p-refinement).

`TimeStep`
  `expression-cst-list-item | { expression-cst-list }`

  Outputs results for the specified time steps only.

`LastTimeStepOnly`

  Outputs results for the last time step only (useful when calling a `PostOperation` directly in a `Resolution`, for example).

`Frequency`
  `expression-cst-list-item | { expression-cst-list }`

  Outputs results for the specified frequencies only.

`Format`
  post-operation-fmt

  Outputs results in the specified format.

`Adapt`
  `P1 | H1 | H2`

  Performs p- or h-refinement on the post-processing result, considered as an error map.

`Target`
  expression-cst

  Specifies the target for the optimizer during adaptation (error for `P1|H1`, number of elements for `H2`).

`Value`
  `expression-cst-list-item | { expression-cst-list }`

  Specifies acceptable output values for discrete optimization (e.g. the available interpolation orders with `Adapt P1`).

`Sort`
  `Position | Connection`

  Sorts the output by position (x, y, z) or by connection (for `LINE` elements only).

`Iso`
  expression-cst

  Outputs directly contour prints (with expression-cst values) instead of elementary values.

`Iso`
  `{ expression-cst-list }`

  Outputs directly contour prints for the values specified in the expression-cst-list instead of elementary values.

`NoNewLine`
  Suppresses the new lines in the output when printing global quantities (i.e., with `Print OnRegion` or `Print OnGlobal`).

`ChangeOfCoordinates`
  `{ expression, expression, expression }`

  Changes the coordinates of the results according to the three expressions given in argument. The three expressions represent the three new cartesian coordinates x, y and z, and can be functions of the current values of the cartesian coordinates `$X`, `$Y` and `$Z`.

`ChangeOfValues`
  `{ expression-list }`

  Changes the values of the results according to the expressions given in argument. The expressions represent the new values (x-compoment, y-component, etc.), and can be functions of the current values of the solution ($Val0, $Val1, etc.).

`DecomposeInSimplex`

  Decomposes all output elements in simplices (points, lines, triangles or tetrahedra).

`Store`
  `expression-cst`

  Stores the result of an `OnRegion` post-processing operation in the register expression-cst.

`TimeLegend`
  `< { expression, expression, expression } >`

  Includes a time legend in Gmsh plots. If the three optional expressions giving the position of the legend are not specified, the legend is centered on top of the plot.

`FrequencyLegend`
  `< { expression, expression, expression } >`

  Includes a frequency legend in Gmsh plots. If the three optional expressions giving the position of the legend are not specified, the legend is centered on top of the plot.

`EigenvalueLegend`
  `< { expression, expression, expression } >`

  Includes an eigenvalue legend in Gmsh plots. If the three optional expressions giving the position of the legend are not specified, the legend is centered on top of the plot.

post-operation-fmt:

`Gmsh`
`GmshParsed`
  Gmsh output. See the documentation of Gmsh (http://www.geuz.org/gmsh/) for a description of the file formats.

`Table`
  Space oriented column output, e.g., suitable for Gnuplot, Excel, Caleida Graph, etc. The columns are: element-type element-index x-coord y-coord z-coord <x-coord y-coord z-coord> ... real real real values. The three real numbers preceding the values contain context-dependent information, depending on the type of plot: curvilinear abscissa for `OnLine` plots, normal to the plane for `OnPlane` plots, parametric coordinates for parametric `OnGrid` plots, etc.

`TimeTable`
  Time oriented column output, e.g., suitable for Gnuplot, Excel, Caleida Graph, etc. The columns are: time-step time x-coord y-coord z-coord <x-coord y-coord z-coord> ... value.

`Gnuplot`
  Space oriented column output similar to the `Table` format, except that a new line is created for each node of each element, with a repetition of the first node if the number of nodes in the element is greater than 2. This permits to draw unstructured meshes and nice three-dimensional elevation plots in Gnuplot. The columns are: element-type element-index x-coord y-coord z-coord real real real values. The three real numbers preceding the values contain context-dependent information, depending on the type of plot: curvilinear abscissa for `OnLine` plots, normal to the plane for `OnPlane` plots, parametric coordinates for parametric `OnGrid` plots, etc.

`Adaptation`
  Adaptation map, suitable for the GetDP `-adapt` command line option.

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

Back to geuz.org/getdp