Objektorientierte Simulation - Startseite TU Ilmenau · Objektorientierte Simulation TU Ilmenau Seite 26 / 126. 2. Modellierungssprache Modelica R Allgemeine Klassen (Fortsetzung)

Objektorientierte Simulation

Dr.-Ing. Siegbert Hopfgarten

Fakultät für Informatik und AutomatisierungInstitut für Automatisierungs- und SystemtechnikFachgebiet Simulation und Optimale Prozesse

Tel., E-Mail: +49 3677 69-1418, [email protected]: Z 3011

Fachgebietsinternetseite: http://www.tu-ilmenau.de/simulation


TU Ilmenau Seite 1 / 126

1. Einführung

Modellierungssprache Modelica R© zur fachgebietsübergreifendenModellierung (Elektrotechnik, Mechanik, Hydraulik, Pneumatik, . . .) seit1996

Modelica-Association: www.modelica.org

Praxisanwendungen: Automobilindustrie, Luft- und Raumfahrt, Robotik,Thermodynamik (Gase, Flüssigkeiten), Klimatisierung, Kraftwerke,Mechanik (Mehrkörpersysteme), Optik, Abwasserreinigung, . . .

Vorher: blockorientierte (kausale) Modellierung vorherrschend

Modelica R© is a trademark of Modelica Association.



1. EinführungBlockorientierte vs. physikalische objektorientierte Modellierung

Blockorientiert (Ursache→Wirkung, Ein-/Ausgang, kausal)

Objektorientiert (physikalisch, akausal)



1. Einführung

Kausale Modellierung - Vorteile/Nützlichkeit:

