A car model in Modelica has been developed to be used in a new setup for distributed real-time simulation where a moving base car simulator is connected with a real car in a chassis dynamometer via a 500m fiber optic communication link. The new co-simulator set-up can be used in a number of configurations where hardware in the loop can be interchanged with software in the loop. The models presented in this paper are the basic blocks chosen for modeling the system in the context of a distributed real-time simulation; estimating parameters for the powertrain model; the choice of numeric solver; and the interaction with the solver for real-time properties.

The past ten to fifteen years has seen active research in the area of automatically generating the code generator part of compilers from formal specifications. However, less work has been done on evaluating and applying these systems in an industrial setting. This paper attempts to fill this gap.Three systems for automatic generation of code generators are evaluated in this paper: CGSS, BEG and TWIG. CGSS is an older Graham-Glanville style system based on pattern matching through parsing, whereas BEG and TWIG are more recent systems based on tree pattern matching combined with dynamic programming. An industrial-strength code generator previously implemented for a special-purpose language using the CGSS system is described and compared in some detail to our new implementation based on the BEG system. Several problems of integrating local and global register allocation within automatically generated code generators are described, and some solutions proposed. We finally conclude that current technology of automatically generating code generators is viable in an industrial setting. However, further research needs to be done on the problem of properly integrating register allocation with instruction selection, when both are generated from declarative specifications.

For a long time efficient use of parallel computers has been hindered by dependencies introduced in software through low-level implementation practice. In this paper we present a programming environment and language called Object-Math (Object oriented Mathematical language for scientific computing), which aims at eliminating this problem by allowing the user to represent mathematical equation-based models directly in the system. The system performs analysis of mathematical models to extract parallelism and automatically generates parallel code for numerical solution.In the context of industrial applications in mechanical analysis, we have so far primarily explored generation of parallel code for solving systems of ordinary differential equations (ODEs), in addition to preliminary work on generating code for solving partial differential equations. Two approaches to extracting parallelism have been implemented and evaluated: extracting parallelism at the equation system level and at the single equation level, respectively. We found that for several applications the corresponding systems of equations do not partition well into subsystems. This means that the equation system level approach is of restricted general applicability. Thus, we focused on the equation-level approach which yielded significant parallelism for ODE systems solution. For the bearing simulation applications we present here, the achieved speedup is however critically dependent on low communication latency of the parallel computer.

The current state of the art in programming for scientific computing is still rather low-level. The mathematical model behind a computing application usually is written using pen and paper, whereas the corresponding numerical software often is developed manually in Fortran or C. This is especially true in application areas such as mechanical analysis, where complex non-linear problems are the norm, and high performance is required. Ideally, a high-level programming environment would provide computer support for these development steps. This motivated the development of the ObjectMath system. Using ObjectMath, complex mathematical models may be structured in an object oriented way, symbolically simplified, and transformed to efficient numerical code in C++ or Fortran.

However, many scientific computing problems are quite computationally demanding, which makes it desirable to use parallel computers. Unfortunately, generating parallel code from arbitrary mathematical models is an intractable problem. Therefore, we have focused most of our efforts on a specific problem domain where the main computation is to solve ordinary differential equation systems where most of the computing time is spent in application specific code, rather than in the serial solver kernel. We have investigated automatic parallelisation of the computation of ordinary differential equation systems at three different levels of granularity: the equation system level, the equation level, and the clustered task level. At the clustered task level we employ domain specific knowledge and existing scheduling and clustering algorithms to partition and distribute the computation.

During the past 10 to 15 years, there has been active research in the area of automatically generating the code generator part of compilers from formal specifications. However, little has been reported on the application of these systems in an industrial setting. This paper attempts to fill this gap, in addition to providing a tutorial overview of the most well-known methods. Four systems for automatic generation of code generators are described in this paper. CGSS, BEG, TWIG and BURG. CGSS is an older Graham-Glanville style system based on pattern matching through parsing, whereas BEG, TWIG, and BURG are more recent systems based on tree pattern matching combined with dynamic programming. An industrial-strength code generator previously implemented for a special-purpose language using the CGSS system is described and compared in some detail to our new implementation based on the BEG system. Several problems of integrating local and global register allocations within automatically generated code generators are described, and some solutions are proposed. In addition, the specification of a full code generator for SUN SPARC with register windows using the BEG system is described. We finally conclude that current technology of automatically generating code generators is viable in an industrial setting. However, further research needs to be done on the problem of properly integrating register allocation and instruction scheduling with instruction selection, when both are generated from declarative specifications.

