Skip to content

Modelon Impact Terminology🔗


Application Programming Interface (API) is a defined connection between Modelon Impact and other programs. Modelon Impact has the following defined APIs: Python.

Assimulo simulation package🔗

Assimulo is a simulation package for solving ordinary differential equations. Further documentation.


Annotations are parts of Modelica models that store additional information about a model (Modelica keyword annotation). Any class, instance and equation may have an annotation. Examples of what is stored in the form of annotations are documentation, icons, version numbers and model-specific default solver settings.

Boundary condition🔗

A boundary condition is something that is given during a simulation, I.e. it isn’t solved but a specified condition. To run a simulation, typically a boundary condition is applied to a component or system model. The result is a simulation model, e.g. a model that can be simulated or executed. This can be seen as a virtual experiment, e.g answering the question of how would this component or system behave, under these conditions (specified as boundary conditions).


An application to access the World Wide Web. Modelon Impact is accessed through a browser regardless of setup. Modelon Impact works with Chromium browsers such as Chrome, Edge, and Opera. Other browsers such as Firefox and Safari will result in an error message. Modelon recommends using the Chrome browser.


The canvas is the central area of the Modelon Impact GUI. The canvas is where class/model layers are shown and edited, and also where the result is presented in the form of stickies and plots. The canvas can be the Diagram View or the Code View of a class/model.


The order in which variables are solved.


The fundamental structuring unit of modeling in Modelica is the class. Classes provide the structure for objects, also known as instances. Classes can contain equations that provide the basis for the executable code that is used for computation in Modelica. Conventional algorithmic code can also be part of classes. All data objects in Modelica are instantiated from classes, including the basic data types – Real, Integer, String, Boolean – and enumeration types, which are built-in classes or class schemata. Declarations are the syntactic constructs needed to introduce classes and objects (i.e., components). Source:

Custom Function🔗

A Custom Function is an integrated Python interface to Modelon Impact. With a Custom Function a user can define a function that does a computation or another operation on an FMU or a model, call it from the simulation browser and return back the result to the result browser.


A component in Modelica usually refers to a component model, e.g. a model describing some behavioral aspect of a physical component or part. A component model is defined by a Modelica class, I.e. a set of variables and equations. A component has to be balanced, I.e. has the same number of unknowns as equations. However that may assume that some connector variables will be assigned from the outside, e.g. adjacent components in a system, or directly defined as boundary conditions. Component models can therefore not usually be simulated, or executed, in itself. Component may also refer to a particular instance of a component model.


Before a simulation, a model must be compiled and execute all algorithms.

Compilation is the process of converting acausal equations of a Modelica model to executable code. That involves symbolic processing of the model equations, as well as integration with numerical solvers and compilation to machine executable code. Modelon Impact uses the FMI standard for compiled models, and the output of the compilation process consequently is an FMU.

Compilation error🔗

Compilation error a failure in the compilation process means that the Modelica code couldn’t be converted to executable code. This can be due to an error in the Modelica code so that it cannot be interpreted properly, or that the specified model is for some reason not possible to formulate as a DAE. If the compilation of a model fails, Modelon Impact will provide an error log that will aid in identifying the problem.


A Connector is a specialized Modelica class that defines how components interact. In contrast to signal-based modeling tools, a connection typically carries information both ways in Modelica. A connector may define one or more variables, and certain variable types (flow and stream) are available for connectors. Connectors don’t impose causality for variables. When two components are connected by dragging a line from one connector to the other, a “connect statement” is created. In the compilation process, the connect statement is converted to equations depending on the variable types in the connector. Ordinary variables are set equal to each other, and for flow variables the sum is computed and set equal to zero.


When simulating a CS FMU, the numerical solver is embedded and supplied by the exporting tool. The importing tool will set the inputs, tell the FMU to step forward at a given time, and then read the outputs. Modelon blog post.


DAE – Differential-algebraic system of equations, is a system of equations that either contains differential equations and algebraic equations. Modelica is a high-level language for specifying DAEs.


A desktop computer is a personal computer designed for regular use at a single location. A Desktop installation of Modelon Impact refers to the installation only being available on a specific computer.

