GetDP API reference

GetDPObject

Base GetDP object that other objects inherit from.

CaseItem_

A case item in a GetDP object.

Case_

A case in a GetDP object.

Constraint

Defining constraints.

Formulation

Building equations.

Function

Defining functions.

Group

Defining topological entities.

ObjectItem

An object item in a GetDP object.

PostOperation

Defining post-operations.

PostProcessing

Defining post-processing.

Problem

The main problem definition class that brings together all the components.

Resolution

Defining how to solve the problem.

SimpleItem

A simple item in a GetDP object.

Abs(expression)

Generate the GetDP string representation for the absolute value/modulus function Abs[...]. (Works for complex numbers).

Acos(expression)

Generate the GetDP string representation for the arc cosine function Acos[...]. Domain: expression in [-1, 1]. Range: [0, Pi]. (Real valued only).

Asin(expression)

Generate the GetDP string representation for the arc sine function Asin[...]. Domain: expression in [-1, 1]. Range: [-Pi/2, Pi/2]. (Real valued only).

AtIndex(index_expr, list_expr::String)

Generate the GetDP string representation for accessing list element by index: AtIndex[index]{list}. list_expr is a comma-separated string list. Index is 0-based(? check GetDP docs).

Atan(expression)

Generate the GetDP string representation for the arc tangent function Atan[...]. Range: [-Pi/2, Pi/2]. (Real valued only).

Atan2(y, x)

Generate the GetDP string representation for the arc tangent function Atan2[y, x]. Computes atan(y/x). Range: [-Pi, Pi]. (Real valued only).

Ceil(expression)

Generate the GetDP string representation for the ceiling function Ceil[...]. Rounds upwards. (Real valued only).

CompElementNum()

Generate the GetDP string representation to compare current and source element tags: CompElementNum[]. Returns 0 if identical.

ComplexScalarField(expression, expression_cst_list; timestep=0, elmt_interp=true)

Generate GetDP string for evaluating complex scalar fields: ComplexScalarField[expr, ts, interp]{list}.

ComplexTensorField(expression, expression_cst_list; timestep=0, elmt_interp=true)

Generate GetDP string for evaluating complex tensor fields: ComplexTensorField[expr, ts, interp]{list}.

ComplexVectorField(expression, expression_cst_list; timestep=0, elmt_interp=true)

Generate GetDP string for evaluating complex vector fields: ComplexVectorField[expr, ts, interp]{list}.

Cos(expression)

Generate the GetDP string representation for the cosine function Cos[...].

Cos_wt_p(omega, phase)

Generate the GetDP string representation for the time function Cos_wt_p[]{omega, phase}. Real: Cos[omega*Time + phase]. Complex: Complex[Cos[phase], Sin[phase]].

Cosh(expression)

Generate the GetDP string representation for the hyperbolic cosine function Cosh[...].

Cross(vector1, vector2)

Generate the GetDP string representation for the cross product Cross[vector1, vector2]. Arguments must be vectors.

Det(expression)

Generate the GetDP string representation for the tensor determinant function Det[...]. Expression must be a tensor.

DualEdgesOf(group::Group, args...; kwargs...)

Dual edges of elements of R1.

DualFacetsOf(group::Group, args...; kwargs...)

Dual facets of elements of R1.

DualNodesOf(group::Group, args...; kwargs...)

Dual nodes of elements of R1.

DualVolumesOf(group::Group, args...; kwargs...)

Dual volumes of elements of R1.

EdgesOf(group::Group, args...; Not=nothing, kwargs...)

Edges of elements of R1 (Not: but not those of R2).

EdgesOfTreeIn(group::Group, args...; StartingOn=nothing, kwargs...)

Edges of a tree of edges of R1 < StartingOn: a complete tree is first built on R2 >.

ElementNum()

Generate the GetDP string representation for the current element's tag: ElementNum[].

ElementVol()

Generate the GetDP string representation for the element's volume (or area/length): ElementVol[].

ElementsOf(group::Group, args...; OnOneSideOf=nothing, OnPositiveSideOf=nothing, Not=nothing, kwargs...)

Elements of regions in R1.

