Notation

The notation is used to explain:

  • typical symbols in equations and formulas (e.g., q)

  • common types used as parameters in items (e.g., PInt)

  • typical annotation of equations (or parts of it) and symbols (e.g., ODE2)

Common types

Common types are especially used in the definition of items. These types indicate how they need to be set (e.g., a Vector3D is set as a list of 3 floats or as a numpy array with 3 floats), and they usually include some range or size check (e.g., PReal is checked for being positive and non-zero):

  • float a single-precision floating point number (note: in Python, ‘float‘ is used also for double precision numbers; in EXUDYN, internally floats are single precision numbers especially for graphics objects and OpenGL)

  • Real a double-precision floating point number (note: in Python this is also of type ‘float‘)

  • UReal same as Real, but may not be negative

  • PReal same as Real, but must be positive, non-zero (e.g., step size may never be zero)

  • Index deprecated, represents unsined integer, UInt

  • Int a (signed) integer number, which converts to ‘int‘ in Python, ‘int‘ in C++

  • UInt an unsigned integer number, which converts to ‘int‘ in Python

  • PInt an positive integer number (> 0), which converts to ‘int‘ in Python

  • NodeIndex, MarkerIndex, ... a special (non-negative) integer type to represent indices of nodes, markers, …; specifically, an unintentional conversion from one index type to the other is not possible (e.g., to convert NodeIndex to MarkerIndex); see Section Item index

  • String a string

  • ArrayIndex a list of integer numbers (either list or in some cases numpy arrays may be allowed)

  • ArrayNodeIndex a list of node indices

  • Bool a boolean parameter: either True or False (’bool‘ in Python)

  • VObjectMassPoint, VObjectRigidBody, VObjectGround, etc. represents the visualization object of the underlying object; ‘V’ is put in front of object name

  • BodyGraphicsData see Section GraphicsData

  • Vector2D a list or numpy array of 2 real numbers

  • Vector3D a list or numpy array of 3 real numbers

  • Vector'X'D a list or numpy array of ‘X’ real numbers

  • Float4 a list of 4 float numbers

  • Vector a list or numpy array of real numbers (length given by according object)

  • NumpyVector a 1D numpy array with real numbers (size given by according object); similar as Vector, but not accepting list

  • Matrix3D a list of lists or numpy array with 3×3 real numbers

  • Matrix6D a list of lists or numpy array with 6×6 real numbers

  • NumpyMatrix a 2D numpy array (matrix) with real numbers (size given by according object)

  • NumpyMatrixI a 2D numpy array (matrix) with integer numbers (size given by according object)

  • MatrixContainer a versatile representation for dense and sparse matrices, see Section MatrixContainer

  • PyFunctionGraphicsData a user function providing GraphicsData, see the user function description of the according object

  • PyFunctionMbsScalar... a user function for the according object; the name is chosen according to the interface (arguments containing scalars, vectors, etc.) and is only used internally for code generation; see the according user function description

Note that for integers, there is also the exu.InvalidIndex() which is used to uniquely mark invalid indices, e.g., for default values of node numbers in objects or for other functions, often marked as invalid (-1) in the documentation. Currently, the invalid index is set to -1, but it may change in the future!

States and coordinate attributes

The following subscripts are used to define configurations of a quantity, e.g., for a vector of displacement coordinates q:

  • qconfig q in any configuration

  • qref q in reference configuration, e.g., reference coordinates: cref

  • qini q in initial configuration, e.g., initial displacements: uini

  • qcur q in current configuration

  • qvis q in visualization configuration

  • qstartofstep q in start of step configuration

As written in the introduction, the coordinates are attributed to certain types of equations and therefore, the following attributes are used (usually as subscript, e.g., qODE2):

  • ODE2, ODE1, AE, Data : These attributes refer to these types of equations or coordinates (click to see explanation)

Time is usually defined as ‘time’ or t. The cross product or vector product ‘ב is often replaced by the skew symmetric matrix using the tilde ‘~‘ symbol,

a×b=a~b=b~a,

in which ~ transforms a vector a into a skew-symmetric matrix a~. If the components of a are defined as a=[a0,a1,a2]T, then the skew-symmetric matrix reads

a~=[0a2a1a20a0a1a00].

The inverse operation is denoted as vec, resulting in vec(a~)=a.

For the length of a vector we often use the abbreviation

(1)a=aTa.

A vector a=[x,y,z]T can be transformed into a diagonal matrix, e.g.,

A=diag(a)=[x000y000z]

Symbols in item equations

The following tables contains the common notation General coordinates are:

