A Scenario-Based Visual Modeling Method for the Complex Products Lifecycle

Abstract

The development of complex products is challenged by diverse requirements, interdisciplinary coupling, intricate behaviors, and prolonged lifecycles. Traditional document-based systems engineering methods exhibit deficiencies in requirement validation, architectural verification, and cross-disciplinary integration, struggling to support early-stage verification and validation as well as interdisciplinary collaboration. To address these limitations, this paper proposes a scenario-based visual modeling method for the entire lifecycle of complex products, aiming to realize a closed-loop process epitomized by “construction as verification.” This method integrates model-based systems engineering, scenario-driven design, and multi-level visualization techniques to construct a multi-paradigm visual modeling and simulation framework driven by operational scenarios, use-case scenarios, and working-condition scenarios, each serving as the blueprint for constructing the corresponding Operational Concept, Functional/Logical, and Physical Specification Models. Concurrently, a semantic integration mechanism based on hybrid ontologies is introduced, which resolves semantic heterogeneity and facilitates model interoperability among multi-source heterogeneous models through formalized mapping. Furthermore, a simulation engine scheme based on Discrete Event System Specification is proposed to enable continuous verification from conceptual design to solution development. A case study on the braking mechanism of a high-speed train demonstrates that the proposed method can effectively support precise requirement validation, logical architectural verification, and multi-solution trade-off analysis, thereby significantly enhancing early verification capabilities and R&D efficiency.

1. Introduction

Complex products, such as aerospace vehicles, large-scale naval vessels, and high-speed trains, are regarded as a concentrated embodiment of a nation’s industrial foundation and technological prowess, representing the pinnacle of the modern industrial system. Such products typically exhibit characteristics including high technological density, tightly coupled subsystems, long iterative development cycles with multiple rounds, and high lifecycle costs [1]. The systems engineering process involved in their development necessitates deep collaboration across multiple disciplines like mechanical, electrical, hydraulic, control, and software engineering, manifesting a high degree of systemic complexity. Traditional document-centric, “waterfall” or V-model serial development paradigms rely heavily on the individual experience and domain knowledge of designers, possessing inherent deficiencies in requirements communication, architectural verification, and multidisciplinary collaboration [2]. This often leads to ambiguous requirement interpretation, late detection of design errors, and “siloing” phenomena among heterogeneous disciplinary models, making it difficult to meet the demands for rapid iterative solutions and technological innovation under market competition. Consequently, these traditional approaches have become a bottleneck constraining the innovation efficiency and quality of complex products.

To systematically address these challenges, model-based systems engineering (MBSE) has emerged as an effective methodology for managing complexity. Emphasizing formal, executable models as the single, authoritative source of truth for system requirements, design, analysis, and verification, MBSE is increasingly becoming the core paradigm for complex product development [3]. MBSE advocates a model-centric approach that spans lifecycle activities—from requirements and design to analysis and verification—replacing traditional, disparate documents. Its goals are to enhance communication efficiency, ensure data consistency, and enable early-stage verification [4]. The International Council on Systems Engineering (INCOSE) has unequivocally stated in multiple editions of its Systems Engineering Handbook that MBSE is a central direction for the future of systems engineering, marking a profound transformation in the field from a “document-centric” to a “model-centric” paradigm.

By improving the precision, consistency, and traceability of information, MBSE supports early and repeated verification and validation, aligning with the engineering demands of complex products for “incremental iteration, dynamic planning, risk management, continuous integration, and frequent validation.” Within the practical framework of MBSE, how to construct and manage a model system that covers different abstraction levels and disciplinary domains constitutes a current research hotspot and challenge. The model system for complex products inevitably exhibits a multi-paradigm characteristic, primarily manifested at three levels: the Operational Concept Model, describing system operation scenarios within the intended environment; the Functional/Logical Model, defining system functionality and logical architecture (commonly using Systems Modeling Language, SysML [5]); and the Physical Specification Model, characterizing the multi-disciplinary behavior and performance of underlying physical components (commonly using the multi-disciplinary unified modeling language Modelica [6]). These models collectively constitute a multi-paradigm model system.

Although significant progress has been made in modeling and simulation technologies for single paradigms, achieving seamless integration and collaborative verification across these heterogeneous modeling paradigms remains a prominent bottleneck in both research and engineering practice. This practical bottleneck primarily manifests as two scientific challenges:

The first is the semantic heterogeneity problem. Different paradigm models use terminology and representations specific to their respective domains, creating a gap between “same name, different meaning” (homonymy) and “different name, same meaning” (synonymy) [7]. This hinders precise interactions between models. For instance, how can a system model (SysML Logical Model) seamlessly interface and translate with specialized disciplinary simulation models (e.g., Modelica models for mechanics and controls) in a semantically consistent manner?

The second is the integration and verification lag problem. Due to the lack of effective integration mechanisms, verification of overall system-level behavior often relies on late-stage physical prototype integration testing. This leads to late problem discovery and exorbitantly high change costs [8].

Addressing these issues, existing research has predominantly focused on in-depth development and optimization within specific phases or for single-paradigm models. Examples include using SysML for system function and logical architecture modeling [9], employing multi-disciplinary unified modeling languages like Modelica for physical system simulation [10], and constructing immersive operational concept prototypes based on Virtual Reality/Augmented Reality (VR/AR) technologies [11]. However, a crucial scientific question remains inadequately resolved: a comprehensive, integrated methodology that seamlessly connects the entire chain from “operational scenarios, functional logic, to physical specification” and supports continuous visual verification is still lacking. This results in potential information flow discontinuities from operational concepts to solution implementation, preventing the true realization of “construction as verification.” Therefore, the key design challenge lies in resolving the semantic consistency and technical interoperability issues of multi-paradigm models to support continuous, traceable integration and verification throughout the complex product lifecycle.

The novelty of this approach lies not in any single technique—each has been explored individually in prior work—but in their systematic integration into a coherent methodological framework that addresses the information flow discontinuity problem. As demonstrated in the comparative analysis presented in Section 2.4 (

Table 1. Comparative Analysis of Modeling and Simulation Approaches for Complex Products.

Dimension	Document-Based Traditional	SysML-Only Modeling	Modelica-Only Simulation	VR/AR Concept Visualization	MBSE +Simulation	Our Proposed Method
Lifecycle Coverage	Requirements only	Requirements → Architecture	Implementation → Verification	Requirements only	Requirements → Architecture +Implementation(disconnected)	Requirements → Architecture →Implementation →Verification (continuous)
Model Paradigms Integrated	None(text only)	Single paradigm (SysML only)	Single paradigm (Modelica only)	Single paradigm (3D visualization only)	Two paradigms (SysML + Modelica) but manually integrated	Three paradigms (Operational+Logical+ Mathematical) with automated integration
Semantic Interoperability	Not applicable	Not applicable (single tool)	Not applicable (single tool)	Not applicable (single tool)	Manual mapping, error-prone	Hybrid-ontology based automated semantic mapping
Verification Approach	Static (manual review)	Static (model checking)	Dynamic (simulation only)	Static (visual inspection)	Mixed but disconnected	Dynamic, continuous, co-simulation across all paradigms
Traceability Support	Manual trace matrices	Within SysML only	None to requirements	None to formal models	Partial, manually maintained	Automated traceability through ontology mappings
Visualization Capability	Text and static diagrams	Static diagrams only	Numeric plots and curves	Immersive 3D visualization	Separate visualizations, no integration	Integrated 3D visualization driven by simulation results
Early Validation Enablement	Low (discover issues late)	Medium (logic errors only)	Low (requires complete design)	Medium (operational concept only)	Medium (disconnects cause late issues)	High (continuous validation from concept to physics)

), the study uniquely combines full lifecycle coverage, multi-paradigm model integration, semantic interoperability, and executable verification in a single unified framework.

To this end, this paper integrates scenario analysis, multi-level visualization technology, formal ontology, and parallel discrete event simulation technology, and deeply fuses them with the core MBSE process to propose a visual modeling and simulation method for the entire lifecycle of complex products. The main contributions of this paper are as follows:

• Proposing a hierarchical, multi-paradigm model visual construction framework driven by three types of scenarios (operational, use-case, working-condition), clarifying the evolution relationships and verification focuses of models at each level.
• Designing a semantic integration and interoperability mechanism based on hybrid ontologies, providing a systematic solution to the first core scientific challenge (semantic heterogeneity).
• Proposing an integrated simulation engine scheme based on Discrete Event System Specification (DEVS), providing a technical implementation pathway to address the second core scientific challenge (integration verification lag), supporting visual, continuous verification through multi-model collaboration.