This paper presents improvements on techniques of merging tasks in task graphs generated in the ModPar automatic parallelization module of the OpenModelica compiler. Automatic parallelization is performed on Modelica models by building data dependency graphs called task graphs from the model equations. To handle large task graphs with fine granularity, i.e. low ratio of execution and communication cost, the tasks are merged. This is done by using a graph rewrite system(GRS), which is a set of graph transformation rules applied on the task graph. In this paper we have solved the confluence problem of the task merging system by giving priorities to the merge rules. A GRS is confluent if the application order of the graph transformations does not matter, i.e. the same result is gained regardless of application order. We also present a Modelica model suited for automatic parallelization and show results on this using the ModPar module in the OpenModelica compiler.

Modelica is an a-causal, equation based, object oriented modeling lan- guage for modeling and efficient simulation of large and complex multi domain systems. The Modelica language, with its strong software component model, makes it possible to use visual component programming, where large complex physical systems can be modeled and composed in a graphical way. One tool with support for both graphical modeling, textual programming and simulation is MathModelica. To deal with growing complexity of modeled systems in the Modelica language, the need for parallelization becomes increasingly important in order to keep sim- ulation time within reasonable limits. The first step in Modelica compilation results in an Ordinary Differential Equa- tion system or a Differential Algebraic Equation system, depending on the spe- cific Modelica model. The Modelica compiler typically performs optimizations on this system of equations to reduce its size. The optimized code consists of simple arithmetic operations, assignments, and function calls. This paper presents an automatic parallelization tool that builds a task graph from the optimized sequential code produced by a commercial Modelica compiler. Var- ious scheduling algorithms have been implemented, as well as specific enhance- ments to cluster nodes for better computation/communication tradeoff. Finally, the tool generates simulation code, in a master-slave fashion, using MPI.

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.

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.

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.

PARFORMAN (PARallel FORMal ANnotation language) is a high-level specification language for expressing intended behavior or known types of error conditions when debugging or testing parallel programs. Models of intended or faulty target program behavior can be succinctly specified in PARFORMAN. These models are then compared with the actual behavior in terms of execution traces of events, in order to localize possible bugs. PARFORMAN can also be used as a general language for expressing computations over target program execution histories. PARFORMAN is based on a precise axiomatic model of target program behavior. This model, called H-space (History-space), is formally defined through a set of general axioms about three basic relations, which may or may not hold between two arbitrary events: they may be sequentially ordered (SEQ), they may be parallel (PAR), or one of them might be included in another composite event (IN). The general notion of composite event is exploited systematic.

PARFORMAN (PARallel FORMal ANnotation language) is a specification language for expressing the intended behaviour or known types of error conditions when debugging or testing parallel programs. The high-level debugging approach which is supported by PARFORMAN is model-based. Models of intended or faulty behaviour can be succinctly specified in PARFORMAN. These models are then compared with the actual behaviour in terms of execution traces of events, in order to localize possible bugs. PARFORMAN is based on an axiomatic model of target program behaviour. This model, called H-space (history-space), is formally defined through a set of general axioms about three basic relations between events. Events may be sequentially ordered, they may be parallel, or one of them might be included in another composite event. The notion of an event grammar is introduced to describe allowed event patterns over a certain application domain or language. Auxiliary composite events such as snapshots are introduced to be able to define the notion “occurred at the same time” at suitable levels of abstraction. In addition to debugging and testing, PARFORMAN can also be used to specify profiles and performance measurements

Nonlinear model predictive control (NMPC) has become increasingly important for today’s control engineers during the last decade. In order to apply NMPC a nonlinear optimal control problem (NOCP) must be solved which needs a high computational effort.

State-of-the-art solution algorithms are based on multiple shooting or collocation algorithms; which are required to solve the underlying dynamic model formulation. This paper describes a general discretization scheme applied to the dynamic model description which can be further concretized to reproduce the mul-tiple shooting or collocation approach. Furthermore; this approach can be refined to represent a total collocation method in order to solve the underlying NOCP much more efficiently. Further speedup of optimization has been achieved by parallelizing the calculation of model specific parts (e.g. constraints; Jacobians; etc.) and is presented in the coming sections.

