CRML (the Common Requirement Modeling Language) is a new language for the formal expression of requirements. The ambition is to release the language as an open standard integrated into the open source modeling and simulation tool OpenModelica and interoperable with the open systems engineering standard SysMLv2. CRML allows to express requirements as multidisciplinary spatiotemporal constraints that can be verified against system design by co-simulating requirements models with behavioral models. Particular attention is paid to the following aspects. The requirements models must be easily legible and sharable between disciplines and stakeholders and must capture realistic constraints on the system, including time-dependent constraints with probabilistic criteria, in recognition of the fact that no constraint can be fulfilled at any time at any cost. The theoretical foundation of the language lies on 4-valued Boolean algebra, set theory and function theory. The coupling of the requirements models to the behavioral models is obtained through the specification of bindings, the automatic generation of Modelica code from the CRML model and use of the FMI and SSP standards. CRML and the proposed methodology is compatible with SysMLv2, forming a comprehensive work-flow and tool-chain encompassing requirement analysis, system design and V&V. The final objective is to facilitate the demonstration of correctness of system behavior against assumptions and requirements by building a workflow around Model-Driven Engineering and Open Standards for automating the creation of verification simulators.

As the effects of the climate crisis become increasingly apparent, efforts are made to encourage and nuance discussion on energy system transition for a more sustainable future. One way this is done is through games that combine role-play, board game elements and computer simulations, i.e. megagames. The aim of this paper is to investigate how visualisations and simulations can be used to drive forward such discussions within a megagame.

Contribution: This article identifies the participation of external stakeholders as a key contributing factor for positive outcomes in project-based software engineering courses. A model for overlapping virtuous circles of lasting positive impact on both stakeholders and students from such courses is proposed. Background: Project-based courses are widespread in software engineering education, and there are numerous designs for such courses presented in literature. It is found that the needs and motivations of external stakeholders, from industry and government sectors, in these courses has received limited attention in related work. Intended Outcomes: A course design that prepares students for graduate level studies and professional life, through close proximity to external stakeholders in a highly realistic setting, working on “live” projects. Application Design: Building on a long tradition of university-industry collaboration dating back to 1977, as well as findings in related work, students are assigned to live projects proposed by external stakeholders from industry and government, working in close proximity with their respective stakeholders throughout the project. The course places great emphasis on coaching over instruction, treating the many unforeseen challenges of such projects as a valuable part of the learning experience. Findings: Based on interviews with stakeholders and students, it is found that stakeholder and student outcomes are interdependent and build upon one another, and that positive outcomes for both groups are necessary for the sustainability of the course over multiple iterations.

In the field of model-based design of Cyber–Physical Systems (CPS), seamless traceability of the process, from requirements to models to simulation results, is becoming increasingly important. It can be used to support several activities such as variant handling, impact analysis, component reuse, software maintenance and evolution, verification, and validation. Despite the fact that the relevance of traceability in the model-based design of CPSs is well known, current tools that support traceability management are inadequate in practice. The lack of comprehensive whole-lifecycle systems engineering support in a single tool is one of the main causes of such ineffective traceability management, where traceability relationships between artifacts are still manually generated and maintained. This paper aims at presenting an approach and a prototype for automatically generating and maintaining the appropriate traceability links between heterogeneous artifacts ranging from requirement models, through design models, down to simulation and verification results throughout the product life cycle in model-based design of CPSs. A use case study is presented to validate and illustrate the proposed method and prototype.

Industrial cyber-physical system products interleave hardware, software, and communication components. System complexity is increasing simultaneously with increased demands on quality and shortened time-to-market. To effectively support the development of such systems, we present languages and tools for comprehensive integrated model-based development that cover major phases such as requirement analysis, design, implementation, and maintenance. The model-based approach raises the level of abstraction and allows to perform virtual prototyping by simulating and optimizing system models before building physical products. Moreover, open standards and open source implementations enable model portability, tool reuse and a broader deployment. In this paper we present a general overview of the available solutions with focus on Modelica/OpenModelica, Bloqqi, and Acumen. The paper presents contributions to these languages and environments, including symbolic-numeric modeling, requirement verification, code generation, model debugging, design optimization, graphical modeling, and variant handling with traceability, as well a general discussion and conclusions.