Systemverständnis (Pole, Nullstellen, Übertragungsfunktion,-verhalten, lineares/nichtlineares/linearisiertes System, . . .

Beschreibung der Steuerungs-/Regelungsstruktur

Kausale Modellierung - Nachteile:

Aufwändig zu erzeugen/umzuformen; manuelle Ableitung ausZustands- und Erhaltungsgleichungen; fehlerträchtig

Weniger gut wiederverwendbar

Schwierigkeiten bei komplexen Systemen, konsistenteAnfangsbedinungen herzustellen (insbesondere beidifferential-algebraischen Gleichungssystemen(DAE-Systemen)



1. Einführung

Kausale Modellierung - Nachteile (Fortsetzung):

A priori (Im Vorhinein): Was ist bekannt (Eingang), was istunbekannt (Ausgang)?

Annahmen über Kausalität auf Komponentenebene (nicht:Gesamtsystem)

Robustheit, Wartung: Modellparameter „verteilt“ (nicht imSinne von Systemen mit verteilten Parametern, sondern imSinne „verstreut“ im gesamten Modell (Signalflussbild))

Diagramm beinhaltet nicht genügend Informationen, umAnfangsbedingungen zu berechnen



1. Einführung

Akausal (physikalisch, objektorientiert) - Merkmale:

Beschreibung eines Systems/einer Komponente anhand vonZustands- und Erhaltungsgleichungen (i. d. R. Kombination;−→ DAE-System); physikalische Gesetzmäßigkeiten

Keine explizite Festlegung über Ein- und Ausgang

Zwei Arten von Variablen: Potenzial- und Flussvariablen;(Potenzialvariablen: Triebkraft); Einheit des Produkts vonFluss- und Potenzialvariablen typischerweise Einheit derLeistung

Beispiel: Block- und objektorientierte Modellierung eineselektrischen Netzwerks (Blockschaltbild, Objektdiagramm)



1. EinführungBegriffe

Objekt (in der objektorientierten Programmierung):Datenstruktur mit Eigenschaften und MethodenObjektorientierung: Zuordnung/Anbindung von Eigenschaftenund Methoden an ein ObjektModell: Verhaltensbeschreibung (nicht Objekt selbst; entsprichtKlasse (class) bei objektorientierter Programmierung)Komponente: Instanz eines Modells/einer Klasse −→ Objekt(für gegebenes Modell, z. B. Widerstandsmodell, ist dieaktuelle Instanz der jeweilige Widerstand (z. B. R1, R2))Unter-, Subkomponente: ist in anderen Komponentenenthalten (hierarchische Modelle)Systemmodell: abgeschlossenes Modell; keine externenVerbindungen (engl.: self-contained); Anzahl der Unbekannten= Anzahl der Gleichungen



1. EinführungBegriffe (Fortsetzung)

Quantität (engl.: quantity): bezieht sich auf die Gebilde (engl.:entity), die einen Wert haben (z. B. Widerstandswert einesWiderstands (real, integer, boolean; Skalar, Feld (engl.: array)))

Definition: Beschreibung aller Variablen, Parameter,Gleichungen, die mit dem Modell verbunden sind(Modelldefinition)

Deklaration: Instanziierung/Erzeugung eines Objekts/einerKomponente, einer Variablen, eines Parameters einerbestimmten Klasse (im Systemmodell oder einer Komponente)

Paket (engl.: package): Sammlung von Modellen (Bibliothek)

Schlüsselörter (engl.: keywords): z. B. model, class, connect,equation, . . .



2. Modellierungssprache Modelica R©

Modelica R©: Modellierungssprache für Beschreibung komplexermathematischer Modelle zur Simulation dynamischer Systeme

Modelica R©: objektorientierte gleichungsbasierte Programmiersprache;Computeranwendungen mit hoher Komplexität; hohe Leistungsfähigkeiterforderlich

Vier wichtige Merkmale:1 Gleichungsbasiert; keine Zuweisungen (akausale

Modellierung, Wiederverwendbarkeit)2 Fachgebietsübergreifend3 Objektorientierte Sprache mit Klassenkonzept4 Strenges Softwarekomponentenmodell (Erzeugung und

Verbindung von Komponenten→ komplexe physikalischeSysteme)



Modellierungssprache Modelica R©

Klasse = Modell (class = model)

Erzeugen von Objekten mit Hilfe der Klassen (Instanziierung)

Variablen, Konstanten, Datentypen, Deklarationen

Bsp.: Homogene Diffentialgleichung 1. Ordnung

x(t) + a x(t) = 0 x(0) = x0 6= 0

Modelica R©-Syntaxclass HomDgl1OReal x(start=1);parameter Real a=1;

equationder(x)=-a*x;

end HomDgl1O;

ErläuterungKlasseTyp/Variable/StartwertParameter(änderbar∗)/Typ/Name/WertGleichungsabschnittDgl. (Gleichung, nicht Zuweisung)Beendigung der Klasse

∗ im Gegensatz zu constObjektorientierte Simulation



Bsp.: DAE-System (engl.: differential-algebraic equation system)

class DAESystemReal x(start=0.9);Real y;

equationder(y)+(1+0.5*sin(y))*der(x)=sin(time);x-y=exp(-0.9*x)*cos(y);

end DAESystem;

Anzahl der Variablen = Anzahl der Gleichungen (Dgln. u. algebraische Gln.)

„Primitive“ Datentypen:Boolean: true, falseInteger: 32-bit breite ganze ZahlReal: 64-bit GleitkommazahlString: Textzeichen (Zeichenkette)enumeration(...): Aufzählung




Konstanten: Integerwerte, Gleitkommawerte, Zeichenketten, Bsp.:

constant Real pi=3.14159;constant String bluecolor=’’blue’’;constant Integer number=2;parameter Real l=1.3;

Z. B. auch „Parameter-Konstanten“: Deklaration ohneDeklarationsgleichung, da z. B. vorher einlesbar aus Datei

parameter Real mass, length;

Startwerte für Variablen: üblicherweise Null; Boolesche V.: false;Zeichenkettenvariablen: leer ; Ausnahmen: Funktionsergebnisse und lokaleVariablen in Funktionen: undefiniert




Drei Arten von Kommentaren:” ... ”: nach Variablen, Klassendefinitionen//: Kommentar danach bis Zeilenende/* ... */ : Kommentar zwischen den Zeichen /* und */




Objektorientierte Sprache unterstützt Operatoren auf gespeicherten Daten(Variable; Objektdaten; dynamische Änderung der Objekte)

Modelica R©-Sicht auf die Objektorientierung:Strukturierte mathematische ModellierungModelica R©-Modell: deklarative mathematische Beschreibung durchGleichungen (Deklaration; Gültigkeit; weniger: schrittweiseAlgorithmen)

1 Strukturiertes Konzept: deklarative Strukturen; Wiederverwendung;Hierarchie; Komponenten und Verbindungen sowie Vererbung

2 Ausdrücken dynamischer Modelleigenschaften durch Deklaration inForm von Gleichungen

3 Objekt: Sammlung von Instanzen, Variablen und Gleichungen, die aufDaten angewendet werdenNicht: dynamisches Weiterleiten von NachrichtenHöheres Abstraktionsniveau als bei objektorientierten Programmier-sprachen (z. B. kein Code für Datentransport zwischen Objekten oderNachrichtenweiterleitung)→ automatisch durch Modelica R©-Compiler




Klassen, Instanzen, ObjekteKlasse kann beinhalten:

1 Daten/Variablen (Berechnungsergebnisse, dynamischesVerhalten); verbunden mit Klassen und Objekten

2 Gleichungen (Verhalten der Klasse)3 Klassen

Bsp.:class Point "point in 3D space"

publicReal x;Real y,z;

end Point;




Klassen, Instanzen, Objekte (Fortsetzung)

Instanziierung und Initialisierung:Bsp.:

class DreieckPoint point1(start={1,2,3});Point point2, point3;

end Dreieck;

Oder auch Initialisierung:class Main

Dreieck pts(point1.start={1,2,3});end Main;




Klassen, Instanzen, Objekte (Fortsetzung)

Oder auch Initialisierung:model Controller

Real y;equation

der(y)=a*y + b*u;initial equation

der(y)=0;end Controller;

der(y)=0→ y = − ba u; entspricht y(0)




Klassen, Instanzen, Objekte (Fortsetzung)Eingeschränkte Klassen („nahezu alles“ ist in Modelica R© eineKlasse)→ präzisierte AusdrucksweiseUnter bestimmten Voraussetzungen sind Klassen (class):model, connector, record, block, typeBsp.:

record PersonReal age;String name;

end Person;

block: Kausalitätconnector: Verbindungselemente (engl.: ports)type: Erweiterung von Typen, z. B. type vector 3D=Real[3];package und function: viele Gemeinsamkeiten mit Klasse;nicht wirklich Klasse




Wiederverwendung von (modifizierten) KlassenKlassenkonzept: Hauptmerkmal von Modelica R©

Modifikation am Bsp.: 2 T1-Glieder (Tiefpassfilter)model T1Glied "Tiefpass"parameter Real T1 "Zeitkonstante"Real u,y(start=1);

equationT*der(y)+y=u; // Dgl.

end T1Glied;

Erzeugen zweier Instanzen (Objekte) der Klasse T1Glied undDefinition der Klasse T2Glied

model T2Glied "2 Tiefpaesse"T1Glied F1(T=2), F2(T=3);

equationF1.u=sin(time);F2.u=F1.y;

end T2Glied;Objektorientierte Simulation



Nutzung dieses Modells, um auf höherer Hierarchieebene Variablen zudeklarieren→ Modifikation der Zeitkonstanten

model ModifT2Glied "Tiefpass"T2Glied F12(F1(T=6),F2.T=11);

end ModifT2Glied;

Vorhandene Typklassen (engl.: built-in type classes):Real, Integer, Boolean, String, enumeration(...)

Modifikation:

class Voltage = Real(unit="V",min=-240.0,max=240.0);type Voltage = Real(unit="V",min=-240.0,max=240.0); // äquivalenttype Voltageextends Real(unit="V",min=-240.0,max=240.0)

end Voltage; // äquivalent




Wiederverwendung von (modifizierten) Klassen (Fortsetzung)

Neu-Deklaration (replaceable, redeclare)

Vorher: Modifikation, d. h. Änderung der Standardwerte(„Default“-Werte)

Jetzt:

Änderung des Typs und/oder der „Vorsätze“, Attribute (engl.:prefix), d. h. Ersetzung der Originaldeklaration

Element, dass ersetzt werden soll: replaceable





Bsp.: (Resistor und TempResistor existieren bereits.)

class Circuitreplaceable discrete Resistor R1;

end Circuit;Circuit tempcircuit(redeclare parameter TempResistor R1);class Circuit2parameter TempResistor R1;

end Circuit2;

Im Bsp. anstelle von redeclare auch replaceable möglich fürspäteres redeclare.

Typänderung: Resistor→ TempResistor

Vorsatz-, Attributänderung: discrete→ parameter





Zwei Ausnahmen, wo replaceable nicht erforderlich

1 Beschränkung der Variabilität, z. B. von parameter→ constant

2 Beschränkung der Feldgröße, z. B. von [:] zu spezieller Größe

class C3Real x1;Real[:] vec;

end C3;class C4 = C3(redeclare parameter Real x1,

redeclare Real[20] vec; // gleich mitclass C4expanded

parameter Real x1;Real[20] vec;

end C4expanded;

final: spätere Veränderung nicht möglichObjektorientierte Simulation



VererbungÜbergeordnete Klasse (engl.: superclasse, base class)Untergeordnete Klasse (engl.: subclass, derived class)Definition einer Klasse: s. o. class Point

Einführung zweier neuer Klassen ColorData und Color; Color erbtvon ColorData und fügt Gleichung als Beschränkung hinzu

model ColorDataReal red, green, blue;

end ColorData;

class Colorextends ColorData;

equationred+green+blue=1;

end Color;




Vererbung (Fortsetzung)

class PointpublicReal x;real y,z;

end Point;

class ColoredPointextends Point;extends Color;

end ColoredPoint;




Allgemeine KlassenSinnvoll, allgemeine Klassen zu definierenNicht: oft ähnlichen Code programmieren2 Fälle:

1 Klassenparameter als Instanzen (Instanzparameter),d. h. Instanzdeklaration (Komponente) als Wertclass C

replaceable GreenClass pobj1(p1=5);replaceable YellowClass pobj2;replaceable GreenClass pobj3;RedClass obj4;

equation...

end C;

3 Klassenparameter (replaceable, Komponenten/Variablen)der Klasse C; obj4: kein Klassenparameter; s. Abb.




Allgemeine Klassen (Fortsetzung)

Variable umdeklarieren (engl.: redeclare)

class C2 = C(redeclare RedClass pobj1,redeclare GreenClass pobj2); // gleich mit Folgendem

class C2RedClass pobj1(p1=5);GreenClass pobj2;GreenClass pobj3;RedClass obj4;

end C2;




2 Parameter als Typ-Parameter, d. h. sie haben Typen als Werte

class Creplaceable class ColoredClass = GreenClass;ColoredClass obj1(p1=5);replaceable YellowClass obj2;ColoredClass obj3;RedClass obj4;

equation...

end C;

Klassenparameter ColoredClass ist Typ-Parameters. Abb.




Umdeklaration:

class C2 = C(redeclare class ColoredClass=BlueClass);// gleich mit Folgendem

class C2BlueClass obj1(p1=5);YellowClass obj2;BlueClass obj3;RedClass obj4;

end C2;




Klasse (Bsp.):

class Himmelskoerperconstant Real g=6.672e-11;parameter Real radius;parameter String name;Real mass;

end Himmelskoerper;

→ damit Variablenvereinbarung:

...Himmelskoerper Mond;equation/* Verhaltensbeschreibung der Klasse */...




Klasse (Bsp.) (Fortsetzung):Variablenzugriff:

class ...parameter Real force1=36350;

protectedparameter Real thrustEndTime=210;

publicRocket apollo(name="apollo12");

...equationapollo.thrust=... // Variablenzugriff; def. in class Rocket...

end ...

Kurzdefinition von Klassen

class Voltage = Real; // gleich mit Folgendem

type Voltage = Real;Objektorientierte Simulation



Lokale Klasse (engl.: nested class) C2:

class C1class C2Real p1;

end C2;class Voltage=Real(unit="kV");Voltage v1, v2;C2 pn;

end C1;

Eingeschränkte Klasse (engl.: restricted class) model:Einzige Einschränkung: kann nicht in Verbindungen (Konnektoren) benutztwerden




Eingeschränkte Klasse record:Spezifizierung von „Daten ohne Verhalten“, d. h. keine Gleichungen; nichtin Verbindungen benutzbar

record PersonReal age;String name;

end Person;

Eingeschränkte Klasse type:Definition neuer Typen; Nur Erweiterung bestehender Typen, record- oderarray-Typen

type Matrix3 = Real[3,3];




Eingeschränkte Klasse connector:Verbindung: Potenzial- und Flussvariablen; keine Gleichungen

connector FlangePosition s;flow Force f;

end Flange;

Eingeschränkte Klasse block:Kausalität! (E-/A-Datenfluss; alle Variablen haben input oder output; nichtin Konnektor)

block Multiply;input Real x;input Real y(start=0);output Real result;

equationresult=x*y;

end Multiply;




Eingeschränkte Klasse function:kann wie eingeschränkte Klasse betrachtet werden mit einigenErweiterungen; Funktionswertrückgabe durch jene formalen Parameter, diemit output gekennzeichnet sind

Sechs Einschränkungen:1 Jeder formale Parameter: input, output oder public!; nicht konstant!2 Nicht in Konnektor; keine Gleichungen; höchstens ein Algorithmus3 Algorithmus oder externe Funktionsschnittstelle4 Darf nicht beinhalten: der, initial, terminal, sample, pre, edge,

change, reinit, delay, cardinality, when,5 Untertyp (engl.: subtype) eines Funktionstypen (functiontype) muss

gleich Funktionstyp selbst sein6 Größe jedes Feldes/jeder lokalen Variablen muss gegeben sein durch

formale Parameter oder durch constant- oder parameter-Ausdrücke




Eingeschränkte Klasse function (Fortsetzung):

function multiplyinput Real x;input Real y:=0;output Real result;

algorithmresult := x*y;

end multiply;




Klasse package (eingeschränkt und erweitert):Sowohl eingeschränkte als auch erweiterte Klasse zur Organisationdes Namensraumes und des Modelica R©-CodesDarf nur Deklarationen von Klassen (einschließlich aller beschränktenKlassen) und Konstanten enthalten, aber keine VariablenKann importierenencapsulated: unabhängige Code-Einheit; Abhängigkeiten zuDefinitionen in anderen Paketen sichtbar durch importencapsulated package SmallPackimport OtherPackage;constant Real mypi=3.14159;connector Pin...end Pin;function multiply...end multiply;...

end SmallPack;Objektorientierte Simulation



Gleichungen:

Gleichungsbasierte Modellierung (vordergündig); nicht:zuweisungsbasiertZuweisungen in herkömmlichen Programmiersprachen:algebraische Gleichungen in Modelica R©

Attributzuweisungen→ GleichungenVerbindungen erzeugen GleichungenFlexibel: z. B. Ohmsches Gesetz: R*i=v;, i=v/R;, v=R*i;,R=v/i;




Gleichungen (Fortsetzung):Klassifizierung:

Algebraische Gleichungen (im equation-Abschnitt,einschl. connect-Gleichungen):Einfache Gleichungen:v=R*i;der(i)*L=v;

Wiederholte Gleichungen:class FiveEquations;

Real[5] x;equationfor i in 1:5 loop

x[i] = i+1;end FiveEquations;




Gleichungen (Fortsetzung):Klassifizierung (Fortsetzung):

Algebraische Gleichungen (Fortsetzung):connect-Gleichungen:Durch connect-Anweisungen (explizit) oder durch Verbindenvon Objekten (grafisch, implizit)

Bedingte Gleichungen (if) - hybride Modelle:if-Gleichung oder if-Anweisung/Ausdruck; unterschiedlicheArbeits-/Gültigkeitsbereiche<, bedingte Gln. könnenzeitkontinuierliche Ausdrücke enthaltenif u > uMaxthen y = uMax;elseif u < uMin

then y = uMin;else y = u;

endif;

gleiche Anzahl von GleichungenObjektorientierte Simulation




Algebraische Gleichungen (Fortsetzung):Bedingte Gleichungen (when):? when-Gln. werden benutzt, um momentane Gln. auszudrücken,die nur zu Ereigniszeitpunkten gelten→ zeitdiskreter Ausdruckwhen x > 2then y1 =sin(x);

y3 = 2*x + y1 +y2;end when;

? kombinierbar mit initial und terminate? Einschränkungen:• Variable = Ausdruck• (Out1,Out2,...)=function(InExpr1,...)• assert(), terminate(), reinit()• repetitive- und conditional- Anweisungen (for, if)





Algebraische Gleichungen (Fortsetzung):Bedingte Gleichungen (when) (Fortsetzung):? Bsp.:when condition1then close := true;elsewhen condition2

then close := false;end when;

? Bsp. für reinit: „neue“ Werte für Zustandsvariable(springender Ball)...when height < 0then reinit(v,-c*v);end when;





Algebraische Gleichungen (Fortsetzung):Bedingte Gleichungen (when) (Fortsetzung):? assert, terminate - keine Gleichungen im gewöhnlichenSinne? assert:• Test auf Modellgültigkeit; Nachricht, wenn Bedingung „false“;Nutzung für spezielle Fortsetzung.... assert(x >= LowLimit and x <= HighLimit, ...

’Variable x out of limit’);

? terminate:• Beendigung der Simulation (außer: feste Zeit)when height < 0,then terminate("Landung.")end when;




Gleichungen (Fortsetzung):

Klassifizierung (Fortsetzung):

Deklarationsgleichungen (engl.: declaration eq.): Teil einerVariablen- oder Konstantendefinition

const Integer one=1;parameter Real mass=2.2;Real v(start=0);

Modifikationsgleichungen: Modifikation von Attributen






Initialisierung, Initialisierungsgleichung oderInitialisierungsalgorithmus für abhängige Variablen inDifferentialgleichung (der(x) - zeitkontinuierlich) oder inDifferenzengleichungen (pre(x) - zeitdiskret)→ Lösen desInitialisierungsproblems für die Anfangszeit

Startattribut:

parameter Real x0=0.5;Real x(start=x0); // x0: Parameter; oder konst. Ausdruck

Bedeutung: Hinweis, dass x0 gute Schätzung ist, wenn dasAnfangswertproblem gelöst wird; heißt nicht, dass x denAnfangswert x0 haben muss

Real x(start=x0, fixed=true); // Gleichung: x(0) = x0






Initialisierung,. . . (Fortsetzung)

Initial equation:

model PIControllerReal y(fixed=false); // default, redundant...

initial equationder(y) = 0; // Gl. hinzugefuegt: y=-b/a*u

equationder(x) = u/TN;y = KR* (x + u);

end PIController;







Initial equation und when-Anweisung (nur mit initial-Operator):

when {initial(), sample(0,Ts)}then xd=pre(xd) + Ts/T*(xref - x);

u = k*(xd + xref - x);end when;






Initialisierung,. . . (Fortsetzung)Explizite und implizite Parameterwert-Vorgabe für Initialisierung:

Bsp.: Pendel

// 1.parameter Real L=1;Real x(start=0.3, fixed=true);Real y(start=0.4, fixed=true);// 2.parameter Real L(fixed=false);Real x(start=0.3, fixed=true);Real y(start=0.4, fixed=true); // Widerspruch!

implizit: möglich, dass Parameter abhängig von Anfangswertenzeitabhängiger Variablen ist







Nötige Gleichungsanzahl für die Initialisierung:

? ODE: 2n+m, n - Anzahl der Zustände (+ unbekannteAnfangsbedingungen), m - Anzahl der Ausgänge

? DAE: mindestens n zusätzliche Gleichungen (2n + m);DAESystem mit höherem Index; schwierig zu bestimmen;Index-Reduktion; Unterstützung durch Modelica

((Bsp.:))






Initialisierung,. . . (Fortsetzung):

Initial-Algorithmus:

Ausführung zur Initialisierung

model InitAlgReal x, x2;discrete Real xd;

initial algorithmder(x)=0;pre(xd)=5;x2=der(x)-10;

end InitAlg;






Zwei Regeln/Prizipien:

Single-assignment rule:

? Anzahl der Gln. = Anzahl der Variablen (sowohl Gleichungenals auch Zuweisungen außer in function)

Synchronous data flow principle:

? Alle Variablen behalten aktuellen Wert, ehe sie nicht explizitgeändert werden (Zugriff auf alle Variablen zu jeder Zeit)

? Zu jeder Zeit müssen aktive Gleichungen gleichzeitig erfülltsein.

? Berechnung und Kommunikation zu Ereigniszeitpunkten„brauchen keine Zeit“.




Softwarekomponenten-Modell:

1 Komponenten

2 Verbindungsmechanismus

3 Komponenten-Rahmen (realisiert Komponenten und Verbindungen;sichert, dass Informationsaustausch und Einhaltung vonBeschränkungen über die Verbindungen gewährleistet sind)

zu 1. Komponenten

Klasse, auch Instanzen von Klassen (partial model)

„Ports“→ Konnektoren

Unabhängige Definition

Kann aus anderen/mehreren Komponenten bestehen(hierarchische Modellierung)




Softwarekomponenten-Modell (Fortsetzung):

zu 2. Verbindungsmechanismus

Modelica-Konnektor: Instanz einer Klasse (connector)

Potential- und Flussvariablen

connector PinVoltage v;flow Current i;

end Pin;...Pin pin; // Instanz der Klasse Pin

Kausale Verbindungen (gerichteter Signalfluss)

connector RealInput = input RealSignal;// RealSignal = subtype of Real

RealInput u; // instance u with one signal




Softwarekomponenten-Modell (Fortsetzung):

zu 3. Komponenten-Rahmen

Anweisung connect(A.n,B.p) zieht Gleichungen nach sich:Summe aller Flüsse gleich Null; verbundene Potentiale habengleichen Wert

Gleicher Typ

Auch implizite Verbindungen: inner, outer




Partielle Klassen (partial class):

Allgemeines Modell/allgemeine Klasse

Abstrakte Klasse (in anderen Programmiersprachen)

Bsp.:

partial model OnePortPin p,n;Voltage v;flow Current i;

equationv = p.v - n.v;0 = p.i + n.i;i = p.i;

end OnePort;




Partielle Klassen (partial class) (Fortsetzung):

Wiederverwendung partieller Klassen (Bsp.:)

class Resistorextends OnePort;parameter Real R(unit="Ohm") "Resistance";

equationR*i = v;

end Resistor;... // Def. weiterer Modelle, z.B. Wechselspannungsquelleclass VsourceAC "Sine-wave voltage source"extends OnePort;parameter Voltage VA=220 "Amplitude";parameter Real f(unit="Hz") "Frequency";const Real pi = 3.14159;

equationv = VA*sin(2*pi*f*time);

end VsourceAC;




Felder:

Elemente haben gleichen Typ

Beispiele:

Real[3] postionvector = {1,2,3};Real identitymatrix[3,3] = {{1,0,0},{0,1,0},{0,0,1}};Real arr3d[3,3,3];Boolean[2] truthvalues = {false, true};String[3] str3 = {"one","two","three"};Voltage[10] volt_vec;

Index: 1 bis size(matrix,k), k - Dimension, A[i1:i2,j1:j2]

Operatoren +,-,*,/: anwendbar auf skalare Felder, Vektoren,Matrizen, . . . (*: bei Vektoren: Skalarprodukt, bei Matrizen:Matrizenmultiplikation)




Felder (Fortsetzung):

Funktionen anwendbar auch auf Felder; cos({1,2,3}) ={cos(1),cos(2),cos(3)}

Verknüpfung von Feldern: cat(k,A,B,C) - Verknüpfung entlang derk-ten DImension

cat(1,{2,3},{5,8,4}) // ==> {2,3,5,8,4}[A;B;C] // ==> [A B C]

Keine Unterscheidung bei Vektoren zwischen Zeilen- undSpaltenvektoren

Real[n,1] col_vec;Real[1,n] row_vec;

Leeres Feld erlaubt: Integer x[0];

Indizes: Boolean, Integer, enumeration typeObjektorientierte Simulation



Felder (Fortsetzung):

Flexible Feldgrenzen: Real[:,:] y,z;

Teilfelder

Real v[4] = 1.0:2:8; // v = {1.0,3.0,5.0,7.0};

Ansprechen von Teilfeldern

... A[2,1] ... // Einzelelement

... A[1,2] := ... // Zuweisung

... A[end-1,end] ... // vorletztes, letztes Element

... A[2,:] ... // gesamte 2. Zeile

Funktionen für Vektoren und Matrizen zeros, ones, fill,identity, diagonal, linspace, min, max, sum, product(elementweise), transpose, outerproduct (x xT )




Algorithmen und Funktionen:

Gleichungen→ physikalische Modellierung

Berechnungen als Algorithmus, d. h. Abfolge von Instruktionen,Anweisungen→ nicht-deklarative algorithmische Konstrukte

Deklarative Konstrukte Nicht-deklarative K.(Gleichungen, Deklarationen) (Algorithmen, Rezept)sagt aus (Beziehungen, Eigenschaften) beschreibt, wie bestimmtesund beschreibt, was Ziel ist Ziel erreicht wirdVorteil: Semantik und Bedeutung bleibtunabhängig, wo benutzt, erhalteny = z - 8; y := x -8;x = y + 2; x := y + 2;z - 3 = x + 5; // gleich mit // verschieden zux = y + 2; x := y +2;z - 3 = x + 5; y := x - 8;y + 8 = z;




Algorithmen und Anweisungen:

Algorithmus: Folge von Kommandos, Instruktionen (im Folgenden:Anweisungen)

Solche Anweisungen treten in Algorithmenabschnitten oder im„Funktionskörper“ auf

algorithm...<anweisungen>...

<beendigung> // durch equation, public, protected,// algorithm, initial, end




Algorithmen und Anweisungen (Fortsetzung):

Bsp.:

...equationx = y*2;z = w;

algorithmx1 := z + x; // x, y, z - "input"-Parameterx2 := y - 5;x1 := x2 + y; // x1, x2 - "output"-Parameter

equationu = x1 + x2;

Nahezu alle Anweisungen erlaubt (reinit() nur inwhen-Anweisungen)

In function mehrer Ausnahmen: s. o.





Speziell: initial algorithm, s. o. InitAlg

Einfache Anweisungen

y[3] := 35 - y[4];z.Name := "Maria";on := false;

Funktion

function fooinput Real x:=2.0; // formaler Parameter x

protected // mit Standardwert-ZuweisungReal y1 := cos(1.84) + x - 1.2E-2; // lokale Variable y1

end foo; // mit Initialisierungs-Zuweisung





Spezielle Form einer Zuweisung: rechte Seite enthält Funktionsaufrufmit mehreren Ergebnisvariablen(out1,out2)=fcnname(in1,in2,...)

Bsp.:

(a,b,c)=f(1.0,2.0)

function finput Real x, y;output Real r1, r2, r3;

algorithmr1 := x;r2 := y;r3 := x*y;

end f;





for ... loop-Anweisung,˜mit implizitem Iterationsbereich

Bsp.:

...Real a[n], b[n], c[n+1];...for i loop

a[i] := 2*b[i]; // gleich mit// for i in 1:size(a,1) loop ...// a und b müssen gleich groß sein





Geschachtelte for ... loop-Anweisung

...Real[n,m] A, B;...for i in 1:size(A,1) loop

for j in 1:size(A,2) loopA[i,j] := B[i,j]^3;

end for;end for;// besser (kompakt)for i in 1:size(A,1), j in 1:size(A,2) loop

A[i,j] := B[i,j]^3;end for;// noch besser (kompakter)for i,j loop

A[i,j] := B[i,j]^3;end for;





while-Anweisung

class SumSeriesparameter Real eps = 1E-6;Integer i;Real sum, delta;

algorithmi :=1;delta := exp(-0.01*i);while delta >= eps loop

sum := sum + delta;i := i + 1; delta := exp(-0.01*i);

end while;end SumSeries;

break-Anweisung: Unterbrechung von while- und for-Anweisungen





if-Anweisung

if <condition1>then

<statement>elseif <condition2> // optional (auch mehrfach)then <statement>else <statement> // nur einmalend if;

Bedingte Zuweisungen: alle output-Variablen haben definierte Werte(Startwerte bei Algorithmenaufruf); Bsp.: s. nächste Seite





Bedingte Zuweisungen (Fortsetzung):

Bsp. 1:

class CondAssignReal x(start=35), y(start=45), z(start=0);

algorithmif x > 5 then x := 400; // immer wahrend if;if z > 10 then y := 500; // z "input" für "algorithm"-

// Abschnittend if;

end CondAssign;





Bedingte Zuweisungen (Fortsetzung):

Bsp. 2:

function CondAssignFuncinput Real z;

protectedReal x := 35; // lokale Variablen x und yReal y := 45; // AnfangswertzuweisungReal z;

algorithmif x > 5 then x := 400; end if;if z > 10 then y := 500; end if;

end CondAssignFunc;

reinit(), assert(), terminate(): s. o. (Gleichungen; equation)




Funktionen (function):

Vordefiniert: abs, sqrt, ...; Operatoren +, -, *, /

In Bibliothek: Modelica.Math: sin, cos, exp, ...

Deklaration (allg.)

function <function-name>input TypeI1 in1; // Reihenfolge !!input TypeI2 in2 := <default-expr> "<comment>" annotation();...output TypeO1 out1;output TypeO2 out2 := <default-expr>;...

protected<local vaiables> ...

algorithm<statements>

end <function-name>;




Funktionen (function) (Fortsetzung):

Aufruf:

1 Zusammenhang formaler – aktueller Parameter über Position

2 ˜über Namen

3 1. und 2. gemischt

→ Regeln

Bsp.: s. nächste Seite





Bsp.:

function polynomialEvaluatorinput Real A[:]; // Feldgröße zur Zeit des Funktionsaufrufsinput Real x := 1.0; // expliziter Anfangswertoutput Real sum;

protectedReal xpower; // lokale Variable

...algorithmsum := 0;xpower := 1;for i in 1:size(A,1) loop

sum := sum + A[i]*xpower;xpower := xpower + 1;

end for;end polynomialEvaluator;





Zu 1.: Formaler – aktueller Parameter über Position

p := polynomialEvaluator({1,2,3,4},21);

Zu 2.: Formaler – aktueller Parameter über Namen

p := polynomialEvaluator(A={1,2,3,4},x=21); // besser

Zu 3.: Gemischt

p := polynomialEvaluator(1,2,3,4,x=21); // besser

Rückgabe mehrerer Argumente: s. o.

Rückgabe optionaler Argumente: analog MATLAB R©;(o1,o2,o3)=... ; o1 = ... ;

MATLAB R© is a registered trademark of The Mathworks Inc.





return: Rücksprung aus Funktionen

„record constructor function“: Funktion (gibt „record“ zurück)

record Person // im type-KontextString name;Integer age;String[2] children;

end Person;function Person // im function-Kontextinput String name;input Integer age;input String[2] children;output Person p;

algorithmp.name := name; p.age := age;p.children := children;

end Person;





„record constructor function“ (Fortsetzung):

Personeninstanz: Person john =Person(”John”,35,{”Carl”,”Eva”});

Regeln

Anwendung skalarer Funktionen auf Felder (s. auch oben)

cos(a,b,c) // result: cos(a),cos(b),cos(c)

Externe Funktionen (C (Untermenge von C++), FORTRAN 77(Untermenge von FORTRAN 90))

function loginput Real x;output Real y;

externalend log;





C-, FORTRAN-Funktionen: siehe Handbuch

Overloading




Anmerkungen, Einheiten, Größen:

Zusätzliche Konstrukte, Attribute

annotation: Informationen über Modell (Modelldokumentation,grafisches Layout, (Symbol, Verbindungen)→ grafischer Editorbenötigt Informationen (s. Bsp.)

model Resistor1annotation(Icon(coordinateSystem(

extend={{-120,120},{120,120}}),graphics={Rectangle(extent=[-70,-30;70,30],

fillPattern=FillPattern.None),Text=(extent=[-100,55;100,110],

textString="%name=%R"),Line(points=[-90,0;-70,0]),Line(points=[70,0;90,0])} ));

...end Resistor1;




Anmerkungen, Einheiten, Größen:

annotation auch möglich im Zusammenhang mit: class, package,redeclare, import, Variablendefinition, Gleichungen, Zuweisungs-und Algorithmenabschnitt, Grafik

package Modelicaannotation(Documentation(info="<HTML-Code>"));...end Modelica;




Anmerkungen, Einheiten, Größe (Fortsetzung):

Einheiten (engl.: units): SI-Einheiten, displayUnit

Physikalische Größen (engl.:quatities)

Bsp: Typ-Definition Winkel

type Angle = Real(final quantity="Angle",final unit="rad",dispalyUnit="deg");



3. Dymola (DYnamic MOdeling LAboratory)(Modellierungs- und Simulationsumgebung mit Simulationssprache Modelica)

Wesentliche MerkmaleKommerzielles Produkt (Dassault Systems, früher: Dynasim AB,Lund/Schweden); auch andere: MathModelicaSystemDesigner, MOSILAB,SimulationX (www.dynasim.se, www.3ds.com/de/,https://www.openmodelica.org, www.mathmore.com, www.mosilab.de,www.simulationx.com)OpenModelica (www.ida.liu.se/labs/pelab/modelica/OpenModelica.html)Modellierung verschiedener Arten von physikalischen ObjektenHierarchische Modellerstellung, Objektorientierung und GleichungenBibliotheken: elektr. Netzwerke, mechan. Systeme (translatorisch,rotatorisch), Hydraulik, Übertragungsglieder (Regelungstechnik),Mehrkörpersysteme, Petri–Netze, Konstanten, mathematische Funktionen,Einheiten, u.a.m.Interface zu MATLAB/Simulink, dSPACE, Excel3D-Animation (Option)Grafischer Modelleditor

Dymola R© is a trademark of Dassault Systèmes.Objektorientierte Simulation


3. DymolaModellierungsumgebung

Bibliothek Modell

Übersetzung

ÜbersetztesModell

p =

x =0

t , t0 1

AndereProgramme Dymosim

AnimationGrafik- und

Numerikausgabe

Modelleditor

Simulationssteuerung

(Parameter,Anfangswerte,Zeithorizont,Simulation,Skripte)

Visualisierung



3. DymolaSoftware

Hauptfenster

Reiter „Modeling“: Modellfenster, Package Browser, Component Browser,Menü (Grafische und/oder gleichungsorientierte Modelleditierung; Modellhat verschiedene Schichten (layer): icon l., diagram l., documentation l.,Modelica text, used classes)

Reiter „Simulation“: Plot-Fenster, Variable Browser, Commands, Menü(Übersetzung, Parametrierung, Steuerung der Simulation,Ergebnisausgabe)

Animationsfenster

Weitere MerkmaleDemonstrationsbeispiele (Roboter, Motor)

Modelica-Simulationssprache

Simulation (Menü, Skript)



3. DymolaBearbeiten von Aufgabenstellungen

1.) Simulationsdiagramm aus Bibliothekselementen (Bsp.: RC-Netz mitSpannungsquelle und Erdung)

2.) Problemstellung bearbeiten anhand math.-physikal. Beschreibung;Programmieren in Modelica (Bsp.: planares, reibungsfreies Pendel)

Math.-physikal. Beschreibung

J ω = −m g l sin(ϕ)

ϕ = ω

mit m - Masse, l - Länge, g - Erdbeschleu-nigung, J - Trägheitsmoment (J = m l2), ϕ -Auslenkwinkel, ω - Winkelgeschwindigkeit,ω - Winkelbeschleunigung.

Illustration



3. DymolaBearbeiten von Aufgabenstellungen (Fortsetzung)

Programmtechnische Umsetzung; aufeinander folgende Wahl derReiter/Menüpunkte/Fenster:

Reiter „Modeling“: Menü File/Clear All/Equation layer; Deklaration vonVariablen und Parameternparameter Real m=1;parameter Real l=1;parameter Real g=9.81;parameter Real J=m*l^2;Real phi(start=1),w;...der(phi)=w;J*der(w)=-m*g*l*sin(phi);

„Modeling“: File/Save As - SpeichernReiter „Simulation“: File/Translate - Übersetzen

„Simulation“: Experiment/Parameter - Parameter ändern



3. Dymola

Bearbeiten von Aufgabenstellungen (Fortsetzung)„Simulation“: Simulation/Setup - Anfangs-, Endzeit, Integrationsverfahren,. . .

„Simulation“: Variable Browser/Advanced/x0 = - Anfangswerte

„Simulation“: Variable Browser/Advanced/p = - Modellparameter

„Simulation“: Menü Simulation/Simulate - Ausführen der Simulation

„Simulation“: Variable Browser - Variablen auswählen für Anzeigebzw. Druck



3. DymolaBearbeiten von Aufgabenstellungen (Fortsetzung)

3.) Teilweise Nutzung von Bibliothekselementen, teilweise Erstellung neuerModelle, Aufbau eines Gesamtmodells (Ausführlich: Übung)

Nutzung des vordefinierten Konnektors „Pin“Definition eines Teilmodells „Elektrisches Bauelement mit zweiAnschlüssen“Nutzung des Teilmodells und Spezifizierung eigener Modelle fürKonstantspannungquelle, Widerstand und InduktivitätAufbau des Stromkreises



3. Dymola

Ausgewählte IntegrationsverfahrenAbkürzung Modelltyp Ordnung BemerkungLsodar ODE 1 - 12 Adams’ methodsDopri45 ODE 5 RK45 Dormand-PrinceDopri853 ODE 8Dassl DAE 1-5 steife Dgl.systeme, BDF methodsRadau IIa DAE 5 steife Dgl.systeme. . .alle o.g. Verfahren mit variabler Schrittweitefolgende Verfahren mit konstanter SchrittweiteEuler ODE 1Rkfix2 ODE 2Rkfix3 ODE 3Rkfix4 ODE 4



3. Dymola

Abarbeitung von Simulationsaufgaben mittels SkriptBsp. für Skript:translateModel(”Eigenes”)W.R := 1000;experiment StopTime=0.0001simulateplot(”I.v”,”W.v”)



3. Dymola

Simulator DymosimEigenständiger Simulator Dymosim („Stand-Alone“-Programm); kann alssolches oder aus anderen Benutzerprogrammen als C-Funktion aufgerufenwerden

Kopplung Dymola-MATLABdymosim kann aus MATLAB aus M-File aufgerufen werden (vorherigesÜbersetzen des Modells unter Dymola)

Bsp.: Van-der-Pol-Oszillator und Druck aller Resultate (Parameter:Anfangs-, Endzeit, Kommunikationsintervalllänge und-anzahl,Toleranz,Integrationsverfahren, Anfangszustand, Parameter)[s,n]=dymosim([0,50,0.1,0,1e-4,1],[0.5;0],0.2); ...tplot(s,2:size(s,2),n)



4. OpenModelica

Freie Modelica-basierte Modellierungs- undSimulationsumgebung

OpenModelica Connection Editor: ähnlich Dymola (Modellierung undSimulation)

OpenModelica Notebook: Dialog-Übungssystem

OpenModelica Optimization Editor (Optimierung vonOpenModelica-Modellen)

OpenModelica Shell: Simulation (u. a. Befehle) in einer „Shell“

Dokumentation



4. OpenModelica

OpenModelica Connection EditorFenster Search MSL (Modelica Standard Library): Suche

Fenster Komponenten: Reiter Modelica-Bibliotheken

Fenster Komponenten: Reiter: Modelica-Files

Fenster Modell-Browser: Hierarchische Anzeige der Modellstruktur

Designer-Fenster: Hauptfenster (Icon, Diagramm, Modelica-Text)

Plot-Variablen-Fenster

Dokumentationsfenster

Nachrichten-Fenster



4. OpenModelicaBearbeiten von Aufgabenstellungen (OMEdit)

1.) Simulationsdiagramm aus Bibliothekselementen (Bsp.: RC-Netz mitSpannungsquelle und Erdung, s. Bsp.)

2.) Problemstellung bearbeiten anhand math.-physikal. Beschreibung;Programmieren in Modelica (Bsp.: planares, reibungsfreies Pendel, s. o.)