The corresponding discretized optimization problem has been solved by the interior optimizer Ipopt. The proposed parallelized algorithms have been tested on different applications. As industrial relevant application an optimal control of a Diesel-Electric power train has been investigated. The modeling and problem description has been done in Optimica and Modelica. The simulation has been performed using OpenModelica. Speedup curves for parallel execution are presented.

A primary goal with this work has been to investigate the consequences of a token-based program and document representation. This representation lies between plain text and trees in complexity.We have found that a program or a document represented as a token sequence saves on the average 50 representation. Another advantage is that deltas between program versions stored in source code control systems become insensitive to changes in whitespace or formatting style. Statistics from version-handling, computation of deltas, and storage is presented in the paper.

The Modelica language supports syntax for declaring physical units of variables, but it does not yet exist any defined semantics for how dimensional and unit consistency checking should be carried out. In this paper we explore different approaches and new constructs for improved dimensional inference and unit consistency checking in Modelica; both from an end-user, library, and tool perspective. A proposal for how dimensional inference and unit checking can be carried out is outlined and a prototype implementation is developed and verified using several examples from the Modelica standard library.

Modelica is an open standardized language used for modeling and simulation of complex physical systems. The language specification defines a formal concrete syntax, but the semantics is informally described using natural language. The latter makes the language hard to interpret, maintain and reason about, which affect both tool development and language evolution. Even if a completely formal semantics of the Modelica language can be seen as a natural goal, it is a well-known fact that defining understandable and concise formal semantics specifications for large and complex languages is a very hard problem. In this paper, we will discuss different aspects of formulating a Modelica specification; both in terms of what should be specified and how it can be done. Moreover, we will further argue that a “middle-way” strategy can make the specification both clearer and easier to reason about. A proposal is outlined, where the current informally specified semantics is complemented with several grammars, specifying intermediate representations of abstract syntax. We believe that this kind of evolutionary strategy is easier to gain acceptance for, and is more realistic in the short-term, than a revolutionary approach of using a fully formal semantics definition of the language.

Current equation-based object-oriented (EOO) languages typically contain a number of fairly complex language constructs for enabling reuse of models. However, support for model transformation is still often limited to scripting solutions provided by tool implementations. In this paper we investigate the possibility of combining the well known concept of higher-order functions, used in standard functional programming languages, with acausal models. This concept, called Higher-Order Acausal Models (HOAMs), simplifies the creation of reusable model libraries and model transformations within the modeling language itself. These transformations include general model composition and recursion operations and do not require data representation/reification of models as in metaprogramming/metamodeling. Examples within the electrical and mechanical domain are given using a small research language. However, the language concept is not limited to a particular language, and could in the future be incorporated into existing commercially available EOO-languages.

Due to the increasing number of vulnerabilities in software systems and customers- need to trust the producers- development process, third party security evaluations, such as Common Criteria (CC), are today commonly used to provide assurance of security critical software. Modelica is a modern, strongly typed, declarative, and object-oriented language for modeling and simulation of complex systems. In this paper we sketch two ideas for improving security assurance, by expanding the scope of Modelica into also becoming a declarative modeling language for other application areas than simulation.

Modelica is an object-oriented language designed

for modeling and simulation of complex physical

systems. To enable the possibility for an engineer

to discover errors in a model, languages and com-

pilers are making use of the concept of types and

type checking. This paper gives an overview of

the concept of types in the context of the Model-

ica language. Furthermore, a new concrete syntax

for describing Modelica types is given as a starting

point to formalize types in Modelica. Finally, it is

concluded that the current state of the Modelica

language specification is too informal and should

in the long term be augmented by a formal defin-

ition.

Operational semantics and attribute grammars are examples of formalisms that can be used for generating compilers. We are interested in finding similarities and differences in how these approaches are applied to complex languages, and for generating compilers of such maturity that they have users in industry.

As a specific case, we present a comparative analysis of two compilers for Modelica, a language for physical modeling, and which contains numerous compilation challenges. The two compilers are OpenModelica, which is based on big-step operational semantics, and JModelica.org, which is based on reference attribute grammars.

