diff --git a/.gitignore b/.gitignore
deleted file mode 100644
index f2daa098..00000000
--- a/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-.vscode/
-examples/src/.ipynb_checkpoints/
-Manifest.toml
diff --git a/examples/Project.toml b/examples/Project.toml
deleted file mode 100644
index c2c217e5..00000000
--- a/examples/Project.toml
+++ /dev/null
@@ -1,16 +0,0 @@
-name = "Examples"
-
-[deps]
-BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
-DifferentialEquations = "0c46a032-eb83-5123-abaf-570d42b7fbaa"
-FMI = "14a09403-18e3-468f-ad8a-74f8dda2d9ac"
-FMICore = "8af89139-c281-408e-bce2-3005eb87462f"
-FMIZoo = "724179cf-c260-40a9-bd27-cccc6fe2f195"
-Folds = "41a02a25-b8f0-4f67-bc48-60067656b558"
-IJulia = "7073ff75-c697-5162-941a-fcdaad2a7d2a"
-Optim = "429524aa-4258-5aef-a3af-852621145aeb"
-Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
-Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
-
-[compat]
-julia = "1.6"
diff --git a/examples/README.md b/examples/README.md
deleted file mode 100644
index 8e41e396..00000000
--- a/examples/README.md
+++ /dev/null
@@ -1,39 +0,0 @@
-
-
-# Structure
-
-Examples can be found in the [examples folder in the examples branch](https://github.com/ThummeTo/FMI.jl/tree/examples/examples) or the [examples section of the documentation](https://thummeto.github.io/FMI.jl/dev/examples/overview/). All examples are available as Julia-Script (*.jl*), Jupyter-Notebook (*.ipynb*) and Markdown (*.md*).
-
-
-# Getting Started
-
-## Install Jupyter in Visual Studio Code
-The Jupyter Notebooks extension for Visual Studio Code can be [here](https://marketplace.visualstudio.com/items?itemName=ms-toolsai.jupyter).
-
-## Add Julia Kernel to Jupyter
-To run Julia as kernel in a jupyter notebook it is necessary to add the **IJulia** package.
-
-1. Start the Julia REPL.
-
- ```
- julia
- ```
-
-2. Select your environment.
- ```julia
- using Pkg
- Pkg.activate("Your Env")
- ```
-
-3. Add and build the IJulia package by typing inside the Julia REPL.
-
- ```julia
- using Pkg
- Pkg.add("IJulia")
- Pkg.build("IJulia")
- ```
-
-4. Now you should be able to choose a Julia kernel in a Jupyter notebook.
-
-
-More information can be found [here](https://towardsdatascience.com/how-to-best-use-julia-with-jupyter-82678a482677).
diff --git a/examples/pluto-src/FMUExplorer/FMUExplorer.html b/examples/pluto-src/FMUExplorer/FMUExplorer.html
deleted file mode 100644
index c0ce0bc8..00000000
--- a/examples/pluto-src/FMUExplorer/FMUExplorer.html
+++ /dev/null
@@ -1,18 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
diff --git a/examples/pluto-src/pluto_export.json b/examples/pluto-src/pluto_export.json
deleted file mode 100644
index 98e92cbd..00000000
--- a/examples/pluto-src/pluto_export.json
+++ /dev/null
@@ -1 +0,0 @@
-{"notebooks":{"FMUExplorer/FMUExplorer.jl":{"id":"FMUExplorer/FMUExplorer.jl","hash":"skk-usn2fuZ51Nz88pnKXE9Gd_xEz8RaPJ_CWE6CBd0","html_path":"FMUExplorer/FMUExplorer.html","statefile_path":null,"notebookfile_path":null,"current_hash":"skk-usn2fuZ51Nz88pnKXE9Gd_xEz8RaPJ_CWE6CBd0","desired_hash":"skk-usn2fuZ51Nz88pnKXE9Gd_xEz8RaPJ_CWE6CBd0","frontmatter":{"title":"FMUExplorer"}}},"pluto_version":"0.19.46","julia_version":"1.10.5","format_version":"1","title":null,"description":null,"collections":null,"binder_url":"https://mybinder.org/v2/gh/fonsp/pluto-on-binder/v0.19.46","slider_server_url":null}
\ No newline at end of file
diff --git a/examples/src/.gitignore b/examples/src/.gitignore
deleted file mode 100644
index 761fabac..00000000
--- a/examples/src/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-FMI_*_Benchmark/
-tmp/
\ No newline at end of file
diff --git a/examples/src/inputs.ipynb b/examples/src/inputs.ipynb
deleted file mode 100644
index 5b1e0b77..00000000
--- a/examples/src/inputs.ipynb
+++ /dev/null
@@ -1,233 +0,0 @@
-{
- "cells": [
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Simulate an FMU with inputs\n",
- "Tutorial by Tobias Thummerer\n",
- "\n",
- "🚧 This tutorial is under revision and will be replaced by an up-to-date version soon 🚧\n",
- "\n",
- "## License"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:28:04.723000Z",
- "iopub.status.busy": "2022-10-22T13:28:04.017000Z",
- "iopub.status.idle": "2022-10-22T13:28:04.999000Z",
- "shell.execute_reply": "2022-10-22T13:28:04.926000Z"
- }
- },
- "outputs": [],
- "source": [
- "# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar\n",
- "# Licensed under the MIT license. \n",
- "# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Introduction to the example\n",
- "This example shows how to add custom inputs to a FMU, that are used during simulation.\n",
- "\n",
- "## Other formats\n",
- "Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/inputs.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/inputs.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/inputs.md) corresponding to the notebook. \n",
- "\n",
- "## Code section"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:28:05.004000Z",
- "iopub.status.busy": "2022-10-22T13:28:05.004000Z",
- "iopub.status.idle": "2022-10-22T13:28:49.082000Z",
- "shell.execute_reply": "2022-10-22T13:28:49.082000Z"
- }
- },
- "outputs": [],
- "source": [
- "# imports\n",
- "using FMI\n",
- "using FMIZoo\n",
- "using Plots\n",
- "using DifferentialEquations"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Simulation setup\n",
- "\n",
- "Next, the start time and end time of the simulation are set. Finally, a step size is specified to store the results of the simulation at these time steps."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:28:51.448000Z",
- "iopub.status.busy": "2022-10-22T13:28:49.085000Z",
- "iopub.status.idle": "2022-10-22T13:28:52.234000Z",
- "shell.execute_reply": "2022-10-22T13:28:52.233000Z"
- }
- },
- "outputs": [],
- "source": [
- "tStart = 0.0\n",
- "tStep = 0.01\n",
- "tStop = 8.0\n",
- "tSave = tStart:tStep:tStop"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Import FMU\n",
- "\n",
- "Next, the FMU model from *FMIZoo.jl* is loaded."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:28:52.238000Z",
- "iopub.status.busy": "2022-10-22T13:28:52.237000Z",
- "iopub.status.idle": "2022-10-22T13:28:57.034000Z",
- "shell.execute_reply": "2022-10-22T13:28:57.034000Z"
- }
- },
- "outputs": [],
- "source": [
- "# we use an FMU from the FMIZoo.jl\n",
- "fmu = loadFMU(\"SpringPendulumExtForce1D\", \"Dymola\", \"2022x\"; type=:ME) # load FMU in ME-Mode (\"Model Exchange\")"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### Simulate as Model-Exchange\n",
- "\n",
- "In the function `simulate()` the FMU is simulated with an adaptive step size but with fixed save points `tSave`. In addition, the start and end time are specified. Note, that the dynamics of the input variables are not considered by the steps ize control of the solver, so it is highly recommended to limit the solver step size with the keyword argument `dtmax` if the input is more dynamic than the system."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:29:04.979000Z",
- "iopub.status.busy": "2022-10-22T13:29:04.978000Z",
- "iopub.status.idle": "2022-10-22T13:29:21.052000Z",
- "shell.execute_reply": "2022-10-22T13:29:21.052000Z"
- }
- },
- "outputs": [],
- "source": [
- "# input function format \"t\", dependent on `t` (time)\n",
- "function extForce_t(t::Real, u::AbstractArray{<:Real})\n",
- " u[1] = sin(t)\n",
- "end \n",
- "\n",
- "# simulate while setting inputs\n",
- "data_extForce_t = simulate(fmu, (tStart, tStop); # FMU, start and stop time\n",
- " solver = Tsit5(),\n",
- " saveat=tSave, # timepoints for the ODE solution to be saved\n",
- " inputValueReferences=[\"extForce\"], # the value references that should be set (inputs)\n",
- " inputFunction=extForce_t, # the input function to be used\n",
- " dtmax=1e-2, # limit max step size to capture inputs\n",
- " showProgress=false) # disable progress bar\n",
- "plot(data_extForce_t)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# input function format \"cxt\", dependent on `c` (component), `x` (state) and `t` (time)\n",
- "function extForce_cxt(c::Union{FMU2Component, Nothing}, x::Union{AbstractArray{<:Real}, Nothing}, t::Real, u::AbstractArray{<:Real})\n",
- " x1 = 0.0\n",
- " if x != nothing # this check is important, because inputs may be needed before the system state is known\n",
- " x1 = x[1] \n",
- " end\n",
- " u[1] = sin(t) * x1\n",
- " nothing\n",
- "end \n",
- "\n",
- "# simulate while setting inputs\n",
- "data_extForce_cxt = simulate(fmu, (tStart, tStop); saveat=tSave, inputValueReferences=[\"extForce\"], inputFunction=extForce_cxt, dtmax=1e-2, showProgress=false)\n",
- "plot(data_extForce_cxt)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Unload FMU\n",
- "\n",
- "After plotting the data, the FMU is unloaded and all unpacked data on disc is removed."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:30:01.970000Z",
- "iopub.status.busy": "2022-10-22T13:30:01.970000Z",
- "iopub.status.idle": "2022-10-22T13:30:02.010000Z",
- "shell.execute_reply": "2022-10-22T13:30:02.010000Z"
- }
- },
- "outputs": [],
- "source": [
- "unloadFMU(fmu)"
- ]
- }
- ],
- "metadata": {
- "interpreter": {
- "hash": "037537ff7419c497b9325f7d495147943224d408cf5d5ed915294a5b960167b0"
- },
- "jupytext": {
- "cell_metadata_filter": "-all",
- "comment_magics": "false",
- "notebook_metadata_filter": "-all"
- },
- "kernelspec": {
- "display_name": "Julia 1.10.4",
- "language": "julia",
- "name": "julia-1.10"
- },
- "language_info": {
- "file_extension": ".jl",
- "mimetype": "application/julia",
- "name": "julia",
- "version": "1.10.5"
- },
- "nteract": {
- "version": "0.28.0"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/examples/src/inputs.jl b/examples/src/inputs.jl
deleted file mode 100644
index bfadd274..00000000
--- a/examples/src/inputs.jl
+++ /dev/null
@@ -1,48 +0,0 @@
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-
-# imports
-using FMI
-using FMIZoo
-using Plots
-using DifferentialEquations
-
-tStart = 0.0
-tStep = 0.01
-tStop = 8.0
-tSave = tStart:tStep:tStop
-
-# we use an FMU from the FMIZoo.jl
-fmu = loadFMU("SpringPendulumExtForce1D", "Dymola", "2022x"; type=:ME) # load FMU in ME-Mode ("Model Exchange")
-
-# input function format "t", dependent on `t` (time)
-function extForce_t(t::Real, u::AbstractArray{<:Real})
- u[1] = sin(t)
-end
-
-# simulate while setting inputs
-data_extForce_t = simulate(fmu, (tStart, tStop); # FMU, start and stop time
- solver = Tsit5(),
- saveat=tSave, # timepoints for the ODE solution to be saved
- inputValueReferences=["extForce"], # the value references that should be set (inputs)
- inputFunction=extForce_t, # the input function to be used
- dtmax=1e-2, # limit max step size to capture inputs
- showProgress=false) # disable progress bar
-plot(data_extForce_t)
-
-# input function format "cxt", dependent on `c` (component), `x` (state) and `t` (time)
-function extForce_cxt(c::Union{FMU2Component, Nothing}, x::Union{AbstractArray{<:Real}, Nothing}, t::Real, u::AbstractArray{<:Real})
- x1 = 0.0
- if x != nothing # this check is important, because inputs may be needed before the system state is known
- x1 = x[1]
- end
- u[1] = sin(t) * x1
- nothing
-end
-
-# simulate while setting inputs
-data_extForce_cxt = simulate(fmu, (tStart, tStop); saveat=tSave, inputValueReferences=["extForce"], inputFunction=extForce_cxt, dtmax=1e-2, showProgress=false)
-plot(data_extForce_cxt)
-
-unloadFMU(fmu)
diff --git a/examples/src/inputs.md b/examples/src/inputs.md
deleted file mode 100644
index 2df82dee..00000000
--- a/examples/src/inputs.md
+++ /dev/null
@@ -1,225 +0,0 @@
-# Simulate an FMU with inputs
-Tutorial by Tobias Thummerer
-
-🚧 This tutorial is under revision and will be replaced by an up-to-date version soon 🚧
-
-## License
-
-
-```julia
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-```
-
-## Introduction to the example
-This example shows how to add custom inputs to a FMU, that are used during simulation.
-
-## Other formats
-Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/inputs.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/inputs.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/inputs.md) corresponding to the notebook.
-
-## Code section
-
-
-```julia
-# imports
-using FMI
-using FMIZoo
-using Plots
-using DifferentialEquations
-```
-
-### Simulation setup
-
-Next, the start time and end time of the simulation are set. Finally, a step size is specified to store the results of the simulation at these time steps.
-
-
-```julia
-tStart = 0.0
-tStep = 0.01
-tStop = 8.0
-tSave = tStart:tStep:tStop
-```
-
-
-
-
- 0.0:0.01:8.0
-
-
-
-### Import FMU
-
-Next, the FMU model from *FMIZoo.jl* is loaded.
-
-
-```julia
-# we use an FMU from the FMIZoo.jl
-fmu = loadFMU("SpringPendulumExtForce1D", "Dymola", "2022x"; type=:ME) # load FMU in ME-Mode ("Model Exchange")
-```
-
-
-
-
- Model name: SpringPendulumExtForce1D
- Type: 0
-
-
-
-#### Simulate as Model-Exchange
-
-In the function `simulate()` the FMU is simulated with an adaptive step size but with fixed save points `tSave`. In addition, the start and end time are specified. Note, that the dynamics of the input variables are not considered by the steps ize control of the solver, so it is highly recommended to limit the solver step size with the keyword argument `dtmax` if the input is more dynamic than the system.
-
-
-```julia
-# input function format "t", dependent on `t` (time)
-function extForce_t(t::Real, u::AbstractArray{<:Real})
- u[1] = sin(t)
-end
-
-# simulate while setting inputs
-data_extForce_t = simulate(fmu, (tStart, tStop); # FMU, start and stop time
- solver = Tsit5(),
- saveat=tSave, # timepoints for the ODE solution to be saved
- inputValueReferences=["extForce"], # the value references that should be set (inputs)
- inputFunction=extForce_t, # the input function to be used
- dtmax=1e-2, # limit max step size to capture inputs
- showProgress=false) # disable progress bar
-plot(data_extForce_t)
-```
-
-
-
-
-
-
-
-
-
-
-
-```julia
-# input function format "cxt", dependent on `c` (component), `x` (state) and `t` (time)
-function extForce_cxt(c::Union{FMU2Component, Nothing}, x::Union{AbstractArray{<:Real}, Nothing}, t::Real, u::AbstractArray{<:Real})
- x1 = 0.0
- if x != nothing # this check is important, because inputs may be needed before the system state is known
- x1 = x[1]
- end
- u[1] = sin(t) * x1
- nothing
-end
-
-# simulate while setting inputs
-data_extForce_cxt = simulate(fmu, (tStart, tStop); saveat=tSave, inputValueReferences=["extForce"], inputFunction=extForce_cxt, dtmax=1e-2, showProgress=false)
-plot(data_extForce_cxt)
-```
-
-
-
-
-
-
-
-
-
-
-### Unload FMU
-
-After plotting the data, the FMU is unloaded and all unpacked data on disc is removed.
-
-
-```julia
-unloadFMU(fmu)
-```
diff --git a/examples/src/inputs_files/inputs_10_0.png b/examples/src/inputs_files/inputs_10_0.png
deleted file mode 100644
index 90f173d0..00000000
Binary files a/examples/src/inputs_files/inputs_10_0.png and /dev/null differ
diff --git a/examples/src/inputs_files/inputs_10_0.svg b/examples/src/inputs_files/inputs_10_0.svg
deleted file mode 100644
index 6ef67a43..00000000
--- a/examples/src/inputs_files/inputs_10_0.svg
+++ /dev/null
@@ -1,48 +0,0 @@
-
-
diff --git a/examples/src/inputs_files/inputs_9_0.png b/examples/src/inputs_files/inputs_9_0.png
deleted file mode 100644
index 20d72aeb..00000000
Binary files a/examples/src/inputs_files/inputs_9_0.png and /dev/null differ
diff --git a/examples/src/inputs_files/inputs_9_0.svg b/examples/src/inputs_files/inputs_9_0.svg
deleted file mode 100644
index d81732ff..00000000
--- a/examples/src/inputs_files/inputs_9_0.svg
+++ /dev/null
@@ -1,48 +0,0 @@
-
-
diff --git a/examples/src/manipulation.ipynb b/examples/src/manipulation.ipynb
deleted file mode 100644
index e1021bb4..00000000
--- a/examples/src/manipulation.ipynb
+++ /dev/null
@@ -1,374 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Manipulate a function\n",
- "Tutorial by Tobias Thummerer, Johannes Stoljar\n",
- "\n",
- "🚧 This tutorial is under revision and will be replaced by an up-to-date version soon 🚧\n",
- "\n",
- "## License"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 45,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:14:08.404000Z",
- "iopub.status.busy": "2022-10-22T13:14:07.559000Z",
- "iopub.status.idle": "2022-10-22T13:14:08.684000Z",
- "shell.execute_reply": "2022-10-22T13:14:08.606000Z"
- }
- },
- "outputs": [],
- "source": [
- "# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar\n",
- "# Licensed under the MIT license. \n",
- "# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Introduction to the example\n",
- "This example shows how to overwrite a FMI function with a custom C-function. For this the FMU model is simulated first without changes. Then the function `fmi2GetReal()` is overwritten and simulated again. Both simulations are displayed in a graph to show the change caused by overwriting the function. The model used is a one-dimensional spring pendulum with friction. The object-orientated structure of the *SpringFrictionPendulum1D* can be seen in the following graphic.\n",
- "\n",
- " \n",
- "\n",
- "\n",
- "## Other formats\n",
- "Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/manipulation.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/manipulation.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/manipulation.md) corresponding to the notebook. "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Code section\n",
- "\n",
- "To run the example, the previously installed packages must be included. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 46,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:14:08.688000Z",
- "iopub.status.busy": "2022-10-22T13:14:08.687000Z",
- "iopub.status.idle": "2022-10-22T13:14:52.393000Z",
- "shell.execute_reply": "2022-10-22T13:14:52.393000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "# imports\n",
- "using FMI\n",
- "using FMI: fmi2SetFctGetReal\n",
- "using FMIZoo\n",
- "using FMICore\n",
- "using Plots\n",
- "using DifferentialEquations # for auto solver detection"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Simulation setup\n",
- "\n",
- "Next, the start time and end time of the simulation are set."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:14:54.760000Z",
- "iopub.status.busy": "2022-10-22T13:14:52.396000Z",
- "iopub.status.idle": "2022-10-22T13:14:55.420000Z",
- "shell.execute_reply": "2022-10-22T13:14:55.420000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "tStart = 0.0\n",
- "tStop = 8.0"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Import FMU\n",
- "\n",
- "Next, the FMU model from *FMIZoo.jl* is loaded."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:14:55.461000Z",
- "iopub.status.busy": "2022-10-22T13:14:55.461000Z",
- "iopub.status.idle": "2022-10-22T13:15:00.391000Z",
- "shell.execute_reply": "2022-10-22T13:15:00.391000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "# we use an FMU from the FMIZoo.jl\n",
- "fmu = loadFMU(\"SpringFrictionPendulum1D\", \"Dymola\", \"2022x\"; type=:ME)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Simulate FMU\n",
- "\n",
- "In the next steps the recorded value is defined. The recorded value is the position of the mass. In the function `simulateME()` the FMU is simulated in model-exchange mode (ME) with an adaptive step size. In addition, the start and end time and the recorded variables are specified."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:15:00.394000Z",
- "iopub.status.busy": "2022-10-22T13:15:00.394000Z",
- "iopub.status.idle": "2022-10-22T13:15:22.896000Z",
- "shell.execute_reply": "2022-10-22T13:15:22.896000Z"
- }
- },
- "outputs": [],
- "source": [
- "# an array of value references... or just one\n",
- "vrs = [\"mass.s\"]\n",
- "\n",
- "simData = simulate(fmu, (tStart, tStop); recordValues=vrs)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Plotting FMU\n",
- "\n",
- "After the simulation is finished, the result of the FMU for the model-exchange mode can be plotted. In the plot for the FMU it can be seen that the oscillation continues to decrease due to the effect of the friction. If you simulate long enough, the oscillation comes to a standstill in a certain time."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:15:22.900000Z",
- "iopub.status.busy": "2022-10-22T13:15:22.900000Z",
- "iopub.status.idle": "2022-10-22T13:16:03.717000Z",
- "shell.execute_reply": "2022-10-22T13:16:03.717000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "fig = plot(simData, states=false)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Override Function\n",
- "\n",
- "After overwriting a function, the previous one is no longer accessible. The original function `fmi2GetReal()` is cached by storing the address of the pointer. The addresses of the pointers are kept in the FMU and are thus accessible."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:16:03.722000Z",
- "iopub.status.busy": "2022-10-22T13:16:03.722000Z",
- "iopub.status.idle": "2022-10-22T13:16:04.520000Z",
- "shell.execute_reply": "2022-10-22T13:16:04.520000Z"
- }
- },
- "outputs": [],
- "source": [
- "# save, where the original `fmi2GetReal` function was stored, so we can access it in our new function\n",
- "originalGetReal = fmu.cGetReal"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "To overwrite the function `fmi2GetReal!()`, the function header of the new custom function must be identical to the previous one. The function header looks like `fmi2GetReal!(cfunc::Ptr{Nothing}, c::fmi2Component, vr::Union{Array{fmi2ValueReference}, Ptr{fmi2ValueReference}}, nvr::Csize_t, value::Union{Array{fmi2Real}, Ptr{fmi2Real}})::fmi2Status`. The information how the FMI2 function are structured can be seen from [FMICore.jl](https://github.com/ThummeTo/FMICore.jl), the api of [`fmi2GetReal!`](@ref) or the FMI2.0.3-specification.\n",
- "\n",
- "In the new implementation the original function is called by the previously stored pointer. Next there is a special handling if `value` is a pointer to an array. In this case the pointer is treated as an array, so that the entries are accessible. Otherwise, each value in `value` is multiplied by two. Finally, the original state of the original function is output."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:16:04.525000Z",
- "iopub.status.busy": "2022-10-22T13:16:04.524000Z",
- "iopub.status.idle": "2022-10-22T13:16:05.526000Z",
- "shell.execute_reply": "2022-10-22T13:16:05.526000Z"
- }
- },
- "outputs": [],
- "source": [
- "function myGetReal!(c::fmi2Component, vr::Union{Array{fmi2ValueReference}, Ptr{fmi2ValueReference}}, \n",
- " nvr::Csize_t, value::Union{Array{fmi2Real}, Ptr{fmi2Real}})\n",
- " # first, we do what the original function does\n",
- " status = fmi2GetReal!(originalGetReal, c, vr, nvr, value)\n",
- "\n",
- " # if we have a pointer to an array, we must interprete it as array to access elements\n",
- " if isa(value, Ptr{fmi2Real})\n",
- " value = unsafe_wrap(Array{fmi2Real}, value, nvr, own=false)\n",
- " end\n",
- "\n",
- " # now, we multiply every value by two (just for fun!)\n",
- " for i in 1:nvr \n",
- " value[i] *= 2.0 \n",
- " end \n",
- "\n",
- " # return the original status\n",
- " return status\n",
- "end"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "In the next command the original function is overwritten with the new defined function, for which the command `fmiSetFctGetReal()` is called."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:16:05.530000Z",
- "iopub.status.busy": "2022-10-22T13:16:05.530000Z",
- "iopub.status.idle": "2022-10-22T13:16:05.542000Z",
- "shell.execute_reply": "2022-10-22T13:16:05.542000Z"
- }
- },
- "outputs": [],
- "source": [
- "# no we overwrite the original function\n",
- "fmi2SetFctGetReal(fmu, myGetReal!)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Simulate and Plot FMU with modified function\n",
- "\n",
- "As before, the identical command is called here for simulation. This is also a model exchange simulation. Immediately afterwards, the results are added to the previous graph as a dashed line."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:16:05.545000Z",
- "iopub.status.busy": "2022-10-22T13:16:05.545000Z",
- "iopub.status.idle": "2022-10-22T13:16:06.060000Z",
- "shell.execute_reply": "2022-10-22T13:16:06.060000Z"
- }
- },
- "outputs": [],
- "source": [
- "simData = simulate(fmu, (tStart, tStop); recordValues=vrs)\n",
- "plot!(fig, simData; states=false, style=:dash)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "As expected by overwriting the function, all values are doubled."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Unload FMU\n",
- "\n",
- "After plotting the data, the FMU is unloaded and all unpacked data on disc is removed."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 55,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:16:06.065000Z",
- "iopub.status.busy": "2022-10-22T13:16:06.064000Z",
- "iopub.status.idle": "2022-10-22T13:16:06.104000Z",
- "shell.execute_reply": "2022-10-22T13:16:06.103000Z"
- }
- },
- "outputs": [],
- "source": [
- "unloadFMU(fmu)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Summary\n",
- "\n",
- "In this tutorial it is shown how an existing function of the library can be replaced by an own implementation."
- ]
- }
- ],
- "metadata": {
- "interpreter": {
- "hash": "037537ff7419c497b9325f7d495147943224d408cf5d5ed915294a5b960167b0"
- },
- "jupytext": {
- "cell_metadata_filter": "-all",
- "comment_magics": "false",
- "notebook_metadata_filter": "-all"
- },
- "kernelspec": {
- "display_name": "Julia 1.10.5",
- "language": "julia",
- "name": "julia-1.10"
- },
- "language_info": {
- "file_extension": ".jl",
- "mimetype": "application/julia",
- "name": "julia",
- "version": "1.10.5"
- },
- "nteract": {
- "version": "0.28.0"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/examples/src/manipulation.jl b/examples/src/manipulation.jl
deleted file mode 100644
index 8c9985f6..00000000
--- a/examples/src/manipulation.jl
+++ /dev/null
@@ -1,53 +0,0 @@
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-
-# imports
-using FMI
-using FMI: fmiSetFctGetReal
-using FMIZoo
-using FMICore
-using Plots
-
-tStart = 0.0
-tStop = 8.0
-
-# we use an FMU from the FMIZoo.jl
-fmu = fmiLoad("SpringFrictionPendulum1D", "Dymola", "2022x"; type=:ME)
-
-# an array of value references... or just one
-vrs = ["mass.s"]
-
-simData = fmiSimulate(fmu, (tStart, tStop); recordValues=vrs)
-
-fig = plot(simData, states=false)
-
-# save, where the original `fmi2GetReal` function was stored, so we can access it in our new function
-originalGetReal = fmu.cGetReal
-
-function myGetReal!(c::fmi2Component, vr::Union{Array{fmi2ValueReference}, Ptr{fmi2ValueReference}},
- nvr::Csize_t, value::Union{Array{fmi2Real}, Ptr{fmi2Real}})
- # first, we do what the original function does
- status = fmi2GetReal!(originalGetReal, c, vr, nvr, value)
-
- # if we have a pointer to an array, we must interprete it as array to access elements
- if isa(value, Ptr{fmi2Real})
- value = unsafe_wrap(Array{fmi2Real}, value, nvr, own=false)
- end
-
- # now, we multiply every value by two (just for fun!)
- for i in 1:nvr
- value[i] *= 2.0
- end
-
- # return the original status
- return status
-end
-
-# no we overwrite the original function
-fmiSetFctGetReal(fmu, myGetReal!)
-
-simData = fmiSimulate(fmu, (tStart, tStop); recordValues=vrs)
-plot!(fig, simData; states=false, style=:dash)
-
-fmiUnload(fmu)
diff --git a/examples/src/manipulation.md b/examples/src/manipulation.md
deleted file mode 100644
index c073b57f..00000000
--- a/examples/src/manipulation.md
+++ /dev/null
@@ -1,146 +0,0 @@
-# Manipulate a function
-Tutorial by Tobias Thummerer, Johannes Stoljar
-
-🚧 This tutorial is under revision and will be replaced by an up-to-date version soon 🚧
-
-## License
-
-
-```julia
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-```
-
-## Introduction to the example
-This example shows how to overwrite a FMI function with a custom C-function. For this the FMU model is simulated first without changes. Then the function `fmi2GetReal()` is overwritten and simulated again. Both simulations are displayed in a graph to show the change caused by overwriting the function. The model used is a one-dimensional spring pendulum with friction. The object-orientated structure of the *SpringFrictionPendulum1D* can be seen in the following graphic.
-
-
-
-
-## Other formats
-Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/manipulation.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/manipulation.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/manipulation.md) corresponding to the notebook.
-
-## Code section
-
-To run the example, the previously installed packages must be included.
-
-
-```julia
-# imports
-using FMI
-using FMI: fmiSetFctGetReal
-using FMIZoo
-using FMICore
-using Plots
-```
-
-### Simulation setup
-
-Next, the start time and end time of the simulation are set.
-
-
-```julia
-tStart = 0.0
-tStop = 8.0
-```
-
-### Import FMU
-
-Next, the FMU model from *FMIZoo.jl* is loaded.
-
-
-```julia
-# we use an FMU from the FMIZoo.jl
-fmu = fmiLoad("SpringFrictionPendulum1D", "Dymola", "2022x"; type=:ME)
-```
-
-### Simulate FMU
-
-In the next steps the recorded value is defined. The recorded value is the position of the mass. In the function `fmiSimulateME()` the FMU is simulated in model-exchange mode (ME) with an adaptive step size. In addition, the start and end time and the recorded variables are specified.
-
-
-```julia
-# an array of value references... or just one
-vrs = ["mass.s"]
-
-simData = fmiSimulate(fmu, (tStart, tStop); recordValues=vrs)
-```
-
-### Plotting FMU
-
-After the simulation is finished, the result of the FMU for the model-exchange mode can be plotted. In the plot for the FMU it can be seen that the oscillation continues to decrease due to the effect of the friction. If you simulate long enough, the oscillation comes to a standstill in a certain time.
-
-
-```julia
-fig = plot(simData, states=false)
-```
-
-### Override Function
-
-After overwriting a function, the previous one is no longer accessible. The original function `fmi2GetReal()` is cached by storing the address of the pointer. The addresses of the pointers are kept in the FMU and are thus accessible.
-
-
-```julia
-# save, where the original `fmi2GetReal` function was stored, so we can access it in our new function
-originalGetReal = fmu.cGetReal
-```
-
-To overwrite the function `fmi2GetReal!()`, the function header of the new custom function must be identical to the previous one. The function header looks like `fmi2GetReal!(cfunc::Ptr{Nothing}, c::fmi2Component, vr::Union{Array{fmi2ValueReference}, Ptr{fmi2ValueReference}}, nvr::Csize_t, value::Union{Array{fmi2Real}, Ptr{fmi2Real}})::fmi2Status`. The information how the FMI2 function are structured can be seen from [FMICore.jl](https://github.com/ThummeTo/FMICore.jl), the api of [`fmi2GetReal!`](@ref) or the FMI2.0.3-specification.
-
-In the new implementation the original function is called by the previously stored pointer. Next there is a special handling if `value` is a pointer to an array. In this case the pointer is treated as an array, so that the entries are accessible. Otherwise, each value in `value` is multiplied by two. Finally, the original state of the original function is output.
-
-
-```julia
-function myGetReal!(c::fmi2Component, vr::Union{Array{fmi2ValueReference}, Ptr{fmi2ValueReference}},
- nvr::Csize_t, value::Union{Array{fmi2Real}, Ptr{fmi2Real}})
- # first, we do what the original function does
- status = fmi2GetReal!(originalGetReal, c, vr, nvr, value)
-
- # if we have a pointer to an array, we must interprete it as array to access elements
- if isa(value, Ptr{fmi2Real})
- value = unsafe_wrap(Array{fmi2Real}, value, nvr, own=false)
- end
-
- # now, we multiply every value by two (just for fun!)
- for i in 1:nvr
- value[i] *= 2.0
- end
-
- # return the original status
- return status
-end
-```
-
-In the next command the original function is overwritten with the new defined function, for which the command `fmiSetFctGetReal()` is called.
-
-
-```julia
-# no we overwrite the original function
-fmiSetFctGetReal(fmu, myGetReal!)
-```
-
-### Simulate and Plot FMU with modified function
-
-As before, the identical command is called here for simulation. This is also a model exchange simulation. Immediately afterwards, the results are added to the previous graph as a dashed line.
-
-
-```julia
-simData = fmiSimulate(fmu, (tStart, tStop); recordValues=vrs)
-plot!(fig, simData; states=false, style=:dash)
-```
-
-As expected by overwriting the function, all values are doubled.
-
-### Unload FMU
-
-After plotting the data, the FMU is unloaded and all unpacked data on disc is removed.
-
-
-```julia
-fmiUnload(fmu)
-```
-
-### Summary
-
-In this tutorial it is shown how an existing function of the library can be replaced by an own implementation.
diff --git a/examples/src/manipulation_files/manipulation_12_0.png b/examples/src/manipulation_files/manipulation_12_0.png
deleted file mode 100644
index 8e3029be..00000000
Binary files a/examples/src/manipulation_files/manipulation_12_0.png and /dev/null differ
diff --git a/examples/src/manipulation_files/manipulation_12_0.svg b/examples/src/manipulation_files/manipulation_12_0.svg
deleted file mode 100644
index 1f95423a..00000000
--- a/examples/src/manipulation_files/manipulation_12_0.svg
+++ /dev/null
@@ -1,53 +0,0 @@
-
-
diff --git a/examples/src/manipulation_files/manipulation_20_0.png b/examples/src/manipulation_files/manipulation_20_0.png
deleted file mode 100644
index 0c01b4ec..00000000
Binary files a/examples/src/manipulation_files/manipulation_20_0.png and /dev/null differ
diff --git a/examples/src/manipulation_files/manipulation_20_0.svg b/examples/src/manipulation_files/manipulation_20_0.svg
deleted file mode 100644
index aa360adb..00000000
--- a/examples/src/manipulation_files/manipulation_20_0.svg
+++ /dev/null
@@ -1,62 +0,0 @@
-
-
diff --git a/examples/src/modelica_conference_2021.ipynb b/examples/src/modelica_conference_2021.ipynb
deleted file mode 100644
index bf148af9..00000000
--- a/examples/src/modelica_conference_2021.ipynb
+++ /dev/null
@@ -1,354 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Example from the Modelica Conference 2021\n",
- "Tutorial by Tobias Thummerer, Johannes Stoljar\n",
- "\n",
- "This example was updated over time to keep track with developments and changes in *FMI.jl*.\n",
- "\n",
- "🚧 This tutorial is under revision and will be replaced by an up-to-date version soon 🚧\n",
- "\n",
- "## License"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 12,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:16:18.554000Z",
- "iopub.status.busy": "2022-10-22T13:16:17.709000Z",
- "iopub.status.idle": "2022-10-22T13:16:18.840000Z",
- "shell.execute_reply": "2022-10-22T13:16:18.765000Z"
- }
- },
- "outputs": [],
- "source": [
- "# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar\n",
- "# Licensed under the MIT license. \n",
- "# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Introduction to the example\n",
- "FMUs can be simulated in multiple ways using *FMI.jl*. You can use a very simple interface, that offers possibilities that satisfy almost any user requirement. However, if you need to build a custom simulation loop for your use case using the core FMI functions, we show that too.\n",
- "\n",
- " \n",
- "\n",
- "## Other formats\n",
- "Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/modelica_conference_2021.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/modelica_conference_2021.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/modelica_conference_2021.md) corresponding to the notebook. "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Code section\n",
- "\n",
- "To run the example, the previously installed packages must be included. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 13,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:16:18.843000Z",
- "iopub.status.busy": "2022-10-22T13:16:18.843000Z",
- "iopub.status.idle": "2022-10-22T13:17:02.927000Z",
- "shell.execute_reply": "2022-10-22T13:17:02.927000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "# imports\n",
- "using FMI\n",
- "using FMIZoo\n",
- "using Plots"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Simulation setup\n",
- "\n",
- "Next, the start time and end time of the simulation are set. Finally, a step size is specified to store the results of the simulation at these time steps."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:17:05.306000Z",
- "iopub.status.busy": "2022-10-22T13:17:02.930000Z",
- "iopub.status.idle": "2022-10-22T13:17:06.057000Z",
- "shell.execute_reply": "2022-10-22T13:17:06.057000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "tStart = 0.0\n",
- "tStep = 0.1\n",
- "tStop = 8.0\n",
- "tSave = tStart:tStep:tStop"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Simple FMU Simulation\n",
- "Next, the FMU model from *FMIZoo.jl* is loaded and the information about the FMU is shown."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:17:06.062000Z",
- "iopub.status.busy": "2022-10-22T13:17:06.061000Z",
- "iopub.status.idle": "2022-10-22T13:17:11.103000Z",
- "shell.execute_reply": "2022-10-22T13:17:11.103000Z"
- }
- },
- "outputs": [],
- "source": [
- "# we use an FMU from the FMIZoo.jl\n",
- "fmu = loadFMU(\"SpringFrictionPendulum1D\", \"Dymola\", \"2022x\")\n",
- "info(fmu)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Easy Simulation\n",
- "In the next commands the FMU is simulated, for which the start and end time and recorded variables are declared. Afterwards the simulation result is plotted. In the plot for the FMU, it can be seen that the oscillation keeps decreasing due to the effect of friction. If one simulates long enough, the oscillation comes to a standstill after a certain time."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:17:11.106000Z",
- "iopub.status.busy": "2022-10-22T13:17:11.106000Z",
- "iopub.status.idle": "2022-10-22T13:18:05.013000Z",
- "shell.execute_reply": "2022-10-22T13:18:05.013000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "simData = simulate(fmu, (tStart, tStop); recordValues=[\"mass.s\"], saveat=tSave)\n",
- "plot(simData)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "After plotting the data, the FMU is unloaded and all unpacked data on disc is removed."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 17,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:18:05.018000Z",
- "iopub.status.busy": "2022-10-22T13:18:05.018000Z",
- "iopub.status.idle": "2022-10-22T13:18:05.057000Z",
- "shell.execute_reply": "2022-10-22T13:18:05.057000Z"
- }
- },
- "outputs": [],
- "source": [
- "unloadFMU(fmu)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Custom Simulation\n",
- "\n",
- "In the following type of simulation a more advanced variant is presented, which allows intervening more in the simulation process. Analogous to the simple variant, an FMU model must be loaded."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:18:05.061000Z",
- "iopub.status.busy": "2022-10-22T13:18:05.060000Z",
- "iopub.status.idle": "2022-10-22T13:18:05.160000Z",
- "shell.execute_reply": "2022-10-22T13:18:05.160000Z"
- }
- },
- "outputs": [],
- "source": [
- "fmu = loadFMU(\"SpringFrictionPendulum1D\", \"Dymola\", \"2022x\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Next, it is necessary to create an instance of the FMU, this is achieved by the command `fmi2Instantiate!()`. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:18:05.163000Z",
- "iopub.status.busy": "2022-10-22T13:18:05.163000Z",
- "iopub.status.idle": "2022-10-22T13:18:05.510000Z",
- "shell.execute_reply": "2022-10-22T13:18:05.510000Z"
- }
- },
- "outputs": [],
- "source": [
- "instanceFMU = fmi2Instantiate!(fmu)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "In the following code block, start and end time for the simulation is set by the `fmi2SetupExperiment()` command. Next, the FMU is initialized by the calls of `fmi2EnterInitializationMode()` and `fmi2ExitInitializationMode()`. It would also be possible to set initial states, parameters or inputs at this place in code."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:18:05.514000Z",
- "iopub.status.busy": "2022-10-22T13:18:05.514000Z",
- "iopub.status.idle": "2022-10-22T13:18:05.780000Z",
- "shell.execute_reply": "2022-10-22T13:18:05.780000Z"
- }
- },
- "outputs": [],
- "source": [
- "fmi2SetupExperiment(instanceFMU, tStart, tStop)\n",
- "# set initial model states\n",
- "fmi2EnterInitializationMode(instanceFMU)\n",
- "# get initial model states\n",
- "fmi2ExitInitializationMode(instanceFMU)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "The actual simulation loop is shown in the following block. Here a simulation step `fmi2DoStep()` with the fixed step size `tStep` is executed. As indicated in the code by the comments, the input values and output values of the FMU could be changed in the simulation loop as desired, whereby the higher possibility of adjustments arises."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:18:05.785000Z",
- "iopub.status.busy": "2022-10-22T13:18:05.784000Z",
- "iopub.status.idle": "2022-10-22T13:18:05.818000Z",
- "shell.execute_reply": "2022-10-22T13:18:05.818000Z"
- }
- },
- "outputs": [],
- "source": [
- "values = []\n",
- "\n",
- "for t in tSave\n",
- " # set model inputs if any\n",
- " # ...\n",
- "\n",
- " fmi2DoStep(instanceFMU, tStep)\n",
- " \n",
- " # get model outputs\n",
- " value = fmi2GetReal(instanceFMU, \"mass.s\")\n",
- " push!(values, value)\n",
- "end\n",
- "\n",
- "plot(tSave, values)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "The instantiated FMU must be terminated and then the memory area for the instance can also be deallocated. The last step is to unload the FMU to remove all unpacked data on disc. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 22,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:18:05.822000Z",
- "iopub.status.busy": "2022-10-22T13:18:05.822000Z",
- "iopub.status.idle": "2022-10-22T13:18:05.833000Z",
- "shell.execute_reply": "2022-10-22T13:18:05.833000Z"
- }
- },
- "outputs": [],
- "source": [
- "fmi2Terminate(instanceFMU)\n",
- "fmi2FreeInstance!(instanceFMU)\n",
- "unloadFMU(fmu)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Summary\n",
- "\n",
- "The tutorial has shown how to use the default simulation command and how to deploy a custom simulation loop."
- ]
- }
- ],
- "metadata": {
- "interpreter": {
- "hash": "037537ff7419c497b9325f7d495147943224d408cf5d5ed915294a5b960167b0"
- },
- "jupytext": {
- "cell_metadata_filter": "-all",
- "comment_magics": "false",
- "notebook_metadata_filter": "-all"
- },
- "kernelspec": {
- "display_name": "Julia 1.10.5",
- "language": "julia",
- "name": "julia-1.10"
- },
- "language_info": {
- "file_extension": ".jl",
- "mimetype": "application/julia",
- "name": "julia",
- "version": "1.10.5"
- },
- "nteract": {
- "version": "0.28.0"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/examples/src/modelica_conference_2021.jl b/examples/src/modelica_conference_2021.jl
deleted file mode 100644
index ab6f37c4..00000000
--- a/examples/src/modelica_conference_2021.jl
+++ /dev/null
@@ -1,51 +0,0 @@
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-
-# imports
-using FMI
-using FMIZoo
-using Plots
-
-tStart = 0.0
-tStep = 0.1
-tStop = 8.0
-tSave = tStart:tStep:tStop
-
-# we use an FMU from the FMIZoo.jl
-fmu = fmiLoad("SpringFrictionPendulum1D", "Dymola", "2022x")
-fmiInfo(fmu)
-
-simData = fmiSimulate(fmu, (tStart, tStop); recordValues=["mass.s"], saveat=tSave)
-plot(simData)
-
-fmiUnload(fmu)
-
-fmu = fmiLoad(pathToFMU)
-
-instanceFMU = fmi2Instantiate!(fmu)
-
-fmi2SetupExperiment(instanceFMU, tStart, tStop)
-# set initial model states
-fmi2EnterInitializationMode(instanceFMU)
-# get initial model states
-fmi2ExitInitializationMode(instanceFMU)
-
-values = []
-
-for t in tSave
- # set model inputs if any
- # ...
-
- fmi2DoStep(instanceFMU, tStep)
-
- # get model outputs
- value = fmi2GetReal(instanceFMU, "mass.s")
- push!(values, value)
-end
-
-plot(tSave, values)
-
-fmi2Terminate(instanceFMU)
-fmi2FreeInstance!(instanceFMU)
-fmi2Unload(fmu)
diff --git a/examples/src/modelica_conference_2021.md b/examples/src/modelica_conference_2021.md
deleted file mode 100644
index 1a71a5c0..00000000
--- a/examples/src/modelica_conference_2021.md
+++ /dev/null
@@ -1,133 +0,0 @@
-# Example from the Modelica Conference 2021
-Tutorial by Tobias Thummerer, Johannes Stoljar
-
-This example was updated over time to keep track with developments and changes in *FMI.jl*.
-
-🚧 This tutorial is under revision and will be replaced by an up-to-date version soon 🚧
-
-## License
-
-
-```julia
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-```
-
-## Introduction to the example
-FMUs can be simulated in multiple ways using *FMI.jl*. You can use a very simple interface, that offers possibilities that satisfy almost any user requirement. However, if you need to build a custom simulation loop for your use case using the core FMI functions, we show that too.
-
-
-
-## Other formats
-Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/modelica_conference_2021.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/modelica_conference_2021.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/modelica_conference_2021.md) corresponding to the notebook.
-
-## Code section
-
-To run the example, the previously installed packages must be included.
-
-
-```julia
-# imports
-using FMI
-using FMIZoo
-using Plots
-```
-
-### Simulation setup
-
-Next, the start time and end time of the simulation are set. Finally, a step size is specified to store the results of the simulation at these time steps.
-
-
-```julia
-tStart = 0.0
-tStep = 0.1
-tStop = 8.0
-tSave = tStart:tStep:tStop
-```
-
-### Simple FMU Simulation
-Next, the FMU model from *FMIZoo.jl* is loaded and the information about the FMU is shown.
-
-
-```julia
-# we use an FMU from the FMIZoo.jl
-fmu = fmiLoad("SpringFrictionPendulum1D", "Dymola", "2022x")
-fmiInfo(fmu)
-```
-
-### Easy Simulation
-In the next commands the FMU is simulated, for which the start and end time and recorded variables are declared. Afterwards the simulation result is plotted. In the plot for the FMU, it can be seen that the oscillation keeps decreasing due to the effect of friction. If one simulates long enough, the oscillation comes to a standstill after a certain time.
-
-
-```julia
-simData = fmiSimulate(fmu, (tStart, tStop); recordValues=["mass.s"], saveat=tSave)
-plot(simData)
-```
-
-After plotting the data, the FMU is unloaded and all unpacked data on disc is removed.
-
-
-```julia
-fmiUnload(fmu)
-```
-
-### Custom Simulation
-
-In the following type of simulation a more advanced variant is presented, which allows intervening more in the simulation process. Analogous to the simple variant, an FMU model must be loaded.
-
-
-```julia
-fmu = fmiLoad(pathToFMU)
-```
-
-Next, it is necessary to create an instance of the FMU, this is achieved by the command `fmi2Instantiate!()`.
-
-
-```julia
-instanceFMU = fmi2Instantiate!(fmu)
-```
-
-In the following code block, start and end time for the simulation is set by the `fmi2SetupExperiment()` command. Next, the FMU is initialized by the calls of `fmi2EnterInitializationMode()` and `fmi2ExitInitializationMode()`. It would also be possible to set initial states, parameters or inputs at this place in code.
-
-
-```julia
-fmi2SetupExperiment(instanceFMU, tStart, tStop)
-# set initial model states
-fmi2EnterInitializationMode(instanceFMU)
-# get initial model states
-fmi2ExitInitializationMode(instanceFMU)
-```
-
-The actual simulation loop is shown in the following block. Here a simulation step `fmi2DoStep()` with the fixed step size `tStep` is executed. As indicated in the code by the comments, the input values and output values of the FMU could be changed in the simulation loop as desired, whereby the higher possibility of adjustments arises.
-
-
-```julia
-values = []
-
-for t in tSave
- # set model inputs if any
- # ...
-
- fmi2DoStep(instanceFMU, tStep)
-
- # get model outputs
- value = fmi2GetReal(instanceFMU, "mass.s")
- push!(values, value)
-end
-
-plot(tSave, values)
-```
-
-The instantiated FMU must be terminated and then the memory area for the instance can also be deallocated. The last step is to unload the FMU to remove all unpacked data on disc.
-
-
-```julia
-fmi2Terminate(instanceFMU)
-fmi2FreeInstance!(instanceFMU)
-fmi2Unload(fmu)
-```
-
-### Summary
-
-The tutorial has shown how to use the default simulation command and how to deploy a custom simulation loop.
diff --git a/examples/src/modelica_conference_2021_files/modelica_conference_2021_10_0.png b/examples/src/modelica_conference_2021_files/modelica_conference_2021_10_0.png
deleted file mode 100644
index dc08671d..00000000
Binary files a/examples/src/modelica_conference_2021_files/modelica_conference_2021_10_0.png and /dev/null differ
diff --git a/examples/src/modelica_conference_2021_files/modelica_conference_2021_10_0.svg b/examples/src/modelica_conference_2021_files/modelica_conference_2021_10_0.svg
deleted file mode 100644
index 557a35cd..00000000
--- a/examples/src/modelica_conference_2021_files/modelica_conference_2021_10_0.svg
+++ /dev/null
@@ -1,46 +0,0 @@
-
-
diff --git a/examples/src/modelica_conference_2021_files/modelica_conference_2021_20_0.png b/examples/src/modelica_conference_2021_files/modelica_conference_2021_20_0.png
deleted file mode 100644
index 056696c8..00000000
Binary files a/examples/src/modelica_conference_2021_files/modelica_conference_2021_20_0.png and /dev/null differ
diff --git a/examples/src/modelica_conference_2021_files/modelica_conference_2021_20_0.svg b/examples/src/modelica_conference_2021_files/modelica_conference_2021_20_0.svg
deleted file mode 100644
index 264663fd..00000000
--- a/examples/src/modelica_conference_2021_files/modelica_conference_2021_20_0.svg
+++ /dev/null
@@ -1,46 +0,0 @@
-
-
diff --git a/examples/src/multiple_instances.ipynb b/examples/src/multiple_instances.ipynb
deleted file mode 100644
index af2bcdd8..00000000
--- a/examples/src/multiple_instances.ipynb
+++ /dev/null
@@ -1,388 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Multiple Instances of an FMU\n",
- "Tutorial by Johannes Stoljar, Tobias Thummerer\n",
- "\n",
- "🚧 This tutorial is under revision and will be replaced by an up-to-date version soon 🚧\n",
- "\n",
- "## License"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 73,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:18:17.738000Z",
- "iopub.status.busy": "2022-10-22T13:18:17.035000Z",
- "iopub.status.idle": "2022-10-22T13:18:18.022000Z",
- "shell.execute_reply": "2022-10-22T13:18:17.946000Z"
- }
- },
- "outputs": [],
- "source": [
- "# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar\n",
- "# Licensed under the MIT license. \n",
- "# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Motivation\n",
- "This Julia Package *FMI.jl* is motivated by the use of simulation models in Julia. Here the FMI specification is implemented. FMI (*Functional Mock-up Interface*) is a free standard ([fmi-standard.org](https://fmi-standard.org/)) that defines a container and an interface to exchange dynamic models using a combination of XML files, binaries and C code zipped into a single file. The user can thus use simulation models in the form of an FMU (*Functional Mock-up Units*). Besides loading the FMU, the user can also set values for parameters and states and simulate the FMU both as co-simulation and model exchange simulation.\n",
- "\n",
- "## Introduction to the example\n",
- "In this example we want to show that it is possible to create different instances of an FMU. The different instances can then be used to run independent simulations. After the FMU has been simulated, the simulation results are displayed in a graph. The used model is a one-dimensional spring pendulum without friction. The object-orientated structure of the *SpringPendulum1D* can be seen in the following graphic.\n",
- "\n",
- " \n",
- "\n",
- "\n",
- "## Target group\n",
- "The example is primarily intended for users who work in the field of simulations. The example wants to show how simple it is to use FMUs in Julia.\n",
- "\n",
- "\n",
- "## Other formats\n",
- "Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multiple_instances.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multiple_instances.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multiple_instances.md) corresponding to the notebook. \n",
- "\n",
- "\n",
- "## Getting started\n",
- "\n",
- "### Installation prerequisites\n",
- "| | Description | Command | Alternative | \n",
- "|:----|:----------------------------------|:--------------------------|:-----------------------------------------------|\n",
- "| 1. | Enter Package Manager via | ] | |\n",
- "| 2. | Install FMI via | add FMI | add \" https://github.com/ThummeTo/FMI.jl \" |\n",
- "| 3. | Install FMIZoo via | add FMIZoo | add \" https://github.com/ThummeTo/FMIZoo.jl \" |\n",
- "| 4. | Install Plots via | add Plots | |"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Code section\n",
- "\n",
- "To run the example, the previously installed packages must be included. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 74,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:18:18.025000Z",
- "iopub.status.busy": "2022-10-22T13:18:18.025000Z",
- "iopub.status.idle": "2022-10-22T13:19:02.368000Z",
- "shell.execute_reply": "2022-10-22T13:19:02.368000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "# imports\n",
- "using FMI\n",
- "using FMIZoo\n",
- "using Plots"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Simulation setup\n",
- "\n",
- "Next, the start time and end time of the simulation are set. Finally, the recorded values are specified to store the results of the simulation."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:19:04.768000Z",
- "iopub.status.busy": "2022-10-22T13:19:02.371000Z",
- "iopub.status.idle": "2022-10-22T13:19:08.730000Z",
- "shell.execute_reply": "2022-10-22T13:19:08.730000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "tStart = 0.0\n",
- "tStop = 8.0\n",
- "\n",
- "vrs = [\"mass.s\"]"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Import FMU\n",
- "\n",
- "In the next lines of code the FMU model from *FMIZoo.jl* is loaded and the information about the FMU is shown."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:19:08.735000Z",
- "iopub.status.busy": "2022-10-22T13:19:08.734000Z",
- "iopub.status.idle": "2022-10-22T13:19:14.412000Z",
- "shell.execute_reply": "2022-10-22T13:19:14.412000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "# we use an FMU from the FMIZoo.jl\n",
- "pathToFMU = get_model_filename(\"SpringPendulum1D\", \"Dymola\", \"2022x\")\n",
- "\n",
- "myFMU = loadFMU(pathToFMU)\n",
- "info(myFMU)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### First Instance\n",
- "\n",
- "To create an instance of the FMU it is necessary to call the command `fmi2Instantiate!()`. With the component address you now have a unique instance of the FMU."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:19:14.415000Z",
- "iopub.status.busy": "2022-10-22T13:19:14.415000Z",
- "iopub.status.idle": "2022-10-22T13:19:14.932000Z",
- "shell.execute_reply": "2022-10-22T13:19:14.932000Z"
- }
- },
- "outputs": [],
- "source": [
- "c1 = fmi2Instantiate!(myFMU; loggingOn=true)\n",
- "comp1Address = c1.addr\n",
- "println(c1)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Next, a dictionary for the parameters is created. With this dictionary you can set the initial states of the variables of the FMU. For the spring constant `spring.c` a value of $10.0 \\frac{N}{m}$ and for the position of the mass `mass.s` a value of $1.0 m$ is set. The created dictionary with the specified variables for recording are passed to the command for simulation. In addition, other keywords are set. On the one hand the keyword `instantiate=false` is set, which prevents that in the simulation command a new instance is created. On the other hand the keyword `freeInstance=false` is set, this prevents that after the simulation command the instance is released. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:19:14.936000Z",
- "iopub.status.busy": "2022-10-22T13:19:14.936000Z",
- "iopub.status.idle": "2022-10-22T13:20:06.087000Z",
- "shell.execute_reply": "2022-10-22T13:20:06.087000Z"
- }
- },
- "outputs": [],
- "source": [
- "param1 = Dict(\"spring.c\"=>10.0, \"mass_s0\"=>1.0)\n",
- "data1 = simulate(c1, (tStart, tStop); parameters=param1, recordValues=vrs, instantiate=false, freeInstance=false)\n",
- "fig = plot(data1)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "For control, you can compare again the address of the instance to the previous address, and it should be the same address. As soon as this is not the case an error would be thrown by the macro `@assert`."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 79,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:20:06.093000Z",
- "iopub.status.busy": "2022-10-22T13:20:06.093000Z",
- "iopub.status.idle": "2022-10-22T13:20:06.135000Z",
- "shell.execute_reply": "2022-10-22T13:20:06.135000Z"
- }
- },
- "outputs": [],
- "source": [
- "@assert c1.addr === comp1Address"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Second Instance\n",
- "\n",
- "To create a second instance of the FMU it is necessary to call the command `fmi2Instantiate!()`. With the component address you now have a unique instance of the FMU."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:20:06.139000Z",
- "iopub.status.busy": "2022-10-22T13:20:06.138000Z",
- "iopub.status.idle": "2022-10-22T13:20:06.141000Z",
- "shell.execute_reply": "2022-10-22T13:20:06.141000Z"
- }
- },
- "outputs": [],
- "source": [
- "c2 = fmi2Instantiate!(myFMU; loggingOn=true)\n",
- "comp2Address = c2.addr\n",
- "println(c2)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "The addresses of the instantiated FMUs must differ, and you can see that in the comparison below."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 81,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:20:06.145000Z",
- "iopub.status.busy": "2022-10-22T13:20:06.145000Z",
- "iopub.status.idle": "2022-10-22T13:20:06.146000Z",
- "shell.execute_reply": "2022-10-22T13:20:06.146000Z"
- }
- },
- "outputs": [],
- "source": [
- "@assert comp1Address !== comp2Address"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Again, a dictionary for the parameters is created. With this dictionary you can set the initial states of the variables of the FMU. For the spring constant `spring.c` a value of $1.0 \\frac{N}{m}$ and for the position of the mass `mass.s` a value of $2.0 m$ is set. The created dictionary with the specified variables for recording are passed to the command for simulation. As before, the two keywords `instantiate=false` and `freeInstance=false` are set."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:20:06.148000Z",
- "iopub.status.busy": "2022-10-22T13:20:06.148000Z",
- "iopub.status.idle": "2022-10-22T13:20:06.248000Z",
- "shell.execute_reply": "2022-10-22T13:20:06.248000Z"
- }
- },
- "outputs": [],
- "source": [
- "param2 = Dict(\"spring.c\"=>1.0, \"mass.s\"=>2.0)\n",
- "data2 = simulateCS(c2, (tStart, tStop); parameters=param2, recordValues=vrs, instantiate=false, freeInstance=false)\n",
- "plot!(fig, data2)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "For control, you can compare again the address of the instance `comp2` to the previous address `comp2Address` and it should be the same address."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 83,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:20:06.256000Z",
- "iopub.status.busy": "2022-10-22T13:20:06.256000Z",
- "iopub.status.idle": "2022-10-22T13:20:06.257000Z",
- "shell.execute_reply": "2022-10-22T13:20:06.257000Z"
- }
- },
- "outputs": [],
- "source": [
- "@assert c2.addr === comp2Address"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Unload FMU\n",
- "\n",
- "After plotting the data, the FMU is unloaded and all unpacked data on disc is removed."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 84,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:20:06.260000Z",
- "iopub.status.busy": "2022-10-22T13:20:06.259000Z",
- "iopub.status.idle": "2022-10-22T13:20:06.301000Z",
- "shell.execute_reply": "2022-10-22T13:20:06.301000Z"
- }
- },
- "outputs": [],
- "source": [
- "unloadFMU(myFMU)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Summary\n",
- "\n",
- "Based on the example it can be seen that it is possible to create different instances of an FMU. The different instances can then be used to perform different simulations."
- ]
- }
- ],
- "metadata": {
- "interpreter": {
- "hash": "037537ff7419c497b9325f7d495147943224d408cf5d5ed915294a5b960167b0"
- },
- "jupytext": {
- "cell_metadata_filter": "-all",
- "comment_magics": "false",
- "notebook_metadata_filter": "-all"
- },
- "kernelspec": {
- "display_name": "Julia 1.10.5",
- "language": "julia",
- "name": "julia-1.10"
- },
- "language_info": {
- "file_extension": ".jl",
- "mimetype": "application/julia",
- "name": "julia",
- "version": "1.10.5"
- },
- "nteract": {
- "version": "0.28.0"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/examples/src/multiple_instances.jl b/examples/src/multiple_instances.jl
deleted file mode 100644
index f53fdad4..00000000
--- a/examples/src/multiple_instances.jl
+++ /dev/null
@@ -1,43 +0,0 @@
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-
-# imports
-using FMI
-using FMIZoo
-using Plots
-
-tStart = 0.0
-tStop = 8.0
-
-vrs = ["mass.s"]
-
-# we use an FMU from the FMIZoo.jl
-pathToFMU = get_model_filename("SpringPendulum1D", "Dymola", "2022x")
-
-myFMU = fmiLoad(pathToFMU)
-fmiInfo(myFMU)
-
-comp1 = fmiInstantiate!(myFMU; loggingOn=true)
-comp1Address= comp1.compAddr
-println(comp1)
-
-param1 = Dict("spring.c"=>10.0, "mass_s0"=>1.0)
-data1 = fmiSimulate(comp1, (tStart, tStop); parameters=param1, recordValues=vrs, instantiate=false, freeInstance=false)
-fig = fmiPlot(data1)
-
-@assert comp1.compAddr === comp1Address
-
-comp2 = fmiInstantiate!(myFMU; loggingOn=true)
-comp2Address= comp2.compAddr
-println(comp2)
-
-@assert comp1Address !== comp2Address
-
-param2 = Dict("spring.c"=>1.0, "mass.s"=>2.0)
-data2 = fmiSimulateCS(comp2, (tStart, tStop); parameters=param2, recordValues=vrs, instantiate=false, freeInstance=false)
-fmiPlot!(fig, data2)
-
-@assert comp2.compAddr === comp2Address
-
-fmiUnload(myFMU)
diff --git a/examples/src/multiple_instances.md b/examples/src/multiple_instances.md
deleted file mode 100644
index 3a0eebf3..00000000
--- a/examples/src/multiple_instances.md
+++ /dev/null
@@ -1,151 +0,0 @@
-# Multiple Instances of an FMU
-Tutorial by Johannes Stoljar, Tobias Thummerer
-
-🚧 This tutorial is under revision and will be replaced by an up-to-date version soon 🚧
-
-## License
-
-
-```julia
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-```
-
-## Motivation
-This Julia Package *FMI.jl* is motivated by the use of simulation models in Julia. Here the FMI specification is implemented. FMI (*Functional Mock-up Interface*) is a free standard ([fmi-standard.org](https://fmi-standard.org/)) that defines a container and an interface to exchange dynamic models using a combination of XML files, binaries and C code zipped into a single file. The user can thus use simulation models in the form of an FMU (*Functional Mock-up Units*). Besides loading the FMU, the user can also set values for parameters and states and simulate the FMU both as co-simulation and model exchange simulation.
-
-## Introduction to the example
-In this example we want to show that it is possible to create different instances of an FMU. The different instances can then be used to run independent simulations. After the FMU has been simulated, the simulation results are displayed in a graph. The used model is a one-dimensional spring pendulum without friction. The object-orientated structure of the *SpringPendulum1D* can be seen in the following graphic.
-
-
-
-
-## Target group
-The example is primarily intended for users who work in the field of simulations. The example wants to show how simple it is to use FMUs in Julia.
-
-
-## Other formats
-Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multiple_instances.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multiple_instances.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multiple_instances.md) corresponding to the notebook.
-
-
-## Getting started
-
-### Installation prerequisites
-| | Description | Command | Alternative |
-|:----|:----------------------------------|:--------------------------|:-----------------------------------------------|
-| 1. | Enter Package Manager via | ] | |
-| 2. | Install FMI via | add FMI | add " https://github.com/ThummeTo/FMI.jl " |
-| 3. | Install FMIZoo via | add FMIZoo | add " https://github.com/ThummeTo/FMIZoo.jl " |
-| 4. | Install Plots via | add Plots | |
-
-## Code section
-
-To run the example, the previously installed packages must be included.
-
-
-```julia
-# imports
-using FMI
-using FMIZoo
-using Plots
-```
-
-### Simulation setup
-
-Next, the start time and end time of the simulation are set. Finally, the recorded values are specified to store the results of the simulation.
-
-
-```julia
-tStart = 0.0
-tStop = 8.0
-
-vrs = ["mass.s"]
-```
-
-### Import FMU
-
-In the next lines of code the FMU model from *FMIZoo.jl* is loaded and the information about the FMU is shown.
-
-
-```julia
-# we use an FMU from the FMIZoo.jl
-pathToFMU = get_model_filename("SpringPendulum1D", "Dymola", "2022x")
-
-myFMU = fmiLoad(pathToFMU)
-fmiInfo(myFMU)
-```
-
-### First Instance
-
-To create an instance of the FMU it is necessary to call the command `fmiInstantiate!()`. With the component address you now have a unique instance of the FMU.
-
-
-```julia
-comp1 = fmiInstantiate!(myFMU; loggingOn=true)
-comp1Address= comp1.compAddr
-println(comp1)
-```
-
-Next, a dictionary for the parameters is created. With this dictionary you can set the initial states of the variables of the FMU. For the spring constant `spring.c` a value of $10.0 \frac{N}{m}$ and for the position of the mass `mass.s` a value of $1.0 m$ is set. The created dictionary with the specified variables for recording are passed to the command for simulation. In addition, other keywords are set. On the one hand the keyword `instantiate=false` is set, which prevents that in the simulation command a new instance is created. On the other hand the keyword `freeInstance=false` is set, this prevents that after the simulation command the instance is released.
-
-
-```julia
-param1 = Dict("spring.c"=>10.0, "mass_s0"=>1.0)
-data1 = fmiSimulate(comp1, (tStart, tStop); parameters=param1, recordValues=vrs, instantiate=false, freeInstance=false)
-fig = fmiPlot(data1)
-```
-
-For control, you can compare again the address of the instance to the previous address, and it should be the same address. As soon as this is not the case an error would be thrown by the macro `@assert`.
-
-
-```julia
-@assert comp1.compAddr === comp1Address
-```
-
-### Second Instance
-
-To create a second instance of the FMU it is necessary to call the command `fmiInstantiate!()`. With the component address you now have a unique instance of the FMU.
-
-
-```julia
-comp2 = fmiInstantiate!(myFMU; loggingOn=true)
-comp2Address= comp2.compAddr
-println(comp2)
-```
-
-The addresses of the instantiated FMUs must differ, and you can see that in the comparison below.
-
-
-```julia
-@assert comp1Address !== comp2Address
-```
-
-Again, a dictionary for the parameters is created. With this dictionary you can set the initial states of the variables of the FMU. For the spring constant `spring.c` a value of $1.0 \frac{N}{m}$ and for the position of the mass `mass.s` a value of $2.0 m$ is set. The created dictionary with the specified variables for recording are passed to the command for simulation. As before, the two keywords `instantiate=false` and `freeInstance=false` are set.
-
-
-```julia
-param2 = Dict("spring.c"=>1.0, "mass.s"=>2.0)
-data2 = fmiSimulateCS(comp2, (tStart, tStop); parameters=param2, recordValues=vrs, instantiate=false, freeInstance=false)
-fmiPlot!(fig, data2)
-```
-
-For control, you can compare again the address of the instance `comp2` to the previous address `comp2Address` and it should be the same address.
-
-
-```julia
-@assert comp2.compAddr === comp2Address
-```
-
-### Unload FMU
-
-After plotting the data, the FMU is unloaded and all unpacked data on disc is removed.
-
-
-```julia
-fmiUnload(myFMU)
-```
-
-### Summary
-
-Based on the example it can be seen that it is possible to create different instances of an FMU. The different instances can then be used to perform different simulations.
diff --git a/examples/src/multiple_instances_files/multiple_instances_12_0.png b/examples/src/multiple_instances_files/multiple_instances_12_0.png
deleted file mode 100644
index f7839178..00000000
Binary files a/examples/src/multiple_instances_files/multiple_instances_12_0.png and /dev/null differ
diff --git a/examples/src/multiple_instances_files/multiple_instances_12_0.svg b/examples/src/multiple_instances_files/multiple_instances_12_0.svg
deleted file mode 100644
index dce225c8..00000000
--- a/examples/src/multiple_instances_files/multiple_instances_12_0.svg
+++ /dev/null
@@ -1,46 +0,0 @@
-
-
diff --git a/examples/src/multiple_instances_files/multiple_instances_20_0.png b/examples/src/multiple_instances_files/multiple_instances_20_0.png
deleted file mode 100644
index 5f2120f3..00000000
Binary files a/examples/src/multiple_instances_files/multiple_instances_20_0.png and /dev/null differ
diff --git a/examples/src/multiple_instances_files/multiple_instances_20_0.svg b/examples/src/multiple_instances_files/multiple_instances_20_0.svg
deleted file mode 100644
index ec42c5b5..00000000
--- a/examples/src/multiple_instances_files/multiple_instances_20_0.svg
+++ /dev/null
@@ -1,48 +0,0 @@
-
-
diff --git a/examples/src/multiprocessing.ipynb b/examples/src/multiprocessing.ipynb
deleted file mode 100644
index b0a9ae3f..00000000
--- a/examples/src/multiprocessing.ipynb
+++ /dev/null
@@ -1,510 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Multiprocessing\n",
- "Tutorial by Jonas Wilfert, Tobias Thummerer\n",
- "\n",
- "🚧 This tutorial is under revision and will be replaced by an up-to-date version soon 🚧\n",
- "\n",
- "## License"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2024-09-18T06:56:55.696000Z",
- "iopub.status.busy": "2024-09-18T06:56:55.258000Z",
- "iopub.status.idle": "2024-09-18T06:56:55.977000Z",
- "shell.execute_reply": "2024-09-18T06:56:55.930000Z"
- }
- },
- "outputs": [],
- "source": [
- "# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar, Jonas Wilfert\n",
- "# Licensed under the MIT license. \n",
- "# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Motivation\n",
- "This Julia Package *FMI.jl* is motivated by the use of simulation models in Julia. Here the FMI specification is implemented. FMI (*Functional Mock-up Interface*) is a free standard ([fmi-standard.org](https://fmi-standard.org/)) that defines a container and an interface to exchange dynamic models using a combination of XML files, binaries and C code zipped into a single file. The user can thus use simulation models in the form of an FMU (*Functional Mock-up Units*). Besides loading the FMU, the user can also set values for parameters and states and simulate the FMU both as co-simulation and model exchange simulation.\n",
- "\n",
- "## Introduction to the example\n",
- "This example shows how to parallelize the computation of an FMU in FMI.jl. We can compute a batch of FMU-evaluations in parallel with different initial settings.\n",
- "Parallelization can be achieved using multithreading or using multiprocessing. This example shows **multiprocessing**, check `multithreading.ipynb` for multithreading.\n",
- "Advantage of multithreading is a lower communication overhead as well as lower RAM usage.\n",
- "However in some cases multiprocessing can be faster as the garbage collector is not shared.\n",
- "\n",
- "\n",
- "The model used is a one-dimensional spring pendulum with friction. The object-orientated structure of the *SpringFrictionPendulum1D* can be seen in the following graphic.\n",
- "\n",
- " \n",
- "\n",
- "\n",
- "## Target group\n",
- "The example is primarily intended for users who work in the field of simulations. The example wants to show how simple it is to use FMUs in Julia.\n",
- "\n",
- "\n",
- "## Other formats\n",
- "Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multiprocessing.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multiprocessing.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multiprocessing.md) corresponding to the notebook. \n",
- "\n",
- "\n",
- "## Getting started\n",
- "\n",
- "### Installation prerequisites\n",
- "| | Description | Command | Alternative | \n",
- "|:----|:----------------------------------|:--------------------------|:-----------------------------------------------|\n",
- "| 1. | Enter Package Manager via | ] | |\n",
- "| 2. | Install FMI via | add FMI | add \" https://github.com/ThummeTo/FMI.jl \" |\n",
- "| 3. | Install FMIZoo via | add FMIZoo | add \" https://github.com/ThummeTo/FMIZoo.jl \" |\n",
- "| 4. | Install FMICore via | add FMICore | add \" https://github.com/ThummeTo/FMICore.jl \" |\n",
- "| 5. | Install BenchmarkTools via | add BenchmarkTools | |"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Code section\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Adding your desired amount of processes:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2024-09-18T06:56:55.977000Z",
- "iopub.status.busy": "2024-09-18T06:56:55.977000Z",
- "iopub.status.idle": "2024-09-18T06:57:03.075000Z",
- "shell.execute_reply": "2024-09-18T06:57:03.075000Z"
- }
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "2-element Vector{Int64}:\n",
- " 2\n",
- " 3"
- ]
- },
- "execution_count": 2,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "using Distributed\n",
- "n_procs = 2\n",
- "addprocs(n_procs; exeflags=`--project=$(Base.active_project()) --threads=auto`, restrict=false)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "To run the example, the previously installed packages must be included. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2024-09-18T06:57:03.107000Z",
- "iopub.status.busy": "2024-09-18T06:57:03.107000Z",
- "iopub.status.idle": "2024-09-18T06:57:24.919000Z",
- "shell.execute_reply": "2024-09-18T06:57:24.919000Z"
- }
- },
- "outputs": [],
- "source": [
- "# imports\n",
- "@everywhere using FMI\n",
- "@everywhere using FMIZoo\n",
- "@everywhere using DifferentialEquations\n",
- "@everywhere using BenchmarkTools"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Checking that we workers have been correctly initialized:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2024-09-18T06:57:25.060000Z",
- "iopub.status.busy": "2024-09-18T06:57:24.919000Z",
- "iopub.status.idle": "2024-09-18T06:57:25.123000Z",
- "shell.execute_reply": "2024-09-18T06:57:25.123000Z"
- }
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hello World!\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- " From worker 2:\tHello World!\n",
- " From worker 3:\tHello World!"
- ]
- }
- ],
- "source": [
- "workers()\n",
- "\n",
- "@everywhere println(\"Hello World!\")\n",
- "\n",
- "# The following lines can be uncommented for more advanced information about the subprocesses\n",
- "# @everywhere println(pwd())\n",
- "# @everywhere println(Base.active_project())\n",
- "# @everywhere println(gethostname())\n",
- "# @everywhere println(VERSION)\n",
- "# @everywhere println(Threads.nthreads())"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Simulation setup\n",
- "\n",
- "Next, the batch size and input values are defined."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2024-09-18T06:57:25.123000Z",
- "iopub.status.busy": "2024-09-18T06:57:25.123000Z",
- "iopub.status.idle": "2024-09-18T06:57:26.764000Z",
- "shell.execute_reply": "2024-09-18T06:57:26.764000Z"
- }
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "\n"
- ]
- },
- {
- "data": {
- "text/plain": [
- "16-element Vector{Vector{Float64}}:\n",
- " [0.8896151422243904, 0.19360331402643516]\n",
- " [0.5667607315125027, 0.8469069630650393]\n",
- " [0.4467595228412755, 0.11565682370854558]\n",
- " [0.16792108625193536, 0.8851389775680923]\n",
- " [0.8085429088036629, 0.1348042631253319]\n",
- " [0.22403537940585305, 0.4003499683325523]\n",
- " [0.6181748598004135, 0.03844117933163582]\n",
- " [0.4406224572743377, 0.5926575758049457]\n",
- " [0.2983365896614829, 0.553293392273904]\n",
- " [0.024123375732912677, 0.3322971075005886]\n",
- " [0.9602759520524581, 0.36629615676373006]\n",
- " [0.5403567465763699, 0.48659208795242603]\n",
- " [0.7055325623167514, 0.9113177671381074]\n",
- " [0.9584900337743231, 0.7550085456804099]\n",
- " [0.4928513219033166, 0.24472926422690866]\n",
- " [0.6994234096332927, 0.8094366580173032]"
- ]
- },
- "execution_count": 5,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "\n",
- "# Best if batchSize is a multiple of the threads/cores\n",
- "batchSize = 16\n",
- "\n",
- "# Define an array of arrays randomly\n",
- "input_values = collect(collect.(eachrow(rand(batchSize,2))))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Shared Module\n",
- "For Distributed we need to embed the FMU into its own `module`. This prevents Distributed from trying to serialize and send the FMU over the network, as this can cause issues. This module needs to be made available on all processes using `@everywhere`."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2024-09-18T06:57:26.764000Z",
- "iopub.status.busy": "2024-09-18T06:57:26.764000Z",
- "iopub.status.idle": "2024-09-18T06:57:35.285000Z",
- "shell.execute_reply": "2024-09-18T06:57:35.285000Z"
- }
- },
- "outputs": [],
- "source": [
- "@everywhere module SharedModule\n",
- " using FMIZoo\n",
- " using FMI\n",
- "\n",
- " t_start = 0.0\n",
- " t_step = 0.1\n",
- " t_stop = 10.0\n",
- " tspan = (t_start, t_stop)\n",
- " tData = collect(t_start:t_step:t_stop)\n",
- "\n",
- " model_fmu = loadFMU(\"SpringPendulum1D\", \"Dymola\", \"2022x\"; type=:ME)\n",
- "end"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "We define a helper function to calculate the FMU and combine it into an Matrix."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2024-09-18T06:57:35.285000Z",
- "iopub.status.busy": "2024-09-18T06:57:35.285000Z",
- "iopub.status.idle": "2024-09-18T06:57:35.363000Z",
- "shell.execute_reply": "2024-09-18T06:57:35.363000Z"
- }
- },
- "outputs": [],
- "source": [
- "@everywhere function runCalcFormatted(fmu, x0, recordValues=[\"mass.s\", \"mass.v\"])\n",
- " data = simulateME(fmu, SharedModule.tspan; recordValues=recordValues, saveat=SharedModule.tData, x0=x0, showProgress=false, dtmax=1e-4)\n",
- " return reduce(hcat, data.states.u)\n",
- "end"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Running a single evaluation is pretty quick, therefore the speed can be better tested with BenchmarkTools."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2024-09-18T06:57:35.363000Z",
- "iopub.status.busy": "2024-09-18T06:57:35.363000Z",
- "iopub.status.idle": "2024-09-18T06:58:16.187000Z",
- "shell.execute_reply": "2024-09-18T06:58:16.187000Z"
- }
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "BenchmarkTools.Trial: 2 samples with 1 evaluation.\n",
- " Range \u001b[90m(\u001b[39m\u001b[36m\u001b[1mmin\u001b[22m\u001b[39m … \u001b[35mmax\u001b[39m\u001b[90m): \u001b[39m\u001b[36m\u001b[1m3.064 s\u001b[22m\u001b[39m … \u001b[35m 3.397 s\u001b[39m \u001b[90m┊\u001b[39m GC \u001b[90m(\u001b[39mmin … max\u001b[90m): \u001b[39m0.73% … 7.40%\n",
- " Time \u001b[90m(\u001b[39m\u001b[34m\u001b[1mmedian\u001b[22m\u001b[39m\u001b[90m): \u001b[39m\u001b[34m\u001b[1m3.230 s \u001b[22m\u001b[39m\u001b[90m┊\u001b[39m GC \u001b[90m(\u001b[39mmedian\u001b[90m): \u001b[39m4.24%\n",
- " Time \u001b[90m(\u001b[39m\u001b[32m\u001b[1mmean\u001b[22m\u001b[39m ± \u001b[32mσ\u001b[39m\u001b[90m): \u001b[39m\u001b[32m\u001b[1m3.230 s\u001b[22m\u001b[39m ± \u001b[32m235.653 ms\u001b[39m \u001b[90m┊\u001b[39m GC \u001b[90m(\u001b[39mmean ± σ\u001b[90m): \u001b[39m4.24% ± 4.72%\n",
- "\n",
- " \u001b[34m█\u001b[39m\u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[32m \u001b[39m\u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m█\u001b[39m \u001b[39m \n",
- " \u001b[34m█\u001b[39m\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[32m▁\u001b[39m\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m█\u001b[39m \u001b[39m▁\n",
- " 3.06 s\u001b[90m Histogram: frequency by time\u001b[39m 3.4 s \u001b[0m\u001b[1m<\u001b[22m\n",
- "\n",
- " Memory estimate\u001b[90m: \u001b[39m\u001b[33m300.76 MiB\u001b[39m, allocs estimate\u001b[90m: \u001b[39m\u001b[33m7603698\u001b[39m."
- ]
- },
- "execution_count": 8,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "@benchmark data = runCalcFormatted(SharedModule.model_fmu, rand(2))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Single Threaded Batch Execution\n",
- "To compute a batch we can collect multiple evaluations. In a single threaded context we can use the same FMU for every call."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 9,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2024-09-18T06:58:16.187000Z",
- "iopub.status.busy": "2024-09-18T06:58:16.187000Z",
- "iopub.status.idle": "2024-09-18T07:00:45.253000Z",
- "shell.execute_reply": "2024-09-18T07:00:45.253000Z"
- }
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Single Threaded\n"
- ]
- },
- {
- "data": {
- "text/plain": [
- "BenchmarkTools.Trial: 1 sample with 1 evaluation.\n",
- " Single result which took \u001b[34m49.249 s\u001b[39m (0.94% GC) to evaluate,\n",
- " with a memory estimate of \u001b[33m4.70 GiB\u001b[39m, over \u001b[33m121659156\u001b[39m allocations."
- ]
- },
- "execution_count": 9,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "println(\"Single Threaded\")\n",
- "@benchmark collect(runCalcFormatted(SharedModule.model_fmu, i) for i in input_values)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Multithreaded Batch Execution\n",
- "In a multithreaded context we have to provide each thread it's own fmu, as they are not thread safe.\n",
- "To spread the execution of a function to multiple processes, the function `pmap` can be used."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2024-09-18T07:00:45.268000Z",
- "iopub.status.busy": "2024-09-18T07:00:45.268000Z",
- "iopub.status.idle": "2024-09-18T07:02:35.412000Z",
- "shell.execute_reply": "2024-09-18T07:02:35.412000Z"
- }
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Multi Threaded\n"
- ]
- },
- {
- "data": {
- "text/plain": [
- "BenchmarkTools.Trial: 1 sample with 1 evaluation.\n",
- " Single result which took \u001b[34m29.315 s\u001b[39m (0.00% GC) to evaluate,\n",
- " with a memory estimate of \u001b[33m99.25 KiB\u001b[39m, over \u001b[33m1583\u001b[39m allocations."
- ]
- },
- "execution_count": 10,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "println(\"Multi Threaded\")\n",
- "@benchmark pmap(i -> runCalcFormatted(SharedModule.model_fmu, i), input_values)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "As you can see, there is a significant speed-up in the median execution time. But: The speed-up is often much smaller than `n_procs` (or the number of physical cores of your CPU), this has different reasons. For a rule of thumb, the speed-up should be around `n/2` on a `n`-core-processor with `n` Julia processes."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Unload FMU\n",
- "\n",
- "After calculating the data, the FMU is unloaded and all unpacked data on disc is removed."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2024-09-18T07:02:35.427000Z",
- "iopub.status.busy": "2024-09-18T07:02:35.427000Z",
- "iopub.status.idle": "2024-09-18T07:02:35.787000Z",
- "shell.execute_reply": "2024-09-18T07:02:35.787000Z"
- }
- },
- "outputs": [],
- "source": [
- "@everywhere unloadFMU(SharedModule.model_fmu)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Summary\n",
- "\n",
- "In this tutorial it is shown how multi processing with `Distributed.jl` can be used to improve the performance for calculating a Batch of FMUs."
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Julia 1.10.5",
- "language": "julia",
- "name": "julia-1.10"
- },
- "language_info": {
- "file_extension": ".jl",
- "mimetype": "application/julia",
- "name": "julia",
- "version": "1.10.5"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/examples/src/multiprocessing.jl b/examples/src/multiprocessing.jl
deleted file mode 100644
index a1464b29..00000000
--- a/examples/src/multiprocessing.jl
+++ /dev/null
@@ -1,58 +0,0 @@
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar, Jonas Wilfert
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-
-using Distributed
-n_procs = 2
-addprocs(n_procs; exeflags=`--project=$(Base.active_project()) --threads=auto`, restrict=false)
-
-# imports
-@everywhere using FMI
-@everywhere using FMIZoo
-@everywhere using BenchmarkTools
-
-workers()
-
-@everywhere println("Hello World!")
-
-# The following lines can be uncommented for more advanced informations about the subprocesses
-# @everywhere println(pwd())
-# @everywhere println(Base.active_project())
-# @everywhere println(gethostname())
-# @everywhere println(VERSION)
-# @everywhere println(Threads.nthreads())
-
-
-# Best if batchSize is a multiple of the threads/cores
-batchSize = 16
-
-# Define an array of arrays randomly
-input_values = collect(collect.(eachrow(rand(batchSize,2))))
-
-@everywhere module SharedModule
- using FMIZoo
- using FMI
-
- t_start = 0.0
- t_step = 0.1
- t_stop = 10.0
- tspan = (t_start, t_stop)
- tData = collect(t_start:t_step:t_stop)
-
- model_fmu = FMIZoo.fmiLoad("SpringPendulum1D", "Dymola", "2022x")
-end
-
-@everywhere function runCalcFormatted(fmu, x0, recordValues=["mass.s", "mass.v"])
- data = fmiSimulateME(fmu, SharedModule.tspan; recordValues=recordValues, saveat=SharedModule.tData, x0=x0, showProgress=false, dtmax=1e-4)
- return reduce(hcat, data.states.u)
-end
-
-@benchmark data = runCalcFormatted(SharedModule.model_fmu, rand(2))
-
-println("Single Threaded")
-@benchmark collect(runCalcFormatted(SharedModule.model_fmu, i) for i in input_values)
-
-println("Multi Threaded")
-@benchmark pmap(i -> runCalcFormatted(SharedModule.model_fmu, i), input_values)
-
-@everywhere fmiUnload(SharedModule.model_fmu)
diff --git a/examples/src/multiprocessing.md b/examples/src/multiprocessing.md
deleted file mode 100644
index 4250c5c5..00000000
--- a/examples/src/multiprocessing.md
+++ /dev/null
@@ -1,170 +0,0 @@
-# Multiprocessing
-Tutorial by Jonas Wilfert, Tobias Thummerer
-
-🚧 This tutorial is under revision and will be replaced by an up-to-date version soon 🚧
-
-## License
-
-
-```julia
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar, Jonas Wilfert
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-```
-
-## Motivation
-This Julia Package *FMI.jl* is motivated by the use of simulation models in Julia. Here the FMI specification is implemented. FMI (*Functional Mock-up Interface*) is a free standard ([fmi-standard.org](https://fmi-standard.org/)) that defines a container and an interface to exchange dynamic models using a combination of XML files, binaries and C code zipped into a single file. The user can thus use simulation models in the form of an FMU (*Functional Mock-up Units*). Besides loading the FMU, the user can also set values for parameters and states and simulate the FMU both as co-simulation and model exchange simulation.
-
-## Introduction to the example
-This example shows how to parallelize the computation of an FMU in FMI.jl. We can compute a batch of FMU-evaluations in parallel with different initial settings.
-Parallelization can be achieved using multithreading or using multiprocessing. This example shows **multiprocessing**, check `multithreading.ipynb` for multithreading.
-Advantage of multithreading is a lower communication overhead as well as lower RAM usage.
-However in some cases multiprocessing can be faster as the garbage collector is not shared.
-
-
-The model used is a one-dimensional spring pendulum with friction. The object-orientated structure of the *SpringFrictionPendulum1D* can be seen in the following graphic.
-
-
-
-
-## Target group
-The example is primarily intended for users who work in the field of simulations. The example wants to show how simple it is to use FMUs in Julia.
-
-
-## Other formats
-Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multiprocessing.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multiprocessing.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multiprocessing.md) corresponding to the notebook.
-
-
-## Getting started
-
-### Installation prerequisites
-| | Description | Command | Alternative |
-|:----|:----------------------------------|:--------------------------|:-----------------------------------------------|
-| 1. | Enter Package Manager via | ] | |
-| 2. | Install FMI via | add FMI | add " https://github.com/ThummeTo/FMI.jl " |
-| 3. | Install FMIZoo via | add FMIZoo | add " https://github.com/ThummeTo/FMIZoo.jl " |
-| 4. | Install FMICore via | add FMICore | add " https://github.com/ThummeTo/FMICore.jl " |
-| 5. | Install BenchmarkTools via | add BenchmarkTools | |
-
-## Code section
-
-
-
-Adding your desired amount of processes:
-
-
-```julia
-using Distributed
-n_procs = 2
-addprocs(n_procs; exeflags=`--project=$(Base.active_project()) --threads=auto`, restrict=false)
-```
-
-To run the example, the previously installed packages must be included.
-
-
-```julia
-# imports
-@everywhere using FMI
-@everywhere using FMIZoo
-@everywhere using BenchmarkTools
-```
-
-Checking that we workers have been correctly initialized:
-
-
-```julia
-workers()
-
-@everywhere println("Hello World!")
-
-# The following lines can be uncommented for more advanced informations about the subprocesses
-# @everywhere println(pwd())
-# @everywhere println(Base.active_project())
-# @everywhere println(gethostname())
-# @everywhere println(VERSION)
-# @everywhere println(Threads.nthreads())
-```
-
-### Simulation setup
-
-Next, the batch size and input values are defined.
-
-
-```julia
-
-# Best if batchSize is a multiple of the threads/cores
-batchSize = 16
-
-# Define an array of arrays randomly
-input_values = collect(collect.(eachrow(rand(batchSize,2))))
-```
-
-### Shared Module
-For Distributed we need to embed the FMU into its own `module`. This prevents Distributed from trying to serialize and send the FMU over the network, as this can cause issues. This module needs to be made available on all processes using `@everywhere`.
-
-
-```julia
-@everywhere module SharedModule
- using FMIZoo
- using FMI
-
- t_start = 0.0
- t_step = 0.1
- t_stop = 10.0
- tspan = (t_start, t_stop)
- tData = collect(t_start:t_step:t_stop)
-
- model_fmu = FMIZoo.fmiLoad("SpringPendulum1D", "Dymola", "2022x")
-end
-```
-
-We define a helper function to calculate the FMU and combine it into an Matrix.
-
-
-```julia
-@everywhere function runCalcFormatted(fmu, x0, recordValues=["mass.s", "mass.v"])
- data = fmiSimulateME(fmu, SharedModule.tspan; recordValues=recordValues, saveat=SharedModule.tData, x0=x0, showProgress=false, dtmax=1e-4)
- return reduce(hcat, data.states.u)
-end
-```
-
-Running a single evaluation is pretty quick, therefore the speed can be better tested with BenchmarkTools.
-
-
-```julia
-@benchmark data = runCalcFormatted(SharedModule.model_fmu, rand(2))
-```
-
-### Single Threaded Batch Execution
-To compute a batch we can collect multiple evaluations. In a single threaded context we can use the same FMU for every call.
-
-
-```julia
-println("Single Threaded")
-@benchmark collect(runCalcFormatted(SharedModule.model_fmu, i) for i in input_values)
-```
-
-### Multithreaded Batch Execution
-In a multithreaded context we have to provide each thread it's own fmu, as they are not thread safe.
-To spread the execution of a function to multiple processes, the function `pmap` can be used.
-
-
-```julia
-println("Multi Threaded")
-@benchmark pmap(i -> runCalcFormatted(SharedModule.model_fmu, i), input_values)
-```
-
-As you can see, there is a significant speed-up in the median execution time. But: The speed-up is often much smaller than `n_procs` (or the number of physical cores of your CPU), this has different reasons. For a rule of thumb, the speed-up should be around `n/2` on a `n`-core-processor with `n` Julia processes.
-
-### Unload FMU
-
-After calculating the data, the FMU is unloaded and all unpacked data on disc is removed.
-
-
-```julia
-@everywhere fmiUnload(SharedModule.model_fmu)
-```
-
-### Summary
-
-In this tutorial it is shown how multi processing with `Distributed.jl` can be used to improve the performance for calculating a Batch of FMUs.
diff --git a/examples/src/multithreading.ipynb b/examples/src/multithreading.ipynb
deleted file mode 100644
index 4f7f1edc..00000000
--- a/examples/src/multithreading.ipynb
+++ /dev/null
@@ -1,354 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Multithreading\n",
- "Tutorial by Jonas Wilfert, Tobias Thummerer\n",
- "\n",
- "🚧 This tutorial is under revision and will be replaced by an up-to-date version soon 🚧\n",
- "\n",
- "## License"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 21,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:24:22.502000Z",
- "iopub.status.busy": "2022-10-22T13:24:21.808000Z",
- "iopub.status.idle": "2022-10-22T13:24:22.776000Z",
- "shell.execute_reply": "2022-10-22T13:24:22.704000Z"
- }
- },
- "outputs": [],
- "source": [
- "# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar, Jonas Wilfert\n",
- "# Licensed under the MIT license. \n",
- "# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Motivation\n",
- "This Julia Package *FMI.jl* is motivated by the use of simulation models in Julia. Here the FMI specification is implemented. FMI (*Functional Mock-up Interface*) is a free standard ([fmi-standard.org](https://fmi-standard.org/)) that defines a container and an interface to exchange dynamic models using a combination of XML files, binaries and C code zipped into a single file. The user can thus use simulation models in the form of an FMU (*Functional Mock-up Units*). Besides loading the FMU, the user can also set values for parameters and states and simulate the FMU both as co-simulation and model exchange simulation.\n",
- "\n",
- "## Introduction to the example\n",
- "This example shows how to parallelize the computation of an FMU in FMI.jl. We can compute a batch of FMU-evaluations in parallel with different initial settings.\n",
- "Parallelization can be achieved using multithreading or using multiprocessing. This example shows **multithreading**, check `multiprocessing.ipynb` for multiprocessing.\n",
- "Advantage of multithreading is a lower communication overhead as well as lower RAM usage.\n",
- "However in some cases multiprocessing can be faster as the garbage collector is not shared.\n",
- "\n",
- "\n",
- "The model used is a one-dimensional spring pendulum with friction. The object-orientated structure of the *SpringFrictionPendulum1D* can be seen in the following graphic.\n",
- "\n",
- " \n",
- "\n",
- "\n",
- "## Target group\n",
- "The example is primarily intended for users who work in the field of simulations. The example wants to show how simple it is to use FMUs in Julia.\n",
- "\n",
- "\n",
- "## Other formats\n",
- "Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multithreading.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multithreading.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multithreading.md) corresponding to the notebook. \n",
- "\n",
- "\n",
- "## Getting started\n",
- "\n",
- "### Installation prerequisites\n",
- "| | Description | Command | Alternative | \n",
- "|:----|:----------------------------------|:--------------------------|:-----------------------------------------------|\n",
- "| 1. | Enter Package Manager via | ] | |\n",
- "| 2. | Install FMI via | add FMI | add \" https://github.com/ThummeTo/FMI.jl \" |\n",
- "| 3. | Install FMIZoo via | add FMIZoo | add \" https://github.com/ThummeTo/FMIZoo.jl \" |\n",
- "| 4. | Install FMICore via | add FMICore | add \" https://github.com/ThummeTo/FMICore.jl \" |\n",
- "| 5. | Install Folds via | add Folds | |\n",
- "| 6. | Install BenchmarkTools via | add BenchmarkTools | |"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Code section\n",
- "\n",
- "To run the example, the previously installed packages must be included. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 22,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:24:22.779000Z",
- "iopub.status.busy": "2022-10-22T13:24:22.779000Z",
- "iopub.status.idle": "2022-10-22T13:24:56.411000Z",
- "shell.execute_reply": "2022-10-22T13:24:56.411000Z"
- }
- },
- "outputs": [],
- "source": [
- "# imports\n",
- "using FMI\n",
- "using FMIZoo\n",
- "using Folds\n",
- "using BenchmarkTools\n",
- "using DifferentialEquations"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "First, check the amount of available threads:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:24:56.610000Z",
- "iopub.status.busy": "2022-10-22T13:24:56.414000Z",
- "iopub.status.idle": "2022-10-22T13:24:57.213000Z",
- "shell.execute_reply": "2022-10-22T13:24:57.212000Z"
- }
- },
- "outputs": [],
- "source": [
- "Threads.nthreads()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "If the number of available threads doesn't match your expections, you can increase the number of threads available to the Julia process like described [here](https://docs.julialang.org/en/v1/manual/multi-threading/#Starting-Julia-with-multiple-threads)."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Simulation setup\n",
- "\n",
- "Next, the start time and end time of the simulation are set. Here we also decide the size of the batch."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:24:57.217000Z",
- "iopub.status.busy": "2022-10-22T13:24:57.217000Z",
- "iopub.status.idle": "2022-10-22T13:25:02.608000Z",
- "shell.execute_reply": "2022-10-22T13:25:02.608000Z"
- }
- },
- "outputs": [],
- "source": [
- "t_start = 0.0\n",
- "t_step = 0.1\n",
- "t_stop = 10.0\n",
- "tspan = (t_start, t_stop)\n",
- "tData = collect(t_start:t_step:t_stop)\n",
- "\n",
- "# Best if batchSize is a multiple of the threads/cores\n",
- "batchSize = Threads.nthreads()\n",
- "\n",
- "# Define an array of arrays randomly\n",
- "input_values = collect(collect.(eachrow(rand(batchSize,2))))\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "We need to instantiate one FMU for each parallel execution, as they cannot be easily shared among different threads."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:25:02.612000Z",
- "iopub.status.busy": "2022-10-22T13:25:02.612000Z",
- "iopub.status.idle": "2022-10-22T13:25:08.843000Z",
- "shell.execute_reply": "2022-10-22T13:25:08.843000Z"
- }
- },
- "outputs": [],
- "source": [
- "# a single FMU to compare the performance\n",
- "realFMU = loadFMU(\"SpringPendulum1D\", \"Dymola\", \"2022x\")\n",
- "\n",
- "# the FMU batch\n",
- "realFMUBatch = [loadFMU(\"SpringPendulum1D\", \"Dymola\", \"2022x\") for _ in 1:batchSize]"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "We define a helper function to calculate the FMU solution and combine it into an Matrix."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:25:08.847000Z",
- "iopub.status.busy": "2022-10-22T13:25:08.847000Z",
- "iopub.status.idle": "2022-10-22T13:25:09.898000Z",
- "shell.execute_reply": "2022-10-22T13:25:09.898000Z"
- }
- },
- "outputs": [],
- "source": [
- "function runCalcFormatted(fmu::FMU2, x0::Vector{Float64}, recordValues::Vector{String}=[\"mass.s\", \"mass.v\"])\n",
- " data = simulateME(fmu, tspan; recordValues=recordValues, saveat=tData, x0=x0, showProgress=false, dtmax=1e-4)\n",
- " return reduce(hcat, data.states.u)\n",
- "end"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Running a single evaluation is pretty quick, therefore the speed can be better tested with BenchmarkTools."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:25:09.902000Z",
- "iopub.status.busy": "2022-10-22T13:25:09.902000Z",
- "iopub.status.idle": "2022-10-22T13:25:55.418000Z",
- "shell.execute_reply": "2022-10-22T13:25:55.417000Z"
- }
- },
- "outputs": [],
- "source": [
- "@benchmark data = runCalcFormatted(realFMU, rand(2))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Single Threaded Batch Execution\n",
- "To compute a batch we can collect multiple evaluations. In a single threaded context we can use the same FMU for every call."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:25:55.422000Z",
- "iopub.status.busy": "2022-10-22T13:25:55.422000Z",
- "iopub.status.idle": "2022-10-22T13:26:13.196000Z",
- "shell.execute_reply": "2022-10-22T13:26:13.196000Z"
- }
- },
- "outputs": [],
- "source": [
- "println(\"Single Threaded\")\n",
- "@benchmark collect(runCalcFormatted(realFMU, i) for i in input_values)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Multithreaded Batch Execution\n",
- "In a multithreaded context we have to provide each thread it's own fmu, as they are not thread safe.\n",
- "To spread the execution of a function to multiple threads, the library `Folds` can be used."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:26:13.200000Z",
- "iopub.status.busy": "2022-10-22T13:26:13.200000Z",
- "iopub.status.idle": "2022-10-22T13:26:34.238000Z",
- "shell.execute_reply": "2022-10-22T13:26:34.238000Z"
- }
- },
- "outputs": [],
- "source": [
- "println(\"Multi Threaded\")\n",
- "@benchmark Folds.collect(runCalcFormatted(fmu, i) for (fmu, i) in zip(realFMUBatch, input_values))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "As you can see, there is a significant speed-up in the median execution time. But: The speed-up is often much smaller than `Threads.nthreads()`, this has different reasons. For a rule of thumb, the speed-up should be around `n/2` on a `n`-core-processor with `n` threads for the Julia process."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Unload FMU\n",
- "\n",
- "After calculating the data, the FMU is unloaded and all unpacked data on disc is removed."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:26:34.242000Z",
- "iopub.status.busy": "2022-10-22T13:26:34.242000Z",
- "iopub.status.idle": "2022-10-22T13:26:35.698000Z",
- "shell.execute_reply": "2022-10-22T13:26:35.698000Z"
- }
- },
- "outputs": [],
- "source": [
- "unloadFMU(realFMU)\n",
- "unloadFMU.(realFMUBatch)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Summary\n",
- "\n",
- "In this tutorial it is shown how multi threading with `Folds.jl` can be used to improve the performance for calculating a Batch of FMUs."
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Julia 1.10.5",
- "language": "julia",
- "name": "julia-1.10"
- },
- "language_info": {
- "file_extension": ".jl",
- "mimetype": "application/julia",
- "name": "julia",
- "version": "1.10.5"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/examples/src/multithreading.jl b/examples/src/multithreading.jl
deleted file mode 100644
index d33a9316..00000000
--- a/examples/src/multithreading.jl
+++ /dev/null
@@ -1,46 +0,0 @@
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar, Jonas Wilfert
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-
-# imports
-using FMI
-using FMIZoo
-using Folds
-using BenchmarkTools
-
-Threads.nthreads()
-
-t_start = 0.0
-t_step = 0.1
-t_stop = 10.0
-tspan = (t_start, t_stop)
-tData = collect(t_start:t_step:t_stop)
-
-# Best if batchSize is a multiple of the threads/cores
-batchSize = Threads.nthreads()
-
-# Define an array of arrays randomly
-input_values = collect(collect.(eachrow(rand(batchSize,2))))
-
-
-# a single FMU to compare the performance
-realFMU = fmiLoad("SpringPendulum1D", "Dymola", "2022x")
-
-# the FMU batch
-realFMUBatch = [fmiLoad("SpringPendulum1D", "Dymola", "2022x") for _ in 1:batchSize]
-
-function runCalcFormatted(fmu::FMU2, x0::Vector{Float64}, recordValues::Vector{String}=["mass.s", "mass.v"])
- data = fmiSimulateME(fmu, tspan; recordValues=recordValues, saveat=tData, x0=x0, showProgress=false, dtmax=1e-4)
- return reduce(hcat, data.states.u)
-end
-
-@benchmark data = runCalcFormatted(realFMU, rand(2))
-
-println("Single Threaded")
-@benchmark collect(runCalcFormatted(realFMU, i) for i in input_values)
-
-println("Multi Threaded")
-@benchmark Folds.collect(runCalcFormatted(fmu, i) for (fmu, i) in zip(realFMUBatch, input_values))
-
-fmiUnload(realFMU)
-fmiUnload.(realFMUBatch)
diff --git a/examples/src/multithreading.md b/examples/src/multithreading.md
deleted file mode 100644
index 5e69d3bf..00000000
--- a/examples/src/multithreading.md
+++ /dev/null
@@ -1,153 +0,0 @@
-# Multithreading
-Tutorial by Jonas Wilfert, Tobias Thummerer
-
-🚧 This tutorial is under revision and will be replaced by an up-to-date version soon 🚧
-
-## License
-
-
-```julia
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar, Jonas Wilfert
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-```
-
-## Motivation
-This Julia Package *FMI.jl* is motivated by the use of simulation models in Julia. Here the FMI specification is implemented. FMI (*Functional Mock-up Interface*) is a free standard ([fmi-standard.org](https://fmi-standard.org/)) that defines a container and an interface to exchange dynamic models using a combination of XML files, binaries and C code zipped into a single file. The user can thus use simulation models in the form of an FMU (*Functional Mock-up Units*). Besides loading the FMU, the user can also set values for parameters and states and simulate the FMU both as co-simulation and model exchange simulation.
-
-## Introduction to the example
-This example shows how to parallelize the computation of an FMU in FMI.jl. We can compute a batch of FMU-evaluations in parallel with different initial settings.
-Parallelization can be achieved using multithreading or using multiprocessing. This example shows **multithreading**, check `multiprocessing.ipynb` for multiprocessing.
-Advantage of multithreading is a lower communication overhead as well as lower RAM usage.
-However in some cases multiprocessing can be faster as the garbage collector is not shared.
-
-
-The model used is a one-dimensional spring pendulum with friction. The object-orientated structure of the *SpringFrictionPendulum1D* can be seen in the following graphic.
-
-
-
-
-## Target group
-The example is primarily intended for users who work in the field of simulations. The example wants to show how simple it is to use FMUs in Julia.
-
-
-## Other formats
-Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multithreading.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multithreading.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/multithreading.md) corresponding to the notebook.
-
-
-## Getting started
-
-### Installation prerequisites
-| | Description | Command | Alternative |
-|:----|:----------------------------------|:--------------------------|:-----------------------------------------------|
-| 1. | Enter Package Manager via | ] | |
-| 2. | Install FMI via | add FMI | add " https://github.com/ThummeTo/FMI.jl " |
-| 3. | Install FMIZoo via | add FMIZoo | add " https://github.com/ThummeTo/FMIZoo.jl " |
-| 4. | Install FMICore via | add FMICore | add " https://github.com/ThummeTo/FMICore.jl " |
-| 5. | Install Folds via | add Folds | |
-| 6. | Install BenchmarkTools via | add BenchmarkTools | |
-
-## Code section
-
-To run the example, the previously installed packages must be included.
-
-
-```julia
-# imports
-using FMI
-using FMIZoo
-using Folds
-using BenchmarkTools
-```
-
-First, check the amount of available threads:
-
-
-```julia
-Threads.nthreads()
-```
-
-If the number of available threads doesn't match your expections, you can increase the number of threads available to the Julia process like described [here](https://docs.julialang.org/en/v1/manual/multi-threading/#Starting-Julia-with-multiple-threads).
-
-### Simulation setup
-
-Next, the start time and end time of the simulation are set. Here we also decide the size of the batch.
-
-
-```julia
-t_start = 0.0
-t_step = 0.1
-t_stop = 10.0
-tspan = (t_start, t_stop)
-tData = collect(t_start:t_step:t_stop)
-
-# Best if batchSize is a multiple of the threads/cores
-batchSize = Threads.nthreads()
-
-# Define an array of arrays randomly
-input_values = collect(collect.(eachrow(rand(batchSize,2))))
-
-```
-
-We need to instantiate one FMU for each parallel execution, as they cannot be easily shared among different threads.
-
-
-```julia
-# a single FMU to compare the performance
-realFMU = fmiLoad("SpringPendulum1D", "Dymola", "2022x")
-
-# the FMU batch
-realFMUBatch = [fmiLoad("SpringPendulum1D", "Dymola", "2022x") for _ in 1:batchSize]
-```
-
-We define a helper function to calculate the FMU solution and combine it into an Matrix.
-
-
-```julia
-function runCalcFormatted(fmu::FMU2, x0::Vector{Float64}, recordValues::Vector{String}=["mass.s", "mass.v"])
- data = fmiSimulateME(fmu, tspan; recordValues=recordValues, saveat=tData, x0=x0, showProgress=false, dtmax=1e-4)
- return reduce(hcat, data.states.u)
-end
-```
-
-Running a single evaluation is pretty quick, therefore the speed can be better tested with BenchmarkTools.
-
-
-```julia
-@benchmark data = runCalcFormatted(realFMU, rand(2))
-```
-
-### Single Threaded Batch Execution
-To compute a batch we can collect multiple evaluations. In a single threaded context we can use the same FMU for every call.
-
-
-```julia
-println("Single Threaded")
-@benchmark collect(runCalcFormatted(realFMU, i) for i in input_values)
-```
-
-### Multithreaded Batch Execution
-In a multithreaded context we have to provide each thread it's own fmu, as they are not thread safe.
-To spread the execution of a function to multiple threads, the library `Folds` can be used.
-
-
-```julia
-println("Multi Threaded")
-@benchmark Folds.collect(runCalcFormatted(fmu, i) for (fmu, i) in zip(realFMUBatch, input_values))
-```
-
-As you can see, there is a significant speed-up in the median execution time. But: The speed-up is often much smaller than `Threads.nthreads()`, this has different reasons. For a rule of thumb, the speed-up should be around `n/2` on a `n`-core-processor with `n` threads for the Julia process.
-
-### Unload FMU
-
-After calculating the data, the FMU is unloaded and all unpacked data on disc is removed.
-
-
-```julia
-fmiUnload(realFMU)
-fmiUnload.(realFMUBatch)
-```
-
-### Summary
-
-In this tutorial it is shown how multi threading with `Folds.jl` can be used to improve the performance for calculating a Batch of FMUs.
diff --git a/examples/src/parameter_optimization.ipynb b/examples/src/parameter_optimization.ipynb
deleted file mode 100644
index 585466bb..00000000
--- a/examples/src/parameter_optimization.ipynb
+++ /dev/null
@@ -1,356 +0,0 @@
-{
- "cells": [
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# FMU Parameter Optimization\n",
- "Tutorial by Tobias Thummerer\n",
- "\n",
- "## License"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 19,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:26:47.623000Z",
- "iopub.status.busy": "2022-10-22T13:26:46.768000Z",
- "iopub.status.idle": "2022-10-22T13:26:47.904000Z",
- "shell.execute_reply": "2022-10-22T13:26:47.830000Z"
- }
- },
- "outputs": [],
- "source": [
- "# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons\n",
- "# Licensed under the MIT license. \n",
- "# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Introduction to the example\n",
- "This example shows how a parameter optimization can be set up for a FMU. The goal is to fit FMU parameters (and initial states), so that a reference trajectory is fit as good as possible.\n",
- "\n",
- "Note, that this tutorial covers optimization *without* gradient information. Basically, *FMI.jl* supports gradient based optimization, too.\n",
- "\n",
- "## Other formats\n",
- "Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/parameter_optimization.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/parameter_optimization.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/parameter_optimization.md) corresponding to the notebook. \n",
- "\n",
- "## Getting started\n",
- "\n",
- "### Installation prerequisites\n",
- "| | Description | Command |\n",
- "|:----|:----------------------------------|:--------------------------|\n",
- "| 1. | Enter Package Manager via | ] |\n",
- "| 2. | Install FMI via | add FMI | \n",
- "| 3. | Install FMIZoo via | add FMIZoo | \n",
- "| 4. | Install Optim via | add Optim | \n",
- "| 5. | Install Plots via | add Plots | "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Code section\n",
- "\n",
- "To run the example, the previously installed packages must be included. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 20,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:26:47.908000Z",
- "iopub.status.busy": "2022-10-22T13:26:47.907000Z",
- "iopub.status.idle": "2022-10-22T13:27:21.215000Z",
- "shell.execute_reply": "2022-10-22T13:27:21.215000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "# imports\n",
- "using FMI\n",
- "using FMIZoo\n",
- "using Optim\n",
- "using Plots\n",
- "using DifferentialEquations"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Simulation setup\n",
- "\n",
- "Next, the start time and end time of the simulation are set."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:21.476000Z",
- "iopub.status.busy": "2022-10-22T13:27:21.219000Z",
- "iopub.status.idle": "2022-10-22T13:27:25.399000Z",
- "shell.execute_reply": "2022-10-22T13:27:25.398000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "tStart = 0.0\n",
- "tStop = 5.0\n",
- "tStep = 0.1\n",
- "tSave = tStart:tStep:tStop"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Import FMU\n",
- "\n",
- "In the next lines of code the FMU model from *FMIZoo.jl* is loaded and the information about the FMU is shown."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:25.403000Z",
- "iopub.status.busy": "2022-10-22T13:27:25.403000Z",
- "iopub.status.idle": "2022-10-22T13:27:30.244000Z",
- "shell.execute_reply": "2022-10-22T13:27:30.244000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "# we use an FMU from the FMIZoo.jl\n",
- "fmu = loadFMU(\"SpringPendulum1D\", \"Dymola\", \"2022x\"; type=:ME)\n",
- "info(fmu)"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Now, the optimization objective (the function to minimize) needs to be defined. In this case, we just want to do a simulation and compare it to a regular `sin` wave."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:31.661000Z",
- "iopub.status.busy": "2022-10-22T13:27:31.660000Z",
- "iopub.status.idle": "2022-10-22T13:27:33.084000Z",
- "shell.execute_reply": "2022-10-22T13:27:33.084000Z"
- }
- },
- "outputs": [],
- "source": [
- "s_tar = 1.0 .+ sin.(tSave)\n",
- "\n",
- "# a function to simulate the FMU for given parameters\n",
- "function simulateFMU(p)\n",
- " s0, v0, c, m = p # unpack parameters: s0 (start position), v0 (start velocity), c (spring constant) and m (pendulum mass)\n",
- "\n",
- " # pack the parameters into a dictionary\n",
- " paramDict = Dict{String, Any}()\n",
- " paramDict[\"spring.c\"] = c \n",
- " paramDict[\"mass.m\"] = m\n",
- "\n",
- " # pack the start state\n",
- " x0 = [s0, v0]\n",
- "\n",
- " # simulate with given start stae and parameters\n",
- " sol = simulate(fmu, (tStart, tStop); x0=x0, parameters=paramDict, saveat=tSave)\n",
- "\n",
- " # get state with index 1 (the position) from the solution\n",
- " s_res = getState(sol, 1; isIndex=true) \n",
- "\n",
- " return s_res\n",
- "end\n",
- "\n",
- "# the optimization objective\n",
- "function objective(p)\n",
- " s_res = simulateFMU(p)\n",
- "\n",
- " # return the position error sum between FMU simulation (s_res) and target (s_tar)\n",
- " return sum(abs.(s_tar .- s_res)) \n",
- "end"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Now let's see how far we are away for our guess parameters:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:33.088000Z",
- "iopub.status.busy": "2022-10-22T13:27:33.088000Z",
- "iopub.status.idle": "2022-10-22T13:27:33.164000Z",
- "shell.execute_reply": "2022-10-22T13:27:33.164000Z"
- },
- "scrolled": true
- },
- "outputs": [],
- "source": [
- "s0 = 0.0 \n",
- "v0 = 0.0\n",
- "c = 1.0\n",
- "m = 1.0 \n",
- "p = [s0, v0, c, m]\n",
- "\n",
- "obj_before = objective(p) # not really good!"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Let's have a look on the differences:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:33.168000Z",
- "iopub.status.busy": "2022-10-22T13:27:33.168000Z",
- "iopub.status.idle": "2022-10-22T13:27:36.378000Z",
- "shell.execute_reply": "2022-10-22T13:27:36.378000Z"
- }
- },
- "outputs": [],
- "source": [
- "s_fmu = simulateFMU(p); # simulate the position\n",
- "\n",
- "plot(tSave, s_fmu; label=\"FMU\")\n",
- "plot!(tSave, s_tar; label=\"Optimization target\")"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Not that good. So let's do a bit of optimization!"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:36.383000Z",
- "iopub.status.busy": "2022-10-22T13:27:36.382000Z",
- "iopub.status.idle": "2022-10-22T13:27:36.453000Z",
- "shell.execute_reply": "2022-10-22T13:27:36.453000Z"
- }
- },
- "outputs": [],
- "source": [
- "opt = Optim.optimize(objective, p; iterations=250) # do max. 250 iterations\n",
- "obj_after = opt.minimum # much better!\n",
- "p_res = opt.minimizer # the optimized parameters"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Looks promising, let's have a look on the results plot:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "s_fmu = simulateFMU(p_res); # simulate the position\n",
- "\n",
- "plot(tSave, s_fmu; label=\"FMU\")\n",
- "plot!(tSave, s_tar; label=\"Optimization target\")"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Actually a pretty fit! If you have higher requirements, check out the *Optim.jl* library."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 28,
- "metadata": {},
- "outputs": [],
- "source": [
- "unloadFMU(fmu)"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Summary\n",
- "\n",
- "This tutorial showed how a parameter (and start value) optimization can be performed on a FMU with a gradient free optimizer. This tutorial will be extended soon to further show how convergence for large parameter spaces can be improoved!"
- ]
- }
- ],
- "metadata": {
- "interpreter": {
- "hash": "037537ff7419c497b9325f7d495147943224d408cf5d5ed915294a5b960167b0"
- },
- "jupytext": {
- "cell_metadata_filter": "-all",
- "comment_magics": "false",
- "notebook_metadata_filter": "-all"
- },
- "kernelspec": {
- "display_name": "Julia 1.10.5",
- "language": "julia",
- "name": "julia-1.10"
- },
- "language_info": {
- "file_extension": ".jl",
- "mimetype": "application/julia",
- "name": "julia",
- "version": "1.10.5"
- },
- "nteract": {
- "version": "0.28.0"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/examples/src/parameter_optimization.jl b/examples/src/parameter_optimization.jl
deleted file mode 100644
index 59bbaddc..00000000
--- a/examples/src/parameter_optimization.jl
+++ /dev/null
@@ -1,71 +0,0 @@
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-
-# imports
-using FMI
-using FMIZoo
-using Optim
-using Plots
-
-tStart = 0.0
-tStop = 5.0
-tStep = 0.1
-tSave = tStart:tStep:tStop
-
-# we use an FMU from the FMIZoo.jl
-fmu = loadFMU("SpringPendulum1D", "Dymola", "2022x"; type=:ME)
-info(fmu)
-
-s_tar = 1.0 .+ sin.(tSave)
-
-# a function to simulate the FMU for given parameters
-function simulateFMU(p)
- s0, v0, c, m = p # unpack parameters: s0 (start position), v0 (start velocity), c (spring constant) and m (pendulum mass)
-
- # pack the parameters into a dictionary
- paramDict = Dict{String, Any}()
- paramDict["spring.c"] = c
- paramDict["mass.m"] = m
-
- # pack the start state
- x0 = [s0, v0]
-
- # simulate with given start stae and parameters
- sol = simulate(fmu, (tStart, tStop); x0=x0, parameters=paramDict, saveat=tSave)
-
- # get state with index 1 (the position) from the solution
- s_res = getState(sol, 1; isIndex=true)
-
- return s_res
-end
-
-# the optimization objective
-function objective(p)
- s_res = simulateFMU(p)
-
- # return the position error sum between FMU simulation (s_res) and target (s_tar)
- return sum(abs.(s_tar .- s_res))
-end
-
-s0 = 0.0
-v0 = 0.0
-c = 1.0
-m = 1.0
-p = [s0, v0, c, m]
-
-obj_before = objective(p) # not really good!
-
-s_fmu = simulateFMU(p); # simulate the position
-
-plot(tSave, s_fmu; label="FMU")
-plot!(tSave, s_tar; label="Optimization target")
-
-opt = Optim.optimize(objective, p; iterations=250) # do max. 250 iterations
-obj_after = opt.minimum # much better!
-p_res = opt.minimizer # the optimized parameters
-
-s_fmu = simulateFMU(p_res); # simulate the position
-
-plot(tSave, s_fmu; label="FMU")
-plot!(tSave, s_tar; label="Optimization target")
diff --git a/examples/src/parameter_optimization.md b/examples/src/parameter_optimization.md
deleted file mode 100644
index c346b700..00000000
--- a/examples/src/parameter_optimization.md
+++ /dev/null
@@ -1,150 +0,0 @@
-# FMU Parameter Optimization
-Tutorial by Tobias Thummerer
-
-## License
-
-
-```julia
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-```
-
-## Introduction to the example
-This example shows how a parameter optimization can be set up for a FMU. The goal is to fit FMU parameters (and initial states), so that a reference trajectory is fit as good as possible.
-
-Note, that this tutorial covers optimization *without* gradient information. Basically, *FMI.jl* supports gradient based optimization, too.
-
-## Other formats
-Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/parameter_optimization.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/parameter_optimization.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/parameter_optimization.md) corresponding to the notebook.
-
-## Getting started
-
-### Installation prerequisites
-| | Description | Command |
-|:----|:----------------------------------|:--------------------------|
-| 1. | Enter Package Manager via | ] |
-| 2. | Install FMI via | add FMI |
-| 3. | Install FMIZoo via | add FMIZoo |
-| 4. | Install Optim via | add Optim |
-| 5. | Install Plots via | add Plots |
-
-## Code section
-
-To run the example, the previously installed packages must be included.
-
-
-```julia
-# imports
-using FMI
-using FMIZoo
-using Optim
-using Plots
-```
-
-### Simulation setup
-
-Next, the start time and end time of the simulation are set.
-
-
-```julia
-tStart = 0.0
-tStop = 5.0
-tStep = 0.1
-tSave = tStart:tStep:tStop
-```
-
-### Import FMU
-
-In the next lines of code the FMU model from *FMIZoo.jl* is loaded and the information about the FMU is shown.
-
-
-```julia
-# we use an FMU from the FMIZoo.jl
-fmu = loadFMU("SpringPendulum1D", "Dymola", "2022x"; type=:ME)
-info(fmu)
-```
-
-Now, the optimization objective (the function to minimize) needs to be defined. In this case, we just want to do a simulation and compare it to a regular `sin` wave.
-
-
-```julia
-s_tar = 1.0 .+ sin.(tSave)
-
-# a function to simulate the FMU for given parameters
-function simulateFMU(p)
- s0, v0, c, m = p # unpack parameters: s0 (start position), v0 (start velocity), c (spring constant) and m (pendulum mass)
-
- # pack the parameters into a dictionary
- paramDict = Dict{String, Any}()
- paramDict["spring.c"] = c
- paramDict["mass.m"] = m
-
- # pack the start state
- x0 = [s0, v0]
-
- # simulate with given start stae and parameters
- sol = simulate(fmu, (tStart, tStop); x0=x0, parameters=paramDict, saveat=tSave)
-
- # get state with index 1 (the position) from the solution
- s_res = getState(sol, 1; isIndex=true)
-
- return s_res
-end
-
-# the optimization objective
-function objective(p)
- s_res = simulateFMU(p)
-
- # return the position error sum between FMU simulation (s_res) and target (s_tar)
- return sum(abs.(s_tar .- s_res))
-end
-```
-
-Now let's see how far we are away for our guess parameters:
-
-
-```julia
-s0 = 0.0
-v0 = 0.0
-c = 1.0
-m = 1.0
-p = [s0, v0, c, m]
-
-obj_before = objective(p) # not really good!
-```
-
-Let's have a look on the differences:
-
-
-```julia
-s_fmu = simulateFMU(p); # simulate the position
-
-plot(tSave, s_fmu; label="FMU")
-plot!(tSave, s_tar; label="Optimization target")
-```
-
-Not that good. So let's do a bit of optimization!
-
-
-```julia
-opt = Optim.optimize(objective, p; iterations=250) # do max. 250 iterations
-obj_after = opt.minimum # much better!
-p_res = opt.minimizer # the optimized parameters
-```
-
-Looks promising, let's have a look on the results plot:
-
-
-```julia
-s_fmu = simulateFMU(p_res); # simulate the position
-
-plot(tSave, s_fmu; label="FMU")
-plot!(tSave, s_tar; label="Optimization target")
-```
-
-Actually a pretty fit! If you have higher requirements, check out the *Optim.jl* library.
-
-### Summary
-
-This tutorial showed how a parameter (and start value) optimization can be performed on a FMU with a gradient free optimizer. This tutorial will be extended soon to further show how convergence for large parameter spaces can be improoved!
diff --git a/examples/src/parameter_optimization_files/parameter_optimization_14_0.png b/examples/src/parameter_optimization_files/parameter_optimization_14_0.png
deleted file mode 100644
index e374aab0..00000000
Binary files a/examples/src/parameter_optimization_files/parameter_optimization_14_0.png and /dev/null differ
diff --git a/examples/src/parameter_optimization_files/parameter_optimization_14_0.svg b/examples/src/parameter_optimization_files/parameter_optimization_14_0.svg
deleted file mode 100644
index 456ea9a7..00000000
--- a/examples/src/parameter_optimization_files/parameter_optimization_14_0.svg
+++ /dev/null
@@ -1,50 +0,0 @@
-
-
diff --git a/examples/src/parameter_optimization_files/parameter_optimization_18_0.png b/examples/src/parameter_optimization_files/parameter_optimization_18_0.png
deleted file mode 100644
index f29a7542..00000000
Binary files a/examples/src/parameter_optimization_files/parameter_optimization_18_0.png and /dev/null differ
diff --git a/examples/src/parameter_optimization_files/parameter_optimization_18_0.svg b/examples/src/parameter_optimization_files/parameter_optimization_18_0.svg
deleted file mode 100644
index b9804ab2..00000000
--- a/examples/src/parameter_optimization_files/parameter_optimization_18_0.svg
+++ /dev/null
@@ -1,50 +0,0 @@
-
-
diff --git a/examples/src/parameterize.ipynb b/examples/src/parameterize.ipynb
deleted file mode 100644
index 80b7a458..00000000
--- a/examples/src/parameterize.ipynb
+++ /dev/null
@@ -1,647 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Parameterize a FMU\n",
- "Tutorial by Tobias Thummerer, Johannes Stoljar\n",
- "\n",
- "Last update: 09.08.2023\n",
- "\n",
- "🚧 This tutorial is under revision and will be replaced by an up-to-date version soon 🚧\n",
- "\n",
- "## License"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 47,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:26:47.623000Z",
- "iopub.status.busy": "2022-10-22T13:26:46.768000Z",
- "iopub.status.idle": "2022-10-22T13:26:47.904000Z",
- "shell.execute_reply": "2022-10-22T13:26:47.830000Z"
- }
- },
- "outputs": [],
- "source": [
- "# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar\n",
- "# Licensed under the MIT license. \n",
- "# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Introduction\n",
- "This example shows how to parameterize a FMU. We will show to possible ways to parameterize: The default option using the parameterization feature of `fmiSimulate`, `fmiSimulateME` or `fmiSimulateCS`. Second, a custom parameterization routine for advanced users. \n",
- "\n",
- "## Other formats\n",
- "Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/parameterize.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/parameterize.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/parameterize.md) corresponding to the notebook. "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Code section\n",
- "\n",
- "To run the example, the previously installed packages must be included. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 48,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:26:47.908000Z",
- "iopub.status.busy": "2022-10-22T13:26:47.907000Z",
- "iopub.status.idle": "2022-10-22T13:27:21.215000Z",
- "shell.execute_reply": "2022-10-22T13:27:21.215000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "# imports\n",
- "using FMI\n",
- "using FMIZoo"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Simulation setup\n",
- "\n",
- "Next, the start time and end time of the simulation are set."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:21.476000Z",
- "iopub.status.busy": "2022-10-22T13:27:21.219000Z",
- "iopub.status.idle": "2022-10-22T13:27:25.399000Z",
- "shell.execute_reply": "2022-10-22T13:27:25.398000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "tStart = 0.0\n",
- "tStop = 1.0\n",
- "tSave = collect(tStart:tStop)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Import FMU\n",
- "\n",
- "In the next lines of code the FMU model from *FMIZoo.jl* is loaded and the information about the FMU is shown."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:25.403000Z",
- "iopub.status.busy": "2022-10-22T13:27:25.403000Z",
- "iopub.status.idle": "2022-10-22T13:27:30.244000Z",
- "shell.execute_reply": "2022-10-22T13:27:30.244000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "# we use an FMU from the FMIZoo.jl\n",
- "# just replace this line with a local path if you want to use your own FMU\n",
- "pathToFMU = get_model_filename(\"IO\", \"Dymola\", \"2022x\")\n",
- "\n",
- "fmu = loadFMU(pathToFMU)\n",
- "info(fmu)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Option A: Integrated parameterization feature of *FMI.jl*\n",
- "If you are using the commands for simulation integrated in *FMI.jl*, the parameters and initial conditions are set at the correct locations during the initialization process of your FMU. This is the recommended way of parameterizing your model, if you don't have very uncommon requirements regarding initialization."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "dict = Dict{String, Any}()\n",
- "dict"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Option B: Custom parameterization routine\n",
- "If you have special requirements for initialization and parameterization, you can write your very own parameterization routine.\n",
- "\n",
- "### Instantiate and Setup FMU\n",
- "\n",
- "Next it is necessary to create an instance of the FMU. This is achieved by the command `fmiInstantiate!()`."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:30.247000Z",
- "iopub.status.busy": "2022-10-22T13:27:30.247000Z",
- "iopub.status.idle": "2022-10-22T13:27:31.208000Z",
- "shell.execute_reply": "2022-10-22T13:27:31.208000Z"
- }
- },
- "outputs": [],
- "source": [
- "c = fmi2Instantiate!(fmu; loggingOn=true)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "In the following code block, start and end time for the simulation is set by the `fmiSetupExperiment()` command."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:31.212000Z",
- "iopub.status.busy": "2022-10-22T13:27:31.212000Z",
- "iopub.status.idle": "2022-10-22T13:27:31.657000Z",
- "shell.execute_reply": "2022-10-22T13:27:31.656000Z"
- }
- },
- "outputs": [],
- "source": [
- "fmi2SetupExperiment(c, tStart, tStop)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Parameterize FMU\n",
- "\n",
- "In this example, for each data type (`real`, `boolean`, `integer` and `string`) a corresponding input or parameter is selected. From here on, the inputs and parameters will be referred to as parameters for simplicity."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:31.661000Z",
- "iopub.status.busy": "2022-10-22T13:27:31.660000Z",
- "iopub.status.idle": "2022-10-22T13:27:33.084000Z",
- "shell.execute_reply": "2022-10-22T13:27:33.084000Z"
- }
- },
- "outputs": [],
- "source": [
- "params = [\"p_real\", \"p_boolean\", \"p_integer\", \"p_string\"]"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "At the beginning we want to display the initial state of these parameters, for which the FMU must be in initialization mode. The next function `fmiEnterInitializationMode()` informs the FMU to enter the initialization mode. Before calling this function, the variables can be set. Furthermore, `fmiSetupExperiment()` must be called at least once before calling `fmiEnterInitializationMode()`, in order that the start time is defined."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:33.088000Z",
- "iopub.status.busy": "2022-10-22T13:27:33.088000Z",
- "iopub.status.idle": "2022-10-22T13:27:33.164000Z",
- "shell.execute_reply": "2022-10-22T13:27:33.164000Z"
- },
- "scrolled": true
- },
- "outputs": [],
- "source": [
- "fmi2EnterInitializationMode(c)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "The initial state of these parameters are displayed with the function `getValue()`."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:33.168000Z",
- "iopub.status.busy": "2022-10-22T13:27:33.168000Z",
- "iopub.status.idle": "2022-10-22T13:27:36.378000Z",
- "shell.execute_reply": "2022-10-22T13:27:36.378000Z"
- }
- },
- "outputs": [],
- "source": [
- "getValue(c, params)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "The initialization mode is terminated with the function `fmi2ExitInitializationMode()`. (For the model exchange FMU type, this function switches off all initialization equations, and enters the event mode implicitly.)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:36.383000Z",
- "iopub.status.busy": "2022-10-22T13:27:36.382000Z",
- "iopub.status.idle": "2022-10-22T13:27:36.453000Z",
- "shell.execute_reply": "2022-10-22T13:27:36.453000Z"
- }
- },
- "outputs": [],
- "source": [
- "fmi2ExitInitializationMode(c)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "In the next step, a function is defined that generates a random value for each parameter. For the parameter `p_string` a random number is inserted into the string. All parameters are combined to a tuple and output."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:36.457000Z",
- "iopub.status.busy": "2022-10-22T13:27:36.457000Z",
- "iopub.status.idle": "2022-10-22T13:27:37.435000Z",
- "shell.execute_reply": "2022-10-22T13:27:37.435000Z"
- }
- },
- "outputs": [],
- "source": [
- "function generateRandomNumbers()\n",
- " rndReal = 100 * rand()\n",
- " rndBoolean = rand() > 0.5\n",
- " rndInteger = round(Integer, 100 * rand())\n",
- " rndString = \"Random number $(100 * rand())!\"\n",
- "\n",
- " return rndReal, rndBoolean, rndInteger, rndString\n",
- "end"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "The previously defined function is called and the results are displayed in the console."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:37.439000Z",
- "iopub.status.busy": "2022-10-22T13:27:37.439000Z",
- "iopub.status.idle": "2022-10-22T13:27:38.222000Z",
- "shell.execute_reply": "2022-10-22T13:27:38.222000Z"
- }
- },
- "outputs": [],
- "source": [
- "paramsVal = generateRandomNumbers()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### First variant\n",
- "\n",
- "To show the first variant, it is necessary to terminate and reset the FMU instance. Then, as before, the setup command must be called for the FMU. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:38.225000Z",
- "iopub.status.busy": "2022-10-22T13:27:38.225000Z",
- "iopub.status.idle": "2022-10-22T13:27:38.411000Z",
- "shell.execute_reply": "2022-10-22T13:27:38.411000Z"
- }
- },
- "outputs": [],
- "source": [
- "fmi2Terminate(c)\n",
- "fmi2Reset(c)\n",
- "fmi2SetupExperiment(c, tStart, tStop)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "In the next step it is possible to set the parameters for the FMU. With the first variant it is quickly possible to set all parameters at once. Even different data types can be set with only one command. The command `setValue()` selects itself which function is chosen for which data type. As long as the output of the function gives the status code 0, setting the parameters has worked."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:38.415000Z",
- "iopub.status.busy": "2022-10-22T13:27:38.415000Z",
- "iopub.status.idle": "2022-10-22T13:27:40.852000Z",
- "shell.execute_reply": "2022-10-22T13:27:40.852000Z"
- }
- },
- "outputs": [],
- "source": [
- "setValue(c, params, collect(paramsVal))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "After setting the parameters, it can be checked whether the corresponding parameters were set correctly. For this the function `getValue()` can be used as above. To be able to call the function `getValue()` the FMU must be in initialization mode."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:40.856000Z",
- "iopub.status.busy": "2022-10-22T13:27:40.856000Z",
- "iopub.status.idle": "2022-10-22T13:27:40.857000Z",
- "shell.execute_reply": "2022-10-22T13:27:40.857000Z"
- }
- },
- "outputs": [],
- "source": [
- "fmi2EnterInitializationMode(c)\n",
- "# getValue(c, params)\n",
- "fmi2ExitInitializationMode(c)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Now the FMU has been initialized correctly, the FMU can be simulated. The `simulate()` command is used for this purpose. It must be pointed out that the keywords `instantiate=false`, `setup=false` must be set. The keyword `instantiate=false` prevents the simulation command from creating a new FMU instance, otherwise our parameterization will be lost. The keyword `setup=false` prevents the FMU from calling the initialization mode again. The additionally listed keyword `freeInstance=false` prevents that the instance is removed after the simulation. This is only needed in this example, because we want to continue working on the created instance. Another keyword is the `recordValues=parmas[1:3]`, which saves: `p_real`, `p_boolean` and `p_integer` as output. It should be noted that the `simulate()` function is not capable of outputting string values, so `p_string` is omitted."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:40.861000Z",
- "iopub.status.busy": "2022-10-22T13:27:40.861000Z",
- "iopub.status.idle": "2022-10-22T13:27:51.266000Z",
- "shell.execute_reply": "2022-10-22T13:27:51.265000Z"
- }
- },
- "outputs": [],
- "source": [
- "simData = simulate(c, (tStart, tStop); recordValues=params[1:3], saveat=tSave, \n",
- " instantiate=false, setup=false, freeInstance=false, terminate=false, reset=false)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### Second variant\n",
- "\n",
- "To show the second variant, it is necessary to terminate and reset the FMU instance. Then, as before, the setup command must be called for the FMU. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:51.270000Z",
- "iopub.status.busy": "2022-10-22T13:27:51.269000Z",
- "iopub.status.idle": "2022-10-22T13:27:51.271000Z",
- "shell.execute_reply": "2022-10-22T13:27:51.271000Z"
- }
- },
- "outputs": [],
- "source": [
- "fmi2Terminate(c)\n",
- "fmi2Reset(c)\n",
- "fmi2SetupExperiment(c, tStart, tStop)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "To make sure that the functions work it is necessary to generate random numbers again. As shown already, we call the defined function `generateRandomNumbers()` and output the values."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:51.275000Z",
- "iopub.status.busy": "2022-10-22T13:27:51.275000Z",
- "iopub.status.idle": "2022-10-22T13:27:51.288000Z",
- "shell.execute_reply": "2022-10-22T13:27:51.288000Z"
- }
- },
- "outputs": [],
- "source": [
- "rndReal, rndBoolean, rndInteger, rndString = generateRandomNumbers()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "In the second variant, the value for each data type is set separately by the corresponding command. By this variant one has the maximum control and can be sure that also the correct data type is set. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:51.291000Z",
- "iopub.status.busy": "2022-10-22T13:27:51.291000Z",
- "iopub.status.idle": "2022-10-22T13:27:51.615000Z",
- "shell.execute_reply": "2022-10-22T13:27:51.615000Z"
- }
- },
- "outputs": [],
- "source": [
- "fmi2SetReal(c, \"p_real\", rndReal)\n",
- "fmi2SetBoolean(c, \"p_boolean\", rndBoolean)\n",
- "fmi2SetInteger(c, \"p_integer\", rndInteger)\n",
- "fmi2SetString(c, \"p_string\", rndString)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "To illustrate the functionality of the parameterization with the separate functions, the corresponding get function can be also called separately for each data type:\n",
- "* `fmi2SetReal()` ⇔ `fmi2GetReal()`\n",
- "* `fmi2SetBoolean()` ⇔ `fmi2GetBoolean()`\n",
- "* `fmi2SetInteger()` ⇔ `fmi2GetInteger()`\n",
- "* `fmi2SetString()` ⇔ `fmi2GetString()`.\n",
- "\n",
- "As before, the FMU must be in initialization mode."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:51.619000Z",
- "iopub.status.busy": "2022-10-22T13:27:51.619000Z",
- "iopub.status.idle": "2022-10-22T13:27:51.620000Z",
- "shell.execute_reply": "2022-10-22T13:27:51.620000Z"
- }
- },
- "outputs": [],
- "source": [
- "fmi2EnterInitializationMode(c)\n",
- "# fmi2GetReal(c, \"u_real\")\n",
- "# fmi2GetBoolean(c, \"u_boolean\")\n",
- "# fmi2GetInteger(c, \"u_integer\")\n",
- "# fmi2GetString(c, \"p_string\")\n",
- "fmi2ExitInitializationMode(c)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "From here on, you may want to simulate the FMU. Please note, that with the default `executionConfig`, it is necessary to prevent a new instantiation using the keyword `instantiate=false`. Otherwise, a new instance is allocated for the simulation-call and the parameters set for the previous instance are not transfered."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:51.624000Z",
- "iopub.status.busy": "2022-10-22T13:27:51.624000Z",
- "iopub.status.idle": "2022-10-22T13:27:52.288000Z",
- "shell.execute_reply": "2022-10-22T13:27:52.288000Z"
- }
- },
- "outputs": [],
- "source": [
- "simData = simulate(c, (tStart, tStop); recordValues=params[1:3], saveat=tSave, \n",
- " instantiate=false, setup=false)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Unload FMU\n",
- "\n",
- "The FMU will be unloaded and all unpacked data on disc will be removed."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 69,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:27:52.293000Z",
- "iopub.status.busy": "2022-10-22T13:27:52.292000Z",
- "iopub.status.idle": "2022-10-22T13:27:52.330000Z",
- "shell.execute_reply": "2022-10-22T13:27:52.329000Z"
- }
- },
- "outputs": [],
- "source": [
- "unloadFMU(fmu)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Summary\n",
- "\n",
- "Based on this tutorial it can be seen that there are two different variants to set and get parameters.These examples should make it clear to the user how parameters can also be set with different data types. As a small reminder, the sequence of commands for the manual parameterization of an FMU is summarized again. \n",
- "\n",
- "`loadFMU()` → `fmiInstantiate!()` → `fmiSetupExperiment()` → `fmiSetXXX()` → `fmiEnterInitializationMode()` → `fmiGetXXX()` → `fmiExitInitializationMode()` → `simualte()` → `unloadFMU()`"
- ]
- }
- ],
- "metadata": {
- "interpreter": {
- "hash": "037537ff7419c497b9325f7d495147943224d408cf5d5ed915294a5b960167b0"
- },
- "jupytext": {
- "cell_metadata_filter": "-all",
- "comment_magics": "false",
- "notebook_metadata_filter": "-all"
- },
- "kernelspec": {
- "display_name": "Julia 1.10.5",
- "language": "julia",
- "name": "julia-1.10"
- },
- "language_info": {
- "file_extension": ".jl",
- "mimetype": "application/julia",
- "name": "julia",
- "version": "1.10.5"
- },
- "nteract": {
- "version": "0.28.0"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/examples/src/parameterize.jl b/examples/src/parameterize.jl
deleted file mode 100644
index 845349de..00000000
--- a/examples/src/parameterize.jl
+++ /dev/null
@@ -1,80 +0,0 @@
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-
-# imports
-using FMI
-using FMIZoo
-
-tStart = 0.0
-tStop = 1.0
-tSave = collect(tStart:tStop)
-
-# we use an FMU from the FMIZoo.jl
-# just replace this line with a local path if you want to use your own FMU
-pathToFMU = get_model_filename("IO", "Dymola", "2022x")
-
-fmu = fmiLoad(pathToFMU)
-fmiInfo(fmu)
-
-dict = Dict{String, Any}()
-dict
-
-fmiInstantiate!(fmu; loggingOn=true)
-
-fmiSetupExperiment(fmu, tStart, tStop)
-
-params = ["p_real", "p_boolean", "p_integer", "p_string"]
-
-fmiEnterInitializationMode(fmu)
-
-fmiGet(fmu, params)
-
-fmiExitInitializationMode(fmu)
-
-function generateRandomNumbers()
- rndReal = 100 * rand()
- rndBoolean = rand() > 0.5
- rndInteger = round(Integer, 100 * rand())
- rndString = "Random number $(100 * rand())!"
-
- return rndReal, rndBoolean, rndInteger, rndString
-end
-
-paramsVal = generateRandomNumbers()
-
-fmiTerminate(fmu)
-fmiReset(fmu)
-fmiSetupExperiment(fmu, tStart, tStop)
-
-fmiSet(fmu, params, collect(paramsVal))
-
-fmiEnterInitializationMode(fmu)
-# fmiGet(fmu, params)
-fmiExitInitializationMode(fmu)
-
-simData = fmiSimulate(fmu, (tStart, tStop); recordValues=params[1:3], saveat=tSave,
- instantiate=false, setup=false, freeInstance=false, terminate=false, reset=false)
-
-fmiTerminate(fmu)
-fmiReset(fmu)
-fmiSetupExperiment(fmu, tStart, tStop)
-
-rndReal, rndBoolean, rndInteger, rndString = generateRandomNumbers()
-
-fmiSetReal(fmu, "p_real", rndReal)
-fmiSetBoolean(fmu, "p_boolean", rndBoolean)
-fmiSetInteger(fmu, "p_integer", rndInteger)
-fmiSetString(fmu, "p_string", rndString)
-
-fmiEnterInitializationMode(fmu)
-# fmiGetReal(fmu, "u_real")
-# fmiGetBoolean(fmu, "u_boolean")
-# fmiGetInteger(fmu, "u_integer")
-# fmiGetString(fmu, "p_string")
-fmiExitInitializationMode(fmu)
-
-simData = fmiSimulate(fmu, (tStart, tStop); recordValues=params[1:3], saveat=tSave,
- instantiate=false, setup=false)
-
-fmiUnload(fmu)
diff --git a/examples/src/parameterize.md b/examples/src/parameterize.md
deleted file mode 100644
index 46a02a88..00000000
--- a/examples/src/parameterize.md
+++ /dev/null
@@ -1,240 +0,0 @@
-# Parameterize a FMU
-Tutorial by Tobias Thummerer, Johannes Stoljar
-
-Last update: 09.08.2023
-
-🚧 This tutorial is under revision and will be replaced by an up-to-date version soon 🚧
-
-## License
-
-
-```julia
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-```
-
-## Introduction
-This example shows how to parameterize a FMU. We will show to possible ways to parameterize: The default option using the parameterization feature of `fmiSimulate`, `fmiSimulateME` or `fmiSimulateCS`. Second, a custom parameterization routine for advanced users.
-
-## Other formats
-Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/parameterize.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/parameterize.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/parameterize.md) corresponding to the notebook.
-
-## Code section
-
-To run the example, the previously installed packages must be included.
-
-
-```julia
-# imports
-using FMI
-using FMIZoo
-```
-
-### Simulation setup
-
-Next, the start time and end time of the simulation are set.
-
-
-```julia
-tStart = 0.0
-tStop = 1.0
-tSave = collect(tStart:tStop)
-```
-
-### Import FMU
-
-In the next lines of code the FMU model from *FMIZoo.jl* is loaded and the information about the FMU is shown.
-
-
-```julia
-# we use an FMU from the FMIZoo.jl
-# just replace this line with a local path if you want to use your own FMU
-pathToFMU = get_model_filename("IO", "Dymola", "2022x")
-
-fmu = fmiLoad(pathToFMU)
-fmiInfo(fmu)
-```
-
-### Option A: Integrated parameterization feature of *FMI.jl*
-If you are using the commands for simulation integrated in *FMI.jl*, the parameters and initial conditions are set at the correct locations during the initialization process of your FMU. This is the recommended way of parameterizing your model, if you don't have very uncommon requirements regarding initialization.
-
-
-```julia
-dict = Dict{String, Any}()
-dict
-```
-
-### Option B: Custom parameterization routine
-If you have special requirements for initialization and parameterization, you can write your very own parameterization routine.
-
-### Instantiate and Setup FMU
-
-Next it is necessary to create an instance of the FMU. This is achieved by the command `fmiInstantiate!()`.
-
-
-```julia
-fmiInstantiate!(fmu; loggingOn=true)
-```
-
-In the following code block, start and end time for the simulation is set by the `fmiSetupExperiment()` command.
-
-
-```julia
-fmiSetupExperiment(fmu, tStart, tStop)
-```
-
-### Parameterize FMU
-
-In this example, for each data type (`real`, `boolean`, `integer` and `string`) a corresponding input or parameter is selected. From here on, the inputs and parameters will be referred to as parameters for simplicity.
-
-
-```julia
-params = ["p_real", "p_boolean", "p_integer", "p_string"]
-```
-
-At the beginning we want to display the initial state of these parameters, for which the FMU must be in initialization mode. The next function `fmiEnterInitializationMode()` informs the FMU to enter the initialization mode. Before calling this function, the variables can be set. Furthermore, `fmiSetupExperiment()` must be called at least once before calling `fmiEnterInitializationMode()`, in order that the start time is defined.
-
-
-```julia
-fmiEnterInitializationMode(fmu)
-```
-
-The initial state of these parameters are displayed with the function `fmiGet()`.
-
-
-```julia
-fmiGet(fmu, params)
-```
-
-The initialization mode is terminated with the function `fmiExitInitializationMode()`. (For the model exchange FMU type, this function switches off all initialization equations, and enters the event mode implicitly.)
-
-
-```julia
-fmiExitInitializationMode(fmu)
-```
-
-In the next step, a function is defined that generates a random value for each parameter. For the parameter `p_string` a random number is inserted into the string. All parameters are combined to a tuple and output.
-
-
-```julia
-function generateRandomNumbers()
- rndReal = 100 * rand()
- rndBoolean = rand() > 0.5
- rndInteger = round(Integer, 100 * rand())
- rndString = "Random number $(100 * rand())!"
-
- return rndReal, rndBoolean, rndInteger, rndString
-end
-```
-
-The previously defined function is called and the results are displayed in the console.
-
-
-```julia
-paramsVal = generateRandomNumbers()
-```
-
-#### First variant
-
-To show the first variant, it is necessary to terminate and reset the FMU instance. Then, as before, the setup command must be called for the FMU.
-
-
-```julia
-fmiTerminate(fmu)
-fmiReset(fmu)
-fmiSetupExperiment(fmu, tStart, tStop)
-```
-
-In the next step it is possible to set the parameters for the FMU. With the first variant it is quickly possible to set all parameters at once. Even different data types can be set with only one command. The command `fmiSet()` selects itself which function is chosen for which data type. As long as the output of the function gives the status code 0, setting the parameters has worked.
-
-
-```julia
-fmiSet(fmu, params, collect(paramsVal))
-```
-
-After setting the parameters, it can be checked whether the corresponding parameters were set correctly. For this the function `fmiGet()` can be used as above. To be able to call the function `fmiGet()` the FMU must be in initialization mode.
-
-
-```julia
-fmiEnterInitializationMode(fmu)
-# fmiGet(fmu, params)
-fmiExitInitializationMode(fmu)
-```
-
-Now the FMU has been initialized correctly, the FMU can be simulated. The `fmiSimulate()` command is used for this purpose. It must be pointed out that the keywords `instantiate=false`, `setup=false` must be set. The keyword `instantiate=false` prevents the simulation command from creating a new FMU instance, otherwise our parameterization will be lost. The keyword `setup=false` prevents the FMU from calling the initialization mode again. The additionally listed keyword `freeInstance=false` prevents that the instance is removed after the simulation. This is only needed in this example, because we want to continue working on the created instance. Another keyword is the `recordValues=parmas[1:3]`, which saves: `p_real`, `p_boolean` and `p_integer` as output. It should be noted that the `fmiSimulate()` function is not capable of outputting string values, so `p_string` is omitted.
-
-
-```julia
-simData = fmiSimulate(fmu, (tStart, tStop); recordValues=params[1:3], saveat=tSave,
- instantiate=false, setup=false, freeInstance=false, terminate=false, reset=false)
-```
-
-#### Second variant
-
-To show the second variant, it is necessary to terminate and reset the FMU instance. Then, as before, the setup command must be called for the FMU.
-
-
-```julia
-fmiTerminate(fmu)
-fmiReset(fmu)
-fmiSetupExperiment(fmu, tStart, tStop)
-```
-
-To make sure that the functions work it is necessary to generate random numbers again. As shown already, we call the defined function `generateRandomNumbers()` and output the values.
-
-
-```julia
-rndReal, rndBoolean, rndInteger, rndString = generateRandomNumbers()
-```
-
-In the second variant, the value for each data type is set separately by the corresponding command. By this variant one has the maximum control and can be sure that also the correct data type is set.
-
-
-```julia
-fmiSetReal(fmu, "p_real", rndReal)
-fmiSetBoolean(fmu, "p_boolean", rndBoolean)
-fmiSetInteger(fmu, "p_integer", rndInteger)
-fmiSetString(fmu, "p_string", rndString)
-```
-
-To illustrate the functionality of the parameterization with the separate functions, the corresponding get function can be also called separately for each data type:
-* `fmiSetReal()` ⇔ `fmiGetReal()`
-* `fmiSetBoolean()` ⇔ `fmiGetBoolean()`
-* `fmiSetInteger()` ⇔ `fmiGetInteger()`
-* `fmiSetString()` ⇔ `fmiGetString()`.
-
-As before, the FMU must be in initialization mode.
-
-
-```julia
-fmiEnterInitializationMode(fmu)
-# fmiGetReal(fmu, "u_real")
-# fmiGetBoolean(fmu, "u_boolean")
-# fmiGetInteger(fmu, "u_integer")
-# fmiGetString(fmu, "p_string")
-fmiExitInitializationMode(fmu)
-```
-
-From here on, you may want to simulate the FMU. Please note, that with the default `executionConfig`, it is necessary to prevent a new instantiation using the keyword `instantiate=false`. Otherwise, a new instance is allocated for the simulation-call and the parameters set for the previous instance are not transfered.
-
-
-```julia
-simData = fmiSimulate(fmu, (tStart, tStop); recordValues=params[1:3], saveat=tSave,
- instantiate=false, setup=false)
-```
-
-### Unload FMU
-
-The FMU will be unloaded and all unpacked data on disc will be removed.
-
-
-```julia
-fmiUnload(fmu)
-```
-
-### Summary
-
-Based on this tutorial it can be seen that there are two different variants to set and get parameters.These examples should make it clear to the user how parameters can also be set with different data types. As a small reminder, the sequence of commands for the manual parameterization of an FMU is summarized again.
-
-`fmiLoad()` → `fmiInstantiate!()` → `fmiSetupExperiment()` → `fmiSetXXX()` → `fmiEnterInitializationMode()` → `fmiGetXXX()` → `fmiExitInitializationMode()` → `fmiSimualte()` → `fmiUnload()`
diff --git a/examples/src/simulate.ipynb b/examples/src/simulate.ipynb
deleted file mode 100644
index 70442ab9..00000000
--- a/examples/src/simulate.ipynb
+++ /dev/null
@@ -1,323 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Simulate an FMU in different modes\n",
- "Tutorial by Johannes Stoljar, Tobias Thummerer\n",
- "\n",
- "🚧 This tutorial is under revision and will be replaced by an up-to-date version soon 🚧\n",
- "\n",
- "## License"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:28:04.723000Z",
- "iopub.status.busy": "2022-10-22T13:28:04.017000Z",
- "iopub.status.idle": "2022-10-22T13:28:04.999000Z",
- "shell.execute_reply": "2022-10-22T13:28:04.926000Z"
- }
- },
- "outputs": [],
- "source": [
- "# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar\n",
- "# Licensed under the MIT license. \n",
- "# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Motivation\n",
- "This Julia Package *FMI.jl* is motivated by the use of simulation models in Julia. Here the FMI specification is implemented. FMI (*Functional Mock-up Interface*) is a free standard ([fmi-standard.org](https://fmi-standard.org/)) that defines a container and an interface to exchange dynamic models using a combination of XML files, binaries and C code zipped into a single file. The user can thus use simulation models in the form of an FMU (*Functional Mock-up Units*). Besides loading the FMU, the user can also set values for parameters and states and simulate the FMU both as co-simulation and model exchange simulation.\n",
- "\n",
- "## Introduction to the example\n",
- "In this example we want to show how fast and easy the simulation for an FMU is. For this purpose, the FMU is simulated in co-simulation mode and in model-exchange mode. After the FMU has been simulated, the simulation results are displayed in a graph. The graphs of the different modes are compared with each other. The used model is a one-dimensional spring pendulum with friction. The object-orientated structure of the *SpringFrictionPendulum1D* can be seen in the following graphic.\n",
- "\n",
- " \n",
- "\n",
- "\n",
- "## Target group\n",
- "The example is primarily intended for users who work in the field of simulations. The example wants to show how simple it is to use FMUs in Julia.\n",
- "\n",
- "\n",
- "## Other formats\n",
- "Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/simulate.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/simulate.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/simulate.md) corresponding to the notebook. \n",
- "\n",
- "\n",
- "## Getting started\n",
- "\n",
- "### Installation prerequisites\n",
- "| | Description | Command | Alternative | \n",
- "|:----|:----------------------------------|:--------------------------|:-----------------------------------------------|\n",
- "| 1. | Enter Package Manager via | ] | |\n",
- "| 2. | Install FMI via | add FMI | add \" https://github.com/ThummeTo/FMI.jl \" |\n",
- "| 3. | Install FMIZoo via | add FMIZoo | add \" https://github.com/ThummeTo/FMIZoo.jl \" |\n",
- "| 4. | Install Plots via | add Plots | |"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Code section\n",
- "\n",
- "To run the example, the previously installed packages must be included. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:28:05.004000Z",
- "iopub.status.busy": "2022-10-22T13:28:05.004000Z",
- "iopub.status.idle": "2022-10-22T13:28:49.082000Z",
- "shell.execute_reply": "2022-10-22T13:28:49.082000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "# imports\n",
- "using FMI\n",
- "using FMIZoo\n",
- "using Plots\n",
- "using DifferentialEquations"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Simulation setup\n",
- "\n",
- "Next, the start time and end time of the simulation are set. Finally, a step size is specified to store the results of the simulation at these time steps."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:28:51.448000Z",
- "iopub.status.busy": "2022-10-22T13:28:49.085000Z",
- "iopub.status.idle": "2022-10-22T13:28:52.234000Z",
- "shell.execute_reply": "2022-10-22T13:28:52.233000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "tStart = 0.0\n",
- "tStep = 0.01\n",
- "tStop = 8.0\n",
- "tSave = tStart:tStep:tStop"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Import FMU\n",
- "\n",
- "In the next lines of code the FMU model from *FMIZoo.jl* is loaded and the information about the FMU is shown."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:28:52.238000Z",
- "iopub.status.busy": "2022-10-22T13:28:52.237000Z",
- "iopub.status.idle": "2022-10-22T13:28:57.034000Z",
- "shell.execute_reply": "2022-10-22T13:28:57.034000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "# we use an FMU from the FMIZoo.jl\n",
- "pathToFMU = get_model_filename(\"SpringFrictionPendulum1D\", \"Dymola\", \"2022x\")\n",
- "\n",
- "myFMU = loadFMU(pathToFMU)\n",
- "# loadFMU(\"path/to/myFMU.fmu\"; unpackPath = \"path/to/unpacked/fmu/\")\n",
- "\n",
- "info(myFMU)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Simulate FMU\n",
- "\n",
- "In the following, the FMU is simulated in the two different simulation modes.\n",
- "\n",
- "#### Simulate as Co-Simulation\n",
- "\n",
- "In the next steps the recorded values are defined. The first state is the position of the mass and the second state is the velocity. In the function `simulateCS()` the FMU is simulated in co-simulation mode (CS) with an adaptive step size but with fixed save points `tSave`. In addition, the start and end time and the recorded variables are specified."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:28:57.037000Z",
- "iopub.status.busy": "2022-10-22T13:28:57.037000Z",
- "iopub.status.idle": "2022-10-22T13:29:04.975000Z",
- "shell.execute_reply": "2022-10-22T13:29:04.974000Z"
- }
- },
- "outputs": [],
- "source": [
- "vrs = [\"mass.s\", \"mass.v\"]\n",
- "\n",
- "dataCS = simulateCS(myFMU, (tStart, tStop); recordValues=vrs, saveat=tSave)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### Simulate as Model-Exchange\n",
- "\n",
- "In the function `simulateME()` the FMU is simulated in model-exchange mode (ME) with an adaptive step size but with fixed save points `tSave`. In addition, the start and end time are specified. In contrast to the co-simulation, the values to be stored are not specified here, since the states and events of the FMU are always output as well. The identifiers given above just correspond to the states of the FMU."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:29:04.979000Z",
- "iopub.status.busy": "2022-10-22T13:29:04.978000Z",
- "iopub.status.idle": "2022-10-22T13:29:21.052000Z",
- "shell.execute_reply": "2022-10-22T13:29:21.052000Z"
- }
- },
- "outputs": [],
- "source": [
- "dataME = simulateME(myFMU, (tStart, tStop); saveat=tSave)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Plotting FMU\n",
- "\n",
- "After the simulation is finished the results of the FMU for the co-simulation and model-exchange mode can be plotted. In the plot for the FMU it can be seen that the oscillation continues to decrease due to the effect of the friction. If you simulate long enough, the oscillation comes to a standstill in a certain time."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:29:21.056000Z",
- "iopub.status.busy": "2022-10-22T13:29:21.056000Z",
- "iopub.status.idle": "2022-10-22T13:30:01.756000Z",
- "shell.execute_reply": "2022-10-22T13:30:01.756000Z"
- },
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "plot(dataCS)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:30:01.762000Z",
- "iopub.status.busy": "2022-10-22T13:30:01.762000Z",
- "iopub.status.idle": "2022-10-22T13:30:01.964000Z",
- "shell.execute_reply": "2022-10-22T13:30:01.964000Z"
- }
- },
- "outputs": [],
- "source": [
- "plot(dataME)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "From both graphs it can be seen that the simulation calculates exactly the same results."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Unload FMU\n",
- "\n",
- "After plotting the data, the FMU is unloaded and all unpacked data on disc is removed."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 18,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2022-10-22T13:30:01.970000Z",
- "iopub.status.busy": "2022-10-22T13:30:01.970000Z",
- "iopub.status.idle": "2022-10-22T13:30:02.010000Z",
- "shell.execute_reply": "2022-10-22T13:30:02.010000Z"
- }
- },
- "outputs": [],
- "source": [
- "unloadFMU(myFMU)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Summary\n",
- "\n",
- "Based on this tutorial it can be seen that simulating in the different mode is very easy, and it only takes a few commands to simulate the FMU. "
- ]
- }
- ],
- "metadata": {
- "interpreter": {
- "hash": "037537ff7419c497b9325f7d495147943224d408cf5d5ed915294a5b960167b0"
- },
- "jupytext": {
- "cell_metadata_filter": "-all",
- "comment_magics": "false",
- "notebook_metadata_filter": "-all"
- },
- "kernelspec": {
- "display_name": "Julia 1.10.5",
- "language": "julia",
- "name": "julia-1.10"
- },
- "language_info": {
- "file_extension": ".jl",
- "mimetype": "application/julia",
- "name": "julia",
- "version": "1.10.5"
- },
- "nteract": {
- "version": "0.28.0"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/examples/src/simulate.jl b/examples/src/simulate.jl
deleted file mode 100644
index 8768c027..00000000
--- a/examples/src/simulate.jl
+++ /dev/null
@@ -1,33 +0,0 @@
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-
-# imports
-using FMI
-using FMIZoo
-using Plots
-
-tStart = 0.0
-tStep = 0.01
-tStop = 8.0
-tSave = tStart:tStep:tStop
-
-# we use an FMU from the FMIZoo.jl
-pathToFMU = get_model_filename("SpringFrictionPendulum1D", "Dymola", "2022x")
-
-myFMU = fmiLoad(pathToFMU)
-# fmiLoad("path/to/myFMU.fmu"; unpackPath = "path/to/unpacked/fmu/")
-
-fmiInfo(myFMU)
-
-vrs = ["mass.s", "mass.v"]
-
-dataCS = fmiSimulateCS(myFMU, (tStart, tStop); recordValues=vrs, saveat=tSave)
-
-dataME = fmiSimulateME(myFMU, (tStart, tStop); saveat=tSave)
-
-fmiPlot(dataCS)
-
-fmiPlot(dataME)
-
-fmiUnload(myFMU)
diff --git a/examples/src/simulate.md b/examples/src/simulate.md
deleted file mode 100644
index 78937ff9..00000000
--- a/examples/src/simulate.md
+++ /dev/null
@@ -1,132 +0,0 @@
-# Simulate an FMU in different modes
-Tutorial by Johannes Stoljar, Tobias Thummerer
-
-🚧 This tutorial is under revision and will be replaced by an up-to-date version soon 🚧
-
-## License
-
-
-```julia
-# Copyright (c) 2021 Tobias Thummerer, Lars Mikelsons, Josef Kircher, Johannes Stoljar
-# Licensed under the MIT license.
-# See LICENSE (https://github.com/thummeto/FMI.jl/blob/main/LICENSE) file in the project root for details.
-```
-
-## Motivation
-This Julia Package *FMI.jl* is motivated by the use of simulation models in Julia. Here the FMI specification is implemented. FMI (*Functional Mock-up Interface*) is a free standard ([fmi-standard.org](http://fmi-standard.org/)) that defines a container and an interface to exchange dynamic models using a combination of XML files, binaries and C code zipped into a single file. The user can thus use simulation models in the form of an FMU (*Functional Mock-up Units*). Besides loading the FMU, the user can also set values for parameters and states and simulate the FMU both as co-simulation and model exchange simulation.
-
-## Introduction to the example
-In this example we want to show how fast and easy the simulation for an FMU is. For this purpose, the FMU is simulated in co-simulation mode and in model-exchange mode. After the FMU has been simulated, the simulation results are displayed in a graph. The graphs of the different modes are compared with each other. The used model is a one-dimensional spring pendulum with friction. The object-orientated structure of the *SpringFrictionPendulum1D* can be seen in the following graphic.
-
-
-
-
-## Target group
-The example is primarily intended for users who work in the field of simulations. The example wants to show how simple it is to use FMUs in Julia.
-
-
-## Other formats
-Besides, this [Jupyter Notebook](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/simulate.ipynb) there is also a [Julia file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/simulate.jl) with the same name, which contains only the code cells and for the documentation there is a [Markdown file](https://github.com/thummeto/FMI.jl/blob/examples/examples/src/simulate.md) corresponding to the notebook.
-
-
-## Getting started
-
-### Installation prerequisites
-| | Description | Command | Alternative |
-|:----|:----------------------------------|:--------------------------|:-----------------------------------------------|
-| 1. | Enter Package Manager via | ] | |
-| 2. | Install FMI via | add FMI | add " https://github.com/ThummeTo/FMI.jl " |
-| 3. | Install FMIZoo via | add FMIZoo | add " https://github.com/ThummeTo/FMIZoo.jl " |
-| 4. | Install Plots via | add Plots | |
-
-## Code section
-
-To run the example, the previously installed packages must be included.
-
-
-```julia
-# imports
-using FMI
-using FMIZoo
-using Plots
-```
-
-### Simulation setup
-
-Next, the start time and end time of the simulation are set. Finally, a step size is specified to store the results of the simulation at these time steps.
-
-
-```julia
-tStart = 0.0
-tStep = 0.01
-tStop = 8.0
-tSave = tStart:tStep:tStop
-```
-
-### Import FMU
-
-In the next lines of code the FMU model from *FMIZoo.jl* is loaded and the information about the FMU is shown.
-
-
-```julia
-# we use an FMU from the FMIZoo.jl
-pathToFMU = get_model_filename("SpringFrictionPendulum1D", "Dymola", "2022x")
-
-myFMU = fmiLoad(pathToFMU)
-# fmiLoad("path/to/myFMU.fmu"; unpackPath = "path/to/unpacked/fmu/")
-
-fmiInfo(myFMU)
-```
-
-### Simulate FMU
-
-In the following, the FMU is simulated in the two different simulation modes.
-
-#### Simulate as Co-Simulation
-
-In the next steps the recorded values are defined. The first state is the position of the mass and the second state is the velocity. In the function `fmiSimulateCS()` the FMU is simulated in co-simulation mode (CS) with an adaptive step size but with fixed save points `tSave`. In addition, the start and end time and the recorded variables are specified.
-
-
-```julia
-vrs = ["mass.s", "mass.v"]
-
-dataCS = fmiSimulateCS(myFMU, (tStart, tStop); recordValues=vrs, saveat=tSave)
-```
-
-#### Simulate as Model-Exchange
-
-In the function `fmiSimulateME()` the FMU is simulated in model-exchange mode (ME) with an adaptive step size but with fixed save points `tSave`. In addition, the start and end time are specified. In contrast to the co-simulation, the values to be stored are not specified here, since the states and events of the FMU are always output as well. The identifiers given above just correspond to the states of the FMU.
-
-
-```julia
-dataME = fmiSimulateME(myFMU, (tStart, tStop); saveat=tSave)
-```
-
-### Plotting FMU
-
-After the simulation is finished the results of the FMU for the co-simulation and model-exchange mode can be plotted. In the plot for the FMU it can be seen that the oscillation continues to decrease due to the effect of the friction. If you simulate long enough, the oscillation comes to a standstill in a certain time.
-
-
-```julia
-fmiPlot(dataCS)
-```
-
-
-```julia
-fmiPlot(dataME)
-```
-
-From both graphs it can be seen that the simulation calculates exactly the same results.
-
-### Unload FMU
-
-After plotting the data, the FMU is unloaded and all unpacked data on disc is removed.
-
-
-```julia
-fmiUnload(myFMU)
-```
-
-### Summary
-
-Based on this tutorial it can be seen that simulating in the different mode is very easy, and it only takes a few commands to simulate the FMU.
diff --git a/examples/src/simulate_files/simulate_14_0.png b/examples/src/simulate_files/simulate_14_0.png
deleted file mode 100644
index 59876b6e..00000000
Binary files a/examples/src/simulate_files/simulate_14_0.png and /dev/null differ
diff --git a/examples/src/simulate_files/simulate_14_0.svg b/examples/src/simulate_files/simulate_14_0.svg
deleted file mode 100644
index d5e1c938..00000000
--- a/examples/src/simulate_files/simulate_14_0.svg
+++ /dev/null
@@ -1,50 +0,0 @@
-
-
diff --git a/examples/src/simulate_files/simulate_15_0.png b/examples/src/simulate_files/simulate_15_0.png
deleted file mode 100644
index 94ea6948..00000000
Binary files a/examples/src/simulate_files/simulate_15_0.png and /dev/null differ
diff --git a/examples/src/simulate_files/simulate_15_0.svg b/examples/src/simulate_files/simulate_15_0.svg
deleted file mode 100644
index dd4654b5..00000000
--- a/examples/src/simulate_files/simulate_15_0.svg
+++ /dev/null
@@ -1,57 +0,0 @@
-
-