(glossary_page)=

#  Glossary


## Frames


| Term | Definition |
|------|------------|
| **Homogeneous Transformation** | An element of SE(3) (the *Special Euclidean group* of rigid motions (rotations + translations)  that encodes a 3‑D pose: a rotation  and a translation vector. In {{ kdflex }} it is represented by `Karana.Math.HomTran`. |
| **Pose** | An informal term for a homogeneous transformation that specifies a frame’s location and orientation relative to another frame. |
| **Passive Attitude Representation** | {{ kdflex }} uses a passive (coordinate‑frame‑based) attitude representation. A vector transforms as ${}^a v = {}^aR_b\ {}^b v$, i.e., it is rotated from the “b” frame into the “a” frame. |
| **Spatial Vector** | An element of se(3) that encodes an angular  and a  translation 3-vector. In {{ kdflex }} it is represented by `Karana.Math.SpatialVector`. Spatial vectors quantities can be use for spatial velocities, spatial accelerations, spatial forces and spatial momentum etc. |
| **Rigid body transformation `phi`** | A 6x6 matrix associated with homogeneous transforms that is is used to transform spatial quantities such as spatial velocities, spatial forces, spatial inertias and more from one frame on a rigid body to another frame on the same rigid body. |
| **Frame** | A coordinate system that defines a position and orientation in 3‑D space. In {{ kdflex }}, a `Karana.Frame.Frame` instance represents a node in the directed tree of frames that underpins the multibody model and more. | 
| **FrameContainer** | The container class (`Karana.Frame.FrameContainer`) that owns and manages all `Frame` objects. It manages the directed tree (parent/child relationships) of frames and supplies utility methods for querying the hierarchy. |
| **Root Frame** | The root from for the frames tree. |
| **FrameToFrame** | An abstraction representing a directed relationship between two frames, `from` and `to`. It is defined by a `Karana.Frame.FrameToFrame` instance. The class provides methods to query the relative pose, spatial velocity, and spatial acceleration between the two frames. |
| **oframe** | *Origin* (or “from”) frame of a `Karana.Frame.FrameToFrame` instance. In {{ kdflex }} terminology it is the *root* of the directed relationship. |
| **pframe** | *Destination* (or “to”) frame of `Karana.Frame.FrameToFrame` instance. It is the child frame whose pose/velocity/acceleration is being queried relative to the `oframe`. |
| **EdgeFrameToFrame** | The tree edge type that actually stores the transformation between two adjacent frames in the `FrameContainer` tree. An `EdgeFrameToFrame` contains a *relative pose* (a homogeneous transform), relative *spatial velocity* and relative *spatial acceleration* between a child frame and its parent frame. |
| **Observing Frame** | The *observing* frame is defined as the frame that is used to express vector coordinates  whose  time derivatives such as  relative velocity and accelerations are taken. The observing is also at times referred to as the *derivative frame*. |
| **Representation Frame** | A vector's  *representation* frame is the one in which a vector's coordinates are expressed. | 
| **Relative Pose** | The pose of the “to‑frame” expressed in the “from‑frame” coordinates. The `FrameToFrame.relTransform()` method returns the pose of the pframe with respect to the oframe.  |
| **Relative Spatial Velocity** | The spatial velocity of the “to‑frame” with respect to the “from‑frame” coordinates. It includes both angular and linear components. The `FrameToFrame::relSpVel` method returns the relative spatial velocity of the pframe with respect to the oframe  as observed and represented in the oframe. |
| **Relative Spatial Acceleration** | The spatial acceleration of the “to‑frame” expressed in the “from‑frame” coordinates. The `FrameToFrame::relSpAccel` method returns the relative spatial acceleration of the pframe with respect to the oframe as observed and represented in the oframe. |
| **Changing Observer / Derivative Frames** | `FrameToFrame` offers additional methods that let you change the observing or derivative frame for a pose/velocity/acceleration query, thereby providing the same quantity in a different reference frame. |
| **OrientedFrameToFrame** | A specialized `FrameToFrame` chain that represents a concatenation of sequence of `FrameToFrame` edges whose `pframe`  is required to be downstream of the `oframe`.   |
| **ChainedFrameToFrame** | A lightweight wrapper that represents a concatenation of sequence of `FrameToFrame` edges. The `oframe` and `pframe` can be arbitrary frames in the frame tree. It allows querying relative poses/velocities across several tree edges in a single call (e.g., from a leaf to the Newtonian frame). |
| **SpiceFrame** | A specialized `Karana.Frame.FrameToFrame` instance instance that is tied to a NASA SPICE kernel (C-Kernel) time‑dependent reference. It provides time‑varying poses and velocities derived from SPICE kernels, typically used for spacecraft or planetary frames. |
| **SpiceFrameToFrame** | The corresponding edge type between a `SpiceFrame` oframe and  a `SpiceFrame` pframe. It uses the SPICE kernel to compute the relative transform at any simulation time. |




## Multibody model



| Term | Definition |
|------|------------|
| **Spatial Operator Algebra (SOA)** | SOA is the broad and unifying mathematical framework that underpins {{ kdflex }}’s dynamics engine. It uses  a set of system level operators to exploit the rich structure of minimal coordinate dynamics to develop analytical insights (eg. factorization and inversion of the mass matrix) and uses these to develop fast, recursive computational  algorithms for solving different problems related to the equations of motion. SOA methods apply to the broad class of multibody systems including those with rigid and flexible bodies, and tree and graph topologies.  | 
| **Rotational Inertia  Matrix** | A 3×3 symmetric matrix that describes how a body’s mass is distributed about its center of mass. |
| **Spatial Inertia Matrix** | A 6×6 matrix that combines mass, center‑of‑mass, and inertia tensor into a single object for use in spatial vector algebra. |
| **Parallel‑Axis Theorem** | A rule that shifts an inertia tensor from one frame to any other frame for a body. There is a version of the parallel-axis theorem for similarly transforming spatial inertias.  |
| **Rigid Body** | A body whose shape and mass distribution do not change over time. |
| **Flexible Body** | A body that can deform; its internal dynamics are usually represented by modal expansions or finite‑element discretization. |
| **Body Frame** | The coordinate system attached to a particular body; often used to express velocities, forces, and inertias. |
| **Multibody System** | A collection of rigid (or flexible) bodies connected by joints and constraints and subject to forces/torques, described by a set of equations of motion. |
| **Multibody topology** | A multibody topology is the graph‑theoretic structure that describes how the individual bodies in a multibody system are connected by joints (hinges, sliders, etc.). It tells you whether the system is a simple serial chain, a branched tree, or a closed‑loop graph, and it determines the number of independent coordinates, the number of constraints, and the computational strategy that {{ kdflex }} will use. |
| **Newtonian Frame** | The inertial (world) reference frame in {{ kdflex }} for dynamics computations. This frame is often the same as the root frame for the frames tree,
| **Multibody virtual root body** | The multibody's virtual root body is a special PhysicalBody that has no parent body.  All other bodies in the model are attached to this root (directly or indirectly) through hinges. The root body therefore serves as the anchor for the whole multibody system. The root body's  whose frame is either the same or  downstream of  the Newtonian frame. |
| **Subhinge** | A connection between a pair of frames  that defines  the permissible relative pose between the frames via an algebraic relationship. The  dimension of the subspace of permitted relative spatial velocities can range from 0 to 6 and defines the degrees of freedom for the subhinge. Examples of subhinges are pin, prismatic and spherical subhinges.   |
| **Hinge** | A connection between a pair of body nodes  attached to parent/child bodies  made up of a sequence of subhinges.  Examples of hinges are revolute, slider, ball and full 6 dof hinges. A hinge's body node on the inboard (parent) body is referred to as its *onode*, and the body node on the outboard (child) body is referred to an its *pnode*. The onode and pnode frames coincide when the `Q` generalized coordinates for a hinge are zero.  |
| **onode** | The attachment body node for a hinge on the inboard (parent) body.  |
| **pnode** | The attachment body node for a hinge on the outboard (child) body.  |
| **Joint** | Another term for hinges. |
| **Generalized Coordinate (`Q`)** | A vector of independent variables that parameterizes the  configuration of the system at multiple levels (e.g., joint angles, prismatic displacements). |
| **Generalized Coordinate (`Qdot`)** | The time derivatives of the `Q` generalized coordinates.. |
| **Generalized Velocity (`U`)** | A vector of independent variables that parameterizes the  velocities in the system at multiple levels. These are often the time derivatives of the `Q` generalized coordinates, but that does not hold true for spherical subhinges.   |
| **Generalized Acceleration (`Udot`)** | The time derivatives of the `U` generalized velocity coordinates. They parameterize the accelerations in the system at multiple levels.  |
| **Generalized Force (`T`))** | The vector of independent variables that serve as the dual of the `U` generalized velocities, and represent the forces on the system. They are referred to as generalized forces since their dot product with `U` has the units of power. Example of generalized forces are torques at the subhinges . |
| **Degrees of Freedom (DOF)** | Number of independent generalized coordinates in the system. |
| **Hinge DOF** | DOF contributed by a single hinge (e.g., 1 for revolute, 3 for spherical). |
| **Zero configuration** | The configuration of the multibody system when all the hinge generalized coordinates `Q` are zero. Imported multibody models are normally created in the zero-configuration. In this configuration the frames for the onode/pnode pair for each hinge are parallel. |
| **Bilateral Constraint** | A bilateral constraint enforces  a algebraic relationship on the relative motion of a pair of bodies. Thus the permitted motion is implicitly restricted by such constraints.  This is in contrast with hinges and subhinges where the permissible motion is explicitly parameterized by the `Q`, `U` etc generalized coordinates.   |
| **Loop Constraint** | A type of *bilateral constraint* that closes a *closed‑chain* (a kinematic loop) in the multibody tree. It enforces that the relative motion between two non‑parent/child frames satisfies a specific relationship (often equality of pose, velocity, or acceleration). |
| **Cut‑Joint Loop Constraint** | A cut‑joint loop constraint is a special type of bilateral loop  constraint where the permissible relative motion can be represented explicitly by a hinge.  Hinges can be replaced by equivalent cut-joint constraints, and this is often done to decompose graph topology systems in a tree system (with hinges) and additional cut-joint constraints where loops have been cut. |
| **ConVel Loop Constraint** | A *ConVel loop constraint* (short for constant‑velocity loop constraint) is a special type of bilateral loop constraint that is applied to a loop (closed‑chain) in a multibody model. Unlike a normal kinematic (position‑level) constraint, a ConVel constraint only enforces a relationship at the velocity and acceleration levels. It does not restrict the bodies’ positions; it only forces a particular component of the relative velocity of two bodies to remain constant (usually zero). |
| **Coordinate Constraint** | A coordinate constraint is a type of bilateral constraint that directly restricts one or more generalized coordinates (the independent configuration variables of the multibody system). Unlike loop  constraints that enforce relationships between body poses and velocities, a coordinate constraint enforces a relationship between pairs of coordinates. Such constraints are used for modeling gears and rack and pinion systems.  |
| **Prescribed Subhinge** | A subhinge  whose `Udot` generalized acceleration  coordinates  are **not** solved by the dynamic equations but are instead **explicitly defined** as a time‑varying function (e.g., a trajectory, periodic motion, or user‑supplied motion law).  |
| **Sub‑tree** | A SubTree is a connected subset of bodies (and the hinges that link them) within a larger multibody system. It is defined by a root body and includes every body that can be reached from that root by following only the joints that belong to the SubTree. The root body itself is not considered part of the subtree. SubTree instances can be used to  limit computations to just the bodies in the subtree. There can be a arbitrary hierarchy of subtrees defined in a multibody system.  |
| **Sub‑graph** | Sub‑graphs are sub‑trees with additional bilateral constraints.There can be a arbitrary hierarchy of subgraphs defined in a multibody system. The multibody system itself is a unique, top-level  special type of subgraph that contains the full set of physical bodies and bilateral constraints defined for the system.  |
| **Node** | A node is  is a special kind of Frame  that is attached to a PhysicalBody. Body nodes often serve as attachment points for sensor and actuator device models.  |
| **Force Node** | A force node is a special kind of Node that is attached to a PhysicalBody and is used to apply a spatial force (force + moment) to that body. It is the mechanism by which external loads are added to the dynamics equations without modifying the body’s internal structure. |
| **Constraint Node** | A constraint node is a special kind of Node that is attached to a PhysicalBody and are used as attachment points for cut-joint and other loop constraints. |
| **Coordinate Provider** | A coordinate‑data provider in {{ kdflex }} refers to entities that have generalized coordinates (`Q`, `U` etc)  associated with them. It includes subhinges for their articulation coordinates, as well as flexible bodies for their deformable coordinates. {{ kdflex }} uses `CoordBase` as the base class for coordinate providers. |
| **CoordData Class** | The CoordData class is a container that manages a group of coordinate‑provider objects (CoordBase instances) in the {{ kdflex }} dynamics framework. It is used to aggregate and manipulate the generalized coordinates (Q, U, etc.) that belong to a set of bodies or sub‑hinges.  |
| **Compound Body** | A collection of rigid (or flexible) bodies associated with a subgraph of bodies  that are **treated as a virtual body** for simulation purposes. The bodies within the subgraph are said to be *embedded* within the compound body.  Compound bodies do not change the dynamics of the system, and are used to add an abstraction option for simplifying the system topology. Unlike rigid and flexible bodies,  compound bodies allow articulation of the internal embedded bodies and thus have variable geometry.   In {{ kdflex }} a compound body is defined by a `CompoundBody` instance. |
 **Body aggregation** | Body aggregation refers to the process of creating a *compound body* by aggregating a set of bodies into a subgraph and creating a compound body to embed them. |