The rest of the paper is structured as follows: Section 1 elaborates on the overall framework of the proposed visual method for the complex product lifecycle. Section 2 details the scenario-based visual construction method for the three types of model. Section 3 explains the model integration method based on ontology and key interoperability algorithms. Section 4 introduces the integrated simulation technology based on discrete events. Section 5 conducts a case study and simulation verification using the braking mechanism of a high-speed train as the subject. Finally, the paper concludes and discusses potential directions for future research.

2. Visual Methodology Framework for the Complex Product Lifecycle

2.1. Visual Modeling Framework

The development of complex products can be deconstructed along three orthogonal dimensions: the System Hierarchy Dimension, the Lifecycle Dimension, and the Model Type Dimension. The core challenge lies in ensuring the continuous, consistent, and unambiguous flow of information across these three dimensions. Consequently, an integrated modeling and simulation approach capable of seamlessly bridging different levels, phases, and disciplines is required. Given the multi-dimensional and multi-layered nature of complex product development, a systematic theoretical framework is essential. To systematically address these development challenges, this paper, grounded in MBSE methodology and systems engineering best practices, proposes constructing a framework for complex product development based on the following three orthogonal dimensions. These three dimensions together form a comprehensive framework for complex product development, as illustrated in Figure 1:

• System Hierarchy Dimension: A four-layer “System–Subsystem–Module–Component” architecture is adopted. This structure aligns with the definition of system hierarchical decomposition found in standards such as ISO 15288 [12], enabling clear expression of the compositional relationships and interface characteristics within complex products. For example, in a high-speed train system, the complete train constitutes the system level; components like the bogies and carbodies form the subsystem level; functional units such as the braking control module and traction module constitute the module level; and finally, specific mechanical and electrical parts compose the component level.
• Lifecycle Dimension: This dimension follows the “Requirements–Architecture–Implementation–Operation” phase delineation. It reflects the evolution of the system from concept to physical entity. The requirements phase clarifies functional and performance specifications; the architecture phase defines structural and behavioral constraints; the implementation phase involves design, development, and manufacturing; and the operation phase encompasses system runtime service and support. Research indicates that this four-phase division effectively supports the full lifecycle management of complex products.
• Model Type Dimension: A three-category model system of “Operational Concept–Functional/Logical–Physical Specification” is established. These model types correspond to distinct abstraction levels and descriptive emphases: Operational Concept Models describe system behavioral performance within the intended environment; Functional/Logical Models define the system’s functional composition and logical relationships; and Physical Specification Models describe system physical behavior through mathematical formalisms.

2.2. Scenario-Driven Visual Methodology

Scenario-driven product design is a user-centered design paradigm. Its core principle is to guide design decisions by constructing and analyzing the interaction processes between users and products within specific contexts. In this methodology, a scenario is defined as a narrative structure used to depict the sequence of interactions a user executes to achieve a particular goal. It typically encompasses the key elements of the 5W1H framework—Who (participants), When (time), Where (location), How (behavior/means), Why (purpose/task), and What (goal). This approach integrates user research, narrative construction, and interaction design, aiming to develop products that more closely align with user needs and usage contexts, thereby enhancing the intuitiveness and effectiveness of design outcomes.

Traditional text-based scenario descriptions suffer from issues such as incomplete information representation, interpretive ambiguity, and limited decision support capabilities. With the advancement of model-driven engineering, visualization technologies based on multi-level models offer a new technical pathway for complex product design. The development framework for complex products typically involves three levels of models: Operational Concept, Functional/Logical, and Physical Specification. Therefore, integrating scenario-driven design methods with multi-level model visualization technology becomes a key strategy to address complex product design challenges. Following the top-down refinement sequence of the aforementioned three model types, this paper systematically elaborates on the integrated application of scenario-based visualization technology throughout the entire model development lifecycle.

The proposed modeling framework employs “scenarios” as the driving force for developing the three core model types. Their logical relationship is illustrated in Figure 2. As illustrated in Figure 2, the proposed framework is structured around three synergistic layers. The bottom layer, ‘Multi-Paradigm Visual Modeling,’ is driven by three distinct scenario types: operational scenarios guide the construction of the Operational Concept Model for intuitive requirements capture; use-case scenarios drive the development of the Functional/Logical Model using SysML for architectural definition; and working-condition scenarios underpin the Physical Specification Model in Modelica for multi-disciplinary performance analysis. The middle layer, ‘Ontology-Based Multi-Paradigm Model Integration and Interoperation Method,’ serves as the semantic backbone. It resolves semantic heterogeneity among the three top-layer models through a hybrid ontology approach, ensuring consistent and unambiguous data exchange. The top layer, ‘Discrete-Event-Based Holistic Simulation Technology,’ acts as the execution engine. It provides a simulation bus for unified scheduling, time synchronization, and data-driven co-simulation of the heterogeneous models, thereby enabling the continuous, end-to-end verification that spans from operational concepts to physical specifications.

2.3. Two Key Enabling Technologies: Ontology-Based Semantic Integration and DEVS-Based Integrated Simulation

The development process for complex products spans multiple hierarchical levels, crosses multiple lifecycle phases, and involves diverse model types (Operational Concept, Functional/Logical, and Physical Specification). Therefore, ensuring the continuous transfer and sharing of model data across different levels, phases, and paradigms is critical. Failure to guarantee continuous and consistent data flow can exacerbate the formation of information silos and generate significant information chaos. Hence, research is required into technologies for constructing multi-level ontologies for complex products, techniques for aligning multi-paradigm models with ontologies, and ontology-based semantic backbone technologies to achieve integration and interoperation among multi-paradigm models.

To support the effective operation of the framework described above, the issues of “adhesion” and “execution” among multi-paradigm models must be resolved. This paper introduces two key enabling technologies essential for achieving seamless integration and verification across multi-paradigm models:

• Ontology-Based Semantic Integration Technology [13]: Aims to resolve the semantic heterogeneity problem. By constructing a multi-level ontology framework comprising “Upper-Level Ontology–Domain Ontology–Application Ontology” and establishing mapping relationships between its elements and those of the various paradigm models, a “Semantic Backbone” is formed. This backbone provides a unified semantic interpretation for data exchange between different models, ensuring information fidelity during cross-paradigm transfer. Complementary approaches such as graph neural diffusion networks [14] offer alternative perspectives on handling complex multi-scale relational structures and could further enhance semantic interoperability in future extensions of this framework.
• Discrete Event System Specification (DEVS)-Based Integrated Simulation Technology [15]: Aims to address the integration and verification lag problem. By constructing a DEVS-based simulation bus, it enables unified scheduling, time synchronization, and data-driven execution of models from various paradigms, including those exhibiting continuous and discrete behaviors. This allows multi-paradigm models to operate collaboratively. Consequently, early, continuous, visual verification of overall system behavior can be performed in a virtual environment, realizing a closed loop of “construction as verification” and enabling system-level, visual co-simulation and verification.

Beyond technical integration, complex product development must also address non-functional requirements such as cybersecurity. Following established frameworks [16], these risks should be identified during the requirements phase and propagated through subsequent models.

2.4. Comparative Analysis with Existing Approaches

To precisely position the novelty of our proposed method within the existing research landscape, this section presents a comparative analysis against representative approaches from the literature. The comparison is structured along seven key dimensions that capture the essential capabilities required for comprehensive complex product development:

• Lifecycle Coverage: The phases of the development lifecycle supported (requirements, architecture, implementation, and verification).
• Model Paradigms Integrated: The types of models that can be co-simulated and verified together.
• Semantic Interoperability: The mechanism used to ensure consistent meaning across heterogeneous models.
• Verification Approach: Whether verification is static (manual review and inspection) or dynamic (executable simulation).
• Traceability Support: The ability to maintain links between requirements, design, and verification artifacts.
• Visualization Capability: The fidelity and interactivity of visual representation.
• Early Validation Enablement: The extent to which the method supports verification before physical prototyping.

Table 1 compares our proposed method against five categories of existing approaches identified in the literature review: Document-Based Traditional Methods: Representing pre-MBSE approaches that rely on textual specifications and manual reviews [2,3]. SysML-Only Modeling: Approaches that use SysML for architecture definition but do not integrate with downstream simulation [17]. Modelica-Only Simulation: Approaches focused on multi-disciplinary physical simulation without upstream architecture traceability [6,7]. VR/AR Concept Visualization: Approaches that use virtual/augmented reality for operational concept exploration but lack formal system models [9,11]. Isolated MBSE+Simulation: Approaches that attempt to combine MBSE and simulation but without semantic integration or automated transformation [8,10].