Detail panel🔗

The detail panel area to the right of the model canvas is used to configure the model, set up experiments and access simulation results.

Diagram layer or Diagram View🔗

The Diagram layer or the Diagram View of a class/model shows all component model instances, connections and other objects with a Diagram annotation. The Diagram layer is rendered from component model icon layers, component instances location annotations, and line annotations of connect statements. It’s also possible to edit the model directly in the Diagram layer. If components are added, moved or removed, the corresponding changes are immediately applied to the Modelica code by Modelon Impact. The Diagram layer is a powerful way of visualizing an equation-based model.

Digital twin🔗

A digital twin is a virtual representation that serves as the real-time digital counterpart of a physical object or process. Digital Twin in Wikipedia

Dynamic analysis🔗

A dynamic analysis means the analysis of the dynamic, e.g. time-dependent, behavior of a system.

Dynamic model🔗

Dynamic model is a model of a system or component that describes a least some aspect of the system dynamics, I.e. how the system will behave over time. In Modelica, this means that the time derivative of at least one variable is involved in some model equation.

Dynamic simulation🔗

Dynamic simulation means simulating a model over time (in the time domain). I.e. answering the question, if I start at a certain time in a certain (dynamic) state, what will the (dynamic) state be at a future point in time? Technically this means numerical integration concerning time for the dynamic state variables, that the dynamic model gives derivatives for.

Dynamic state variables🔗

Dynamic state variables are the variables that the numerical solver integrates in time-domain during the simulation. Intuitively, they can be seen as the model degrees of freedom, I.e. at any given point in time, all model variables are determined by the values of the dynamic state variables and the boundary conditions.


An element in Modelica usually refers to a component model, but also to parameters, variables, and more. Components are a subset of elements a class is composed of. The element may also refer to a particular instance of a component model.


Execute to run executable code


An Experiment is the process of extracting information from a system by exercising its inputs. The term can be used for a model that is balanced without assuming any external inputs, e.g. the model includes both boundary conditions and some model that should be solved under said boundary conditions. Impact also has an “experimentation layer” where additional Experiments can be created from the same model, effectively those experiments are sets of model parameters that will be applied to the model in the execution of those Experiments.


For inheritance of classes the Modelica keyword extends is used. A class may extend some other class and thereby apply all of the extended class objects to itself. Inheritance is a powerful concept that allows code reuse and the creation of configurable models. Multiple models may inherit the same class (then usually called a base class), and a model may declare replaceable objects which allows users to change between different classes that inherit a certain base class.


FMI – Functional Mock-up Interface is an open standard interface for the exchange of dynamic models. Modelon Impact uses it to represent compiled models.

FMU file🔗

FMU file an FMU contains a simulation model that adheres to the FMI standard. Tags Model Exchange, Co-Simulation


final is a Modelica keyword that means that a parameter or constant may no longer be modified (have its value changed) at inheritance or instantiation. Normally, parameters and constant values may be changed at inheritance and instantiation.


Git is an open-source distributed version control system. Documentation on GIT.


GUI – Graphical User Interface allows the user to access Modelon Impact’s functionality through the use of a mouse by clicking icons and accessing menus in the system. Modelon Impact GUI consists of four (4) main areas: App bar, Workspace panel, Details panel and Model canvas.

Hierarchical system modeling🔗

A hierarchical model is a model in which lower levels are sorted under a hierarchy of successively higher-level units.

Hybrid systems🔗

Hybrid Systems a system that combines continuous time and discrete time equations. The discrete part can come from sampling, a state graph or any logical operation in the physical model. They are normally more difficult to integrate and require specific solvers that are efficient in event handling.

Icon layer🔗

The icon layer (in Modelica) defines the appearance of a class in the package browser and its instance in the Diagram layer (Modelica) of another class. Drawing nice icons of models improves the visual appearance and readability of a model.


Inheritance is when a class, like a model, function or package, takes all objects and properties of a different (parent) class and applies them to itself. See also extends keyword


