Ticket #3167: Test6Total.mo

File Test6Total.mo, 25.1 KB (added by Lennart Ochel, 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;