Ticket #3167: Test6Total.mo

File Test6Total.mo, 25.1 KB (added by lochel, 10 years ago)
Line 
1package PNlib
2
3  model PC "Continuous Place"
4    Real t = if t_ < minMarks then minMarks else t_ "marking";
5    Real tSumIn(fixed = true, start = 0.0);
6    Real tSumIn_[nIn](each fixed = true, each start = 0.0);
7    Real tSumOut(fixed = true, start = 0.0);
8    Real tSumOut_[nOut](each fixed = true, each start = 0.0);
9    parameter Integer nIn = 0 "number of input transitions" annotation(Dialog(connectorSizing = true));
10    parameter Integer nOut = 0 "number of output transitions" annotation(Dialog(connectorSizing = true));
11    // *** MODIFIABLE PARAMETERS AND VARIABLES BEGIN ***
12    parameter Real startMarks = 0 "start marks" annotation(Dialog(enable = true, group = "Marks"));
13    parameter Real minMarks(min=0) = 0 "minimum capacity" annotation(Dialog(enable = true, group = "Marks"));
14    parameter Real maxMarks(min=minMarks) = PNlib.Constants.inf
15    "maximum capacity"                                                             annotation(Dialog(enable = true, group = "Marks"));
16    // *** MODIFIABLE PARAMETERS AND VARIABLES END ***
17protected
18    Real t_(start = startMarks, fixed = true) "marking";
19    Real arcWeightIn[nIn] "weights of input arcs";
20    Real arcWeightOut[nOut] "weights of output arcs";
21    Real instSpeedIn[nIn] "instantaneous speed of input transitions";
22    Real instSpeedOut[nOut] "instantaneous speed of output transitions";
23    Real maxSpeedIn[nIn] "maximum speed of input transitions";
24    Real maxSpeedOut[nOut] "maximum speed of output transitions";
25    Real prelimSpeedIn[nIn] "preliminary speed of input transitions";
26    Real prelimSpeedOut[nOut] "preliminary speed of output transitions";
27    Boolean fireIn[nIn](each start = false, each fixed = true)
28    "Does any input transition fire?";
29    Boolean fireOut[nOut](each start = false, each fixed = true)
30    "Does any output transition fire?";
31    Boolean activeIn[nIn] "Are the input transitions active?";
32    Boolean activeOut[nOut] "Are the output transitions active?";
33    Boolean enabledByInPlaces[nIn]
34    "Are the input transitions enabled by all their input places?";
35    // *** BLOCKS BEGIN ***
36    // since no events are generated within functions!!!
37    Boolean feeding = Functions.anyTrue(pre(fireIn))
38    "Is the place fed by input transitions?";
39    Boolean emptying = Functions.anyTrue(vec=  pre(fireOut))
40    "Is the place emptied by output transitions?";
41    Real firingSumIn = Functions.firingSumCon(fire=pre(fireIn), arcWeight=arcWeightIn, instSpeed=instSpeedIn)
42    "firing sum calculation";
43    Real firingSumOut = Functions.firingSumCon(fire=  pre(fireOut), arcWeight=  arcWeightOut, instSpeed=  instSpeedOut)
44    "firing sum calculation";
45    // *** BLOCKS END ***
46public
47    Interfaces.PlaceIn inTransition[nIn](each t = t_, each maxTokens = maxMarks, enable = activeIn, each emptied = emptying, each speedSum = firingSumOut, fire = fireIn, active = activeIn, arcWeight = arcWeightIn, instSpeed = instSpeedIn, maxSpeed = maxSpeedIn, prelimSpeed = prelimSpeedIn, enabledByInPlaces = enabledByInPlaces)
48    "connector for input transitions"                                                                                                     annotation(Placement(transformation(origin = {-93, 0}, extent = {{-10, -10}, {10, 10}}, rotation = 0), iconTransformation(origin = {-93, 0}, extent = {{-10, -10}, {10, 10}})));
49    Interfaces.PlaceOut outTransition[nOut](each t = t_, each minTokens = minMarks, enable = activeOut, each arcType = PNlib.Types.ArcType.normal_arc, each testValue = -1.0, each fed = feeding, each speedSum = firingSumIn, fire = fireOut, active = activeOut, arcWeight = arcWeightOut, instSpeed = instSpeedOut, maxSpeed = maxSpeedOut, prelimSpeed = prelimSpeedOut)
50    "connector for output transitions"                                                                                                     annotation(Placement(transformation(origin = {93, 0}, extent = {{-10, -10}, {10, 10}}, rotation = 0), iconTransformation(origin = {93, 0}, extent = {{-10, -10}, {10, 10}})));
51    //initial equation
52    //  fireIn = pre(fireIn);
53    //  fireOut = pre(fireOut);
54  equation
55    // *** MAIN BEGIN ***
56    der(tSumIn) = firingSumIn;
57    // der(tSumIn_) = arcWeightIn .* instSpeedIn;
58    for i in 1:nIn loop
59      der(tSumIn_[i]) = if pre(fireIn[i]) then arcWeightIn[i] * instSpeedIn[i] else 0.0;
60    end for;
61    der(tSumOut) = firingSumOut;
62    // der(tSumOut_) = arcWeightOut .* instSpeedOut;
63    for i in 1:nOut loop
64      der(tSumOut_[i]) = if pre(fireOut[i]) then arcWeightOut[i] * instSpeedOut[i] else 0.0;
65    end for;
66    der(t_) = firingSumIn - firingSumOut
67    "calculation of continuous mark change";
68    // *** MAIN END ***
69    // *** ERROR MESSENGES BEGIN ***
70    assert(startMarks >= minMarks and startMarks <= maxMarks, "minMarks <= startMarks <= maxMarks");
71    // *** ERROR MESSENGES END ***
72    annotation(defaultComponentName = "P1", Diagram(coordinateSystem(extent = {{-100, -100}, {100, 100}}, preserveAspectRatio = false), graphics), Icon(coordinateSystem(extent = {{-100, -100}, {100, 100}}, preserveAspectRatio = false, initialScale = 0.1, grid = {2, 2}), graphics={  Ellipse(fillColor = {255, 255, 255},
73              fillPattern =                                                                                                    FillPattern.Solid, extent = {{-86, 86}, {86, -86}}, endAngle = 360), Ellipse(fillColor = {255, 255, 255},
74              fillPattern =                                                                                                    FillPattern.Solid, extent = {{-79, 79}, {79, -79}}, endAngle = 360), Text(origin = {0.5, -0.5}, extent = {{-1.5, 25.5}, {-1.5, -21.5}}, textString = DynamicSelect("%startMarks", if t > 0 then realString(t, 1, 2) else "0.0")), Text(extent = {{-74, -103}, {-74, -128}}, textString = "%name")}));
75  end PC;
76
77  model TC "Continuous Transition"
78    parameter Integer nIn = 0 "number of input places" annotation(Dialog(connectorSizing = true));
79    parameter Integer nOut = 0 "number of output places" annotation(Dialog(connectorSizing = true));
80    // *** MODIFIABLE PARAMETERS AND VARIABLES BEGIN ***
81    Real maximumSpeed = 1 "maximum speed" annotation(Dialog(enable = true, group = "Maximum Speed"));
82    Real arcWeightIn[nIn] = fill(1, nIn) "arc weights of input places" annotation(Dialog(enable = true, group = "Arc Weights"));
83    Real arcWeightOut[nOut] = fill(1, nOut) "arc weights of output places" annotation(Dialog(enable = true, group = "Arc Weights"));
84    // *** MODIFIABLE PARAMETERS AND VARIABLES END ***
85    Boolean fire "Does the transition fire?";
86    Real instantaneousSpeed "instantaneous speed";
87    Real actualSpeed = if fire then instantaneousSpeed else 0.0;
88    Interfaces.TransitionOut[nOut] outPlaces(each active = activation.active, each fire = fire, each enabledByInPlaces = true, arcWeight = arcWeightOut, each instSpeed = instantaneousSpeed, each prelimSpeed = preliminarySpeed, each maxSpeed = maximumSpeed, t = tOut, maxTokens = maxTokens, emptied = emptied, speedSum = speedSumOut)
89    "connector for output places"                                                                                                     annotation(Placement(transformation(origin = {47, 0}, extent = {{-10, -10}, {10, 10}}, rotation = 0), iconTransformation(origin = {47, 0}, extent = {{-10, -10}, {10, 10}})));
90    Interfaces.TransitionIn[nIn] inPlaces(each active = activation.active, each fire = fire, arcWeight = arcWeightIn, each instSpeed = instantaneousSpeed, each prelimSpeed = preliminarySpeed, each maxSpeed = maximumSpeed, t = tIn, minTokens = minTokens, fed = fed, enable = enableIn, speedSum = speedSumIn)
91    "connector for input places"                                                                                                     annotation(Placement(visible = true, transformation(origin = {-47, 0}, extent = {{-10, -10}, {10, 10}}, rotation = 0), iconTransformation(origin = {-47, 0}, extent = {{-10, -10}, {10, 10}}, rotation = 0)));
92protected
93    Real tIn[nIn] "tokens of input places";
94    Real tOut[nOut] "tokens of output places";
95    Real minTokens[nIn] "minimum tokens of input places";
96    Real maxTokens[nOut] "maximum tokens of output places";
97    Real speedSumIn[nIn] "Input speeds of continuous input places";
98    Real speedSumOut[nOut] "Output speeds of continuous output places";
99    Boolean fed[nIn] "Are the input places fed by their input transitions?";
100    Boolean emptied[nOut]
101    "Are the output places emptied by their output transitions?";
102    Boolean enableIn[nIn]
103    "Is the transition enabled by all its discrete input transitions?";
104    // *** BLOCKS BEGIN ***
105    // since no events are generated within functions!!!
106    Blocks.activationCon activation(nIn = nIn, nOut = nOut, tIn = tIn, tOut = tOut, arcWeightIn = arcWeightIn, arcWeightOut = arcWeightOut, minTokens = minTokens, maxTokens = maxTokens, fed = fed, emptied = emptied, testValue = inPlaces.testValue, arcType = inPlaces.arcType)
107    "activation process";
108    Real preliminarySpeed = Functions.preliminarySpeed(nIn=  nIn, nOut=  nOut, arcWeightIn=  arcWeightIn, arcWeightOut=  arcWeightOut, speedSumIn=  speedSumIn, speedSumOut=  speedSumOut, maximumSpeed=  maximumSpeed, active=  activation.active, weaklyInputActiveVec=  activation.weaklyInputActiveVec, weaklyOutputActiveVec=  activation.weaklyOutputActiveVec)
109    "preliminary speed calculation";
110    // *** BLOCKS END ***
111  equation
112    // *** MAIN BEGIN ***
113    fire = activation.active and not maximumSpeed <= 0 "firing process";
114    instantaneousSpeed = max(min(maximumSpeed, preliminarySpeed), 0.0)
115    "instantaneous speed calculation";
116    // *** MAIN END ***
117    annotation(defaultComponentName = "T1", Icon(coordinateSystem(preserveAspectRatio = false, extent = {{-100, -100}, {100, 100}}), graphics={  Rectangle(extent = {{-40, 100}, {40, -100}}, lineColor = {0, 0, 0}, fillColor = DynamicSelect({255, 255, 255}, if fire then {255, 255, 0} else {255, 255, 255}),
118              fillPattern =                                                                                                    FillPattern.Solid), Text(extent = {{-2, -116}, {-2, -144}}, lineColor = {0, 0, 0}, textString = DynamicSelect(" ", if animateSpeed == 1 and fire > 0.5 then if instantaneousSpeed > 0 then realString(instantaneousSpeed, 1, 2) else "0.0" else " ")), Text(extent = {{-4, 139}, {-4, 114}}, lineColor = {0, 0, 0}, textString = "%name")}), Diagram(coordinateSystem(preserveAspectRatio = false, extent = {{-100, -100}, {100, 100}}), graphics));
119  end TC;
120
121  package Interfaces
122  "contains the connectors for the Petri net component models"
123
124    connector PlaceIn
125    "part of place model to connect places to input transitions"
126      output Real t "Marking of the place" annotation(HideResult = true);
127      output Real maxTokens "Maximum capacity of the place" annotation(HideResult = true);
128      output Boolean enable
129      "Which of the input transitions are enabled by the place?"                       annotation(HideResult = true);
130      output Boolean emptied
131      "Is the continuous place emptied by output transitions?"                        annotation(HideResult = true);
132      output Real speedSum "Output speed of a continuous place" annotation(HideResult = true);
133      input Boolean active "Are the input transitions active?" annotation(HideResult = true);
134      input Boolean fire "Do the input transitions fire?" annotation(HideResult = true);
135      input Real arcWeight "Arc weights of input transitions" annotation(HideResult = true);
136      input Boolean enabledByInPlaces
137      "Are the input transitions enabled by all theier input places?"                                 annotation(HideResult = true);
138      input Real instSpeed
139      "Instantaneous speeds of continuous input transitions"                      annotation(HideResult = true);
140      input Real prelimSpeed
141      "Preliminary speeds of continuous input transitions"                        annotation(HideResult = true);
142      input Real maxSpeed "Maximum speeds of continuous input transitions" annotation(HideResult = true);
143      annotation(Diagram(graphics={  Polygon(fillColor = {95, 95, 95},
144                fillPattern =                                                        FillPattern.Solid, points = {{-70, 100}, {70, 0}, {-70, -100}, {-70, 100}}, lineColor = {0, 0, 0})}), Icon(coordinateSystem(extent = {{-100, -100}, {100, 100}}, preserveAspectRatio = true, initialScale = 0.1, grid = {2, 2}), graphics={  Polygon(
145                fillPattern =                                                                                                    FillPattern.Solid, points = {{-70, 100}, {70, 0}, {-70, -100}, {-70, 100}})}));
146    end PlaceIn;
147
148    connector PlaceOut
149    "part of place model to connect places to output transitions"
150      output Real t "Marking of the place" annotation(HideResult = true);
151      output Real minTokens "Minimum capacity of the place" annotation(HideResult = true);
152      output Boolean enable
153      "Which of the output transitions are enabled by the place?"                       annotation(HideResult = true);
154      output PNlib.Types.ArcType arcType
155      "Type of output arcs ([1]normal, [2]test, [3]inhibition, or [4]read)"                                    annotation(HideResult = true);
156      output Real testValue "Test value of a test or inhibitor arc" annotation(HideResult = true);
157      output Boolean fed "Is the continuous place fed by input transitions?" annotation(HideResult = true);
158      output Real speedSum "Input speed of a continuous place" annotation(HideResult = true);
159      input Boolean active "Are the output transitions active?" annotation(HideResult = true);
160      input Boolean fire "Do the output transitions fire?" annotation(HideResult = true);
161      input Real arcWeight "Arc weights of output transitions" annotation(HideResult = true);
162      input Real instSpeed
163      "Instantaneous speeds of continuous output transitions"                      annotation(HideResult = true);
164      input Real prelimSpeed
165      "Preliminary speeds of continuous output transitions"                        annotation(HideResult = true);
166      input Real maxSpeed "Maximum speeds of continuous output transitions" annotation(HideResult = true);
167      annotation(Icon(coordinateSystem(extent = {{-100, -100}, {100, 100}}, preserveAspectRatio = true, initialScale = 0.1, grid = {2, 2}), graphics={  Polygon(fillColor = {255, 255, 255},
168                fillPattern =                                                                                                    FillPattern.Solid, points = {{-70, 100}, {70, 0}, {-70, -100}, {-70, 100}})}), Diagram(graphics={  Polygon(fillColor = {215, 215, 215},
169                fillPattern =                                                                                                    FillPattern.Solid, points = {{-72, 100}, {68, 0}, {-72, -100}, {-72, 100}}, lineColor = {0, 0, 0})}));
170    end PlaceOut;
171
172    connector TransitionIn
173    "part of transition model to connect transitions to input places"
174      input Real t "Markings of input places" annotation(HideResult = true);
175      input Real minTokens "Minimum capacites of input places" annotation(HideResult = true);
176      input Boolean enable "Is the transition enabled by input places?" annotation(HideResult = true);
177      input PNlib.Types.ArcType arcType
178      "Type of output arcs ([1]normal, [2]test, [3]inhibition, or [4]read)"                                   annotation(HideResult = true);
179      input Real testValue "Test value of a test or inhibitor arc" annotation(HideResult = true);
180      input Boolean fed "Are the continuous input places fed?" annotation(HideResult = true);
181      input Real speedSum "Input speeds of continuous input places" annotation(HideResult = true);
182      output Boolean active "Is the transition active?" annotation(HideResult = true);
183      output Boolean fire "Does the transition fire?" annotation(HideResult = true);
184      output Real arcWeight "Input arc weights of the transition" annotation(HideResult = true);
185      output Real instSpeed "Instantaneous speed of a continuous transition" annotation(HideResult = true);
186      output Real prelimSpeed "Preliminary speed of a continuous transition" annotation(HideResult = true);
187      output Real maxSpeed "Maximum speed of a continuous transition" annotation(HideResult = true);
188      annotation(Diagram(graphics={  Polygon(fillColor = {95, 95, 95},
189                fillPattern =                                                        FillPattern.Solid, points = {{-70, 100}, {70, 0}, {-70, -100}, {-70, 100}}, lineColor = {0, 0, 0})}), Icon(coordinateSystem(extent = {{-100, -100}, {100, 100}}, preserveAspectRatio = true, initialScale = 0.1, grid = {2, 2}), graphics={  Polygon(
190                fillPattern =                                                                                                    FillPattern.Solid, points = {{-70, 100}, {70, 0}, {-70, -100}, {-70, 100}})}));
191    end TransitionIn;
192
193    connector TransitionOut
194    "part of transition model to connect transitions to output places"
195      input Real t "Markings of output places" annotation(HideResult = true);
196      input Real maxTokens "Maximum capacities of output places" annotation(HideResult = true);
197      input Boolean enable "Is the transition enabled by output places?" annotation(HideResult = true);
198      input Boolean emptied "Are the continuous output places emptied?" annotation(HideResult = true);
199      input Real speedSum "Output speeds of continuous output places" annotation(HideResult = true);
200      output Boolean active "Is the transition active?" annotation(HideResult = true);
201      output Boolean fire "Does the transition fire?" annotation(HideResult = true);
202      output Real arcWeight "Output arc weights of the transition" annotation(HideResult = true);
203      output Boolean enabledByInPlaces
204      "Is the transition enabled by all input places?"                                  annotation(HideResult = true);
205      output Real instSpeed "Instantaneous speed of a continuous transition" annotation(HideResult = true);
206      output Real prelimSpeed "Preliminary speed of a continuous transition" annotation(HideResult = true);
207      output Real maxSpeed "Maximum speed of a continuous transition" annotation(HideResult = true);
208      annotation(Icon(coordinateSystem(extent = {{-100, -100}, {100, 100}}, preserveAspectRatio = true, initialScale = 0.1, grid = {2, 2}), graphics={  Polygon(fillColor = {255, 255, 255},
209                fillPattern =                                                                                                    FillPattern.Solid, points = {{-70, 100}, {70, 0}, {-70, -100}, {-70, 100}})}), Diagram(graphics={  Polygon(fillColor = {215, 215, 215},
210                fillPattern =                                                                                                    FillPattern.Solid, points = {{-70, 100}, {70, 0}, {-70, -100}, {-70, 100}}, lineColor = {0, 0, 0})}));
211    end TransitionOut;
212  end Interfaces;
213
214  package Blocks
215  "contains blocks with specific procedures that are used in the Petri net component models"
216
217    block activationCon "activation process of continuous transitions"
218      parameter input Integer nIn "number of input places";
219      parameter input Integer nOut "number of output places";
220      input Real tIn[:] "marking of input places";
221      input Real tOut[:] "marking of output places";
222      input Real arcWeightIn[:] "arc weights of input places";
223      input Real arcWeightOut[:] "arc weights of output places";
224      input Real minTokens[:] "minimum capacities of input places";
225      input Real maxTokens[:] "maximum capacities of output places";
226      input Boolean fed[:] "input places are fed?";
227      input Boolean emptied[:] "output places are emptied?";
228      input PNlib.Types.ArcType arcType[:] "arc type of input places";
229      input Real testValue[:] "test values of test and inhibitor arcs";
230      output Boolean active "activation of transition";
231      output Boolean weaklyInputActiveVec[nIn]
232      "places that causes weakly input activation";
233      output Boolean weaklyOutputActiveVec[nOut]
234      "places that causes weakly output activation";
235    algorithm
236      active := true;
237      weaklyInputActiveVec := fill(false, nIn);
238      weaklyOutputActiveVec := fill(false, nOut);
239
240      //check input places
241      for i in 1:nIn loop
242        // normal arc
243        if arcType[i] == PNlib.Types.ArcType.normal_arc then
244          if tIn[i] <= minTokens[i] then
245             if fed[i] then
246               weaklyInputActiveVec[i] := true;
247             else
248               active := false;
249             end if;
250          end if;
251        // inhibitor arc
252        elseif arcType[i] == PNlib.Types.ArcType.inhibitor_arc then
253          if not tIn[i] < testValue[i] then
254            active := false;
255          end if;
256        end if;
257      end for;
258
259      //output places
260      for i in 1:nOut loop
261        if tOut[i] >= maxTokens[i] and not emptied[i] then
262          active := false;
263        elseif tOut[i] >= maxTokens[i] and emptied[i] then
264          weaklyOutputActiveVec[i] := true;
265        end if;
266      end for;
267    end activationCon;
268  end Blocks;
269
270  package Functions
271
272    function anyTrue "Is any entry of a Boolean vector true?"
273      input Boolean vec[:];
274      output Boolean anytrue;
275    algorithm
276      anytrue := false;
277      for i in 1:size(vec, 1) loop
278        if vec[i] then
279          anytrue := true;
280        end if;
281      end for;
282    end anyTrue;
283
284    function firingSumCon "calculates the firing sum of continuous places"
285      input Boolean fire[:] "firability of transitions";
286      input Real arcWeight[:] "arc weights";
287      input Real instSpeed[:] "istantaneous speed of transitions";
288      output Real conFiringSum "continuous firing sum";
289    algorithm
290      conFiringSum := 0.0;
291      for i in 1:size(fire, 1) loop
292        if fire[i] then
293          conFiringSum := conFiringSum + arcWeight[i] * instSpeed[i];
294        end if;
295      end for;
296    end firingSumCon;
297
298    function preliminarySpeed
299    "calculates the preliminary speed of a continuous transition"
300      input Integer nIn "number of input places";
301      input Integer nOut "number of output places";
302      input Real arcWeightIn[:] "input arc weights";
303      input Real arcWeightOut[:] "output arc weights";
304      input Real speedSumIn[:] "input speed";
305      input Real speedSumOut[:] "output speed";
306      input Real maximumSpeed "maximum speed";
307      input Boolean active "activation";
308      input Boolean weaklyInputActiveVec[:]
309      "places that causes weakly input activation";
310      input Boolean weaklyOutputActiveVec[:]
311      "places that causes weakly output activation";
312      output Real prelimSpeed "preliminary speed";
313    algorithm
314      prelimSpeed := maximumSpeed;
315      for i in 1:nIn loop
316        if weaklyInputActiveVec[i] and speedSumIn[i] / arcWeightIn[i] < prelimSpeed then
317          prelimSpeed := speedSumIn[i] / arcWeightIn[i];
318        end if;
319      end for;
320      for i in 1:nOut loop
321        if weaklyOutputActiveVec[i] and speedSumOut[i] / arcWeightOut[i] < prelimSpeed then
322          prelimSpeed := speedSumOut[i] / arcWeightOut[i];
323        end if;
324      end for;
325    end preliminarySpeed;
326  end Functions;
327
328  package Constants
329  "contains constants which are used in the Petri net component models"
330
331    constant Real inf = 9.999999999999999e+059
332    "Biggest Real number such that inf and -inf are representable on the machine";
333  end Constants;
334
335  package Types
336
337    type ArcType = enumeration(
338      normal_arc,
339      inhibitor_arc);
340  end Types;
341
342  package Examples
343
344    model Test6
345      PNlib.PC P1(nOut = 1, startMarks = 1) annotation(Placement(visible = true, transformation(origin = {-30, 10}, extent = {{-10, -10}, {10, 10}}, rotation = 0)));
346      PNlib.PC P2(nIn = 1, maxMarks = 0.4) annotation(Placement(visible = true, transformation(origin = {30, 10}, extent = {{-10, -10}, {10, 10}}, rotation = 0)));
347      PNlib.TC T1(nIn = 1, nOut = 1) annotation(Placement(visible = true, transformation(origin = {0, 10}, extent = {{-10, -10}, {10, 10}}, rotation = 0)));
348    equation
349      connect(T1.outPlaces[1], P2.inTransition[1]) annotation(Line(points = {{4.7, 10}, {4.7, 10}, {20.7, 10}}));
350      connect(P1.outTransition[1], T1.inPlaces[1]) annotation(Line(points = {{-20.7, 10}, {-20.7, 10}, {-4.7, 10}}));
351      annotation(Diagram(coordinateSystem(extent = {{-60, -20}, {60, 40}}, preserveAspectRatio = true, initialScale = 0.1, grid = {2, 2})), Icon(coordinateSystem(extent = {{-60, -20}, {60, 40}}, preserveAspectRatio = true, initialScale = 0.1, grid = {2, 2})), experiment(StartTime = 0, StopTime = 1, Tolerance = 1e-006));
352    end Test6;
353    annotation(Icon(coordinateSystem(extent = {{-100, -100}, {100, 100}}, preserveAspectRatio = true, initialScale = 0.1, grid = {2, 2})), Diagram(coordinateSystem(extent = {{-100, -100}, {100, 100}}, preserveAspectRatio = true, initialScale = 0.1, grid = {2, 2})));
354  end Examples;
355  annotation(uses(Modelica(version="3.2.1")));
356end PNlib;
357model PNlib_Examples_Test6
358 extends PNlib.Examples.Test6;
359  annotation(experiment(
360  StartTime=0,
361  StopTime=1,
362  Tolerance=1e-006));
363end PNlib_Examples_Test6;