Functional Mock-up Interface (FMI)

An FMU is a self-contained, compressed ZIP file that packages a dynamic simulation model along with all necessary metadata and binaries. It is the atomic unit of exchange in the FMI ecosystem.

• Structure: Contains an XML model description file, compiled C code binaries for target platforms, and optional documentation and resources
• Self-Description: The XML file declares all variables, parameters, inputs, outputs, and the model's mathematical capabilities
• Platform Portability: A single FMU can include binaries for multiple operating systems and architectures (win64, linux64, darwin64)
• IP Protection: The model is distributed as compiled binaries, allowing suppliers to share high-fidelity models without revealing proprietary source code or internal equations

Model Exchange enables a simulation environment to import and solve a model's equations using its own numerical solvers. The importing tool takes full control of the integration algorithm.

• Mechanism: The FMU exposes a set of differential algebraic equations (DAEs) through a standardized C interface
• Solver Responsibility: The host simulator provides the ODE/DAE solver, calling the FMU's functions to compute derivatives and outputs at each time step
• Efficiency: Eliminates redundant solver overhead when multiple models are integrated into a single simulation environment
• Use Case: Ideal when a tool vendor wants to leverage their own optimized, proprietary solvers for a specific domain like multi-body dynamics or circuit simulation

Co-Simulation allows each FMU to contain its own embedded solver, enabling the coupling of models from different domains where each subsystem advances in time independently and exchanges data only at discrete communication points.

• Solver Encapsulation: Each FMU is a black-box solver that advances its internal state from one communication point to the next
• Master Algorithm: A co-simulation master orchestrates the data exchange and time synchronization between all coupled FMUs
• Variable-Step Support: FMUs can signal the master to reject a step and retry with a smaller step size, enabling robust handling of events and stiff dynamics
• Use Case: Essential for coupling a mechanical multi-body tool with a hydraulic circuit simulator where each domain requires fundamentally different solver strategies

Every FMU contains a mandatory modelDescription.xml file that serves as a machine-readable manifest, declaring the model's interface, capabilities, and structural metadata without executing any code.

• Variable Catalog: Declares all scalar variables with attributes like name, causality (input, output, parameter, local), variability (constant, fixed, tunable, discrete, continuous), and initial value
• Unit Definitions: Specifies physical units for all variables, enabling automatic unit checking and conversion by the importing tool
• Capability Flags: Boolean flags declare optional features like canGetAndSetFMUstate, canSerializeFMUstate, and providesDirectionalDerivative
• Structure: Groups variables into logical model structure sections for outputs, derivatives, and event indicators, aiding tools in generating efficient simulation code

FMI supports saving and restoring the complete internal state of an FMU, enabling advanced simulation workflows like checkpointing, rollback, and iterative co-simulation algorithms.

• FMU State Object: An opaque binary blob that captures the entire internal state vector, including solver memory and event history
• Serialization: The serializeFMUstate function converts the state object into a byte stream that can be persisted to disk or transmitted over a network
• Use Cases: Enables long-running simulations to be paused and resumed, supports Monte Carlo branching from a common checkpoint, and allows co-simulation masters to implement sophisticated step rejection and retry logic
• Deterministic Restart: A deserialized FMU must produce bitwise-identical results when resumed, a critical requirement for debugging and verification

Advanced FMUs can optionally expose directional derivatives and adjoint derivatives, enabling gradient-based optimization and sensitivity analysis directly within the importing tool.

• Directional Derivatives: Compute the directional derivative of outputs with respect to inputs or states, essential for Newton-type solvers and parameter estimation
• Adjoint Derivatives: Provide the reverse-mode derivative, enabling efficient gradient computation for models with many inputs and few outputs, critical for gradient-based optimization and machine learning integration
• Performance: By exposing analytical derivatives, FMUs eliminate the need for slow and inaccurate finite-difference approximations
• Use Case: Enables a digital twin to be used directly inside a Model Predictive Control (MPC) optimizer that requires Jacobian matrices at every time step

The FMI for Model Exchange interface allows a simulation environment to import and solve a model using its own native solver. The FMU contains the mathematical equations (differential, algebraic, and discrete) but no embedded solver. This provides maximum numerical integration flexibility for the importing tool.

• Directional derivative: FMUs expose Jacobian information for efficient implicit solvers
• Event handling: State events and time events are signaled to the host solver
• Use case: Importing a high-fidelity engine model into a vehicle dynamics simulator

The practice of testing and validating industrial control logic against a simulated digital model before physical deployment. FMI enables this by packaging plant models as FMUs that can be connected to real PLCs or soft controllers via Hardware-in-the-Loop (HIL) or Software-in-the-Loop (SIL) configurations.

• SIL: Controller code and plant model run on the same PC, synchronized in virtual time
• HIL: Physical controller hardware interacts with a real-time plant FMU simulation
• Benefit: Reduces on-site commissioning time by up to 80% by catching logic errors early