Math.-physikal. Beschreibung

J ω = −m g l sin(ϕ)

ϕ = ω

mit m - Masse, l - Länge, g - Erdbeschleu-nigung, J - Trägheitsmoment (J = m l2), ϕ -Auslenkwinkel, ω - Winkelgeschwindigkeit,ω - Winkelbeschleunigung.

Illustration



4. OpenModelica

Bearbeiten von Aufgabenstellungen (Fortsetzung)Programmtechnische Umsetzung; aufeinander folgende Wahl derIcon/Menüpunkte/Fenster:

Reiter „Modellieren“: Deklaration von Variablen und Parametern;Werte (s. o.)„Modeling“: File/Save as - SpeichernIcon „Simulate“: Simulation/Simulate - Übersetzen und Simulation (mitSimulationsparametereinstellungen)

Icon „Plot“/Plot variables: Variablen auswählen fürAnzeige/Speichern/Druck



4. OpenModelica

Bearbeiten von Aufgabenstellungen (Fortsetzung),Integrationsverfahren, Skripte

3.) Teilweise Nutzung von Bibliothekselementen, teilweise Erstellung neuerModelle, Aufbau eines Gesamtmodells (s. o.)

Integrationsverfahren: dassl, dassl2, euler, rungekutta, dopri5, inline-euler,inline-rungekutta