• OnOneSideOf: only elements on one side of R2 (non-automatic, i.e., both sides if both in R1)
• OnPositiveSideOf: only elements on positive (normal) side of R2
• Not: but not those touching only its skin R3 (mandatory for free skins for correct separation of side layers)

Exp(expression)

Generate the GetDP string representation for the exponential function Exp[...]. Example: Exp("x") returns "Exp[x]".

Fabs(expression)

Generate the GetDP string representation for the absolute value function Fabs[...]. (Real valued only).

FacetsOf(group::Group, args...; Not=nothing, kwargs...)

Facets of elements of R1 (Not: but not those of R2).

FacetsOfTreeIn(group::Group, args...; StartingOn=nothing, kwargs...)

Facets of a tree of facets of R1 < StartingOn: a complete tree is first built on R2 >.

Field(eval_point_expr, tags_list_expr::String)

Generate the GetDP string representation for evaluating and summing specific Gmsh fields: Field[eval_point]{tags_list}. tags_list_expr is a comma-separated list of field tags.

Field(eval_point_expr)

Generate the GetDP string representation for evaluating the last Gmsh field: Field[eval_point]. Typically eval_point_expr is XYZ[].

Floor(expression)

Generate the GetDP string representation for the floor function Floor[...]. Rounds downwards. (Real valued only).

Fmod(x, y)

Generate the GetDP string representation for the floating-point remainder function Fmod[x, y]. Remainder of x/y with sign of x. (Real valued only).

GetCpuTime()

Generate GetDP string for getting CPU time: GetCpuTime[].

GetMemory()

Generate GetDP string for getting memory usage (MB): GetMemory[].

GetNumElements(list_expr::String="")

Generate the GetDP string representation for counting elements: GetNumElements[]{list}. list_expr is a comma-separated string of physical region tags, or empty for the current region.

GetNumberRunTime(name::String; default_value=nothing)

Generate GetDP string for getting a ONELAB variable at runtime: GetNumberRunTime["name"] or GetNumberRunTime["name"]{default}.

GetVariable(variable_id::String; default_value=nothing)

Generate GetDP string for getting a runtime variable: GetVariable[]{variable_id} or GetVariable[default]{variable_id}.

GetVolume()

Generate the GetDP string representation for the volume of the current physical group: GetVolume[].

GetWallClockTime()

Generate GetDP string for getting wall clock time: GetWallClockTime[].

Global(group::Group, args...; kwargs...)

Regions in R1 (variant of Region used with global BasisFunctions BFGlobal and BFdGlobal).

GroupOfRegionsOf(group::Group, args...; kwargs...)

Single group of elements of regions in R1 (with basis function BF_Region just one DOF is created for all elements of R1).

GroupsOfEdgesOf(group::Group, args...; InSupport=nothing, kwargs...)

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(group::Group, args...; Not=nothing, kwargs...)

Groups of edges incident to nodes of elements of R1 (a group is associated with each node). < Not: but not those of R2) >.

GroupsOfNodesOf(group::Group, args...; kwargs...)

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

Hypot(a, b)

Generate the GetDP string representation for the hypotenuse function Hypot[a, b]. Computes Sqrt(a^2 + b^2).

InterpolationAkima(x_expr, table_list_expr::String)

Generate the GetDP string representation for Akima interpolation: InterpolationAkima[x]{table}. table_list_expr is a comma-separated list of x,y pairs: "x1,y1,x2,y2,...".

InterpolationBilinear(x_expr, y_expr, table_list_expr::String)

Generate the GetDP string representation for bilinear interpolation: InterpolationBilinear[x, y]{table}. Table format needs checking in GetDP docs.

InterpolationLinear(x_expr, table_list_expr::String)

Generate the GetDP string representation for linear interpolation: InterpolationLinear[x]{table}. table_list_expr is a comma-separated list of x,y pairs: "x1,y1,x2,y2,...".

Inv(expression)

Generate the GetDP string representation for the inverse tensor function Inv[...]. Expression must be a tensor.

Jn(order, value)

Generate the GetDP string representation for the Bessel function of the first kind Jn[order, value]. (Real valued only).

