Graphical Annotations

1 Graphical Representation of Resistor

The example below shows the use of graphical attributes in the form of annotations to define the different parts of the Resistor icon.

1.1 Electrical units

type Voltage = ElectricPotential; type Current = ElectricCurrent;

1.2 Electrical Connectors

connector Pin "Pin of an electrical component" Voltage v "Potential at the pin"; flow Current i "Current flowing into the pin"; end Pin; //From Modelica.Electrical.Analog.Interfaces

1.3 Resistor

model Resistor //?? Uses old or new Modelica annotations Pin p annotation(extent = [-110, -10, -90, 10], style(fillPattern = 1)); Pin n annotation(extent = [110, -10, 90, 10]); parameter Real R "Resistance in [Ohm]"; equation R*p.i = p.v - n.v; n.i = p.i; public annotation(Icon( Rectangle(extent = [-70, -30, 70, 30], style(fillPattern = 1)), Text(extent =[-100, 55; 100, 110], string = "%name = %R"), Line(points = [-90, 0; -70, 0]), Line(points = [70, 0; 90, 0]) )); end Resistor;

2 Graphical Annotation Attributes

There are a number of predefined graphical annotation attributes, which can be divided into basic attributes; built-in attributes to classes, instances, and connections; and attributes that are graphical elements to specify the appearance of class icons.

2.1 Basic Attributes

The basic attribute classes are Point, Extent, and Style with the corresponding attributes point, extent, and style.

type Point = Real[2]; // {x, y}
type Extent = Real[2, 2]; // [x1, y1; x2, y2]
record Style Integer color[3], fillColor[3]; // RGB Integer pattern, fillPattern, thickness, gradient, // ??Explanations smooth, arrow, textStyle; String font; end Style;

2.2 Built-in Attributes to Classes, Instances and Connections

The annotation elements CoordinateSystem, Placement, and Route below are by default associated with classes, instances, and connection equations respectively. This means that these elements including their attributes exist even if they are not mentioned explicitly in the annotations of these entities. The Route annotation element also has alternative names such as Line and Polygon defined in the next section.

record CoordinateSystem // Attribute to class Extent extent; Point grid; Point size; end CoordinateSystem;
record Placement // Attribute for components Extent extent; Real rotation; end Placement;
record Route // Attribute for connect equations Point points[:]; Style style; String label; end Route;

2.3 Definitions of Graphical Elements

The following predefined graphical elements are used as graphical annotation elements including annotation attributes when defining the appearance of class icons. The Line graphical element can also be used for connection lines.

record Line = Route;
record Polygon = Route;
record GraphicItem Extent extent; Style style; end GraphicItem;
record Rectangle = GraphicItem;
record Ellipse = GraphicItem;
record Text extends GraphicItem; String string; end Text;
record BitMap extends GraphicItem; String URL; // Name of Bitmap file end BitMap;

2.4 Choices Annotations for Variables and Enumerations Types

The choices annotation is applicable to both replaceable and nonreplaceable elements. For example, consider the following Integer type called KindOfController used to represent a choice of controller in the modeling process. This choice is made from the following enumeration of three recommended alternatives:

type KindOfController = Integer(min = 1,max = 3) annotation(choices( choice = 1 "P", choice = 2 "PI", choice = 3 "PID"));

Assume that KindOfController is used in a model A as below:

model A parameter KindOfController x; end A;

If you interactively choose the third alternative from the menu this corresponds to giving the default value 3 for the instantiated variable x in the following code for an instance a2 of the model A:

class AInst A a2(x=3 "PID"); end AInst;

2.5 Choices Annotations for Replaceable Model Elements

The choices annotation can also be used to generate menus with redeclaration alternatives for replaceable models. For example, consider the following replaceable model with a choices annotation:

2.6 Resistor

model Resistor Pin p annotation(extent = [-110, -10, -90, 10], style(fillPattern = 1)); Pin n annotation(extent = [110, -10, 90, 10]); parameter Real R "Resistance in [Ohm]"; equation R*p.i = p.v - n.v; n.i = p.i; public annotation(Icon( Rectangle(extent = [-70, -30, 70, 30], style(fillPattern = 1)), Text(extent =[-100, 55; 100, 110], string = "%name = %R"), Line(points = [-90, 0; -70, 0]), Line(points = [70, 0; 90, 0]) )); end Resistor;

2.7 MyResistor

class ResistorAnnotation replaceable model MyResistor = Resistor annotation(choices( choice(redeclare model MyResistor = lib2.Resistor "Resistor 1"), choice(redeclare model MyResistor = lib2.Resistor2 "Resistor 2"))); end ResistorAnnotation;

2.8 MyCircuit

If the user would choose the first alternative, the following code might be produced if MyResistor is part of the class MyCircuit and the chosen name of the instantiated component is x:

model MyCircuit model MyResistorModel extends Electrical.Interfaces.ResistorModel; // declarations and equations end MyResistorModel; encapsulated package MyComponents = Electrical.Components (redeclare model ResistorModel = MyResistorModel); MyComponents.Transformer tr1; MyComponents.Transducer td2; // ... end MyCircuit;
class MyCircuitInst MyCircuit x(redeclare model MyResistor = lib2.Resistor); end MyCircuitInst;

2.9 Additional Examples of Replaceable Class Declarations

Additional examples of replaceable class declarations with redeclaration choices are shown below. In the first example you can choose between a resistor and a capacitor as choices of components with two pins, and in the second example a friction function is implemented as a constant, a table, or defined as an exponentiation function depending on your choice.

class NewResistor replaceable Resistor Load(R=2) extends TwoPin; annotation(choices( choice(redeclare lib2.Resistor Load(a={2}) "Resistor"), choice(redeclare Capacitor Load(L=3) "Capacitor"))); end NewResistor;
class NewFrictionFunction replaceable FrictionFunction a(func = exp) extends TwoPin; annotation(choices( choice(redeclare ConstantFriction a(c = 1) "Friction Constant"), choice(redeclare TableFriction a(table = "...") "Friction-table"), choice(redeclare FunctionFriction a(func = exp) "Friction-exp") )); end NewFrictionFunction;