Skripte (s. o. , wie unter Dymola)



5. Physikalische Grundgesetze und Umsetzungbei objektorientierter ModellierungÜbersicht

Fachgebiet Potentialv. Flussv. Energieträger Bibl.Elektrotechn. Spannung El. Strom Ladung ElectricalMechanik, Position Kraft Lin. Moment Mechanics.transl., 1D TranslationalMechanik, Winkel Dreh- Dreh- Mechanics.rotator., 1D moment moment RotationalMechanik, Position (3D), Kraft (3D),- Lin. u.- Mechanics.3D Rot.winkel (3D) Drehm. (3D) Drehmom. MultiBodyMagnet., Magn., Magn.,- Magn. Magnetic

Potential Flussrate FlussFlüss./Gase, Druck, Durchfl.,Wär- Volumen,Wär- HyLib,Hydr.,Wärme Temp. me-, Stoffstr. me, Teilchen PneuLib, etc.Chemie Chem., Stoffteil- Teilchen Media,

Potential chenstrom Thermofluid



5. Physikalische Grundgesetze ...

Modellierung analoger elektrotechnischer SystemeGesetzmäßigkeiten: Strom-/Spannungsbeziehungen, KirchhoffscheGesetze, Energieerhaltung, Leistung, Transformator, Elektro-motorischeKraft, u. a.:

