Search

Nowadays, industrial products are getting increasingly complex, and time-to-market is significantly shorter. Modeling and simulation tools for cyber-physical systems need to keep up with the increased complexity. This paper presents OpenModelica.jl, a modular and extensible Modelica compiler framework in Julia targeting ModelingToolkit.jl and supporting Variable Structured Systems. We extended the Modelica language with three new operators to support continuous-time mode-switching and reconfiguration via recompilation at runtime. Therefore, our compiler supports the Modelica language and variable structure systems via the aforementioned extensions. To our knowledge, there are no other Modelica tools available that support both standard Modelica and variable structure systems. We evaluated our framework using a standardized benchmark suite, in terms of simulation, compilation and recompilation performance. The results concerning compilation and simulation time performance were compared with the results of running the existing OpenModelica compiler with the same set of models. A custom benchmark was devised to estimate the cost in terms of recompilation when simulating variable structure systems. The performance experiments showed that OpenModelica.jl is currently about four times slower in terms of compilation time when compiling a transmission line model with tens of thousands of equations and variables. The difference in simulation performance between the two compilers was negligable. Furthermore, the impact of recompilation during the simulation was usually small compared with the simulation time for long simulations. The results are promising for a prototype, and we outline approaches to further improve both compilation and simulation performance as future research., Funding: Swedish Government via the ELLIIT project; Vinnova via the ITEA3 EMBRACE project; Swedish Strategic Research foundation (SSF)

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. View Full-Text, Funding: Strategic Research Area ELLIIT, funded by the Swedish government, and by Vinnova in the ITEA OPENPROD, MODRIO, OPENCPS, EMPHYSIS and EMBRACE projects. Support has also been received from the Swedish Strategic Research Foundation (SSF) in the LargeDyn project. The OpenModelica development is supported by the Open Source Modelica Consortium.

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., Funding Agencies|Strategic Research Area ELLIIT - Swedish government; Vinnova in the ITEA OPENPRODVinnova; Vinnova in the ITEA MODRIO projectVinnova; Vinnova in the ITEA OPENCPS projectVinnova; Vinnova in the ITEA EMPHYSIS projectVinnova; Vinnova in the ITEA EMBRACE projectVinnova; Swedish Strategic Research Foundation (SSF) in the LargeDyn project; Open Source Modelica Consortium

This paper presents the simulation of electromagnetic transients (EMTs) with Modelica. The advantages and disadvantages are discussed. Simulation performance and accuracy are analyzed through the IEEE 118-bus benchmark which includes EMT-detailed models with nonlinearities. The domain-specific simulator EMTP is used for validations and comparisons.

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., Funding agencies: Vinnova in the ITEA OPENPROD projectVinnova; Vinnova in the ITEA MODRIO projectVinnova; Vinnova in the ITEA OPENCPS projectVinnova; Vinnova in the ITEA EMPHYSIS projectVinnova; Vinnova in the ITEA EMBRACE projectVinnova; Vinnova RTISIM projectVinnova; Vin

Recently the Julia language has become an option for scientific computing. As of 2020, efforts exist to provide libraries that emulate the equation-based modeling features provided by Modelica or otherwise provide such functionality in Julia. The issue with these approaches is that investment in standardization and libraries would be lost unless standard-complacency is guaranteed. We believe that it is possible to combine features from both by implementing such a compiler in Julia. We argue that this approach would open additional opportunities. One such being the handling of variable structure systems (VSS) within the framework of a Modelica standard-compliant compiler. The other being a proposed compiler architecture reminiscent of LLVM for equation-based object-oriented languages. Using the OpenModelica Compiler as a baseline, we verified the fidelity of our implementation by simulating a selected set of models. While there are performance penalties, we argue that improvements to the frontend would mitigate these issues.

The equation-based object-oriented Modelica language allows easy composition of models from components. It is very easy to create very large parametrized models using component arrays of models. Current open-source and commercial Modelica tools can with ease handle models with a hundred thousand equations and a thousand states. However, when the system size goes above half a million (or more) equations the tools begin to have problems with scalability. This paper presents the new frontend of the OpenModelica compiler, designed with scalability in mind. The new OpenModelica frontend can handle much larger systems than the current one with better time and memory performance. The new frontend was validated against large models from the ScalableTestSuite library and Modelica Standard Library, with good results.