As evident from Table 1, existing approaches excel in specific niches but exhibit significant gaps when considered from a full-lifecycle perspective. Document-based methods lack formality and executability. SysML-only approaches provide architectural rigor but cannot validate physical performance. Modelica-only simulation delivers accurate physics predictions but engages too late to influence architecture. VR/AR visualization offers immersive concept exploration but no connection to formal models. Even attempts to combine MBSE and simulation typically rely on manual, point-to-point integrations that are brittle, labor-intensive, and fail to maintain semantic consistency as models evolve.

The proposed method addresses these gaps through three key innovations that together enable the “construct as verification” paradigm:

• Scenario-Driven Multi-Paradigm Modeling: A systematic approach that derives Operational Concept Models, Functional/Logical Models, and mathematical models from three hierarchical scenario types (operational, use-case, and working-condition), ensuring that each level of abstraction is traceable to validated stakeholder needs.
• Ontology-Based Semantic Integration: A hybrid ontology framework that resolves semantic heterogeneity across paradigms, enabling automated, unambiguous data exchange between tools without manual mapping or custom scripting.
• DEVS-Based Holistic Simulation: A simulation bus architecture that orchestrates multi-paradigm model co-simulation with unified time management, event processing, and semantic translation, supporting continuous verification throughout the development lifecycle.

The combination of these innovations yields a methodology that is not merely an assembly of existing techniques but a fundamentally integrated approach to complex product development. As the comparative analysis demonstrates, our method is unique in its ability to maintain semantic continuity across all three modeling paradigms while supporting executable, visual verification from early conceptual design through detailed physical analysis.

3. Scenario-Based Full-Process Visual Methodology

3.1. Visualizing Operational Concept Models Based on Operational Scenarios

An operational scenario describes the process through which a complex product fulfills its intended functions by interacting with users, operators, and management organizations within its anticipated natural and socio-technical environment.

Operational Concept Models based on operational scenarios are primarily employed for the requirements capture of complex products. By modeling and analyzing the spatiotemporal information within operational scenarios, the operational requirements and architecture of a complex product can be captured and validated intuitively. This aims to construct a visual analysis platform capable of authentically reflecting the operational status of a complex system within its natural environment. This technical architecture integrates three core layers: Integrated Natural Environment Modeling, 3D Product Concept Visualization, and Model Simulation Interaction, forming a complete technical chain from environment construction to product behavior verification. By establishing a unified visualization platform, it facilitates multi-stakeholder understanding of product operational logic in a collaborative environment, assists in identifying potential issues within the operational concept, and enhances the accuracy and consistency of requirement capture and architectural design.

Integrated Natural Environment Modeling [18] provides foundational environmental support for the visualization system. Its technological evolution has progressed from foundational technologies, such as terrain databases, to advanced techniques like Environmental Data Models and Multi-Resolution Representation. As shown in Figure 3, the Integrated Natural Environment Modeling system comprises five interrelated technology areas. Environmental Data Models provide standardized logical structures for defining environmental data content and relationships. Natural Environment Data Representation and Exchange ensures consistent interpretation and lossless transfer of heterogeneous environmental data sources. Natural Environment Databases and Model Libraries serve as authoritative repositories enabling distributed storage, rapid search, and automated scenario generation. Dynamic Natural Environment Simulation addresses runtime environmental effects, including time management and consistency maintenance. Finally, Multi-Resolution Modeling and Simulation balances fidelity and performance through dynamic switching between different levels of detail while maintaining physical and logical consistency. Together, these five areas form a comprehensive technical ecosystem that provides authoritative, consistent, and dynamically adjustable natural environment backgrounds for operational scenario visualization.

3D Product Concept Visualization Technology deeply integrates product design with environmental factors. Through key technologies such as high-precision geospatial data integration, climatic condition simulation, and dynamic lighting calculation, it constructs an immersive visual representation of the product within an authentic environment. This technology achieves not only precise terrain modeling and dynamic meteorological simulation but also incorporates virtual reality (VR) technology to provide an intuitive interactive experience, enabling designers to comprehensively evaluate the interaction between the product and its environment.

Environment and Product Model Simulation Interaction Technology establishes a bidirectional interaction and verification mechanism, covering key aspects such as inter-product communication and product–environment effect calculation. Through three core algorithmic categories—Pose Analysis, Line-of-Sight Analysis, and Proximity Analysis—it enables quantitative assessment of the product’s operational state. Pose analysis predicts motion trajectories based on dynamic models; LOS analysis determines object visibility using multiple techniques; and proximity analysis employs various algorithms to assess spatial relationships between entities. Together, they constitute a comprehensive operational state verification system.

The 3D product concept visualization aligns naturally with the 5W1H framework introduced in Section 2.2. The geospatial environment establishes ‘Where’ the product operates; dynamic climate and lighting simulations define ‘When’ (time and conditions) the operation occurs; the product model itself represents ‘What’ is being visualized; interactive user controls determine ‘Who’ is interacting with the system; and the simulated operational sequences illustrate ‘How’ the product behaves and ‘Why’ certain actions are performed. This alignment ensures that all scenario elements are consistently represented across the visualization layer.

Through the synergistic operation of this three-layer architecture, the technical system provides full-process support from visual presentation to interactive verification of the operational concept, offering effective technical support for the conceptual design and feasibility validation of complex systems.

3.2. Visualizing Functional/Logical Models Based on Use-Case Scenarios

A use-case scenario represents an abstracted refinement and formalized expression of operational scenarios. It defines the top-level functionality of a complex product by determining system boundaries, use cases, actors, and their interactions. Scenario techniques are then applied to formally describe the behavior of each use case. From this, system structure, interfaces, states, constraints, and other information are analyzed to define the system architecture.

Functional/Logical Models based on use-case scenarios are primarily used for the architecture definition of complex products. By modeling and analyzing the behavioral structure of use-case scenarios, the system requirements and architecture of a complex product can be accurately defined and validated. Use-Case Diagrams from system modeling languages are employed to provide an overall description of system functionality, depicting interaction relationships between actors and the system. Here, a scenario is defined as a path of use-case execution, including both main and exceptional paths, establishing a one-to-many “use-case to scenario” mapping. Visualizing system logic and processes through graphical symbols and diagrams not only enhances model comprehensibility but also improves model maintainability and adaptability in response to changing business requirements.

To achieve visual expression and verification of complex system functional logic, this study constructs a systematic methodological framework integrating three stages: “Requirements Analysis–Modeling Expression–Logical Verification.” This method initiates use-case scenarios for requirement capture, achieves structured expression of functional logic through multi-viewpoint SysML modeling, and ultimately realizes visual verification of design logic through model co-simulation.

• System Requirements Analysis Stage: A structured analysis method based on use cases and scenarios is adopted. Through steps including stakeholder identification, system use-case definition, requirement extraction, and the establishment of a requirements traceability mechanism, user interaction scenarios are transformed into formalized functional and non-functional requirements, ensuring the accuracy and traceability of requirement descriptions.
• System Modeling Expression Level: Incorporating MBSE principles, a modeling framework with three layered viewpoints—Operational, Logical, and Physical—is established, as shown in Table 1. The Operational viewpoint describes the interactive behavior between the system and the external environment; the Logical viewpoint defines the internal functional architecture and data flow; and the Physical viewpoint specifies the concrete technical implementation. Each viewpoint is expressed through five types of SysML diagrams: Requirement Diagrams record functional and non-functional requirements; Behavior Diagrams (Activity, State Machine, and Sequence) describe system dynamic processes; Structure Diagrams (Block Definition and Internal Block) define system composition and interfaces; Parametric Diagrams express performance constraints; and Traceability Diagrams establish traceable links between requirements, design, and verification, forming a complete model expression system.
• System Logical Verification Stage: A visual verification technique based on SysML Model Co-Simulation is proposed. This method organizes the system model using a hierarchical, modular architecture. By synchronously executing the system activity diagram, parametric diagrams, and subsystem state machines, it enables the combined verification of interface specifications, behavioral flows, and state transitions. During simulation, the execution of the system activity diagram dynamically modifies properties and triggers the solving of parametric equations, while simultaneously driving subsystem state transitions through signal passing. Interactions between state machines must comply with the interface specifications defined in the Internal Block Diagrams. This multi-model co-simulation can display signal passing, state changes, and constraint satisfaction in real-time during system execution, allowing designers to intuitively identify design flaws such as interface mismatches, logical contradictions, or constraint violations.

Through the organic integration of the above three stages, the Functional/Logical Model visualization method established in this study transforms the traditional document-based design process into an executable, verifiable graphical model development process. This method not only improves the standardization and consistency of complex system functional design but, more importantly, effectively reduces the risk of discovering major design flaws during later integration testing phases through early visual verification, providing reliable technical support for complex system development.

3.3. Visualizing Physical Specification Models Based on Working-Condition Scenarios