Konnektor Pin mit Strom und Spannung

(Teil)-Modelle, partial model PositivePin, NegativePin, TwoPin,OnePort, TwoPort, . . .; Bibliothek: Electrical.Analog



5. Physikalische Grundgesetze ...Modellierung mechanischer, translatorischer Systeme (1D)

Gesetzmäßigkeiten: Zusammenhänge zwischen Zuständen einestranslatorischen Systems (Weg, Geschwindikeit, Beschleunigung, Ruck),Newtonsche Gesetze (Kräftebilanz), Kraft-Zustands-Beziehung anEinzelelementen (Feder, Dämpfer, usw.), Reibung, Energie, u. a.

Konnektor Flange_a, Flange_b (in/aus Schnittebene) mit Position, Kraft

(Teil)-Modelle; Bibliothek(en): Mechanics.Translational

Modellierung mechanischer, rotatorischer Systeme (1D)Gesetzmäßigkeiten: Zusammenhänge zwischen Zuständen einesrotatorischen Systems (Winkel, Winkelgeschwindigkeit,Winkelbeschleunigung), Newtonsche Gesetze (rotatorisch,Drehmomentenbilanz), . . .

Konnektor Flange_a, Flange_b mit Winkel und Drehmoment

(Teil)-Modelle, Bibliothek(en): Mechanics.Rotational, . . .




