getdp.texi

cfd求解器使用与gmsh网格的求解

@noindent with

@example
@var{built-in-function-id}:
  @var{math-function-id} |
  @var{extended-math-function-id} |
  @var{green-function-id} |
  @var{type-function-id} |
  @var{coord-function-id} |
  @var{misc-function-id}
@end example

@noindent Notes:
@enumerate
@item
All possible values for @var{built-in-function-id} are listed in
@ref{Types for Function}.  
@item 
Classical mathematical functions (@pxref{Math functions}) are
the only functions allowed in a constant definition (see the definition of
@var{expression-cst} in @ref{Constants}).
@end enumerate


@c -------------------------------------------------------------------------
@c Current Values
@c -------------------------------------------------------------------------

@node Current values, Arguments, Functions, Expressions
@section Current values

@cindex Current values
@cindex Values, current

@tindex $Time
@tindex $DTime
@tindex $Theta
@tindex $TimeStep
@tindex $Iteration
@tindex $EigenvalueReal
@tindex $EigenvalueImag
@tindex $X
@tindex $XS
@tindex $Y
@tindex $YS
@tindex $Z
@tindex $ZS
@tindex $A
@tindex $B
@tindex $C

Current values are a special kind of arguments (@pxref{Arguments}) which
return the current integer or floating point value of an internal GetDP
variable:

@table @code
@item $Time
Value of the current time. This value is set to zero for non time dependent 
analyses.
@item $DTime
Value of the current time increment used in a time stepping algorithm.
@item $Theta
Current theta value in a theta time stepping algorithm.
@item $TimeStep
Number of the current time step in a time stepping algorithm.
@item $Iteration
Number of the current iteration in a nonlinear loop.
@item $EigenvalueReal
Real part of the current eigenvalue.
@item $EigenvalueImag
Imaginary part of the current eigenvalue.
@item $X, $XS
Value of the current (destination or source) X-coordinate.
@item $Y, $YS
Value of the current (destination or source) Y-coordinate.
@item $Z, $ZS
Value of the current (destination or source) Z-coordinate.
@item $A, $B, $C
Value of the current parametric coordinates used in the parametric
@code{OnGrid} @code{PostOperation} (@pxref{Types for PostOperation}).
@end table

@noindent Note:
@enumerate
@item
The current X, Y and Z coordinates refer to the `physical world'
coordinates, i.e., coordinates in which the mesh is expressed.
@end enumerate


@c -------------------------------------------------------------------------
@c Arguments
@c -------------------------------------------------------------------------

@node Arguments, Registers, Current values, Expressions
@section Arguments

@cindex Arguments, definition

@vindex @var{argument}

@tindex $@var{integer}

Function arguments can be used in expressions and have the following
syntax (@var{integer} indicates the position of the argument in the
@var{expression-list} of the function, starting from 1):

@example
@var{argument}:
  $@var{integer}
@end example

See @ref{Function}, and @ref{Function examples}, for more details.


@c -------------------------------------------------------------------------
@c Registers
@c -------------------------------------------------------------------------

@node Registers, Fields, Arguments, Expressions
@section Registers

@cindex Registers, definition

@vindex @var{register-value-set}
@vindex @var{register-value-get}

@tindex #@var{integer}

In many situations, identical parts of expressions are used more than
once. If this is not a problem with constant expressions (since
@var{expression-cst}s are evaluated only once during the analysis of the
problem definition structure, cf.@: @ref{Constants}), it may introduce some
important overhead while evaluating complex @var{expression}s (which are
evaluated at runtime, thanks to an internal stack mechanism). In order to
circumvent this problem, the evaluation result of any part of an
@var{expression} can be saved in a register: a memory location where this
partial result will be accessible without any costly reevaluation of the
partial expression.

Registers have the following syntax: 
@example
@var{register-value-set}:
  @var{expression}#@var{integer}

@var{register-value-get}:
  #@var{integer}
@end example

@noindent Thus, to store any part of an expression in the register 5, one
should add @code{#5} directly after the expression. To reuse the value
stored in this register, one simply uses @code{#5} instead of the expression
it should replace.

See @ref{Function examples}, for an example.


@c -------------------------------------------------------------------------
@c Fields
@c -------------------------------------------------------------------------

@node Fields, Loops and conditionals, Registers, Expressions
@section Fields

@cindex Fields
@cindex Operators, differential
@cindex Differential operators
@cindex Discrete quantities
@cindex Quantities, discrete
@cindex Interpolation
@cindex Gradient
@cindex Curl
@cindex Divergence
@cindex Exterior derivative
@cindex Derivative, exterior

@vindex @var{quantity}
@vindex @var{quantity-id}
@vindex @var{quantity-dof}
@vindex @var{quantity-operator}

A discretized quantity (defined in a function space, cf.@:
@ref{FunctionSpace}) is represented between braces @code{@{@}}, and can only
appear in well-defined expressions in @code{Formulation}
(@pxref{Formulation}) and @code{PostProcessing} (@pxref{PostProcessing})
objects:

@example
@var{quantity}:
  < @var{quantity-dof} > @{ < @var{quantity-operator} > @var{quantity-id} @} |
  @{ < @var{quantity-operator} > @var{quantity-id} @} [ @var{expression-cst-list} ]
@end example

@noindent with 

@example
@var{quantity-id}:
  @var{string} |
  @var{string} ~ @{ @var{expression-cst} @}
@end example

@noindent and

@noindent
@var{quantity-dof}:
@ftable @code

@item Dof
Defines a vector of discrete quantities (vector of @code{D}egrees @code{o}f
@code{f}reedom), to be used only in @code{Equation} terms of formulations to
define (elementary) matrices.  Roughly said, the @code{Dof} symbol in front
of a discrete quantity indicates that this quantity is an unknown quantity,
and should therefore not be considered as already computed.

@item BF
Indicates that only a basis function will be used (only valid with basis
functions associated with regions).

@end ftable

@noindent
@var{quantity-operator}:
@ftable @code

@item d
Exterior derivative (d): applied to a @var{p}-form, gives a (@var{p+1})-form.

@item Grad
Gradient: applied to a scalar field, gives a vector.

@item Curl
@itemx Rot
Curl: applied to a vector field, gives a vector.

@item Div
Divergence (div): applied to a vector field, gives a scalar.

@item dInv
d^(-1): applied to a p-form, gives a (p-1)-form.

@item GradInv
Inverse grad: applied to a gradient field, gives a scalar.

@item CurlInv
@itemx RotInv
Inverse curl: applied to a curl field, gives a vector.

@item DivInv
Inverse div: applied to a divergence field.

@end ftable

@noindent Notes:
@enumerate
@item
While the operators @code{Grad}, @code{Curl} and @code{Div} can be applied
to 0, 1 and 2-forms respectively, the exterior derivative operator @code{d}
is usually preferred with such fields.
@item
The second case permits to evaluate a discretized quantity at a certain
position X, Y, Z (when @var{expression-cst-list} contains three items) or at
a specific time, N time steps ago (when @var{expression-cst-list} contains a
single item).
@end enumerate

@c -------------------------------------------------------------------------
@c Loops and conditionals
@c -------------------------------------------------------------------------

@node Loops and conditionals,  , Fields, Expressions
@section Loops and conditionals

@cindex Loops
@cindex Conditionals

@vindex @var{loop}

Loops and conditionals are defined as follows, and can be imbricated:

@var{loop}:

@ftable @code
@item For ( @var{expression-cst} : @var{expression-cst} )
Iterates from the value of the first @var{expression-cst} to the value of
the second @var{expression-cst}, with a unit incrementation step. At each
iteration, the commands comprised between `@code{For ( @var{expression-cst}
: @var{expression-cst} )}' and the matching @code{EndFor} are executed.