A working-condition scenario provides an integrated description of the operational conditions, external excitations, and internal events to which a system is subjected within a specific time interval. This concept offers engineers an analytical framework to study the system’s dynamic response behavior under diverse constraints, thereby guiding system design optimization and performance enhancement.

A Physical Specification Model builds upon the system’s Functional/Logical Model. It employs a multi-disciplinary unified modeling language (such as Modelica) to mathematically formalize the intrinsic principles of the underlying physical components that constitute the system. By addressing coupled multi-physics problems, it enables the simulation and verification of overall system behavior. The core objective of this model is to ensure that the selected implementation technology pathway can simultaneously meet the established functional specifications and performance requirements. Models based on working-condition scenarios are primarily used for the component design of complex products. By modeling and analyzing the engineering principles of system components, the design requirements and constraints of a complex product can be accurately defined and validated. Therefore, the Physical Specification Model primarily consists of two parts:

(1) Multi-Disciplinary/Domain Unified Modeling

To overcome disciplinary barriers and achieve model consistency and integrability, this study employs Modelica as the core mathematical modeling language. Modelica is an equation-based, object-oriented, acausal modeling language, designed from the outset to support unified modeling and simulation of multi-disciplinary physical systems. Its key characteristics ensure effective description of complex system principles: capability for multi-domain unified modeling, covering mechanics, electricals, hydraulics, control, etc.; support for object-oriented and component-based development, facilitating modularity and model reuse; acausal modeling, allowing developers to focus on physical topology rather than solving sequence; and a rich, standardized, and extensible model library as a foundation, suitable for rapid modeling and simulation of complex physical systems.

(2) Key to Model Continuity: SysPhS-Based Automatic Transformation Mechanism

Although Modelica addresses the issue of unified multi-disciplinary modeling, ensuring semantic consistency and information continuity between the SysML system logical model and the Modelica mathematical model remains a critical challenge. To enable continuous information flow from system design to performance simulation, this study adheres to the SysPhS (SysML for Physical Interaction and Signal Flow Simulation) specification [19] published by the Object Management Group (OMG), establishing an automatic transformation mechanism from SysML logical models to Modelica mathematical models.

SysPhS, as a simulation extension of SysML, defines standard stereotypes (e.g., «PhSVariable» and «PhSConstant») for describing physical interactions, signal flows, and mathematical expressions, establishing a mapping bridge between SysML and simulation languages like Modelica.

The SysML-to-Modelica Transformation Mechanism: First, the transformation engine identifies elements within SysML block diagrams that possess specific SysPhS stereotypes. Second, it maps system structure (blocks, internal block diagrams, and connectors) to Modelica class and connect statements. Finally, it maps behavioral constraints (e.g., equations in constraint blocks) to Modelica equation statements. By configuring mapping rules, standard .mo files can be exported for direct simulation verification within the Modelica environment.

The core function of this transformation mechanism is to tightly couple the early-stage system architecture analysis of MBSE with later-stage multi-disciplinary performance simulation. It achieves the transformation from functional/logical semantics to mathematical/physical semantics based on defined rules, ensuring the standardized continuous transfer of system architecture information. Subsequently, through multi-disciplinary co-simulation, it verifies the rationality and correctness of the architecture, guaranteeing consistency between the simulation model and the system design intent.

4. Ontology-Based Multi-Paradigm Model Integration and Interoperation Method

Multi-Paradigm Modeling is a methodology that synthesizes multiple modeling paradigms, aiming to solve the design and analysis problems of complex products by combining different modeling techniques and tools. The development process of complex products spans multiple hierarchical levels and phases, involving models of different abstraction levels, modeling conventions, and development tools, such as Operational Concept Models (constructed in 3D visualization environments like Unity), Functional/Logical Models (expressed in SysML using tools like MagicDraw), and Physical Specification Models (formulated in Modelica using tools like Dymola). These models express various facets of a complex product from different dimensions using diverse formalisms and tool-specific representations.

However, the coexistence of multi-paradigm models introduces a fundamental challenge: semantic heterogeneity. Different modeling languages and tools use different concepts, terminologies, and structures to describe the same or related entities. For example, a “braking force” parameter may be represented as a continuous variable in a Modelica physical model, as a signal flow in a SysML internal block diagram, and as a visual animation property in a Unity 3D scene. Without a mechanism to reconcile these different representations, information cannot flow seamlessly across models, leading to the proliferation of information silos and generating significant information confusion. Consequently, ensuring the continuous, unambiguous flow and sharing of model data across different levels, phases, and paradigms is a critical challenge in the development of complex products.

To address the aforementioned semantic heterogeneity problem of multi-paradigm models, this study proposes a formal ontology-based semantic integration framework. This framework achieves consistent interpretation of models at different abstraction levels by establishing a three-layer ontology structure (Upper-Level Ontology, Domain Ontology, and Application Ontology) and, crucially, provides the mapping mechanisms that enable dynamic interoperability between diverse software tools.

4.1. Multi-Level Ontology Framework

Multi-Paradigm Modeling, as a key enabling technology for complex system development, faces significant challenges in model semantic heterogeneity and integration difficulties. This study proposes a multi-level integration framework based on formal ontologies, which supports the interoperation of multi-paradigm models by establishing a rigorous semantic foundation.

• Upper-Level Ontology Design [20]: Basic Formal Ontology (BFO) is adopted as the conceptual foundation [21]. BFO, based on a realist philosophical stance, rigorously distinguishes between two fundamental categories: Continuants and Occurrents. Continuants characterize entities that persist through time and maintain their identity, such as structural components of a system. Occurrents characterize processes and events that unfold over time, such as behavioral sequences of a system. This ontological commitment provides a unified conceptual basis for models at different abstraction levels.
• Domain Ontology Construction: Professional terminology systems are established based on domain analysis methods. Taking the rail transportation domain as an example, the semantic connotations of domain concepts such as vehicles, tracks, and signals are explicitly defined by extending the core concepts of BFO. Physical objects (e.g., car body and bogie) are classified as Independent Continuants; functional attributes (e.g., load capacity and braking performance) are classified as Dependent Continuants; and operational processes (e.g., acceleration and braking) are classified as Occurrents. This classification system ensures the formalized expression of domain concepts. The ontology for the rail transportation domain is illustrated in Figure 4.
• Application Ontology Instantiation: Following the Model-Driven Architecture (MDA) approach and based on the complex product system modeling framework shown in

  Table 2. Systems engineering architectural perspectives and corresponding views.

  Perspective (Aspect)	Requirement View	Behavior View	Structure View	Parameter View	Traceability
  Operational	Operational Requirement	Operational Behavior	Operational Structure	Operational Parameter	Operational Requirement Traceability
  Logical	Logical Requirement	Logical Behavior	Logical Structure	Logical Parameter	Logical Requirement Traceability
  Physical	Physical Requirement	Physical Behavior	Physical Structure	Physical Parameter	Physical Requirement Traceability

  , a three-layer mapping mechanism among Operational Models, System Models, and Component Models is established [22]. Operational Models describe the interactive behavior between the system and its environment from an external viewpoint, corresponding to Occurrents in BFO. System Models describe the functional structure of the system from an internal viewpoint, corresponding to Independent Continuants. Component Models describe specific technical implementations from a realization viewpoint, corresponding to Dependent Continuants. This explicit semantic mapping ensures consistency among models at different abstraction levels.

4.2. Multi-Level Ontology Development for Complex Products

This paper proposes a multi-level ontology framework for complex products, aiming to efficiently manage and express vast and complex domain knowledge in a layered manner. This framework, while ensuring knowledge generality and portability, provides precise semantic support for specific application scenarios, thereby effectively enhancing interoperability between systems and promoting cross-disciplinary integration and research. The construction of this framework is a systematic engineering effort. Its core lies in integrating knowledge engineering, semantic web technology, and domain expertise, realized through an iterative process encompassing goal definition, upper-level ontology selection, domain/application ontology development, implementation validation, and continuous maintenance. The key steps in constructing this ontology development framework include the following:

• Goal and Scope Definition: Clarify the core purpose of the ontology, the problems to be solved, and the knowledge boundaries.
• Upper-Level Ontology Integration: Evaluate, select, or customize a general upper-level ontology (e.g., DOLCE or BFO) to establish a foundational semantic model and guarantee interoperability.
• Domain Ontology Development: Collaborate with domain experts to extract key concepts and relationships, constructing a hierarchical domain knowledge model based on the upper-level ontology.
• Application Ontology Instantiation: For specific application scenarios, refine domain ontology concepts and inject instance data to achieve contextualized application of knowledge.
• Formal Implementation and Verification: Implement the ontology using standard languages (e.g., OWL) and tools (e.g., Protégé) [23], and perform validation through logical consistency checking and utility evaluation.
• Continuous Maintenance and Evolution: Establish an iterative update mechanism to enable the ontology to adapt to the evolution of domain knowledge and technological environments.