Modellierung mechanischer 3D-SystemeGesetzmäßigkeiten im 3D-Raum

Konnektor Frame mit 3D-Position, 3D-Kraft, 3D-Drehmoment,Raumorientierung

(Teil)-Modelle, Bibliothek(en): Mechanics.MultiBody




Modellierung von Flüssigkeits- und HydrauliksystemenGesetzmäßigkeiten: Druck-Durchfluss-Beziehung, Flussbilanzen,laminare/turbulente Strömung, Kontinuitätsgleichung, Energieerhaltung

Konnektoren (FluidPort mit Massestrom (Flussvariable) und Druck(Potentialvariable); zusätzlich: stream-Variable Enthalpie, Masseanteile,Konzentrationen), Bibliothek: Fluid, Hydraulics (kommerziell), Pneumatics(kommerziell)

stream-Variable erforderlich wegen numerisch günstigerer Lösbarkeit vonGleichungssystemen (ohne 0/1-Variablen wegen Richtungsumkehr vonStoffströmen); inStream()-, actualStream()-Operatoren




Modellierung von thermischen SystemenGesetzmäßigkeiten: Speicherung und Transport thermischer Energie(Wärme); Wärmeleitung (Dgl., Partielle Dgl.), Konvektion (Wärmetransportdurch Materiestrom), Wärmestrahlung, . . .; s. auch thermodynamischeSysteme

