This object is used to represent modally reduced flexible bodies using the FFRF <FFRF>
and the CMS <CMS>
. It can be used to model real-life mechanical systems imported from finite element codes or Python tools such as NETGEN/NGsolve, see the FEMinterface
in Section sec-fem-feminterface---init--
. It contains a RigidBodyNode (always node 0) and a NodeGenericODE2 representing the modal coordinates. Currently, equations must be defined within user functions, which are available in the FEM module, see class ObjectFFRFreducedOrderInterface
, especially the user functions UFmassFFRFreducedOrder
and UFforceFFRFreducedOrder
, Section sec-fem-objectffrfreducedorderinterface-addobjectffrfreducedorderwithuserfunctions
.
Authors: Gerstmayr Johannes, Zwölfer Andreas
Additional information for ObjectFFRFreducedOrder:
- This
Object
has/provides the following types =Body
,MultiNoded
,SuperElement
- Requested
Node
type: read detailed information of item - Short name for Python =
CMSobject
- Short name for Python visualization object =
VCMSobject
The item ObjectFFRFreducedOrder with type = 'FFRFreducedOrder' has the following parameters:
- name [type = String, default = '']:
objects's unique name - nodeNumbers [
$\mathbf{n} = [n_0,\,n_1]\tp$ , type = ArrayNodeIndex, default = []]:
node numbers of rigid body node and NodeGenericODE2 for modal coordinates; the global nodal position needs to be reconstructed from the rigid-body motion of the reference frame, the modal coordinates and the mode basis - massMatrixReduced [
${\mathbf{M}}\indred \in \Rcal^{n_m \times n_m}$ , type = PyMatrixContainer, default = PyMatrixContainer[]]:
body-fixed and ONLY flexible coordinates part of reduced mass matrix; provided as MatrixContainer(sparse/dense matrix) - stiffnessMatrixReduced [
${\mathbf{K}}\indred \in \Rcal^{n_m \times n_m}$ , type = PyMatrixContainer, default = PyMatrixContainer[]]:
body-fixed and ONLY flexible coordinates part of reduced stiffness matrix; provided as MatrixContainer(sparse/dense matrix) - dampingMatrixReduced [
${\mathbf{D}}\indred \in \Rcal^{n_m \times n_m}$ , type = PyMatrixContainer, default = PyMatrixContainer[]]:
body-fixed and ONLY flexible coordinates part of reduced damping matrix; provided as MatrixContainer(sparse/dense matrix) - forceUserFunction [
${\mathbf{f}}\induser \in \Rcal^{n_{ODE2}}$ , type = PyFunctionVectorMbsScalarIndex2Vector, default = 0]:
A Python user function which computes the generalized user force vector for theODE2 <ODE2>
equations; see description below - massMatrixUserFunction [
${\mathbf{M}}\induser \in \Rcal^{n_{ODE2}\times n_{ODE2}}$ , type = PyFunctionMatrixMbsScalarIndex2Vector, default = 0]:
A Python user function which computes the TOTAL mass matrix (including reference node) and adds the local constant mass matrix; see description below - computeFFRFterms [type = Bool, default = True]:
flag decides whether the standardFFRF <FFRF>
/CMS <CMS>
terms are computed; use this flag for user-defined definition ofFFRF <FFRF>
terms in mass matrix and quadratic velocity vector - modeBasis [
$\LU{b}{\tPsi} \in \Rcal^{n\indf \times n_{m}}$ , type = NumpyMatrix, default = Matrix[]]:
mode basis, which transforms reduced coordinates to (full) nodal coordinates, written as a single vector$[u_{x,n_0},\,u_{y,n_0},\,u_{z,n_0},\,\ldots,\,u_{x,n_n},\,u_{y,n_n},\,u_{z,n_n}]\tp$ - outputVariableModeBasis [
$\LU{b}{\tPsi}_{OV} \in \Rcal^{n_n \times (n_{m}\cdot s_{OV})}$ , type = NumpyMatrix, default = Matrix[]]:
mode basis, which transforms reduced coordinates to output variables per mode and per node; sOV is the size of the output variable, e.g., 6 for stress modes (Sxx, ..., Sxy) - outputVariableTypeModeBasis [type = OutputVariableType, default = OutputVariableType::_None]:
this must be the output variable type of the outputVariableModeBasis, e.g. exu.OutputVariableType.Stress - referencePositions [
$\LU{b}{{\mathbf{x}}}\cRef \in \Rcal^{n\indf}$ , type = NumpyVector, default = []]:
vector containing the reference positions of all flexible nodes, needed for graphics - objectIsInitialized [type = Bool, default = False]:
ALWAYS set to False! flag used to correctly initialize allFFRF <FFRF>
matrices; as soon as this flag is False, some internal (constant)FFRF <FFRF>
matrices are recomputed during Assemble() - physicsMass [m, type = UReal, default = 0.]:
total mass [SI:kg] of FFRFreducedOrder object - physicsInertia [
${\mathbf{J}}_r \in \Rcal^{3 \times 3}$ , type = Matrix3D, default = [[1,0,0], [0,1,0], [0,0,1]]]:
inertia tensor [SI:kgm2] of rigid body w.r.t. to the reference point of the body - physicsCenterOfMass [
$\LU{b}{{\mathbf{b}}}_{COM}$ , type = Vector3D, size = 3, default = [0.,0.,0.]]:
local position of center of mass (COM <COM>
) - mPsiTildePsi [type = NumpyMatrix, default = Matrix[]]:
special FFRFreducedOrder matrix, computed in ObjectFFRFreducedOrderInterface - mPsiTildePsiTilde [type = NumpyMatrix, default = Matrix[]]:
special FFRFreducedOrder matrix, computed in ObjectFFRFreducedOrderInterface - mPhitTPsi [type = NumpyMatrix, default = Matrix[]]:
special FFRFreducedOrder matrix, computed in ObjectFFRFreducedOrderInterface - mPhitTPsiTilde [type = NumpyMatrix, default = Matrix[]]:
special FFRFreducedOrder matrix, computed in ObjectFFRFreducedOrderInterface - mXRefTildePsi [type = NumpyMatrix, default = Matrix[]]:
special FFRFreducedOrder matrix, computed in ObjectFFRFreducedOrderInterface - mXRefTildePsiTilde [type = NumpyMatrix, default = Matrix[]]:
special FFRFreducedOrder matrix, computed in ObjectFFRFreducedOrderInterface - physicsCenterOfMassTilde [
$\LU{b}{\tilde {\mathbf{b}}}_{COM}$ , type = Matrix3D, default = [[0,0,0], [0,0,0], [0,0,0]]]:
tilde matrix from local position ofCOM <COM>
; autocomputed during initialization - tempUserFunctionForce [
${\mathbf{f}}_{temp} \in \Rcal^{n_{ODE2}}$ , type = NumpyVector, default = []]:
temporary vector for UF force - visualization [type = VObjectFFRFreducedOrder]:
parameters for visualization of item
The item VObjectFFRFreducedOrder has the following parameters:
- show [type = Bool, default = 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 [type = Float4, size = 4, default = [-1.,-1.,-1.,-1.]]:
RGBA color for object; 4th value is alpha-transparency; R=-1.f means, that default color is used - triangleMesh [type = NumpyMatrixI, default = MatrixI[]]:
a matrix, containg node number triples in every row, referring to the node numbers of the GenericODE2 object; the mesh uses the nodes to visualize the underlying object; contour plot colors are still computed in the local frame! - showNodes [type = Bool, default = 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'
The following output variables are available as OutputVariableType in sensors, Get...Output() and other functions:
Coordinates
:
allODE2 <ODE2>
coordinatesCoordinates\_t
:
allODE2 <ODE2>
velocity coordinatesForce
:
generalized forces for all coordinates (residual of all forces except mass*accleration; corresponds to ComputeODE2LHS)
Functions like GetObjectOutputSuperElement(...)
, see Section sec-mainsystem-object
, or SensorSuperElement
, see Section sec-mainsystem-sensor
, directly access special output variables (OutputVariableType
) of the mesh nodes of the superelement. Additionally, the contour drawing of the object can make use the OutputVariableType
of the meshnodes.
super element output variables |
symbol |
description |
---|---|---|
DisplacementLocal (mesh node i) |
local nodal mesh displacement in reference (body) frame, measuring only flexible part of displacement |
|
VelocityLocal (mesh node (i)) |
local nodal mesh velocity in reference (body) frame, only for flexible part of displacement |
|
Displacement (mesh node (i)) |
nodal mesh displacement in global coordinates |
|
Position (mesh node (i)) |
nodal mesh position in global coordinates |
|
Velocity (mesh node (i)) |
nodal mesh velocity in global coordinates |
|
Acceleration (mesh node (i)) |
global acceleration of mesh node ni including rigid body motion and flexible deformation; note that |
|
StressLocal (mesh node (i)) |
linearized stress components of mesh node (i) in reference frame; outputVariableTypeModeBasis== exu.OutputVariableType.StressLocal
|
|
StrainLocal (mesh node (i)) |
linearized strain components of mesh node (i) in reference frame; outputVariableTypeModeBasis== exu.OutputVariableType.StrainLocal
|
intermediate variables |
symbol |
description |
---|---|---|
reference frame |
b |
the body-fixed / local frame is always denoted by b
|
number of rigid body coordinates |
number of rigid body node coordinates: 6 in case of Euler angles (not fully available for ObjectFFRFreducedOrder) and 7 in case of Euler parameters |
|
number of flexible / mesh coordinates |
with number of nodes nn; relevant for visualization |
|
number of modal coordinates |
the number of reduced or modal coordinates, computed from number of columns given in modeBasis
|
|
total number object coordinates |
nODE2 = nm + nrigid |
|
reference frame origin |
reference frame position (origin) |
|
reference frame rotation |
reference frame rotation parameters in any configuration except reference |
|
reference frame orientation |
transformation matrix for transformation of local (reference frame) to global coordinates, given by underlying rigid body node n0
|
|
local vector of flexible coordinates |
represents mesh displacements; vector of alternating x,y, an z coordinates of local (in body frame) mesh displacements reconstructed from modal coordinates ObjectFFRF
|
|
local nodal positions |
vector of all body-fixed nodal positions including flexible part; only evaluated for selected node points during computation |
|
local position of node (i) |
body-fixed, deformed nodal mesh position (including flexible part) |
|
vector of modal coordinates |
vector of modal or reduced coordinates; these coordinates can either represent amplitudes of eigenmodes, static modes or general modes, depending on your mode basis |
|
coordinate vector |
vector of object coordinates; |
|
flexible coordinates transformation matrix |
block diagonal transformation matrix, which transforms all flexible coordinates from local to global coordinates |
The formulation is based on the EOM of ObjectFFRF
, also regarding parts of notation and some input parameters, Section sec-item-objectffrf
, and can be found in Zwölfer and Gerstmayr with only small modifications in the notation. The notation of kinematics quantities follows the floating frame of reference idea with quantities given in the tables above and sketched in fig-objectffrfreducedorder-mesh
.
Floating frame of reference with exemplary position of a mesh node i
The reduced order FFRF <FFRF>
formulation is based on an approximation of flexible coordinates modeBasis
) and the the modal coordinates
The mode basis exudyn.FEM
, within the class text{FEMinterface}. To compute eigen modes, use FEMinterface.ComputeEigenmodes(...)
or FEMinterface.ComputeHurtyCraigBamptonModes(...)
. For details on model order reduction and component mode synthesis, see Section sec-theory-cms
. In many applications, nm typically ranges between 10 and 50, but also beyond -- depending on the desired accuracy of the model.
The ObjectFFRF
coordinates and Eqs. eq-objectffrf-eom
(this is not done for user functions and forceVector
) can be reduced by the matrix
with the 4 × 4 identity matrix
The reduced equations follow from the reduction of system matrices in Eqs. eq-objectffrf-eom
,
the computation of rigid body inertia
the center of mass (and according tilde matrix), using eq-objectffrf-phit
,
and seven inertia-like matrices ,
Note that the special tilde operator for vectors eq-objectffrf-specialtilde
is frequently used.
Equations of motion, in case that computeFFRFterms = True
:
(NOTE that currently the internal (C++) computed terms are zero,
but they are implemented in predefined user functions, see FEM.py
, Section sec-fem-objectffrfreducedorderinterface-addobjectffrfreducedorderwithuserfunctions
. In near future, these terms will be implemented in C++ and replace the user functions.) Note that in case of Euler parameters for the parameterization of rotations for the reference frame, the Euler parameter constraint equation is added automatically by this object. The single terms of the mass matrix are defined as
with the Kronecker product(In Python numpy module this is computed by numpy.kron(zeta, Im).T
),
The quadratic velocity vector
Note that terms including
In case that computeFFRFterms = False
, the mass terms
For joints and loads, the position jacobian of a node is needed in order to compute forces applied to averaged displacements and rotations at nodes. Recall that the modal coordinates
The local displacements
and the global position of a node, see tables above, reads
Thus, the jacobian of the global position reads
in which
Furthermore, the jacobian of the local position reads
which is used in MarkerSuperElementRigid
.
Use special MarkerSuperElementPosition
to apply forces, SpringDampers or spherical joints. This marker can be attached to a single node of the underlying mesh or to a set of nodes, which is then averaged, see the according marker description.
Use special MarkerSuperElementRigid
to apply torques or special joints (e.g., JointGeneric
). This marker must be attached to a set of nodes which can represent rigid body motion. The rigid body motion is then averaged for all of these nodes, see the according marker description.
For application of mass proportional loads (gravity), you can use conventional MarkerBodyMass. However, do not use MarkerBodyPosition
or MarkerBodyRigid
for ObjectFFRFreducedOrder, unless wanted, because it only attaches to the floating frame. This means, that a force to a MarkerBodyPosition
would only be applied to the (rigid) floating frame, but not onto the deformable body and results depend strongly on the choice of the reference frame (or the underlying mode shapes).
CoordinateLoads are added for each ODE2 <ODE2>
coordinate on the RHS of the equations of motion.
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. Note that itemNumber represents the index of the ObjectFFRFreducedOrder object in mbs, which can be used to retrieve additional data from the object through mbs.GetObjectParameter(itemNumber, ...)
, see the according description of GetObjectParameter
.
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 |
FFRF <FFRF> object coordinates (rigid body coordinates and reduced coordinates in a list) in current configuration, without reference values |
q_t |
Vector |
object velocity coordinates (time derivatives of q ) in current configuration |
returnValue |
Vector |
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 |
FFRF <FFRF> object coordinates (rigid body coordinates and reduced coordinates in a list) in current configuration, without reference values |
q_t |
Vector |
object velocity coordinates (time derivatives of q ) in current configuration |
returnValue |
NumpyMatrix |
returns mass matrix for object |
Relevant Examples and TestModels with weblink:
NGsolvePistonEngine.py (Examples/), objectFFRFreducedOrderNetgen.py (Examples/), NGsolveCrankShaftTest.py (TestModels/), objectFFRFreducedOrderAccelerations.py (TestModels/), objectFFRFreducedOrderShowModes.py (TestModels/), objectFFRFreducedOrderStressModesTest.py (TestModels/), superElementRigidJointTest.py (TestModels/)
The web version may not be complete. For details, consider also the Exudyn PDF documentation : theDoc.pdf