4.3. Semantic-Oriented Data Integration and Interoperation

Data heterogeneity primarily manifests in three forms: structural heterogeneity, syntactic heterogeneity, and semantic heterogeneity. Structural and syntactic heterogeneities have been relatively well-addressed in traditional data integration approaches. However, semantic heterogeneity remains a challenge for traditional techniques. This is because semantic heterogeneity mainly arises when different data sources across systems use different concepts to describe the same entity (synonym problem), or use the same concept to describe different entities (homonym problem). In the context of multi-paradigm modeling throughout the complex product lifecycle, such semantic conflicts become particularly pronounced.

To address this challenge, this paper proposes a hybrid ontology-based semantic integration and interoperation method. The overall architecture is illustrated in Figure 5. This approach aims to construct a dynamic and extensible integration framework that ensures unambiguous understanding and exchange of model data originating from different modeling tools and development phases (e.g., Operational Concept Models, Functional/Logical Models, and Physical Specification Models). As shown in Figure 5, the architecture consists of three core layers:

• Model Repository Layer: This layer manages three types of core models—Operational Concept Models driven by operational scenarios, Functional/Logical Models (implemented using SysML/MagicDraw) driven by use-case scenarios, and Physical Specification Models (implemented using Modelica) driven by working-condition scenarios. These three model types correspond to distinct design views at different stages of product development.
• Goal and Scope Definition—Semantic Integration Layer: This layer implements an ontology-based global semantic backbone, serving as the “neural center” of the entire architecture. It encompasses the global ontology (defining the shared domain vocabulary) and local ontologies (describing the semantics of each tool-specific model), while maintaining mapping relationships between ontologies through query/rule engines. When model data is transferred across layers, the semantic integration layer ensures precise interpretation and lossless transformation of information.
• Adapter and Proxy Layer: Through tool-specific adapters and PROXY/SERVER mechanisms, this layer handles data publication/subscription (Publish/Subscribe), parsing, assembly, and mapping. It shields the heterogeneity of underlying tools and provides a unified interaction interface for the upper layers, enabling dynamic interoperability among heterogeneous tools.

4.3.1. Hybrid Ontology Integration Architecture

Traditional ontology-based integration methods primarily fall into three categories: single ontology, multi-ontology, and hybrid ontology approachess [24], as illustrated in Figure 6.

The single ontology method employs a global ontology but struggles to accommodate frequent changes in local models. The multi-ontology approach allows multiple independent ontologies but lacks a unified reference, making cross-model comparison difficult. To overcome these limitations, this paper adopts the hybrid ontology method. Its core architecture, as illustrated in the semantic integration layer of Figure 5, comprises the following three components:

• Global Ontology: A shared core vocabulary for the domain is constructed, corresponding to the domain ontology in this paper. It defines the most fundamental and stable concepts and their interrelationships (e.g., “system”, “component”, “function”, “behavior”, and “parameter”) within the complex product domain, serving as the “semantic backbone” of the entire integration framework. The global ontology does not aim for exhaustive domain coverage but focuses on the minimal and complete set of concepts necessary to support model interoperability.
• Local Ontology: An independent local ontology is constructed for each heterogeneous model source (e.g., a specific SysML model or Modelica model), corresponding to the application ontology in this paper. The local ontology precisely describes the concepts, attributes, and relationships specific to that model source. Its terminology must be defined and extended based on the shared vocabulary provided by the global ontology, ensuring that all local ontologies are built upon a unified semantic baseline.
• Mapping Relationships: Explicit and formalized mapping relationships between local ontologies and the global ontology are established and maintained. These mappings define how local concepts correspond to global concepts and are fundamental to achieving semantic interoperability.

4.3.2. Dynamic Interoperation Mechanism

Based on the hybrid ontology architecture described above, this paper further designs a dynamic interoperation mechanism, as illustrated in Figure 5. This mechanism ensures that simulation models can collaborate in a decoupled, semantics-based manner through the simulation integration bus at runtime, rather than through direct point-to-point interactions. The specific process is as follows:

• Semantic Publication: When the state of a simulation node model (e.g., a SysML logical model) changes—such as an attribute value update, an operation invocation, or an event trigger—the change is not sent directly to other nodes. Instead, it is first encapsulated by its adapter into a semantically enriched change event and published to the simulation integration bus via the Publish mechanism.
• Semantic Transformation: The Data Acquisition and Aggregation Layer within the bus performs parsing and assembly of the event. Subsequently, the Data Mapping engine automatically transforms the semantics of this event into a standardized representation based on global ontology, according to the predefined mapping relationships between local and global ontologies. This process achieves “lossless” conversion from tool-specific syntax to unified semantics.
• Semantic Distribution: The transformed standard event is then distributed by the bus, based on its topic and content, to other simulation nodes that have subscribed to such information through the Subscribe mechanism.
• Semantic Interpretation: Upon receiving the distributed standard information, the target node, through its own adapter and utilizing its local ontology along with its mapping to the global ontology, interprets the standard event into specific instructions that its local model can understand and execute, thereby triggering corresponding state updates or behavioral responses.

This mechanism, through the design principle of “local autonomy, global sharing,” achieves dynamic integration and interoperation among multi-paradigm models. It not only ensures semantic consistency during information transfer across different models and tools but also significantly enhances system extensibility. When integrating a new modeling tool, it is only necessary to develop a new adapter, establish a new local ontology, and declare its mappings to the global ontology, without modifying existing models or the core of the simulation bus.

5. Holistic Simulation of Multi-Paradigm Models Based on Discrete Events

Holistic simulation (HS) is a method aimed at simulating an entire system and its environment, rather than focusing solely on a part or individual components. It seeks to capture all significant interactions and dynamic behaviors to more accurately predict system performance and response. The goal of holistic simulation is to reproduce real-world situations as faithfully as possible. Complex product models encompass both continuous and discrete models. Visual simulation is the process of observing and predicting the behavior and performance of complex systems orchestrated under discrete events. The holistic simulation of complex product multi-paradigm models is a key pathway to addressing system-level verification challenges.

Therefore, research into discrete event-based holistic simulation control technology is needed to provide an integrated simulation platform for the continuous integration and frequent validation of multi-paradigm models. Based on Discrete Event System Specification (DEVS) theory, this study constructs a formal framework supporting the co-simulation of multi-paradigm models. It employs a hierarchical abstraction approach encompassing three key technologies: Simulation Data Driving, Visual Resource Scheduling, and Visual Simulation Control, ensuring the credibility of the simulation process through rigorous mathematical definitions.

5.1. Simulation Data Driving

To achieve data interaction among multi-source heterogeneous models, this study designs a semantic-based simulation data-driving architecture, addressing the issues of inconsistent data formats and semantic ambiguity in traditional simulations.

Data Modeling: Based on standardized data representation models such as the Object Model Template (OMT) from High-Level Architecture (HLA), the State Distribution Object from the Test and Training Enabling Architecture (TENA), and the Base Object Model (BOM) from the Simulation Interoperability Standards Organization (SISO) [25], a unified data representation specification is established.

Simulation Data Definition: Utilizing the global ontology (based on domain ontologies) and local ontologies (based on application ontologies), an ontology model management module is developed. This module manages and configures ontology models used in the simulation, supporting the import and export of ontology models in JSON format. Configured ontology model lists can be exported to form template files, and template files can be imported to quickly complete ontology model configurations. Local Ontology Management involves reading, storing, and managing the node models of simulation node software. The system reads instance model data from simulation node software via the simulation integration and interaction bus, storing it within the simulation system, and supports mapping between global and local ontologies. The Global Ontology Management Interface and Local Ontology Management Interface are shown in Figure 7 and Figure 8, respectively.

Data Mapping: An ontology-based semantic transformation method is proposed. By establishing mapping relationships between global and local ontologies, as illustrated in Figure 9, lossless transformation of data from different paradigm models is achieved. This specifically includes three hierarchical mappings: Attribute Mapping, Operation Mapping, and Event Mapping, ensuring semantic consistency of data throughout the transformation process.

To achieve dynamic data interaction among multi-source heterogeneous models during simulation execution, this paper proposes a data mapping method based on Semantic Web technologies. The core idea is that simulation nodes do not engage in direct, hard-coded data exchange but instead collaborate through a shared semantic space in a decoupled manner, thereby achieving “plug-and-play” level interoperability. The implementation of data mapping workflow comprises three key steps:

