Embedding a Functional Hybrid Modelling Language in Haskell

This paper explores how to implement an iteratively staged domain-specific language (DSL) by embedding into a functional language. The domain is modelling and simulation of physical systems where models are expressed in terms of non-causal differential-algebraic equations; i.e., sets of constraints solved through numerical simulation. What distinguishes our language is that the equational constraints are first class entities allowing for an evolving model structure characterised by repeated generation of updated constraints. Hence iteratively staged. Our DSL can thus be seen as a combined functional and constraint programming language, albeit a two-level one, with the functional language chiefly serving as a meta language. However, the two levels do interact throughout the simulation. The embedding strategy we pursue is a mixture of deep and shallow, with the deep embedding enabling justin-time (JIT) compilation of the constraints as they are generated for efficiency, while the shallow embedding is used for the remainder for maximum leverage of the host language. The paper is organised around a specific DSL, but our implementation strategy should be applicable for iteratively staged languages in general. Our DSL itself is further a novel variation of a declarative constraint programming language.

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

Port-based modeling of mechatronic systems

A framework for compiler construction of functional programming languages is described. The framework has been designed to allow experimenting with functional programming languages and their implementations. Its three main characteristics are: (1) given the existing implementation of a functional programming language (not necessary in a source code), the implementation of a new functional programming language can be easily and efficiently developed, using the framework; (2) the framework enables enhancement of already implemented languages with new features; and (3) implementations of the languages in the framework are transparent, which can be freely exchanged between the languages.

With processor architecture evolution, the HPC market has undergone a paradigm shift. The adoption of low-cost, Linux-based clusters extended the reach of HPC from its roots in modelling and simulation of complex physical systems to a broader range of industries, from biotechnology, cloud computing, computer analytics and big data challenges to manufacturing sectors. In this perspective, the near future HPC systems can be envisioned as composed of millions of low-power computing cores, densely packed — meaning cooling by appropriate technology — with a tightly interconnected, low latency and high performance network and equipped with a distributed storage architecture. Each of these features — dense packing, distributed storage and high performance interconnect — represents a challenge, made all the harder by the need to solve them at the same time. These challenges lie as stumbling blocks along the road towards Exascale-class systems; the ExaNeSt project acknowledges them and tasks itself with investigating ways around them.

Many real-life applications of processor-arrays suffer from memory bandwidth limitations. In many cases an unstructured mesh is given (computation on sensor data, simulations of physical systems — PDEs), where the vertices represent computations with dependencies represented by the edges. Utilization of processing elements (PEs) during these computations is mainly depends on the node indexing of the mesh. If the adjacent nodes are stored close to each other in main memory, the reloading of node data can be significantly decreased. In case of FPGA the memory accesses can be fully determined by the designer. The mesh and an ordering of its nodes, define the graph bandwidth, which determines the minimum size of on-chip memory to avoid reloading of the nodes from the off-chip memory. If the required on-chip memory size is higher than the available resources, the mesh must be divided into parts. In this paper a novel geometry-based method is presented, which constructs reordered parts from a given unstructured mesh, where each part meets some predefined constraints on graph bandwidth.

An Integrated Intelligent Modeling and Simulation Language for Model-based Systems Engineering

Removing partial parametrization for efficient implementation of functional languages

The simulation of complex physical systems using a discretized mesh is a cornerstone of applied mechanics, but traditional numerical solvers are often computationally prohibitive for many-query tasks. While Graph Neural Networks (GNNs) have emerged as powerful surrogate models for mesh-based data, their standard autoregressive application for long-term prediction is often plagued by error accumulation and instability. To address this, we introduce MeshODENet, a general framework that synergizes the spatial reasoning of GNNs with the continuous-time modeling of Neural Ordinary Differential Equations. We demonstrate the framework's effectiveness and versatility on a series of challenging structural mechanics problems, including different elastic bodies undergoing large, non-linear deformations. The results demonstrate that our approach significantly outperforms baseline models in long-term predictive accuracy and stability, while achieving substantial computational speed-ups over traditional solvers. This work presents a powerful and generalizable approach for developing data-driven surrogates to accelerate the analysis and modeling of complex structural systems.

