```{raw} latex \clearpage ``` (sec-item-objectffrf)= # ObjectFFRF This object is used to represent equations modelled by the {ref}`FFRF `. It contains a RigidBodyNode (always node 0) and a list of other nodes representing the finite element nodes used in the {ref}`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: [](#sec-item-markerbodymass), [](#sec-item-markerbodyposition), [](#sec-item-markerbodyrigid), [](#sec-item-markersuperelementposition), [](#sec-item-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 {ref}`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 {ref}`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 {ref}`FFRF ` mass matrix; see description below | | **computeFFRFterms** | Bool | | True | flag decides whether the standard {ref}`FFRF ` terms are computed; use this flag for user-defined definition of {ref}`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 {ref}`FFRF ` matrices; as soon as this flag is False, internal (constant) {ref}`FFRF ` matrices are recomputed during Assemble() | | **mass** | UReal | | 0. | (symbol: $m$) total mass [SI:kg] of {ref}`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 ({ref}`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](#sec-drawing-objectssuperelement); its `triangleMesh` on the nodes, deformed with `bodies.deformationScaleFactor`, and with `showNodes` its nodes. Settings beyond those of all super elements: [`nodes.defaultSize`](#sec-vsettingsnodes), [`nodes.drawNodesAsPoint`](#sec-vsettingsnodes), [`nodes.show`](#sec-vsettingsnodes), [`nodes.showNumbers`](#sec-vsettingsnodes), [`nodes.tiling`](#sec-vsettingsnodes), [`openGL.advanced.initialMaxSceneSize`](#sec-vsettingsopengladvanced). ## Output variables Available as `OutputVariableType` in sensors, `Get...Output()` and other functions: ```{tabularcolumns} \Y{0.25}\Y{0.25}\Y{0.5} ``` | output variable | symbol | description | |---|---|---| | Coordinates | | all {ref}`ODE2 ` coordinates | | Coordinates_t | | all {ref}`ODE2 ` velocity coordinates | | Coordinates_tt | | all {ref}`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]$ | (description-objectffrf)= ## Detailed description ### Additional output variables for superelement node access Functions like `GetObjectOutputSuperElement(...)`, see [](#sec-mainsystem-object), or `SensorSuperElement`, see [](#sec-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. (sec-objectffrf-superelementoutput)= ### 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, $$ n_c = \sum_{i=0}^{n_\mathrm{nf}} n_{c_i} \, , $$ whereof the number of flexible coordinates is $$ n\indf = 3 \cdot n_\mathrm{nf} \, . $$ 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 {ref}`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, $$ \LU{0}{\cv} = \LU{0}{\cv\indt} + \LU{0}{\cv\indr} + \LU{0}{\cv\indf} \, . $$ (eq-objectffrf-coordinatessplitting) which are written in global coordinates in {eq}`eq-objectffrf-coordinatessplitting` but will be transformed to other coordinates later on. In the present formulation of `ObjectFFRF`, we use the following set of object coordinates (unknowns) $$ \qv = \left[\LU{0}{\qv\indt\tp} \;\; \ttheta\tp \;\; \LU{b}{\qv\indf\tp} \right]\tp \in \Rcal^{n_c} $$ 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 $$ \begin{aligned} \tPhi\indt &= \left[\ImThree ,\; \ldots ,\; \ImThree \right]\tp \in \Rcal^{n\indf \times 3} \, ,\\ \LU{0}{\cv\indt} &= \tPhi\indt \LU{0}{\qv\indt} \, ,\\ \LU{0}{\cv\indr} &= \left(\LU{0b}{\Am_{bd}} - \Im_{bd}\right) \LU{b}{\xv\cRef} \, ,\\ \LU{0}{\cv\indf} &= \LU{0b}{\Am_{bd}} \LU{b}{\qv\indf} \, , \mathrm{and}\\ \Im_{bd} &= \mathrm{diag}(\ImThree, \; \ldots ,\; \ImThree) \in \Rcal^{n\indf \times n\indf} \, , \end{aligned} $$ (eq-objectffrf-phit) we obtain the total relation of (global) nodal displacements to the object coordinates $$ \LU{0}{\cv} = \tPhi\indt \LU{0}{\qv\indt} + \left(\LU{0b}{\Am_{bd}} - \Im_{bd}\right) \LU{b}{\xv\cRef} + \LU{0b}{\Am_{bd}} \LU{b}{\qv\indf} \, . $$ On velocity level, we have $$ \LU{0}{\dot \cv} = \Lm \dot \qv \, , $$ with the matrix $\Lm \in \Rcal^{n\indf \times n_c}$ $$ \Lm = \left[\tPhi\indt ,\;\; -\LU{0b}{\Am_{bd}} \LU{b}{\tilde \pv} \LU{b}{\Gm} ,\;\; \LU{0b}{\Am_{bd}} \right] $$ 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$) $$ \LU{b}{\pv} = \LU{b}{\xv\cRef} + \LU{b}{\qv\indf}, \quad \LU{b}{\pv^{(i)}} = \LU{b}{\xv^{(i)}\cRef} + \LU{b}{\qv_{\mathrm{f},i}^{(i)}} $$ and the special tilde matrix for vectors $\pv \in \Rcal^{3 {n_\mathrm{nf}}}$, $$ \LU{b}{\tilde \pv} = \vr{\LU{b}{\tilde\pv^{(i)}}}{\vdots}{\LU{b}{\tilde\pv^{(i)}}} \in \Rcal^{3{n_\mathrm{nf}} \times 3} \, . $$ (eq-objectffrf-specialtilde) 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$, $$ \frac{d}{dt} \left( \frac{\partial T}{\partial \dot \qv\tp} \right) - \frac{\partial T}{\partial \qv\tp} + \frac{\partial V}{\partial \qv\tp} + \frac{\partial \tlambda\tp \gv}{\partial \qv\tp} = \frac{\partial W}{\partial \qv\tp} $$ with the quantities $$ \begin{aligned} T(\LU{0}{\dot \cv(\qv, \dot \qv)}) &= \frac{1}{2}\LU{0}{\dot \cv\tp} \LU{0}{\Mm} \LU{0}{\dot \cv} = \frac{1}{2}\LU{0}{\dot \cv\tp} \LU{0b}{\Am_{bd}} \LU{b}{\Mm} \LU{0b}{\Am_{bd}}\tp \LU{0}{\dot \cv} = \frac{1}{2}\LU{0}{\dot \cv\tp} \LU{b}{\Mm} \LU{0}{\dot \cv}\\ V(\LU{0}{\qv\indf}) &= \frac{1}{2}\LU{b}{\qv\indf\tp} \LU{b}{\Km} \LU{b}{\qv\indf} \\ \delta W(\LU{0}{\cv(\qv)},t) &= \LU{b}{\delta \cv \tp} \fv \\ \gv(\qv, t) &= \Null \\ \end{aligned} $$ 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 $$ \Lm\tp \Mm \Lm \ddot \qv + \Lm\tp \Mm \dot \Lm \dot \qv + \hat \Km \qv + \frac{\partial \gv}{\partial \qv\tp} \tlambda = \Lm\tp \fv $$ (eq-objectffrf-leq) with $\Mm = \LU{b}{\Mm}$ and $\hat \Km$ becoming obvious in {eq}`eq-objectffrf-eom`. Note that {eq}`eq-objectffrf-leq` 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`, {eq}`eq-objectffrf-leq` can be transformed into the equations of motion, $$ \left(\Mm_{user}(mbs, t, i_N, \qv,\dot \qv) + \mr{\Mm\indtt}{\Mm\indtr}{\Mm\indtf} {}{\Mm\indrr}{\Mm\indrf} {\mathrm{sym.}}{}{\LU{b}{\Mm}} \right) \ddot \qv + \mr{0}{0}{0} {0}{0}{0} {0}{0}{\LU{b}{\Dm}} \dot \qv + \mr{0}{0}{0} {0}{0}{0} {0}{0}{\LU{b}{\Km}} \qv = \fv_{v}(\qv,\dot \qv) + \vp{\fv\indr}{\LURU{0b}{\Am}{bd}{\mathrm{T}} \fv\indf} + \fv_{user}(mbs, t, i_N, \qv, \dot \qv) $$ (eq-objectffrf-eom) in which `iN` represents the itemNumber (=objectNumber of ObjectFFRF in mbs) in the user function. The mass terms are given as $$ \begin{aligned} \Mm\indtt &= \tPhi\indt\tp \LU{b}{\Mm} \tPhi\indt,\\ \Mm\indtr &= -\LU{0b}{\Rot} \tPhi\indt\tp \LU{b}{\Mm} \LU{b}{\tilde \pv} \LU{b}{\Gm} ,\\ \Mm\indtf &= \LU{0b}{\Rot} \tPhi\indt\tp \LU{b}{\Mm} ,\\ \Mm\indrr &= \LU{b}{\Gm}\tp \LU{b}{\tilde \pv\tp} \LU{b}{\Mm} \LU{b}{\tilde \pv} \LU{b}{\Gm} ,\\ \Mm\indrf &= - \LU{b}{\Gm}\tp \LU{b}{\tilde \pv\tp} \LU{b}{\Mm} \, . \end{aligned} $$ In case that `computeFFRFterms = False`, the mass terms $\Mm\indtt, \Mm\indtr, \Mm\indtf, \Mm\indrr, \Mm\indrf, \LU{b}{\Mm}$ in {eq}`eq-objectffrf-eom` 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 $$ \fv_{v}(\qv,\dot \qv) = \vr {-\LU{0b}{\Rot} \tPhi\indt\tp \LU{b}{\Mm}\left( \omegaBDtilde \omegaBDtilde \LU{b}{\pv} + 2 \omegaBDtilde \LU{b}{\dot \qv}\indf - \LU{b}{\tilde \pv} \LU{b}{\dot \Gm} \dot \ttheta \right)} {\LU{b}{\Gm}\tp \LU{b}{\tilde \pv\tp} \LU{b}{\Mm} \left( \omegaBDtilde \omegaBDtilde \LU{b}{\pv} + 2 \omegaBDtilde \LU{b}{\dot \qv}\indf - \LU{b}{\tilde \pv} \LU{b}{\dot \Gm} \dot \ttheta \right)} {-\LU{b}{\Mm} \left( \omegaBDtilde \omegaBDtilde \LU{b}{\pv} + 2 \omegaBDtilde \LU{b}{\dot \qv}\indf - \LU{b}{\tilde \pv} \LU{b}{\dot \Gm} \dot \ttheta \right)} $$ with the special matrix $$ \omegaBDtilde = \mathrm{diag}\left(\LU{b}{\tilde \tomega_\mathrm{bd}}, \; \ldots ,\; \LU{b}{\tilde \tomega_\mathrm{bd}} \right) \in \Rcal^{n\indf \times n\indf} $$ CoordinateLoads are added for each {ref}`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 $$ 1 - \sum_{i=0}^{3} \theta_i^2 = 0. $$ 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 $$ \Phi\indt\tp \LU{b}{\Mm} \qv\indf = 0 $$ and 3 constraints for the rotation, $$ \tilde\xv_{f}\tp \LU{b}{\Mm} \qv\indf = 0 $$ ### 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 | |---|---|---| | `mbs` | MainSystem | provides MainSystem mbs to which object belongs | | `t` | Real | current time in mbs | | `itemNumber` | Index | integer number of the object in mbs, allowing easy access to all object data via mbs.GetObjectParameter(itemNumber, ...) | | `q` | Vector $\in \Rcal^n_c$ | object coordinates (nodal displacement coordinates of rigid body and mesh nodes) in current configuration, without reference values | | `q_t` | Vector $\in \Rcal^n_c$ | object velocity coordinates (time derivative of `q`) in current configuration | | **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 | |---|---|---| | `mbs` | MainSystem | provides MainSystem mbs to which object belongs | | `t` | Real | current time in mbs | | `itemNumber` | Index | integer number of the object in mbs, allowing easy access to all object data via mbs.GetObjectParameter(itemNumber, ...) | | `q` | Vector $\in \Rcal^n_c$ | object coordinates (nodal displacement coordinates of rigid body and mesh nodes) in current configuration, without reference values | | `q_t` | Vector $\in \Rcal^n_c$ | object velocity coordinates (time derivative of `q`) in current configuration | | **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`](https://github.com/jgerstmayr/EXUDYN/blob/master/python/Examples/NGsolveFFRF.py) (Ex), [`objectFFRFTest.py`](https://github.com/jgerstmayr/EXUDYN/blob/master/python/TestModels/objectFFRFTest.py) (TM), [`objectFFRFTest2.py`](https://github.com/jgerstmayr/EXUDYN/blob/master/python/TestModels/objectFFRFTest2.py) (TM)