Log(expression)

Generate the GetDP string representation for the natural logarithm function Log[...]. Example: Log("x") returns "Log[x]".

Log10(expression)

Generate the GetDP string representation for the base-10 logarithm function Log10[...]. Example: Log10("x") returns "Log10[x]".

Max(a, b)

Generate the GetDP string representation for the maximum function Max[a, b]. (Scalar, real valued only).

Min(a, b)

Generate the GetDP string representation for the minimum function Min[a, b]. (Scalar, real valued only).

NodesOf(group::Group, args...; Not=nothing, kwargs...)

Nodes of elements of R1 (Not: but not those of R2).

Norm(expression)

Generate the GetDP string representation for the norm function Norm[...]. Absolute value for scalar, Euclidean norm for vector.

Normal()

Generate the GetDP string representation for the element's normal vector: Normal[].

NormalSource()

Generate the GetDP string representation for the source element's normal vector: NormalSource[]. (Valid in Integral quantity).

Order(quantity_name)

Generate the GetDP string representation for getting interpolation order: Order[quantity].

Period(expression, period_const)

Generate the GetDP string representation for the periodic function Period[expr]{period_const}. Result is always in [0, period_const[.

Printf(expression)

Generate the GetDP string representation for printing a value during evaluation: Printf[expression].

QuadraturePointIndex()

Generate the GetDP string representation for the current quadrature point index: QuadraturePointIndex[].

Rand(max_val)

Generate the GetDP string representation for a pseudo-random number in [0, maxval]: `Rand[maxval]`.

Region(group::Group, args...; kwargs...)

Regions in R1.

Rotate(object, rot_x, rot_y, rot_z)

Generate the GetDP string representation for the rotation function Rotate[object, rx, ry, rz]. Rotates a vector or tensor object by angles rot_x, rot_y, rot_z (radians) around axes x, y, z.

ScalarField(expression, expression_cst_list; timestep=0, elmt_interp=true)

Generate GetDP string for evaluating scalar fields: ScalarField[expr, ts, interp]{list}.

SetNumberRunTime(value_expr, name::String)

Generate GetDP string for setting a ONELAB variable at runtime: SetNumberRunTime[value]{"name"}.

SetVariable(value_expr, variable_id::String)

Generate GetDP string for setting a runtime variable: SetVariable[value]{variable_id}.

Sign(expression)

Generate the GetDP string representation for the sign function Sign[...]. Returns -1 for expression < 0, 1 otherwise. (Real valued only).

Sin(expression)

Generate the GetDP string representation for the sine function Sin[...].

Sin_wt_p(omega, phase)

Generate the GetDP string representation for the time function Sin_wt_p[]{omega, phase}. Real: Sin[omega*Time + phase]. Complex: Complex[Sin[phase], -Cos[phase]].

Sinh(expression)

Generate the GetDP string representation for the hyperbolic sine function Sinh[...].

Sqrt(expression)

Generate the GetDP string representation for the square root function Sqrt[...]. Example: Sqrt("x") returns "Sqrt[x]".

SquNorm(expression)

Generate the GetDP string representation for the square norm function SquNorm[...]. Equivalent to Norm[expression]^2.

SurfaceArea(list_expr::String="")

Generate the GetDP string representation for surface area calculation: SurfaceArea[]{list}. list_expr is a comma-separated string of physical surface tags, or empty for the current surface.

TTrace(tensor)

Generate the GetDP string representation for the tensor trace function TTrace[...]. Expression must be a tensor.

Tan(expression)

Generate the GetDP string representation for the tangent function Tan[...].

Tangent()

Generate the GetDP string representation for the element's tangent vector: Tangent[]. (Valid for line elements).

TangentSource()

Generate the GetDP string representation for the source element's tangent vector: TangentSource[]. (Valid in Integral quantity, line elements).

Tanh(expression)

Generate the GetDP string representation for the hyperbolic tangent function Tanh[...]. (Real valued only).

TanhC2(expression)

Generate the GetDP string representation for the complex hyperbolic tangent function TanhC2[...].

TensorField(expression, expression_cst_list; timestep=0, elmt_interp=true)

Generate GetDP string for evaluating tensor fields: TensorField[expr, ts, interp]{list}.

Transpose(expression)

Generate the GetDP string representation for the transpose function Transpose[...]. Expression must be a tensor.

Unit(expression)

Generate the GetDP string representation for the unit vector function Unit[...]. Computes expression / Norm[expression]. Returns 0 if norm is near zero.

ValueFromIndex(list_expr::String)

Generate GetDP string for getting value from index map: ValueFromIndex[]{list}. List format: "entity1, value1, entity2, value2, ...".

ValueFromTable(default_expr, table_name::String)

Generate GetDP string for getting value from PostOperation table: ValueFromTable[default]{"table_name"}.

VectorField(expression, expression_cst_list; timestep=0, elmt_interp=true)

Generate GetDP string for evaluating vector fields: VectorField[expr, ts, interp]{list}.

VectorFromIndex(list_expr::String)

Generate GetDP string for getting vector from index map: VectorFromIndex[]{list}. List format: "entity1, v1x, v1y, v1z, entity2, v2x, ...".

VolumesOf(group::Group, args...; Not=nothing, kwargs...)

Volumes of elements of R1 (Not: but not those of R2).

Yn(order, value)

Generate the GetDP string representation for the Bessel function of the second kind Yn[order, value]. (Real valued only).

add!(group::Group, id="domain", glist=[1], gtype="Region"; operation="=", comment=nothing, kwargs...)

Add an expression to the Group object. The default group type is "Region". Use operation="=" to define a group or operation="+=" to extend an existing group.

add!(base::Base_, args...; kwargs...)

Add a SimpleItem to a Base_ object.

add!(case::Case_, args...; kwargs...)

Add a CaseItem_ to a Case_ object.

add!(constraint::Constraint, name; type="Assign", comment=nothing)

Add a constraint to the Constraint object. Returns the ConstraintItem for adding cases.

add!(formulation::Formulation, Name, Type; kwargs...)

Add a formulation item to a formulation.

add!(equation::Equation, term_type::String, term::String; kwargs...)

Add an equation term to an equation.

add!(func::Function, id, expression; comment=nothing)

Add a simple function to the Function object.

add!(func::Function, id; expression, arguments=String[], region=String[], comment=nothing)

Add a function to the Function object with optional region and arguments.

add!(obj::ObjectItem, args...; kwargs...)

Add a Case_ to an ObjectItem.

add!(postoperation::PostOperation, id, NameOfPostProcessing; kwargs...)

Add a post-operation item.

add!(postprocessing::PostProcessing, name::String, NameOfFormulation::String; kwargs...)

Add a post-processing item.

add!(resolution::Resolution, id, system_name; kwargs...)

Add a resolution with system and operation to the Resolution object.

add_akima!(func::Function, id, x, y; comment=nothing)

Add an Akima interpolation function to the Function object.

add_analytic!(func::Function, id, expression; comment=nothing)

Add an analytic function to the Function object.

add_comment!(obj::GetDPObject, comment_text, newline=true)

Add a comment to the object's content.

add_comment!(postoperation::PostOperation, comment_text, newline=true)

Add a comment to the PostOperation object.

add_comment!(func::Function, comment_text, newline=true)

Add a comment to the Function object.

add_comment!(formulation::Formulation, comment_text, newline=true)

Add a comment to the Formulation object.

add_comment!(resolution::Resolution, comment_text, newline=true)

Add a comment to the Resolution object.

add_comment!(constraint::Constraint, comment_text, newline=true)

Add a comment to the Constraint object.

add_comment!(postprocessing::PostProcessing, comment_text, newline=true)

Add a comment to the PostProcessing object.

add_comment!(problem::Problem, comment_text, newline=true)

Add a comment to the Problem object.

add_comment!(group::group, comment_text, newline=true)

Add a comment to the group object.

add_constant!(func::Function, variable, value; comment=nothing)

Add a global constant to the Function object.

add_equation!(item::FormulationItem, args...; kwargs...)

Add an equation to a formulation item.

add_file!(func::Function, id, filename; comment=nothing)

Add a function from a file to the Function object.

add_list!(func::Function, id, expression_list; comment=nothing)

Add a list of functions to the Function object.

add_piecewise!(func::Function, id, x, y; comment=nothing)

Add a piecewise function to the Function object.

add_quantity!(item::FormulationItem, name::String; kwargs...)

Add a quantity to a formulation item.

add_raw_code(s, raw_code, newline=true)

Add raw code to a string, optionally with a newline.

add_raw_code!(obj::GetDPObject, raw_code, newline=true)

Add raw code to the object's content.

add_raw_code!(postoperation::PostOperation, raw_code, newline=true)

Add raw code to the PostOperation object.

add_raw_code!(group::group, raw_code, newline=true)

Add raw code to the group object.

add_raw_code!(func::Function, raw_code, newline=true)

Add raw code to the Function object.

add_raw_code!(formulation::Formulation, raw_code, newline=true)

Add raw code to the Formulation object.

add_raw_code!(resolution::Resolution, raw_code, newline=true)

Add raw code to the Resolution object.

add_raw_code!(postprocessing::PostProcessing, raw_code, newline=true)

Add raw code to the PostProcessing object.

add_raw_code!(constraint::Constraint, raw_code, newline=true)

Add raw code to the Constraint object.

add_raw_code!(problem::Problem, raw_code, newline=true)

Add raw code to the Problem object.

add_raw_code!(poitem::PostOperationItem, raw_code)

Add raw code to a PostOperationItem.

add_space!(group::Group, num_spaces::Int=1)

Add a specified number of empty lines to the Group object's content for spacing in the output.

add_space!(function::Function, num_spaces::Int=1)

Add a specified number of empty lines to the function object's content for spacing in the output.

assign!(constraint::Constraint, name; comment=nothing)

Add an Assign-type constraint to the Constraint object (shortcut for add!). Returns the ConstraintItem for adding cases.

case!(item::ConstraintItem, region; value=nothing, time_function=nothing, comment=nothing)

Add a case to a ConstraintItem with specified region and parameters.

code(constraint::Constraint)

Generate GetDP code for a Constraint object.

code(formulation::Formulation)

Generate GetDP code for a Formulation object.

code(func::Function)

Generate GetDP code for a Function object.

code(obj::GetDPObject)

Generate GetDP code for the object.

code(group::Group)

Generate GetDP code for a Group object.

code(obj::ObjectItem)

Generate GetDP code for the object item.

code(postoperation::PostOperation)

Generate GetDP code for a PostOperation object.

code(postprocessing::PostProcessing)

Generate GetDP code for a PostProcessing object.

code(resolution::Resolution)

Generate GetDP code for a Resolution object.

comment(s, style="short", newline=false)

Add a comment to a string, optionally with a newline.

content(formulation::Formulation)

Get the content of a formulation.

dInterpolationAkima(x_expr, table_list_expr::String)

Generate the GetDP string representation for the derivative of Akima interpolation: dInterpolationAkima[x]{table}.

dInterpolationBilinear(x_expr, y_expr, table_list_expr::String)

Generate the GetDP string representation for the derivative of bilinear interpolation: dInterpolationBilinear[x, y]{table}. Result is a vector.

dInterpolationLinear(x_expr, table_list_expr::String)

Generate the GetDP string representation for the derivative of linear interpolation: dInterpolationLinear[x]{table}.

dJn(order, value)

Generate the GetDP string representation for the derivative of the Bessel function of the first kind dJn[order, value]. (Real valued only).

dYn(order, value)

Generate the GetDP string representation for the derivative of the Bessel function of the second kind dYn[order, value]. (Real valued only).

define!(group::Group, id="domain")

Define a group.

for_loop!(item::ConstraintItem, index, range)

Set a For loop for the ConstraintItem (e.g., For k In {1:3}).

get_code(problem::Problem)

Returns properly formatted GetDP code.

include!(problem::Problem, incl_file)

Include another GetDP file.

make_problem!(problem::Problem)

Generate the GetDP code for all objects in the Problem, including only non-empty components.

write_file(problem::Problem)

Write the GetDP code to a file.