Step 1: Ontology Mapping: First, a corresponding local ontology is constructed for each simulation node software model. This local ontology serves as a precise semantic mapping of the node model at the ontology layer. Subsequently, formal mapping relationships between the local ontology and the global ontology (i.e., the domain ontology defined in Section 4.3) are established through a combination of semantic similarity calculation and expert validation, as illustrated in Figure 9. These mappings encompass three levels: Attribute Mapping, Operation Mapping, and Event Mapping, ensuring that all node models are aligned with the unified “semantic backbone”.

Step 2: Semantic Publication: During simulation runtime, when the state of any node model changes—such as a temperature attribute change in a physical model, an operation execution in a logical model, or an event trigger in a conceptual model—the node does not send raw data directly to other nodes. Instead, it encapsulates this change information (including change type, value, timestamp, etc.) into a structured semantic change message based on its local ontology and publishes it to the simulation integration bus.

Step 3: Semantic Transformation and Distribution: Upon receiving the semantic change message, the semantic transformation engine at the core of the simulation integration bus immediately operates. According to the “local ontology–global ontology” mapping relationships established in Step 1, the engine automatically “translates” the local concepts in the message into a standardized semantic representation based on the global ontology. For example, an attribute change brakePad.temp from a Modelica model is uniformly converted into a change of the global concept BrakeComponent.Temperature. The bus then distributes this standardized information to other simulation nodes that have “subscribed” to such information (e.g., temperature change events).

Step 4: Semantic Interpretation and Execution: Upon receiving the standardized information distributed by the bus, other simulation nodes perform a reverse “interpretation” using their own local ontologies and their mappings to the global ontology. They convert the information into local instructions or data that their models can understand, thereby driving local model state updates or behavioral execution.

Through this semantic-driven mechanism—which consists of the stages of node publication, bus transformation, and subscription reception—each simulation model achieves fully decoupled interoperability. During the transfer process, data traverses a sequential semantic mapping chain: from the source model, to its local ontology, then to the global ontology, followed by the target’s local ontology, and finally to the target model. This ensures semantic losslessness and precise consistency as information flows across different paradigms and tools.

5.2. Visual Resource Scheduling Strategy

This section designs a Discrete Event-Driven Visual Resource Scheduling Architecture for the coordinated operation and state monitoring of complex product hybrid simulation systems. As shown in Figure 10, this architecture adopts a three-layer progressive design, implementing a closed-loop scheduling process from logical decision-making to physical execution [26].

Three-Layer Progressive Scheduling Architecture: The architecture is divided into three layers from top to bottom. The top layer is the Discrete Event Control Layer, serving as the decision-making hub processing Boolean logic events such as “task start/stop”. The middle layer is the Hybrid Control Layer, responsible for parsing abstract events into continuous control tasks. The bottom layer is the Continuous Execution and Sensing Layer, which drives physical actuators via specialized controllers (e.g., PID) and receives state feedback (e.g., low battery) from sensor networks, triggering new events to form a closed loop.

DEVS Event-Driven and Visual Monitoring: The core scheduling mechanism adheres to the principle of “event-driven, state feedback”. Scheduling logic revolves around events, with the system dynamically adjusting strategies based on events (e.g., low battery alarm) fed back from the bottom layer. All critical data (event sequences, control commands, state trajectories) are pushed in real time to the visualization system, presented in two dimensions: time-dimension curves and space-dimension trajectories. This provides intuitive data support for strategy verification and optimization.

Hybrid System Coordination and Integrated Verification: Through unified time management, this architecture organically integrates discrete event logic with continuous variable control. The visual interface synchronously renders the state of each layer, enabling analysts to intuitively observe the entire process of “event triggering, task scheduling, control execution, and state feedback”. This effectively evaluates whether the scheduling strategy achieves the design intent, providing an integrated solution for the simulation verification of complex systems [27].

5.3. Visual Simulation Control and Time Management

Precise control of the simulation process is crucial for ensuring the effectiveness of holistic simulation. This study establishes a comprehensive simulation control system from three dimensions: Model Management, Process Control, and Time Synchronization.

Model Management: Container-based simulation model encapsulation technology is employed. Simulation models and their dependent environments are packaged into standardized images using Docker containers, enabling rapid deployment and migration of simulation environments. Dynamic loading and unloading of simulation models are supported, enhancing the flexibility of the simulation system.

Process Control: A Finite State Machine (FSM)-based simulation process control mechanism is designed. It defines six basic states: Preparation, Initialization, Running, Paused, Resumed, and Ended. Smooth transitions between states are achieved via event-driven mechanisms. Experiments have proven that this mechanism can effectively handle exceptions during simulation, ensuring simulation reliability.

Time Management: A multi-granularity time advancement model is established. A strict distinction is made among Wall Clock Time, CPU Time, and Simulation Time. A coordinated time advancement algorithm ensures time synchronization across distributed simulation nodes. Specifically, an optimistic time advancement method based on a conservative strategy is adopted, improving simulation efficiency while guaranteeing correctness.

5.4. Mapping Continuous Behavior to Discrete Events

The integration of Modelica’s continuous-time behavior with DEVS discrete-event semantics follows the principle of “continuous computation, discrete observation”. Modelica models execute continuous-time integration, while their interactions with the DEVS simulation bus occur through discrete event messages at specific time points.

Modelica models generate discrete events through three mechanisms, each mapped to DEVS event types via the Event Mapping mechanism: (1) state events from zero-crossing detection when continuous variables cross predefined thresholds; (2) time events scheduled at specific absolute times; and (3) step events from discontinuous parameter changes.

Semantic consistency is preserved through the ontology-based mapping framework (Section 4.3). Each continuous variable in the Modelica model maps to a corresponding global ontology concept via its local ontology. For example, ‘hydraulicPressure.setpoint (MPa)’ maps to ‘BrakingControl.ForceDemand (N)’. When a continuous variable triggers an event, the resulting discrete message carries this semantic information for interpretation by other simulation nodes.

Time synchronization follows a conservative protocol: the bus broadcasts a time advance request to $t_{\mathrm{next}}$ based on the earliest pending events; Modelica integrates continuously to $t_{\mathrm{next}}$ while detecting zero-crossings; all detected events are collected, transformed semantically, and distributed; and nodes update states before the next advance. If a zero-crossing occurs before $t_{\mathrm{next}}$, the solver interrupts and reports the exact event time for resynchronization, accommodating variable-step solvers.

In the emergency braking scenario (Section 6), a discrete EmergencyBrakeCommand from the 3D scenario triggers the SysML logical model to publish control events. The Modelica model receives these events, performs continuous integration of pressure dynamics, and generates a PressureTargetReached event upon zero-crossing detection, which updates the 3D visualization. This mechanism enables integrated verification of discrete control logic and continuous physical responses within a unified framework.

6. Case Verification

6.1. Case Background and Verification Framework

To systematically verify the engineering effectiveness of the scenario-based, full-process visual modeling and simulation method proposed in this paper, the braking mechanism of an Electric Multiple Unit (EMU) is selected as a typical validation object. As a quintessential representative of complex mechatronic systems, its development process perfectly aligns with the three major challenges addressed by this method: complex and variable requirements (involving multiple objectives such as safety, comfort, and precision); tightly coupled system hierarchy and disciplines (covering system, subsystem, module, and component levels, and involving multiple disciplines such as mechanics, fluidics, control, and thermodynamics); and high verification costs with lengthy cycles (traditionally reliant on physical prototype testing). This case aims to explore an innovative R&D pathway supporting early, continuous, and visual verification by constructing a complete digital twin chain covering “Operational Concept–Functional/Logical–Physical Specification”.

The verification work covers four phases: requirements analysis, system design, component design, and virtual integration verification. The case implementation path is clearly divided into four stages, culminating in virtual integration verification through holistic simulation based on discrete events:

• Requirements Design Phase: Construct a 3D visual Operational Concept Model based on operational scenarios for capturing and validating top-level requirements.
• System Design Phase: Develop a SysML-based Functional/Logical Model for defining and verifying the system architecture.
• Component Design Phase: Establish a Modelica-based Physical Specification Model for multi-disciplinary performance simulation and solution trade-off analysis.
• Virtual Integration Verification Phase: Utilize a DEVS-based simulation bus to achieve co-simulation and visual analysis of multi-paradigm models.

Through this framework, two core questions are proposed:

• RQ1: Model Construction and Traceability Capability (Method Feasibility): Can the three-layer models be systematically constructed following a scenario-driven approach while maintaining traceability among them?
• RQ2: Holistic Simulation Decision Value (Method Effectiveness): Can holistic simulation effectively verify the performance of design solutions and provide intuitive visual analysis results to support design verification?

6.2. Construction and Integration of Multi-Level Visual Models

6.2.1. Operational Concept Model: 3D Scenario-Driven Immersive Requirements Review