## Multibody properties and algorithms



| Term | Definition |
|------|------------|
| **Minimal Coordinates** | Coordinate representation that contains only the true degrees of freedom, avoiding redundant variables. |
| **Redundant Coordinates** | Representation that includes more variables than necessary (e.g., quaternions for orientation, explicit constraints). |
| **Jacobian matrix** | The Jacobian matrix of a system of equations. In multibody dynamics it maps a vector of generalized coordinates (or velocities) to a vector of Cartesian (spatial) quantities. | 
| **Mass Matrix (${\cal M}(q)$)** | In kdFlex the multibody system mass matrix is the configuration dependent matrix that relates the generalized velocity vector `U` of the entire multibody system to its generalized momentum. The mass matrix also is the matrix that defines the quadratic form for computing the system kinetic energy via $u^* {\cal M} u/2$. Solving the multibody equations of motion for a tree topology system involves the computation of ${\cal M}^{-1} x$ where $x$ contains contributions from Coriolis accelerations, gyroscopic forces, external forces, gravity etc.  |
| **Composite Rigid Body (CRB) Algorithm** | Efficient recursive method to compute the mass matrix ${\cal M}(q)$. |
| **Forward Dynamics** | Solving the equations of motion for the `Udot` generalized accelerations  given the state, and external and generalized forces on the system. |
| **Inverse Dynamics** | Solving the equations of motion for the `T` generalized forces  given the state, and external forces and generalized accelerations on the system. |
| **Hybrid Forward Dynamics** | Hybrid forward dynamics addresses the case where a mix of `Udot` generalized accelerations and complimentary `T` generalized forces are inputs, and the equations of motion need to be solved for the remaining  generalized accelerations and forces as outputs. The hybrid dynamics problem reduces to the regular forward dynamics when the full `T` are the inputs, and to the inverse dynamics problem with all the `Udot` are inputs. {{ kdflex }} implements a version of ABA algorithm for O(N) hybrid dynamics.   | 
| **Recursive Newton–Euler (NE) Algorithm** | Recursively computes inverse dynamics  for tree topology systems. |
| **Articulated Body (AB) Algorithm** | Recursive O(N) method to compute forward dynamics (solve for `Udot` for tree topology systems. |
| **Inter‑body forces** |  In {{ kdflex }} are the equal‑and‑opposite spatial forces that act across the hinges (physical joints) that connect two bodies in a multibody system. They are internal forces—i.e., they do not appear in the external force balance of the whole system, but they are crucial for understanding the loads on each joint and for design‑level analysis. While normally not solved for in the normal forward dynamics procedures,  {{ kdflex }} provides low-cost ways of computing them on demand.  |
| **Multibody state** | The complete set of `Q` generalized configuration and `U` velocity  coordinates that uniquely describe the instantaneous configuration and motion of every body in a {{ kdflex }} multibody system.
| **ODE Solver** | Numerical algorithm (e.g., RK4, implicit trapezoidal) that integrates equations of motion in the form of ordinary differential equations over time. |
| **Equilibration** | An equilibrium is a configuration of the multibody system in which all generalized forces and moments balance so that the system can remain at rest (or move with constant velocity) without any external actuation. In other words, the net acceleration of every body is zero when the system is held in that configuration. Within {{ kdflex }}, equilibration is the process for finding equilibrium configurations.   | 
| **Linearization** | Linearization is the process of approximating the nonlinear multibody dynamics of a {{ kdflex }} model by a linear, first‑order system around a chosen operating point (typically an equilibrium configuration). The resulting linear model is expressed in state‑space form and is the basis for control‑system design, rapid simulation, and system analysis. Such linearization should always be carried out around equilibrium configurations for meaningful results.  |
| **State space model** | A state‑space model is a compact, first‑order representation of a dynamical system that expresses the system’s evolution in terms of a set of state variables and a set of inputs. In {{ kdflex }} it is used to describe the linearized dynamics of a multibody system (rigid or flexible) in a form that is convenient for control‑system design, simulation, and analysis.  |
| **Modal Analysis** | Modal analysis is the process of determining the natural frequencies and the corresponding mode shapes (eigenvectors) of a flexible structure using a linearized model. In {{ kdflex }} it is used to recover system modes and frequencies, and develop reduced order models for control system design and analysis.  |
| **Fully Augmented (FA) Model** | An FA model is a multibody representation in which every physical body is treated as an independent entity. Each body is connected to the root (or ground) by a 6‑degree‑of‑freedom hinge, and no body has any children. The motion constraints on each body are defined solely by a set of bilateral constraints. The generalized coordinates for such models are fully redundant. |
| **Tree Augmented (TA) Model** | A TA model is a compact representation of a multibody system that uses a maximal spanning tree of physical bodies connected by hinges, together with a minimal set of bilateral constraint instances that close any remaining loops.  | 
| **Constraint Embedding (CE) Model** | Constraint embedding is the process of **embedding** constraints directly into a *compound body*. When applied to all the bilateral constraints on the system, the system's graph topology is transformed into a tree topology with a mix of physical and compound bodies. This minimal coordinate constraint embedding model dynamics  can be solved with fast O(N) AB like algorithms.   |
| **Aggregation Subgraph** |  For a list of one or more bilateral constraints, their *aggregation subgraph* is defined as the minimal subgraph that meets the requirements for  embedding the bilateral  constraints within a compound body. |
| **Constraint Kinematics Solver** | In {{ kdflex }} the `ConstraintKinematicsSolver` is a dedicated class that can be used to  solves for the generalized coordinates (`Q`),  the generalized velocities (`U`) and generalized accelerations (`Udot`)that satisfy a set of bilateral constraints imposed on a subgraph. | 
| **Tree-Augmented (TA) dynamics** | A 2-pass recursive forward dynamics algorithm for solving the equations of motion in the presence of explicit bilateral constraints. This method is an alternative to the constraint embedding approach for solving the dynamics of constrained multibody systems. |
| **Operational Space Compliance Matrix (OSCM)** | The OSCM is the the system mass matrix inverse reflected to the task space and is defined as $J{\cal M}^{-1} J^*$. {{ kdflex }}  provides a low-cost recursive algorithm for computing this important quantity for solving  equations of motion under constraints, as well as in robotics for whole-body motion control. |

<!--


| Term | Definition |
|------|------------|


| **Spatial Momentum** | A **6‑vector** that bundles the **angular momentum** and **linear momentum** of a body with respect to a given reference frame:  
  \[
  \mathbf{h} = \begin{bmatrix} \mathbf{L} \\ \mathbf{P} \end{bmatrix} ,
  \]  
  where \(\mathbf{L} = I\,\boldsymbol{\omega}\) is the angular momentum (with \(I\) the spatial inertia) and \(\mathbf{P} = m\,\mathbf{v}\) is the linear momentum (with \(m\) the mass and \(\mathbf{v}\) the linear velocity).  In {{ kdflex }} spatial momentum is handled by the `SpatialForce` class and appears in the **Newton–Euler** equations as the time derivative of the momentum vector. |
| **Relative Jacobian** | The Jacobian that maps **joint velocities** to the **velocity of a point or frame expressed in another frame**.  For a relative motion between an *origin* frame (`oframe`) and a *destination* frame (`pframe`) the relative Jacobian \(J_{rel}\) is defined such that:  
  \[
  \dot{\mathbf{x}}_{rel} = J_{rel}\,\dot q ,
  \]  
  where \(\dot{\mathbf{x}}_{rel}\) is the spatial velocity of `pframe` relative to `oframe`.  {{ kdflex }} computes relative Jacobians by recursively propagating the **spatial‑motion Jacobian** of each `DynamicNode` and then subtracting the transforms to obtain the velocity expressed in the correct reference frame.  The relative Jacobian is used by the **constraint kinematics solver** (for velocity‑level constraints) and by the `TreeAugmentedModel` when evaluating the term \(\dot J_c \dot q\). |



| Term | Definition |
|------|------------|
| **Force Node** | In {{ kdflex }} a **ForceNode** is a `DynamicNode` extension that represents an **external spatial force** (torque + wrench) applied to a link.  It contains a `SpatialForce` object and an optional **force‑provider** (e.g., a constant load, a time‑varying actuator, or a contact impulse).  Force nodes are inserted into the tree during model construction or at runtime (e.g., when a new contact is detected).  During forward dynamics they contribute to the right‑hand side of the equations of motion as an external force term \(F_{\text{ext}}\). |
| **Jacobian Generator** | The {{ kdflex }} class (often `JacobianGenerator`) that **constructs Jacobian matrices** for kinematic constraints and for mapping joint velocities to end‑effector or contact velocities.  The generator traverses the `ConstraintNode` hierarchy, collects the relative Jacobians of each constraint, and assembles them into a sparse matrix \(J_c\).  It also supports the computation of the time derivative \(\dot J_c\) for velocity‑level constraint enforcement.  The API typically exposes methods such as `computeJacobian(constraintIndex, outMatrix)` and `computeJacobianDerivative()`. |
| **State‑Space Model** | The {{ kdflex }} representation of a multibody system in the form \(\dot x = Ax + Bu,\; y = Cx + Du\).  Here \(x = [Q^T\;\dot Q^T]^T\) is the state vector, \(A\) is the system matrix derived from linearizing the nonlinear dynamics, \(B\) maps control inputs to state derivatives, and \(C,D\) provide the output mapping.  {{ kdflex }}’s `StateSpaceModel` class supports linearization about an operating point, eigen‑analysis, controllability/observability checks, and model‑order reduction.  It is used for control synthesis, observer design, and system‑level analysis. |
| **Modal Analysis** | The procedure in {{ kdflex }} that computes the **natural frequencies** and **mode shapes** of a flexible body (or a reduced‑order model).  The analysis solves the generalized eigenvalue problem \(K \phi = \omega^2 M \phi\) where \(K\) and \(M\) are the body’s stiffness and mass matrices.  {{ kdflex }} implements this in `ModalAnalysis`, which returns a list of **modal vectors** \(\phi_i\) and their corresponding eigenvalues \(\omega_i\).  The mode shapes are stored as `ModalCoordinate` objects that can be used in modal reduction or in the assumed‑mode formulation. |
| **Modal Coordinates** | The **generalized coordinates** expressed in the modal basis.  If a flexible body’s displacement \(\xi(t)\) is expanded as \(\xi(t) = \sum_{i=1}^{N} q_i(t)\,\phi_i\), then the scalars \(q_i(t)\) are the **modal coordinates**.  {{ kdflex }}’s `ModalCoordinates` class manages the transformation \(Q = \Phi\,q_{\text{modal}}\) (with \(\Phi\) the matrix of retained mode shapes) and its inverse, enabling efficient simulation of large‑scale flexible systems with a modest number of DOFs. |
| **Constraint Nodes** | The {{ kdflex }} objects that **represent kinematic constraints** in the multibody graph.  Every loop closure, bilateral, bilateral‑prescribed‑motion, cut‑joint, or contact constraint is embodied by a `ConstraintNode` (derived from `DynamicNode`).  Constraint nodes supply:  * the **constraint Jacobian** \(J_c\) (via `getConstraintJacobian()`),  * the **velocity‑level right‑hand side** \(v_c\) (e.g., zero relative velocity for a cut‑joint), and  * the **acceleration‑level term** \(a_c\).  They are embedded into the solver by a `ConstraintEmbeddingNode` or by the `TreeAugmentedModel`. |
| **Virtual Root Body** | A **fictitious root** (`VirtualRootBody`) that {{ kdflex }} inserts between two or more disconnected subtrees when a global constraint (e.g., a global bilateral or loop) must be enforced.  The virtual body has zero mass and inertia but serves as a reference frame for the constraint Jacobian.  All constraint nodes that involve multiple subtrees attach to the virtual root, allowing the solver to treat the entire system as a single connected tree while still respecting the separate kinematic structures of each subtree. |
| **Assumed Modes** | The **reduced‑order modeling assumption** used in {{ kdflex }} to describe flexible‑body deformations as a finite linear combination of pre‑computed mode shapes:  
  \[
  \xi(t) \approx \sum_{i=1}^{N_{\text{mode}}} q_i(t)\,\phi_i .
  \]  
  The set \(\{\phi_i\}\) is obtained from modal analysis and is stored in `AssumedModes`.  The assumption reduces a large sparse system to a compact set of **modal coordinates** \(q_i\), thereby preserving the essential dynamics (e.g., bending, torsion) while dramatically lowering computational cost.  {{ kdflex }} uses `AssumedModes` in its flexible‑body solvers (`FlexibleBodyDS`, `ReducedOrderModel`) and in the `ModalCoordinates` transformation. |



| Term | Definition |
|------|------------|
| **DataStruct** | In {{ kdflex }} the **DataStruct** class (often instantiated as `DataStruct`) is the container that holds the **static (model) data** of a multibody system: the list of `Frame` objects, the list of `Edge` (joint) objects, the contact manifold descriptors, and any prescribed‑motion or force‑provider objects.  It is the input to the `MultibodyDSFactory`, which translates the `DataStruct` into the runtime `DynamicNode` hierarchy used for simulation.  The name “DataStruct” follows {{ kdflex }}’s naming convention for “data structures” that are **immutable** once the system is constructed. |
| **Kinematics Analysis** | The set of {{ kdflex }} routines that compute **joint positions, velocities, and accelerations** from a given state or control input, without solving the dynamic equations.  The `KinematicsAnalysis` class uses the **recursive forward–backward** traversal of the `DynamicNode` tree to evaluate the **forward Jacobian** \(J\) and its time derivative \(\dot J\).  It also evaluates **constraint kinematics** (relative velocities, accelerations) via the `ConstraintKinematicsSolver`.  Kinematics analysis is typically invoked during control or trajectory‑planning phases where the dynamic forces are not required. |
| **Coordinate Partitioning** | The technique of dividing the generalized coordinates \(q\) into **independent** and **dependent** sets according to the constraints.  In {{ kdflex }} the `CoordinatePartitioner` class analyzes the constraint Jacobian \(J_c\) and performs a **reduced‑row‑Echelon** factorization to identify which coordinates are free and which are fixed by the constraints.  The resulting partition is used to reduce the dimensionality of the dynamic equations, enabling the **Tree‑Augmented** or **Fully Augmented** solvers to operate on the minimal set of independent coordinates while still accounting for all constraint forces. |



poseGradient

for U mention quasi-velocities





## Software interface

- Python Interface: A comprehensive interface  that allows users to set up and interact with {{ KDFLEX }} simulations using Python scripts. 

- KClick 

## Kinematics

- Jacobian 

- Constraint kinematics solver 

## System modeling

- State propagator 

- Scheduler 

- Events 

- KModel 

- Multi-rate simulation 

- Ktime 

- Step, hop, pre/post deriv methods 

- Integrator soft and hard resets 

- Activating and deactivating models 

- Rotation Vector

## Flexible bodies

- Assumed modes 

- Small deformation dynamics 

- Onodes and pnodes 
- Nodes, force nodes, constraint nodes 
- Jacobian generator 

- modal coordinates

## Scene, geometry, visualization

- Stick figure 
- ProxyScene, WebScene, CoalScene
- SceneNode, ScenePart
- WebUI

- Scene layer


## Architecture

- Finalization 

- Data caches, lazy evaluation

- Not healthy/Healthy notions 


- DataStruct 


!-->