| 1. |
|
|
| 2. |
|
|
| 3. |
- Fritzson, Peter, 1952-, et al.
(författare)
-
Modelica - A Strongly Typed System Specification Language for Safe Engineering Practices
- 2004
-
Ingår i: Proceedings of the SimSAFE Conference, Karlskoga, Sweden, June 15-17, 2004.
-
Konferensbidrag (övrigt vetenskapligt/konstnärligt)abstract
- Recent years have witnessed a significant growth of interest in modeling and simulation of engineering application systems. A key factor in this growth has been the development of efficient equation-based simulation languages, with Modelica as one of the prime examples. Such languages have been designed to allow automatic generation of efficient simulation code from declarative specifications. A major objective is to facilitate reuse and exchange of models, model libraries, and simulation specifications.The Modelica language and its associated support technologies have achieved considerable success through the development of domain libraries in a number of technical areas. By using domain-libraries complex simulation models can be built by aggregating and combining submodels and components from various physical domains.The concept of safe engineering practices has been one of the most important guidelines when designing Modelica. This made it natural to make Modelica a statically strongly typed language, which allows the compiler to check the consistency of a design before it is executed, in contrast to dynamically typed languages such as Matlab.The ability of static checking has also influenced the design of conditional equations and the ongoing the design of variant handling features in Modelica. Moreover, the language allows support for standardized physical units, thus enabling tools for unit checking of relationships and connections between interfaces. A third possible level of checking is through design rules within application-specific libraries, which can be enforced via assert statements. These properties taken together gives a good foundation for safe engineering practices, even though more work is needed to further increase the safety quality level.
|
|
| 4. |
- Fritzson, Peter, et al.
(författare)
-
The Open Source Modelica Project
- 2002
-
Ingår i: Proceedings from The 2nd International Modelica Conference was held March 18-19, 2002, Oberpfaffenhofen, Germany. - : Modelica Association. ; , s. 297-306
-
Konferensbidrag (refereegranskat)abstract
- The open source software movement has received enormous attention in recent years. It is often characterized as a fundamentally new way to develop software. This paper describes an effort to develop an open source Modelica environment to a large extent based on a formal specification of Modelica, coordinated by PELAB, Department of Computer and Information Science, Linköping University, Sweden. The current version of the system provides an efficient interactive computational environment for most of the expression, algorithm, and function parts of the Modelica language as well as an almost complete static semantics for Modelica 2.0.The longer-term goal is to provide reasonable simulation execution support, at least for less complex models, also for the equation part of Modelica which is the real essence of the language. People are invited to contribute to this open source project, e.g. to provide implementations of numerical algorithms as Modelica functions, add-on tools to the environment, or contributions to compiler itself. The source code of the tool components of the open source Modelica environment is available under the Gnu Public License, GPL. The library components are available under the same conditions as the standard Modelica library. The system currently runs under Microsoft Windows, Linux, and Sun Sparc Solaris. A benchmark example of running a simplex algorithm shows that the performance of the current system is close to the performance of handwritten C code for the same algorithm.
|
|
| 5. |
- Aronsson, Peter, et al.
(författare)
-
A Task Merging Technique for Parallelization of Modelica Models
- 2005
-
Ingår i: 4th International Modelica Conference. ; , s. -128
-
Konferensbidrag (refereegranskat)abstract
- 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.
|
|
| 6. |
|
|
| 7. |
- Aronsson, Peter, 1974-
(författare)
-
Automatic Parallelization of Equation-Based Simulation Programs
- 2006
-
Doktorsavhandling (övrigt vetenskapligt/konstnärligt)abstract
- Modern equation-based object-oriented modeling languages which have emerged during the past decades make it easier to build models of large and complex systems. The increasing size and complexity of modeled systems requires high performance execution of the simulation code derived from such models. More efficient compilation and code optimization techniques can help to some extent. However, a number of heavy-duty simulation applications require the use of high performance parallel computers in order to obtain acceptable execution times. Unfortunately, the possible additional performance offered by parallel computer architectures requires the simulation program to be expressed in a way that makes the potential parallelism accessible to the parallel computer. Manual parallelization of computer programs is generally a tedious and error prone process. Therefore, it would be very attractive to achieve automatic parallelization of simulation programs.This thesis presents solutions to the research problem of finding practically usable methods for automatic parallelization of simulation codes produced from models in typical equationbased object-oriented languages. The methods have been implemented in a tool to automatically translate models in the Modelica modeling language to parallel codes which can be efficiently executed on parallel computers. The tool has been evaluated on several application models. The research problem includes the problem of how to extract a sufficient amount of parallelism from equations represented in the form of a data dependency graph (task graph), requiring analysis of the code at a level as detailed as individual expressions. Moreover, efficient clustering algorithms for building clusters of tasks from the task graph are also required. One of the major contributions of this thesis work is a new approach for merging fine-grained tasks by using a graph rewrite system. Results from using this method show that it is efficient in merging task graphs, thereby decreasing their size, while still retaining a reasonable amount of parallelism. Moreover, the new task-merging approach is generally applicable to programs which can be represented as static (or almost static) task graphs, not only to code from equation-based models.An early prototype called DSBPart was developed to perform parallelization of codes produced by the Dymola tool. The final research prototype is the ModPar tool which is part of the OpenModelica framework. Results from using the DSBpart and ModPar tools show that the amount of parallelism of complex models varies substantially between different application models, and in some cases can produce reasonable speedups. Also, different optimization techniques used on the system of equations from a model affect the amount of parallelism of the model and thus influence how much is gained by parallelization.
|
|
| 8. |
- Aronsson, Peter
(författare)
-
Automatic Parallelization of Simulation Code from Equation Based Simulation Languages
- 2002
-
Licentiatavhandling (övrigt vetenskapligt/konstnärligt)abstract
- Modern state-of-the-art equation based object oriented modeling languages such as Modelica have enabled easy modeling of large and complex physical systems. When such complex models are to be simulated, simulation tools typically perform a number of optimizations on the underlying set of equations in the modeled system, with the goal of gaining better simulation performance by decreasing the equation system size and complexity. The tools then typically generate efficient code to obtain fast execution of the simulations. However, with increasing complexity of modeled systems the number of equations and variables are increasing. Therefore, to be able to simulate these large complex systems in an efficient way parallel computing can be exploited.This thesis presents the work of building an automatic parallelization tool that produces an efficient parallel version of the simulation code by building a data dependency graph (task graph) from the simulation code and applying efficient scheduling and clustering algorithms on the task graph. Various scheduling and clustering algorithms, adapted for the requirements from this type of simulation code, have been implemented and evaluated. The scheduling and clustering algorithms presented and evaluated can also be used for functional dataflow languages in general, since the algorithms work on a task graph with dataflow edges between nodes.Results are given in form of speedup measurements and task graph statistics produced by the tool. The conclusion drawn is that some of the algorithms investigated and adapted in this work give reasonable measured speedup results for some specific Modelica models, e.g. a model of a thermofluid pipe gave a speedup of about 2.5 on 8 processors in a PC-cluster. However, future work lies in finding a good algorithm that works well in general.
|
|
| 9. |
|
|
| 10. |
- Aronsson, Peter, et al.
(författare)
-
Parallel Code Generation in MathModelica / An Object Oriented Component Based Simulation Environment
- 2001
-
Ingår i: Proceedings of Workshop on Parallel/High Performance Object-Oriented Scientific Computing (POOSC’01).
-
Konferensbidrag (refereegranskat)abstract
- 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.
|
|
| 11. |
|
|
| 12. |
|
|
| 13. |
- Broman, David, 1977-, et al.
(författare)
-
Design Considerations for Dimensional Inference and Unit Consistency Checking in Modelica
- 2008
-
Ingår i: Proceedings of the 6th International Modelica Conference. - Bielefeld, Germany : Modelica Association. ; , s. 3-12
-
Konferensbidrag (refereegranskat)abstract
- 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.
|
|
| 14. |
- Bunus, Peter, et al.
(författare)
-
A Debugging Scheme for Declarative Equation Based Modeling Languages
- 2002
-
Ingår i: Practical Aspects of Declarative Languages. - Berlin, Heidelberg : Springer Berlin/Heidelberg. - 9783540430926 - 9783540455875
-
Konferensbidrag (refereegranskat)abstract
- 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.
|
|
| 15. |
- Bunus, Peter, et al.
(författare)
-
An Interactive Environment for Debugging Declarative Equation-based Languages
- 2001
-
Konferensbidrag (refereegranskat)abstract
- 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.
|
|
| 16. |
- Bunus, Peter, et al.
(författare)
-
Application of Graph Decomposition Techniques to Debugging Declarative Equation Based Languages
- 2001
-
Konferensbidrag (refereegranskat)abstract
- 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.
|
|
| 17. |
- Bunus, Peter, et al.
(författare)
-
Automated static analysis of equation-based components
- 2004
-
Ingår i: Simulation (San Diego, Calif.). - : SAGE Publications. - 0037-5497 .- 1741-3133. ; 80:7-8, s. 321-345
-
Tidskriftsartikel (refereegranskat)abstract
- 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.
|
|
| 18. |
- Bunus, Peter, 1973-
(författare)
-
Debugging and Structural Analysis of Declarative Equation-Based Languages
- 2002
-
Licentiatavhandling (övrigt vetenskapligt/konstnärligt)abstract
- A significant part of the software development effort is spent on detecting deviations between software implementations and specifications, and subsequently locating the sources of such errors. This thesis illustrates that is possible to identify a significant number of errors during static analysis of declarative object-oriented equation-based modeling languages that are typically used for system modeling and simulation. Detecting anomalies in the source code without actually solving the underlying system of equations provides a significant advantage: a modeling error can be corrected before trying to get the model compiled or embarking on a computationally expensive symbolic or numerical solution process. The overall objective of this work is to demonstrate that debugging based on static analysis techniques can considerably improve the error location and error correcting process when modeling with equation-based languages.A new method is proposed for debugging of over- and under-constrained systems of equations. The improved approach described in this thesis is to perform the debugging process on the flattened intermediate form of the source code and to use filtering criteria generated from program annotations and from the translation rules. Each time when an error is detected in the intermediate code and the error fixing solution is elaborated, the debugger queries for the original source code before presenting any information to the user. In this way, the user is exposed to the original language source code and not burdened with additional information from the translation process or required to inspect the intermediate code.We present the design and implementation of debugging kernel prototypes, tightly integrated with the core of the optimizer module of a Modelica compiler, including details of the novel framework required for automatic debugging of equation-based languages.This thesis establishes that structural static analysis performed on the underlying system of equations from object-oriented mathematical models can effectively be used to statically debug real Modelica programs. Most of our conclusions developed in this thesis are also valid for other equation-based modeling languages.
|
|
| 19. |
|
|
| 20. |
|
|
| 21. |
- Bunus, Peter, et al.
(författare)
-
Semantics guided filtering of combinatorial graph transformations in declarative equation-based languages
- 2002
-
Ingår i: Source Code Analysis and Manipulation, 2002. - 0769517935 ; , s. 163-172
-
Konferensbidrag (refereegranskat)abstract
- 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.
|
|
| 22. |
|
|
| 23. |
|
|
| 24. |
|
|
| 25. |
|
|
| 26. |
|
|
| 27. |
|
|
| 28. |
- Engelson, Vadim, 1965-, et al.
(författare)
-
Automatic generation of user interfaces from data structure specifications and object-oriented application models
- 1996
-
Ingår i: ECOOP ’96 — Object-Oriented Programming. - : Springer Berlin/Heidelberg. - 9783540614395 ; , s. 114-141
-
Konferensbidrag (refereegranskat)abstract
- Applications in scientific computing operate with data of complex structure and graphical tools for data editing, browsing and visualization are necessary.Most approaches to generating user interfaces provide some interactive layout facility together with a specialized language for describing user interaction. Realistic automated generation approaches are largely lacking, especially for applications in the area of scientific computing.This paper presents two approaches to automatically generating user interfaces (that include forms, pull-down menus and pop-up windows) from specifications.The first is a semi-automatic approach, that uses information from object-oriented mathematical models, together with a set of predefined elementary types and manually supplied layout and grouping information. This system is currently in industrial use. A disadvantage is that some manual changes need to be made after each update of the model.Within the second approach we have designed a tool, PDGen (Persistence and Display Generator) that automatically creates a graphical user interface and persistence routines from the declarations of data structures used in the application (e.g., C++ class declarations). This largely eliminates the manual update problem. The attributes of the generated graphical user interface can be altered.Now structuring and grouping information is automatically extracted from the object-oriented mathematical model and transferred to PDGen. This is one of very few existing practical systems for automatically generating user interfaces from type declarations and related object-oriented structure information.
|
|
| 29. |
- Engelson, Vadim, et al.
(författare)
-
Generating efficient 3D graphics animation code with OpenGL from object oriented models in Mathematica
- 1997
-
Ingår i: Innovation in Mathematics. ; , s. 129-136
-
Konferensbidrag (refereegranskat)abstract
- Traditionally 3D plots of parametric functions expressed in Mathematica are computed interpretively and saved in a static form before display. This causes low graphic performance. In this paper we describe an approach to generate efficient C++/Fortran90 code from such functions. This code is linked together with a powerful 3D browsing environment and uses OpenGL with possible hardware support. Thus flexibility of interactive exploration of 3D scenes and animation options become available for the end-user. 1 Introduction 1.1 The visualization problem Numerical experiments based on mathematical models is one of the most prevalent classes of applications of high performance computers and workstations. A common problem is however to interpret and make use of numerical data produced from such experiments. High performance numerical programs usually generate vast amounts of data (in our applications 1-2 Gbyte or more).
|
|
| 30. |
- Engelson, Vadim, 1965-, et al.
(författare)
-
Lossless compression of high-volume numerical data from simulations
- 2000
-
Ingår i: Proceedings. DCC 2000 Data Compression Conference, 2000. - : IEEE. - 0769505929
-
Konferensbidrag (refereegranskat)abstract
- Summary form only given. We propose a lossless algorithm of delta compression (a variant of predictive coding) that attempts to predict the next point from previous points using higher-order polynomial extrapolation. In contrast to traditional predictive coding our method takes into account varying (non-equidistant) domain (typically, time) steps. To save space and guarantee lossless compression, the actual and predicted values are converted to 64-bit integers. The residual (difference between actual and predicted values) is computed as difference of integers. The unnecessary bits of the residual are truncated, e.g., 1111110101 is replaced by 10101. The length of the bit sequence (510=(000101)2) is prepended
|
|
| 31. |
- Engelson, Vadim, 1965-, et al.
(författare)
-
Lossless Compression of High-volume Numerical Data from Simulations
- 2000
-
Rapport (övrigt vetenskapligt/konstnärligt)abstract
- Applications in scientific computing operate with high-volume numerical data and the occupied space should be reduced. Traditional compression algorithms cannot provide sufficient compression ratio for such kinds of data. We propose a lossless algorithm of delta-compression (a variant of predictive coding) that packs the higher-order differences between adjacent data elements. The algorithm takes into account varying domain (typically, time) steps. The algorithm is simple, it has high performance and delivers a high compression ratio for smoothly changing data. Both lossless and lossy variants of the algorithm can be used. The algorithm has been successfully applied to the output from a simulation application that uses a solver of ordinary differential equations.
|
|
| 32. |
|
|
| 33. |
|
|
| 34. |
- Engelson, Vadim, 1965-, et al.
(författare)
-
Using the Mathematica environment for generating efficient 3D graphics
- 1997
-
Ingår i: Proceedings of EDUGRAPHICS/COMPUGRAPHICS-97. - : Graphic Science Promotions and Publications. ; , s. 222-231
-
Konferensbidrag (refereegranskat)abstract
- Mathematica is an integrated environment for symbolic transformation of mathematical formulas. This environment has applications in scientific computing, scientific visualization and education. Mathematica gives possibility to describe visualized objects in form of mathematical formulas and expressions. Such descriptions are more clear and concise than low-level C or C++ code. Many visualization systems require input in the form of (sometimes huge) data files, which is a disadvantage for highly interactive and animated 3D graphics applications. This is also the case for graphics expressed in Mathematica which is computed interpretively and saved in a static data form before display. This causes low graphic performance. In this paper we describe an approach which uses object geometry descriptions in the form of efficient program code instead of huge data files. We have built a tool that produces 3D visualizations of geometrical objects and object trajectories from mathematical specifications expressed as parametric functions in Mathematica. A compiler has been developed which generates efficient C++ code from such functions and symbolic expressions. This code is linked together with a powerful 3D browsing environment and uses OpenGL with possible hardware support. All the computations are performed within the visualizing application. Object geometry, color, etc. can be changed dynamically during animations. Thus the flexibility of interactive exploration of 3D scenes and animation become available for the end-user.
|
|
| 35. |
- Fritzson, Dag, et al.
(författare)
-
Object-Oriented Mathematical Modelling – Applied to Machine Elements
- 1994
-
Ingår i: Computers & structures. - : Elsevier. - 0045-7949 .- 1879-2243. ; 51:3, s. 241-253
-
Tidskriftsartikel (refereegranskat)abstract
- Machine element analysis has a goal of describing function and other aspects of machine elements in a theoretical form. This paper shows how ideas from object-oriented modelling can be applied to machine element analysis. The models thus obtained are both easier to understand, better structured, and allow a higher degree of re-use than conventional models. An object-oriented model description is natural and suitable for machine element analysis. As a realistic example an equational model of rolling bearings is presented. The structure of the model is general, and applies to many types of rolling bearings. The model and one solution require approximately 200 + 200 equations. The model is extensible, e.g. simple submodels of detailed properties can be made more complex without altering the overall structure. The example model has been implemented in a language of our own design, ObjectMath (Object-oriented Mathematical language for scientific computing). Using ObjectMath, it is possible to model classes of equation objects, to support multiple and single inheritance of equations, to support composition of equations, and to solve systems of equations. Algebraic transformations can conveniently be done since ObjectMath models are translated into the Mathematica computer algebra language. When necessary, equations can be transformed to C++ code for efficient numerical solution. The re-use of equations through inheritance reduced the size of the model by a factor of two, compared to a direct representation of the model in the Mathematica computer algebra language.
|
|
| 36. |
- Fritzson, Dag, et al.
(författare)
-
Object-Oriented Mathematical Modelling - Applied to Rolling Bearings
- 1992
-
Konferensbidrag (refereegranskat)abstract
- Machine element analysis has the goal of describing functionality and other important aspects of machine elements in theoretical form. A rolling bearing is a typical example of a machine element. The first issue covered in this paper is how ideas from object-oriented programming and modelling can be applied to machine element analysis. The models thus obtained are easier to understand, better structured, and allow a higher degree of re-use than conventional models. Our conclusion is that an object-oriented model description is natural for the machine element analyst and is suitable for machine element analysis.An equational model of rolling bearings is presented in this paper. The structure of the model is general, in three dimensions, and applies to many types of rolling bearings. Part of this generality is obtained by using parametric surfaces. In order to keep the presentation of the model understandable, we have simplified many details. Nevertheless, the model and one solution require approximately 200+200 equations. The model is also extensible, e.g., simple submodels of detailed properties can be made more complex without altering the overall structure.
|
|
| 37. |
- Fritzson, Dag, et al.
(författare)
-
Rolling Bearing Simulation on MIMD Computers
- 1997
-
Ingår i: The international journal of high performance computing applications. - : Sage Publications. - 1094-3420 .- 1741-2846. ; 11:4, s. 299-313
-
Tidskriftsartikel (refereegranskat)abstract
- Rolling bearing simulations are very computationally in tensive. Serial simulations may take weeks to execute, and there is a need to use the potential of parallel comput ing. The specific structure of the rolling bearing problem is used to develop suitable scheduling strategies. The authors discuss the system of stiff ordinary differential equations arising from a bearing model and show how to numerically solve these ordinary differential equations on parallel computers. Benchmarking results are presented for two test cases on three platforms.
|
|
| 38. |
- Fritzson, Peter, et al.
(författare)
-
A parallel debugger with support for distributed arrays, multiple executables and dynamic processes
- 1996
-
Ingår i: Compiler Construction. - Berlin, Heidelberg : Springer Berlin/Heidelberg. - 9783540610533 - 9783540499398 ; , s. 341-355
-
Konferensbidrag (refereegranskat)abstract
- In this paper we present the parallel debugger DETOP with special emphasis on new support for debugging of programs with distributed data structures such as arrays that have been partitioned over a number of processors. The new array visualizer within DETOP supports transparent browsing and visualization of distributed arrays which occur in languages such as High Performance Fortran. Visualization of sparse arrays is supported through an array mapper facility, as well as transparent visualization of arrays which have been partitioned by hand for applications in C or Fortran77. Color coding makes the visualization more expressive and easier to read.DETOP provides a graphical user interface that is simple to use even for inexperienced users and supports not only static data parallel programs, but also dynamic programs and parallel applications based on functional decomposition. The combination of support for applications that include dynamic process creation, multiple executables, processes and threads, and distributed data structures, makes DETOP rather unique among parallel debuggers. DETOP has been implemented for Parsytec PowerPC based multicomputers with Sparcstation frontends. Ongoing efforts include portable versions of DETOP for PVM and MPI run-time environments.
|
|
| 39. |
- Fritzson, Peter, et al.
(författare)
-
Formal Semantics Based Translator Generation and Tool Development in Practice
- 2009
-
Ingår i: Proceedings of 20th Australian Software Engineering Conference (ASWEC 2009). - : IEEE Computer Society. - 9780769535999 ; , s. 256-266
-
Konferensbidrag (refereegranskat)abstract
- In this paper we report on a long-term research effort to develop and use efficient language implementation generators in practice. The generator is applied to a number of different languages, some of which are used for projects in industry. The used formal specification style is operational semantics, primarily in the form called natural semantics, represented and supported by a meta-language and tool called the relational meta language (RML), which can generate efficient implementations in C, on par with hand-implemented code. Generating implementations from formal specifications are assumed to give advantages such as: high level descriptions, higher degree of correctness, and consistency between specification and implementation. To what extent can this be realized in practice? Does it scale to large language implementations? To answer some of these questions we have developed specifications of a range of languages: imperative, functional, object-oriented (Java), and equation-based (Modelica). The size of specifications range from half a page to large specifications of 60 000 lines. It turns out to be possible to generate efficient compilers, also for large languages. However, the performance of the generator tool and the user support of the development environment become increasingly important for large specifications. To satisfy such user needs the speed of the generator was increased a factor of ten to reduce turn-around time, and an Eclipse plug-in including a debugger were developed. For very large specifications, the structuring and modularity of the specification itself also become essential for performance and maintainability.
|
|
| 40. |
- Fritzson, Peter, et al.
(författare)
-
High-level mathematical modeling and programming in Scientific Computing
- 1995
-
Ingår i: IEEE Software. - : IEEE. - 0740-7459 .- 1937-4194. ; 12:4, s. 77-87
-
Tidskriftsartikel (refereegranskat)abstract
- Scientific computing and advanced mechanical analysis demand high-level support for modeling and solving complex equations. To meet this need, the authors designed ObjectMath and applied it to real problems in machine-element analysis
|
|
| 41. |
- Fritzson, Peter, et al.
(författare)
-
Industrial Application of Object-Oriented Mathematical Modeling and Computer Algebra in Mechanical Analysis
- 1992
-
Konferensbidrag (refereegranskat)abstract
- 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.
|
|
| 42. |
- Fritzson, Peter, et al.
(författare)
-
Modelica - a general object-oriented language for continuous and discrete-event system modeling and simulation
- 2002
-
Ingår i: Simulation Symposium, 2002. - : IEEE. ; , s. 365-380
-
Konferensbidrag (refereegranskat)abstract
- Modelica is a general equation-based object-oriented language for continuous and discrete-event modeling of physical systems for the purpose of efficient simulation. The language unifies and generalizes previous objectoriented modeling languages. The Modelica modeling language and technology is being warmly received by the world community in modeling and simulation. It is bringing about a revolution in this area, based on its ease of use, visual design of models with combination of legolike predefined model building blocks, its ability to define model libraries with re-usable components and its support for modeling and simulation of complex applications involving parts from several application domains. In this paper we present the Modelica language with emphasis on its language features and one of the associated simulation environments. Simulation models can be developed in an integrated problem-solving environment by using a graphical editor for connection diagrams. Connections are established just by drawing lines between objects picked from a class library. The principles of object oriented physical systems modeling and the multi-domain capabilities of the language are presented in the paper by several examples.
|
|
| 43. |
- Fritzson, Peter, 1952-, et al.
(författare)
-
OpenModelica - A Free Open-Source Environment for System Modeling, Simulation, and Teaching
- 2006
-
Ingår i: Proceedings of the2006 IEEE International Conference on Control Applications (CCA)2006 IEEE Conference on Computer-Aided Control Systems Design (CACSD)2006 IEEE International Symposium on Intelligent Control (ISIC). - Munich, Germany : IEEE. - 0780397975 - 0780397975 ; , s. 1588-1595
-
Konferensbidrag (refereegranskat)abstract
- Modelica is a modern, strongly typed, declarative, and object-oriented language for modeling and simulation of complex systems. This paper gives a quick overview of some aspects of the OpenModelica environment - an open-source environment for modeling, simulation, and development of Modelica applications. An introduction of the objectives of the environment is given, an overview of the architecture is outlined and a number of examples are illustrated.
|
|
| 44. |
- Fritzson, Peter, et al.
(författare)
-
The Need for High-Level Programming Support in Scientific Computing - Applied to Mechanical Analysis
- 1992
-
Ingår i: Computers and Structures. - : Elsevier. - 0045-7949 .- 1879-2243. ; 45:2, s. 387-395
-
Tidskriftsartikel (refereegranskat)abstract
- We describe the current state of the art in computerized support of mathematical and numerical modelling for mechanical analysis. An overview of relevant high-level languages, computer algebra systems, and hybrid symbolic-numerical systems is also given. Several problems with current tools are identified, and a high-level programming environment is proposed as a solution. Such an environment should include object oriented model description, symbolic formula manipulation, generation of numeric code, automatic use of equation solvers and optimization techniques, in addition to graphical presentation of model and simulation data.
|
|
| 45. |
- Fritzson, Peter, 1952-, et al.
(författare)
-
The OpenModelica Integrated Environment for Modeling, Simulation, and Model-Based Development
- 2020
-
Ingår i: Modeling, Identification and Control. - Kristiansand, Norway : Norsk Forening for Automatisering. - 0332-7353 .- 1890-1328. ; 41:4, s. 241-295
-
Tidskriftsartikel (refereegranskat)abstract
- 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.
|
|
| 46. |
- Fritzson, Peter, et al.
(författare)
-
The OpenModelica Modeling, Simulation, and Development Environment
- 2005
-
Konferensbidrag (refereegranskat)abstract
- Modelica is a modern, strongly typed, declarative, and object-oriented language for modeling and simulation of complex systems. This paper gives a quick overview of some aspects of the OpenModelica environment – an open-source environment for modeling, simulation, and development of Modelica applications. An introduction of the objectives of the environment is given, an overview of the architecture is outlined and a number of examples are illustrated.
|
|
| 47. |
|
|
| 48. |
|
|
| 49. |
|
|
| 50. |
- Gorm Larsen, Peter, et al.
(författare)
-
Integrated Tool Chain for Model-based Design of Cyber-Physical Systems: The INTO-CPS Project
- 2016
-
Ingår i: 2016 2ND INTERNATIONAL WORKSHOP ON MODELLING, ANALYSIS, AND CONTROL OF COMPLEX CPS (CPS DATA). - : IEEE. - 9781509011544
-
Konferensbidrag (refereegranskat)abstract
- We describe INTO-CPS, a project that aims to realise the goal of integrated tool chains for the collaborative and multidisciplinary engineering of dependable Cyber-Physical Systems (CPSs). Challenges facing model-based CPS engineering are described, focussing on the semantic diversity of models, management of the large space of models and artefacts produced in CPS engineering, and the need to evaluate effectiveness in industrial settings. We outline the approach taken to each of these issues, particularly on the use of semantically integrated multi-models, links to architectural modelling, code generation and testing, and evaluation via industry-led studies. We describe progress on the development of a prototype tool chain from baseline tools, and discuss ongoing challenges and open research questions in this area.
|
|
