The need for debugging tools for declarative programming languages has increased due to the rapid development of modeling and simulation tools/programs. Declarative equation-based programming languages have the problem of equation systems being over-, or under-constrained. This means that the system of equations has more equations than variables or more variables than equations respectively, making the system of equations unsolvable. In this study a static debugger is implemented in OpenModelica compiler for the equation-based programming language Modelica to make it easier for the programmer or modeler to locate the equation/s causing the unconstrained system of equations. The debugging techniques used by the debugger are developed by Peter Bunus. Those techniques are able to detect unconstrained systems of equations and give solutions by identifying the minimal set ofequation/s that should be removed or which variable/s should be added to an equation/s to make the system solvable. In this study the debugging techniques for detecting and giving a solution for over-constrained system of equations are shown suitable to be used for the programming language Modelica in the OpenModelica compiler.

A complete Java interface to OpenModelica has been created, supporting both standard Modelica and the metamodeling extensions in MetaModelica. It is bidirectional, and capable of passing both standard Modelica data types, as well as abstract syntax trees and list structures to and from Java and process them in either Java or the OpenModelica Compiler.It currently uses the existing CORBA interface as well as JNI for standard Modelica. It is also capable of automatically generating the Java classes corresponding to MetaModelica code.This interface opens up increased possibilities for tool integration between OpenModelica and Java-based tools, since for example models or model fragments can be extracted from OpenModelica, processed in a Java tool, and put back into the main model representation in OpenModelica. A first version text generation template language for MetaModelica is also presented. The goal for such a language is the ability to create a more concise and readablecode when translating an abstract syntax tree (AST) to text.

Using the object-oriented, equation-based modeling language Modelica, it is possible to model and simulate computationally intensive models. To reduce the simulation time, a desirable approach is to perform the simulations on parallel multi-core platforms. For this purpose, several works have been carried out so far, the most recent one includes language enhancements with explicit parallel programing language constructs in the algorithmic parts of the Modelica language. This extension automatically generates parallel simulation code for execution on OpenCL-enabled platforms, and it has been implemented in the open-source OpenModelica environment. However, to ensure that this extension as well as future developments regarding parallel simulations of Modelica models are feasible, performing a systematic benchmarking with respect to a set of appropriate Modelica models is essential, which is the main focus of study in this thesis. In this thesis a benchmark test suite containing computationally intensive Modelica models which are relevant for parallel simulations is presented. The suite is used in this thesis as a means for evaluating the feasibility and performance measurements of the generated OpenCL code when using the new Modelica language extension. In addition, several considerations and suggestions on how the modeler can efficiently parallelize sequential models to achieve better performance on OpenCL-enabled GPUs and multi-coreCPUs are also given. The measurements have been done for both sequential and parallel implementations of the benchmark suite using the generated code from the OpenModelica compiler on different hardware configurations including single and multi-core CPUs as well as GPUs. The gained results in this thesis show that simulating Modelica models using OpenCL as a target language is very feasible. In addition, it is concluded that for models with large data sizes and great level of parallelism, it is possible to achieve considerable speedup on GPUs compared to single and multi-core CPUs.

OpenModelica (www.openmodelica.org) is an open-source Modelica-based modeling and simulation environment intended for industrial as well as academic usage. Its long-term development is supported by a non-profit organization – the Open Source Modelica Consortium OSMC, where Linköping University is a member.The main reason behind this thesis was the need for a user friendly, efficient and modular OpenModelica graphical connection editor. The already existing open source editors were either textual or not so user friendly. As a part of this thesis work a new open source Qt-based cross platform graphical user interface was designed and implemented, called OMEdit, partially based on an existing GUI for hydraulic systems, HOPSAN. The usage of Qt C++ libraries makes this tool more future safe and also allows it to be easily integrated into other parts of the OpenModelica platform.This thesis aims at developing an advanced open source user friendly graphical user interface that provides the users with easy-to-use model creation, connection editing, simulation of models, and plotting of results. The interface is extensible enough to support user-defined extensions/models. Models can be both textual and graphical. From the annotation information in the Modelica models (e.g. Modelica Standard Library components) a connection tree and diagrams can be created. The communication to the OpenModelica Compiler (OMC) Subsystem is performed through a Corba client-server interface. The OMC Corba server provides an interactive API interface. The connection editor will function as the front-end and OMC as the backend. OMEdit communicates with OMC through the interactive API interface, requests the model information and creates models/connection diagrams based on the Modelica annotations standard version 3.2.

OMPython is a Python library for OpenModelica, which provides a Python interface to OpenModelica. This thesis significantly improves OMPython by an enhanced, more powerful and easier to use API. It presents how a user can use the Python interface to simulate and access Modelica models using Python objects. The enhanced OMPython includes the list of functions that have been implemented such as getXXXNames(), getXXXValues(), setXXXValues(), getXXXOptions(), setXXXOptions(), and simulate(), etc. that allow users to interact with Modelica model properties(i.e., model variables) and the output of the OpenModelica compiler and simulator. A few Modelica models are used for demonstrations in order to make it easy for readers to understand. By the way, this thesis does not describe modeling Modelica models or compilation of such models.

