Physique : recalage, FMU et Modelica
Un réseau physique est un ensemble de parts (une résistance, un moteur, une inertie) reliées sans direction, comme sur un schéma. Cette page montre trois choses que vous pouvez en faire : recaler ses paramètres sur des mesures, y faire tourner une FMU, et l'écrire en Modelica. Les équations elles-mêmes sont décrites dans la spécification.
Un premier recalage#
examples/dc-motor/main.arche est un moteur à courant continu qui entraîne une
charge. Son modèle indique que la résistance d'induit r vaut 1 Ω, la
constante du moteur k vaut 0,01 et le frottement d vaut 0,1. Supposons que
le vrai moteur soit un peu différent. Ici, le « vrai » moteur est une copie du
modèle, real.arche, avec d'autres valeurs :
part motor: DcMotor(r = 1.3Ω, k = 0.012)
part friction: RotationalDamper(d = 0.08)
Enregistrez une exécution de ce moteur, puis recalez le modèle sur cette exécution :
archec physics real.arche Drive --for 3s --every 10ms --print load.w,motor.la.i --csv run.csv
archec fit main.arche Drive run.csv --params motor.r,motor.k,friction.d
✓ 301 samples of 2 variables → run.csv
fit Drive — 2 signals, 3 parameters; Levenberg–Marquardt, 7 iterations, 34 runs
parameter before fitted uncertainty (1σ)
motor.r 1 Ω 1.3 Ω ± 2.8e-17 Ω (2.2e-15 %)
motor.k 0.01 0.012 ± 4.2e-18 (3.5e-14 %)
friction.d 0.1 0.08 ± 2.9e-17 (3.6e-14 %)
signal samples RMS error before after
motor.la.i 301 2.141 A 0 A
load.w 301 0.1955 rad/s 7.275e-16 rad/s
cost 1.381 → 3.806e-30 (sum of squares, each signal scaled by its spread)
Le recalage retrouve les trois valeurs. Avec un vrai moteur, les données sont bruitées, les erreurs après recalage ne sont pas nulles et l'incertitude est plus grande.
Recaler le modèle sur des mesures#
archec fit trouve les paramètres d'un réseau physique à partir de ce qu'a
fait le système réel. C'est de l'identification de système (ce pour quoi on
utilise souvent MuJoCo), réalisée avec le réseau du modèle lui-même.
- Les entrées mesurées pilotent le réseau.
- Ses sorties sont comparées aux sorties mesurées.
- Les moindres carrés (Levenberg–Marquardt) ajustent les paramètres jusqu'à ce que les deux concordent.
Les données sont au choix :
- un CSV : le temps d'abord, puis une colonne par signal, nommée comme les variables du réseau ;
- tout journal que lit
archec replay. Chaque champ de message devient alors une série nomméeMSG.field.--signals load.w=MOTOR.speedassocie une série à une variable.
Un paramètre est celui d'une part (motor.r), du système, ou un
parameter. Un parameter reste dans sa tolérance.
Ce qu'il signale :
- Deux paramètres que les données ne permettent pas de distinguer sont nommés
(
fit-correlated). - Un paramètre sur lequel les données ne disent rien est laissé tel quel
(
fit-no-influence).
Options :
--writeinscrit les valeurs recalées dans le modèle, sans toucher au reste du fichier.--html fit.htmlécrit un rapport.--jsonaffiche le résultat en JSON.
Voir docs/commands.md.
Des FMU dans la simulation#
Une FMU (Functional Mock-up Unit) est un modèle de simulation empaqueté.
archec accepte les FMU FMI 2.0 en co-simulation, issues de Modelica, Simulink,
Amesim et d'autres, ou de archec fmi. Une FMU peut servir de comportement
continu à un composant :
archec import plant.fmu -o plant.arche # writes the component below
component Plant {
fmu "plant.fmu"
solver 1ms
in power: data // an input: the flow linked into it
var temp: float64 = 20 // an output (or a parameter): readable by Python and tests
}
Son fonctionnement :
- La FMU est copiée dans le projet (
fmus/). - La simulation d'Arche l'avance au pas
solver, à côté des composants qui ont des équations. - Ses entrées reçoivent les flux qui arrivent sur ses ports
in(ou ses variables) de même nom. - Ses sorties vont vers ses ports
out(ou ses variables). Un nom pointé devient un nom à tiret bas :upper.leveldevientupper_level. - Un pas utilise les entrées du pas précédent. Ce retard d'un pas est courant en co-simulation.
Elle tourne dans arche-cli, et donc dans archec test, dans un petit hôte
natif. L'hôte utilise le binaire de la FMU pour cette plateforme, ou compile
ses sources/ avec le compilateur C du système.
Les variables Real, Integer, Enumeration et Boolean sont échangées. Un Integer
devient un int32 et un Boolean un bool. Une variable String est ignorée,
avec une note.
En Modelica#
archec gen --target modelica écrit le réseau en
Modelica, pour OpenModelica, Dymola ou tout autre outil
Modelica.
archec gen examples/dc-motor/main.arche --target modelica -o generated
generated/modelica/dc_motor.mo
generated/modelica/simulate_Drive.mos
La commande écrit :
- un package Modelica,
modelica/<project>.mo, avec tous les systèmes dont les parts ont des équations ou des ports physiques. Le package porte le nom du projet. Sansproject, il porte le nom du fichier ; pour unmain.arche, celui de son dossier (icidc_motor). - un script OpenModelica par système,
modelica/simulate_<System>.mos.omc simulate_Drive.mos, lancé dans ce dossier, écritDrive_res.csv.
model Drive "A DC motor turning a load"
Modelica.Electrical.Analog.Sources.ConstantVoltage supply(V = 12);
Modelica.Electrical.Analog.Basic.Ground gnd;
DcMotor motor;
Modelica.Mechanics.Rotational.Components.Inertia load(J = 0.01, w(start = 0, fixed = true), phi(start = 0, fixed = true));
…
equation
connect(supply.p, motor.p);
connect(motor.flange, load.flange_a);
…
annotation(experiment(StartTime = 0, StopTime = 3, Interval = 0.006, Tolerance = 1e-06));
end Drive;
Ce que devient chaque part#
Parts.
- Une part de
std/physicsdevient le composant correspondant de la Modelica Standard Library (MSL 4.0). Ses paramètres sont renommés, et ses états sont fixés à leur valeur de départ (voir le tableau ci-dessous). - Les autres parts deviennent des modèles à part entière, avec leurs
paramètres, variables et équations tels qu'écrits. Ce sont les composants du
projet, et les parts std sans équivalent exact dans la MSL. Dans leurs
équations :
tdevienttime;clamp(x, lo, hi)devientmin(max(x, lo), hi);lndevientlog;step(x)devientif x >= 0 then 1 else 0;- une constante est remplacée par sa valeur.
- Une part composite le reste : ses parts et ses liens sont dans son propre
modèle, et ses paramètres sont transmis (
Resistor(r = r)devientra(R = r)).
Ports.
- Un port physique devient le connecteur de la MSL :
pindevientInterfaces.Pin;flangedevientTranslational.Interfaces.Flange_a;shaftdevientRotational.Interfaces.Flange_a;heatdevientHeatTransfer.Interfaces.HeatPort_a.
- Les connecteurs mécaniques de la MSL portent une position : un potentiel de
vitesse devient donc sa dérivée.
flange.vdevientder(flange.s),shaft.wdevientder(shaft.phi). - Un type de port absent de la MSL (le
fluidde std, ou un type du projet) devient un connecteur du package, avec ses potentiels et ses flux (flow Real q). - Un signal (un
inou unoutd'une part qui a des équations) devient unRealInputou unRealOutput.- Une entrée alimentée par plusieurs sorties reçoit leur somme, comme lorsque le simulateur d'Arche les additionne.
- Une entrée que rien n'alimente dans le réseau vaut 0.
Comportement. Un fn main qui se contente d'attendre et d'affecter des
variables (wait 800ms; valve = 0) devient when time >= 0.8 then valve := 0;
sur un discrete Real. Le reste du code est ignoré, avec une note : handlers,
machines à états, toute autre instruction.
L'expérience s'exécute :
- jusqu'au dernier instant que vérifient les plans de test du système (sinon 1 s) ;
- au pas
solver(sinon un 500e de la durée) ; - avec une tolérance de 1e-6.
| std/physics | Modelica Standard Library | paramètres |
|---|---|---|
Resistor |
Electrical.Analog.Basic.Resistor |
r → R |
Capacitor |
Electrical.Analog.Basic.Capacitor |
c → C, v0 → v(start) |
Inductor |
Electrical.Analog.Basic.Inductor |
l → L, i0 → i(start) |
Ground |
Electrical.Analog.Basic.Ground |
|
VoltageSource |
Electrical.Analog.Sources.ConstantVoltage |
v → V |
SignalVoltage |
Electrical.Analog.Sources.SignalVoltage |
son entrée u est v |
CurrentSource |
Electrical.Analog.Sources.ConstantCurrent |
i → I |
Emf |
Electrical.Analog.Basic.EMF |
k |
Mass |
Mechanics.Translational.Components.Mass (flange_a) |
m, s0 → s(start), v0 → v(start) |
Damper |
Mechanics.Translational.Components.Damper (a, b → flange_a, flange_b) |
d |
Fixed |
Mechanics.Translational.Components.Fixed |
|
Force |
Mechanics.Translational.Sources.ConstantForce |
f → f_constant |
Inertia |
Mechanics.Rotational.Components.Inertia (flange_a) |
j → J, w0 → w(start) ; phi part de 0 |
RotationalDamper |
Mechanics.Rotational.Components.Damper |
d |
FixedShaft |
Mechanics.Rotational.Components.Fixed |
|
Torque |
Mechanics.Rotational.Sources.ConstantTorque |
tau → tau_constant |
SpeedSensor |
Mechanics.Rotational.Sensors.SpeedSensor |
sa sortie w |
HeatCapacitor |
Thermal.HeatTransfer.Components.HeatCapacitor |
c → C, t0 → T(start) ; temp est T |
ThermalConductor |
Thermal.HeatTransfer.Components.ThermalConductor (a, b → port_a, port_b) |
g → G ; q est Q_flow |
FixedTemperature |
Thermal.HeatTransfer.Sources.FixedTemperature |
temp → T |
HeatSource |
Thermal.HeatTransfer.Sources.FixedHeatFlow |
q → Q_flow |
Spring, RotationalSpring |
leurs propres équations | leur allongement est un état propre, là où la MSL le lit dans les positions des flanges |
Orifice, Volume, PressureSource |
leurs propres équations, sur le FluidPort du package |
les fluides de la MSL ne sont pas des parts linéaires à constantes localisées |
Vérifié face à Modelica#
archec verify --modelica vérifie le réseau face à une simulation Modelica :
- Il simule avec OpenModelica chaque système qui a des plans de test (
omcdans le PATH, ouOMC=/path/to/omc). - Il lit les attendus des plans de test sur les résultats :
at 600ms expect …,within,never:,always:, leexpect at 600s: …d'une étape. Les noms sont ceux du réseau (motor.la.i) ou ceux d'Arche (physics.load_w). Une valeur située entre deux échantillons est interpolée. - Il fait tourner archec physics sur le même réseau en parallèle, et donne
l'écart maximal de chaque état. Cet écart doit rester sous
--tol(1 % par défaut) de l'étendue de l'état.
archec verify examples/dc-motor/main.arche --modelica --system Drive # omc runs it
archec verify examples/dc-motor/main.arche --modelica --system Drive --results run.csv # a run made elsewhere
Ici, run.csv provient de archec physics examples/dc-motor/main.arche Drive --for 3s --every 10ms --csv run.csv :
Drive — dc_motor.Drive, 3 s (run.csv)
✓ TC-SPIN The load reaches its speed (TP-DRIVE)
✓ archec physics beside it: 3 states, the largest gap 0.0226036 % of a span (allowed 1 %)
motor.la.i max |Δ| 5.699e-4 A at 6 ms, span 11.9585
load.phi max |Δ| 1.925e-5 rad at 204 ms, span 2.87968
load.w max |Δ| 2.701e-4 rad/s at 6 ms, span 1.19511
L'écart correspond à ce que perd un échantillonnage toutes les 10 ms par rapport à l'exécution propre d'archec physics.
Sans OpenModelica, la commande le signale, écrit quand même le Modelica et sort avec le code 2 :
archec verify --modelica: OpenModelica is not installed (`omc` on the PATH, or OMC=/path/to/omc). The Modelica is in arche-verify/modelica/dc_motor.mo: simulate it with any Modelica tool and give its results — archec verify --modelica --results S_res.csv
Simulez-le avec n'importe quel outil Modelica, et fournissez ses résultats avec
--results S_res.csv (et --system S). Les résultats sont un CSV : le temps
d'abord (time ou t), puis une colonne par variable. Une colonne porte le
nom Modelica de la variable ("motor.la.i") ou celui du réseau. Le CSV
d'OpenModelica convient, tout comme celui de archec physics --csv.
Codes de sortie. La commande sort avec le code 1 quand un cas échoue ou quand archec physics n'est pas d'accord.
La structure du Modelica est vérifiée sans analyseur Modelica, par
checkModelica (dans la bibliothèque). Il vérifie :
- que les classes sont ouvertes et fermées dans l'ordre ;
- les parenthèses, et le
;de chaque instruction ; - que chaque classe utilisée est l'une de celles du package, ou une classe MSL du tableau, avec les modificateurs qui y sont indiqués ;
- que chaque
connectrelie des instances déclarées.
Les tests l'exécutent sur les exemples, et y lancent OpenModelica quand il est installé.
Limites#
- Une FMU doit être en FMI 2.0 pour la co-simulation. Les variables String ne sont pas échangées.
- L'application Arche dans le navigateur ne peut pas exécuter de FMU, et le signale.
- En Modelica, seul un
fn mainqui attend et affecte des variables est écrit. Handlers, machines à états et autres instructions sont ignorés, avec une note. - Un cas de test qui agit (
do …) n'a pas sa place dans une exécution Modelica : c'est une erreur dansarchec verify --modelica. Il en va de même pour un nom absent des résultats, comme l'état d'une machine à états. - Les fluides de la MSL ne sont pas des parts linéaires à constantes
localisées :
Orifice,VolumeetPressureSourcesont donc écrits avec leurs propres équations.