Instantiation can be seen as the manifestation of a class. The class describes how a component or system behaves, but to simulate it, an instance is needed. Only instance variables are computed when a model is simulated. In Impact, classes are collected in the Workspace panel (left side) and instances are created by drag-and-drop to the model canvas (center). Values given to parameters in classes are merely default values and may be changed for every instance. This is done by clicking on the component instance on the canvas and giving values in the Details panel (right side).


Initialization means solving all model variables at the start time. Usually, the start time is t = 0.

Iteration variables🔗

Iteration variables ("IV") are variables that Modelon Impact iterates in order to solve a system of equations when it cannot be solved by forward calculations only. The process involves evaluating the model variables for assumed values of the iteration variables, testing them as a solution and finding new values closer to the solution. Iteration variables can be selected automatically by Impact, or defined manually by the model author utilizing annotations.


Intervals refer to the time gaps between result points in a dynamic simulation. In the result points the solver has ensured that the model equations are fulfilled to a certain tolerance. In between those time points result points are interpolated to produce plots. The number of intervals or the time between result points can be specified by solver settings in Impact.

Inspect component🔗

"Inspect component" means that you peek into an instantiated component while still keeping the current class open. Compared to “Open class” you cannot edit anything while inspecting a component, however, what you see there will reflect any modifications to the instance done in the open class.

Jupyter Lab🔗

Jupyter Lab or JupyterLab is the latest web-based interactive development environment for Python notebooks, code, and data.

Jupyter Notebook🔗

The Jupyter Notebook is a web-based interactive computing platform. The notebook combines live code, equations, narrative text and visualizations. Jupyter Notebook's documentation page.


Kubernetes, also known as K8s, is an open-source system for automating the deployment, scaling, and management of containerized applications. Kubernetes' documentation page


Modelon uses the term Library for officially released Modelica packages (of components, example models, and tutorials). They are usually provided as read-only. In the Modelica language specifications, it is used as a synonym for a top-level package. So, a top-level package is always a Library.

Library browser🔗

The Library browser is part of the Workspace panel where you see and browse read-only Modelica Libraries that are included in your Modelon Impact.

Linear system🔗

A "linear system" is a system of linear equations involving the same set of variables.


Linearize means to create a linear approximation of a system of nonlinear equations, by computing derivatives of non-linear parts at a certain point, and using those as coefficients.


A log is a record of an event. Modelon Impact shows compilation logs and simulation logs.


Broadly, a model of a system is basically anything an experiment can be applied to in order to analyze the system's behavior. In Impact, a model is a class comprising several equations that describe the physical behavior of a system or component. A component model may require that variables be assigned externally, while a model that doesn’t require external input is called a simulation model and can be simulated as it is.

Please note, that simulation__ models are a subset of "models". Please read more in the section simulation model.

Model canvas🔗

The area where you can view the Diagram of a model and where you can design and change models in a GUI. See also “Canvas”

Model Exchange FMU🔗

Model Exchange FMU In an ME FMU, the numerical solver is supplied by the importing tool. The FMU provides functions to set the state and inputs, and to compute the state derivatives (i.e., the left-hand side of the equation). The solver in the importing tool will determine what time steps to use, and how to compute the state at the next time step. Modelon blog post.


Modelica - language for creating models used in Impact. Modelica's documentation page.

The navigation bar is the top part of Modelon Impact graphical user interface (GUI), displays in which mode the user is in, model, experiment or results as well as provides access to settings, help center and support.

Non-linear system🔗

A "non-linear system" is a system of nonlinear equations involving the same set of variables. These are solved numerically using tearing. That means that a set of unknown variables are taken as iteration variables, their values are guessed, and the rest of the variables in the system are computed from these. All equations of the system will not hold when values different from the solution are used. Those are called residual equations. The residuals for a certain variable guess can be used to find better guesses and eventually the solution to the non-linear system, where all equations hold.


The OPTIMICA Compiler Toolkit (OCT) is the calculation engine (both compiler and solver) used by Modelon Impact. It comes with a Modelica compiler with capabilities beyond dynamic simulation by offering unique features for optimization and steady-state computations. See also OCT reference.