The paper is a partial synthesis of the work that a team within the Faculty of Managerial and Technological Engineering has in the field of modeling and simulation of systems with Petri nets. The paper deals with three issues. The first part is Modeling and simulation of manufacturing systems with timed Petri nets. The first part presents the way in which the performances of some manufacturing systems are evaluated using timed Petri nets. The first example is a manufacturing system specific to the textile industry. The system has three production lines. In this case, the modeling with timed Petri nets allows the analysis of the operation of the flow lines and highlights the bottleneck. Another modeled manufacturing system is specific to a series production, more precisely it refers to the manufacture of gas cookers within a company from Oradea. The model with Petri nets also describes the supply sequences of the stocks of parts and subassemblies. The next modeled system is an automated manufacturing system for the packaging of detergents. The complexity of the Detergent Packing System and the high level of automation, require the use of efficient modeling and simulation methods to verify the validity of the solutions adopted. In this chapter is present the model of a robotic welding cell. The second part of the paper, the transition from timed Petri nets to hierarchical colored Petri nets, shows how Petri nets were developed for a robotic cell for metallographic analysis. The third part is dedicated to modeling with colored Petri nets timed with complex colors of the flexible manufacturing cell A007 within the Department of Industrial Engineering.

Computational Approaches in Physics reviews computational schemes which are used in the simulations of physical systems. These range from very accurate ab initio techniques up to coarse-grained and mesoscopic schemes. The choice of the method is based on the desired accuracy and computational efficiency. A bottom-up approach is used to present the various simulation methods used in Physics, starting from the lower level and the most accurate methods, up to particle-based ones. The book outlines the basic theory underlying each technique and its complexity, addresses the computational implications and issues in the implementation, as well as present representative examples. A link to the most common computational codes, commercial or open source is listed in each chapter. The strengths and deficiencies of the variety of techniques discussed in this book are presented in detail and visualization tools commonly used to make the simulation data more comprehensive are also discussed. In the end, specific techniques are used as bridges across different disciplines. To this end, examples of different systems tackled with the same methods are presented. The appendices include elements of physical theory which are prerequisites in understanding the simulation methods.

Many computational problems that turn up in industry, operations research, network design, artificial intelligence, simulation of physical systems, logic, number theory, combinatorics, algebra, and computational biology lack a fast or feasible algorithmic solution. The best known algorithms for these problems are horrendously slow. One of the central open problems in computer science is the question of whether this slowness is inherent in these problems or that we simply lack good programming techniques. This question is known as the P versus NP question. The hardest computational problems of the above type are called NP-complete problems. It is widely believed that there does not exist a feasible algorithmic solution for these NP-complete problems.

Integrating Experimental Data and Mathematical Models in Simulation of Physical Systems

Computational Approaches in Physics reviews computational schemes which are used in the simulations of physical systems. These range from very accurate ab initio techniques up to coarse-grained and mesoscopic schemes. The choice of the method is based on the desired accuracy and computational efficiency. A bottom-up approach is used to present the various simulation methods used in Physics, starting from the lower level and the most accurate methods, up to particle-based ones. The book outlines the basic theory underlying each technique and its complexity, addresses the computational implications and issues in the implementation, as well as present representative examples. A link to the most common computational codes, commercial or open source is listed in each chapter. The strengths and deficiencies of the variety of techniques discussed in this book are presented in detail and visualization tools commonly used to make the simulation data more comprehensive are also discussed. In the end, specific techniques are used as bridges across different disciplines. To this end, examples of different systems tackled with the same methods are presented. The appendices include elements of physical theory which are prerequisites in understanding the simulation methods.

The random batch Ewald (RBE) is an efficient and accurate method for molecular dynamics (MD) simulations of physical systems at the nano/microscale. The method shows great potential to solve the computational bottleneck of long-range interactions, motivating a necessity to accelerate short-range components of the nonbonded interactions for a further speedup of MD simulations. In this work, we present an improved RBE method for the nonbonding interactions by introducing the random batch idea to constructing neighbor lists for the treatment of both the short-range part of the Ewald splitting and the Lennard-Jones potential. The efficiency that the novel neighbor list algorithm owes to the stochastic minibatch strategy can significantly reduce the total number of neighbors. We obtain the error estimate and convergence by theoretical analysis and implement the improved RBE method in the LAMMPS package. Benchmark simulations are performed to demonstrate the accuracy and stability of the algorithm. Numerical tests on computer performance by conducting large-scaled MD simulations for systems including up to 0.1 billion water molecules are run on massive clusters with up to 50000 CPU cores, demonstrating the attractive features such as the high parallel scalability and memory-saving of the method in comparison to the existing methods.