Computer aided modeling and simulation of complex physical systems, using components from multiple application domains, such as electrical, mechanical, and hydraulic, have in recent years witnessed a significant growth of interest. In the last decade, equation-based object-oriented (EOO) modeling languages, (e.g. Modelica, gPROMS, and VHDL-AMS) based on acausal modeling using Differential Algebraic Equations (DAEs), have appeared. With such languages, it is possible to model physical systems at a high level of abstraction by using reusable components.A model in an EOO language needs to have the same number of equations as unknowns. A previously unsolved problem concerning this property is the efficient detection of over- or under-constrained models in the case of separately compiled models.This paper describes a novel technique to determine over- and under-constrained systems of equations in models, based on a concept called structural constraint delta. In many cases it is also possible to locate the source of the constraint-problem. Our approach makes use of static type checking and consists of a type inference algorithm. We have implemented it for a subset of the Modelica language, and successfully validated it on several examples.

Requirement verification is an important part of the development process, and the increasing system complexity has exacerbated the need for integrating this step into a formalized model driven development process, providing a dedicated methodology as well as tool support. In this paper the authors propose an extension for Modelica, an equation-based language for system modeling, that will allow to represent system requirements in the same formalism as the design model, thus reducing the need for transformations between different specialized formalisms, lowering maintenance and modification costs, and benefitting from the expression and simulation capabilities, as well as extensive tool support of Modelica. The object-oriented nature of the approach provides the advantages of modular design and hierarchical structuring of the requirement model. This paper also illustrates, with the help of an example, how requirement verification can be used alongside the simulation process to trace the components responsible for requirement violations. To this end, we introduce a formalism for expressing relationships between components and requirements, as well as a tracing algorithm.

This paper concerns the static analysis for debugging purposes of programs written in declarative equation based modeling languages. We first give an introduction to declarative equation based languages and the consequences equation based programming has for debugging. At the same time, we examine the particular debugging problems posed by Modelica, a declarative equation based modeling language. A brief overview of the Modelica language is also given. We also present our view of the issues and solutions based on a proposed framework for debugging declarative equation based languages. Program analysis solutions for program understanding and for static debugging of declarative equation based languages, based on bipartite graph decomposition, are presented in the paper. We also present an efficient way to annotate the underlying equations in order to help the implemented debugger to eliminate the heuristics involved in choosing the right error fixing solution. This also provides means to report the location of an error caught by the static analyzer or by the numeric solver, consistent with the user’s perception of the source code and simulation model.

In this paper we present a general framework for debugging declarative equation based languages. This paper uses certain existing bipartite graph based techniques to derive debugging algorithms for the structural diagnosis of simulation models specified in declarative equation based modeling languages. An efficient way of annotating the underlying equations of a simulation model in order to help the user to take error-fixing decisions is also presented. This also provides means to report the location of the error caught bythe extended static analyzer or by the numeric solver, consistent with the user’s perception of the source code and the simulation model. We also present a unified reasoning process in order to relax over-constrained systems and obtain a consistent simulation model that supports an enhanced user interaction. The interactive debugging environment provides to the user a greater confidence in the correctness of the simulation model and helps them to resolve conflicting situations when multiple elimination choices are possible. A prototype debugger is implemented.

This paper concerns the static analysis for debugging purposes of programs written in declarative equation based modeling languages. We first give an introduction to declarative equation based languages and the consequences equation based programming has for debugging. At the same time, we examine the particular debugging problems posed by Modelica, a declarative equation based modeling language. A brief overview of the Modelica language is also given. We also present our view of the issues and solutions based on a proposed framework for debugging declarative equation based languages. Program analysis solutions for program understanding and for static debugging of declarative equation based languages, based on bipartite graph decomposition, are presented in the paper. We also present an efficient way to annotate the underlying equations in order to help the implemented debugger to eliminate the heuristics involved in choosing the right error fixing solution. This also provides means to report the location of an error caught by the static analyzer or by the numeric solver, consistent with the user’s perception of the source code and simulation model.

Mathematical modeling and the simulation of complex physical systems are emerging as key technologies in engineering. The availability of static analyzers and automatic debuggers for detecting structural and numerical inconsistencies in the simulation models is crucial. To address this need, the authors propose a methodology for detecting and repairing overconstrained and underconstrained situations based on graph-theoretical approaches. Components and equations that cause the irregularities are automatically isolated, and meaningful error messages for the user are elaborated. The authors have implemented the AMOEBA (Automatic Modelica Equation-Based Analyzer) environment to support the development and specification of correct equation-based simulation models by applying graph-theoretical approaches and semiautomatic debugging techniques. The implementation architecture and preliminary experiments with a prototype debugger integrated in the symbolic and numeric engine, ModSimPack, of the Modelica language compiler are presented and discussed.

