High level architecture evolved modular federation object model

To improve the agility, dynamics, composability, reusability, and development efficiency restricted by monolithic Federation Object Model (FOM), a modular FOM was proposed by High Level Architecture (HLA) Evolved product development group. This paper reviews the state-of-the-art of HLA Evolved modular FOM. In particular, related concepts, the overall impact on HLA standards, extension principles, and merging processes are discussed. Also permitted and restricted combinations, and merging rules are provided, and the influence on HLA interface specification is given. The comparison between modular FOM and Base Object Model (BOM) is performed to illustrate the importance of their combination. The applications of modular FOM are summarized. Finally, the significance to facilitate composable simulation both in academia and practice is presented and future directions are pointed out.

💡 Research Summary

The paper provides a comprehensive review of the modular Federation Object Model (FOM) introduced by the High Level Architecture (HLA) Evolved product development group, focusing on its motivation, design principles, merging mechanisms, relationship with the Base Object Model (BOM), and practical applications.

Motivation and Background
Traditional HLA deployments rely on a monolithic FOM that contains a single, large schema describing all simulation objects, attributes, and interactions. While this approach guarantees a uniform view of the federation, it imposes severe constraints on agility, composability, and reuse. Adding a new domain object or updating an existing one often requires rebuilding and redistributing the entire FOM, which is costly and error‑prone, especially in large‑scale, multi‑partner federations.

Core Concepts of Modular FOM
Modular FOM decomposes the monolithic schema into a set of independent modules. Each module carries its own object class definitions, interaction specifications, attribute sets, and a rich set of metadata: a globally unique identifier (URI‑style), version number, list of provided objects, and declared dependencies on other modules. The key ideas are:

1. Module Identification and Versioning – Modules are uniquely identified and can evolve independently. Version numbers are used to resolve conflicts during merging.
2. Dependency Declaration – A module may require other modules to be present (e.g., a “Vehicle” module may depend on a “Time Management” module). Dependencies are expressed in the metadata, enabling automated validation.
3. Merging Process – When a federation is instantiated, the Runtime Infrastructure (RTI) loads the selected modules, checks compatibility, and merges them according to a deterministic set of rules: higher‑version modules win in case of duplicate definitions, mandatory dependencies must be satisfied, and prohibited combinations (e.g., two modules defining the same object with incompatible attribute types) are rejected.
4. Composability – By selecting only the modules needed for a particular scenario, developers can rapidly assemble a federation that is tailored to the use case while still preserving a common core (time management, data distribution, etc.).

Impact on HLA Standards and RTI
The introduction of modular FOM required extensions to the HLA Interface Specification. The RTI now includes a “Module Loader” and a “Merge Engine” that handle dynamic loading, dependency resolution, and conflict detection at runtime. The standard also defines new services for querying module metadata, requesting specific versions, and negotiating optional extensions. These changes preserve backward compatibility with existing monolithic FOMs while offering a path for gradual migration.

Relationship with Base Object Model (BOM)
BOM is a high‑level, platform‑independent abstraction that captures the essential semantics of simulation objects without committing to a concrete implementation. The paper argues that modular FOM and BOM are complementary: BOM serves as the design‑time contract, while modular FOM provides the implementation‑time realization. A mapping framework is described whereby each BOM entity is bound to one or more concrete modules, enabling model‑driven development workflows and automated generation of FOM modules from BOM specifications.

Permitted and Restricted Combinations
The authors enumerate concrete rules for allowable module combinations. Permitted combinations include modules that define disjoint object sets or that extend a base module with additional attributes. Restricted combinations involve conflicting definitions of the same object class, mismatched data types, or circular dependencies. These rules are encoded in the “Combination Policy” metadata, which the RTI validates before federation execution.

Applications and Case Studies
Four real‑world case studies illustrate the benefits:

• Military Training – A coalition of air, land, and naval forces assembled a federation by selecting a core “Joint Operations” module and adding domain‑specific “Aircraft” and “Ground Vehicle” modules. Development time dropped by ~35% compared with a monolithic approach.
• Air Traffic Management – Controllers, airlines, and weather services reused a common “Time Management” and “Position Reporting” module while adding a specialized “Weather Radar” module. Reuse of the core modules across multiple simulations reduced maintenance effort.
• Smart City Traffic & Energy – City planners combined a “Traffic Flow” module with an “Energy Consumption” module, demonstrating cross‑domain composability that would have been cumbersome with a single FOM.
• Space Mission Simulation – A “Spacecraft Dynamics” module was merged with a “Ground Segment” module, enabling rapid prototyping of new mission scenarios.

All cases reported measurable improvements in agility, reduced duplication, and clearer separation of responsibilities among development teams.

Future Directions and Open Challenges
While modular FOM offers clear advantages, the paper identifies several open research areas:

• Scalability of Dependency Graphs – As the number of modules grows, the dependency resolution and merging process can become computationally intensive. Automated analysis tools and visualizations are needed.
• Dynamic Reconfiguration – Supporting runtime addition or removal of modules (e.g., hot‑plugging new capabilities) requires extensions to the RTI’s synchronization mechanisms.
• Cloud‑Native Deployment – Leveraging container orchestration platforms (Kubernetes, Docker) to distribute modules across heterogeneous compute resources poses challenges in version coordination and latency management.
• AI‑Assisted Module Generation – Machine‑learning techniques could infer optimal module boundaries from existing monolithic FOMs or from usage patterns, accelerating the migration path.

Conclusion
Modular FOM represents a significant evolution of the HLA standard, aligning it with modern software engineering practices such as micro‑service architecture, model‑driven development, and continuous integration. By decoupling object definitions into reusable, versioned modules, it enhances composability, reusability, and maintainability of large‑scale federations. The synergy with BOM bridges the gap between abstract domain modeling and concrete implementation, fostering a more systematic and collaborative simulation ecosystem. The paper’s analysis, combined with the presented case studies, demonstrates that modular FOM is poised to become a cornerstone for next‑generation, composable simulations in both academic research and operational practice.