On-premises software is installed and runs on computers on the premises of the organization using the software. Modelon Impact On-premise installation is available to all users within an organization that has a valid license.

Over-constrained model🔗

Over-constrained model is a model with more equations than unknown variables. It is normally not allowed in Modelica, with one exception, see the Modelica Language Specification.


The Package is a "container class" to collect models and other Modelica classes to organize library content. A package may contain other packages, classes and constants. The equivalent to a folder in a file system. All Libraries are packages!


A parameter is similar to a model variable, but may not vary over time. Parameters may be given default values in the model, get changed at inheritance and instantiation (except if they have a final prefix). Parameters may be computed from other parameters. Parameters may also be implicitly defined, by giving a fixed=false attribute and providing an initial equation from which it can be solved. In this case, the parameter value is solved during initialization. A parameter is structural if it influences the numerical structure of the model, like the number of equations. Structural parameters are determined at model compilation. Other parameters can be changed without the need to re-compile the model.

Parameterization means to assign values to a model's parameters.


User work in Projects, which means Projects are editable and all the data is stored there. You can have multiple Projects in your Workspace. Each Projects can contain Modelica libraries/packages (normal case).

Rest API🔗

A REST API is an application programming interface (API or web API) that conforms to the constraints of REST architectural style and allows for interaction with RESTful web services. Modelon Impact REST API.


Record is a Modelica class that may only include variables, parameters and constants, but not equations or algorithms. They are typically used for collecting parameters or variables, to make them easier to find or propagate.


Replacing a component with a compatible component is referred to as redeclaring the component model. Components that can be redeclared are said to be replaceable and are shown with dashed line borders in the model canvas. From a Modelica point-of-view, redeclare means to change the class of an instance or local class.


Simulate means to solve all model equations so that the values of all variables become known.

A simulation is an experiment performed on a model.

Simulation model🔗

A simulation model, as defined in the Modelica language specification, is declared as: - model, or - block, or - class.

All without declaration prefixes like partial or replaceable. Simulation models can be simulated in Impact. Modelon Impact will ensure that there is an Experiment and enable the Play button.


The solver is part of Impact that computes the resulting time trajectories of all model variables during simulation. From the start time, the solver evaluates the model equations to obtain the time derivatives of the dynamic state variables. Those derivatives are used to compute state variable values in future time points. Different solvers are available and will perform differently.


A time-independent simulation. A steady-state model is a model that performs a system or component under certain conditions assuming it is left in those conditions until the modeled aspect is no longer changing. A steady-state model consists of algebraic equations, while a dynamic model also includes differential equations. A dynamic model can also be solved in steady-state by giving the boundary condition that all derivatives are zero. Since model equations are typically non-linear, solving industrial steady-state problems means solving large non-linear systems.

State – See Dynamic state variable.


Stickies are used in Modelon Impact to visualize parameters and variables in the model canvas. Go to Stickies.


A system is an object or collection of objects whose properties we want to study


Additional documents or content are accessed in a Workspace or Details panel.


Templates – model examples designed so the user can select components to insert. Templates are found in the library documentation and found through the filter function in the Workspace panel.


Tools are programs used to access advanced Modelon Impact capabilities such as VS Code, Jupyter Hub, Jupyter Lab, or Jupyter Notebook.


Step-by-step instructions from an engineering question to a result. A workflow can be automated or be a set of documented instructions.


The Workspace is a virtual configuration in the user space, where a user defines which Projects and Libraries are used. Data (models, experiments, etc.) will be stored in Projects. Results will be stored outside of Workspaces and are linked to a Project.

Workspace panel🔗

The Workspace panel shows the active Workspace, which contains Projects (top) and Libraries (bottom) and their contents. The filter function helps find relevant components and models.

Version control🔗

Version control is the practice of tracking and managing changes to software code.


A variable is a notation for the value that may change over time (during simulation). A variable may be given a value explicitly, or need to be solved from model equations.


Views are composed of stickies and result charts (plots) and belong to a specific Modelica class. Views define user-defined and simplified access to parameters etc. and can be saved.