@item For ( @var{expression-cst} : @var{expression-cst} : @var{expression-cst} )
Iterates from the value of the first @var{expression-cst} to the value of the
second @var{expression-cst}, with a positive or negative incrementation step
equal to the third @var{expression-cst}. At each iteration, the commands
comprised between `@code{For ( @var{expression-cst} : @var{expression-cst} :
@var{expression-cst} )}' and the matching @code{EndFor} are executed.

@item For @var{string} In @{ @var{expression-cst} : @var{expression-cst} @}
Iterates from the value of the first @var{expression-cst} to the value of the
second @var{expression-cst}, with a unit incrementation step. At each iteration,
the value of the iterate is affected to an expression named @var{string},
and the commands comprised between `@code{For @var{string} In @{
@var{expression-cst} : @var{expression-cst} @}}' and the matching @code{EndFor} are
executed.

@item For @var{string} In @{ @var{expression-cst} : @var{expression-cst} : @var{expression-cst} @}
Iterates from the value of the first @var{expression-cst} to the value of the
second @var{expression-cst}, with a positive or negative incrementation step
equal to the third @var{expression-cst}. At each iteration, the value of the
iterate is affected to an expression named @var{string}, and the commands
comprised between `@code{For @var{string} In @{ @var{expression-cst} :
@var{expression-cst} : @var{expression-cst} @}}' and the matching @code{EndFor} are
executed.

@item EndFor
Ends a matching @code{For} command.

@item If ( @var{expression-cst} )
The body enclosed between `@code{If ( @var{expression-cst} )}' and the matching
@code{Endif} is evaluated if @var{expression-cst} is non-zero.

@item EndIf
Ends a matching @code{If} command.
@end ftable

Loops and conditionals can be used in any of the following objects: Group,
Function, Constraint (as well as in a contraint-case), FunctionSpace,
Formulation (as well as in the quantity and equation defintions), Resolution
(as well as resolution-term, system defintion and operations),
PostProcessing (in the definition of the PostQuantities) and PostOperation
(as well as in the operation list).

@c =========================================================================
@c Objects
@c =========================================================================

@node Objects, Types for objects, Expressions, Top
@chapter Objects

@cindex Objects, definition

This chapter presents the formal definition of the ten GetDP objects
mentioned in @ref{Overview}. To be concise, all the possible parameters for
these objects are not given here (cf.@: the @var{etc} syntactic rule defined
in @ref{Syntactic rules}). Please refer to @ref{Types for objects}, for
the list of all available options.

@menu
* Group::                       
* Function::                    
* Constraint::                  
* FunctionSpace::               
* Jacobian::                    
* Integration::                 
* Formulation::                 
* Resolution::                  
* PostProcessing::              
* PostOperation::               
@end menu


@c -------------------------------------------------------------------------
@c Group
@c -------------------------------------------------------------------------

@node Group, Function, Objects, Objects
@section @code{Group}: defining topological entities

@cindex Mesh
@cindex Grid
@cindex Discretized Geometry
@cindex Group, definition
@cindex Topology
@cindex Entities, topological
@cindex Region groups
@cindex Function groups
@cindex Tree

@tindex Group
@tindex DefineGroup
@tindex =

@vindex @var{group-id}
@vindex @var{group-def}
@vindex @var{group-type}
@vindex @var{group-list}
@vindex @var{group-list-item}
@vindex @var{group-sub-type}

Meshes (grids) constitute the input data of GetDP. All that is needed by