The Modelica language is a modelling and programming  language for modelling cyber-physical systems using equations and  algorithms. In this thesis two suggested extensions of the Modelica  language are covered. Those are Partial Differential Equations (PDE)  and explicit parallelism in algorithmic code.  While PDEs are not  yet supported by the Modelica language, this thesis presents a  framework for solving PDEs using the algorithmic part of the  Modelica language, including parallel extensions. Different  numerical solvers have been implemented using the explicit parallel  constructs suggested for Modelica by the ParModelica language  extensions, and implemented as part of OpenModelica. The solvers  have been evaluated using different models, and it can be seen how  bigger models are suitable for a parallel solver. The intention has  been to write a framework suitable for modelling and parallel  simulation of PDEs. This work can, however, also be seen as a case  study of how to write a custom solver using parallel algorithmic  Modelica and how to evaluate the performance of a parallel solver.

The practical result of this thesis is an extension to OpenModelica that transforms Modelica into Figaro. Modelica is an equation-based object-oriented modeling language. OpenModelica is an open source implementation of Modelica. Figaro is a language used for reliability modeling. Figaro is a general representation formalism that can be transformed into reliability models like fault trees. Figaro was designed for fault analysis. Modelica was designed to model the behavior of physical systems and run dynamic simulations. Because of that, you cannot just break components and analyze what happens to a system. This work enables us to have fault analysis in OpenModelica by transforming our Modelica model into a Figaro model and invoke the Figaro compiler. This lets us break particular components and see what happens to the system. This work is part of an ongoing effort to integrate several modeling environments.

The move from single core and processor systems to multi-core and many-processors systemscomes with the requirement of implementing computations in a way that can utilizethese multiple units eciently. This task of writing ecient multi-threaded algorithmswill not be possible with out improving programming languages and compilers to providethe mechanisms to do so. Computer aided mathematical modeling and simulationis one of the most computationally intensive areas of computer science. Even simpli-ed models of physical systems can impose a considerable amount of computational loadon the processors at hand. Being able to take advantage of the potential computationpower provided by multi-core systems is vital in this area of application. This thesis triesto address how we can take advantage of the potential computation power provided bythese modern processors to improve the performance of simulations. The work presentsimprovements for the Modelica modeling language and the OpenModelica compiler. Two approaches of utilizing the computational power provided by modern multi-corearchitectures are presented in this thesis: Automatic and Explicit parallelization. Therst approach presents the process of extracting and utilizing potential parallelism fromequation systems in an automatic way with out any need for extra eort from the modelers/programmers side. The thesis explains improvements made to the OpenModelicacompiler and presents the accompanying task systems library for ecient representation,clustering, scheduling proling and executing complex equation/task systems with heavydependencies. The Explicit parallelization approach explains the process of utilizing parallelismwith the help of the modeler or programmer. New programming constructs havebeen introduced to the Modelica language in order to enable modelers write parallelizedcode. the OpenModelica compiler has been improved accordingly to recognize and utilizethe information from this new algorithmic constructs and generate parallel code toimprove the performance of computations. / <p>The series name <em>Linköping Studies in Science and Technology Licentiate Thesis</em> is incorrect. The correct series name is <em>Linköping Studies in Science and Technology Thesis.</em></p>

No description available.

This project presents a feasibility study and an investigation of the potential for low temperature district heating system in Västerås. The investigation treats integrations possibilities for 4GDH (4th Generation District Heating) in Kungsängens area in Västerås, which is undergoing a large-scale building-up and construction.  The study is conducted for the company Mälarenergi AB. The advantages of 4GDH technology are identified and analyzed, where energy effectiveness and economic benefits aspects were concluded. Problems with existing technology and higher cooling demand expectations drive 4GDH to be an interesting and necessary technology in the future. Four Different integration solutions between old and new networks are presented, analyzed and discussed. Quantitative analysis conducted where initial cost for the four technical solutions were estimated and compared. The results show that low temperature district heating could lead to reduction in the initial cost for the network by using PEX instead of steel as pipe material. The results show also that one solution using heat exchanger as exchange stations has the lowest cost between the four solutions. The results show that the cost for the retention flow that is linked with 4GDH stands for 20%-30% of the total cost. The importance of the retention flow pipe is investigated using two physical models in OpenModelica and Excel, where simulations were conducted. It is concluded that it is possible to provide Kungsängen area with low temperature district heating without having the retention flow pipe. Three parameters were identified to be critical which are, geographical placement of the consumers, pattern variation for the heat demand and heat systems installed inside consumer’s buildings. The results show also that it might be critical to have a variate and optimized supply temperature for the area, depending on the demand. The simulations of a fictive area that could present a future heat demand for Kungsängen area shows that a temperature of 55°C is satisfying during winter season where the demand is high and a temperature between 60-65°C must be available during spring/autumn seasons and specially during summer. The variation depends directly on the temperature drop through the supply pipes to the consumers. The temperature drop is directly linked with water velocity inside the pipes. The losses increase during summer nights when the heat demand is low which lead to low water velocities.