OpenModelica is a unique large-scale integrated open-source Modelica-and FMI-based modeling, simulation, optimization, model-based analysis and development environment.Moreover, the OpenModelica environment provides a number of facilities such as debugging; optimization; visualization and 3D animation; web-based model editing and simulation; scripting from Modelica, Python, Julia, and Matlab; efficient simulation and co-simulation of FMI-based models; compilation for embedded systems; Modelica-UML integration; requirement verification; and generation of parallel code for multi-core architectures.The environment is based on the equation-based object-oriented Modelica language and currently uses the MetaModelica extended version of Modelica for its model compiler implementation.This overview paper gives an up-to-date description of the capabilities of the system, short overviews of used open source symbolic and numeric algorithms with pointers to published literature, tool integration aspects, some lessons learned, and the main vision behind its development.

OpenModelica is currently the most complete opensource Modelica-and FMI-based modeling, simulation, optimization, and model-based development environment.Moreover, the OpenModelica environment provides a number of facilities such as debugging; optimization; visualization and 3D animation; web-based model editing and simulation; scripting from Modelica, Python, Julia, and Matlab; efficient simulation and co-simulation of FMI-based models; compilation for embedded systems; Modelica-UML integration; requirement verification; and generation of parallel code for multi-ore architectures.The environment is based on Modelica and uses an extended version of Modelica for its implementation.This overview paper intends to give an up-to-date brief description of the capabilities of the system, and the main vision behind its development.

Modelica is an object oriented, acausal equation-based language for describing complex, hybrid dynamic models. About ten Modelica implementations exist, of which most are commercial and two are open source; the implementations have varying levels of tool functionality. Many Modelica implementations have limited support for model analysis. It is therefore of interest to integrate Modelica tools with a powerful scripting and programming language, such as Julia. Julia is a modern and free language for scientific computing. Such integration would facilitate the needed analysis possibilities and can speed up the development of effient simulation models. A number of design choices for interaction between Julia and Modelica tools are discussed. Next, Julia package OMJulia is introduced with an API for interaction between OpenModelica and Julia. Some discussion of the reasoning behind the OMJulia design is given. The API is based on a new class ModelicaSystem within package OMJulia, with systematic methods which operate on instantiated models. OMJulia supports handling of FMU and Modelica models, setting and getting model values, as well as some model operations. Results are available in Julia for further analysis. OMJulia is a further development of a previous OMPython package; a key advantage of Julia over Python is that Julia has better support for control engineering packages. OMJulia represents a first effort to interface a relatively complete Modelica tool to Julia, giving access to an open source set-up for modeling and analysis, including control synthesis, easily installable from a unified package manager. Some possibilities of OMJulia are illustrated by application to a few simple, yet industrially relevant problems within control design.

OMSimulator is an FMI-based co-simulation tool and recent addition to the OpenModelica tool suite. It supports large-scale simulation and virtual prototyping using models from multiple sources utilizing the FMI standard. It is integrated into OpenModelica but also available stand-alone, i.e., without dependencies to Modelicaspecific models or technology. OMSimulator provides an industrial-strength open-source FMI-based modelling and simulation tool. Input/output ports of FMUs can be connected, ports can be grouped to buses, FMUs can be parameterized and composed, and composite models can be exported according to the (preliminary) SSP (System Structure and Parameterization) standard. Efficient FMIbased simulation is provided for both model-exchange and co-simulation. TLM-based tool connection is provided for a range of applications, e.g., Adams, Simulink, Beast, Dymola, and OpenModelica. Moreover, optional TLM (Transmission Line Modelling) domain-specific connectors are also supported, providing additional numerical stability to co-simulation. An external API is available for use from other tools and scripting languages such as Python and Lua. The paper gives an overview of the tool functionality, compares with related work, and presents experience from industrial usage.

Shortened time-to-market cycles and increasingly complex systems are just some of the challenges faced by industry. The requirement engineering process needs to adapt to these challenges in order to guarantee that the end product fulfils the customer expectations as well as the necessary safety norms. The goal of this paper is to investigate the way engineers work in practice with the requirement engeneering processes at different stages of the development, with a particular focus on the use of requirements in cross domain development and to compare this to the existing theory in the domain.