Bibliothek: Thermal




Modellierung von thermodynamischen SystemenGesetzmäßgikeiten: Speicherung und Transport von Energie und Masse,Thermodynamisches Gleichgewicht (Druck, Temperatur, Volumen),thermodynamische Prozesse, Arbeit und Wärme, Masse- undEnergieerhaltung in Volumen (engl.: control volume), Energiefluss,-umwandlung, Interne Energie, Enthalpie

Bibliotheken: Thermal und freie Bibliotheken (TechThermo, ThermoSysPro,ThermoPower)



6. Tools / 6.1 Functional Mockup Interface (FMI)

Functional Mockup Interface (FMI)engl.: mockup ≈ dt.: Gesamtmodell

Anwenderprogrammunabhängige Schnittstelle zur Unterstützung desModellaustauschs und der Co-Simulation; Lösungsverfahren imSimulationstool bzw. in der „Functional Mockup Unit (FMU)“

FMU beinhaltet separierte Interface-Beschreibung (XML) und Funktionalität(Modell; Quellcode, binär)

https://www.fmi-standard.org/

https://trac.fmi-standard.org/export/HEAD/branches/public/docs/Modelica2011/The_Functional_Mockup_Interface.pdf



https://www.fmi-standard.org/



6. Tools / 6.2 JModelica.org

Aufbau und Komponenten

Basis: Modelica(objektorientierteModellierung undSimulation)

Optimica: Erweiterung vonModelica; Formulierungvon Optimierungsproble-men (Zielfunktional,Optimierungs(zeit)-horizont,Beschränkungen,Randbedingungen, usw.)basierend auf Modelica-oder FMI-Modellen

StrukturCompiler

Fro

nt-

en

d

Mid

dle

-e

nd

Ba

ck-

en

d

Modelica DLLGenerated code

JMI runtime library

ODE DAEDAEInit.

Opt.

Integrated Developement Environment

(Eclipse plugin)

Optimica

C

XML

Python Algorithms

User scripts/code

Internetadressen:jmodelica.org, jastadd.org,python.org, ipython.org,numpy.scipy.org,https://projects.coin-or.org/Ipopt



jmodelica.org

jastadd.org

python.org

ipython.org

numpy.scipy.org

https://projects.coin-or.org/Ipopt

https://projects.coin-or.org/Ipopt

6. Tools / 6.2 JModelica.orgAufbau und Komponenten (Fortsetzung)

JModelica-Compiler entwickelt mittels JastAdd

JModelica.org Model Interface (JMI) C Runtime Lib. mitAnwenderprogrammschnittstelle zu erzeugtem C-Code; automatischeDifferentiation; Nutzung der schwachen Besetztheitsstruktur von Matrizen

Benutzerinteraktion mittels Skriptsprache Python (Erstellung von Skripten,nutzerspezifische Anwendungen, prototypische Algorithmen);Python-Pakete Numpy, Scipy: Unterstützung für numerische Berechnungen(Matrizen-, Vektoroperationen, lineare Algebra, Druck)

Optimierungsalgorithmus IPOPT zur Lösung von Parameteroptimierungs-und Optimalsteuerungsaufgaben

Functional Mockup Interface (FMI) (Import, Export)

XML-Export des flachen Modells (zur Nutzung mit anderen Tools oderAlgorithmen)

Erweiterbarkeit



6. Tools / 6.2.1 Simulation mit JModelica.org

Modellunterstützung

Modelica- und FMI-Modelle

Eigenständiges Python-Paket Assimulo zur Simulation von ODE- undDAE-Systemen

Zwei Simulationsmittel: FMU (Functional Mockup Unit) und JMU(JModelica.org Model Unit)

FMU: Umwandlung in ODE-System (Standard; empfohlen;leistungsfähiger, robustere Initialisierungsmechanismen, signifikantbessere Unterstützung hybrider Systeme)

JMU: Umwandlung in DAE-System (nützlich z. B. in einigenOptimierungsanwendungen, wo Simulation von DAE/JMU-Modellen einewichtige Voraussetzung für die Optimierung mit Kollokationsverfahren ist)



6. Tools / 6.2.1 Simulation mit JModelica.orgSimulationsmodell, Bsp.: Van-der-Pol-Schwinger

x1(t) =

(1− x2

2 (t))

x1(t)− x2(t) + u(t) , x1(0) = 0

x2(t) = x1(t) , x2(0) = 1 , u(t) = 0

Modelica-Modell VDP.mo

model VDP// State initial valuesparameter Real x10 = 0;parameter Real x20 = 1;// The statesReal x1(start = x10);Real x2(start = x20); //...

// ... Fortsetzung// The control signalinput Real u; // ...

equationder(x1) = (1 - x2^2)*x1-x2+u;der(x2) = x1;

end VDP;



6. Tools / 6.2.1 Simulation mit JModelica.orgSimulationsschritte

Erstellen eines Modelica-Modells VDP.mo (s. o.)

Aufruf einer IPython-Shell (IPython: interactive python)

Erzeugen eines Python-Skripts VDP_Sim.py mittels eines Editors (s. u.)

Ausführen des Skripts (run VDP_Sim)

Python-Simulationsskript VDP_Sim.py# Import model compilation function and FMUModel classfrom pymodelica import compile_fmufrom pyfmi import FMUModel# Import plotting libraryimport matplotlib.pyplot as plt# Compile modelfmu_name = compile_fmu("VDP","VDP.mo")# Load modelvdp = FMUModel(fmu_name)



6. Tools / 6.2.1 Simulation mit JModelica.orgPython-Simulationsskript VDP_Sim.py (Fortsetzung)# simulationres = vdp.simulate(final_time=10)

# variable trajectories returned as numpy arraysx1 = res[’x1’]x2 = res[’x2’]t = res[’time’]

# visualizationplt.figure(1)plt.plot(t, x1, t, x2)plt.legend((’x1’,’x2’))plt.title(’Van der Pol oscillator.’)plt.ylabel(’Angle (rad)’)plt.xlabel(’Time (s)’)plt.show()



6. Tools / 6.2.2 Optimierung mit JModelica.orgMerkmale

Unterstützung der Optimierung statischer und dynamischer Modelle

Lösung von nichtlinearen Optimierungsproblemen (NLP) undOptimalsteuerungsaufgaben (DOCP) (statische und dynamischeOptimierung), z. B. optimale Parameterwahl bei Systemauslegung,Modellkalibrierung (Modellparameteranpassung), zeitoptimaler,energieoptimaler Steuerungsentwurf

Notation eines Optimalsteuerungsproblems

minu(t)

J (x(t),u(t), t) = Φ (x(tf ), tf ) +

tf∫t0

f0 (x(t),u(t), t) dt

x(t) = f (x(t),u(t), t) , t ∈ [t0, tf ] ; x(t0), x(tf ) , tf jeweils fest/frei

g (x(t),u(t), t) ≤ 0



6. Tools / 6.2.2 Optimierung mit JModelica.org

Schritte zur Lösung eines Optimalsteuerungsproblems

Mathematische Problemformulierung

Implementierung des Optimierungsproblems in Modelica/Optimica

Aufruf einer IPython-Shell

Problemlösung mittels JModelica.orgDynamische Optimierung von DAEs mittels direkter Kollokation undJMUs (Standard; DOCP und NLP; C, CppAD, IPOPT; function undrecord; DAEs und keine Diskontinuitäten)Dynamische Optimierung von DAEs mittels direkter Kollokation undCasADi (DOCP und NLP; Python, CasADi, IPOPT; zeitkont. DAEs,keine function und record; leistungsfähiger )

Pseudospektraloptimierung von ODEs mittels CasADi (DOCP;Python, CasADi, IPOPT; zeitkont. ODEs mit Mehrphasen...)




Schritte zur Lösung eines Optimalsteuerungsproblems (Fortsetzung)

Problemlösung mittels JModelica.org (Fortsetzung)

Ableitungsfreie Parameteroptimierung (z. B. Modellkalibrierung) undOptimierung von ODEs mit JMU (FMU-Modelle; NLP; Nelder-Mead);großes System, und/oder Diskontinuitäten oder hybride Elemente)

d. h. Erstellung eines Python-Optimierungsskripts (z. B. VDPOpt.py) undAusführen des Python-Optimierungsskripts (z. B. run VDPOpt)