This paper concerns the use of static analysis for debugging purposes of declarative object-oriented equation-based modeling languages. We propose a framework where over- and under-constraining situations present in simulation models specified in such languages are detected by combinatorial graph transformations performed on the flattened intermediate code and filtered by the semantic transformation rules derived from the original language. This is powerful enough to statically detect a broad range of errors without having to execute the simulation model. Debuggers associated with simulation environments for such languages can provide efficient error-fixing strategies based on the graph-based representation of the intermediate code. The emphasis, in this paper, is on detecting and debugging over-constraining equations, which are present in some simulation model specifications. We discuss various ways in which we have extended our approach to allow static global analysis of the original modeling source code.

This paper discusses technical issues and implementation of a generic interface to import a Functional Mock-up Unit (FMU) into Modelica simulators, specifically the Open- Modelica environment. Whereas other approaches for importing the FMUs rely on functionality specific to the simulator environment, this approach tries to provide a generic Modelica interface for embedding an FMU to be imported into a Modelica model. In this way any FMU conforming to the Functional Mock-up Interface (FMI) for Model Exchange v1.0 Specification for model exchange from MODELISAR can be imported into any Modelica simulator. When importing an FMU into a model, the resulting Modelica model can be used just like any pure Modelica models. Hence, a better reusability and interoperability for both sides, namely the external models provided via FMI and the Modelica environment, are achieved.

Virtual experimentation is a collective term that includes various model evaluation procedures such as simulation, optimization and scenario analysis. Given the complexity of the models used in these procedures, and the number of evaluations that is required to complete them, highly efficient model implementations are desired. Although water quality management is a domain in which complex virtual experimentation is often adopted, only relatively little attention has thus far been devoted to the automated generation of efficient executable models. This article reports on a number of promising results regarding executable model generation that were obtained in the scope of the Tornado kernel, using techniques such as equiv substitution and equation lifting. © IWA Publishing 2007.

It is well known that, due to bimodal operation as well as existent discontinuous differential states of batteries, standalone microgrids belong to the class of hybrid dynamical systems of non-Filippov type. In this work, however, standalone microgrids are presented as complementarity systems (CSs) of the Filippov type which is then used to develop a multivariable nonlinear model predictive control (NMPC)-based load tracking strategy as well as Modelica models for long-term simulation purposes. The developed load tracker strategy is a multi-source maximum power point tracker (MPPT) that also regulates the DC bus voltage at its nominal value with the maximum of ±2.0% error despite substantial demand and supply variations.

In this paper, two ecological models of nitrogen processes in treatment wetlands have been evaluated and compared. These models were implemented, simulated, and visualized using the Modelica modelling and simulation language [P. Fritzson, Principles of Object-Oriented Modelling and Simulation with Modelica 2.1 (Wiley-IEEE Press, USA, 2004).] and an associated tool. The differences and similarities between the MathModelica Model Editor and three other ecological modelling tools have also been evaluated. The results show that the models can well be modelled and simulated in the MathModelica Model Editor, and that nitrogen decrease in a constructed treatment wetland should be described and simulated using the Nitrification/Denitrification model as this model has the highest overall quality score and provides a more variable environment. © 2007 Elsevier B.V. All rights reserved.

The global problem of eutrophication, the enrichment of water bodies by nutrients, has inrecent years resulted in an increased interest in non-conventional ways to reduce the amount of nutrients discharged into the environment. One of the more commonly proposed and also used solutions is to append artificial or constructed wetlands as a final step in the treatment of wastewater. However, both the construction of the wetlands and the maintenance thereof are time and resource consuming, hence a high production and maintenance cost. Due to these high costs, tools for modeling and simulation have turned out to be valuable asset in the development of constructed wetlands.

In this paper, two ecological models of nitrogen processes in treatment wetlands have beenmodeled, simulated, and visualized using the Modelica language. The results show that nitrogen decrease in a constructed treatment wetland can well be simulated using the Total Nitrogen or the Nitrification/Denitrification model expressed in Modelica and the MathModelica Model Editor.