The goal of Operational Concept Modeling is to transform stakeholders’ vague expectations into unambiguous, verifiable system-level requirements. This case moves away from traditional text and sketches, employing high-fidelity 3D visualization technology to construct a virtual operational scenario encompassing tracks, signaling systems, station environments, and dynamic weather. Focusing on braking functionality, it highlights three key scenario segments: “Preparing for Departure”, “Normal Operation in Section”, and “Approaching Station and Braking”.

• In the “Preparing for Departure” scenario (Figure 11), visualization intuitively displays the spatial layout and initial states of components like the car body, bogie, and wheel set used to review the rationality of interface relationships and maintenance accessibility.
• In the “Normal Operation in Section” scenario (Figure 12), the train’s uniform or cruising motion on the track are simulated. The core verification points of this scenario are: the braking system is in a low-power monitoring state, but its core sensors (e.g., pressure sensors, wear detection) remain operational. Simultaneously, this scenario can be used to demonstrate normal information interaction between the braking system and the traction system and signaling system (e.g., receiving movement authorities and monitoring train integrity), reviewing its continuous monitoring function as the core of overall vehicle safety.
• In the “Approaching Station and Braking” scenario (Figure 13), the entire process of the train decelerating from cruising to stopping precisely aligned at a designated point is realistically simulated through timeline animation control. Reviewers can intuitively observe dynamic phenomena like coupler buffering and car body pitch during braking.

These three figures are not merely illustrative renderings but represent the core of our executable Operational Concept Model. They provide an immersive, interactive 3D environment in which stakeholders can directly observe and validate system behavior across the complete ‘Start–Run–Stop’ operational cycle. This visual validation enables early detection of requirement defects, establishes a shared understanding across multidisciplinary teams, and creates the foundational layer for traceability to subsequent logical and physical models. During the case study, these visualizations were actively used to review operational logic, verify interface completeness, and achieve stakeholder consensus on top-level requirements before proceeding to detailed design. This yields high-quality, comprehensive system operational requirement specifications confirmed by multiple parties, laying a solid, visual foundation for subsequent design.

6.2.2. Functional/Logical Model: SysML Architecture Modeling and Formal Verification Based on Use-Case Scenarios

The goal of Functional/Logical Modeling is to define the system’s structure and behavior, as well as the interactions between components. In the EMU braking mechanism design process, based on the confirmed operational concept, this paper employs SysML for formal architectural modeling of the braking system, including SysML views such as requirement, behavior, and structure models.

Requirements Analysis: Through analysis of the Operational Concept Model, a Requirement Diagram for the Bogie (Figure 14) is constructed, establishing a complete traceability chain from operational goals to technical indicators.

Behavior Modeling: Based on requirements analysis, the bogie’s behavioral model is defined, including use cases during train operation and the flow activities implementing those use cases. Activity Diagrams are used for visual analysis and verification. During Activity Diagram execution, various events are received and generated. By correlating these with events generated in the operational scenario simulation, formal verification and validation of operational logic can be performed. Figure 15, Figure 16 and Figure 17 show the bogie’s Use-Case Diagram and two key Activity Diagrams.

Structure Definition: Based on swimlane partitioning and activity allocation in the flow activities, the basic organizational structure of the bogie is derived, as shown in Figure 18. Further analysis of interactions between swimlanes yields the interface relationships between the bogie’s internal load-bearing subsystem, acceleration/deceleration module, and guidance subsystem, as shown in Figure 19. Further analysis of the acceleration/deceleration module reveals the interface relationships between the drive subsystem, braking subsystem, and traction rod, as shown in Figure 20.

Model Execution Verification: To verify logical correctness, model execution verification was implemented. The “Emergency Brake Trigger” event generated from the operational concept scenario was injected as input into the SysML model. The model execution engine drove state machine and activity diagram execution, producing a series of expected control commands and interface signals. By monitoring and comparing the model’s output command sequence, signal timing, and design specifications in the simulation environment, a redundancy in control logic was successfully identified and corrected at the software level in advance. This verified the correctness of the functional architecture design, achieving a “white-box” level of logic pre-verification.

6.2.3. Functional/Logical Model: SysML Architecture Modeling and Formal Verification Based on Use-Case Scenarios

The goal of physical specification modeling is to precisely describe system behavior and performance using object-oriented, acausal equations. The Functional/Logical Model defines the behavior and interfaces the system should possess, while the Physical Specification Model is used to verify and optimize the performance of its physical implementation. To evaluate the feasibility of the design solution at the physical level, this paper constructs a multi-disciplinary simulation model of the EMU braking system based on Modelica. This is achieved through semi-automatic transformation and component instantiation, starting from the determined system architecture (derived from SysML Internal Block Diagrams). Suitable component sets are then selected from the complex product multi-disciplinary component library to generate multiple mathematical model variants of the complex product. Finally, through simulation and trade-off analysis of each variant, the optimal technical solution is selected. Figure 21, Figure 22 and Figure 23 respectively show the top-level Physical Specification Model of the locomotive, and the Physical Specification Models of the included car body, bogie, and wheel, providing the model foundation for conducting functional-performance simulation of the bogie.

6.2.4. Implementation and Verification Analysis of Discrete Event-Based Holistic Simulation

In the holistic simulation verification of the EMU braking mechanism, the simulation bus constructed based on DEVS theory forms the “Virtual Proving Ground” coordinating the collaborative operation of multi-paradigm models, as shown in Figure 24. Its overall architecture and data flow strictly adhere to the principle of “Event-Driven, State Feedback”: The simulation begins with the user triggering a preset working condition (e.g., “Initiate Emergency Braking”) in the 3D operational concept scenario. This action is instantiated as a standardized discrete event BrakingCommand: Emergency and published by the bus. The SysML Functional/Logical Model, acting as the “Decision Hub”, subscribes to this event, triggering internal state machine transitions and activity diagram execution, thereby generating a control command set with strict timing (e.g., “Apply Maximum Electric Braking”, “Request Air Braking Backup”), which is then published back to the bus as new events.

The simulation bus implements four key functions during this process: Semantic Conversion, Event Management, Time Synchronization, and Simulation Control. Based on predefined ontology mappings, the bus automatically performs semantic alignment of cross-model data, ensuring unambiguous information transfer. Through efficient event ordering and distribution mechanisms, the bus guarantees strict consistency between discrete events and continuous variables in the simulation timeline. The Modelica mathematical model receives control commands, performs multi-disciplinary calculations, and returns continuous physical quantities like braking distance and brake pad temperature to the bus. These finally drive synchronous updates of 3D scene animations and performance curve plotting, achieving a complete closed-loop verification and visual analysis from operational command to physical response.

6.3. Efficiency Comparative Analysis

To quantitatively validate the efficiency gains of the proposed methodology, a controlled experiment was designed and executed within this case study. The experiment aimed to answer the following research question: compared to traditional manual methods, how much improvement in simulation preparation and integration efficiency does the proposed scenario-driven, ontology-integrated framework provide?

6.3.1. Experimental Setup

The experiment was conducted in a standard industrial development environment, involving three experienced system engineers (each with over three years of experience in multi-disciplinary simulation). Each engineer performed identical braking system co-simulation tasks using two different approaches:

Traditional Method: Engineers performed the simulation preparation and integration task using conventional document-based and manual integration methods. This included manually aligning model interfaces between 3D visualization models, Functional/Logical Models (SysML modeled in MagicDraw), and physical models (Modelica modeled in Dymola), manually configuring data exchange formats and protocols, writing custom scripts for data format conversion, debugging integration issues through trial-and-error, and manually documenting the integration process and results.

Experimental Group (Proposed Method): The same engineers performed an identical task using the proposed scenario-driven, ontology-integrated automated framework. This included configuring operational scenarios within the unified visual environment, associating pre-built models (3D, SysML, and Modelica) to the scenarios, triggering the “one-click start” function of the DEVS-based simulation bus, monitoring the automated semantic alignment and data transformation processes, and verifying the resulting co-simulation execution.

6.3.2. Experimental Procedure

Each engineer completed the tasks using both methods in separate sessions, with a one-week interval between sessions to minimize learning effects. The order of method application was randomized across engineers to control for order effects. For each session, the following metrics were recorded:

Total Preparation Time: Time from starting the task to the moment when the co-simulation was successfully launched and produced valid results; Breakdown of Time Consumption: Time spent on specific activities including interface alignment and configuration, data format conversion, debugging and troubleshooting, and documentation; First-Time Success Rate: Whether the co-simulation ran successfully on the first attempt without requiring rework.

6.3.3. Experimental Quantitative Results

The experimental results are summarized in

Table 3. Comparative results of simulation preparation efficiency.