The need for integrating system modeling with advanced tool capabilities is becoming increasingly pronounced. For example, a set of simulation experiments may give rise to new data that are used to systematically construct a series of new models, e.g. for further simulation and design optimization. Such combined symbolic-numeric capabilities have been pioneered by dynamically typed interpreted languages such as Lisp and Mathematica. Such capabilities are also relevant for advanced modeling and simulation applications but lacking in the standard Modelica language. Therefore, this is a topic of long-running design discussions in the Modelica Design group. One contribution in this direction is MetaModelica, that has been developed to extend Modelica with symbolic operations and advanced data structures, while preserving safe engineering practices through static type checking and a compilation-based efficient implementation. Another recent effort is Modia, implemented using the Julia macro mechanism, making it dynamically typed but also adding new capabilities. The Julia language has appeared rather recently and has expanded into a large and fast-growing ecosystem. It is dynamically typed, provides both symbolic and numeric operations, advanced data structures, and has a just-intime compilation-based efficient implementation. Despite independent developments there are surprisingly many similarities between Julia and MetaModelica. This paper presents MetaModelica and its environment as a large case study, together with a short comparison to Julia. Since Julia may be important for the future Modelica, some integration options between Modelica tools and Julia are also discussed, including a possible approach for implementing MetaModelica (and OpenModelica) in Julia.

We are investigating ways of introducing just-in-time compilation in a standard-compliant Modelica compiler, the Open-Modelica compiler (OMC). The main motivations are enabling extensions to support dynamically varying model structure, faster compilation, and faster recompilation of models after changes. We are investigating two approaches. The first approach is to adapt the low-level OpenModelica intermediate representation (IR) before code generation to be compatible with LLVM. In that way we can avoid generating intermediate C-code and instead generate LLVM IR in memory for just-in-time compilation (JIT). The second approach is to translate OMC itself written in MetaModelica to Julia, and thereby gain access to the JIT capabilities of LLVM. Another benefit of the second approach is the access to the Julia ecosystem, including a rich set of libraries for numerical computing. We have done a preliminary investigation of both approaches, with measurements on a selected sample of algorithms, and discovered that compilation-time of generated Julia code is slower compared to generating LLVM IR directly. We conclude that providing a standard-compliant Modelica compiler which supports a dynamically varying model structure is feasible and possible, and we believe that such a compiler can be provided by using Julia or MetaModelica.

The ease of use and the high abstraction level of equation-based object-oriented (EOO) languages such as Modelica has the drawback that performance problems and modeling errors are often hard to find. To address this problem, we have earlier developed advanced performance analysis and equation model debugging support in the OpenModelica tool. The aim of the work reported in this paper is to perform an independent investigation and evaluation of this equation model performance analysis and debugging methods and tool support on industrial models. The results turned out to be mainly positive. The integrated debugger and performance analyzer locates several kinds of errors such as division by zero, chattering, etc., and greatly facilitates finding the equations that take most of the execution time during simulation. It remains to further evaluate the performance profiler and debugger on even larger industrial models., Funding agencies: ITEA2 MODRIO project via Swedish Government (Vinnova); ITEA3 OPENCPS project via the Swedish Government (Vinnova); RTISIM project - Vinnova; Siemens Turbo Machinery AB

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.

The Modelica and FMI tool ecosystem is growing each year with new tools and methods becoming available. The open Modelica standard promises portability but it is important to ensure that a certain model behaves the same in different Modelica tools or in a different version of the same tool. It is also very important (for model evolution) to check that a new version of the same model produces comparable results. Finally, it is desirable to verify that a model exported in FMU form from a Modelica tool gives exactly the same results as the original model. This paper presents a framework for automatic regression testing as part of PySimulator which provides an efficient and concise way of testing if a model or a range of models behaves in the same way in several tools or versions of a tool by checking that the results produced are essentially identical. The FMI standard has been adopted by many tool vendors and is growing in popularity each year. This paper proposes a concept for building and simulating a system made from connected FMUs generated by different tools. The FMUs for Co-Simulation can be connected together using a GUI. The system model built graphically in this way can be saved for later use or simulated directly inside PySimulator. Active development is going on to support simulation of connected FMUs for Model Exchange.

What does it mean to bootstrap a compiler, and why do it? This paper reports on the first bootstrapping of a full-scale EOO (Equation-based Object-Oriented) modeling language such as Modelica. Bootstrapping means that the compiler of a language can compile itself. However, the usual application area for the Modelica is modeling and simulation of complex physical systems. Fortunately it turns out that with some minor extensions, the Modelica language is well suited for the modeling of language semantics. We use the name MetaModelica for this slightly extended Modelica. This is a prerequisite for bootstrapping which requires that the language can be used to model and/or implement itself. The OpenModelica Compiler (OMC) has been written in this MetaModelica language. It originally supported only the standard Modelica language but has been gradually extended to also cover the MetaModelica language extensions. After substantial work, OMC is able to quickly compile itself and produces an executable with good performance. The benefits include a more extensible and maintainable compiler by introducing improved language constructs and a more powerful runtime that makes it easy to add functionality such as parser generators, debuggers, and profiling tools. Future work includes extracting and restructuring parts of OMC, making the compiler smaller and more modular and extensible. This will also make it easier to interface with OMC, making it possible to create more powerful and user-friendly OpenModelica-based tools. The compiler and its bootstrapping is a major effort -- it is currently about 330 000 lines of code, and the MetaModelica extensions are used routinely by approximately ten developers on a daily basis.

