ObjectFFRF
This object is used to represent equations modelled by the FFRF. It contains a RigidBodyNode (always node 0) and a list of other nodes representing the finite element nodes used in the FFRF. Note that temporary matrices and vectors are subject of change in future. NOTE: Usually you SHOULD NOT USE THIS OBJECT - use the much more efficient ObjectFFRFreducedOrder object with modal reduction instead.
Authors: Gerstmayr Johannes, Zwölfer Andreas
Interface
Body markers that can be placed on it: MarkerBodyMass, MarkerBodyPosition, MarkerBodyRigid, MarkerSuperElementPosition, MarkerSuperElementRigid
Nodes: see the detailed description
Parameters
The parameters of the item; in a dictionary, its type is ‘FFRF’:
name |
type |
size |
default |
description |
|---|---|---|---|---|
name |
String |
‘’ |
objects’s unique name |
|
nodeNumbers |
ArrayNodeIndex |
[] |
(symbol: \(\mathbf{n}\indf = [n_0,\,\ldots,\,n_{n_\mathrm{nf}}]\tp\)) node numbers which provide the coordinates for the object (consecutively as provided in this list); the \((n_\mathrm{nf}+1)\) nodes represent the nodes of the FE mesh (except for node 0); the global nodal position needs to be reconstructed from the rigid-body motion of the reference frame |
|
massMatrixFF |
PyMatrixContainer |
[] |
(symbol: \(\LU{b}{\Mm} \in \Rcal^{n\indf \times n\indf}\)) body-fixed and ONLY flexible coordinates part of mass matrix of object given in Python numpy format (sparse (CSR) or dense, converted to sparse matrix); internally data is stored in triplet format |
|
stiffnessMatrixFF |
PyMatrixContainer |
[] |
(symbol: \(\LU{b}{\Km} \in \Rcal^{n\indf \times n\indf}\)) body-fixed and ONLY flexible coordinates part of stiffness matrix of object in Python numpy format (sparse (CSR) or dense, converted to sparse matrix); internally data is stored in triplet format |
|
dampingMatrixFF |
PyMatrixContainer |
[] |
(symbol: \(\LU{b}{\Dm} \in \Rcal^{n\indf \times n\indf}\)) body-fixed and ONLY flexible coordinates part of damping matrix of object in Python numpy format (sparse (CSR) or dense, converted to sparse matrix); internally data is stored in triplet format |
|
forceVector |
NumpyVector |
[] |
(symbol: \(\LU{0}{\fv} = [\LU{0}{\fv\indr},\; \LU{0}{\fv\indf}]\tp \in \Rcal^{n_c}\)) generalized, force vector added to RHS; the rigid body part \(\fv_r\) is directly applied to rigid body coordinates while the flexible part \(\fv\indf\) is transformed from global to local coordinates; note that this force vector only allows to add gravity forces for bodies with COM at the origin of the reference frame |
|
forceUserFunction |
ObjectFFRFForceUserFunction |
0 |
(symbol: \(\fv_{user} = [\LU{0}{\fv_{\mathrm{r},user}},\; \LU{b}{\fv_{\mathrm{f},user}}]\tp \in \Rcal^{n_c}\)) A Python user function which computes the generalized user force vector for the ODE2 equations; note the different coordinate systems for rigid body and flexible part; The function args are mbs, time, objectNumber, coordinates q (without reference values) and coordinate velocities q_t; see description below |
|
massMatrixUserFunction |
ObjectFFRFMassMatrixUserFunction |
0 |
(symbol: \(\Mm_{user} \in \Rcal^{n_c\times n_c}\)) A Python user function which computes the TOTAL mass matrix (including reference node) and adds the local constant mass matrix; note the different coordinate systems as described in the FFRF mass matrix; see description below |
|
computeFFRFterms |
Bool |
True |
flag decides whether the standard FFRF terms are computed; use this flag for user-defined definition of FFRF terms in mass matrix and quadratic velocity vector |
|
coordinateIndexPerNode |
ArrayIndex |
[] |
this list contains the local coordinate index for every node, which is needed, e.g., for markers; the list is generated automatically every time parameters have been changed |
|
objectIsInitialized |
Bool |
False |
ALWAYS set to False! flag used to correctly initialize all FFRF matrices; as soon as this flag is False, internal (constant) FFRF matrices are recomputed during Assemble() |
|
mass |
UReal |
0. |
(symbol: \(m\)) total mass [SI:kg] of FFRF object, auto-computed from mass matrix \(\LU{b}{\Mm}\) |
|
inertia |
Matrix3D |
9 |
[[1,0,0], [0,1,0], [0,0,1]] |
(symbol: \(J_r \in \Rcal^{3 \times 3}\)) inertia tensor [SI:kgm\(^2\)] of rigid body w.r.t. to the reference point of the body, auto-computed from the mass matrix \(\LU{b}{\Mm}\) |
centerOfMass |
Vector3D |
3 |
[0.,0.,0.] |
(symbol: \(\LU{b}{\bv}_{COM}\)) local position of center of mass (COM); auto-computed from mass matrix \(\LU{b}{\Mm}\) |
PHItTM |
NumpyMatrix |
[] |
(symbol: \(\tPhi\indt\tp \in \Rcal^{n\indf \times 3}\)) projector matrix; may be removed in future |
|
referencePositions |
NumpyVector |
[] |
(symbol: \(\xv\cRef \in \Rcal^{n\indf}\)) vector containing the reference positions of all flexible nodes |
|
tempVector |
NumpyVector |
[] |
(symbol: \(\vv_{temp} \in \Rcal^{n\indf}\)) temporary vector |
|
tempCoordinates |
NumpyVector |
[] |
(symbol: \(\cv_{temp} \in \Rcal^{n\indf}\)) temporary vector containing coordinates |
|
tempCoordinates_t |
NumpyVector |
[] |
(symbol: \(\dot \cv_{temp} \in \Rcal^{n\indf}\)) temporary vector containing velocity coordinates |
|
tempRefPosSkew |
NumpyMatrix |
[] |
(symbol: \(\tilde\pv\indf \in \Rcal^{n\indf \times 3}\)) temporary matrix with skew symmetric local (deformed) node positions |
|
tempVelSkew |
NumpyMatrix |
[] |
(symbol: \(\dot{\tilde\cv}\indf \in \Rcal^{n\indf \times 3}\)) temporary matrix with skew symmetric local node velocities |
|
visualization |
VObjectFFRF |
parameters for visualization of item |
Visualization parameters
The parameters of VObjectFFRF, given as visualization:
name |
type |
size |
default |
description |
|---|---|---|---|---|
show |
Bool |
True |
set true, if item is shown in visualization and false if it is not shown; use visualizationSettings.bodies.deformationScaleFactor to draw scaled (local) deformations; the reference frame node is shown with additional letters RF |
|
color |
Float4 |
4 |
[-1.,-1.,-1.,-1.] |
RGBA color for object; 4th value is alpha-transparency; R=-1.f means, that default color is used |
triangleMesh |
NumpyMatrixI |
[] |
a matrix of node numbers referring to the mesh nodes of the object, one triangle per row: 3 columns for flat triangles, or 6 for 6-node triangles drawn curved - the corners counterclockwise seen from outside, then the mid nodes of the edges 0-1, 1-2 and 2-0, as in GraphicsData triangles6; the mesh uses the nodes to visualize the underlying object; contour plot colors are still computed in the local frame! |
|
showNodes |
Bool |
False |
set true, nodes are drawn uniquely via the mesh, eventually using the floating reference frame, even in the visualization of the node is show=False; node numbers are shown with indicator ‘NF’ |
Drawing
Drawn as all super elements; its triangleMesh on the nodes, deformed with bodies.deformationScaleFactor, and with showNodes its nodes.
Settings beyond those of all super elements: nodes.defaultSize, nodes.drawNodesAsPoint, nodes.show, nodes.showNumbers, nodes.tiling, openGL.advanced.initialMaxSceneSize.
Output variables
Available as OutputVariableType in sensors, Get...Output() and other functions:
output variable |
symbol |
description |
|---|---|---|
Coordinates |
all ODE2 coordinates |
|
Coordinates_t |
all ODE2 velocity coordinates |
|
Coordinates_tt |
all ODE2 acceleration coordinates |
|
Force |
generalized forces for all coordinates (residual of all forces except mass*accleration; corresponds to ComputeODE2LHS) |
|
KineticEnergy |
\(T = \frac{1}{2} \dot\qv\tp \Mm\, \dot\qv\) |
kinetic energy from the mass matrix of the current state and the velocities of the nodes; current configuration only; localPosition must be \([0,0,0]\) |
PotentialEnergy |
\(V = \frac{1}{2} \qv_\mathrm{f}\tp \Km_{\mathrm{ff}}\, \qv_\mathrm{f} - \fv\tp \qv\) |
elastic energy of the flexible coordinates and the potential of the constant force vector; raises for a forceUserFunction; localPosition must be \([0,0,0]\) |
Detailed description
Additional output variables for superelement node access
Functions like GetObjectOutputSuperElement(...), see MainSystem: Object,
or SensorSuperElement, see MainSystem: Sensor, directly access special output variables
(OutputVariableType) of the mesh nodes \(n_i\) of the superelement.
Additionally, the contour drawing of the object can make use the OutputVariableType of the meshnodes.
Super element output variables
super element output variables |
symbol |
description |
|---|---|---|
Position |
\(\LU{0}{\pv}\cConfig(n_i) = \LU{0}{\pRef\cConfig} + \LU{0b}{\Rot}\cConfig \LU{b}{\pv}\cConfig(n_i)\) |
global position of mesh node \(n_i\) including rigid body motion and flexible deformation |
Displacement |
\(\LU{0}{\cv}\cConfig(n_i) = \LU{0}{\pv\cConfig(n_i)} - \LU{0}{\pv\cRef(n_i)}\) |
global displacement of mesh node \(n_i\) including rigid body motion and flexible deformation |
Velocity |
\(\LU{0}{\vv}\cConfig(n_i) = \LU{0}{\dot \pRef\cConfig} + \LU{0b}{\Rot}\cConfig (\LU{b}{\dot \qv\indf}\cConfig(n_i) + \LU{b}{\tomega}\cConfig \times \LU{b}{\pv}\cConfig(n_i))\) |
global velocity of mesh node \(n_i\) including rigid body motion and flexible deformation |
Acceleration |
\(\begin{array}{l} \LU{0}{\av}\cConfig(n_i) = \LU{0}{\ddot \pRef\cConfig}\cConfig \\ + \LU{0b}{\Rot}\cConfig \LU{b}{\ddot \qv\indf}\cConfig(n_i) \\ + 2\LU{0}{\tomega}\cConfig \times \LU{0b}{\Rot}\cConfig \LU{b}{\dot \qv\indf}\cConfig(n_i) \\ + \LU{0}{\talpha}\cConfig \times \LU{0}{\pv}\cConfig(n_i) \\ + \LU{0}{\tomega}\cConfig \times (\LU{0}{\tomega}\cConfig \times \LU{0}{\pv}\cConfig(n_i)) \end{array}\) |
global acceleration of mesh node \(n_i\) including rigid body motion and flexible deformation; note that \(\LU{0}{\pv}\cConfig(n_i) = \LU{0b}{\Rot} \LU{b}{\pv}\cConfig(n_i)\) |
DisplacementLocal |
\(\LU{b}{\dv}\cConfig(n_i) = \LU{b}{\pv}\cConfig(n_i) - \LU{b}{\xv}\cRef(n_i)\) |
local displacement of mesh node \(n_i\), representing the flexible deformation within the body frame; note that \(\LU{0}{\uv}\cConfig \neq \LU{0b}{\Rot}\LU{b}{\dv}\cConfig\) ! |
VelocityLocal |
\(\LU{b}{\dot \qv\indf}\cConfig(n_i)\) |
local velocity of mesh node \(n_i\), representing the rate of flexible deformation within the body frame |
Definition of quantities
intermediate variables |
symbol |
description |
|---|---|---|
object coordinates |
\(\qv = [\qv\indt\tp,\;\qv\indr\tp,\;\qv\indf\tp]\tp\) |
object coordinates |
rigid body coordinates |
\(\qv\indrigid = [\qv\indt\tp,\;\qv\indr\tp]\tp = [q_0,\,q_1,\,q_2,\,\psi_0,\,\psi_1,\,\psi_2,\,\psi_3]\tp\) |
rigid body coordinates in case of Euler parameters |
reference frame (rigid body) position |
\(\LU{0}{\pRef\cConfig} = \LU{0}{\qv_\mathrm{t,config}}+\LU{0}{\qv_\mathrm{t,ref}}\) |
global position of underlying rigid body node \(n_0\) which defines the reference frame origin |
reference frame (rigid body) orientation |
\(\LU{0b}{\Rot(\ttheta)}\cConfig\) |
transformation matrix for transformation of local (reference frame) to global coordinates, given by underlying rigid body node \(n_0\) |
local nodal position |
\(\LU{b}{\pv^{(i)}} = \LU{b}{\xv^{(i)}}\cRef + \LU{b}{\qv\indf^{(i)}} \) |
vector of body-fixed (local) position of node \((i)\), including flexible part |
local nodal positions |
\(\LU{b}{\pv} = \LU{b}{\xv}\cRef + \LU{b}{\qv\indf}\) |
vector of all body-fixed (local) nodal positions including flexible part |
rotation coordinates |
\(\ttheta\cCur = [\psi_0,\,\psi_1,\,\psi_2,\,\psi_3]\tp\cRef + [\psi_0,\,\psi_1,\,\psi_2,\,\psi_3]\cCur\tp\) |
rigid body coordinates in case of Euler parameters |
flexible coordinates |
\(\LU{b}{\qv\indf}\) |
flexible, body-fixed coordinates |
transformation of flexible coordinates |
\(\LU{0b}{\Am_{bd}} = \mathrm{diag}([\LU{0b}{\Am},\;\ldots,\;\LU{0b}{\Am})\) |
block diagonal transformation matrix, which transforms all flexible coordinates from local to global coordinates |
The derivations follow Zwölfer and Gerstmayr ZwoelferGerstmayr2021 with only small modifications in the notation.
Nodal coordinates
Consider an object with \(n = 1 + n_\mathrm{nf}\) nodes, \(n_\mathrm{nf}\) being the number of ‘flexible’ nodes and one additional node is the rigid body node for the reference frame. The list if node numbers is \([n_0,\,\ldots,\,n_{n_\mathrm{nf}}]\) and the according numbers of nodal coordinates are \([n_{c_0},\,\ldots,\,n_{c_n}]\), where \(n_0\) denotes the rigid body node. This gives \(n_c\) total nodal coordinates,
whereof the number of flexible coordinates is
The total number of equations (=coordinates) of the object is \(n_c\). The first node \(n_0\) represents the rigid body motion of the underlying reference frame with \(n_{c\indr} = n_{c_0}\) coordinates (e.g., \(n_{c\indr}=6\) coordinates for Euler angles and \(n_{c\indr}=7\) coordinates in case of Euler parameters; currently only the Euler parameter case is implemented.).
Kinematics
We assume a finite element mesh with The kinematics of the FFRF is based on a splitting of translational (\(\cv_t \in \Rcal^{n\indf}\)), rotational (\(\cv\indr \in \Rcal^{n\indf}\)) and flexible (\(\cv\indf \in \Rcal^{n\indf}\)) nodal displacements,
which are written in global coordinates in (59) but will be transformed to other coordinates later on.
In the present formulation of ObjectFFRF, we use the following set of object coordinates (unknowns)
with \(\LU{0}{\qv}\indt \in \Rcal^{3}\), \(\ttheta \in \Rcal^{4}\) and \(\LU{b}{\qv}\indf \in \Rcal^{n\indf}\). Note that parts of the coordinates \(\qv\) can be already interpreted in specific coordinate systems, which is therefore added.
With the relations
we obtain the total relation of (global) nodal displacements to the object coordinates
On velocity level, we have
with the matrix \(\Lm \in \Rcal^{n\indf \times n_c}\)
with the rotation parameters specific matrix \(\LU{b}{\Gm}\), implicitly defined in the rigid body node by the relation \(\LU{b}{\tomega} = \LU{b}{\Gm} \dot \ttheta\) and the body-fixed nodal position vector (for node \(i\))
and the special tilde matrix for vectors \(\pv \in \Rcal^{3 {n_\mathrm{nf}}}\),
with the tilde operator for a \(\pv^{(i)} \in \Rcal^{3}\) defined in the common notations section.
Equations of motion
We use the Lagrange equations extended for constraint \(\gv\),
with the quantities
Note that \(\LU{b}{\Mm}\) and \(\LU{b}{\Km}\) are the conventional finite element mass an stiffness matrices defined in the body frame.
Elementary differentiation rules of the Lagrange equations lead to
with \(\Mm = \LU{b}{\Mm}\) and \(\hat \Km\) becoming obvious in (63). Note that (62) is given in global coordinates for the translational part, in terms of rotation parameters for the rotation part and in body-fixed coordinates for the flexible part of the equations.
In case that computeFFRFterms = True, (62) can be transformed into the equations of motion,
in which iN represents the itemNumber (=objectNumber of ObjectFFRF in mbs) in the user function.
The mass terms are given as
In case that computeFFRFterms = False, the mass terms \(\Mm\indtt, \Mm\indtr, \Mm\indtf, \Mm\indrr,
\Mm\indrf, \LU{b}{\Mm}\) in (63) are set to zero (and not computed) and
the quadratic velocity vector \(\fv_{v} = \Null\).
Note that the user functions \(\fv_{user}(mbs, t, i_N, \qv,\dot \qv)\) and \(\Mm_{user}(mbs, t, i_N, \qv,\dot \qv)\) may be empty (=0).
The detailed equations of motion for this element can be found in ZwoelferGerstmayr2020.
The quadratic velocity vector follows as
with the special matrix
CoordinateLoads are added for each ODE2 coordinate on the RHS of the latter equation.
If the rigid body node is using Euler parameters \(\ttheta = [\theta_0,\,\theta_1,\,\theta_2,\,\theta_3]\tp\), an additional constraint (constraint nr. 0) is added automatically for the Euler parameter norm, reading
In order to suppress the rigid body motion of the mesh nodes, you should apply a ObjectConnectorCoordinateVector object with the following constraint equations which impose constraints of a so-called Tisserand frame, giving 3 constraints for the position of the center of mass
and 3 constraints for the rotation,
Marker interfaces
MarkerSuperElementPosition and MarkerSuperElementRigid act on the mesh nodes - the nodes of
the finite element mesh, moved with the reference frame -, averaged with the weights of the marker;
they are the markers for forces, connectors and joints on the flexible body. The general body markers
MarkerBodyPosition and MarkerBodyRigid act on the reference frame only, the rigid body node 0,
and not on the deformation. MarkerBodyMass applies a load proportional to the total mass at the
center of mass centerOfMass, through the coordinates of the reference frame only: the
flexible coordinates get no share of it.
This object has no MiniExample, because it needs a finite element mesh; a complete model is
NGsolveFFRF.py, with the mesh from NGsolve; it is in the examples below.
Userfunction: forceUserFunction(mbs, t, itemNumber, q, q_t)
A user function, which computes a force vector depending on current time and states of object. Can be used to create any kind of mechanical system by using the object states.
arguments / return |
type or size |
description |
|---|---|---|
|
MainSystem |
provides MainSystem mbs to which object belongs |
|
Real |
current time in mbs |
|
Index |
integer number of the object in mbs, allowing easy access to all object data via mbs.GetObjectParameter(itemNumber, …) |
|
Vector \(\in \Rcal^n_c\) |
object coordinates (nodal displacement coordinates of rigid body and mesh nodes) in current configuration, without reference values |
|
Vector \(\in \Rcal^n_c\) |
object velocity coordinates (time derivative of |
return value |
Vector \(\in \Rcal^{n_c}\) |
returns force vector for object |
Userfunction: massMatrixUserFunction(mbs, t, itemNumber, q, q_t)
A user function, which computes a mass matrix depending on current time and states of object. Can be used to create any kind of mechanical system by using the object states.
arguments / return |
type or size |
description |
|---|---|---|
|
MainSystem |
provides MainSystem mbs to which object belongs |
|
Real |
current time in mbs |
|
Index |
integer number of the object in mbs, allowing easy access to all object data via mbs.GetObjectParameter(itemNumber, …) |
|
Vector \(\in \Rcal^n_c\) |
object coordinates (nodal displacement coordinates of rigid body and mesh nodes) in current configuration, without reference values |
|
Vector \(\in \Rcal^n_c\) |
object velocity coordinates (time derivative of |
return value |
NumpyMatrix \(\in \Rcal^{n_c \times n_c}\) |
returns mass matrix for object |
Examples (Ex) and TestModels (TM) that show this item, with weblink to github: NGsolveFFRF.py (Ex), objectFFRFTest.py (TM), objectFFRFTest2.py (TM)