From f51e1b36d2c4060064deb6847a612cbeaf362c19 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Christia=20M=C3=B8ldrup=20Legaard?= Date: Mon, 31 Jul 2023 10:02:08 +0200 Subject: [PATCH] Update --- README.md | 7 + notebooks/2_simulation.ipynb | 6 + notebooks/2_simulation.py | 316 ++++++++++ notebooks/3_sciml.py | 168 +++++ notebooks/3_sciml_ad_pytorch.py | 43 ++ notebooks/3_sciml_linear_regression.py | 76 +++ notebooks/4_cosim.ipynb | 65 ++ notebooks/4_cosim.py | 142 +++++ notebooks/4_cosim_improved.py | 150 +++++ notebooks/4_orchestrator.c | 84 +++ notebooks/4_robot_fmu.c | 177 ++++++ notebooks/4_robot_modelDescription.xml | 20 + notebooks/fmi3FunctionTypes.h | 638 +++++++++++++++++++ notebooks/fmi3Functions.h | 343 +++++++++++ notebooks/fmi3PlatformTypes.h | 94 +++ notebooks/notebook.ipynb | 817 ++++++++++++++++++++++++- scripts/assessment.py | 57 ++ scripts/spider.py | 188 ++++++ 18 files changed, 3361 insertions(+), 30 deletions(-) create mode 100644 README.md create mode 100644 notebooks/2_simulation.ipynb create mode 100644 notebooks/2_simulation.py create mode 100644 notebooks/3_sciml.py create mode 100644 notebooks/3_sciml_ad_pytorch.py create mode 100644 notebooks/3_sciml_linear_regression.py create mode 100644 notebooks/4_cosim.ipynb create mode 100644 notebooks/4_cosim.py create mode 100644 notebooks/4_cosim_improved.py create mode 100644 notebooks/4_orchestrator.c create mode 100644 notebooks/4_robot_fmu.c create mode 100644 notebooks/4_robot_modelDescription.xml create mode 100644 notebooks/fmi3FunctionTypes.h create mode 100644 notebooks/fmi3Functions.h create mode 100644 notebooks/fmi3PlatformTypes.h create mode 100644 scripts/assessment.py create mode 100644 scripts/spider.py diff --git a/README.md b/README.md new file mode 100644 index 0000000..04dccc6 --- /dev/null +++ b/README.md @@ -0,0 +1,7 @@ +# + +``` bash +python3 -m venv venv +source venv/bin/active +python3 -m pip install numpy matplotlib jupyterlab ipykernel 'jax[cpu]' +``` \ No newline at end of file diff --git a/notebooks/2_simulation.ipynb b/notebooks/2_simulation.ipynb new file mode 100644 index 0000000..363fcab --- /dev/null +++ b/notebooks/2_simulation.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/2_simulation.py b/notebooks/2_simulation.py new file mode 100644 index 0000000..fd93ea3 --- /dev/null +++ b/notebooks/2_simulation.py @@ -0,0 +1,316 @@ +import numpy as np +import matplotlib.pyplot as plt +import sys + + +def pendulum_ideal(x): + g = 1.0 # gravity + l = 1.0 # pendulum arm length + θ, ω = x + + dθdt = ω + dωdt = -(g / l) * np.sin(θ) + return np.array((dθdt, dωdt)) + + +def pendulum_friction(x): + g = 1.0 # gravity + l = 1.0 # pendulum arm length + γ = 1.0 # friction co-efficient + θ, ω = x + + dθdt = ω + dωdt = -(g / l) * np.sin(θ) - γ * ω + return dθdt, dωdt + + +def lotka_volterra(x): + x, y = x + a = 1.0 + b = 1.0 + c = 1.0 + d = 1.0 + dxdt = a * x - b * x * y + dydt = c * x * y - d * y + return dxdt, dydt + + +def run_lotka_volterra(): + mesh_step = 0.3 + x, y = np.meshgrid( + np.arange(0.0, 5.0 + mesh_step, mesh_step), + np.arange(0.0, 5.0 + mesh_step, mesh_step), + ) + + dxdt, dydt = lotka_volterra((x, y)) + + fig, ax = plt.subplots() + # ax.quiver(x, y, dxdt, dydt, angles="xy", scale_units="xy", scale=8) + ax.streamplot(x, y, dxdt, dydt) + ax.set_xlabel("x") + ax.set_ylabel("y") + ax.set_title("Vector Field: Lotka-Volterra") + plt.savefig("figures/simulation/lotka_volterra_vector_field.pdf") + plt.show() + + +def run_pendulum_solver(): + step_size_reference = 0.00001 + step_size = 0.1 + + t_start = 0.0 + t_end = 4 * np.pi + + # simulate reference + t_reference = np.arange(t_start, t_end + step_size_reference, step_size_reference) + x_cur = np.array((np.pi / 4, 00)) # initial state + xs_reference = [x_cur] + + for _ in t_reference[1:]: + x_new = x_cur + step_size_reference * pendulum_ideal(x_cur) + xs_reference.append(x_new) + x_cur = x_new + + xs_reference = np.stack(xs_reference, axis=1) # (n_states, n_steps) + + # simulate Euler + t = np.arange(t_start, t_end + step_size, step_size) + + x_cur = np.array((np.pi / 4, 00)) # initial state + xs_euler = [x_cur] + + for _ in t[1:]: + x_new = x_cur + step_size * pendulum_ideal(x_cur) + xs_euler.append(x_new) + x_cur = x_new + + xs_euler = np.stack(xs_euler, axis=1) # (n_states, n_steps) + + # simulate midpoint + + x_cur = np.array((np.pi / 4, 00)) # initial state + xs_midpoint = [x_cur] + + for _ in t[1:]: + x_new = x_cur + step_size * pendulum_ideal( + x_cur + step_size / 2 * pendulum_ideal(x_cur) + ) + xs_midpoint.append(x_new) + x_cur = x_new + + xs_midpoint = np.stack(xs_midpoint, axis=1) # (n_states, n_steps) + + # plotting + + fig, (ax1, ax2) = plt.subplots(2, sharex=True) + + ax1.plot( + t_reference, + xs_reference[0], + label=f"FE (step-size = {step_size_reference})", + c="black", + linewidth=2, + ) + ax1.plot( + t, + xs_euler[0], + label=f"FE (step-size = {step_size})", + c="blue", + linestyle="dotted", + linewidth=2, + ) + ax1.plot( + t, + xs_midpoint[0], + label=f"MID (step-size = {step_size})", + c="red", + linestyle="dotted", + linewidth=2, + ) + ax1.set_ylabel(rf"$\theta$ [rad]") + ax2.plot(t_reference, xs_reference[1], label="reference", c="black", linewidth=2) + ax2.plot( + t, + xs_euler[1], + c="blue", + linestyle="dotted", + linewidth=2, + ) + ax2.plot( + t, + xs_midpoint[1], + c="red", + linestyle="dotted", + linewidth=2, + ) + ax2.set_ylabel(rf"$\omega$ [rad/s]") + ax2.set_xlabel("t [s]") + ax1.legend() + plt.tight_layout() + plt.show() + + +def run_pendulum_phase(): + mesh_step = 0.3 + θ, ω = np.meshgrid( + np.arange(-np.pi, np.pi + mesh_step, mesh_step), + np.arange(-np.pi, np.pi + mesh_step, mesh_step), + ) + θ_wrapped, ω_wrapped = np.meshgrid( + np.arange(-2 * np.pi, 2 * np.pi + mesh_step, mesh_step), + np.arange(-2 * np.pi, 2 * np.pi + mesh_step, mesh_step), + ) + + dθdt_ideal, dωdt_ideal = pendulum_ideal((θ, ω)) + dθdt_ideal_wrapped, dωdt_ideal_wrapped = pendulum_ideal((θ_wrapped, ω_wrapped)) + dθdt_friction, dωdt_friction = pendulum_friction((θ, ω)) + + fig, ax = plt.subplots() + # ax.quiver(θ, ω, dθdt_ideal, dωdt_ideal, angles="xy", scale_units="xy", scale=5) + ax.streamplot(θ, ω, dθdt_ideal, dωdt_ideal) + ax.set_xlabel(rf"$\theta$") + ax.set_ylabel(rf"$\omega$") + ax.set_title("Vector Field: Ideal Pendulum") + plt.savefig("figures/simulation/pendulum_ideal_vector_field.pdf") + + fig, ax = plt.subplots() + ax.quiver( + θ_wrapped, + ω_wrapped, + dθdt_ideal_wrapped, + dωdt_ideal_wrapped, + angles="xy", + scale_units="xy", + scale=10, + ) + ax.set_xlim(-2 * np.pi, 2 * np.pi) + ax.set_ylim(-np.pi, np.pi) + ax.set_xlabel(rf"$\theta$") + ax.set_ylabel(rf"$\omega$") + ax.set_title("Vector Field: Ideal Pendulum") + plt.savefig("figures/simulation/pendulum_ideal_vector_field_wrapped.pdf") + + fig, ax = plt.subplots() + # ax.quiver( + # θ, ω, dθdt_friction, dωdt_friction, angles="xy", scale_units="xy", scale=5 + # ) + ax.streamplot(θ, ω, dθdt_friction, dωdt_friction) + ax.set_xlabel(rf"$\theta$") + ax.set_ylabel(rf"$\omega$") + ax.set_title("Vector Field: Pendulum with friction") + plt.savefig("figures/simulation/pendulum_friction_vector_field.pdf") + + plt.show() + + +def simulate_with_stepsize(f, x0, t_start, t_stop, step_size): + t = np.arange(t_start, t_stop + step_size, step_size) + x_euler = [x0] + x_midpoint = [x0] + + for _ in t[1:]: + x_euler.append(x_euler[-1] + step_size * f(x_euler[-1])) + x_midpoint.append( + x_midpoint[-1] + + step_size * f(x_midpoint[-1] + step_size / 2 * x_midpoint[-1]) + ) + + x_exact = np.array([np.e**t for t in t]) + x_euler = np.stack(x_euler) + x_midpoint = np.stack(x_midpoint) + + return t, x_exact, x_euler, x_midpoint + + +def run_convergence(): + def f(x): + return x + + step_size_min = 2**-25 + step_size_max = 1.0 + n_steps_sizes_in_sweep = 5 + step_size_increment = (step_size_max - step_size_min) / n_steps_sizes_in_sweep + t_start = 0.0 + t_end = 0.1 + + def f(x): + return x + + x0 = np.array((1.0)) + + step_sizes = np.arange( + step_size_min, step_size_max + step_size_increment, step_size_increment + ) + + errors = {} + + for h in step_sizes: + t_cur = t_start + x_cur = x0 + while t_cur < t_end: + x_cur = x_cur + h * f(x_cur) + t_cur += h + + # assert t_cur == t_end, "simulation did not stop at the desired end time" + + x_true = np.e**t_cur + errors[h] = abs(x_cur - x_true) + + fig, ax = plt.subplots() + ax.loglog(list(errors), list(errors.values()), label="euler") + # ax.loglog(np.array(list(errors)), errors_midpoint, label="midpoint") + ax.set_ylabel("Mean-squared error") + ax.set_xlabel("step-size") + plt.legend() + plt.show() + + +def run_integrator(): + step_size = 0.001 + step_size_coarse = 0.3 + t_start = 0.0 + t_end = 10.0 + t = np.arange(t_start, t_end + step_size, step_size) + t_coarse = np.arange(t_start, t_end + step_size_coarse, step_size_coarse) + + # fine + x_cur = np.array((0.5, 0.0)) + x = [x_cur] + + for _ in t[1:]: + x_new = x_cur + step_size * pendulum_ideal(x_cur) + x.append(x_new) + x_cur = x_new + + x = np.stack(x, axis=1) # (n_states, n_steps) + + # coarse + x_cur = np.array((0.5, 0.0)) + x_coarse = [x_cur] + x_straight = [] + n_steps_per_coarse = step_size_coarse // step_size + + for _ in t_coarse[1:]: + x_new = x_cur + step_size_coarse * pendulum_ideal(x_cur) + x_coarse.append(x_new) + x_cur = x_new + + x_coarse = np.stack(x_coarse, axis=1) # (n_states, n_steps_coarse) + + # plotting + fig, (ax1, ax2) = plt.subplots(2, sharex=True) + ax1.plot(t, x[0]) + ax1.scatter(t_coarse, x_coarse[0], marker="x", c="red") + + ax2.plot(t, x[1]) + ax1.set_ylabel(rf"$\theta$ [rad]") + ax2.set_ylabel(rf"$\omega$ [rad/s]") + ax2.set_xlabel("t [s]") + plt.show() + + +if __name__ == "__main__": + # run_lotka_volterra() + # run_convergence() + # run_pendulum_solver() + run_pendulum_phase() diff --git a/notebooks/3_sciml.py b/notebooks/3_sciml.py new file mode 100644 index 0000000..a1d42b7 --- /dev/null +++ b/notebooks/3_sciml.py @@ -0,0 +1,168 @@ +import jax.numpy as jnp +from jax import grad, jit, value_and_grad, vmap, random, tree_map +from jax.lax import scan +import matplotlib.pyplot as plt +from tqdm import tqdm +import numpy as np + +key = random.PRNGKey(1) + + +def solve_euler(f, t, y0, *args, **kwargs): + step_sizes = t[1:] - t[:-1] + y_cur = y0 + Y = [y_cur] + + for t, step_size in zip(t[1:], step_sizes): + dydt = f(t, y_cur, *args) + y_new = y_cur + step_size * dydt + Y.append(y_new) + y_cur = y_new + + return jnp.stack(Y, axis=1) + + +def solve_euler_scan(f, t, y0, *args, **kwargs): + step_sizes = t[1:] - t[:-1] + + def f_scan(y_cur, t_and_step): + t, step_size = t_and_step + dydt = f(t, y_cur, *args) + y_new = y_cur + step_size * dydt + return y_new, y_new + + _, Y = scan(f_scan, init=y0, xs=(t[1:], step_sizes)) + Y = jnp.concatenate((y0.reshape(-1, 1), Y.T), axis=1) + return Y + + +def f(t, x, params): + θ, ω = x + dθdt = ω + dωdt = -params["g"] / params["l"] * jnp.sin(θ) + return jnp.array((dθdt, dωdt)) + + +def run_parameter_estimation(): + h = 0.001 + t_train_start = 0.0 + t_train_end = h + t_train = jnp.arange(t_train_start, t_train_end + h, h) + t_validation_start = t_train_start + t_validation_end = 4 * jnp.pi + t_validation = jnp.arange(t_validation_start, t_validation_end + h, h) + + x0 = jnp.array((-0.5, 0.0)) + + solve_euler_scan_grid = vmap(solve_euler_scan, (None, None, 0, None)) + + res = 0.1 + + θ_grid, ω_grid = jnp.meshgrid( + jnp.arange(-jnp.pi, jnp.pi + res, res), + jnp.arange(-jnp.pi, jnp.pi + res, res), + ) + θ_grid = θ_grid.reshape(-1) + ω_grid = ω_grid.reshape(-1) + x0_grid = jnp.stack((θ_grid, ω_grid), axis=1) + + def update(x_target, t, x0, params): + def loss(params): + y_predicted = solve_euler_scan(f, t, x0, params) + return jnp.linalg.norm(x_target - y_predicted) + + loss, grads = value_and_grad(loss)(params) + + params = tree_map(lambda p, g: p - lr * g, params, grads) + return loss, params + + def update_grid(x_target, t, x0, params): + def loss(params): + y_predicted = solve_euler_scan_grid(f, t, x0, params) + return jnp.linalg.norm(x_target - y_predicted) + + loss, grads = value_and_grad(loss)(params) + + params = tree_map(lambda p, g: p - lr * g, params, grads) + return loss, params + + parameters_true = {"g": 1.0, "l": 1.0} + parameters_estimated = {"g": 1.0, "l": 0.5} + + x_true_grid = solve_euler_scan_grid(f, t_train, x0_grid, parameters_true) + + n_epochs = 10000 + lr = 0.001 # learning rate + losses = [] + + update = jit(update_grid) + + for _ in tqdm(range(n_epochs)): + # value, parameters_estimated = update(x_true, t, x0, parameters_estimated) + value, parameters_estimated = update( + x_true_grid, t_train, x0_grid, parameters_estimated + ) + losses.append(value) + + x_true_validation = solve_euler_scan(f, t_validation, x0, parameters_true) + x_predicted_validation = solve_euler_scan(f, t_validation, x0, parameters_estimated) + + fig, ax = plt.subplots() + ax.plot(t_validation, x_true_validation[0], label=rf"$\theta$", color="blue") + ax.plot(t_validation, x_true_validation[1], label=rf"$\omega$", color="orange") + ax.plot( + t_validation, + x_predicted_validation[0], + label=rf"$\hat{{\theta}}$", + color="blue", + linestyle="dotted", + ) + ax.plot( + t_validation, + x_predicted_validation[1], + label=rf"$\hat{{\omega}}$", + color="orange", + linestyle="dotted", + ) + ax.set_xlabel("t[s]") + ax.set_ylabel("x(t)") + ax.legend() + ax.set_title( + rf"Pendulum $\hat{{g}}$={parameters_estimated['g']:.2f},$\hat{{l}}$={parameters_estimated['l']:.2f}" + ) + plt.savefig("./figures/sciml/parameter_estimation_pendulum_simulation.pdf") + + fig, ax = plt.subplots() + ax.semilogy(losses) + ax.set_xlabel("epoch") + _ = ax.set_ylabel("loss(epoch)") + plt.savefig("./figures/sciml/parameter_estimation_pendulum_losses.pdf") + + plt.show() + + +def run_phase_plot(): + res = 0.1 + g = 1.0 + l = 1.0 + xx, yy = jnp.meshgrid( + jnp.arange(-jnp.pi, jnp.pi + res, res), + jnp.arange(-jnp.pi, jnp.pi + res, res), + ) + + dx, dy = f((xx, yy), g, l) + + fig, ax = plt.subplots() + + xx = np.asarray(xx) + yy = np.asarray(yy) + + ax.streamplot(xx, yy, dx, dy) + ax.set_xlabel("θ") + ax.set_ylabel("ω") + + plt.show() + + +if __name__ == "__main__": + run_parameter_estimation() diff --git a/notebooks/3_sciml_ad_pytorch.py b/notebooks/3_sciml_ad_pytorch.py new file mode 100644 index 0000000..1e7b35b --- /dev/null +++ b/notebooks/3_sciml_ad_pytorch.py @@ -0,0 +1,43 @@ +import torch +from torch.func import grad +from sympy import symbols, diff, cos, sin +import math + + +def run_numerical_differences(): + h = 0.001 + x = 1.0 + x0 = math.cos(math.sin(x)) + x1 = math.cos(math.sin(x + h)) + dzdx = (x1 - x0) / h + print(dzdx) # -0.40264575946546977 + + +def run_symbolic(): + x = symbols("x") + y = sin(x) + z = cos(y) + dzdx = diff(z, x) + print(dzdx) # -sin(sin(x))*cos(x) + print(dzdx.subs(x, 1.0)) # -0.402862443052853 + + +def run(): + # imperative + x = torch.ones([], requires_grad=True) + y = torch.sin(x) + z = torch.cos(y) + z.backward() + print(x.grad) # tensor(-0.4029) + + # functional + def h(x): + return torch.cos(torch.sin(x)) + + print(grad(h)(x)) # tensor(-0.4029) + + +if __name__ == "__main__": + # run() + run_numerical_differences() + # run_symbolic() diff --git a/notebooks/3_sciml_linear_regression.py b/notebooks/3_sciml_linear_regression.py new file mode 100644 index 0000000..ec92aa4 --- /dev/null +++ b/notebooks/3_sciml_linear_regression.py @@ -0,0 +1,76 @@ +from jax import jit, value_and_grad, random, vmap +import jax.numpy as jnp +from tqdm import tqdm +import matplotlib.pyplot as plt + + +def loss(x, y, a, b): + y_predicted = a * x + b + return jnp.linalg.norm(y - y_predicted) + + +def update(x, y, a, b): + learning_rate = 0.0001 + + value, (dlda, dldb) = value_and_grad(loss, argnums=(2, 3))(x, y, a, b) + a -= learning_rate * dlda + b -= learning_rate * dldb + return value, a, b + + +def run(): + key = random.PRNGKey(1) + + a = 1.0 + b = 2.0 + x = jnp.arange(-3.0, 3.0, 0.001) + e = random.normal(key, x.shape) * 1e-1 + y = a * x + b + e + + update_jit = jit(update) + + a_estimate = -5.0 # 0.5 + b_estimate = 5.0 # 1.0 + n_epochs = 1000 + losses = [] + + ab_grid = jnp.meshgrid(jnp.arange(-5.0, 5.0, 0.1), jnp.arange(-5.0, 5.0, 0.1)) + + loss_grid = vmap(vmap(lambda a, b: loss(x, y, a, b), (0, 0)), (0, 0))(*ab_grid) + + a_estimates = [] + b_estimates = [] + + for i in tqdm(range(n_epochs)): + value, a_estimate, b_estimate = update_jit(x, y, a_estimate, b_estimate) + a_estimates.append(a_estimate) + b_estimates.append(b_estimate) + losses.append(value) + y_estimate = a_estimate * x + b_estimate + + fig, ax = plt.subplots() + ax.plot(x, y, label="f(x)") + ax.plot(x, y_estimate, label=rf"$\hat{{f}}(x)$") + ax.legend() + ax.set_xlabel("x") + ax.set_ylabel("f(x)") + + fig, ax = plt.subplots() + ax.semilogy(jnp.array(losses)) + ax.set_xlabel("epoch") + ax.set_ylabel("loss(epoch)") + print(f"a: {a_estimate}, b: {b_estimate}") + + fig, ax = plt.subplots() + im = ax.imshow(loss_grid, extent=(-5, 5, -5, 5), origin="lower") + ax.set_xlabel("a") + ax.set_ylabel("b") + fig.colorbar(im) + ax.plot(a_estimates, b_estimates, color="red") + ax.set_title("$\mathcal{L}(a,b)$") + + plt.show() + + +if __name__ == "__main__": + run() diff --git a/notebooks/4_cosim.ipynb b/notebooks/4_cosim.ipynb new file mode 100644 index 0000000..582a563 --- /dev/null +++ b/notebooks/4_cosim.ipynb @@ -0,0 +1,65 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from numpy import cos\n", + "\n", + "V_abs = 12.0\n", + "K = 7.45\n", + "g = 9.81\n", + "b = 5.0\n", + "m = 5.0\n", + "R = 0.15\n", + "L = 0.036\n", + "l = 1.0\n", + "\n", + "def robot_dynamics(x, u):\n", + " θ, ω, i = x\n", + " dθdt = ω\n", + " dωdt = K*i*b*ω-m*g*l*cos(θ)\n", + " didt = (u * V_abs - R*i - K * ω) / L\n", + "\n", + "def step_controller(θ, θ_setpoint, step_size):\n", + " pass\n", + "\n", + "t_start = 0.0\n", + "t_end = 10.0\n", + "step_size = 0.001\n", + "θ_setpoint = 1.0\n", + "xs = []\n", + "x = np.array(0.0, 0.0, 0.0)\n", + "\n", + "for t in np.arange(t_start, t_end, step_size):\n", + " θ, _ = x\n", + " u = step_controller(θ, θ_setpoint, step_size)\n", + " dxdt = robot_dynamics(u,)\n", + " x = x + step_size * dxdt\n", + " xs.append(x)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.10.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "dc5e22c7cb6c56d70e5942e17bdff83f85467903f5848450cce624a2363798d7" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/4_cosim.py b/notebooks/4_cosim.py new file mode 100644 index 0000000..a0e6ca9 --- /dev/null +++ b/notebooks/4_cosim.py @@ -0,0 +1,142 @@ +import numpy as np +from numpy import cos +import matplotlib.pyplot as plt +from copy import deepcopy + +from dataclasses import dataclass + + +class Controller: + def step(self, communication_step_size, robot: "Robot"): + error = self.θ_setpoint - robot.θ + + if self.error_last is not None: + error_derivative = (self.error_last - error) / communication_step_size + else: + error_derivative = 0.0 + + self.u = ( + self.kp * error + self.ki * self.error_integral + self.kd * error_derivative + ) + self.error_integral += error * communication_step_size + self.error_last = error + + def __init__(self, kp, ki, kd, θ_setpoint, robot: "Robot"): + error = θ_setpoint - robot.θ + self.kp = kp + self.ki = ki + self.kd = kd + self.θ_setpoint = θ_setpoint + self.error_last = error + self.error_integral = 0.0 + self.u = self.kp * error + + +@dataclass +class Robot: + def step(self, communication_step_size, controller: Controller): + t_elapsed = 0.0 + + while t_elapsed < communication_step_size: + dθdt = self.ω + dωdt = ( + self.K * self.i + - self.b * self.ω + - self.m * self.g * self.l * cos(self.θ) + ) / self.J + didt = ( + controller.u * self.V_abs - self.R * self.i - self.K * self.ω + ) / self.L + + self.θ = self.θ + self.internal_step_size * dθdt + self.ω = self.ω + self.internal_step_size * dωdt + self.i = self.i + self.internal_step_size * didt + + t_elapsed += self.internal_step_size + self._internal_θ = ( + [self.θ] if self._internal_θ is None else self._internal_θ + [self.θ] + ) + + if self._internal_t is None: + self._internal_t = [t_elapsed] + else: + self._internal_t = self._internal_t + [ + self._internal_t[-1] + self.internal_step_size + ] + + assert ( + t_elapsed == communication_step_size + ), f"unable to step for exactly {communication_step_size} " + + θ: float # angle + ω: float # velocity + i: float # current + V_abs = 12.0 + K = 7.45 # torque coefficient + g = 9.81 # gravitational acceleration + b = 5.0 # motor shaft friction + m = 5.0 # mass of joint + R = 0.15 # electrical resistance ? + L = 0.036 # motor inductance + l = 1.0 # length of joint + J = 0.5 * (m * l**2) # moment of intertia + internal_step_size = 1 / 1024 + _internal_θ = None + _internal_t = None + + +def run_cosim_for(controller: Controller, robot: Robot, t): + communication_step_sizes = t[1:] - t[:-1] + + θs = [robot.θ] + ts = [0.0] + + for communication_step_size in communication_step_sizes: + controller_cur = deepcopy(controller) + + controller.step(communication_step_size, robot) + + robot.step(communication_step_size, controller_cur) + + θs += robot._internal_θ + ts += robot._internal_t + return ts, θs + + +def run(): + t_start = 0.0 + t_end = 10.0 + communication_step_size = 1 / 1024 + communication_step_size_coarse = 1 / 8 # 1.0 + + t = np.arange(t_start, t_end + communication_step_size, communication_step_size) + t_coarse = np.arange( + t_start, t_end + communication_step_size_coarse, communication_step_size_coarse + ) + + robot = Robot(θ=0.0, ω=0.0, i=0.0) + controller = Controller(kp=1.0, ki=0.1, kd=-0.01, θ_setpoint=1.0, robot=robot) + + t_internal, θ_internal = run_cosim_for(controller, deepcopy(robot), t) + t_internal_coarse, θ_internal_coarse = run_cosim_for( + controller, deepcopy(robot), t_coarse + ) + + fig, ax = plt.subplots() + ax.axhline(controller.θ_setpoint, label="setpoint", color="red", linestyle="dotted") + ax.plot(t_internal, θ_internal, label=r"$h_{internal} = h_{communication}$") + ax.plot( + t_internal_coarse, + θ_internal_coarse, + label=f"$h_{{communication}}={communication_step_size_coarse}$", + ) + ax.set_xlabel("t [s]") + ax.set_ylabel("$\\theta(t)$") + plt.legend() + plt.tight_layout() + plt.savefig("figures/cosim/monolithic_vs_cosim_simulation.pdf") + plt.show() + + +if __name__ == "__main__": + run() diff --git a/notebooks/4_cosim_improved.py b/notebooks/4_cosim_improved.py new file mode 100644 index 0000000..2c3269e --- /dev/null +++ b/notebooks/4_cosim_improved.py @@ -0,0 +1,150 @@ +import numpy as np +from numpy import cos +import matplotlib.pyplot as plt +import math + + +def step_controller( + current_communication_time, + communication_step_size, + state_communication_point, + parameters, +): + internal_step_size = communication_step_size / 2**10 + + def controller_dynamics(state): + error = parameters["θ_setpoint"] - state["θ"] + error_last = state["error_last"] + + if state["error_last"] is None: + error_derivative = 0.0 + else: + error_derivative = (error_last - error) / internal_step_size + + error_integral += error * internal_step_size + + u = ( + parameters["kp"] * error + + parameters["ki"] * error_integral + + parameters["kd"] * error_derivative + ) + + dudt = u - state["u"] + d_error_last_dt = error_last - state["error_last"] + d_error_integral_dt = error * internal_step_size + + t_internal, state_internal = simulate_euler( + current_communication_time, + current_communication_time + internal_step_size, + internal_step_size, + controller_dynamics, + state_communication_point, + ) + + return t_internal, state_internal + + +def step_robot( + current_communication_time, + communication_step_size, + state_communication_point, +): + assert math.log(communication_step_size, 2).is_integer() + internal_step_size = communication_step_size / 2**10 + + def robot_dynamics(state): + V_abs = 12.0 # voltage across coil + K = 7.45 # torque coefficient + g = 9.81 # gravitational acceleration + b = 5.0 # motor shaft friction + m = 5.0 # mass of joint + R = 0.15 # electrical resistance ? + L = 0.036 # motor inductance + l = 1.0 # length of joint + J = 0.5 * (m * l**2) # moment of intertia + + θ, ω, i, u = state + dθdt = ω + dωdt = (K * i - b * ω - m * g * l * cos(θ)) / J + didt = (u * V_abs - R * i - K * ω) / L + dudt = 0.0 + return np.array((dθdt, dωdt, didt, dudt)) + + t_internal, state_internal = simulate_euler( + current_communication_time, + current_communication_time + internal_step_size, + internal_step_size, + robot_dynamics, + state_communication_point, + ) + + return t_internal, state_internal + + +def simulate_euler(t_begin, t_end, step_size, dynamics, state, parameters): + ts = np.arange(t_begin, t_end + step_size, step_size) + + states = [state] + for t in t: + dxdt = dynamics(t, state, parameters) + state = state + dxdt + states.append(state) + + return ts, state + + +def run(): + kp = 1.0 + kd = 0.0 + ki = 0.01 + + error_integral = 0.0 + error_last = None + + t_start = 0.0 + t_end = 10.0 + step_size = 0.0001 + θ_setpoint = 1.0 + + t = np.arange(t_start, t_end + step_size, step_size) + + controller_parameters = [(1.0, 0.0, 0.01), (1.0, 0.5, 0.01), (1.0, 0.3, 0.01)] + + X = [] + U = [] + for kp, ki, kd in controller_parameters: + xs = [] + us = [] + x = np.array((0.0, 0.0, 0.0)) + + for _ in t: + θ, *_ = x + u, error_last, error_integral = step_controller( + θ, θ_setpoint, step_size, error_last, error_integral, kp, ki, kd + ) + dxdt = robot_dynamics(x, u, K, b, m, g, l, V_abs, R, L, J) + x = x + step_size * dxdt + xs.append(x) + us.append(u) + + X.append(np.array(xs)) + U.append(us) + + # θ, ω, i = np.array(xs).T + + fig, ax = plt.subplots() + ax.axhline(θ_setpoint, label="setpoint", color="red", linestyle="dotted") + for (kp, ki, kd), x, u in zip(controller_parameters, X, U): + ax.plot(t, x[:, 0], label=rf"$K_p={kp}, K_i={ki}, K_d={kd}$") + + ax.set_ylabel(rf"$\theta(t)$") + ax.set_xlabel(rf"$t~[s]$") + ax.legend() + + plt.savefig("figures/cosim/pure_python_simulation.pdf") + + plt.show() + + +if __name__ == "__main__": + run() diff --git a/notebooks/4_orchestrator.c b/notebooks/4_orchestrator.c new file mode 100644 index 0000000..6e3a0bc --- /dev/null +++ b/notebooks/4_orchestrator.c @@ -0,0 +1,84 @@ +/* This example demonstrates how to import an FMU implemented as a shared library */ + +#ifdef _WIN32 +#include +#else +#include +#endif + +#include + +// FMI function types +#include "fmi3FunctionTypes.h" + +#define INSTANTIATION_TOKEN "{8c4e810f-3da3-4a00-8276-176fa3c9f000}" + +static void cb_logMessage(fmi3InstanceEnvironment instanceEnvironment, fmi3Status status, fmi3String category, fmi3String message) +{ + // log message... +} + +int main(int argc, char *argv[]) +{ + +#if defined(_WIN32) + HMODULE libraryHandle = LoadLibraryA("VanDerPol\\binaries\\x86_64-windows\\VanDerPol.dll"); +#elif defined(__APPLE__) + void *libraryHandle = dlopen("VanDerPol/binaries/x86_64-darwin/VanDerPol.dylib", RTLD_LAZY); +#else + void *libraryHandle = dlopen("VanDerPol/binaries/x86_64-linux/VanDerPol.so", RTLD_LAZY); +#endif + + if (!libraryHandle) + { + return EXIT_FAILURE; + } + + fmi3InstantiateModelExchangeTYPE *instantiateModelExchange = (fmi3InstantiateModelExchangeTYPE *) +#ifdef _WIN32 + GetProcAddress(libraryHandle, "fmi3InstantiateModelExchange"); +#else + dlsym(libraryHandle, "fmi3InstantiateModelExchange"); +#endif + + fmi3FreeInstanceTYPE *freeInstance = (fmi3FreeInstanceTYPE *) +#ifdef _WIN32 + GetProcAddress(libraryHandle, "fmi3FreeInstance"); +#else + dlsym(libraryHandle, "fmi3FreeInstance"); +#endif + + // load remaining FMI functions... + + if (!instantiateModelExchange || !freeInstance) + { + return EXIT_FAILURE; + } + + fmi3Instance m = instantiateModelExchange( + "instance1", // instance name + INSTANTIATION_TOKEN, // instantiation token (from XML) + NULL, // resource path + fmi3False, // visible + fmi3False, // debug logging disabled + NULL, // instance environment + cb_logMessage); // logger callback + + if (!m) + { + return EXIT_FAILURE; + } + + // simulation... + + freeInstance(m); + + // unload shared library +#ifdef _WIN32 + FreeLibrary(libraryHandle); +#else + dlclose(libraryHandle); +#endif + + return EXIT_SUCCESS; +} \ No newline at end of file diff --git a/notebooks/4_robot_fmu.c b/notebooks/4_robot_fmu.c new file mode 100644 index 0000000..7247553 --- /dev/null +++ b/notebooks/4_robot_fmu.c @@ -0,0 +1,177 @@ +#include "fmi3Functions.h" +#include "fmi3FunctionTypes.h" +#include + +// ------------------------------ fully functional ------------------------------------ + +typedef struct Robot +{ + // parameters + double V_abs; // supply voltage + double K; // torque coefficient + double g; // gravitational acceleration + double b; // motor shaft friction + double m; // mass of joint + double R; // electrical resistance of coil + double L; // motor inductance + double l; // length of joint + double J; // moment of intertia + // states + double θ; // angle + double ω; // velocity + // inputs + double u; // controller output + +} Robot; + +fmi3Instance fmi3InstantiateCoSimulation( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3Boolean eventModeUsed, + fmi3Boolean earlyReturnAllowed, + const fmi3ValueReference requiredIntermediateVariables[], + size_t nRequiredIntermediateVariables, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage, + fmi3IntermediateUpdateCallback intermediateUpdate) +{ + return malloc(sizeof(Robot)); +} + +fmi3Float64 *vref_to_float64(Robot *m, fmi3ValueReference valueReference) +{ + switch (valueReference) + { + case 0: + return &(m->V_abs); + break; + case 1: + return &(m->K); + break; + case 2: + return &(m->g); + break; + case 3: + return &(m->b); + break; + case 4: + return &(m->m); + break; + case 5: + return &(m->R); + break; + case 6: + return &(m->L); + break; + case 7: + return &(m->l); + break; + case 8: + return &(m->J); + break; + case 9: + return &(m->θ); + break; + case 10: + return &(m->ω); + break; + case 11: + return &(m->u); + break; + default: + return NULL; + } +} + +fmi3Status fmi3GetFloat64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 values[], + size_t nValues) +{ + Robot *m = (Robot *)instance; + + for (int i = 0; i < nValueReferences; ++i) + { + fmi3ValueReference valueReference = valueReferences[i]; + + values[valueReference] = *vref_to_float64(m, valueReference); + } + return fmi3OK; +} + +fmi3Status fmi3GetFloat64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 values[], + size_t nValues) +{ + Robot *m = (Robot *)instance; + + for (int i = 0; i < nValueReferences; ++i) + { + fmi3ValueReference valueReference = valueReferences[i]; + + *vref_to_float64(m, valueReference) = values[valueReference]; + } + return fmi3OK; +} + +fmi3Status fmi3DoStep(fmi3Instance instance, + fmi3Float64 currentCommunicationPoint, + fmi3Float64 communicationStepSize, + fmi3Boolean noSetFMUStatePriorToCurrentPoint, + fmi3Boolean *eventHandlingNeeded, + fmi3Boolean *terminateSimulation, + fmi3Boolean *earlyReturn, + fmi3Float64 *lastSuccessfulTime) +{ + Robot *m = (Robot *)instance; + + double time_internal = 0.0; + double internal_step_size = 1 / 1024; + + while (time_internal != communicationStepSize) + { + double dθdt = m->ω; + double dωdt = -m->g / m->l * sin(m->θ); + m->θ += dθdt; + m->ω += dωdt; + time_internal += internal_step_size; + } + + return fmi3OK; +} + +// ------------------------------ reduced ------------------------------------ + +fmi3Instance _fmi3InstantiateCoSimulation() +{ + return malloc(sizeof(Robot)); +} + +fmi3Status _fmi3DoStep(void *instance, + double currentCommunicationPoint, + double communicationStepSize, + // parameters omitted for brevity + double *lastSuccessfulTime) +{ + Robot *m = (Robot *)instance; + + double time_internal = 0.0; + double internal_step_size = 1 / 1024; + + while (time_internal != communicationStepSize) + { + double dθdt = m->ω; + double dωdt = -m->g / m->l * sin(m->θ); + m->θ += dθdt; + m->ω += dωdt; + time_internal += internal_step_size; + } + + return fmi3OK; +} diff --git a/notebooks/4_robot_modelDescription.xml b/notebooks/4_robot_modelDescription.xml new file mode 100644 index 0000000..fdc13e0 --- /dev/null +++ b/notebooks/4_robot_modelDescription.xml @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/notebooks/fmi3FunctionTypes.h b/notebooks/fmi3FunctionTypes.h new file mode 100644 index 0000000..ca97b70 --- /dev/null +++ b/notebooks/fmi3FunctionTypes.h @@ -0,0 +1,638 @@ +#ifndef fmi3FunctionTypes_h +#define fmi3FunctionTypes_h + +#include "fmi3PlatformTypes.h" + +/* +This header file defines the data and function types of FMI 3.0. +It must be used when compiling an FMU or an FMI importer. + +Copyright (C) 2011 MODELISAR consortium, + 2012-2022 Modelica Association Project "FMI" + All rights reserved. + +This file is licensed by the copyright holders under the 2-Clause BSD License +(https://opensource.org/licenses/BSD-2-Clause): + +---------------------------------------------------------------------------- +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +- Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + +- Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +---------------------------------------------------------------------------- +*/ + +#ifdef __cplusplus +extern "C" { +#endif + +/* Include stddef.h, in order that size_t etc. is defined */ +#include + + +/* Type definitions */ + +/* tag::Status[] */ +typedef enum { + fmi3OK, + fmi3Warning, + fmi3Discard, + fmi3Error, + fmi3Fatal, +} fmi3Status; +/* end::Status[] */ + +/* tag::DependencyKind[] */ +typedef enum { + fmi3Independent, + fmi3Constant, + fmi3Fixed, + fmi3Tunable, + fmi3Discrete, + fmi3Dependent +} fmi3DependencyKind; +/* end::DependencyKind[] */ + +/* tag::IntervalQualifier[] */ +typedef enum { + fmi3IntervalNotYetKnown, + fmi3IntervalUnchanged, + fmi3IntervalChanged +} fmi3IntervalQualifier; +/* end::IntervalQualifier[] */ + +/* tag::CallbackLogMessage[] */ +typedef void (*fmi3LogMessageCallback) (fmi3InstanceEnvironment instanceEnvironment, + fmi3Status status, + fmi3String category, + fmi3String message); +/* end::CallbackLogMessage[] */ + +/* tag::CallbackClockUpdate[] */ +typedef void (*fmi3ClockUpdateCallback) ( + fmi3InstanceEnvironment instanceEnvironment); +/* end::CallbackClockUpdate[] */ + +/* tag::CallbackIntermediateUpdate[] */ +typedef void (*fmi3IntermediateUpdateCallback) ( + fmi3InstanceEnvironment instanceEnvironment, + fmi3Float64 intermediateUpdateTime, + fmi3Boolean intermediateVariableSetRequested, + fmi3Boolean intermediateVariableGetAllowed, + fmi3Boolean intermediateStepFinished, + fmi3Boolean canReturnEarly, + fmi3Boolean* earlyReturnRequested, + fmi3Float64* earlyReturnTime); +/* end::CallbackIntermediateUpdate[] */ + +/* tag::CallbackPreemptionLock[] */ +typedef void (*fmi3LockPreemptionCallback) (); +typedef void (*fmi3UnlockPreemptionCallback) (); +/* end::CallbackPreemptionLock[] */ + +/* Define fmi3 function pointer types to simplify dynamic loading */ + +/*************************************************** +Types for Common Functions +****************************************************/ + +/* Inquire version numbers and setting logging status */ +/* tag::GetVersion[] */ +typedef const char* fmi3GetVersionTYPE(void); +/* end::GetVersion[] */ + +/* tag::SetDebugLogging[] */ +typedef fmi3Status fmi3SetDebugLoggingTYPE(fmi3Instance instance, + fmi3Boolean loggingOn, + size_t nCategories, + const fmi3String categories[]); +/* end::SetDebugLogging[] */ + +/* Creation and destruction of FMU instances and setting debug status */ +/* tag::Instantiate[] */ +typedef fmi3Instance fmi3InstantiateModelExchangeTYPE( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage); + +typedef fmi3Instance fmi3InstantiateCoSimulationTYPE( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3Boolean eventModeUsed, + fmi3Boolean earlyReturnAllowed, + const fmi3ValueReference requiredIntermediateVariables[], + size_t nRequiredIntermediateVariables, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage, + fmi3IntermediateUpdateCallback intermediateUpdate); + +typedef fmi3Instance fmi3InstantiateScheduledExecutionTYPE( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage, + fmi3ClockUpdateCallback clockUpdate, + fmi3LockPreemptionCallback lockPreemption, + fmi3UnlockPreemptionCallback unlockPreemption); +/* end::Instantiate[] */ + +/* tag::FreeInstance[] */ +typedef void fmi3FreeInstanceTYPE(fmi3Instance instance); +/* end::FreeInstance[] */ + +/* Enter and exit initialization mode, enter event mode, terminate and reset */ +/* tag::EnterInitializationMode[] */ +typedef fmi3Status fmi3EnterInitializationModeTYPE(fmi3Instance instance, + fmi3Boolean toleranceDefined, + fmi3Float64 tolerance, + fmi3Float64 startTime, + fmi3Boolean stopTimeDefined, + fmi3Float64 stopTime); +/* end::EnterInitializationMode[] */ + +/* tag::ExitInitializationMode[] */ +typedef fmi3Status fmi3ExitInitializationModeTYPE(fmi3Instance instance); +/* end::ExitInitializationMode[] */ + +/* tag::EnterEventMode[] */ +typedef fmi3Status fmi3EnterEventModeTYPE(fmi3Instance instance); +/* end::EnterEventMode[] */ + +/* tag::Terminate[] */ +typedef fmi3Status fmi3TerminateTYPE(fmi3Instance instance); +/* end::Terminate[] */ + +/* tag::Reset[] */ +typedef fmi3Status fmi3ResetTYPE(fmi3Instance instance); +/* end::Reset[] */ + +/* Getting and setting variable values */ +/* tag::Getters[] */ +typedef fmi3Status fmi3GetFloat32TYPE(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float32 values[], + size_t nValues); + +typedef fmi3Status fmi3GetFloat64TYPE(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 values[], + size_t nValues); + +typedef fmi3Status fmi3GetInt8TYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int8 values[], + size_t nValues); + +typedef fmi3Status fmi3GetUInt8TYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt8 values[], + size_t nValues); + +typedef fmi3Status fmi3GetInt16TYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int16 values[], + size_t nValues); + +typedef fmi3Status fmi3GetUInt16TYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt16 values[], + size_t nValues); + +typedef fmi3Status fmi3GetInt32TYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int32 values[], + size_t nValues); + +typedef fmi3Status fmi3GetUInt32TYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt32 values[], + size_t nValues); + +typedef fmi3Status fmi3GetInt64TYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int64 values[], + size_t nValues); + +typedef fmi3Status fmi3GetUInt64TYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 values[], + size_t nValues); + +typedef fmi3Status fmi3GetBooleanTYPE(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Boolean values[], + size_t nValues); + +typedef fmi3Status fmi3GetStringTYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3String values[], + size_t nValues); + +typedef fmi3Status fmi3GetBinaryTYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + size_t valueSizes[], + fmi3Binary values[], + size_t nValues); +/* end::Getters[] */ + +/* tag::GetClock[] */ +typedef fmi3Status fmi3GetClockTYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Clock values[]); +/* end::GetClock[] */ + +/* tag::Setters[] */ +typedef fmi3Status fmi3SetFloat32TYPE(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float32 values[], + size_t nValues); + +typedef fmi3Status fmi3SetFloat64TYPE(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 values[], + size_t nValues); + +typedef fmi3Status fmi3SetInt8TYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int8 values[], + size_t nValues); + +typedef fmi3Status fmi3SetUInt8TYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt8 values[], + size_t nValues); + +typedef fmi3Status fmi3SetInt16TYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int16 values[], + size_t nValues); + +typedef fmi3Status fmi3SetUInt16TYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt16 values[], + size_t nValues); + +typedef fmi3Status fmi3SetInt32TYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int32 values[], + size_t nValues); + +typedef fmi3Status fmi3SetUInt32TYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt32 values[], + size_t nValues); + +typedef fmi3Status fmi3SetInt64TYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int64 values[], + size_t nValues); + +typedef fmi3Status fmi3SetUInt64TYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 values[], + size_t nValues); + +typedef fmi3Status fmi3SetBooleanTYPE(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Boolean values[], + size_t nValues); + +typedef fmi3Status fmi3SetStringTYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3String values[], + size_t nValues); + +typedef fmi3Status fmi3SetBinaryTYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const size_t valueSizes[], + const fmi3Binary values[], + size_t nValues); +/* end::Setters[] */ +/* tag::SetClock[] */ +typedef fmi3Status fmi3SetClockTYPE (fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Clock values[]); +/* end::SetClock[] */ + +/* Getting Variable Dependency Information */ +/* tag::GetNumberOfVariableDependencies[] */ +typedef fmi3Status fmi3GetNumberOfVariableDependenciesTYPE(fmi3Instance instance, + fmi3ValueReference valueReference, + size_t* nDependencies); +/* end::GetNumberOfVariableDependencies[] */ + +/* tag::GetVariableDependencies[] */ +typedef fmi3Status fmi3GetVariableDependenciesTYPE(fmi3Instance instance, + fmi3ValueReference dependent, + size_t elementIndicesOfDependent[], + fmi3ValueReference independents[], + size_t elementIndicesOfIndependents[], + fmi3DependencyKind dependencyKinds[], + size_t nDependencies); +/* end::GetVariableDependencies[] */ + +/* Getting and setting the internal FMU state */ +/* tag::GetFMUState[] */ +typedef fmi3Status fmi3GetFMUStateTYPE (fmi3Instance instance, fmi3FMUState* FMUState); +/* end::GetFMUState[] */ + +/* tag::SetFMUState[] */ +typedef fmi3Status fmi3SetFMUStateTYPE (fmi3Instance instance, fmi3FMUState FMUState); +/* end::SetFMUState[] */ + +/* tag::FreeFMUState[] */ +typedef fmi3Status fmi3FreeFMUStateTYPE(fmi3Instance instance, fmi3FMUState* FMUState); +/* end::FreeFMUState[] */ + +/* tag::SerializedFMUStateSize[] */ +typedef fmi3Status fmi3SerializedFMUStateSizeTYPE(fmi3Instance instance, + fmi3FMUState FMUState, + size_t* size); +/* end::SerializedFMUStateSize[] */ + +/* tag::SerializeFMUState[] */ +typedef fmi3Status fmi3SerializeFMUStateTYPE (fmi3Instance instance, + fmi3FMUState FMUState, + fmi3Byte serializedState[], + size_t size); +/* end::SerializeFMUState[] */ + +/* tag::DeserializeFMUState[] */ +typedef fmi3Status fmi3DeserializeFMUStateTYPE (fmi3Instance instance, + const fmi3Byte serializedState[], + size_t size, + fmi3FMUState* FMUState); +/* end::DeserializeFMUState[] */ + +/* Getting partial derivatives */ +/* tag::GetDirectionalDerivative[] */ +typedef fmi3Status fmi3GetDirectionalDerivativeTYPE(fmi3Instance instance, + const fmi3ValueReference unknowns[], + size_t nUnknowns, + const fmi3ValueReference knowns[], + size_t nKnowns, + const fmi3Float64 seed[], + size_t nSeed, + fmi3Float64 sensitivity[], + size_t nSensitivity); +/* end::GetDirectionalDerivative[] */ + +/* tag::GetAdjointDerivative[] */ +typedef fmi3Status fmi3GetAdjointDerivativeTYPE(fmi3Instance instance, + const fmi3ValueReference unknowns[], + size_t nUnknowns, + const fmi3ValueReference knowns[], + size_t nKnowns, + const fmi3Float64 seed[], + size_t nSeed, + fmi3Float64 sensitivity[], + size_t nSensitivity); +/* end::GetAdjointDerivative[] */ + +/* Entering and exiting the Configuration or Reconfiguration Mode */ + +/* tag::EnterConfigurationMode[] */ +typedef fmi3Status fmi3EnterConfigurationModeTYPE(fmi3Instance instance); +/* end::EnterConfigurationMode[] */ + +/* tag::ExitConfigurationMode[] */ +typedef fmi3Status fmi3ExitConfigurationModeTYPE(fmi3Instance instance); +/* end::ExitConfigurationMode[] */ + +/* tag::GetIntervalDecimal[] */ +typedef fmi3Status fmi3GetIntervalDecimalTYPE(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 intervals[], + fmi3IntervalQualifier qualifiers[]); +/* end::GetIntervalDecimal[] */ + +/* tag::GetIntervalFraction[] */ +typedef fmi3Status fmi3GetIntervalFractionTYPE(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 counters[], + fmi3UInt64 resolutions[], + fmi3IntervalQualifier qualifiers[]); +/* end::GetIntervalFraction[] */ + +/* tag::GetShiftDecimal[] */ +typedef fmi3Status fmi3GetShiftDecimalTYPE(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 shifts[]); +/* end::GetShiftDecimal[] */ + +/* tag::GetShiftFraction[] */ +typedef fmi3Status fmi3GetShiftFractionTYPE(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 counters[], + fmi3UInt64 resolutions[]); +/* end::GetShiftFraction[] */ + +/* tag::SetIntervalDecimal[] */ +typedef fmi3Status fmi3SetIntervalDecimalTYPE(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 intervals[]); +/* end::SetIntervalDecimal[] */ + +/* tag::SetIntervalFraction[] */ +typedef fmi3Status fmi3SetIntervalFractionTYPE(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 counters[], + const fmi3UInt64 resolutions[]); +/* end::SetIntervalFraction[] */ + +/* tag::SetShiftDecimal[] */ +typedef fmi3Status fmi3SetShiftDecimalTYPE(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 shifts[]); +/* end::SetShiftDecimal[] */ + +/* tag::SetShiftFraction[] */ +typedef fmi3Status fmi3SetShiftFractionTYPE(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 counters[], + const fmi3UInt64 resolutions[]); +/* end::SetShiftFraction[] */ + +/* tag::EvaluateDiscreteStates[] */ +typedef fmi3Status fmi3EvaluateDiscreteStatesTYPE(fmi3Instance instance); +/* end::EvaluateDiscreteStates[] */ + +/* tag::UpdateDiscreteStates[] */ +typedef fmi3Status fmi3UpdateDiscreteStatesTYPE(fmi3Instance instance, + fmi3Boolean* discreteStatesNeedUpdate, + fmi3Boolean* terminateSimulation, + fmi3Boolean* nominalsOfContinuousStatesChanged, + fmi3Boolean* valuesOfContinuousStatesChanged, + fmi3Boolean* nextEventTimeDefined, + fmi3Float64* nextEventTime); +/* end::UpdateDiscreteStates[] */ + +/*************************************************** +Types for Functions for Model Exchange +****************************************************/ + +/* tag::EnterContinuousTimeMode[] */ +typedef fmi3Status fmi3EnterContinuousTimeModeTYPE(fmi3Instance instance); +/* end::EnterContinuousTimeMode[] */ + +/* tag::CompletedIntegratorStep[] */ +typedef fmi3Status fmi3CompletedIntegratorStepTYPE(fmi3Instance instance, + fmi3Boolean noSetFMUStatePriorToCurrentPoint, + fmi3Boolean* enterEventMode, + fmi3Boolean* terminateSimulation); +/* end::CompletedIntegratorStep[] */ + +/* Providing independent variables and re-initialization of caching */ +/* tag::SetTime[] */ +typedef fmi3Status fmi3SetTimeTYPE(fmi3Instance instance, fmi3Float64 time); +/* end::SetTime[] */ + +/* tag::SetContinuousStates[] */ +typedef fmi3Status fmi3SetContinuousStatesTYPE(fmi3Instance instance, + const fmi3Float64 continuousStates[], + size_t nContinuousStates); +/* end::SetContinuousStates[] */ + +/* Evaluation of the model equations */ +/* tag::GetDerivatives[] */ +typedef fmi3Status fmi3GetContinuousStateDerivativesTYPE(fmi3Instance instance, + fmi3Float64 derivatives[], + size_t nContinuousStates); +/* end::GetDerivatives[] */ + +/* tag::GetEventIndicators[] */ +typedef fmi3Status fmi3GetEventIndicatorsTYPE(fmi3Instance instance, + fmi3Float64 eventIndicators[], + size_t nEventIndicators); +/* end::GetEventIndicators[] */ + +/* tag::GetContinuousStates[] */ +typedef fmi3Status fmi3GetContinuousStatesTYPE(fmi3Instance instance, + fmi3Float64 continuousStates[], + size_t nContinuousStates); +/* end::GetContinuousStates[] */ + +/* tag::GetNominalsOfContinuousStates[] */ +typedef fmi3Status fmi3GetNominalsOfContinuousStatesTYPE(fmi3Instance instance, + fmi3Float64 nominals[], + size_t nContinuousStates); +/* end::GetNominalsOfContinuousStates[] */ + +/* tag::GetNumberOfEventIndicators[] */ +typedef fmi3Status fmi3GetNumberOfEventIndicatorsTYPE(fmi3Instance instance, + size_t* nEventIndicators); +/* end::GetNumberOfEventIndicators[] */ + +/* tag::GetNumberOfContinuousStates[] */ +typedef fmi3Status fmi3GetNumberOfContinuousStatesTYPE(fmi3Instance instance, + size_t* nContinuousStates); +/* end::GetNumberOfContinuousStates[] */ + +/*************************************************** +Types for Functions for Co-Simulation +****************************************************/ + +/* Simulating the FMU */ + +/* tag::EnterStepMode[] */ +typedef fmi3Status fmi3EnterStepModeTYPE(fmi3Instance instance); +/* end::EnterStepMode[] */ + +/* tag::GetOutputDerivatives[] */ +typedef fmi3Status fmi3GetOutputDerivativesTYPE(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int32 orders[], + fmi3Float64 values[], + size_t nValues); +/* end::GetOutputDerivatives[] */ + +/* tag::DoStep[] */ +typedef fmi3Status fmi3DoStepTYPE(fmi3Instance instance, + fmi3Float64 currentCommunicationPoint, + fmi3Float64 communicationStepSize, + fmi3Boolean noSetFMUStatePriorToCurrentPoint, + fmi3Boolean* eventHandlingNeeded, + fmi3Boolean* terminateSimulation, + fmi3Boolean* earlyReturn, + fmi3Float64* lastSuccessfulTime); +/* end::DoStep[] */ + +/*************************************************** +Types for Functions for Scheduled Execution +****************************************************/ + +/* tag::ActivateModelPartition[] */ +typedef fmi3Status fmi3ActivateModelPartitionTYPE(fmi3Instance instance, + fmi3ValueReference clockReference, + fmi3Float64 activationTime); +/* end::ActivateModelPartition[] */ + +#ifdef __cplusplus +} /* end of extern "C" { */ +#endif + +#endif /* fmi3FunctionTypes_h */ diff --git a/notebooks/fmi3Functions.h b/notebooks/fmi3Functions.h new file mode 100644 index 0000000..21d0743 --- /dev/null +++ b/notebooks/fmi3Functions.h @@ -0,0 +1,343 @@ +#ifndef fmi3Functions_h +#define fmi3Functions_h + +/* +This header file declares the functions of FMI 3.0. +It must be used when compiling an FMU. + +In order to have unique function names even if several FMUs +are compiled together (e.g. for embedded systems), every "real" function name +is constructed by prepending the function name by "FMI3_FUNCTION_PREFIX". +Therefore, the typical usage is: + + #define FMI3_FUNCTION_PREFIX MyModel_ + #include "fmi3Functions.h" + +As a result, a function that is defined as "fmi3GetContinuousStateDerivatives" in this header file, +is actually getting the name "MyModel_fmi3GetContinuousStateDerivatives". + +This only holds if the FMU is shipped in C source code, or is compiled in a +static link library. For FMUs compiled in a DLL/sharedObject, the "actual" function +names are used and "FMI3_FUNCTION_PREFIX" must not be defined. + +Copyright (C) 2008-2011 MODELISAR consortium, + 2012-2022 Modelica Association Project "FMI" + All rights reserved. + +This file is licensed by the copyright holders under the 2-Clause BSD License +(https://opensource.org/licenses/BSD-2-Clause): + +---------------------------------------------------------------------------- +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +- Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + +- Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +---------------------------------------------------------------------------- +*/ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "fmi3PlatformTypes.h" +#include "fmi3FunctionTypes.h" +#include + +/* +Allow override of FMI3_FUNCTION_PREFIX: If FMI3_OVERRIDE_FUNCTION_PREFIX +is defined, then FMI3_ACTUAL_FUNCTION_PREFIX will be used, if defined, +or no prefix if undefined. Otherwise FMI3_FUNCTION_PREFIX will be used, +if defined. +*/ +#if !defined(FMI3_OVERRIDE_FUNCTION_PREFIX) && defined(FMI3_FUNCTION_PREFIX) + #define FMI3_ACTUAL_FUNCTION_PREFIX FMI3_FUNCTION_PREFIX +#endif + +/* +Export FMI3 API functions on Windows and under GCC. +If custom linking is desired then the FMI3_Export must be +defined before including this file. For instance, +it may be set to __declspec(dllimport). +*/ +#if !defined(FMI3_Export) + #if !defined(FMI3_ACTUAL_FUNCTION_PREFIX) + #if defined _WIN32 || defined __CYGWIN__ + /* Note: both gcc & MSVC on Windows support this syntax. */ + #define FMI3_Export __declspec(dllexport) + #else + #if __GNUC__ >= 4 + #define FMI3_Export __attribute__ ((visibility ("default"))) + #else + #define FMI3_Export + #endif + #endif + #else + #define FMI3_Export + #endif +#endif + +/* Macros to construct the real function name (prepend function name by FMI3_FUNCTION_PREFIX) */ +#if defined(FMI3_ACTUAL_FUNCTION_PREFIX) + #define fmi3Paste(a,b) a ## b + #define fmi3PasteB(a,b) fmi3Paste(a,b) + #define fmi3FullName(name) fmi3PasteB(FMI3_ACTUAL_FUNCTION_PREFIX, name) +#else + #define fmi3FullName(name) name +#endif + +/* FMI version */ +#define fmi3Version "3.0" + +/*************************************************** +Common Functions +****************************************************/ + +/* Inquire version numbers and set debug logging */ +#define fmi3GetVersion fmi3FullName(fmi3GetVersion) +#define fmi3SetDebugLogging fmi3FullName(fmi3SetDebugLogging) + +/* Creation and destruction of FMU instances */ +#define fmi3InstantiateModelExchange fmi3FullName(fmi3InstantiateModelExchange) +#define fmi3InstantiateCoSimulation fmi3FullName(fmi3InstantiateCoSimulation) +#define fmi3InstantiateScheduledExecution fmi3FullName(fmi3InstantiateScheduledExecution) +#define fmi3FreeInstance fmi3FullName(fmi3FreeInstance) + +/* Enter and exit initialization mode, terminate and reset */ +#define fmi3EnterInitializationMode fmi3FullName(fmi3EnterInitializationMode) +#define fmi3ExitInitializationMode fmi3FullName(fmi3ExitInitializationMode) +#define fmi3EnterEventMode fmi3FullName(fmi3EnterEventMode) +#define fmi3Terminate fmi3FullName(fmi3Terminate) +#define fmi3Reset fmi3FullName(fmi3Reset) + +/* Getting and setting variable values */ +#define fmi3GetFloat32 fmi3FullName(fmi3GetFloat32) +#define fmi3GetFloat64 fmi3FullName(fmi3GetFloat64) +#define fmi3GetInt8 fmi3FullName(fmi3GetInt8) +#define fmi3GetUInt8 fmi3FullName(fmi3GetUInt8) +#define fmi3GetInt16 fmi3FullName(fmi3GetInt16) +#define fmi3GetUInt16 fmi3FullName(fmi3GetUInt16) +#define fmi3GetInt32 fmi3FullName(fmi3GetInt32) +#define fmi3GetUInt32 fmi3FullName(fmi3GetUInt32) +#define fmi3GetInt64 fmi3FullName(fmi3GetInt64) +#define fmi3GetUInt64 fmi3FullName(fmi3GetUInt64) +#define fmi3GetBoolean fmi3FullName(fmi3GetBoolean) +#define fmi3GetString fmi3FullName(fmi3GetString) +#define fmi3GetBinary fmi3FullName(fmi3GetBinary) +#define fmi3GetClock fmi3FullName(fmi3GetClock) +#define fmi3SetFloat32 fmi3FullName(fmi3SetFloat32) +#define fmi3SetFloat64 fmi3FullName(fmi3SetFloat64) +#define fmi3SetInt8 fmi3FullName(fmi3SetInt8) +#define fmi3SetUInt8 fmi3FullName(fmi3SetUInt8) +#define fmi3SetInt16 fmi3FullName(fmi3SetInt16) +#define fmi3SetUInt16 fmi3FullName(fmi3SetUInt16) +#define fmi3SetInt32 fmi3FullName(fmi3SetInt32) +#define fmi3SetUInt32 fmi3FullName(fmi3SetUInt32) +#define fmi3SetInt64 fmi3FullName(fmi3SetInt64) +#define fmi3SetUInt64 fmi3FullName(fmi3SetUInt64) +#define fmi3SetBoolean fmi3FullName(fmi3SetBoolean) +#define fmi3SetString fmi3FullName(fmi3SetString) +#define fmi3SetBinary fmi3FullName(fmi3SetBinary) +#define fmi3SetClock fmi3FullName(fmi3SetClock) + +/* Getting Variable Dependency Information */ +#define fmi3GetNumberOfVariableDependencies fmi3FullName(fmi3GetNumberOfVariableDependencies) +#define fmi3GetVariableDependencies fmi3FullName(fmi3GetVariableDependencies) + +/* Getting and setting the internal FMU state */ +#define fmi3GetFMUState fmi3FullName(fmi3GetFMUState) +#define fmi3SetFMUState fmi3FullName(fmi3SetFMUState) +#define fmi3FreeFMUState fmi3FullName(fmi3FreeFMUState) +#define fmi3SerializedFMUStateSize fmi3FullName(fmi3SerializedFMUStateSize) +#define fmi3SerializeFMUState fmi3FullName(fmi3SerializeFMUState) +#define fmi3DeserializeFMUState fmi3FullName(fmi3DeserializeFMUState) + +/* Getting partial derivatives */ +#define fmi3GetDirectionalDerivative fmi3FullName(fmi3GetDirectionalDerivative) +#define fmi3GetAdjointDerivative fmi3FullName(fmi3GetAdjointDerivative) + +/* Entering and exiting the Configuration or Reconfiguration Mode */ +#define fmi3EnterConfigurationMode fmi3FullName(fmi3EnterConfigurationMode) +#define fmi3ExitConfigurationMode fmi3FullName(fmi3ExitConfigurationMode) + +/* Clock related functions */ +#define fmi3GetIntervalDecimal fmi3FullName(fmi3GetIntervalDecimal) +#define fmi3GetIntervalFraction fmi3FullName(fmi3GetIntervalFraction) +#define fmi3GetShiftDecimal fmi3FullName(fmi3GetShiftDecimal) +#define fmi3GetShiftFraction fmi3FullName(fmi3GetShiftFraction) +#define fmi3SetIntervalDecimal fmi3FullName(fmi3SetIntervalDecimal) +#define fmi3SetIntervalFraction fmi3FullName(fmi3SetIntervalFraction) +#define fmi3SetShiftDecimal fmi3FullName(fmi3SetShiftDecimal) +#define fmi3SetShiftFraction fmi3FullName(fmi3SetShiftFraction) +#define fmi3EvaluateDiscreteStates fmi3FullName(fmi3EvaluateDiscreteStates) +#define fmi3UpdateDiscreteStates fmi3FullName(fmi3UpdateDiscreteStates) + +/*************************************************** +Functions for Model Exchange +****************************************************/ + +#define fmi3EnterContinuousTimeMode fmi3FullName(fmi3EnterContinuousTimeMode) +#define fmi3CompletedIntegratorStep fmi3FullName(fmi3CompletedIntegratorStep) + +/* Providing independent variables and re-initialization of caching */ +#define fmi3SetTime fmi3FullName(fmi3SetTime) +#define fmi3SetContinuousStates fmi3FullName(fmi3SetContinuousStates) + +/* Evaluation of the model equations */ +#define fmi3GetContinuousStateDerivatives fmi3FullName(fmi3GetContinuousStateDerivatives) +#define fmi3GetEventIndicators fmi3FullName(fmi3GetEventIndicators) +#define fmi3GetContinuousStates fmi3FullName(fmi3GetContinuousStates) +#define fmi3GetNominalsOfContinuousStates fmi3FullName(fmi3GetNominalsOfContinuousStates) +#define fmi3GetNumberOfEventIndicators fmi3FullName(fmi3GetNumberOfEventIndicators) +#define fmi3GetNumberOfContinuousStates fmi3FullName(fmi3GetNumberOfContinuousStates) + +/*************************************************** +Functions for Co-Simulation +****************************************************/ + +/* Simulating the FMU */ +#define fmi3EnterStepMode fmi3FullName(fmi3EnterStepMode) +#define fmi3GetOutputDerivatives fmi3FullName(fmi3GetOutputDerivatives) +#define fmi3DoStep fmi3FullName(fmi3DoStep) +#define fmi3ActivateModelPartition fmi3FullName(fmi3ActivateModelPartition) + +/*************************************************** +Common Functions +****************************************************/ + +/* Inquire version numbers and set debug logging */ +FMI3_Export fmi3GetVersionTYPE fmi3GetVersion; +FMI3_Export fmi3SetDebugLoggingTYPE fmi3SetDebugLogging; + +/* Creation and destruction of FMU instances */ +FMI3_Export fmi3InstantiateModelExchangeTYPE fmi3InstantiateModelExchange; +FMI3_Export fmi3InstantiateCoSimulationTYPE fmi3InstantiateCoSimulation; +FMI3_Export fmi3InstantiateScheduledExecutionTYPE fmi3InstantiateScheduledExecution; +FMI3_Export fmi3FreeInstanceTYPE fmi3FreeInstance; + +/* Enter and exit initialization mode, terminate and reset */ +FMI3_Export fmi3EnterInitializationModeTYPE fmi3EnterInitializationMode; +FMI3_Export fmi3ExitInitializationModeTYPE fmi3ExitInitializationMode; +FMI3_Export fmi3EnterEventModeTYPE fmi3EnterEventMode; +FMI3_Export fmi3TerminateTYPE fmi3Terminate; +FMI3_Export fmi3ResetTYPE fmi3Reset; + +/* Getting and setting variables values */ +FMI3_Export fmi3GetFloat32TYPE fmi3GetFloat32; +FMI3_Export fmi3GetFloat64TYPE fmi3GetFloat64; +FMI3_Export fmi3GetInt8TYPE fmi3GetInt8; +FMI3_Export fmi3GetUInt8TYPE fmi3GetUInt8; +FMI3_Export fmi3GetInt16TYPE fmi3GetInt16; +FMI3_Export fmi3GetUInt16TYPE fmi3GetUInt16; +FMI3_Export fmi3GetInt32TYPE fmi3GetInt32; +FMI3_Export fmi3GetUInt32TYPE fmi3GetUInt32; +FMI3_Export fmi3GetInt64TYPE fmi3GetInt64; +FMI3_Export fmi3GetUInt64TYPE fmi3GetUInt64; +FMI3_Export fmi3GetBooleanTYPE fmi3GetBoolean; +FMI3_Export fmi3GetStringTYPE fmi3GetString; +FMI3_Export fmi3GetBinaryTYPE fmi3GetBinary; +FMI3_Export fmi3GetClockTYPE fmi3GetClock; +FMI3_Export fmi3SetFloat32TYPE fmi3SetFloat32; +FMI3_Export fmi3SetFloat64TYPE fmi3SetFloat64; +FMI3_Export fmi3SetInt8TYPE fmi3SetInt8; +FMI3_Export fmi3SetUInt8TYPE fmi3SetUInt8; +FMI3_Export fmi3SetInt16TYPE fmi3SetInt16; +FMI3_Export fmi3SetUInt16TYPE fmi3SetUInt16; +FMI3_Export fmi3SetInt32TYPE fmi3SetInt32; +FMI3_Export fmi3SetUInt32TYPE fmi3SetUInt32; +FMI3_Export fmi3SetInt64TYPE fmi3SetInt64; +FMI3_Export fmi3SetUInt64TYPE fmi3SetUInt64; +FMI3_Export fmi3SetBooleanTYPE fmi3SetBoolean; +FMI3_Export fmi3SetStringTYPE fmi3SetString; +FMI3_Export fmi3SetBinaryTYPE fmi3SetBinary; +FMI3_Export fmi3SetClockTYPE fmi3SetClock; + +/* Getting Variable Dependency Information */ +FMI3_Export fmi3GetNumberOfVariableDependenciesTYPE fmi3GetNumberOfVariableDependencies; +FMI3_Export fmi3GetVariableDependenciesTYPE fmi3GetVariableDependencies; + +/* Getting and setting the internal FMU state */ +FMI3_Export fmi3GetFMUStateTYPE fmi3GetFMUState; +FMI3_Export fmi3SetFMUStateTYPE fmi3SetFMUState; +FMI3_Export fmi3FreeFMUStateTYPE fmi3FreeFMUState; +FMI3_Export fmi3SerializedFMUStateSizeTYPE fmi3SerializedFMUStateSize; +FMI3_Export fmi3SerializeFMUStateTYPE fmi3SerializeFMUState; +FMI3_Export fmi3DeserializeFMUStateTYPE fmi3DeserializeFMUState; + +/* Getting partial derivatives */ +FMI3_Export fmi3GetDirectionalDerivativeTYPE fmi3GetDirectionalDerivative; +FMI3_Export fmi3GetAdjointDerivativeTYPE fmi3GetAdjointDerivative; + +/* Entering and exiting the Configuration or Reconfiguration Mode */ +FMI3_Export fmi3EnterConfigurationModeTYPE fmi3EnterConfigurationMode; +FMI3_Export fmi3ExitConfigurationModeTYPE fmi3ExitConfigurationMode; + +/* Clock related functions */ +FMI3_Export fmi3GetIntervalDecimalTYPE fmi3GetIntervalDecimal; +FMI3_Export fmi3GetIntervalFractionTYPE fmi3GetIntervalFraction; +FMI3_Export fmi3GetShiftDecimalTYPE fmi3GetShiftDecimal; +FMI3_Export fmi3GetShiftFractionTYPE fmi3GetShiftFraction; +FMI3_Export fmi3SetIntervalDecimalTYPE fmi3SetIntervalDecimal; +FMI3_Export fmi3SetIntervalFractionTYPE fmi3SetIntervalFraction; +FMI3_Export fmi3SetShiftDecimalTYPE fmi3SetShiftDecimal; +FMI3_Export fmi3SetShiftFractionTYPE fmi3SetShiftFraction; +FMI3_Export fmi3EvaluateDiscreteStatesTYPE fmi3EvaluateDiscreteStates; +FMI3_Export fmi3UpdateDiscreteStatesTYPE fmi3UpdateDiscreteStates; + +/*************************************************** +Functions for Model Exchange +****************************************************/ + +FMI3_Export fmi3EnterContinuousTimeModeTYPE fmi3EnterContinuousTimeMode; +FMI3_Export fmi3CompletedIntegratorStepTYPE fmi3CompletedIntegratorStep; + +/* Providing independent variables and re-initialization of caching */ +/* tag::SetTimeTYPE[] */ +FMI3_Export fmi3SetTimeTYPE fmi3SetTime; +/* end::SetTimeTYPE[] */ +FMI3_Export fmi3SetContinuousStatesTYPE fmi3SetContinuousStates; + +/* Evaluation of the model equations */ +FMI3_Export fmi3GetContinuousStateDerivativesTYPE fmi3GetContinuousStateDerivatives; +FMI3_Export fmi3GetEventIndicatorsTYPE fmi3GetEventIndicators; +FMI3_Export fmi3GetContinuousStatesTYPE fmi3GetContinuousStates; +FMI3_Export fmi3GetNominalsOfContinuousStatesTYPE fmi3GetNominalsOfContinuousStates; +FMI3_Export fmi3GetNumberOfEventIndicatorsTYPE fmi3GetNumberOfEventIndicators; +FMI3_Export fmi3GetNumberOfContinuousStatesTYPE fmi3GetNumberOfContinuousStates; + +/*************************************************** +Functions for Co-Simulation +****************************************************/ + +/* Simulating the FMU */ +FMI3_Export fmi3EnterStepModeTYPE fmi3EnterStepMode; +FMI3_Export fmi3GetOutputDerivativesTYPE fmi3GetOutputDerivatives; +FMI3_Export fmi3DoStepTYPE fmi3DoStep; + +/*************************************************** +Functions for Scheduled Execution +****************************************************/ + +FMI3_Export fmi3ActivateModelPartitionTYPE fmi3ActivateModelPartition; + +#ifdef __cplusplus +} /* end of extern "C" { */ +#endif + +#endif /* fmi3Functions_h */ diff --git a/notebooks/fmi3PlatformTypes.h b/notebooks/fmi3PlatformTypes.h new file mode 100644 index 0000000..18ecb39 --- /dev/null +++ b/notebooks/fmi3PlatformTypes.h @@ -0,0 +1,94 @@ +#ifndef fmi3PlatformTypes_h +#define fmi3PlatformTypes_h + +/* +This header file defines the data types of FMI 3.0. +It must be used by both FMU and FMI master. + +Copyright (C) 2008-2011 MODELISAR consortium, + 2012-2022 Modelica Association Project "FMI" + All rights reserved. + +This file is licensed by the copyright holders under the 2-Clause BSD License +(https://opensource.org/licenses/BSD-2-Clause): + +---------------------------------------------------------------------------- +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +- Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + +- Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +---------------------------------------------------------------------------- +*/ + +/* Include the integer and boolean type definitions */ +#include +#include + + +/* tag::Component[] */ +typedef void* fmi3Instance; /* Pointer to the FMU instance */ +/* end::Component[] */ + +/* tag::ComponentEnvironment[] */ +typedef void* fmi3InstanceEnvironment; /* Pointer to the FMU environment */ +/* end::ComponentEnvironment[] */ + +/* tag::FMUState[] */ +typedef void* fmi3FMUState; /* Pointer to the internal FMU state */ +/* end::FMUState[] */ + +/* tag::ValueReference[] */ +typedef uint32_t fmi3ValueReference; /* Handle to the value of a variable */ +/* end::ValueReference[] */ + +/* tag::VariableTypes[] */ +typedef float fmi3Float32; /* Single precision floating point (32-bit) */ +/* tag::fmi3Float64[] */ +typedef double fmi3Float64; /* Double precision floating point (64-bit) */ +/* end::fmi3Float64[] */ +typedef int8_t fmi3Int8; /* 8-bit signed integer */ +typedef uint8_t fmi3UInt8; /* 8-bit unsigned integer */ +typedef int16_t fmi3Int16; /* 16-bit signed integer */ +typedef uint16_t fmi3UInt16; /* 16-bit unsigned integer */ +typedef int32_t fmi3Int32; /* 32-bit signed integer */ +typedef uint32_t fmi3UInt32; /* 32-bit unsigned integer */ +typedef int64_t fmi3Int64; /* 64-bit signed integer */ +typedef uint64_t fmi3UInt64; /* 64-bit unsigned integer */ +typedef bool fmi3Boolean; /* Data type to be used with fmi3True and fmi3False */ +typedef char fmi3Char; /* Data type for one character */ +typedef const fmi3Char* fmi3String; /* Data type for character strings + ('\0' terminated, UTF-8 encoded) */ +typedef uint8_t fmi3Byte; /* Smallest addressable unit of the machine + (typically one byte) */ +typedef const fmi3Byte* fmi3Binary; /* Data type for binary data + (out-of-band length terminated) */ +typedef bool fmi3Clock; /* Data type to be used with fmi3ClockActive and + fmi3ClockInactive */ + +/* Values for fmi3Boolean */ +#define fmi3True true +#define fmi3False false + +/* Values for fmi3Clock */ +#define fmi3ClockActive true +#define fmi3ClockInactive false +/* end::VariableTypes[] */ + +#endif /* fmi3PlatformTypes_h */ diff --git a/notebooks/notebook.ipynb b/notebooks/notebook.ipynb index 0c2c01d..fa5f270 100644 --- a/notebooks/notebook.ipynb +++ b/notebooks/notebook.ipynb @@ -1,66 +1,823 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [], - "toc_visible": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, "cells": [ { "cell_type": "markdown", + "metadata": { + "id": "hBbvkLyaDH50" + }, "source": [ "**The next Paradigm for Modelling and Simulation?**\n", "\n", "Integrating Scientific Machine Learning Methods in Co-Simulation Environments" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: numpy in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (1.25.1)\n", + "Requirement already satisfied: matplotlib in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (3.7.2)\n", + "Requirement already satisfied: jupyterlab in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (4.0.3)\n", + "Requirement already satisfied: ipykernel in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (6.25.0)\n", + "Collecting tqdm\n", + " Using cached tqdm-4.65.0-py3-none-any.whl (77 kB)\n", + "Requirement already satisfied: jax[cpu] in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (0.4.14)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from matplotlib) (1.1.0)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from matplotlib) (4.41.1)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from matplotlib) (2.8.2)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from matplotlib) (1.4.4)\n", + "Requirement already satisfied: cycler>=0.10 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from matplotlib) (0.11.0)\n", + "Requirement already satisfied: packaging>=20.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from matplotlib) (23.1)\n", + "Requirement already satisfied: pillow>=6.2.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from matplotlib) (10.0.0)\n", + "Requirement already satisfied: pyparsing<3.1,>=2.3.1 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from matplotlib) (3.0.9)\n", + "Requirement already satisfied: traitlets in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyterlab) (5.9.0)\n", + "Requirement already satisfied: jupyter-lsp>=2.0.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyterlab) (2.2.0)\n", + "Requirement already satisfied: jupyter-server<3,>=2.4.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyterlab) (2.7.0)\n", + "Requirement already satisfied: tornado>=6.2.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyterlab) (6.3.2)\n", + "Requirement already satisfied: async-lru>=1.0.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyterlab) (2.0.4)\n", + "Requirement already satisfied: jupyter-core in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyterlab) (5.3.1)\n", + "Requirement already satisfied: jupyterlab-server<3,>=2.19.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyterlab) (2.24.0)\n", + "Requirement already satisfied: jinja2>=3.0.3 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyterlab) (3.1.2)\n", + "Requirement already satisfied: tomli in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyterlab) (2.0.1)\n", + "Requirement already satisfied: notebook-shim>=0.2 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyterlab) (0.2.3)\n", + "Requirement already satisfied: jupyter-client>=6.1.12 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from ipykernel) (8.3.0)\n", + "Requirement already satisfied: pyzmq>=20 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from ipykernel) (25.1.0)\n", + "Requirement already satisfied: psutil in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from ipykernel) (5.9.5)\n", + "Requirement already satisfied: ipython>=7.23.1 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from ipykernel) (8.14.0)\n", + "Requirement already satisfied: debugpy>=1.6.5 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from ipykernel) (1.6.7)\n", + "Requirement already satisfied: comm>=0.1.1 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from ipykernel) (0.1.3)\n", + "Requirement already satisfied: matplotlib-inline>=0.1 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from ipykernel) (0.1.6)\n", + "Requirement already satisfied: nest-asyncio in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from ipykernel) (1.5.7)\n", + "Requirement already satisfied: ml-dtypes>=0.2.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jax[cpu]) (0.2.0)\n", + "Requirement already satisfied: opt-einsum in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jax[cpu]) (3.3.0)\n", + "Requirement already satisfied: scipy>=1.7 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jax[cpu]) (1.11.1)\n", + "Requirement already satisfied: jaxlib==0.4.14 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jax[cpu]) (0.4.14)\n", + "Requirement already satisfied: typing-extensions>=4.0.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from async-lru>=1.0.0->jupyterlab) (4.7.1)\n", + "Requirement already satisfied: pygments>=2.4.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from ipython>=7.23.1->ipykernel) (2.15.1)\n", + "Requirement already satisfied: pexpect>4.3 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from ipython>=7.23.1->ipykernel) (4.8.0)\n", + "Requirement already satisfied: jedi>=0.16 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from ipython>=7.23.1->ipykernel) (0.19.0)\n", + "Requirement already satisfied: prompt-toolkit!=3.0.37,<3.1.0,>=3.0.30 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from ipython>=7.23.1->ipykernel) (3.0.39)\n", + "Requirement already satisfied: decorator in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from ipython>=7.23.1->ipykernel) (5.1.1)\n", + "Requirement already satisfied: pickleshare in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from ipython>=7.23.1->ipykernel) (0.7.5)\n", + "Requirement already satisfied: backcall in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from ipython>=7.23.1->ipykernel) (0.2.0)\n", + "Requirement already satisfied: stack-data in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from ipython>=7.23.1->ipykernel) (0.6.2)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jinja2>=3.0.3->jupyterlab) (2.1.3)\n", + "Requirement already satisfied: platformdirs>=2.5 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyter-core->jupyterlab) (3.10.0)\n", + "Requirement already satisfied: terminado>=0.8.3 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyter-server<3,>=2.4.0->jupyterlab) (0.17.1)\n", + "Requirement already satisfied: overrides in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyter-server<3,>=2.4.0->jupyterlab) (7.3.1)\n", + "Requirement already satisfied: nbconvert>=6.4.4 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyter-server<3,>=2.4.0->jupyterlab) (7.7.3)\n", + "Requirement already satisfied: anyio>=3.1.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyter-server<3,>=2.4.0->jupyterlab) (3.7.1)\n", + "Requirement already satisfied: jupyter-events>=0.6.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyter-server<3,>=2.4.0->jupyterlab) (0.6.3)\n", + "Requirement already satisfied: send2trash in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyter-server<3,>=2.4.0->jupyterlab) (1.8.2)\n", + "Requirement already satisfied: nbformat>=5.3.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyter-server<3,>=2.4.0->jupyterlab) (5.9.1)\n", + "Requirement already satisfied: jupyter-server-terminals in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyter-server<3,>=2.4.0->jupyterlab) (0.4.4)\n", + "Requirement already satisfied: prometheus-client in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyter-server<3,>=2.4.0->jupyterlab) (0.17.1)\n", + "Requirement already satisfied: argon2-cffi in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyter-server<3,>=2.4.0->jupyterlab) (21.3.0)\n", + "Requirement already satisfied: websocket-client in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyter-server<3,>=2.4.0->jupyterlab) (1.6.1)\n", + "Requirement already satisfied: requests>=2.28 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyterlab-server<3,>=2.19.0->jupyterlab) (2.31.0)\n", + "Requirement already satisfied: json5>=0.9.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyterlab-server<3,>=2.19.0->jupyterlab) (0.9.14)\n", + "Requirement already satisfied: babel>=2.10 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyterlab-server<3,>=2.19.0->jupyterlab) (2.12.1)\n", + "Requirement already satisfied: jsonschema>=4.17.3 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyterlab-server<3,>=2.19.0->jupyterlab) (4.18.4)\n", + "Requirement already satisfied: six>=1.5 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n", + "Requirement already satisfied: exceptiongroup in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from anyio>=3.1.0->jupyter-server<3,>=2.4.0->jupyterlab) (1.1.2)\n", + "Requirement already satisfied: idna>=2.8 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from anyio>=3.1.0->jupyter-server<3,>=2.4.0->jupyterlab) (3.4)\n", + "Requirement already satisfied: sniffio>=1.1 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from anyio>=3.1.0->jupyter-server<3,>=2.4.0->jupyterlab) (1.3.0)\n", + "Requirement already satisfied: parso<0.9.0,>=0.8.3 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jedi>=0.16->ipython>=7.23.1->ipykernel) (0.8.3)\n", + "Requirement already satisfied: referencing>=0.28.4 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jsonschema>=4.17.3->jupyterlab-server<3,>=2.19.0->jupyterlab) (0.30.0)\n", + "Requirement already satisfied: attrs>=22.2.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jsonschema>=4.17.3->jupyterlab-server<3,>=2.19.0->jupyterlab) (23.1.0)\n", + "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jsonschema>=4.17.3->jupyterlab-server<3,>=2.19.0->jupyterlab) (2023.7.1)\n", + "Requirement already satisfied: rpds-py>=0.7.1 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jsonschema>=4.17.3->jupyterlab-server<3,>=2.19.0->jupyterlab) (0.9.2)\n", + "Requirement already satisfied: rfc3339-validator in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyter-events>=0.6.0->jupyter-server<3,>=2.4.0->jupyterlab) (0.1.4)\n", + "Requirement already satisfied: pyyaml>=5.3 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyter-events>=0.6.0->jupyter-server<3,>=2.4.0->jupyterlab) (6.0.1)\n", + "Requirement already satisfied: python-json-logger>=2.0.4 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyter-events>=0.6.0->jupyter-server<3,>=2.4.0->jupyterlab) (2.0.7)\n", + "Requirement already satisfied: rfc3986-validator>=0.1.1 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jupyter-events>=0.6.0->jupyter-server<3,>=2.4.0->jupyterlab) (0.1.1)\n", + "Requirement already satisfied: defusedxml in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->jupyterlab) (0.7.1)\n", + "Requirement already satisfied: tinycss2 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->jupyterlab) (1.2.1)\n", + "Requirement already satisfied: bleach!=5.0.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->jupyterlab) (6.0.0)\n", + "Requirement already satisfied: pandocfilters>=1.4.1 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->jupyterlab) (1.5.0)\n", + "Requirement already satisfied: nbclient>=0.5.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->jupyterlab) (0.8.0)\n", + "Requirement already satisfied: beautifulsoup4 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->jupyterlab) (4.12.2)\n", + "Requirement already satisfied: jupyterlab-pygments in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->jupyterlab) (0.2.2)\n", + "Requirement already satisfied: mistune<4,>=2.0.3 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->jupyterlab) (3.0.1)\n", + "Requirement already satisfied: fastjsonschema in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from nbformat>=5.3.0->jupyter-server<3,>=2.4.0->jupyterlab) (2.18.0)\n", + "Requirement already satisfied: ptyprocess>=0.5 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from pexpect>4.3->ipython>=7.23.1->ipykernel) (0.7.0)\n", + "Requirement already satisfied: wcwidth in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from prompt-toolkit!=3.0.37,<3.1.0,>=3.0.30->ipython>=7.23.1->ipykernel) (0.2.6)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from requests>=2.28->jupyterlab-server<3,>=2.19.0->jupyterlab) (2023.7.22)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from requests>=2.28->jupyterlab-server<3,>=2.19.0->jupyterlab) (2.0.4)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from requests>=2.28->jupyterlab-server<3,>=2.19.0->jupyterlab) (3.2.0)\n", + "Requirement already satisfied: argon2-cffi-bindings in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from argon2-cffi->jupyter-server<3,>=2.4.0->jupyterlab) (21.2.0)\n", + "Requirement already satisfied: executing>=1.2.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from stack-data->ipython>=7.23.1->ipykernel) (1.2.0)\n", + "Requirement already satisfied: asttokens>=2.1.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from stack-data->ipython>=7.23.1->ipykernel) (2.2.1)\n", + "Requirement already satisfied: pure-eval in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from stack-data->ipython>=7.23.1->ipykernel) (0.2.2)\n", + "Requirement already satisfied: webencodings in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from bleach!=5.0.0->nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->jupyterlab) (0.5.1)\n", + "Requirement already satisfied: jsonpointer>1.13 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jsonschema>=4.17.3->jupyterlab-server<3,>=2.19.0->jupyterlab) (2.4)\n", + "Requirement already satisfied: isoduration in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jsonschema>=4.17.3->jupyterlab-server<3,>=2.19.0->jupyterlab) (20.11.0)\n", + "Requirement already satisfied: fqdn in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jsonschema>=4.17.3->jupyterlab-server<3,>=2.19.0->jupyterlab) (1.5.1)\n", + "Requirement already satisfied: uri-template in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jsonschema>=4.17.3->jupyterlab-server<3,>=2.19.0->jupyterlab) (1.3.0)\n", + "Requirement already satisfied: webcolors>=1.11 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from jsonschema>=4.17.3->jupyterlab-server<3,>=2.19.0->jupyterlab) (1.13)\n", + "Requirement already satisfied: cffi>=1.0.1 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from argon2-cffi-bindings->argon2-cffi->jupyter-server<3,>=2.4.0->jupyterlab) (1.15.1)\n", + "Requirement already satisfied: soupsieve>1.2 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from beautifulsoup4->nbconvert>=6.4.4->jupyter-server<3,>=2.4.0->jupyterlab) (2.4.1)\n", + "Requirement already satisfied: pycparser in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from cffi>=1.0.1->argon2-cffi-bindings->argon2-cffi->jupyter-server<3,>=2.4.0->jupyterlab) (2.21)\n", + "Requirement already satisfied: arrow>=0.15.0 in /home/clegaard/Desktop/repos/phd_thesis_supplemental_code/venv/lib/python3.10/site-packages (from isoduration->jsonschema>=4.17.3->jupyterlab-server<3,>=2.19.0->jupyterlab) (1.2.3)\n", + "Installing collected packages: tqdm\n", + "Successfully installed tqdm-4.65.0\n" + ] + } ], - "metadata": { - "id": "hBbvkLyaDH50" - } + "source": [ + "!python3 -m pip install numpy matplotlib jupyterlab ipykernel tqdm 'jax[cpu]'" + ] }, { "cell_type": "markdown", + "metadata": { + "id": "05ugIzByDdea" + }, "source": [ "# 2. Modeling and Simulation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Numerical Simulation using Euler and Midpoint" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } ], - "metadata": { - "id": "05ugIzByDdea" - } + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import sys\n", + "\n", + "\n", + "def pendulum_ideal(x):\n", + " g = 1.0 # gravity\n", + " l = 1.0 # pendulum arm length\n", + " θ, ω = x\n", + "\n", + " dθdt = ω\n", + " dωdt = -(g / l) * np.sin(θ)\n", + " return np.array((dθdt, dωdt))\n", + "\n", + "\n", + "def run_pendulum_solver():\n", + " step_size_reference = 0.00001\n", + " step_size = 0.1\n", + "\n", + " t_start = 0.0\n", + " t_end = 4 * np.pi\n", + "\n", + " # simulate reference\n", + " t_reference = np.arange(t_start, t_end + step_size_reference, step_size_reference)\n", + " x_cur = np.array((np.pi / 4, 00)) # initial state\n", + " xs_reference = [x_cur]\n", + "\n", + " for _ in t_reference[1:]:\n", + " x_new = x_cur + step_size_reference * pendulum_ideal(x_cur)\n", + " xs_reference.append(x_new)\n", + " x_cur = x_new\n", + "\n", + " xs_reference = np.stack(xs_reference, axis=1) # (n_states, n_steps)\n", + "\n", + " # simulate Euler\n", + " t = np.arange(t_start, t_end + step_size, step_size)\n", + "\n", + " x_cur = np.array((np.pi / 4, 00)) # initial state\n", + " xs_euler = [x_cur]\n", + "\n", + " for _ in t[1:]:\n", + " x_new = x_cur + step_size * pendulum_ideal(x_cur)\n", + " xs_euler.append(x_new)\n", + " x_cur = x_new\n", + "\n", + " xs_euler = np.stack(xs_euler, axis=1) # (n_states, n_steps)\n", + "\n", + " # simulate midpoint\n", + "\n", + " x_cur = np.array((np.pi / 4, 00)) # initial state\n", + " xs_midpoint = [x_cur]\n", + "\n", + " for _ in t[1:]:\n", + " x_new = x_cur + step_size * pendulum_ideal(\n", + " x_cur + step_size / 2 * pendulum_ideal(x_cur)\n", + " )\n", + " xs_midpoint.append(x_new)\n", + " x_cur = x_new\n", + "\n", + " xs_midpoint = np.stack(xs_midpoint, axis=1) # (n_states, n_steps)\n", + "\n", + " # plotting\n", + "\n", + " fig, (ax1, ax2) = plt.subplots(2, sharex=True)\n", + "\n", + " ax1.plot(\n", + " t_reference,\n", + " xs_reference[0],\n", + " label=f\"FE (step-size = {step_size_reference})\",\n", + " c=\"black\",\n", + " linewidth=2,\n", + " )\n", + " ax1.plot(\n", + " t,\n", + " xs_euler[0],\n", + " label=f\"FE (step-size = {step_size})\",\n", + " c=\"blue\",\n", + " linestyle=\"dotted\",\n", + " linewidth=2,\n", + " )\n", + " ax1.plot(\n", + " t,\n", + " xs_midpoint[0],\n", + " label=f\"MID (step-size = {step_size})\",\n", + " c=\"red\",\n", + " linestyle=\"dotted\",\n", + " linewidth=2,\n", + " )\n", + " ax1.set_ylabel(rf\"$\\theta$ [rad]\")\n", + " ax2.plot(t_reference, xs_reference[1], label=\"reference\", c=\"black\", linewidth=2)\n", + " ax2.plot(\n", + " t,\n", + " xs_euler[1],\n", + " c=\"blue\",\n", + " linestyle=\"dotted\",\n", + " linewidth=2,\n", + " )\n", + " ax2.plot(\n", + " t,\n", + " xs_midpoint[1],\n", + " c=\"red\",\n", + " linestyle=\"dotted\",\n", + " linewidth=2,\n", + " )\n", + " ax2.set_ylabel(rf\"$\\omega$ [rad/s]\")\n", + " ax2.set_xlabel(\"t [s]\")\n", + " ax1.legend()\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "\n", + "\n", + "run_pendulum_solver()\n" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "# 3. Scientific Machine Learning" + "# Vector Fields and Phase Portraits" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } ], + "source": [ + "def pendulum_friction(x):\n", + " g = 1.0 # gravity\n", + " l = 1.0 # pendulum arm length\n", + " γ = 1.0 # friction co-efficient\n", + " θ, ω = x\n", + "\n", + " dθdt = ω\n", + " dωdt = -(g / l) * np.sin(θ) - γ * ω\n", + " return dθdt, dωdt\n", + "\n", + "\n", + "\n", + "def run_pendulum_phase():\n", + " mesh_step = 0.3\n", + " θ, ω = np.meshgrid(\n", + " np.arange(-np.pi, np.pi + mesh_step, mesh_step),\n", + " np.arange(-np.pi, np.pi + mesh_step, mesh_step),\n", + " )\n", + " θ_wrapped, ω_wrapped = np.meshgrid(\n", + " np.arange(-2 * np.pi, 2 * np.pi + mesh_step, mesh_step),\n", + " np.arange(-2 * np.pi, 2 * np.pi + mesh_step, mesh_step),\n", + " )\n", + "\n", + " dθdt_ideal, dωdt_ideal = pendulum_ideal((θ, ω))\n", + " dθdt_ideal_wrapped, dωdt_ideal_wrapped = pendulum_ideal((θ_wrapped, ω_wrapped))\n", + " dθdt_friction, dωdt_friction = pendulum_friction((θ, ω))\n", + "\n", + " fig, ax = plt.subplots()\n", + " # ax.quiver(θ, ω, dθdt_ideal, dωdt_ideal, angles=\"xy\", scale_units=\"xy\", scale=5)\n", + " ax.streamplot(θ, ω, dθdt_ideal, dωdt_ideal)\n", + " ax.set_xlabel(rf\"$\\theta$\")\n", + " ax.set_ylabel(rf\"$\\omega$\")\n", + " ax.set_title(\"Vector Field: Ideal Pendulum\")\n", + "\n", + " fig, ax = plt.subplots()\n", + " ax.quiver(\n", + " θ_wrapped,\n", + " ω_wrapped,\n", + " dθdt_ideal_wrapped,\n", + " dωdt_ideal_wrapped,\n", + " angles=\"xy\",\n", + " scale_units=\"xy\",\n", + " scale=10,\n", + " )\n", + " ax.set_xlim(-2 * np.pi, 2 * np.pi)\n", + " ax.set_ylim(-np.pi, np.pi)\n", + " ax.set_xlabel(rf\"$\\theta$\")\n", + " ax.set_ylabel(rf\"$\\omega$\")\n", + " ax.set_title(\"Vector Field: Ideal Pendulum\")\n", + "\n", + " fig, ax = plt.subplots()\n", + " # ax.quiver(\n", + " # θ, ω, dθdt_friction, dωdt_friction, angles=\"xy\", scale_units=\"xy\", scale=5\n", + " # )\n", + " ax.streamplot(θ, ω, dθdt_friction, dωdt_friction)\n", + " ax.set_xlabel(rf\"$\\theta$\")\n", + " ax.set_ylabel(rf\"$\\omega$\")\n", + " ax.set_title(\"Vector Field: Pendulum with friction\")\n", + " plt.show()\n", + "\n", + "run_pendulum_phase()" + ] + }, + { + "cell_type": "markdown", "metadata": { "id": "UxJgUxjKDhuX" - } + }, + "source": [ + "# 3. Scientific Machine Learning\n", + "\n", + "For implementation of Physics-informed NNs and Neural Ordinary Differential Equations we refer to the repository:\n", + "\n", + "https://github.com/clegaard/deep_learning_for_dynamical_systems\n" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "# 4. Co-Simulation" + "# Differentiable Simulator" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/10000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } ], + "source": [ + "import jax.numpy as jnp\n", + "from jax import grad, jit, value_and_grad, vmap, random, tree_map\n", + "from jax.lax import scan\n", + "import matplotlib.pyplot as plt\n", + "from tqdm import tqdm\n", + "import numpy as np\n", + "\n", + "key = random.PRNGKey(1)\n", + "\n", + "\n", + "def solve_euler(f, t, y0, *args, **kwargs):\n", + " step_sizes = t[1:] - t[:-1]\n", + " y_cur = y0\n", + " Y = [y_cur]\n", + "\n", + " for t, step_size in zip(t[1:], step_sizes):\n", + " dydt = f(t, y_cur, *args)\n", + " y_new = y_cur + step_size * dydt\n", + " Y.append(y_new)\n", + " y_cur = y_new\n", + "\n", + " return jnp.stack(Y, axis=1)\n", + "\n", + "\n", + "def solve_euler_scan(f, t, y0, *args, **kwargs):\n", + " step_sizes = t[1:] - t[:-1]\n", + "\n", + " def f_scan(y_cur, t_and_step):\n", + " t, step_size = t_and_step\n", + " dydt = f(t, y_cur, *args)\n", + " y_new = y_cur + step_size * dydt\n", + " return y_new, y_new\n", + "\n", + " _, Y = scan(f_scan, init=y0, xs=(t[1:], step_sizes))\n", + " Y = jnp.concatenate((y0.reshape(-1, 1), Y.T), axis=1)\n", + " return Y\n", + "\n", + "\n", + "def f(t, x, params):\n", + " θ, ω = x\n", + " dθdt = ω\n", + " dωdt = -params[\"g\"] / params[\"l\"] * jnp.sin(θ)\n", + " return jnp.array((dθdt, dωdt))\n", + "\n", + "\n", + "def run_parameter_estimation():\n", + " h = 0.001\n", + " t_train_start = 0.0\n", + " t_train_end = h\n", + " t_train = jnp.arange(t_train_start, t_train_end + h, h)\n", + " t_validation_start = t_train_start\n", + " t_validation_end = 4 * jnp.pi\n", + " t_validation = jnp.arange(t_validation_start, t_validation_end + h, h)\n", + "\n", + " x0 = jnp.array((-0.5, 0.0))\n", + "\n", + " solve_euler_scan_grid = vmap(solve_euler_scan, (None, None, 0, None))\n", + "\n", + " res = 0.1\n", + "\n", + " θ_grid, ω_grid = jnp.meshgrid(\n", + " jnp.arange(-jnp.pi, jnp.pi + res, res),\n", + " jnp.arange(-jnp.pi, jnp.pi + res, res),\n", + " )\n", + " θ_grid = θ_grid.reshape(-1)\n", + " ω_grid = ω_grid.reshape(-1)\n", + " x0_grid = jnp.stack((θ_grid, ω_grid), axis=1)\n", + "\n", + " def update(x_target, t, x0, params):\n", + " def loss(params):\n", + " y_predicted = solve_euler_scan(f, t, x0, params)\n", + " return jnp.linalg.norm(x_target - y_predicted)\n", + "\n", + " loss, grads = value_and_grad(loss)(params)\n", + "\n", + " params = tree_map(lambda p, g: p - lr * g, params, grads)\n", + " return loss, params\n", + "\n", + " def update_grid(x_target, t, x0, params):\n", + " def loss(params):\n", + " y_predicted = solve_euler_scan_grid(f, t, x0, params)\n", + " return jnp.linalg.norm(x_target - y_predicted)\n", + "\n", + " loss, grads = value_and_grad(loss)(params)\n", + "\n", + " params = tree_map(lambda p, g: p - lr * g, params, grads)\n", + " return loss, params\n", + "\n", + " parameters_true = {\"g\": 1.0, \"l\": 1.0}\n", + " parameters_estimated = {\"g\": 1.0, \"l\": 0.5}\n", + "\n", + " x_true_grid = solve_euler_scan_grid(f, t_train, x0_grid, parameters_true)\n", + "\n", + " n_epochs = 10000\n", + " lr = 0.001 # learning rate\n", + " losses = []\n", + "\n", + " update = jit(update_grid)\n", + "\n", + " for _ in tqdm(range(n_epochs)):\n", + " # value, parameters_estimated = update(x_true, t, x0, parameters_estimated)\n", + " value, parameters_estimated = update(\n", + " x_true_grid, t_train, x0_grid, parameters_estimated\n", + " )\n", + " losses.append(value)\n", + "\n", + " x_true_validation = solve_euler_scan(f, t_validation, x0, parameters_true)\n", + " x_predicted_validation = solve_euler_scan(f, t_validation, x0, parameters_estimated)\n", + "\n", + " fig, ax = plt.subplots()\n", + " ax.plot(t_validation, x_true_validation[0], label=rf\"$\\theta$\", color=\"blue\")\n", + " ax.plot(t_validation, x_true_validation[1], label=rf\"$\\omega$\", color=\"orange\")\n", + " ax.plot(\n", + " t_validation,\n", + " x_predicted_validation[0],\n", + " label=rf\"$\\hat{{\\theta}}$\",\n", + " color=\"blue\",\n", + " linestyle=\"dotted\",\n", + " )\n", + " ax.plot(\n", + " t_validation,\n", + " x_predicted_validation[1],\n", + " label=rf\"$\\hat{{\\omega}}$\",\n", + " color=\"orange\",\n", + " linestyle=\"dotted\",\n", + " )\n", + " ax.set_xlabel(\"t[s]\")\n", + " ax.set_ylabel(\"x(t)\")\n", + " ax.legend()\n", + " ax.set_title(\n", + " rf\"Pendulum $\\hat{{g}}$={parameters_estimated['g']:.2f},$\\hat{{l}}$={parameters_estimated['l']:.2f}\"\n", + " )\n", + "\n", + " fig, ax = plt.subplots()\n", + " ax.semilogy(losses)\n", + " ax.set_xlabel(\"epoch\")\n", + " _ = ax.set_ylabel(\"loss(epoch)\")\n", + "\n", + " plt.show()\n", + "\n", + "\n", + "\n", + "def run_phase_plot():\n", + " res = 0.1\n", + " g = 1.0\n", + " l = 1.0\n", + " xx, yy = jnp.meshgrid(\n", + " jnp.arange(-jnp.pi, jnp.pi + res, res),\n", + " jnp.arange(-jnp.pi, jnp.pi + res, res),\n", + " )\n", + "\n", + " dx, dy = f((xx, yy), g, l)\n", + "\n", + " fig, ax = plt.subplots()\n", + "\n", + " xx = np.asarray(xx)\n", + " yy = np.asarray(yy)\n", + "\n", + " ax.streamplot(xx, yy, dx, dy)\n", + " ax.set_xlabel(\"θ\")\n", + " ax.set_ylabel(\"ω\")\n", + "\n", + " plt.show()\n", + "\n", + "\n", + "\n", + "run_parameter_estimation()\n" + ] + }, + { + "cell_type": "markdown", "metadata": { "id": "K7YLLtIuDpw9" - } + }, + "source": [ + "# 4. Co-Simulation" + ] }, { "cell_type": "code", - "source": [], + "execution_count": 1, "metadata": { "id": "By7eHENzDd9C" }, - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [ + "import numpy as np\n", + "from numpy import cos\n", + "import matplotlib.pyplot as plt\n", + "from copy import deepcopy\n", + "\n", + "from dataclasses import dataclass\n", + "\n", + "\n", + "class Controller:\n", + " def step(self, communication_step_size, robot: \"Robot\"):\n", + " error = self.θ_setpoint - robot.θ\n", + "\n", + " if self.error_last is not None:\n", + " error_derivative = (self.error_last - error) / communication_step_size\n", + " else:\n", + " error_derivative = 0.0\n", + "\n", + " self.u = (\n", + " self.kp * error + self.ki * self.error_integral + self.kd * error_derivative\n", + " )\n", + " self.error_integral += error * communication_step_size\n", + " self.error_last = error\n", + "\n", + " def __init__(self, kp, ki, kd, θ_setpoint, robot: \"Robot\"):\n", + " error = θ_setpoint - robot.θ\n", + " self.kp = kp\n", + " self.ki = ki\n", + " self.kd = kd\n", + " self.θ_setpoint = θ_setpoint\n", + " self.error_last = error\n", + " self.error_integral = 0.0\n", + " self.u = self.kp * error\n", + "\n", + "\n", + "@dataclass\n", + "class Robot:\n", + " def step(self, communication_step_size, controller: Controller):\n", + " t_elapsed = 0.0\n", + "\n", + " while t_elapsed < communication_step_size:\n", + " dθdt = self.ω\n", + " dωdt = (\n", + " self.K * self.i\n", + " - self.b * self.ω\n", + " - self.m * self.g * self.l * cos(self.θ)\n", + " ) / self.J\n", + " didt = (\n", + " controller.u * self.V_abs - self.R * self.i - self.K * self.ω\n", + " ) / self.L\n", + "\n", + " self.θ = self.θ + self.internal_step_size * dθdt\n", + " self.ω = self.ω + self.internal_step_size * dωdt\n", + " self.i = self.i + self.internal_step_size * didt\n", + "\n", + " t_elapsed += self.internal_step_size\n", + " self._internal_θ = (\n", + " [self.θ] if self._internal_θ is None else self._internal_θ + [self.θ]\n", + " )\n", + "\n", + " if self._internal_t is None:\n", + " self._internal_t = [t_elapsed]\n", + " else:\n", + " self._internal_t = self._internal_t + [\n", + " self._internal_t[-1] + self.internal_step_size\n", + " ]\n", + "\n", + " assert (\n", + " t_elapsed == communication_step_size\n", + " ), f\"unable to step for exactly {communication_step_size} \"\n", + "\n", + " θ: float # angle\n", + " ω: float # velocity\n", + " i: float # current\n", + " V_abs = 12.0\n", + " K = 7.45 # torque coefficient\n", + " g = 9.81 # gravitational acceleration\n", + " b = 5.0 # motor shaft friction\n", + " m = 5.0 # mass of joint\n", + " R = 0.15 # electrical resistance ?\n", + " L = 0.036 # motor inductance\n", + " l = 1.0 # length of joint\n", + " J = 0.5 * (m * l**2) # moment of intertia\n", + " internal_step_size = 1 / 1024\n", + " _internal_θ = None\n", + " _internal_t = None\n", + "\n", + "\n", + "def run_cosim_for(controller: Controller, robot: Robot, t):\n", + " communication_step_sizes = t[1:] - t[:-1]\n", + "\n", + " θs = [robot.θ]\n", + " ts = [0.0]\n", + "\n", + " for communication_step_size in communication_step_sizes:\n", + " controller_cur = deepcopy(controller)\n", + "\n", + " controller.step(communication_step_size, robot)\n", + "\n", + " robot.step(communication_step_size, controller_cur)\n", + "\n", + " θs += robot._internal_θ\n", + " ts += robot._internal_t\n", + " return ts, θs\n", + "\n", + "\n", + "def run():\n", + " t_start = 0.0\n", + " t_end = 10.0\n", + " communication_step_size = 1 / 1024\n", + " communication_step_size_coarse = 1 / 8 # 1.0\n", + "\n", + " t = np.arange(t_start, t_end + communication_step_size, communication_step_size)\n", + " t_coarse = np.arange(\n", + " t_start, t_end + communication_step_size_coarse, communication_step_size_coarse\n", + " )\n", + "\n", + " robot = Robot(θ=0.0, ω=0.0, i=0.0)\n", + " controller = Controller(kp=1.0, ki=0.1, kd=-0.01, θ_setpoint=1.0, robot=robot)\n", + "\n", + " t_internal, θ_internal = run_cosim_for(controller, deepcopy(robot), t)\n", + " t_internal_coarse, θ_internal_coarse = run_cosim_for(\n", + " controller, deepcopy(robot), t_coarse\n", + " )\n", + "\n", + " fig, ax = plt.subplots()\n", + " ax.axhline(controller.θ_setpoint, label=\"setpoint\", color=\"red\", linestyle=\"dotted\")\n", + " ax.plot(t_internal, θ_internal, label=r\"$h_{internal} = h_{communication}$\")\n", + " ax.plot(\n", + " t_internal_coarse,\n", + " θ_internal_coarse,\n", + " label=f\"$h_{{communication}}={communication_step_size_coarse}$\",\n", + " )\n", + " ax.set_xlabel(\"t [s]\")\n", + " ax.set_ylabel(\"$\\\\theta(t)$\")\n", + " plt.legend()\n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "run()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.6" } - ] -} \ No newline at end of file + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/scripts/assessment.py b/scripts/assessment.py new file mode 100644 index 0000000..755497a --- /dev/null +++ b/scripts/assessment.py @@ -0,0 +1,57 @@ +import numpy as np +import matplotlib.pyplot as plt +from matplotlib.ticker import MaxNLocator, FixedLocator + +if __name__ == "__main__": + offset = 0.2 + contributions = { + "C1 Self-Adaptive": (2, 2), + "C2: SciML Taxonomy": ( + 3, + 0, + ), + "C3: SciML model implementation": ( + 0, + 2, + ), + "C4: Optimal Control HVAC": (3, 0 + offset), + "C5: PythonFMU": ( + 0, + 2 - offset, + ), + "C6: UniFMU": ( + 0, + 3, + ), + "C7: Building Energy Modeling": ( + 2, + 3, + ), + } + + fig, ax = plt.subplots() + ax.set_axisbelow(True) + ax.grid() + # ax.xaxis.set_major_locator(MaxNLocator(integer=True)) + # ax.yaxis.set_major_locator(MaxNLocator(integer=True)) + for idx, (contribution_name, score) in enumerate(contributions.items()): + ax.scatter(*score) + if score[0] == 3: + ax.annotate(contribution_name, score, rotation=60, rotation_mode="anchor") + else: + ax.annotate(contribution_name, score) + + ax.set_xlabel(rf"$\mathbf{{SciML}}$") + ax.set_ylabel(rf"$\mathbf{{Co-Simulation}}$") + ax.set_aspect(1 / 1.41) + fig.suptitle("Significance of Contribution") + + # plt.savefig("figures/spider_plot.pdf", bbox_inches="tight") + # plt.savefig("figures/spider_plot.svg", bbox_inches="tight") + + ax.set_xticks([0, 1, 2, 3], ["None", "Minor", "Significant", "Major"]) + ax.set_yticks([0, 1, 2, 3], ["None", "Minor", "Significant", "Major"]) + plt.tight_layout() + plt.savefig("figures/introduction/assessment.pdf", bbox_inches="tight") + + plt.show() diff --git a/scripts/spider.py b/scripts/spider.py new file mode 100644 index 0000000..a3f3f15 --- /dev/null +++ b/scripts/spider.py @@ -0,0 +1,188 @@ +import numpy as np + +import matplotlib.pyplot as plt +from matplotlib.patches import Circle, RegularPolygon +from matplotlib.path import Path +from matplotlib.projections.polar import PolarAxes +from matplotlib.projections import register_projection +from matplotlib.spines import Spine +from matplotlib.transforms import Affine2D + + +def radar_factory(num_vars, frame="circle"): + """ + Create a radar chart with `num_vars` axes. + + This function creates a RadarAxes projection and registers it. + + Parameters + ---------- + num_vars : int + Number of variables for radar chart. + frame : {'circle', 'polygon'} + Shape of frame surrounding axes. + + """ + # calculate evenly-spaced axis angles + theta = np.linspace(0, 2 * np.pi, num_vars, endpoint=False) + + class RadarTransform(PolarAxes.PolarTransform): + def transform_path_non_affine(self, path): + # Paths with non-unit interpolation steps correspond to gridlines, + # in which case we force interpolation (to defeat PolarTransform's + # autoconversion to circular arcs). + if path._interpolation_steps > 1: + path = path.interpolated(num_vars) + return Path(self.transform(path.vertices), path.codes) + + class RadarAxes(PolarAxes): + name = "radar" + PolarTransform = RadarTransform + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + # rotate plot such that the first axis is at the top + self.set_theta_zero_location("N") + + def fill(self, *args, closed=True, **kwargs): + """Override fill so that line is closed by default""" + return super().fill(closed=closed, *args, **kwargs) + + def plot(self, *args, **kwargs): + """Override plot so that line is closed by default""" + lines = super().plot(*args, **kwargs) + for line in lines: + self._close_line(line) + + def _close_line(self, line): + x, y = line.get_data() + # FIXME: markers at x[0], y[0] get doubled-up + if x[0] != x[-1]: + x = np.append(x, x[0]) + y = np.append(y, y[0]) + line.set_data(x, y) + + def set_varlabels(self, labels): + self.set_thetagrids(np.degrees(theta), labels) + + def _gen_axes_patch(self): + # The Axes patch must be centered at (0.5, 0.5) and of radius 0.5 + # in axes coordinates. + if frame == "circle": + return Circle((0.5, 0.5), 0.5) + elif frame == "polygon": + return RegularPolygon((0.5, 0.5), num_vars, radius=0.5, edgecolor="k") + else: + raise ValueError("Unknown value for 'frame': %s" % frame) + + def _gen_axes_spines(self): + if frame == "circle": + return super()._gen_axes_spines() + elif frame == "polygon": + # spine_type must be 'left'/'right'/'top'/'bottom'/'circle'. + spine = Spine( + axes=self, + spine_type="circle", + path=Path.unit_regular_polygon(num_vars), + ) + # unit_regular_polygon gives a polygon of radius 1 centered at + # (0, 0) but we want a polygon of radius 0.5 centered at (0.5, + # 0.5) in axes coordinates. + spine.set_transform( + Affine2D().scale(0.5).translate(0.5, 0.5) + self.transAxes + ) + return {"polar": spine} + else: + raise ValueError("Unknown value for 'frame': %s" % frame) + + register_projection(RadarAxes) + return theta + + +if __name__ == "__main__": + score = (0.0, 0.0, 0.0, 0.0) + NONE = 0.0 + MINOR = 0.33 + SIGNIFICANT = 0.66 + MAJOR = 1.00 + + publications = { + "Constructing Neural Network based Models for Simulating Dynamical Systems": ( + MAJOR, + MAJOR, + NONE, + SIGNIFICANT, + ), + "A Universal Mechanism for Implementing Functional Mock-up Units ": ( + NONE, + NONE, + MAJOR, + NONE, + ), + "NeuroMANCER Framework": score, + "Identification and Control of Networked Dynamical Systems: A case study in HVAC": score, + "Portable runtime environments for Python-based FMUs: Adding Docker support to UniFMU": score, + "Coupling physical and machine learning models: case study of a single-family house": score, + "Energy Prediction under Changed Demand Conditions: Robust Machine Learning Models and Input Feature Combinations": score, + "Rapid Prototyping of Self-Adaptive-Systems using Python Functional Mock-up Units": score, + } + publications = {f"P{i+1}": s for i, s in enumerate(publications.values())} + criteria = [ + "RQ1: How to pick the right model?", + "RQ2: How to integrate knowledge?", + "RQ3: How to integrate in simulation tools?", + "RQ4: Novel applications of SciML methods?", + ] + + criteria_to_pub_score = { + c: [s[idx] for s in publications.values()] for idx, c in enumerate(criteria) + } + + n_citeria = len(criteria) + # data = [ + # publications, + # *[(cri, [np.random.uniform(size=len(publications))]) for cri in criteria], + # ] + + theta = radar_factory(len(publications), frame="polygon") + + # data = example_data() + + fig, axs = plt.subplots( + figsize=(9, 9), + nrows=2, + ncols=2, + subplot_kw=dict(projection="radar"), + ) + fig.subplots_adjust(wspace=0.25, hspace=0.20, top=0.85, bottom=0.05) + + colors = ["b", "r", "g"] # ['b', 'r', 'g', 'm', 'y'] + # Plot the four cases from the example data on separate axes + for ax, (title, case_data) in zip(axs.flat, criteria_to_pub_score.items()): + ax.set_rgrids([0.2, 0.4, 0.6, 0.8]) + ax.set_title( + title, + weight="bold", + size="medium", + position=(0.5, 1.1), + horizontalalignment="center", + verticalalignment="center", + ) + for d, color in zip(case_data, colors): + ax.plot(theta, case_data, color=color) + ax.fill(theta, case_data, facecolor=color, alpha=0.25, label="_nolegend_") + ax.set_varlabels(publications) + + # add legend relative to top-left plot + # labels = ('Factor 1', 'Factor 2', 'Factor 3', 'Factor 4', 'Factor 5') + # legend = axs[0, 0].legend(labels, loc=(0.9, .95), + # labelspacing=0.1, fontsize='small') + + # fig.text(0.5, 0.965, '5-Factor Solution Profiles Across Four Scenarios', + # horizontalalignment='center', color='black', weight='bold', + # size='large') + plt.tight_layout() + plt.savefig("figures/spider_plot.pdf", bbox_inches="tight") + plt.savefig("figures/spider_plot.svg", bbox_inches="tight") + + plt.show()