The high abstraction level of equation-based object-oriented (EOO) languages such as Modelica has the drawback that programming and modeling errors are often hard to find. In this paper we present integrated static and dynamic debugging methods for Modelica models and a debugger prototype that addresses several of those problems. The goal is an integrated debugging framework that combines classical debugging techniques with special techniques for equation-based languages partly based on graph visualization and interaction. To our knowledge, this is the first Modelica debugger that supports both equation-based transformational and algorithmic code debugging in an integrated fashion.

The high abstraction level of equation-based object-oriented languages (EOO) such as Modelica has the drawback that programming and modeling errors are often hard to find. In this paper we present the first integrated debugger for equation-based languages like Modelica; which can combine static and dynamic methods for run-time debugging of equation-based Modelica models during simulations. This builds on and extends previous results from a transformational static equation debugger and a dynamic debugger for the algorithmic subset of Modelica.

Modelica models often contain functions with algorithmic code. The fraction of algorithmiccode is increasing in Modelica models since Modelica, in addition to equation-based modeling, is also used for embedded system control code and symbolic model transformations in compilers using the MetaModelica language extension. For these reasons, debugging of algorithmic Modelica code is becoming increasingly relevant. Our earlier work in debuggers for the algorithmic subset of Modelica used trace-based techniques. These have the advantages of being very portable, but turned out to have too much overhead for very large applications. The new debugger is the first Modelica debugger that can operate without trace information. Instead it communicates with a low-level C-language symbolic debugger, the Gnu debugger GDB, to directly extract information from a running executable, set and remove breakpoints, etc. This is made possible by the new bootstrapped OpenModelica compiler which keeps track of a detailed mapping from the high level Modelica code down to the generated C code compiled to machine code. The debugger is operational, supports browsing of both standard Modelica data structures and tree/list data structures, and operates efficiently on large applications such as the OpenModelica compiler with more than 100 000 lines of code.

Beslutsfattande genom förenklade förfaranden är mycket vanligt i svenska aktiebolag. Trots detta råder det en stor oenighet om hur förenklade förfaranden ska klassificeras. En klassificering är av betydelse vid avgörandet för om reglerna i ABL ska tillämpas direkt eller endast analogt där det lämpar sig. Utöver förenklade förfaranden finns det även en teoretisk möjlighet för aktieägare att åstadkomma så kallade universalbeslut. Ett universalbeslut är i praktiken att betrakta som en formlös överenskommelse mellan aktieägarna. Sådana universalbeslut uppkommer i vissa fall inte direkt genom uttryckliga viljeförklaringar utan istället konkludent. I enmansbolag framgår ofta bolagsstämmobeslut indirekt genom ägarens rättshandlande i och för bolaget. Det kan i dessa fall sägas råda en identitet mellan aktieägaren och bolagsstämman. Syftet med denna uppsats är att ifrågasätta föreställningen om en formenlig bolagsstämma, till vilken aktieägarna på förhand kallats. För att göra det kommer bolagsstämmobegreppet att analyseras för att utröna vad, om något, som konstituerar en bolagsstämma. En grundläggande förutsättning för att åstadkomma beslut genom alternativa förfaranden är att samtliga aktieägare samtyckt (SAS-principen) till åsidosättandet av skyddsreglerna i ABL. Principen att aktieägarna själva förfogar över de regler som är uppsatta till skydd för de nuvarande aktieägarna är mycket betydelsefull för småföretagare. Företagsstyrningen skulle, vid en avsaknad av alternativa förfaranden, annars framstå som mycket kostsam och komplicerad. Uppsatsen redogör utförligt för vilken typ av stämmoregler som med stöd av SAS-principens kan frångås och vad det får för innebörd för förfarandets klassificering. Frågeställningen blir om det överhuvudtaget finns någon regel som är så central för en bolagsstämma att dess åsidosättande medför att förfarandet inte de jure längre är att betrakta som en bolagsstämma. Jag är av uppfattningen att någon sådan regel inte existerar och uppdelning

This paper describes the first open source Modelica graphic editor which is integrated with interactive electronic notebooks and online interactive simulation. The work is motivated by the need for easy-to-use graphic editing of Modelica models using OpenModelica, as well as needs in teaching where the student should be able to interactively modify and simulate models in an electronic book. Models can be both textual and graphical. The interactive online simulation makes the simulation respond in real-time to model changes, which is useful in a number of contexts including immediate feedback to students.

The paper presents a contribution to a Modelica benchmark suite. Basic ideas for a tool independent benchmark suite based on Python scripting along with models for testing the performance of Modelica compilers regarding large systems of equation are given. The automation of running the benchmark suite is demonstrated followed by a selection of benchmark results to determine the current limits of Modelica tools and how they scale for an increasing number of equations.