Metric	Traditional Method	Proposed Method	Improvement
Total Preparation Time (person-hours)	15.8	2.2	7.2× reduction
Interface Alignment (h)	6.2	0.3	20.7× reduction
Data Format Conversion (h)	4.5	0.2	22.5× reduction
Debugging & Troubleshooting (h)	3.8	0.4	9.5× reduction
Documentation (h)	1.3	1.3	no change
First-Time Success Rate	33% (1/3 engineers)	100% (3/3 engineers)	67%

. All times are reported as mean values across the three engineers.

6.3.4. Analysis of Results

The experimental data reveal several important insights:

Overall Efficiency Gain: The proposed method reduced total preparation time from an average of 15.8 person hours to 2.2 person hours, representing a 7.2-fold improvement. This gain confirms that the observed improvement is substantial and practically significant.

The most dramatic improvements occurred in activities that were fully automated by the proposed framework:

• Interface alignment: The ontology-based semantic mapping eliminated the need for manual matching of model interfaces across different modeling tools and paradigms.
• Data format conversion: The DEVS simulation bus with built-in semantic transformation handled all data formatting automatically, eliminating the need for custom conversion scripts.
• Debugging: The unified visual environment and automated semantic consistency checking prevented most integration errors before they occurred, significantly reducing trial-and-error debugging time.
• Activity Not Affected: Documentation time remained unchanged (1.3 h in both methods), as this activity still requires engineers to manually record and describe the simulation setup and results for project records and regulatory compliance. This suggests a potential area for future improvement through automated report generation.
• Quality Improvement: The increase in first-time success rate from 33% to 100% indicates that the proposed method not only saves time but also improves reliability. Under the traditional method, two out of three attempts required reworking due to integration errors; with the proposed method, all attempts succeeded on the first try.

6.4. Case Summary and Discussion

Methodology Confirmed: The complete digital design verification chain, from immersive operational scenarios to multi-disciplinary performance simulation, was successfully constructed. This achieved continuous, visual information flow across the three layers of operational scenario, functional logic, and physical specification.

Semantic Interoperability Mechanism Effective: The ontology-based integration framework successfully resolved the data semantic ambiguity among multi-paradigm models, ensuring the accuracy of cross-model data transfer. This is a key technical cornerstone for achieving co-simulation.

Method Value Fully Demonstrated: The DEVS-based holistic simulation not only realized realistic replication of system behavior but, more importantly, its core value lies in advancing design decisions from experience-dependent qualitative judgment to data-driven quantitative trade-off through multi-solution parallel simulation and multi-dimensional visual comparison. This significantly reduces development risk and shortens decision cycles.

Practical Engineering Benefits: The proposed method demonstrates significant practical advantages in engineering efficiency, as validated through controlled experiments detailed in Section 6.3. Under the traditional document-based and manually-integrated subsystem simulation verification model, engineers spent an average of 15.8 person hours on simulation preparation and integration tasks. In contrast, applying the scenario-driven, ontology-integrated automated framework proposed in this paper reduced this time to approximately 2.2 person-hours, representing a 7.2-fold increase in efficiency.

These quantified efficiency gains translate directly into meaningful engineering benefits. The 7.2-fold reduction in simulation preparation time implies a corresponding compression of design iteration cycles and an exponential increase in the frequency of verification activities that can be performed within a given development timeline. What previously required two full working days can now be completed in approximately two hours, enabling multiple design iterations to be performed within a single day and supporting agile development practices. This enables engineers to explore more design alternatives, detect integration issues earlier, and validate performance trade-offs more thoroughly before committing to physical prototyping. Consequently, this approach significantly reduces development risk (by catching defects early) and shortens decision cycles (by providing rapid, data-driven insights for design choices). The method thus provides a practical technical foundation for achieving “high-frequency, short-cycle” agile verification of complex products.

The case demonstrates that the proposed method can establish a “Construction as Verification” digital collaborative environment for complex products. It serves as a powerful tool for advancing MBSE from theoretical frameworks to deep engineering applications and for upgrading the development paradigm of high-end equipment.

6.5. Applicability and Generalizability

The case study presented above focuses on an EMU braking mechanism—a representative complex product characterized by multi-disciplinary coupling, cross-hierarchical integration, and stringent verification requirements. This focus raises an important question: to what extent does the proposed methodology apply to products of lower complexity?

As discussed in Section 1, complex products in this work are defined by five attributes: multi-disciplinary coupling, cross-hierarchical integration, extended lifecycle verification, multi-stakeholder involvement, and high development risk. The proposed methodology is deliberately designed to address these distinctive challenges. Its three core innovations—scenario-driven multi-paradigm modeling, ontology-based semantic integration, and DEVS-based holistic simulation—directly target the problems of multi-level consistency, semantic heterogeneity, and continuous lifecycle verification that arise in complex systems.

However, this emphasis on complex products does not imply limited applicability to simpler products. The core principles—scenario-driven visualization, ontology-based semantic integration, and DEVS-based co-simulation—are fundamentally generalizable and can be applied, either in whole or as a subset, to products of any complexity level. For simpler products, one might implement the following:

• Employ only the scenario-driven visualization for requirement elicitation without full ontology integration.
• Use the SysML-to-Modelica transformation for targeted performance analysis without the complete semantic backbone.
• Adopt a subset of the DEVS simulation bus capabilities for specific verification needs.

The methodology can thus be understood as a scalable framework that provides maximum value where complexity challenges are most acute, while remaining adaptable to less demanding contexts. The EMU case study demonstrates the methodology’s full power in a complex setting, but its constituent techniques can be selectively applied based on project-specific needs.

6.6. Answers to Research Questions

The EMU braking mechanism case study provides clear answers to the two research questions posed in Section 6.1:

RQ1 (Method Feasibility): the proposed scenario-driven approach enables systematic construction of the three-layer models while maintaining explicit traceability among them. The Operational Concept Model was directly derived from operational scenarios. The Functional/Logical Model was developed from use-case scenarios, with requirement traceability explicitly captured in the requirement diagram and behavioral continuity maintained through swimlane partitioning. The Physical Specification Model was transformed from the logical model via SysPhS-based mechanisms, with semantic traceability ensured through ontology mapping between global and local ontologies. The successful end-to-end integration in Section 6 confirms that information flows continuously and unambiguously from operational concepts through functional logic to physical specification.

Answer to RQ2 (Method Effectiveness): holistic simulation based on discrete events effectively verifies design solution performance and provides intuitive visual analysis supporting design decisions. The DEVS-based simulation successfully integrated all three model types, verifying functional correctness through end-to-end execution of the emergency braking scenario. Furthermore, the efficiency comparative analysis quantitatively demonstrates the practical value of the proposed method. The controlled experiment showed that the ontology-integrated framework reduced total simulation preparation time from 15.8 person hours to 2.2 person hours—a 7.2-fold improvement. The most dramatic gains occurred in fully automated activities: interface alignment (20.7× reduction), data format conversion (22.5× reduction), and debugging (9.5× reduction). Additionally, first-time success rate increased from 33% to 100%, confirming that the method not only saves time but also significantly improves reliability by preventing integration errors through automated semantic consistency checking. These quantitative results validate that the proposed method delivers substantial efficiency gains while maintaining or improving quality.

In conclusion, the case study validates both the feasibility and effectiveness of the proposed scenario-based, full-process visual modeling and simulation method for complex product development.

7. Conclusions

This paper addresses key challenges in the development of complex products—namely, multidisciplinary coupling, cross-hierarchical integration, and full lifecycle verification—by proposing a scenario-based, full-process visual modeling and simulation method. The primary contributions are threefold: (1) A three-dimensional modeling framework encompassing system hierarchy, lifecycle phases, and model types was established, enabling visual modeling across the entire lifecycle of complex products. (2) An ontology-based multi-paradigm model integration method was proposed, effectively resolving the semantic heterogeneity issues among Operational Concept Models, Functional/Logical Models, and Physical Specification Models. (3) A discrete event-based holistic simulation technology was developed, supporting the co-simulation and verification of multi-paradigm models.

Nevertheless, this study has certain limitations. The current method requires further enhancement regarding the depth and breadth of multidisciplinary coupling. Future research will focus on exploring the application of artificial intelligence technologies in automated model generation and optimization, thereby improving modeling efficiency.

Additionally, while this study focuses on early-stage verification, the integrated visual models developed through our approach have potential applications as digital twins during the operational phase. Future research will explore real-time synchronization mechanisms, predictive analytics integration, and closed-loop control capabilities to extend the framework’s utility across the entire product lifecycle.

In summary, the method proposed in this paper provides a systematic technical solution for the full-process development of complex products. It demonstrates significant advantages in enhancing development efficiency, reducing development risks, and ensuring system quality, holding substantial theoretical significance and engineering application value.