# source:branches/dev-mj-1626/Compiler/ModelicaMiddleEnd/test/modelica/HybridModelTests.mo@13095

Last change on this file since 13095 was 13095, checked in by tgutzmann, 5 months ago

Merge from trunk

File size: 32.2 KB
Line
1/*
2    Copyright (C) 2009-2015 Modelon AB
3
4    This program is free software: you can redistribute it and/or modify
6    the Free Software Foundation, version 3 of the License.
7
8    This program is distributed in the hope that it will be useful,
9    but WITHOUT ANY WARRANTY; without even the implied warranty of
10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11    GNU General Public License for more details.
12
13    You should have received a copy of the GNU General Public License
14    along with this program.  If not, see <http://www.gnu.org/licenses/>.
15*/
16
17
18package HybridModelTests
19    package PreMerge
20        /**
21         * Tests that ensure that all pre(x) variable references are merged
22         * into the same block that assigns x.
23         */
24        model Test1
25            Integer i;
26            Real x, y;
27            Boolean b;
28        equation
29            der(x) = if pre(i) == 0 then 0 else 1;
30            der(y) = if i == 0 then 2 else 3;
31            b = sin(time) >= 0;
32            i = if b then 1 else 0;
33
34        annotation(__JModelica(UnitTesting(tests={
35            FClassMethodTestCase(
36                name="PreMerge.Test1",
37                description="Testing of hybrid models with pre variable that don't need to be iterated in block",
38                methodName="printDAEBLT",
39                methodResult="
40--- Pre propagation block (Block 1) ---
41  --- Solved equation ---
42  b := sin(time) >= 0
43  --- Solved equation ---
44  i := if b then 1 else 0
45  --- Solved equation ---
46  der(x) := if pre(i) == 0 then 0 else 1
47
48--- Solved equation ---
49der(y) := if i == 0 then 2 else 3
50-------------------------------
51")})));
52        end Test1;
53
54        model Test2
55            Real x, y;
56            Integer i;
57        equation
58            x + pre(i) = y;
59            i = if x >= 0 then 1 else 2;
60            y = 3 * sin(time);
61
62        annotation(__JModelica(UnitTesting(tests={
63            FClassMethodTestCase(
64                name="PreMerge.Test2",
65                description="Testing of hybrid models with pre variable that need to be iterated in block",
66                methodName="printDAEBLT",
67                methodResult="
68--- Solved equation ---
69y := 3 * sin(time)
70
71--- Pre propagation block (Block 1) ---
72  --- Solved equation ---
73  x := - pre(i) + y
74  --- Solved equation ---
75  i := if x >= 0 then 1 else 2
76-------------------------------
77")})));
78        end Test2;
79
80        model Test3
81            Real x, y, z;
82            Integer i, j;
83        equation
84            y = 3 * sin(time);
85            x + pre(i) = y;
86            i = if x >= 0 then 1 else 2;
87            z + pre(i) + pre(j) = y;
88            j = if x >= 0 and z>=0 then 1 else 2;
89
90        annotation(__JModelica(UnitTesting(tests={
91            FClassMethodTestCase(
92                name="PreMerge.Test3",
93                description="Testing of hybrid models with pre variables that need to be iterated in two separate blocks",
94                methodName="printDAEBLT",
95                methodResult="
96--- Solved equation ---
97y := 3 * sin(time)
98
99--- Pre propagation block (Block 1) ---
100  --- Solved equation ---
101  x := - pre(i) + y
102  --- Solved equation ---
103  z := - pre(i) + (- pre(j)) + y
104  --- Solved equation ---
105  j := if x >= 0 and z >= 0 then 1 else 2
106  --- Solved equation ---
107  i := if x >= 0 then 1 else 2
108-------------------------------
109")})));
110        end Test3;
111
112        model Test4
113            discrete Real x_d;
114            Real x_c;
115        initial equation
116            x_c = 1;
117        equation
118            der(x_c) = (-x_c) + x_d;
119            when sample(0, 1) then
120                x_d = x_c + 1;
121            end when;
122
123        annotation(__JModelica(UnitTesting(tests={
124            FClassMethodTestCase(
125                name="PreMerge.Test4",
126                description="Test interaction between continuous and discrete equations",
127                methodName="printDAEBLT",
128                methodResult="
129--- Pre propagation block (Block 1) ---
130  --- Meta equation block ---
131  assert(time < pre(_sampleItr_1) + 1, \"Too long time steps relative to sample interval.\")
132  --- Solved equation ---
133  temp_1 := not initial() and time >= pre(_sampleItr_1)
134  --- Solved equation ---
135  x_d := if temp_1 and not pre(temp_1) then x_c + 1 else pre(x_d)
136  --- Solved equation ---
137  _sampleItr_1 := if temp_1 and not pre(temp_1) then pre(_sampleItr_1) + 1 else pre(_sampleItr_1)
138
139--- Solved equation ---
140der(x_c) := - x_c + x_d
141-------------------------------
142
143")})));
144        end Test4;
145
146        model Test5
147            discrete Real x_d;
148            Real x_c;
149        initial equation
150            x_c = 1;
151        equation
152            0 = (-x_c) + x_d;
153            when sample(0, 1) then
154                x_d = x_c + 1;
155            end when;
156
157        annotation(__JModelica(UnitTesting(tests={
158            FClassMethodTestCase(
159                name="PreMerge.Test5",
160                description="TODO: this model should give an error",
161                methodName="printDAEBLT",
162                methodResult="
163--- Torn mixed linear system (Block 1) of 1 iteration variables and 1 solved variables ---
164Coefficient variability: discrete-time
165Torn variables:
166  x_d
167
168Iteration variables:
169  x_c
170
171Solved discrete variables:
172  temp_1
173  _sampleItr_1
174
175Torn equations:
176  x_d := if temp_1 and not pre(temp_1) then x_c + 1 else pre(x_d)
177
178Continuous residual equations:
179  0 = - x_c + x_d
180    Iteration variables: x_c
181
182Discrete equations:
183  temp_1 := not initial() and time >= pre(_sampleItr_1)
184  _sampleItr_1 := if temp_1 and not pre(temp_1) then pre(_sampleItr_1) + 1 else pre(_sampleItr_1)
185
186Meta equations:
187  assert(time < pre(_sampleItr_1) + 1, \"Too long time steps relative to sample interval.\")
188
189Jacobian:
190  |1.0, - (if temp_1 and not pre(temp_1) then 1.0 else 0.0)|
191  |-1.0, 1.0|
192-------------------------------
193")})));
194        end Test5;
195
196        model Test6
197            discrete Real x_d;
198            Real x_c;
199        initial equation
200            x_c = 1;
201        equation
202            0 = (-x_c) + pre(x_d);
203            when sample(0, 1) then
204                x_d = x_c + 1;
205            end when;
206
207        annotation(__JModelica(UnitTesting(tests={
208            FClassMethodTestCase(
209                name="PreMerge.Test6",
210                description="A case which gives bigger block with local pre handling, but avoid global iteration",
211                methodName="printDAEBLT",
212                methodResult="
213--- Pre propagation block (Block 1) ---
214  --- Meta equation block ---
215  assert(time < pre(_sampleItr_1) + 1, \"Too long time steps relative to sample interval.\")
216  --- Solved equation ---
217  temp_1 := not initial() and time >= pre(_sampleItr_1)
218  --- Solved equation ---
219  _sampleItr_1 := if temp_1 and not pre(temp_1) then pre(_sampleItr_1) + 1 else pre(_sampleItr_1)
220  --- Solved equation ---
221  x_c := pre(x_d)
222  --- Solved equation ---
223  x_d := if temp_1 and not pre(temp_1) then x_c + 1 else pre(x_d)
224-------------------------------
225")})));
226        end Test6;
227
228        model Test7
229            discrete Real x_d;
230            Real x_c;
231        initial equation
232            x_c = 1;
233        equation
234            0 = (-x_c) + x_d;
235            when sample(0, 1) then
236                x_d = pre(x_c) + 1;
237            end when;
238
239        annotation(__JModelica(UnitTesting(tests={
240            FClassMethodTestCase(
241                name="PreMerge.Test7",
242                description="A case which gives bigger block with local pre handling, but avoid global iteration",
243                methodName="printDAEBLT",
244                methodResult="
245--- Pre propagation block (Block 1) ---
246  --- Meta equation block ---
247  assert(time < pre(_sampleItr_1) + 1, \"Too long time steps relative to sample interval.\")
248  --- Solved equation ---
249  temp_1 := not initial() and time >= pre(_sampleItr_1)
250  --- Solved equation ---
251  x_d := if temp_1 and not pre(temp_1) then pre(x_c) + 1 else pre(x_d)
252  --- Solved equation ---
253  _sampleItr_1 := if temp_1 and not pre(temp_1) then pre(_sampleItr_1) + 1 else pre(_sampleItr_1)
254
255--- Solved equation ---
256x_c := x_d
257-------------------------------
258")})));
259        end Test7;
260
261        model Test8
262            Real x;
263            discrete Real y;
264            Integer i;
265        equation
266            i = if time >= 3 then 1 else 0;
267            when sample(0, 1) then
268                y = pre(y) + 1;
269            end when;
270            der(x) = (if pre(y) >= 3 then 1 else 2) + (if pre(i) == 4 then 5 else 6);
271
272        annotation(__JModelica(UnitTesting(tests={
273            FClassMethodTestCase(
274                name="PreMerge.Test8",
275                description="A case which gives bigger block with local pre handling, but avoid global iteration",
276                methodName="printDAEBLT",
277                methodResult="
278--- Pre propagation block (Block 1) ---
279  --- Meta equation block ---
280  assert(time < pre(_sampleItr_1) + 1, \"Too long time steps relative to sample interval.\")
281  --- Solved equation ---
282  der(x) := (if pre(y) >= 3 then 1 else 2) + (if pre(i) == 4 then 5 else 6)
283  --- Solved equation ---
284  temp_1 := not initial() and time >= pre(_sampleItr_1)
285  --- Solved equation ---
286  y := if temp_1 and not pre(temp_1) then pre(y) + 1 else pre(y)
287  --- Solved equation ---
288  _sampleItr_1 := if temp_1 and not pre(temp_1) then pre(_sampleItr_1) + 1 else pre(_sampleItr_1)
289  --- Solved equation ---
290  i := if time >= 3 then 1 else 0
291-------------------------------
292")})));
293        end Test8;
294
295        model Test9
296            parameter Real tau0_max = 0.15, tau0 = 0.10;
297            Real sa;
298            Boolean locked(start=true), startForward(start=false);
299        equation
300            sa = if locked then tau0_max+1e-4 else tau0+1e-4;
301            startForward = sa > tau0_max or pre(startForward) and sa > tau0;
302            locked = not startForward;
303
304        annotation(__JModelica(UnitTesting(tests={
305            FClassMethodTestCase(
306                name="PreMerge.Test9",
307                description="A test that simulates the common friction problems",
308                methodName="printDAEBLT",
309                methodResult="
310--- Unsolved mixed linear system (Block 1) of 3 variables ---
311Coefficient variability: constant
312Unknown continuous variables:
313  sa
314
315Solved discrete variables:
316  startForward
317  locked
318
319Continuous residual equations:
320  sa = if locked then tau0_max + 1.0E-4 else tau0 + 1.0E-4
321    Iteration variables: sa
322
323Discrete equations:
324  startForward := sa > tau0_max or pre(startForward) and sa > tau0
325  locked := not startForward
326
327Jacobian:
328  |1.0|
329-------------------------------
330")})));
331        end Test9;
332    end PreMerge;
333
334    package EventPreMerge
335        /**
336         * Tests that tests so that upstream event generating exps are merged
337         * into the same block as all downstream pre variable references.
338         */
339        model Simple1 // FAILS
340            Boolean a = time > 0.5;
341            Boolean b = a and not pre(a);
342            Boolean c = b and true;
343            Real x;
344        equation
345            when c then
346                x = time;
347            end when;
348        annotation(__JModelica(UnitTesting(tests={
349            FClassMethodTestCase(
350                name="EventPreMerge.Simple1",
351                description="A simple testcase that ensure that equations asigning a and x are in the same block",
352                methodName="printDAEBLT",
353                methodResult="
354--- Pre propagation block (Block 1) ---
355  --- Solved equation ---
356  a := time > 0.5
357  --- Solved equation ---
358  b := a and not pre(a)
359  --- Solved equation ---
360  c := b and true
361  --- Solved equation ---
362  x := if c and not pre(c) then time else pre(x)
363-------------------------------
364")})));
365        end Simple1;
366
367        model Simple2
368            Boolean a = sample(0.5, 1);
369            Boolean b = a and true;
370            Real x;
371        equation
372            when b then
373                x = time;
374            end when;
375        annotation(__JModelica(UnitTesting(tests={
376            FClassMethodTestCase(
377                name="EventPreMerge.Simple2",
378                description="A simple testcase that ensure that equations asigning a and x are in the same block",
379                methodName="printDAEBLT",
380                methodResult="
381--- Pre propagation block (Block 1) ---
382  --- Solved equation ---
383  a := not initial() and time >= 0.5 + pre(_sampleItr_1)
384  --- Solved equation ---
385  b := a and true
386  --- Solved equation ---
387  x := if b and not pre(b) then time else pre(x)
388  --- Meta equation block ---
389  assert(time < 0.5 + (pre(_sampleItr_1) + 1), \"Too long time steps relative to sample interval.\")
390  --- Solved equation ---
391  _sampleItr_1 := if a and not pre(a) then pre(_sampleItr_1) + 1 else pre(_sampleItr_1)
392-------------------------------
393")})));
394        end Simple2;
395
396        model TwoSeparate1
397            Boolean a = sample(0.5, 1);
398            Boolean b = a and true;
399            Boolean c = time > 0.75;
400            Real x;
401            Real y;
402        equation
403            when b then
404                x = time;
405            end when;
406            when c then
407                y = time;
408            end when;
409        annotation(__JModelica(UnitTesting(tests={
410            FClassMethodTestCase(
411                name="EventPreMerge.TwoSeparate1",
412                description="There are two independent parts of the system which have event equations and pre uses which shouldn't be merged",
413                methodName="printDAEBLT",
414                methodResult="
415--- Pre propagation block (Block 1) ---
416  --- Solved equation ---
417  a := not initial() and time >= 0.5 + pre(_sampleItr_1)
418  --- Solved equation ---
419  b := a and true
420  --- Solved equation ---
421  x := if b and not pre(b) then time else pre(x)
422  --- Meta equation block ---
423  assert(time < 0.5 + (pre(_sampleItr_1) + 1), \"Too long time steps relative to sample interval.\")
424  --- Solved equation ---
425  _sampleItr_1 := if a and not pre(a) then pre(_sampleItr_1) + 1 else pre(_sampleItr_1)
426
427--- Pre propagation block (Block 2) ---
428  --- Solved equation ---
429  c := time > 0.75
430  --- Solved equation ---
431  y := if c and not pre(c) then time else pre(y)
432-------------------------------
433")})));
434        end TwoSeparate1;
435
436        model SameUpstream1
437            Boolean a = time > 0.75;
438            Boolean b = a and not pre(a);
439            Boolean c1 = (b or b) and true;
440            Boolean c2 = (b or b) and true;
441            Real x1;
442            Real x2;
443        equation
444            when c1 then
445                x1 = time;
446            end when;
447            when c2 then
448                x2 = time;
449            end when;
450        annotation(__JModelica(UnitTesting(tests={
451            FClassMethodTestCase(
452                name="EventPreMerge.SameUpstream1",
453                description="Two when equations which share the same upstream block to merge",
454                methodName="printDAEBLT",
455                methodResult="
456--- Pre propagation block (Block 1) ---
457  --- Solved equation ---
458  a := time > 0.75
459  --- Solved equation ---
460  b := a and not pre(a)
461  --- Solved equation ---
462  c2 := (b or b) and true
463  --- Solved equation ---
464  x2 := if c2 and not pre(c2) then time else pre(x2)
465  --- Solved equation ---
466  c1 := (b or b) and true
467  --- Solved equation ---
468  x1 := if c1 and not pre(c1) then time else pre(x1)
469-------------------------------
470")})));
471        end SameUpstream1;
472
473        model TwoUpstream1
474            Boolean a1 = time > 0.75;
475            Boolean b1 = a1 and not pre(a1);
476            Boolean a2 = time > 0.5;
477            Boolean b2 = a2 and not pre(a2);
478            Boolean c = (b1 or b2) and true;
479            Real x;
480        equation
481            when c then
482                x = time;
483            end when;
484        annotation(__JModelica(UnitTesting(tests={
485            FClassMethodTestCase(
486                name="EventPreMerge.TwoUpstream1",
487                description="One when equation which has two upstream blocks to merge",
488                methodName="printDAEBLT",
489                methodResult="
490--- Pre propagation block (Block 1) ---
491  --- Solved equation ---
492  a1 := time > 0.75
493  --- Solved equation ---
494  b1 := a1 and not pre(a1)
495  --- Solved equation ---
496  a2 := time > 0.5
497  --- Solved equation ---
498  b2 := a2 and not pre(a2)
499  --- Solved equation ---
500  c := (b1 or b2) and true
501  --- Solved equation ---
502  x := if c and not pre(c) then time else pre(x)
503-------------------------------
504")})));
505        end TwoUpstream1;
506
507        model IndependentMiddle1
508            Boolean a;
509            Boolean b;
510            Boolean c;
511            Real m;
512            Real x;
513        equation
514            a = time > 0.5;
515            b = a and not pre(a);
516            c = b and true;
517            m = sin(time);
518            when c then
519                x = m;
520            end when;
521        annotation(__JModelica(UnitTesting(tests={
522            FClassMethodTestCase(
523                name="EventPreMerge.IndependentMiddle1",
524                description="Ensures that m equation is ordered correctly and not merged",
525                methodName="printDAEBLT",
526                methodResult="
527--- Solved equation ---
528m := sin(time)
529
530--- Pre propagation block (Block 1) ---
531  --- Solved equation ---
532  a := time > 0.5
533  --- Solved equation ---
534  b := a and not pre(a)
535  --- Solved equation ---
536  c := b and true
537  --- Solved equation ---
538  x := if c and not pre(c) then m else pre(x)
539-------------------------------
540")})));
541        end IndependentMiddle1;
542
543        model IndependentMiddle2
544            Boolean a;
545            Boolean b;
546            Boolean c;
547            Real m;
548            Real x;
549        equation
550            a = time > 0.5;
551            b = a and not pre(a);
552            m = if b then 1 else 0;
553            c = b and true;
554            when c then
555                x = time;
556            end when;
557        annotation(__JModelica(UnitTesting(tests={
558            FClassMethodTestCase(
559                name="EventPreMerge.IndependentMiddle2",
560                description="Ensures that m equation is ordered correctly and not merged",
561                methodName="printDAEBLT",
562                methodResult="
563--- Pre propagation block (Block 1) ---
564  --- Solved equation ---
565  a := time > 0.5
566  --- Solved equation ---
567  b := a and not pre(a)
568  --- Solved equation ---
569  c := b and true
570  --- Solved equation ---
571  x := if c and not pre(c) then time else pre(x)
572
573--- Solved equation ---
574m := if b then 1 else 0
575-------------------------------
576")})));
577        end IndependentMiddle2;
578
579        model IndependentDownstream1
580            Boolean a = time > 0.5;
581            Boolean b = a and not pre(a);
582            Boolean c = b and true;
583            Real x;
584            Real y;
585        equation
586            when c then
587                x = time;
588            end when;
589            y = sin(x);
590        annotation(__JModelica(UnitTesting(tests={
591            FClassMethodTestCase(
592                name="EventPreMerge.IndependentDownstream1",
593                description="Ensures that y equation is ordered correctly and not merged",
594                methodName="printDAEBLT",
595                methodResult="
596--- Pre propagation block (Block 1) ---
597  --- Solved equation ---
598  a := time > 0.5
599  --- Solved equation ---
600  b := a and not pre(a)
601  --- Solved equation ---
602  c := b and true
603  --- Solved equation ---
604  x := if c and not pre(c) then time else pre(x)
605
606--- Solved equation ---
607y := sin(x)
608-------------------------------
609")})));
610        end IndependentDownstream1;
611
612
613        model PreMergeInteraction
614            Boolean sample1 = sample(1, 0.4);
615            Real a,b,c;
616        equation
617            when sample1 then
618                a = sin(time);
619                c = b - 2;
620            end when;
621            b = a + 2;
622
623        annotation(__JModelica(UnitTesting(tests={
624            FClassMethodTestCase(
625                name="EventPreMerge.PreMergeInteraction",
626                description="Ensures event and pre merge interacts well with pre merge",
627                methodName="printDAEBLT",
628                methodResult="
629--- Pre propagation block (Block 1) ---
630  --- Solved equation ---
631  sample1 := not initial() and time >= 1 + pre(_sampleItr_1) * 0.4
632  --- Solved equation ---
633  a := if sample1 and not pre(sample1) then sin(time) else pre(a)
634  --- Solved equation ---
635  b := a + 2
636  --- Meta equation block ---
637  assert(time < 1 + (pre(_sampleItr_1) + 1) * 0.4, \"Too long time steps relative to sample interval.\")
638  --- Solved equation ---
639  c := if sample1 and not pre(sample1) then b - 2 else pre(c)
640  --- Solved equation ---
641  _sampleItr_1 := if sample1 and not pre(sample1) then pre(_sampleItr_1) + 1 else pre(_sampleItr_1)
642-------------------------------
643")})));
644        end PreMergeInteraction;
645
646        model DiscreteRealMerge
647            discrete Real x;
648            discrete Real y;
649        equation
650            when time > 0.25 then
651                x = 2*x + y + 1;
652            end when;
653            when time > 0.5 then
654                y = 3*x - 4*y + 1;
655            end when;
656
657        annotation(__JModelica(UnitTesting(tests={
658            FClassMethodTestCase(
659                name="EventPreMerge.DiscreteRealMerge",
660                description="Ensures that we merge discrete reals into the pre block and not nested",
661                methodName="printDAEBLT",
662                methodResult="
663--- Torn mixed linear system (Block 1) of 2 iteration variables and 0 solved variables ---
664Coefficient variability: discrete-time
665Torn variables:
666
667Iteration variables:
668  y
669  x
670
671Solved discrete variables:
672  temp_2
673  temp_1
674
675Torn equations:
676
677Continuous residual equations:
678  y = if temp_2 and not pre(temp_2) then 3 * x - 4 * y + 1 else pre(y)
679    Iteration variables: y
680  x = if temp_1 and not pre(temp_1) then 2 * x + y + 1 else pre(x)
681    Iteration variables: x
682
683Discrete equations:
684  temp_2 := time > 0.5
685  temp_1 := time > 0.25
686
687Jacobian:
688  |1.0 - (if temp_2 and not pre(temp_2) then -4 else 0.0), - (if temp_2 and not pre(temp_2) then 3 else 0.0)|
689  |- (if temp_1 and not pre(temp_1) then 1.0 else 0.0), 1.0 - (if temp_1 and not pre(temp_1) then 2 else 0.0)|
690-------------------------------
691")})));
692        end DiscreteRealMerge;
693
694        model DiscreteRealMerge2
695            Real a;
696            Real b(start=1.0);
697            Real c;
698            Real d;
699        equation
700            when time > 0.5 then
701                a = time+0.5;
702                c = pre(a) + b;
703            end when;
704            -b = a + d^2-2;
705            d=if b > 2.0 then 2.0 else if b < 1.0 then 1.0 else b;
706
707        annotation(__JModelica(UnitTesting(tests={
708            FClassMethodTestCase(
709                name="EventPreMerge.DiscreteRealMerge2",
710                description="Ensures that we merge switches into the pre block and not nested",
711                methodName="printDAEBLT",
712                methodResult="
713--- Torn mixed system (Block 1) of 1 iteration variables and 3 solved variables ---
714Torn variables:
715  d
716  c
717  a
718
719Iteration variables:
720  b (start=1.0)
721
722Solved discrete variables:
723  temp_1
724
725Torn equations:
726  d := if b > 2.0 then 2.0 elseif b < 1.0 then 1.0 else b
727  c := if temp_1 and not pre(temp_1) then pre(a) + b else pre(c)
728  a := if temp_1 and not pre(temp_1) then time + 0.5 else pre(a)
729
730Continuous residual equations:
731  - b = a + d ^ 2 - 2
732    Iteration variables: b
733
734Discrete equations:
735  temp_1 := time > 0.5
736-------------------------------
737")})));
738        end DiscreteRealMerge2;
739
740        model DiscreteRealMerge3
741            Real a;
742            Real b(start=1.0);
743            Real c;
744            Real d;
745            parameter Real p;
746        equation
747            when time > 0.5 then
748                a = time+0.5;
749                c = pre(a) + b;
750            end when;
751            -b = a + d^2-2;
752            d=if p > 2.0 then 2.0 else if p < 1.0 then 1.0 else b;
753
754        annotation(__JModelica(UnitTesting(tests={
755            FClassMethodTestCase(
756                name="EventPreMerge.DiscreteRealMerge3",
757                description="Ensures that we don't merge relational expressions without events into the pre block",
758                methodName="printDAEBLT",
759                methodResult="
760--- Pre propagation block (Block 1) ---
761  --- Solved equation ---
762  temp_1 := time > 0.5
763  --- Solved equation ---
764  a := if temp_1 and not pre(temp_1) then time + 0.5 else pre(a)
765  --- Torn system (Block 1.1) of 1 iteration variables and 1 solved variables ---
766  Torn variables:
767    d
768
769  Iteration variables:
770    b (start=1.0)
771
772  Torn equations:
773    d := if p > 2.0 then 2.0 elseif p < 1.0 then 1.0 else b
774
775  Residual equations:
776    - b = a + d ^ 2 - 2
777      Iteration variables: b
778  --- Solved equation ---
779  c := if temp_1 and not pre(temp_1) then pre(a) + b else pre(c)
780-------------------------------
781")})));
782        end DiscreteRealMerge3;
783
784        model DiscreteRealMerge4
785            Real a;
786            Real b(start=1.0);
787            Real c;
788            Real d;
789            Real x;
790        equation
791            der(x) = time;
792            when time > 0.5 then
793                a = time+0.5;
794                c = pre(a) + b;
795            end when;
796            -b = a + d^2-2;
797            d=if x > 2.0 then 2.0 else if x < 1.0 then 1.0 else b;
798
799        annotation(__JModelica(UnitTesting(tests={
800            FClassMethodTestCase(
801                name="EventPreMerge.DiscreteRealMerge4",
802                description="Ensures that we don't merge switches which does not depend on the block into the pre block",
803                methodName="printDAEBLT",
804                methodResult="
805--- Solved equation ---
806der(x) := time
807
808--- Pre propagation block (Block 1) ---
809  --- Solved equation ---
810  temp_1 := time > 0.5
811  --- Solved equation ---
812  a := if temp_1 and not pre(temp_1) then time + 0.5 else pre(a)
813  --- Torn system (Block 1.1) of 1 iteration variables and 1 solved variables ---
814  Torn variables:
815    d
816
817  Iteration variables:
818    b (start=1.0)
819
820  Torn equations:
821    d := if x > 2.0 then 2.0 elseif x < 1.0 then 1.0 else b
822
823  Residual equations:
824    - b = a + d ^ 2 - 2
825      Iteration variables: b
826  --- Solved equation ---
827  c := if temp_1 and not pre(temp_1) then pre(a) + b else pre(c)
828-------------------------------
829")})));
830        end DiscreteRealMerge4;
831
832        model Big1
833            Boolean d1;
834            Boolean d2;
835            Boolean d3;
836            Boolean d4;
837            Boolean d5;
838            Boolean d6(start=true);
839            Boolean d7;
840            Boolean d8;
841            Boolean d9(start=false);
842            Boolean d16(start=true);
843        initial equation
844            d1=false;
845            pre(d2)=pre(d1);
846            d3 = true;
847            pre(d4)=pre(d3);
848            d7 = false;
849            pre(d8)=pre(d7);
850        equation
851            d1 = pre(d2);
852            d3 = pre(d4);
853            d5 = d3 and not d1;
854            d6 = d1 or d5;
855            d7 = pre(d8);
856            d9 = d7 and not d6;
857            d16 = d1 and not d7;
858            d8 = (d16 or d7 and not d9);
859            d2 = ((d5 or d9) or d1 and not d16);
860            d4 = d3 and not d5;
861        annotation(__JModelica(UnitTesting(tests={
862            FClassMethodTestCase(
863                name="EventPreMerge.Big1",
864                description="An bigger \"real world\" example",
865                methodName="printDAEBLT",
866                methodResult="
867--- Pre propagation block (Block 1) ---
868  --- Solved equation ---
869  d1 := pre(d2)
870  --- Solved equation ---
871  d3 := pre(d4)
872  --- Solved equation ---
873  d5 := d3 and not d1
874  --- Solved equation ---
875  d6 := d1 or d5
876  --- Solved equation ---
877  d7 := pre(d8)
878  --- Solved equation ---
879  d16 := d1 and not d7
880  --- Solved equation ---
881  d9 := d7 and not d6
882  --- Solved equation ---
883  d8 := d16 or d7 and not d9
884  --- Solved equation ---
885  d4 := d3 and not d5
886  --- Solved equation ---
887  d2 := d5 or d9 or d1 and not d16
888-------------------------------
889")})));
890        end Big1;
891    end EventPreMerge;
892
893    model WhenAndPreTest1
894        Real xx(start=2);
895        discrete Real x;
896        discrete Real y;
897        discrete Boolean w(start=true);
898        discrete Boolean v(start=true);
899        discrete Boolean z(start=true);
900    equation
901        when sample(0,1) then
902            x = pre(x) + 1.1;
903            y = pre(y) + 1.1;
904        end when;
905
906        der(xx) = -x;
907
908        when y > 2 and pre(z) then
909            w = false;
910        end when;
911
912        when x > 2 then
913            z = false;
914        end when;
915
916        when y > 2 and z then
917            v = false;
918        end when;
919
920    annotation(__JModelica(UnitTesting(tests={
921        FClassMethodTestCase(
922            name="WhenAndPreTest1",
923            description="Test complicated when and pre variable case",
924            methodName="printDAEBLT",
925            methodResult="
926--- Pre propagation block (Block 1) ---
927  --- Solved equation ---
928  temp_1 := not initial() and time >= pre(_sampleItr_1)
929  --- Solved equation ---
930  y := if temp_1 and not pre(temp_1) then pre(y) + 1.1 else pre(y)
931  --- Solved equation ---
932  x := if temp_1 and not pre(temp_1) then pre(x) + 1.1 else pre(x)
933  --- Solved equation ---
934  temp_3 := x > 2
935  --- Solved equation ---
936  z := if temp_3 and not pre(temp_3) then false else pre(z)
937  --- Solved equation ---
938  temp_4 := y > 2 and z
939  --- Solved equation ---
940  v := if temp_4 and not pre(temp_4) then false else pre(v)
941  --- Solved equation ---
942  temp_2 := y > 2 and pre(z)
943  --- Solved equation ---
944  w := if temp_2 and not pre(temp_2) then false else pre(w)
945  --- Meta equation block ---
946  assert(time < pre(_sampleItr_1) + 1, \"Too long time steps relative to sample interval.\")
947  --- Solved equation ---
948  _sampleItr_1 := if temp_1 and not pre(temp_1) then pre(_sampleItr_1) + 1 else pre(_sampleItr_1)
949
950--- Solved equation ---
951der(xx) := - x
952-------------------------------
953")})));
954    end WhenAndPreTest1;
955
956    model NoResTest1
957        function F
958            input Real i1;
959            input Real i2;
960            output Real o;
961        algorithm
962            assert(i1 == 0, "Oh, no!");
963            assert(i2 == 0, "Oh, no!");
964            o := 3.14 / i1 + 42 / i2;
965            annotation(Inline=false);
966        end F;
967        Real next, x;
968    initial equation
969        pre(next) = 0;
970    equation
971        when time >= pre(next) then
972            next = pre(next) + 1;
973        end when;
974        x = F(next, pre(next));
975
976    annotation(__JModelica(UnitTesting(tests={
977        FClassMethodTestCase(
978            name="NoResTest1",
979            description="Verify that no residuals are added to the block even though it contains continuous equations",
980            methodName="printDAEBLT",
981            methodResult="
982--- Pre propagation block (Block 1) ---
983  --- Solved equation ---
984  temp_1 := time >= pre(next)
985  --- Solved equation ---
986  next := if temp_1 and not pre(temp_1) then pre(next) + 1 else pre(next)
987  --- Solved equation ---
988  x := HybridModelTests.NoResTest1.F(next, pre(next))
989-------------------------------
990")})));
991    end NoResTest1;
992
993    model MixedVariabilityMatch1
994        parameter Real a(fixed=false);
995        Real b;
996    initial equation
997        b = 1;
998    equation
999        b = sin(a + time);
1000
1001    annotation(__JModelica(UnitTesting(tests={
1002        FClassMethodTestCase(
1003            name="MixedVariabilityMatch1",
1004            description="Verify that a noncontinuous variable can be matched to and continuous equation in the initial system",
1005            methodName="printDAEInitBLT",
1006            methodResult="
1007--- Solved equation ---
1008b := 1
1009
1010--- Unsolved equation (Block 1) ---
1011b = sin(a + time)
1012  Computed variables: a
1013-------------------------------
1014")})));
1015    end MixedVariabilityMatch1;
1016
1017    model ParameterVarEventExp1
1018        parameter Boolean p1 = true;
1019        Real a = if p1 then time else -time;
1020
1021        Boolean b = a > 0.5;
1022        Boolean c = b and not pre(b);
1023        Boolean d = c and true;
1024        Real x;
1025    equation
1026        when d then
1027            x = time;
1028        end when;
1029
1030    annotation(__JModelica(UnitTesting(tests={
1031        FClassMethodTestCase(
1032            name="ParameterVarEventExp1",
1033            description="Verify that event generating expressions with parameter variability ins't merged'",
1034            methodName="printDAEBLT",
1035            methodResult="
1036--- Solved equation ---
1037a := if p1 then time else - time
1038
1039--- Pre propagation block (Block 1) ---
1040  --- Solved equation ---
1041  b := a > 0.5
1042  --- Solved equation ---
1043  c := b and not pre(b)
1044  --- Solved equation ---
1045  d := c and true
1046  --- Solved equation ---
1047  x := if d and not pre(d) then time else pre(x)
1048-------------------------------
1049")})));
1050    end ParameterVarEventExp1;
1051
1052end HybridModelTests;
Note: See TracBrowser for help on using the repository browser.