Modelica Language Concepts and Textual Modeling Classes and Inheritance
Typed Declarative Equation-based Textual Language
Hybrid Modeling
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Acausal Modeling
The order of computations is not decided at modeling time
Acausal Causal
Visual Component Level
Equation Level
A resistor equation: R*i = v;
Causal C l possibilities: ibiliti i := v/R; v := R*i; R := v/i;
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Typical Simulation Process
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
What is Special about Modelica?
Multi-Domain Modeling Visual acausal hierarchical component modeling Typed declarative equation-based textual language Hybrid modeling and simulation
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
What is Special about Modelica?
Multi-Domain Modeling
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
What is Special about Modelica?
Multi-Domain Modeling
Keeps the physical structure
Visual Acausal Hierarchical Component Modeling
Acausal model (Modelica)
Causal block-based model (Simulink)
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
What is Special about Modelica?
Multi-Domain Modeling
k2 i qddRef qdRef 1 S qRef 1 S k1 i r3Control r3Motor
Hierarchical system modeling
cut joint
r3Drive1 1
axis6
tn
qd
axis5
Visual Acausal Hierarchical Component Modeling
l
qdRef
Kd
S
0.03
Jmotor=J rel joint=0
spring=c
axis4
+1
b(s)
340.8 S
0.3
+1
a(s)
fric=Rv0
qRef
pSum
Kv
sum
w Sum
rate2
rate3
iRef
S
gear=i
axis3
rate1 b(s) a(s) tacho2 b(s) a(s) tacho1 PT1
g5
axis2
Rp2 2=50 Ra=250 La=(250/(2*D*w m ))
qd
Rd1=100
C=0.004*D/w m
Rp1=200
Srel = n*transpose(n)+(identity(3)n*transpose(n))*cos(q)Rd2=100 Ri=10 skew(n)*sin(q); + + wrela = n*qd; + diff pow er OpI zrela = n*qdd; Sb = Sa*transpose(Srel); Rd4=100 r0b = r0a; vb = Srel*va; g3 wb = Srel*(wa + wrela); g1 ab = Srel*aa; zb = Srel*(za + zrela + cross(wa, wrela));
Rd3=100 Vs hall2
axis1
emf
y x inertial
w r
Courtesy of Martin Otter
hall1
g2
qd
g4
Peter Fritzson 7 Courtesy of Martin Otter
Copyright Open Source Modelica Consortium
pelab
What is Special about Modelica?
Multi-Domain Modeling Visual Acausal Hierarchical A textual class-based language Component OO primary used for as a structuring concept Modeling Behaviour described declaratively using Differential algebraic equations (DAE) (continuous-time) Event triggers (discrete-time)
class VanDerPol "Van der Pol oscillator model" Real x(start = 1) "Descriptive string for x; Real y(start = 1) "y coordinate; parameter Real lambda = 0.3; p equation der(x) = y; der(y) = -x + lambda*(1 - x*x)*y; end VanDerPol;
Variable declarations
Typed Declarative Equation-based Textual Language
8
Peter Fritzson
Differential equations
Copyright Open Source Modelica Consortium
pelab
What is Special about Modelica?
Multi-Domain Modeling Hybrid modeling = continuous-time + discrete-time modeling Continuous-time Discrete-time Visual Acausal Component Modeling
Typed Declarative Equation-based Textual Language
9
Peter Fritzson Copyright Open Source Modelica Consortium
time
Hybrid Modeling
pelab
Modelica Classes and Inheritance
10
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Simplest Model Hello World! A Modelica Hello World model
Equation: x = - x Initial condition: x(0) = 1
class HelloWorld "A simple equation" Real x(start=1); equation der(x)= -x; end HelloWorld;
Simulation in OpenModelica environment
1 0.8 0.6 0.4 0.2
simulate(HelloWorld, stopTime = 2) plot(x)
0.5
1.5
11
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Model Including Algebraic Equations Include algebraic equation
Algebraic equations contain no derivatives
class DAEexample Real x(start=0.9); Real y; equation der(y)+(1+0.5*sin(y))*der(x) = sin(time); x - y = exp(-0.9*x)*cos(y); end DAEexample;
Simulation in OpenModelica environment
1.20 1.15 1.10 1.05 1.0 0.2 0.95 0.90 0.4 0.6 0.8 1 time
simulate(DAEexample, stopTime = 1) plot(x)
12
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Example class: Van der Pol Oscillator
class VanDerPol "Van der Pol oscillator model" Real x(start = 1) "Descriptive string for x"; // Real y(start = 1) "y coordinate"; // parameter Real lambda = 0.3; equation d (x) der ( ) = y; // This hi i is the h der(y) = -x + lambda*(1 - x*x)*y; /* This is the end VanDerPol; x starts at 1 y starts at 1
1st diff equation i // 2nd diff equation */
simulate(VanDerPol,stopTime = 25) plotParametric(x,y)
-2 -1
1 -1
-2
13
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Exercises Simple Textual Modeling
Start S OMNotebook O
Start->Programs->OpenModelica->OMNotebook Open File: Exercise01-classes-simple-textual.onb
Open Exercise01-classes-simple-textual.pdf
14
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Exercises 2.1 and 2.2
Open the Exercise01-classes-simple-textual.onb found in the Tutorial directory. Locate the VanDerPol model in DrModelica (link from S ti 2 Section 2.1), 1) using i OMN OMNotebook! t b k! Exercise 2.1: Simulate and plot VanDerPol. Do a slight change in the model, re-simulate and re-plot. Exercise 2.2. Simulate and plot the HelloWorld example. Do a slight change in the model, re-simulate and re-plot. Try command-completion, val( ), etc.
class HelloWorld "A simple equation" Real x(start=1); equation simulate(HelloWorld, stopTime = 2) der(x)= -x; plot(x) end HelloWorld;
15
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Variables and Constants Built-in primitive data types
Boolean true or false Integer Integer value value, e e.g. g 42 or 3 3 Real Floating point value, e.g. 2.4e-6 String String, e.g. Hello world Enumeration Enumeration literal e.g. ShirtSize.Medium
16
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Variables and Constants cont Names indicate meaning of constant Easier to maintain code Parameters are constant during simulation Two types of constants in Modelica
constant parameter
constant constant constant parameter Real String Integer Real PI=3.141592653589793; redcolor = "red" "red"; one = 1; mass = 22.5;
17
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Comments in Modelica
1) Declaration comments, e.g. Real x "state variable";
class VanDerPol "Van der Pol oscillator model" Real x(start = 1) "Descriptive Descriptive string for x x ; // Real y(start = 1) "y coordinate; // parameter Real lambda = 0.3; equation der(x) = y; // This is the der(y) = -x + lambda*(1 - x*x)*y; /* This is the end VanDerPol; x starts at 1 y starts at 1
1st diff equation // 2nd diff equation */
2) Source code comments, disregarded by compiler 2a) C style, e.g. /* This is a C style comment */ 2b) C++ style, e.g. // Comment to the end of the line
pelab
18
Peter Fritzson
Copyright Open Source Modelica Consortium
A Simple Rocket Model
Rocket
apollo13
thrust mg
thrust mass gravity mass mass = massLossRate abs ( thrust ) acceleration = altitude = velocity velocity = acceleration
declaration comment
new model parameters (changeable before the simulation) floating point type
differentiation with regards to time
class Rocket "rocket class" parameter String name; Real mass(start=1038.358); Real altitude(start= 59404); Real velocity(start= -2003); Real acceleration; Real thrust; // Thrust force on rocket Real gravity; i // Gravity i forcefield i parameter Real massLossRate=0.000277; equation (thrust-mass*gravity)/mass = acceleration; der(mass) = -massLossRate * abs(thrust); der(altitude) = velocity; der(velocity) = acceleration; end Rocket;
start value
name + default value mathematical equation (acausal)
19
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Celestial Body Class A class declaration creates a type name in Modelica
class CelestialBody constant Real parameter Real parameter String parameter Real end CelestialBody; g = 6.672e-11; radius; name; mass;
An instance of the class can be declared by prefixing the type name to a variable name
... CelestialBody moon; ...
The declaration states that moon is a variable containing an object of type CelestialBody
pelab
20
Peter Fritzson
Copyright Open Source Modelica Consortium
10
Moon Landing
Rocket
apollo13
thrust mg altitude
apollo. gravity =
moon. g moon.mass (apollo.altitude + moon.radius )2
CelestialBody
class MoonLanding parameter Real force1 = 36350; parameter Real force2 = 1308; protected parameter Real thrustEndTime = 210; parameter Real thrustDecreaseTime = 43.2; public Rocket apollo(name "apollo13") apollo(name="apollo13"); CelestialBody moon(name="moon",mass=7.382e22,radius=1.738e6); equation apollo.thrust = if (time < thrustDecreaseTime) then force1 else if (time < thrustEndTime) then force2 else 0; apollo.gravity=moon.g*moon.mass/(apollo.altitude+moon.radius)^2; end MoonLanding;
only access inside the class access by dot t ti outside t id notation the class
21
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Simulation of Moon Landing
simulate(MoonLanding, stopTime=230) plot(apollo.altitude, xrange={0,208}) plot(apollo.velocity, xrange={0,208})
30000 50 25000 -100 20000 -200 15000 10000 5000 50 100 150 200 -300 -400 100 150 200
It starts at an altitude of 59404 (not shown in the diagram) at time zero, gradually reducing it until touchdown at the lunar surface when the altitude is zero
22
Peter Fritzson
The rocket initially has a high negative velocity when approaching the lunar surface. This is reduced to zero at touchdown, giving a smooth landing
Copyright Open Source Modelica Consortium
pelab
11
Restricted Class Keywords
The class keyword can be replaced by other keywords, e.g.: model, record, block, connector, function, ... Classes declared with such keywords have restrictions Restrictions apply to the contents of restricted classes Example: A model is a class that cannot be used as a connector class Example: A record is a class that only contains data, with no equations Example: A block is a class with fixed input-output causality
model CelestialBody constant Real parameter Real parameter String parameter Real end CelestialBody;
23
Peter Fritzson Copyright Open Source Modelica Consortium
g = 6.672e-11; radius; name; mass;
pelab
Modelica Functions Modelica Functions can be viewed as a special kind of restricted class with some extensions A function can be called with arguments arguments, and is instantiated dynamically when called More on functions and algorithms later in Lecture 4
function sum input Real arg1; input Real arg2; output Real result; algorithm result := arg1+arg2; end sum;
24
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
12
Inheritance
parent class to Color restricted kind of class without equations
child class or subclass keyword denoting inheritance
record ColorData parameter Real red = 0.2; parameter Real blue = 0.6; Real green; end ColorData; class Color extends ColorData; equation red + blue + green = 1; end Color;
class l E ExpandedColor d dC l parameter Real red=0.2; parameter Real blue=0.6; Real green; equation red + blue + green = 1; end ExpandedColor;
Data and behavior: field declarations, equations, and certain other contents are copied into the subclass
25
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Inheriting definitions
Legal! Identical to the inherited field blue
record ColorData parameter Real red = 0.2; 0 2; parameter Real blue = 0.6; Real green; end ColorData; class ErrorColor extends ColorData; parameter Real blue = 0.6; parameter Real red = 0.3; equation q red + blue + green = 1; end ErrorColor;
Inheriting multiple identical definitions results in only one definition
Illegal! Same name, but different value
Inheriting multiple different definitions of the same item is an error
26
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
13
Inheritance of Equations
class Color parameter Real red=0.2; parameter Real blue=0.6; Real green; equation red + blue + green = 1; end Color;
class Color2 // OK! extends Color; equation red + blue + green = 1; end Color2;
Color is identical to Color2 Same equation twice leaves one copy when inheriting
class Color3 // Error! extends Color; equation red + blue + green = 1.0; // also inherited: red + blue + green = 1; end Color3;
Color3 is overdetermined Different equations means two equations!
27
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Multiple Inheritance
Multiple Inheritance is fine inheriting both geometry and color
class l Color l parameter Real red=0.2; parameter Real blue=0.6; Real green; equation red + blue + green = 1; end Color; class Point Real x; Real y,z; end Point; class ColoredPoint extends Point; extends Color; end ColoredPoint;
multiple inheritance
class ColoredPointWithoutInheritance Real x; Real y, z; parameter Real red = 0.2; parameter Real blue = 0.6; Real green; equation red + blue + green = 1; end ColoredPointWithoutInheritance;
Equivalent to
28
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
14
Multiple Inheritance cont
Only one copy of multiply inherited class Point is kept
class Point Real x; Real l y; end Point;
class VerticalLine extends Point; Real vlength; end VerticalLine;
Diamond Inheritance
class HorizontalLine extends Point; Real hlength; end HorizontalLine;
class Rectangle extends VerticalLine; extends HorizontalLine; end Rectangle;
29
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Simple Class Definition Shorthand Case of Inheritance Example:
class SameColor = Color;
Often used for introducing new names of f types:
type Resistor = Real;
Equivalent to:
inheritance
class SameColor extends Color; end SameColor;
connector MyPin = Pin;
30
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
15
Inheritance Through Modification Modification is a concise way of combining inheritance with declaration of classes or instances A modifier modifies a declaration equation in the inherited class Example: The class Real is inherited, modified with a different start value equation, and instantiated as an altitude variable:
... Real altitude(start= 59404); ...
31
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
The Moon Landing Example Using Inheritance
Rocket
apollo13
thrust mg
model Rocket "generic rocket class" extends Body; parameter Real massLossRate=0.000277; Real altitude(start= 59404); Real velocity(start= -2003); Real acceleration; Real thrust; Real gravity; equation thrust-mass*gravity= mass*acceleration; der(mass)= -massLossRate*abs(thrust); der(altitude)= velocity; d (velocity)= der ( l it ) acceleration; l ti end Rocket;
altitude
CelestialBody
model Body "generic body" Real mass; String name; end Body;
model CelestialBody extends Body; constant Real g = 6.672e-11; parameter Real radius; end CelestialBody;
32
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
16
The Moon Landing Example using Inheritance cont
inherited parameters
model MoonLanding parameter Real force1 = 36350; parameter Real force2 = 1308; parameter Real thrustEndTime = 210; parameter Real thrustDecreaseTime = 43.2; Rocket apollo(name="apollo13", mass(start=1038.358) ); CelestialBody moon(mass=7.382e22,radius=1.738e6,name="moon"); equation apollo.thrust = if (time<thrustDecreaseTime) then force1 else if (time<thrustEndTime) then force2 else 0; apollo.gravity apo o.g a ty =moon.g*moon.mass/(apollo.altitude+moon.radius)^2; oo .g oo . ass/(apo o.a t tude oo . ad us) ; end Landing;
33
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Inheritance of Protected Elements
If an extends-clause is preceded by the protected keyword, all inherited elements from the superclass become protected elements of the subclass
class Color Real red; Real blue; Real green; equation red + blue + green = 1; end Color; class Point Real x; Real y,z; end Point; class ColoredPoint protected extends Color; public extends Point; end ColoredPoint;
Equivalent to
class ColoredPointWithoutInheritance Real x; Real y,z; protected Real red; protected Real blue; protected Real green; equation red + blue + green = 1; end ColoredPointWithoutInheritance;
The inherited fields from Point keep their protection status since that extends-clause is preceded by public A protected element cannot be accessed via dot notation!
34
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
17
Advanced Topic Class parameterization
35
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Generic Classes with Type Parameters
Formal class parameters are replaceable variable or type declarations within the class (usually) marked with the prefix replaceable
Actual arguments to classes are modifiers, which when containing whole variable declarations or types are preceded by the prefix redeclare
class C replaceable class ColoredClass = GreenClass; ColoredClass obj1(p1=5); replaceable YellowClass obj2; ColoredClass obj3; R dCl RedClass obj4 bj4; equation end C; class C2 = C(redeclare class ColoredClass = BlueClass);
ColoredClass object
ColoredClass object GreenClass A yellow object
Equivalent to
class C2 BlueClass YellowClass BlueClass RedClass equation end C2; obj1(p1=5); obj2; obj3; obj4;
A red object
36
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
18
Class Parameterization when Class Parameters are Components
R1
AC
R2
L1
R3
The class ElectricalCircuit has been converted into a parameterized generic class GenericElectricalCircuit with three formal class parameters R1, R2, R3, marked by the keyword replaceable
class ElectricalCircuit Resistor R1(R=100); Resistor R2(R=200); Resistor R3(R=300); Inductor L1; SineVoltage AC; Groung G; equation ti connect(R1.n,R2.n); connect(R1.n,L1.n); connect(R1.n,R3.n); connect(R1.p,AC.p); ..... end ElectricalCircuit;
Class parameterization
class GenericElectricalCircuit replaceable Resistor R1(R=100); replaceable Resistor R2(R=200); replaceable Resistor R3(R=300); Inductor L1; SineVoltage AC; Groung G; equation connect(R1.n,R2.n); connect(R1.n,L1.n); connect(R1.n,R3.n); connect(R1.p,AC.p); ..... end GenericElectricalCircuit;
37
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Class Parameterization when Class Parameters are Components - cont
R1
A more specialized class TemperatureElectricalCircuit is created by changing the types of R1, R3, to TempResistor
R2 L1
2
AC
R3
class TemperatureElectricalCircuit = GenericElectricalCircuit (redeclare TempResistor R1 redeclare TempResistor R3);
We add a temperature variable Temp for class TemperatureElectricalCircuit the temperature of the resistor circuit parameter Real Temp=20; and modifiers for R1 and R3 which are extends GenericElectricalCircuit( now TempResistors. redeclare TempResistor R1(RT=0.1, Temp=Temp), redeclare TempResistor R3(R=300)); end TemperatureElectricalCircuit class ExpandedTemperatureElectricalCircuit parameter Real Temp; TempResistor R1(R=200, RT=0.1, Temp=Temp), replaceable Resistor R2; TempResistor R3(R=300); equation equivalent to .... end ExpandedTemperatureElectricalCircuit
38
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
19
Exercises 1 Simple Textual Continued
C Continue exercises in Exercise01-classessimple-textual.onb Do Exercises 1.3, 1.4, 1.5 and 2
39
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
Exercise 1.3 Model the System Below Model this Simple System of Equations in Modelica
40
Peter Fritzson
Copyright Open Source Modelica Consortium
pelab
20