This paper describes a new API for operating on Modelica models in Python, through OpenModelica. Modelica is an object oriented, acausal language for describing dynamic models in the form of Differential Algebraic Equations. Modelica and various implementations such as OpenModelica have limited support for model analysis, and it is of interest to integrate Modelica code with scripting languages such as Python, which facilitate the needed analysis possibilities. The API is based on a new class ModelicaSystem within package OMPython of OpenModelica, with methods that operate on instantiated models. Empha-sis has been put on specification of a systematic structure for the various methods of the class. A simple case study involving a water tank is used to illustrate the basic ideas.

For assessing whether a system model is a good candidate for a particular simulation scenario or choosing the best system model between multiple design alternatives it is important to be able to evaluate the suitability of the system model.In this paper we present a methodology based on finite state machine requirements verifying system behaviour in a Modelica environment where the intended system model usage is within a moving base driving simulator.A use case illustrate the methodology with a Modelica powertrain system model using replaceable components and measured data from a Golf V.The achieved results show the importance of context of requirements and how users are assisted in finding system model issues.

Seamless tracing of the requirements and associating them with the models and the simulation results is becoming increasingly important. This can be used to support several activities such as variant handling, impact analysis, component reuse, verification, and validation. This work in progress paper presents an approach for combining traceability with requirement verification in Modelica. Traceability is supported via the OSLC specification standard combined with Git version control system. All operations on artifacts of interest are traced. Currently, the traceability data is stored in a graph database which can be queried for generating various reports such as impact analysis, variant handling, etc.

Modelica is an innovative, equation-based, and acausal language that allows modeling complex physical systems, which are made of mechanical, electrical, and electrotechnical components, and evaluates their design through simulation techniques. Unfortunately, the increasing complexity and accuracy of such physical systems require new, more powerful, and flexible tools and techniques for evaluating important system properties and, in particular, the dependability ones such as reliability, safety, and maintainability. In this context, the paper describes some extensions of the Modelica language to support the modeling of system requirements and their relationships. Such extensions enable the requirement verification analysis through native constructs in the Modelica language. Furthermore, they allow exporting a Modelica-based system design as a Bayesian Network in order to analyze its dependability by employing a probabilistic approach. The proposal is exemplified through a case study concerning the dependability analysis of a Tank System.

ABSTRACTModeling and simulation of complex systems is at the heart of any modern engineering activity. Engineers strive to predict the behavior of the system under development in order to get answers to particular questions long before physical prototypes or the actual system are built and today tested in real life. One of the critical questions is whether a particular system design fulfills or violates requirements imposed on the system under development. In this paper, we discuss an approach to model‐based design verification by simulating system dynamic behavior including formalized requirements. We illustrate the approach on a case study – the verification of a new design for flight control surfaces activation against requirements. The contributions of this paper are the evaluation of a new requirements formalization approach using the recently developed Modelica requirements library, and the discussion of solutions for automating the simulation model composition.

Résumé Modelica est un langage de modélisation qui a été créé afin de faciliter la description de systèmes multi-physiques grâce à une approche orientée objet. Les modèles Modelica représentent habituellement seulement le fonctionnement nominal des systèmes et sont utilisés pour les simuler à des fins de conception. Cet article propose une méthode développée dans le projet européen MODRIO pour obtenir des modèles de fiabilité à partir de ces modèles Modelica, aussi automatiquement que possible. Le principe consiste à associer à la structure du système une bibliothèque écrite en Figaro, un langage de modélisation dédié à la fiabilité. Cette association permet l'utilisation des outils de la plateforme Figaro, spécialement conçus pour l'analyse de la sûreté de fonctionnement ; il est alors possible de générer un arbre de défaillance. Le traitement de l'arbre de défaillance peut donner une évaluation quantitative de la fiabilité du système, mais aussi une liste de scénarios de test pour le modèle de simulation. Chaque coupe minimale de l'arbre de défaillance peut être utilisée comme un «stress test» pour le modèle de simulation détaillé.

Modeling and Simulation methods, tools and techniques aim at supporting the different phases of the lifecycle of modern systems, going from requirements analysis to system design and operation. However, their effective application requires investigating several aspects such as the formal modeling of system requirements and the binding and automated composition between heterogeneous models (e.g. requirements models, architectural models, behavioral models). In this context, the paper presents a new formal requirement modeling language based on temporal logic, called FORM-L, and a software library, based on the Modelica language, that implements the constructs provided by FORM-L so as to enable the visual modeling of system properties as well as their verification through simulation. The effectiveness of the proposal is shown on a real case study concerning an Intermediate Cooling System.