python name (or description)
symbol
description
displacement coordinates (ODE2)
q=[q0,,qn]T
vector of n displacement based coordinates in any configuration; used for second order differential equations
rotation coordinates (ODE2)
ψ=[ψ0,,ψη]T
vector of η rotation based coordinates in any configuration; these coordinates are added to reference rotation parameters to provide the current rotation parameters; used for second order differential equations
coordinates (ODE1)
y=[y0,,yn]T
vector of n coordinates for first order ordinary differential equations (ODE1) in any configuration
algebraic coordinates
z=[z0,,zm]T
vector of m algebraic coordinates if not Lagrange multipliers in any configuration
Lagrange multipliers
λ=[λ0,,λm]T
vector of m Lagrange multipliers (=algebraic coordinates) in any configuration
data coordinates
x=[x0,,xl]T
vector of l data coordinates in any configuration

The following parameters represent possible OutputVariable (list is not complete):

python name
symbol
description
Coordinate
c=[c0,,cn]T
coordinate vector with n generalized coordinates ci in any configuration; the letter c is used both for ODE1 and ODE2 coordinates
Coordinate_t
c˙=[c0,,cn]T
time derivative of coordinate vector
Displacement
u0=[u0,u1,u2]T
global displacement vector with 3 displacement coordinates ui in any configuration; in 1D or 2D objects, some of there coordinates may be zero
Rotation
[φ0,φ1,φ2]Tconfig
vector with 3 components of the Euler angles in xyz-sequence (A0bconfig=:A0(φ0)A1(φ1)A2(φ2)), recomputed from rotation matrix
Rotation (alt.)
θ=[θ0,,θn]T
vector of rotation parameters (e.g., Euler parameters, Tait Bryan angles, …) with n coordinates θi in any configuration
Identity matrix
I=[10000001]
the identity matrix, very often I=I3×3, the 3×3 identity matrix
Identity transformation
I3×30b=I3×3
converts body-fixed into global coordinates, e.g., x0=I3×30bxb, thus resulting in x0=xb in this case
RotationMatrix
A0b=[A00A01A02A10A11A12A20A21A22]
a 3D rotation matrix, which transforms local (e.g., body b) to global coordinates (0): x0=A0bxb
RotationMatrixX
A0(θ0)01=[1000cos(θ0)sin(θ0)0sin(θ0)cos(θ0)]
rotation matrix for rotation around X axis (axis 0), transforming a vector from frame 1 to frame 0
RotationMatrixY
A1(θ1)01=[cos(θ1)0sin(θ1)010sin(θ1)0cos(θ1)]
rotation matrix for rotation around Y axis (axis 1), transforming a vector from frame 1 to frame 0
RotationMatrixZ
A2(θ2)01=[cos(θ2)sin(θ2)0sin(θ2)cos(θ2)0001]
rotation matrix for rotation around Z axis (axis 2), transforming a vector from frame 1 to frame 0
Position
p0=[p0,p1,p2]T
global position vector with 3 position coordinates pi in any configuration
Velocity
v0=u˙0=[v0,v1,v2]T
global velocity vector with 3 displacement coordinates vi in any configuration
AngularVelocity
ω0=[ω0,,ω2]T
global angular velocity vector with 3 coordinates ωi in any configuration
Acceleration
a0=u¨0=[a0,a1,a2]T
global acceleration vector with 3 displacement coordinates ai in any configuration
AngularAcceleration
α0=ω˙0=[α0,,α2]T
global angular acceleration vector with 3 coordinates αi in any configuration
VelocityLocal
vb=[v0,v1,v2]T
local (body-fixed) velocity vector with 3 displacement coordinates vi in any configuration
AngularVelocityLocal
ωb=[ω0,,ω2]T
local (body-fixed) angular velocity vector with 3 coordinates ωi in any configuration
Force
f0=[f0,,f2]T
vector of 3 force components in global coordinates
Torque
τ0=[τ0,,τ2]T
vector of 3 torque components in global coordinates

The following table collects some typical input parameters for nodes, objects and markers:

python name
symbol
description
referenceCoordinates
cref=[c0,,cn]refT=[cRef,0,,cRef,n]refT
n coordinates of reference configuration (can usually be set at initialization of nodes)
initialCoordinates
cini
initial coordinates with generalized or mixed displacement/rotation quantities (can usually be set at initialization of nodes)
reference point
0r=[r0,r1,r2]T
reference point of body, e.g., for rigid bodies or FFRF bodies, in any configuration; NOTE: for ANCF elements, 0r is used for the position vector to the beam centerline
localPosition
bv=[b0b,b1b,b2b]T
local (body-fixed) position vector with 3 position coordinates bi in any configuration, measured relative to reference point; NOTE: for rigid bodies, p0=0r+A0bbv; localPosition is used for definition of body-fixed local position of markers, sensors, COM, etc.