Guides pratiques › Modéliser la physique

Guides pratiques

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.

  1. Les entrées mesurées pilotent le réseau.
  2. Ses sorties sont comparées aux sorties mesurées.
  3. 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ée MSG.field. --signals load.w=MOTOR.speed associe 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 :

  • --write inscrit les valeurs recalées dans le modèle, sans toucher au reste du fichier.
  • --html fit.html écrit un rapport.
  • --json affiche 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.level devient upper_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. Sans project, il porte le nom du fichier ; pour un main.arche, celui de son dossier (ici dc_motor).
  • un script OpenModelica par système, modelica/simulate_<System>.mos. omc simulate_Drive.mos, lancé dans ce dossier, écrit Drive_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/physics devient 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 :
    • t devient time ;
    • clamp(x, lo, hi) devient min(max(x, lo), hi) ;
    • ln devient log ;
    • step(x) devient if 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) devient ra(R = r)).

Ports.

  • Un port physique devient le connecteur de la MSL :
    • pin devient Interfaces.Pin ;
    • flange devient Translational.Interfaces.Flange_a ;
    • shaft devient Rotational.Interfaces.Flange_a ;
    • heat devient HeatTransfer.Interfaces.HeatPort_a.
  • Les connecteurs mécaniques de la MSL portent une position : un potentiel de vitesse devient donc sa dérivée. flange.v devient der(flange.s), shaft.w devient der(shaft.phi).
  • Un type de port absent de la MSL (le fluid de std, ou un type du projet) devient un connecteur du package, avec ses potentiels et ses flux (flow Real q).
  • Un signal (un in ou un out d'une part qui a des équations) devient un RealInput ou un RealOutput.
    • 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 :

  1. Il simule avec OpenModelica chaque système qui a des plans de test (omc dans le PATH, ou OMC=/path/to/omc).
  2. Il lit les attendus des plans de test sur les résultats : at 600ms expect …, within, never:, always:, le expect 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.
  3. 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 connect relie 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 main qui 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 dans archec 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, Volume et PressureSource sont donc écrits avec leurs propres équations.