Optimierungsmodell, Bsp. 1: Van-der-Pol-Schwinger, quadratischesZielfunktional, fester Zeithorizont, fester Anfangs- und Endzustand,Steuerbeschränkung

minu(t)

tf∫t0

(x2

1 (t) + x22 (t) + u2(t)

)dt

x1(t) =(

1− x22 (t)

)x1(t)− x2(t) + u(t) , x1(0) = 0

x2(t) = x1(t) , x2(0) = 1

t ∈ [t0 = 0, tf = 20]

g (u(t)) = u(t)− 0.75 ≤ 0



6. Tools / 6.2.2 Optimierung mit JModelica.orgModelica-Optimierungsmodell VDPOpt.mopoptimization VDPOpt (objective = cost(finalTime),

startTime = 0,finalTime = 20)

Real x1(start=0,fixed=true); // StatesReal x2(start=1,fixed=true);

input Real u; // Control signal

Real cost(start=0,fixed=true); // Cost functionalequationder(x1) = (1 - x2^2)*x1-x2+u; // Process modelder(x2) = x1;der(cost) = x1^2 + x2^2 + u^2; // Cost functional

constraintu <= 0.75; // Control constraint

end VDPOpt;



6. Tools / 6.2.2 Optimierung mit JModelica.orgPython-Optimierungsskript VDPOpt.py# Import model compilation function and JMUModel classfrom pymodelica import compile_jmufrom pyfmi import JMUModel# Import plotting libraryimport matplotlib.pyplot as plt# Compile modeljmu_name = compile_jmu("VDPOpt","VDPOpt.mop")# Load modelvdp = JMUModel(jmu_name)# Optimize model, default settingsres = vdp.optimize()# numpy arrays for analysisx1 = res[’x1’]x2 = res[’x2’]u = res[’u’]t = res[’time’]



6. Tools / 6.2.2 Optimierung mit JModelica.orgPython-Optimierungsskript VDPOpt.py (Fortsetzung)// graphical outputplt.figure(1)plt.clf()plt.subplot(311)plt.plot(t,x1)plt.grid()plt.ylabel(’x1’)plt.subplot(312)plt.plot(t,x2)plt.grid()plt.ylabel(’x2’)plt.subplot(313)plt.plot(t,u)plt.grid()plt.ylabel(’u’)plt.xlabel(’time’)plt.show()




Optimierungsmodell, Bsp. 2: Doppelintegrator, zeitoptimaleUmsteuerung, freie Endzeit, fester Anfangs- und Endzustand,Steuerbeschränkung

minu(t)

tf∫

t0

1dt = tf − t0

x1(t) = x2(t), x1(0) = 0 , x1(tf ) = 1

x2(t) = u(t) , x2(0) = 0 , x2(tf ) = 0

t ∈ [t0 = 0, tf = 1]

g (u(t)) =

[u(t)− 5−u(t)− 5

]≤[

00

]



6. Tools / 6.2.2 Optimierung mit JModelica.orgModelica-Optimierungsmodell DITimeOpt.mopoptimization DITimeOpt (objective = finalTime,

startTime = 0,finalTime(free=true,min=0.2,initialGuess=1))

Real x1(start=0,fixed=true); // statesReal x2(start=0,fixed=true);input Real u; // control signalReal cost(start=0,fixed=false); // cost functional

equationder(x1) = x2; // process eauationder(x2) = u;der(cost) = 1; // cost functional

constraintx1(finalTime)=1; // fixed final statesx2(finalTime)=0;u <= 5; // control constraintsu >= -5;

end DITimeOpt;



6. Tools / 6.2.2 Optimierung mit JModelica.orgPython-Optimierungsskript DITimeOpt.py# import numerical librariesimport numpy as N# Import the function for compilation of models and the JMUModel classfrom pymodelica import compile_jmufrom pyjmi import JMUModel# Import the plotting libraryimport matplotlib.pyplot as plt# Compile modeljmu_name = compile_jmu("DITimeOpt","DITimeOpt.mop")# Load modelditime = JMUModel(jmu_name)# optimize model, default settingsres = ditime.optimize()x1 = res[’x1’]x2 = res[’x2’]u = res[’u’]tf=res[’finalTime’]t = res[’time’]



6. Tools / 6.2.2 Optimierung mit JModelica.orgPython-Optimierungsskript DITimeOpt.py (Fortsetzung)// graphical outputplt.figure(1)plt.clf()plt.subplot(311)plt.plot(t,x1)plt.grid()plt.ylabel(’x1’)plt.subplot(312)plt.plot(t,x2)plt.grid()plt.ylabel(’x2’)plt.subplot(313)plt.plot(t,u)plt.grid()plt.ylabel(’u’)plt.xlabel(’time’)plt.show()



6. Tools / 6.3 Weitere ToolsOpenModelica Notebook (OMNotebook)

Fortgeschrittenes Lehrwerkzeug für Modelica

DrControl unter OMNotebook

Interaktives Kursmaterial für Regelungstechnik

OMWeb, OMOptim, MDT, OMPython

Web-basiertes Lernen

Optimierung in der Technik

Entwicklungsumgebung (Eclipse)

Zusammenwirken mit Python

Tools: siehe https://www.openmodelica.org/index.php/home/tools



https://www.openmodelica.org/index.php/home/tools

5. Literatur I

Modelon AB.

JModelica.org User Guide. Version 1.7.

Modelon AB, 2012.

J. Åkesson.

Optimica - An Extension of Modelica Supporting Dynamic Optimization.

In Proc. Modelica Conference, pages 57 – 66, 2008.

J. Åkesson, T. Bergdahl, M. Gäfvert, and H. Tummescheit.

Modeling and Optimization with Modelica and Optimica Using the JModelica.org Open Source Platform.

In Proc. Modelica Conference, pages 29 – 38, 2009.

DOI:10.3384/ecp09430057.



5. Literatur IIModelica Association.

Modelica homepage.

www.modelica.org, 2009.

Modelica Association.

ModelicaTM - A Unified Object-Oriented Language for Physical Systems Modeling - Tutorial.

http://www.modelica.org/documents/ModelicaTutorial14.pdf, 2009.

B. Bachmann.

Modelica Tutorial for Beginners - Exercises with Dymola.

FH Bielefeld, 2002.

B. Bachmann.

Modelica Tutorial for Beginners - Multi-domain modeling and simulation.

FH Bielefeld, 2002.



5. Literatur IIIB. Bachmann.

Mathematical Aspects of Object-Oriented Modeling and Simulation.

4th International Modelica Conference. Hamburg-Harburg, 2005.

B. Bachmann and P. Fritzson.

Mathematical Modelingwith Modelica. Teaching with Active Electronic Notebook.

Workshop on Modelica for Education. Berlin, 2009.

F. E. Cellier.

Continuous System Modeling.

Springer, 1991.

F. E. Cellier and E. Kofman.

Continuous System Simulation.

Springer, 2006.



5. Literatur IVOpen Source Modelica Consortium.

The OpenModelica Project.

www.ida.liu.se/∼ pelab/modelica/OpenModelica.html, 2009.

H. Elmquist, H. Olsson, and M. Otter.

Advanced Modelica Tutorial.

Modelica Conference. Oberpfaffenhofen, 2002.

P. Fritzson.

Principles of Object-Oriented Modeling and Simulation with Modelica 2.1.

IEEE Press. Wiley-Interscience, 2004.

P. Fritzson.

Tutorial - Introduction to Object-Oriented Modeling and Simulation with OpenModelica.

http://www.ida.liu.se/labs/∼ pelab/modelica/OpenModelica/Documents/ModelicaTutorialFritzson.pdf, 2006.



5. Literatur VH.Elmquist, S.E. Matsson, M. Otter, and H. Tummescheit.

Exercises for Modelica Tutorial.

Modelica Conference. Oberpfaffenhofen, 2002.

M. Otter.

Objektorientierte Modellierung Physikalischer Systeme, Teil 1.

at - Automatisierungstechnik, 47(1):A1–A4 und weitere 15 Teile von OTTER, M. als Haupt– bzw. Co–Autor undanderer Autoren, 1999.

Dassault Systemes.

Dymola - Multi-Engineering Modeling and Simulation.

www.3ds.com/products/catia/portfolio/dymola, 2009.

M. Tiller.

Introduction to Physical Modeling with Modelica.

Kluwer, 2001.

