diff options
Diffstat (limited to 'src/main/Simulator/Graph_06inz.c')
| -rw-r--r-- | src/main/Simulator/Graph_06inz.c | 6328 |
1 files changed, 6328 insertions, 0 deletions
diff --git a/src/main/Simulator/Graph_06inz.c b/src/main/Simulator/Graph_06inz.c new file mode 100644 index 0000000..3cc7e52 --- /dev/null +++ b/src/main/Simulator/Graph_06inz.c @@ -0,0 +1,6328 @@ +/* Initialization */ +#include "Graph_model.h" +#include "Graph_11mix.h" +#include "Graph_12jac.h" +#if defined(__cplusplus) +extern "C" { +#endif + +void Graph_functionInitialEquations_0(DATA *data, threadData_t *threadData); + + +/* + equation index: 1 + type: SIMPLE_ASSIGN + y[1,2] = 1.0 + */ +void Graph_eqFunction_1(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,1}; + data->localData[0]->realVars[1035] /* y[1,2] variable */ = 1.0; + TRACE_POP +} + +/* + equation index: 2 + type: SIMPLE_ASSIGN + y[40,2] = 0.0 + */ +void Graph_eqFunction_2(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,2}; + data->localData[0]->realVars[1113] /* y[40,2] variable */ = 0.0; + TRACE_POP +} + +/* + equation index: 3 + type: SIMPLE_ASSIGN + x[40,2] = 0.0 + */ +void Graph_eqFunction_3(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,3}; + data->localData[0]->realVars[1033] /* x[40,2] variable */ = 0.0; + TRACE_POP +} + +/* + equation index: 4 + type: SIMPLE_ASSIGN + x[39,2] = 0.02564102564102566 + */ +void Graph_eqFunction_4(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,4}; + data->localData[0]->realVars[1031] /* x[39,2] variable */ = 0.02564102564102566; + TRACE_POP +} + +/* + equation index: 5 + type: SIMPLE_ASSIGN + x[38,2] = 0.05128205128205132 + */ +void Graph_eqFunction_5(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,5}; + data->localData[0]->realVars[1029] /* x[38,2] variable */ = 0.05128205128205132; + TRACE_POP +} + +/* + equation index: 6 + type: SIMPLE_ASSIGN + x[37,2] = 0.07692307692307687 + */ +void Graph_eqFunction_6(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,6}; + data->localData[0]->realVars[1027] /* x[37,2] variable */ = 0.07692307692307687; + TRACE_POP +} + +/* + equation index: 7 + type: SIMPLE_ASSIGN + x[36,2] = 0.1025641025641025 + */ +void Graph_eqFunction_7(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,7}; + data->localData[0]->realVars[1025] /* x[36,2] variable */ = 0.1025641025641025; + TRACE_POP +} + +/* + equation index: 8 + type: SIMPLE_ASSIGN + x[35,2] = 0.1282051282051282 + */ +void Graph_eqFunction_8(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,8}; + data->localData[0]->realVars[1023] /* x[35,2] variable */ = 0.1282051282051282; + TRACE_POP +} + +/* + equation index: 9 + type: SIMPLE_ASSIGN + x[34,2] = 0.1538461538461539 + */ +void Graph_eqFunction_9(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,9}; + data->localData[0]->realVars[1021] /* x[34,2] variable */ = 0.1538461538461539; + TRACE_POP +} + +/* + equation index: 10 + type: SIMPLE_ASSIGN + x[33,2] = 0.1794871794871795 + */ +void Graph_eqFunction_10(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,10}; + data->localData[0]->realVars[1019] /* x[33,2] variable */ = 0.1794871794871795; + TRACE_POP +} + +/* + equation index: 11 + type: SIMPLE_ASSIGN + x[32,2] = 0.2051282051282052 + */ +void Graph_eqFunction_11(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,11}; + data->localData[0]->realVars[1017] /* x[32,2] variable */ = 0.2051282051282052; + TRACE_POP +} + +/* + equation index: 12 + type: SIMPLE_ASSIGN + x[31,2] = 0.2307692307692307 + */ +void Graph_eqFunction_12(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,12}; + data->localData[0]->realVars[1015] /* x[31,2] variable */ = 0.2307692307692307; + TRACE_POP +} + +/* + equation index: 13 + type: SIMPLE_ASSIGN + x[30,2] = 0.2564102564102564 + */ +void Graph_eqFunction_13(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,13}; + data->localData[0]->realVars[1013] /* x[30,2] variable */ = 0.2564102564102564; + TRACE_POP +} + +/* + equation index: 14 + type: SIMPLE_ASSIGN + x[29,2] = 0.2820512820512821 + */ +void Graph_eqFunction_14(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,14}; + data->localData[0]->realVars[1011] /* x[29,2] variable */ = 0.2820512820512821; + TRACE_POP +} + +/* + equation index: 15 + type: SIMPLE_ASSIGN + x[28,2] = 0.3076923076923077 + */ +void Graph_eqFunction_15(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,15}; + data->localData[0]->realVars[1009] /* x[28,2] variable */ = 0.3076923076923077; + TRACE_POP +} + +/* + equation index: 16 + type: SIMPLE_ASSIGN + x[27,2] = 0.3333333333333334 + */ +void Graph_eqFunction_16(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,16}; + data->localData[0]->realVars[1007] /* x[27,2] variable */ = 0.3333333333333334; + TRACE_POP +} + +/* + equation index: 17 + type: SIMPLE_ASSIGN + x[26,2] = 0.3589743589743589 + */ +void Graph_eqFunction_17(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,17}; + data->localData[0]->realVars[1005] /* x[26,2] variable */ = 0.3589743589743589; + TRACE_POP +} + +/* + equation index: 18 + type: SIMPLE_ASSIGN + x[25,2] = 0.3846153846153846 + */ +void Graph_eqFunction_18(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,18}; + data->localData[0]->realVars[1003] /* x[25,2] variable */ = 0.3846153846153846; + TRACE_POP +} + +/* + equation index: 19 + type: SIMPLE_ASSIGN + x[24,2] = 0.4102564102564102 + */ +void Graph_eqFunction_19(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,19}; + data->localData[0]->realVars[1001] /* x[24,2] variable */ = 0.4102564102564102; + TRACE_POP +} + +/* + equation index: 20 + type: SIMPLE_ASSIGN + x[23,2] = 0.4358974358974359 + */ +void Graph_eqFunction_20(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,20}; + data->localData[0]->realVars[999] /* x[23,2] variable */ = 0.4358974358974359; + TRACE_POP +} + +/* + equation index: 21 + type: SIMPLE_ASSIGN + x[22,2] = 0.4615384615384616 + */ +void Graph_eqFunction_21(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,21}; + data->localData[0]->realVars[997] /* x[22,2] variable */ = 0.4615384615384616; + TRACE_POP +} + +/* + equation index: 22 + type: SIMPLE_ASSIGN + x[21,2] = 0.4871794871794872 + */ +void Graph_eqFunction_22(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,22}; + data->localData[0]->realVars[995] /* x[21,2] variable */ = 0.4871794871794872; + TRACE_POP +} + +/* + equation index: 23 + type: SIMPLE_ASSIGN + x[20,2] = 0.5128205128205128 + */ +void Graph_eqFunction_23(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,23}; + data->localData[0]->realVars[993] /* x[20,2] variable */ = 0.5128205128205128; + TRACE_POP +} + +/* + equation index: 24 + type: SIMPLE_ASSIGN + x[19,2] = 0.5384615384615384 + */ +void Graph_eqFunction_24(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,24}; + data->localData[0]->realVars[991] /* x[19,2] variable */ = 0.5384615384615384; + TRACE_POP +} + +/* + equation index: 25 + type: SIMPLE_ASSIGN + x[18,2] = 0.5641025641025641 + */ +void Graph_eqFunction_25(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,25}; + data->localData[0]->realVars[989] /* x[18,2] variable */ = 0.5641025641025641; + TRACE_POP +} + +/* + equation index: 26 + type: SIMPLE_ASSIGN + x[17,2] = 0.5897435897435898 + */ +void Graph_eqFunction_26(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,26}; + data->localData[0]->realVars[987] /* x[17,2] variable */ = 0.5897435897435898; + TRACE_POP +} + +/* + equation index: 27 + type: SIMPLE_ASSIGN + x[16,2] = 0.6153846153846154 + */ +void Graph_eqFunction_27(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,27}; + data->localData[0]->realVars[985] /* x[16,2] variable */ = 0.6153846153846154; + TRACE_POP +} + +/* + equation index: 28 + type: SIMPLE_ASSIGN + x[15,2] = 0.641025641025641 + */ +void Graph_eqFunction_28(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,28}; + data->localData[0]->realVars[983] /* x[15,2] variable */ = 0.641025641025641; + TRACE_POP +} + +/* + equation index: 29 + type: SIMPLE_ASSIGN + x[14,2] = 0.6666666666666667 + */ +void Graph_eqFunction_29(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,29}; + data->localData[0]->realVars[981] /* x[14,2] variable */ = 0.6666666666666667; + TRACE_POP +} + +/* + equation index: 30 + type: SIMPLE_ASSIGN + x[13,2] = 0.6923076923076923 + */ +void Graph_eqFunction_30(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,30}; + data->localData[0]->realVars[979] /* x[13,2] variable */ = 0.6923076923076923; + TRACE_POP +} + +/* + equation index: 31 + type: SIMPLE_ASSIGN + x[12,2] = 0.717948717948718 + */ +void Graph_eqFunction_31(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,31}; + data->localData[0]->realVars[977] /* x[12,2] variable */ = 0.717948717948718; + TRACE_POP +} + +/* + equation index: 32 + type: SIMPLE_ASSIGN + x[11,2] = 0.7435897435897436 + */ +void Graph_eqFunction_32(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,32}; + data->localData[0]->realVars[975] /* x[11,2] variable */ = 0.7435897435897436; + TRACE_POP +} + +/* + equation index: 33 + type: SIMPLE_ASSIGN + x[10,2] = 0.7692307692307692 + */ +void Graph_eqFunction_33(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,33}; + data->localData[0]->realVars[973] /* x[10,2] variable */ = 0.7692307692307692; + TRACE_POP +} + +/* + equation index: 34 + type: SIMPLE_ASSIGN + x[9,2] = 0.7948717948717949 + */ +void Graph_eqFunction_34(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,34}; + data->localData[0]->realVars[971] /* x[9,2] variable */ = 0.7948717948717949; + TRACE_POP +} + +/* + equation index: 35 + type: SIMPLE_ASSIGN + x[8,2] = 0.8205128205128205 + */ +void Graph_eqFunction_35(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,35}; + data->localData[0]->realVars[969] /* x[8,2] variable */ = 0.8205128205128205; + TRACE_POP +} + +/* + equation index: 36 + type: SIMPLE_ASSIGN + x[7,2] = 0.8461538461538462 + */ +void Graph_eqFunction_36(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,36}; + data->localData[0]->realVars[967] /* x[7,2] variable */ = 0.8461538461538462; + TRACE_POP +} + +/* + equation index: 37 + type: SIMPLE_ASSIGN + x[6,2] = 0.8717948717948718 + */ +void Graph_eqFunction_37(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,37}; + data->localData[0]->realVars[965] /* x[6,2] variable */ = 0.8717948717948718; + TRACE_POP +} + +/* + equation index: 38 + type: SIMPLE_ASSIGN + x[5,2] = 0.8974358974358975 + */ +void Graph_eqFunction_38(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,38}; + data->localData[0]->realVars[963] /* x[5,2] variable */ = 0.8974358974358975; + TRACE_POP +} + +/* + equation index: 39 + type: SIMPLE_ASSIGN + x[4,2] = 0.9230769230769231 + */ +void Graph_eqFunction_39(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,39}; + data->localData[0]->realVars[961] /* x[4,2] variable */ = 0.9230769230769231; + TRACE_POP +} + +/* + equation index: 40 + type: SIMPLE_ASSIGN + x[3,2] = 0.9487179487179487 + */ +void Graph_eqFunction_40(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,40}; + data->localData[0]->realVars[959] /* x[3,2] variable */ = 0.9487179487179487; + TRACE_POP +} + +/* + equation index: 41 + type: SIMPLE_ASSIGN + x[2,2] = 0.9743589743589743 + */ +void Graph_eqFunction_41(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,41}; + data->localData[0]->realVars[957] /* x[2,2] variable */ = 0.9743589743589743; + TRACE_POP +} + +/* + equation index: 42 + type: SIMPLE_ASSIGN + x[1,2] = 1.0 + */ +void Graph_eqFunction_42(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,42}; + data->localData[0]->realVars[955] /* x[1,2] variable */ = 1.0; + TRACE_POP +} + +/* + equation index: 43 + type: SIMPLE_ASSIGN + y[1,1] = 0.0 + */ +void Graph_eqFunction_43(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,43}; + data->localData[0]->realVars[1034] /* y[1,1] variable */ = 0.0; + TRACE_POP +} + +/* + equation index: 44 + type: SIMPLE_ASSIGN + P[1] = 10000.0 + */ +void Graph_eqFunction_44(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,44}; + data->localData[0]->realVars[160] /* P[1] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 45 + type: SIMPLE_ASSIGN + P[2] = 10000.0 + */ +void Graph_eqFunction_45(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,45}; + data->localData[0]->realVars[161] /* P[2] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 46 + type: SIMPLE_ASSIGN + P[3] = 10000.0 + */ +void Graph_eqFunction_46(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,46}; + data->localData[0]->realVars[162] /* P[3] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 47 + type: SIMPLE_ASSIGN + P[4] = 10000.0 + */ +void Graph_eqFunction_47(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,47}; + data->localData[0]->realVars[163] /* P[4] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 48 + type: SIMPLE_ASSIGN + P[5] = 10000.0 + */ +void Graph_eqFunction_48(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,48}; + data->localData[0]->realVars[164] /* P[5] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 49 + type: SIMPLE_ASSIGN + P[6] = 10000.0 + */ +void Graph_eqFunction_49(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,49}; + data->localData[0]->realVars[165] /* P[6] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 50 + type: SIMPLE_ASSIGN + P[7] = 10000.0 + */ +void Graph_eqFunction_50(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,50}; + data->localData[0]->realVars[166] /* P[7] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 51 + type: SIMPLE_ASSIGN + P[8] = 10000.0 + */ +void Graph_eqFunction_51(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,51}; + data->localData[0]->realVars[167] /* P[8] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 52 + type: SIMPLE_ASSIGN + P[9] = 10000.0 + */ +void Graph_eqFunction_52(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,52}; + data->localData[0]->realVars[168] /* P[9] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 53 + type: SIMPLE_ASSIGN + P[10] = 10000.0 + */ +void Graph_eqFunction_53(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,53}; + data->localData[0]->realVars[169] /* P[10] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 54 + type: SIMPLE_ASSIGN + P[11] = 10000.0 + */ +void Graph_eqFunction_54(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,54}; + data->localData[0]->realVars[170] /* P[11] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 55 + type: SIMPLE_ASSIGN + P[12] = 10000.0 + */ +void Graph_eqFunction_55(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,55}; + data->localData[0]->realVars[171] /* P[12] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 56 + type: SIMPLE_ASSIGN + P[13] = 10000.0 + */ +void Graph_eqFunction_56(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,56}; + data->localData[0]->realVars[172] /* P[13] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 57 + type: SIMPLE_ASSIGN + P[14] = 10000.0 + */ +void Graph_eqFunction_57(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,57}; + data->localData[0]->realVars[173] /* P[14] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 58 + type: SIMPLE_ASSIGN + P[15] = 10000.0 + */ +void Graph_eqFunction_58(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,58}; + data->localData[0]->realVars[174] /* P[15] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 59 + type: SIMPLE_ASSIGN + P[16] = 10000.0 + */ +void Graph_eqFunction_59(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,59}; + data->localData[0]->realVars[175] /* P[16] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 60 + type: SIMPLE_ASSIGN + P[17] = 10000.0 + */ +void Graph_eqFunction_60(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,60}; + data->localData[0]->realVars[176] /* P[17] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 61 + type: SIMPLE_ASSIGN + P[18] = 10000.0 + */ +void Graph_eqFunction_61(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,61}; + data->localData[0]->realVars[177] /* P[18] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 62 + type: SIMPLE_ASSIGN + P[19] = 10000.0 + */ +void Graph_eqFunction_62(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,62}; + data->localData[0]->realVars[178] /* P[19] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 63 + type: SIMPLE_ASSIGN + P[20] = 10000.0 + */ +void Graph_eqFunction_63(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,63}; + data->localData[0]->realVars[179] /* P[20] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 64 + type: SIMPLE_ASSIGN + P[21] = 10000.0 + */ +void Graph_eqFunction_64(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,64}; + data->localData[0]->realVars[180] /* P[21] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 65 + type: SIMPLE_ASSIGN + P[22] = 10000.0 + */ +void Graph_eqFunction_65(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,65}; + data->localData[0]->realVars[181] /* P[22] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 66 + type: SIMPLE_ASSIGN + P[23] = 10000.0 + */ +void Graph_eqFunction_66(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,66}; + data->localData[0]->realVars[182] /* P[23] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 67 + type: SIMPLE_ASSIGN + P[24] = 10000.0 + */ +void Graph_eqFunction_67(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,67}; + data->localData[0]->realVars[183] /* P[24] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 68 + type: SIMPLE_ASSIGN + P[25] = 10000.0 + */ +void Graph_eqFunction_68(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,68}; + data->localData[0]->realVars[184] /* P[25] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 69 + type: SIMPLE_ASSIGN + P[26] = 10000.0 + */ +void Graph_eqFunction_69(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,69}; + data->localData[0]->realVars[185] /* P[26] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 70 + type: SIMPLE_ASSIGN + P[27] = 10000.0 + */ +void Graph_eqFunction_70(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,70}; + data->localData[0]->realVars[186] /* P[27] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 71 + type: SIMPLE_ASSIGN + P[28] = 10000.0 + */ +void Graph_eqFunction_71(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,71}; + data->localData[0]->realVars[187] /* P[28] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 72 + type: SIMPLE_ASSIGN + P[29] = 10000.0 + */ +void Graph_eqFunction_72(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,72}; + data->localData[0]->realVars[188] /* P[29] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 73 + type: SIMPLE_ASSIGN + P[30] = 10000.0 + */ +void Graph_eqFunction_73(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,73}; + data->localData[0]->realVars[189] /* P[30] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 74 + type: SIMPLE_ASSIGN + P[31] = 10000.0 + */ +void Graph_eqFunction_74(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,74}; + data->localData[0]->realVars[190] /* P[31] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 75 + type: SIMPLE_ASSIGN + P[32] = 10000.0 + */ +void Graph_eqFunction_75(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,75}; + data->localData[0]->realVars[191] /* P[32] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 76 + type: SIMPLE_ASSIGN + P[33] = 10000.0 + */ +void Graph_eqFunction_76(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,76}; + data->localData[0]->realVars[192] /* P[33] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 77 + type: SIMPLE_ASSIGN + P[34] = 10000.0 + */ +void Graph_eqFunction_77(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,77}; + data->localData[0]->realVars[193] /* P[34] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 78 + type: SIMPLE_ASSIGN + P[35] = 10000.0 + */ +void Graph_eqFunction_78(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,78}; + data->localData[0]->realVars[194] /* P[35] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 79 + type: SIMPLE_ASSIGN + P[36] = 10000.0 + */ +void Graph_eqFunction_79(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,79}; + data->localData[0]->realVars[195] /* P[36] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 80 + type: SIMPLE_ASSIGN + P[37] = 10000.0 + */ +void Graph_eqFunction_80(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,80}; + data->localData[0]->realVars[196] /* P[37] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 81 + type: SIMPLE_ASSIGN + P[38] = 10000.0 + */ +void Graph_eqFunction_81(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,81}; + data->localData[0]->realVars[197] /* P[38] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 82 + type: SIMPLE_ASSIGN + P[39] = 10000.0 + */ +void Graph_eqFunction_82(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,82}; + data->localData[0]->realVars[198] /* P[39] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 83 + type: SIMPLE_ASSIGN + P[40] = 10000.0 + */ +void Graph_eqFunction_83(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,83}; + data->localData[0]->realVars[199] /* P[40] variable */ = 10000.0; + TRACE_POP +} + +/* + equation index: 84 + type: SIMPLE_ASSIGN + x[1,1] = 0.0 + */ +void Graph_eqFunction_84(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,84}; + data->localData[0]->realVars[954] /* x[1,1] variable */ = 0.0; + TRACE_POP +} + +/* + equation index: 85 + type: SIMPLE_ASSIGN + x[2,1] = 0.02564102564102564 + */ +void Graph_eqFunction_85(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,85}; + data->localData[0]->realVars[956] /* x[2,1] variable */ = 0.02564102564102564; + TRACE_POP +} + +/* + equation index: 86 + type: SIMPLE_ASSIGN + x[3,1] = 0.05128205128205128 + */ +void Graph_eqFunction_86(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,86}; + data->localData[0]->realVars[958] /* x[3,1] variable */ = 0.05128205128205128; + TRACE_POP +} + +/* + equation index: 87 + type: SIMPLE_ASSIGN + x[4,1] = 0.07692307692307693 + */ +void Graph_eqFunction_87(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,87}; + data->localData[0]->realVars[960] /* x[4,1] variable */ = 0.07692307692307693; + TRACE_POP +} + +/* + equation index: 88 + type: SIMPLE_ASSIGN + x[5,1] = 0.1025641025641026 + */ +void Graph_eqFunction_88(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,88}; + data->localData[0]->realVars[962] /* x[5,1] variable */ = 0.1025641025641026; + TRACE_POP +} + +/* + equation index: 89 + type: SIMPLE_ASSIGN + x[6,1] = 0.1282051282051282 + */ +void Graph_eqFunction_89(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,89}; + data->localData[0]->realVars[964] /* x[6,1] variable */ = 0.1282051282051282; + TRACE_POP +} + +/* + equation index: 90 + type: SIMPLE_ASSIGN + x[7,1] = 0.1538461538461539 + */ +void Graph_eqFunction_90(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,90}; + data->localData[0]->realVars[966] /* x[7,1] variable */ = 0.1538461538461539; + TRACE_POP +} + +/* + equation index: 91 + type: SIMPLE_ASSIGN + x[8,1] = 0.1794871794871795 + */ +void Graph_eqFunction_91(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,91}; + data->localData[0]->realVars[968] /* x[8,1] variable */ = 0.1794871794871795; + TRACE_POP +} + +/* + equation index: 92 + type: SIMPLE_ASSIGN + x[9,1] = 0.2051282051282051 + */ +void Graph_eqFunction_92(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,92}; + data->localData[0]->realVars[970] /* x[9,1] variable */ = 0.2051282051282051; + TRACE_POP +} + +/* + equation index: 93 + type: SIMPLE_ASSIGN + x[10,1] = 0.2307692307692308 + */ +void Graph_eqFunction_93(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,93}; + data->localData[0]->realVars[972] /* x[10,1] variable */ = 0.2307692307692308; + TRACE_POP +} + +/* + equation index: 94 + type: SIMPLE_ASSIGN + x[11,1] = 0.2564102564102564 + */ +void Graph_eqFunction_94(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,94}; + data->localData[0]->realVars[974] /* x[11,1] variable */ = 0.2564102564102564; + TRACE_POP +} + +/* + equation index: 95 + type: SIMPLE_ASSIGN + x[12,1] = 0.2820512820512821 + */ +void Graph_eqFunction_95(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,95}; + data->localData[0]->realVars[976] /* x[12,1] variable */ = 0.2820512820512821; + TRACE_POP +} + +/* + equation index: 96 + type: SIMPLE_ASSIGN + x[13,1] = 0.3076923076923077 + */ +void Graph_eqFunction_96(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,96}; + data->localData[0]->realVars[978] /* x[13,1] variable */ = 0.3076923076923077; + TRACE_POP +} + +/* + equation index: 97 + type: SIMPLE_ASSIGN + x[14,1] = 0.3333333333333333 + */ +void Graph_eqFunction_97(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,97}; + data->localData[0]->realVars[980] /* x[14,1] variable */ = 0.3333333333333333; + TRACE_POP +} + +/* + equation index: 98 + type: SIMPLE_ASSIGN + x[15,1] = 0.358974358974359 + */ +void Graph_eqFunction_98(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,98}; + data->localData[0]->realVars[982] /* x[15,1] variable */ = 0.358974358974359; + TRACE_POP +} + +/* + equation index: 99 + type: SIMPLE_ASSIGN + x[16,1] = 0.3846153846153846 + */ +void Graph_eqFunction_99(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,99}; + data->localData[0]->realVars[984] /* x[16,1] variable */ = 0.3846153846153846; + TRACE_POP +} + +/* + equation index: 100 + type: SIMPLE_ASSIGN + x[17,1] = 0.4102564102564102 + */ +void Graph_eqFunction_100(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,100}; + data->localData[0]->realVars[986] /* x[17,1] variable */ = 0.4102564102564102; + TRACE_POP +} + +/* + equation index: 101 + type: SIMPLE_ASSIGN + x[18,1] = 0.4358974358974359 + */ +void Graph_eqFunction_101(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,101}; + data->localData[0]->realVars[988] /* x[18,1] variable */ = 0.4358974358974359; + TRACE_POP +} + +/* + equation index: 102 + type: SIMPLE_ASSIGN + x[19,1] = 0.4615384615384616 + */ +void Graph_eqFunction_102(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,102}; + data->localData[0]->realVars[990] /* x[19,1] variable */ = 0.4615384615384616; + TRACE_POP +} + +/* + equation index: 103 + type: SIMPLE_ASSIGN + x[20,1] = 0.4871794871794872 + */ +void Graph_eqFunction_103(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,103}; + data->localData[0]->realVars[992] /* x[20,1] variable */ = 0.4871794871794872; + TRACE_POP +} + +/* + equation index: 104 + type: SIMPLE_ASSIGN + x[21,1] = 0.5128205128205128 + */ +void Graph_eqFunction_104(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,104}; + data->localData[0]->realVars[994] /* x[21,1] variable */ = 0.5128205128205128; + TRACE_POP +} + +/* + equation index: 105 + type: SIMPLE_ASSIGN + x[22,1] = 0.5384615384615384 + */ +void Graph_eqFunction_105(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,105}; + data->localData[0]->realVars[996] /* x[22,1] variable */ = 0.5384615384615384; + TRACE_POP +} + +/* + equation index: 106 + type: SIMPLE_ASSIGN + x[23,1] = 0.5641025641025641 + */ +void Graph_eqFunction_106(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,106}; + data->localData[0]->realVars[998] /* x[23,1] variable */ = 0.5641025641025641; + TRACE_POP +} + +/* + equation index: 107 + type: SIMPLE_ASSIGN + x[24,1] = 0.5897435897435898 + */ +void Graph_eqFunction_107(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,107}; + data->localData[0]->realVars[1000] /* x[24,1] variable */ = 0.5897435897435898; + TRACE_POP +} + +/* + equation index: 108 + type: SIMPLE_ASSIGN + x[25,1] = 0.6153846153846154 + */ +void Graph_eqFunction_108(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,108}; + data->localData[0]->realVars[1002] /* x[25,1] variable */ = 0.6153846153846154; + TRACE_POP +} + +/* + equation index: 109 + type: SIMPLE_ASSIGN + x[26,1] = 0.6410256410256411 + */ +void Graph_eqFunction_109(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,109}; + data->localData[0]->realVars[1004] /* x[26,1] variable */ = 0.6410256410256411; + TRACE_POP +} + +/* + equation index: 110 + type: SIMPLE_ASSIGN + x[27,1] = 0.6666666666666666 + */ +void Graph_eqFunction_110(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,110}; + data->localData[0]->realVars[1006] /* x[27,1] variable */ = 0.6666666666666666; + TRACE_POP +} + +/* + equation index: 111 + type: SIMPLE_ASSIGN + x[28,1] = 0.6923076923076923 + */ +void Graph_eqFunction_111(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,111}; + data->localData[0]->realVars[1008] /* x[28,1] variable */ = 0.6923076923076923; + TRACE_POP +} + +/* + equation index: 112 + type: SIMPLE_ASSIGN + x[29,1] = 0.717948717948718 + */ +void Graph_eqFunction_112(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,112}; + data->localData[0]->realVars[1010] /* x[29,1] variable */ = 0.717948717948718; + TRACE_POP +} + +/* + equation index: 113 + type: SIMPLE_ASSIGN + x[30,1] = 0.7435897435897436 + */ +void Graph_eqFunction_113(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,113}; + data->localData[0]->realVars[1012] /* x[30,1] variable */ = 0.7435897435897436; + TRACE_POP +} + +/* + equation index: 114 + type: SIMPLE_ASSIGN + x[31,1] = 0.7692307692307693 + */ +void Graph_eqFunction_114(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,114}; + data->localData[0]->realVars[1014] /* x[31,1] variable */ = 0.7692307692307693; + TRACE_POP +} + +/* + equation index: 115 + type: SIMPLE_ASSIGN + x[32,1] = 0.7948717948717948 + */ +void Graph_eqFunction_115(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,115}; + data->localData[0]->realVars[1016] /* x[32,1] variable */ = 0.7948717948717948; + TRACE_POP +} + +/* + equation index: 116 + type: SIMPLE_ASSIGN + x[33,1] = 0.8205128205128205 + */ +void Graph_eqFunction_116(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,116}; + data->localData[0]->realVars[1018] /* x[33,1] variable */ = 0.8205128205128205; + TRACE_POP +} + +/* + equation index: 117 + type: SIMPLE_ASSIGN + x[34,1] = 0.8461538461538462 + */ +void Graph_eqFunction_117(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,117}; + data->localData[0]->realVars[1020] /* x[34,1] variable */ = 0.8461538461538462; + TRACE_POP +} + +/* + equation index: 118 + type: SIMPLE_ASSIGN + x[35,1] = 0.8717948717948718 + */ +void Graph_eqFunction_118(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,118}; + data->localData[0]->realVars[1022] /* x[35,1] variable */ = 0.8717948717948718; + TRACE_POP +} + +/* + equation index: 119 + type: SIMPLE_ASSIGN + x[36,1] = 0.8974358974358975 + */ +void Graph_eqFunction_119(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,119}; + data->localData[0]->realVars[1024] /* x[36,1] variable */ = 0.8974358974358975; + TRACE_POP +} + +/* + equation index: 120 + type: SIMPLE_ASSIGN + x[37,1] = 0.9230769230769231 + */ +void Graph_eqFunction_120(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,120}; + data->localData[0]->realVars[1026] /* x[37,1] variable */ = 0.9230769230769231; + TRACE_POP +} + +/* + equation index: 121 + type: SIMPLE_ASSIGN + x[38,1] = 0.9487179487179487 + */ +void Graph_eqFunction_121(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,121}; + data->localData[0]->realVars[1028] /* x[38,1] variable */ = 0.9487179487179487; + TRACE_POP +} + +/* + equation index: 122 + type: SIMPLE_ASSIGN + x[39,1] = 0.9743589743589743 + */ +void Graph_eqFunction_122(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,122}; + data->localData[0]->realVars[1030] /* x[39,1] variable */ = 0.9743589743589743; + TRACE_POP +} + +/* + equation index: 123 + type: SIMPLE_ASSIGN + x[40,1] = 1.0 + */ +void Graph_eqFunction_123(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,123}; + data->localData[0]->realVars[1032] /* x[40,1] variable */ = 1.0; + TRACE_POP +} + +void Graph_eqFunction_124(DATA*,threadData_t*); +void Graph_eqFunction_125(DATA*,threadData_t*); +void Graph_eqFunction_126(DATA*,threadData_t*); +void Graph_eqFunction_127(DATA*,threadData_t*); +void Graph_eqFunction_128(DATA*,threadData_t*); +/* + equation index: 129 + indexNonlinear: 0 + type: NONLINEAR + + vars: {T[1]} + eqns: {124, 125, 126, 127, 128} + */ +void Graph_eqFunction_129(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,129}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 129 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[0].nlsxOld[0] = data->localData[0]->realVars[200] /* T[1] variable */; + retValue = solve_nonlinear_system(data, threadData, 0); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,129}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 129 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[200] /* T[1] variable */ = data->simulationInfo->nonlinearSystemData[0].nlsx[0]; + TRACE_POP +} + +/* + equation index: 130 + type: SIMPLE_ASSIGN + points[1]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[1].comp[2].LiqDen[1], points[1].comp[2].LiqDen[2], points[1].comp[2].LiqDen[3], points[1].comp[2].LiqDen[4], points[1].comp[2].LiqDen[5], points[1].comp[2].LiqDen[6]}, points[1].comp[2].Tc, T[1], 10000.0) + */ +void Graph_eqFunction_130(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,130}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[8890], (modelica_real)data->simulationInfo->realParameter[8891], (modelica_real)data->simulationInfo->realParameter[8892], (modelica_real)data->simulationInfo->realParameter[8893], (modelica_real)data->simulationInfo->realParameter[8894], (modelica_real)data->simulationInfo->realParameter[8895]); + data->localData[0]->realVars[795] /* points[1]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10965], data->localData[0]->realVars[200] /* T[1] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 131 + type: SIMPLE_ASSIGN + points[1]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[1].comp[1].LiqDen[1], points[1].comp[1].LiqDen[2], points[1].comp[1].LiqDen[3], points[1].comp[1].LiqDen[4], points[1].comp[1].LiqDen[5], points[1].comp[1].LiqDen[6]}, points[1].comp[1].Tc, T[1], 10000.0) + */ +void Graph_eqFunction_131(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,131}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[8884], (modelica_real)data->simulationInfo->realParameter[8885], (modelica_real)data->simulationInfo->realParameter[8886], (modelica_real)data->simulationInfo->realParameter[8887], (modelica_real)data->simulationInfo->realParameter[8888], (modelica_real)data->simulationInfo->realParameter[8889]); + data->localData[0]->realVars[794] /* points[1]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10964], data->localData[0]->realVars[200] /* T[1] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 132 + type: SIMPLE_ASSIGN + points[1]._Gamma._tau[2,1] = 0.5032180796191645 * DIVISION(points[1].BIP[2,1,1], T[1]) + */ +void Graph_eqFunction_132(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,132}; + data->localData[0]->realVars[558] /* points[1]._Gamma._tau[2,1] variable */ = (0.5032180796191645) * (DIVISION_SIM(data->simulationInfo->realParameter[328],data->localData[0]->realVars[200] /* T[1] variable */,"T[1]",equationIndexes)); + TRACE_POP +} + +/* + equation index: 133 + type: SIMPLE_ASSIGN + points[1]._Gamma._sum1[1] = exp((-points[1].BIP[2,1,2]) * points[1].Gamma.tau[2,1]) + */ +void Graph_eqFunction_133(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,133}; + data->localData[0]->realVars[396] /* points[1]._Gamma._sum1[1] variable */ = exp(((-data->simulationInfo->realParameter[329])) * (data->localData[0]->realVars[558] /* points[1]._Gamma._tau[2,1] variable */)); + TRACE_POP +} + +/* + equation index: 134 + type: SIMPLE_ASSIGN + points[1]._Gamma._sum2[1] = points[1].Gamma.tau[2,1] * points[1].Gamma.sum1[1] + */ +void Graph_eqFunction_134(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,134}; + data->localData[0]->realVars[476] /* points[1]._Gamma._sum2[1] variable */ = (data->localData[0]->realVars[558] /* points[1]._Gamma._tau[2,1] variable */) * (data->localData[0]->realVars[396] /* points[1]._Gamma._sum1[1] variable */); + TRACE_POP +} + +/* + equation index: 135 + type: SIMPLE_ASSIGN + points[1]._Gamma._tau[1,2] = 0.5032180796191645 * DIVISION(points[1].BIP[1,2,1], T[1]) + */ +void Graph_eqFunction_135(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,135}; + data->localData[0]->realVars[557] /* points[1]._Gamma._tau[1,2] variable */ = (0.5032180796191645) * (DIVISION_SIM(data->simulationInfo->realParameter[326],data->localData[0]->realVars[200] /* T[1] variable */,"T[1]",equationIndexes)); + TRACE_POP +} + +/* + equation index: 136 + type: SIMPLE_ASSIGN + points[1]._Gamma._G[1,2] = exp((-points[1].BIP[1,2,2]) * points[1].Gamma.tau[1,2]) + */ +void Graph_eqFunction_136(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,136}; + data->localData[0]->realVars[241] /* points[1]._Gamma._G[1,2] variable */ = exp(((-data->simulationInfo->realParameter[327])) * (data->localData[0]->realVars[557] /* points[1]._Gamma._tau[1,2] variable */)); + TRACE_POP +} + +/* + equation index: 137 + type: SIMPLE_ASSIGN + points[1]._gamma[1] = exp(DIVISION(points[1].Gamma.sum2[1], points[1].Gamma.sum1[1]) + points[1].Gamma.G[1,2] * DIVISION(points[1].Gamma.tau[1,2] - DIVISION(points[1].Gamma.sum2[2], points[1].Gamma.sum1[2]), points[1].Gamma.sum1[2])) + */ +void Graph_eqFunction_137(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,137}; + data->localData[0]->realVars[874] /* points[1]._gamma[1] variable */ = exp(DIVISION_SIM(data->localData[0]->realVars[476] /* points[1]._Gamma._sum2[1] variable */,data->localData[0]->realVars[396] /* points[1]._Gamma._sum1[1] variable */,"points[1].Gamma.sum1[1]",equationIndexes) + (data->localData[0]->realVars[241] /* points[1]._Gamma._G[1,2] variable */) * (DIVISION_SIM(data->localData[0]->realVars[557] /* points[1]._Gamma._tau[1,2] variable */ - DIVISION_SIM(data->localData[0]->realVars[477] /* points[1]._Gamma._sum2[2] variable */,data->localData[0]->realVars[397] /* points[1]._Gamma._sum1[2] variable */,"points[1].Gamma.sum1[2]",equationIndexes),data->localData[0]->realVars[397] /* points[1]._Gamma._sum1[2] variable */,"points[1].Gamma.sum1[2]",equationIndexes))); + TRACE_POP +} + +/* + equation index: 138 + type: SIMPLE_ASSIGN + points[1]._K[1] = 0.0001 * points[1].gamma[1] * Simulator.Files.ThermodynamicFunctions.Psat({points[1].comp[1].VP[1], points[1].comp[1].VP[2], points[1].comp[1].VP[3], points[1].comp[1].VP[4], points[1].comp[1].VP[5], points[1].comp[1].VP[6]}, T[1]) + */ +void Graph_eqFunction_138(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,138}; + real_array tmp2; + array_alloc_scalar_real_array(&tmp2, 6, (modelica_real)data->simulationInfo->realParameter[11284], (modelica_real)data->simulationInfo->realParameter[11285], (modelica_real)data->simulationInfo->realParameter[11286], (modelica_real)data->simulationInfo->realParameter[11287], (modelica_real)data->simulationInfo->realParameter[11288], (modelica_real)data->simulationInfo->realParameter[11289]); + data->localData[0]->realVars[716] /* points[1]._K[1] variable */ = (0.0001) * ((data->localData[0]->realVars[874] /* points[1]._gamma[1] variable */) * (omc_Simulator_Files_ThermodynamicFunctions_Psat(threadData, tmp2, data->localData[0]->realVars[200] /* T[1] variable */))); + TRACE_POP +} + +/* + equation index: 139 + type: SIMPLE_ASSIGN + points[1]._Gamma._tau[1,1] = 0.5032180796191645 * DIVISION(points[1].BIP[1,1,1], T[1]) + */ +void Graph_eqFunction_139(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,139}; + data->localData[0]->realVars[556] /* points[1]._Gamma._tau[1,1] variable */ = (0.5032180796191645) * (DIVISION_SIM(data->simulationInfo->realParameter[324],data->localData[0]->realVars[200] /* T[1] variable */,"T[1]",equationIndexes)); + TRACE_POP +} + +/* + equation index: 140 + type: SIMPLE_ASSIGN + points[1]._Gamma._G[1,1] = exp((-points[1].BIP[1,1,2]) * points[1].Gamma.tau[1,1]) + */ +void Graph_eqFunction_140(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,140}; + data->localData[0]->realVars[240] /* points[1]._Gamma._G[1,1] variable */ = exp(((-data->simulationInfo->realParameter[325])) * (data->localData[0]->realVars[556] /* points[1]._Gamma._tau[1,1] variable */)); + TRACE_POP +} + +void Graph_eqFunction_141(DATA*,threadData_t*); +void Graph_eqFunction_142(DATA*,threadData_t*); +void Graph_eqFunction_143(DATA*,threadData_t*); +void Graph_eqFunction_144(DATA*,threadData_t*); +void Graph_eqFunction_145(DATA*,threadData_t*); +void Graph_eqFunction_146(DATA*,threadData_t*); +void Graph_eqFunction_147(DATA*,threadData_t*); +void Graph_eqFunction_148(DATA*,threadData_t*); +void Graph_eqFunction_149(DATA*,threadData_t*); +void Graph_eqFunction_150(DATA*,threadData_t*); +void Graph_eqFunction_151(DATA*,threadData_t*); +void Graph_eqFunction_152(DATA*,threadData_t*); +void Graph_eqFunction_153(DATA*,threadData_t*); +void Graph_eqFunction_154(DATA*,threadData_t*); +void Graph_eqFunction_155(DATA*,threadData_t*); +void Graph_eqFunction_156(DATA*,threadData_t*); +void Graph_eqFunction_157(DATA*,threadData_t*); +/* + equation index: 158 + indexNonlinear: 1 + type: NONLINEAR + + vars: {T[2]} + eqns: {141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157} + */ +void Graph_eqFunction_158(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,158}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 158 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[1].nlsxOld[0] = data->localData[0]->realVars[201] /* T[2] variable */; + retValue = solve_nonlinear_system(data, threadData, 1); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,158}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 158 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[201] /* T[2] variable */ = data->simulationInfo->nonlinearSystemData[1].nlsx[0]; + TRACE_POP +} + +/* + equation index: 159 + type: SIMPLE_ASSIGN + y[2,1] = 1.0 - 0.9743589743589743 * points[2].K[2] + */ +void Graph_eqFunction_159(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,159}; + data->localData[0]->realVars[1036] /* y[2,1] variable */ = 1.0 - ((0.9743589743589743) * (data->localData[0]->realVars[718] /* points[2]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 160 + type: SIMPLE_ASSIGN + y[2,2] = 0.9743589743589743 * points[2].K[2] + */ +void Graph_eqFunction_160(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,160}; + data->localData[0]->realVars[1037] /* y[2,2] variable */ = (0.9743589743589743) * (data->localData[0]->realVars[718] /* points[2]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 161 + type: SIMPLE_ASSIGN + points[2]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[2].comp[2].LiqDen[1], points[2].comp[2].LiqDen[2], points[2].comp[2].LiqDen[3], points[2].comp[2].LiqDen[4], points[2].comp[2].LiqDen[5], points[2].comp[2].LiqDen[6]}, points[2].comp[2].Tc, T[2], 10000.0) + */ +void Graph_eqFunction_161(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,161}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[8902], (modelica_real)data->simulationInfo->realParameter[8903], (modelica_real)data->simulationInfo->realParameter[8904], (modelica_real)data->simulationInfo->realParameter[8905], (modelica_real)data->simulationInfo->realParameter[8906], (modelica_real)data->simulationInfo->realParameter[8907]); + data->localData[0]->realVars[797] /* points[2]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10967], data->localData[0]->realVars[201] /* T[2] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 162 + type: SIMPLE_ASSIGN + points[2]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[2].comp[1].LiqDen[1], points[2].comp[1].LiqDen[2], points[2].comp[1].LiqDen[3], points[2].comp[1].LiqDen[4], points[2].comp[1].LiqDen[5], points[2].comp[1].LiqDen[6]}, points[2].comp[1].Tc, T[2], 10000.0) + */ +void Graph_eqFunction_162(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,162}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[8896], (modelica_real)data->simulationInfo->realParameter[8897], (modelica_real)data->simulationInfo->realParameter[8898], (modelica_real)data->simulationInfo->realParameter[8899], (modelica_real)data->simulationInfo->realParameter[8900], (modelica_real)data->simulationInfo->realParameter[8901]); + data->localData[0]->realVars[796] /* points[2]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10966], data->localData[0]->realVars[201] /* T[2] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_163(DATA*,threadData_t*); +void Graph_eqFunction_164(DATA*,threadData_t*); +void Graph_eqFunction_165(DATA*,threadData_t*); +void Graph_eqFunction_166(DATA*,threadData_t*); +void Graph_eqFunction_167(DATA*,threadData_t*); +void Graph_eqFunction_168(DATA*,threadData_t*); +void Graph_eqFunction_169(DATA*,threadData_t*); +void Graph_eqFunction_170(DATA*,threadData_t*); +void Graph_eqFunction_171(DATA*,threadData_t*); +void Graph_eqFunction_172(DATA*,threadData_t*); +void Graph_eqFunction_173(DATA*,threadData_t*); +void Graph_eqFunction_174(DATA*,threadData_t*); +void Graph_eqFunction_175(DATA*,threadData_t*); +void Graph_eqFunction_176(DATA*,threadData_t*); +void Graph_eqFunction_177(DATA*,threadData_t*); +void Graph_eqFunction_178(DATA*,threadData_t*); +void Graph_eqFunction_179(DATA*,threadData_t*); +/* + equation index: 180 + indexNonlinear: 2 + type: NONLINEAR + + vars: {T[3]} + eqns: {163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179} + */ +void Graph_eqFunction_180(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,180}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 180 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[2].nlsxOld[0] = data->localData[0]->realVars[202] /* T[3] variable */; + retValue = solve_nonlinear_system(data, threadData, 2); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,180}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 180 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[202] /* T[3] variable */ = data->simulationInfo->nonlinearSystemData[2].nlsx[0]; + TRACE_POP +} + +/* + equation index: 181 + type: SIMPLE_ASSIGN + y[3,1] = 1.0 - 0.9487179487179487 * points[3].K[2] + */ +void Graph_eqFunction_181(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,181}; + data->localData[0]->realVars[1038] /* y[3,1] variable */ = 1.0 - ((0.9487179487179487) * (data->localData[0]->realVars[720] /* points[3]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 182 + type: SIMPLE_ASSIGN + y[3,2] = 0.9487179487179487 * points[3].K[2] + */ +void Graph_eqFunction_182(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,182}; + data->localData[0]->realVars[1039] /* y[3,2] variable */ = (0.9487179487179487) * (data->localData[0]->realVars[720] /* points[3]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 183 + type: SIMPLE_ASSIGN + points[3]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[3].comp[2].LiqDen[1], points[3].comp[2].LiqDen[2], points[3].comp[2].LiqDen[3], points[3].comp[2].LiqDen[4], points[3].comp[2].LiqDen[5], points[3].comp[2].LiqDen[6]}, points[3].comp[2].Tc, T[3], 10000.0) + */ +void Graph_eqFunction_183(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,183}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[8914], (modelica_real)data->simulationInfo->realParameter[8915], (modelica_real)data->simulationInfo->realParameter[8916], (modelica_real)data->simulationInfo->realParameter[8917], (modelica_real)data->simulationInfo->realParameter[8918], (modelica_real)data->simulationInfo->realParameter[8919]); + data->localData[0]->realVars[799] /* points[3]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10969], data->localData[0]->realVars[202] /* T[3] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 184 + type: SIMPLE_ASSIGN + points[3]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[3].comp[1].LiqDen[1], points[3].comp[1].LiqDen[2], points[3].comp[1].LiqDen[3], points[3].comp[1].LiqDen[4], points[3].comp[1].LiqDen[5], points[3].comp[1].LiqDen[6]}, points[3].comp[1].Tc, T[3], 10000.0) + */ +void Graph_eqFunction_184(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,184}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[8908], (modelica_real)data->simulationInfo->realParameter[8909], (modelica_real)data->simulationInfo->realParameter[8910], (modelica_real)data->simulationInfo->realParameter[8911], (modelica_real)data->simulationInfo->realParameter[8912], (modelica_real)data->simulationInfo->realParameter[8913]); + data->localData[0]->realVars[798] /* points[3]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10968], data->localData[0]->realVars[202] /* T[3] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_185(DATA*,threadData_t*); +void Graph_eqFunction_186(DATA*,threadData_t*); +void Graph_eqFunction_187(DATA*,threadData_t*); +void Graph_eqFunction_188(DATA*,threadData_t*); +void Graph_eqFunction_189(DATA*,threadData_t*); +void Graph_eqFunction_190(DATA*,threadData_t*); +void Graph_eqFunction_191(DATA*,threadData_t*); +void Graph_eqFunction_192(DATA*,threadData_t*); +void Graph_eqFunction_193(DATA*,threadData_t*); +void Graph_eqFunction_194(DATA*,threadData_t*); +void Graph_eqFunction_195(DATA*,threadData_t*); +void Graph_eqFunction_196(DATA*,threadData_t*); +void Graph_eqFunction_197(DATA*,threadData_t*); +void Graph_eqFunction_198(DATA*,threadData_t*); +void Graph_eqFunction_199(DATA*,threadData_t*); +void Graph_eqFunction_200(DATA*,threadData_t*); +void Graph_eqFunction_201(DATA*,threadData_t*); +/* + equation index: 202 + indexNonlinear: 3 + type: NONLINEAR + + vars: {T[4]} + eqns: {185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201} + */ +void Graph_eqFunction_202(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,202}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 202 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[3].nlsxOld[0] = data->localData[0]->realVars[203] /* T[4] variable */; + retValue = solve_nonlinear_system(data, threadData, 3); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,202}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 202 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[203] /* T[4] variable */ = data->simulationInfo->nonlinearSystemData[3].nlsx[0]; + TRACE_POP +} + +/* + equation index: 203 + type: SIMPLE_ASSIGN + y[4,1] = 1.0 - 0.9230769230769231 * points[4].K[2] + */ +void Graph_eqFunction_203(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,203}; + data->localData[0]->realVars[1040] /* y[4,1] variable */ = 1.0 - ((0.9230769230769231) * (data->localData[0]->realVars[722] /* points[4]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 204 + type: SIMPLE_ASSIGN + y[4,2] = 0.9230769230769231 * points[4].K[2] + */ +void Graph_eqFunction_204(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,204}; + data->localData[0]->realVars[1041] /* y[4,2] variable */ = (0.9230769230769231) * (data->localData[0]->realVars[722] /* points[4]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 205 + type: SIMPLE_ASSIGN + points[4]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[4].comp[2].LiqDen[1], points[4].comp[2].LiqDen[2], points[4].comp[2].LiqDen[3], points[4].comp[2].LiqDen[4], points[4].comp[2].LiqDen[5], points[4].comp[2].LiqDen[6]}, points[4].comp[2].Tc, T[4], 10000.0) + */ +void Graph_eqFunction_205(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,205}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[8926], (modelica_real)data->simulationInfo->realParameter[8927], (modelica_real)data->simulationInfo->realParameter[8928], (modelica_real)data->simulationInfo->realParameter[8929], (modelica_real)data->simulationInfo->realParameter[8930], (modelica_real)data->simulationInfo->realParameter[8931]); + data->localData[0]->realVars[801] /* points[4]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10971], data->localData[0]->realVars[203] /* T[4] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 206 + type: SIMPLE_ASSIGN + points[4]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[4].comp[1].LiqDen[1], points[4].comp[1].LiqDen[2], points[4].comp[1].LiqDen[3], points[4].comp[1].LiqDen[4], points[4].comp[1].LiqDen[5], points[4].comp[1].LiqDen[6]}, points[4].comp[1].Tc, T[4], 10000.0) + */ +void Graph_eqFunction_206(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,206}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[8920], (modelica_real)data->simulationInfo->realParameter[8921], (modelica_real)data->simulationInfo->realParameter[8922], (modelica_real)data->simulationInfo->realParameter[8923], (modelica_real)data->simulationInfo->realParameter[8924], (modelica_real)data->simulationInfo->realParameter[8925]); + data->localData[0]->realVars[800] /* points[4]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10970], data->localData[0]->realVars[203] /* T[4] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_207(DATA*,threadData_t*); +void Graph_eqFunction_208(DATA*,threadData_t*); +void Graph_eqFunction_209(DATA*,threadData_t*); +void Graph_eqFunction_210(DATA*,threadData_t*); +void Graph_eqFunction_211(DATA*,threadData_t*); +void Graph_eqFunction_212(DATA*,threadData_t*); +void Graph_eqFunction_213(DATA*,threadData_t*); +void Graph_eqFunction_214(DATA*,threadData_t*); +void Graph_eqFunction_215(DATA*,threadData_t*); +void Graph_eqFunction_216(DATA*,threadData_t*); +void Graph_eqFunction_217(DATA*,threadData_t*); +void Graph_eqFunction_218(DATA*,threadData_t*); +void Graph_eqFunction_219(DATA*,threadData_t*); +void Graph_eqFunction_220(DATA*,threadData_t*); +void Graph_eqFunction_221(DATA*,threadData_t*); +void Graph_eqFunction_222(DATA*,threadData_t*); +void Graph_eqFunction_223(DATA*,threadData_t*); +/* + equation index: 224 + indexNonlinear: 4 + type: NONLINEAR + + vars: {T[5]} + eqns: {207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223} + */ +void Graph_eqFunction_224(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,224}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 224 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[4].nlsxOld[0] = data->localData[0]->realVars[204] /* T[5] variable */; + retValue = solve_nonlinear_system(data, threadData, 4); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,224}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 224 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[204] /* T[5] variable */ = data->simulationInfo->nonlinearSystemData[4].nlsx[0]; + TRACE_POP +} + +/* + equation index: 225 + type: SIMPLE_ASSIGN + y[5,1] = 1.0 - 0.8974358974358975 * points[5].K[2] + */ +void Graph_eqFunction_225(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,225}; + data->localData[0]->realVars[1042] /* y[5,1] variable */ = 1.0 - ((0.8974358974358975) * (data->localData[0]->realVars[724] /* points[5]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 226 + type: SIMPLE_ASSIGN + y[5,2] = 0.8974358974358975 * points[5].K[2] + */ +void Graph_eqFunction_226(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,226}; + data->localData[0]->realVars[1043] /* y[5,2] variable */ = (0.8974358974358975) * (data->localData[0]->realVars[724] /* points[5]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 227 + type: SIMPLE_ASSIGN + points[5]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[5].comp[2].LiqDen[1], points[5].comp[2].LiqDen[2], points[5].comp[2].LiqDen[3], points[5].comp[2].LiqDen[4], points[5].comp[2].LiqDen[5], points[5].comp[2].LiqDen[6]}, points[5].comp[2].Tc, T[5], 10000.0) + */ +void Graph_eqFunction_227(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,227}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[8938], (modelica_real)data->simulationInfo->realParameter[8939], (modelica_real)data->simulationInfo->realParameter[8940], (modelica_real)data->simulationInfo->realParameter[8941], (modelica_real)data->simulationInfo->realParameter[8942], (modelica_real)data->simulationInfo->realParameter[8943]); + data->localData[0]->realVars[803] /* points[5]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10973], data->localData[0]->realVars[204] /* T[5] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 228 + type: SIMPLE_ASSIGN + points[5]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[5].comp[1].LiqDen[1], points[5].comp[1].LiqDen[2], points[5].comp[1].LiqDen[3], points[5].comp[1].LiqDen[4], points[5].comp[1].LiqDen[5], points[5].comp[1].LiqDen[6]}, points[5].comp[1].Tc, T[5], 10000.0) + */ +void Graph_eqFunction_228(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,228}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[8932], (modelica_real)data->simulationInfo->realParameter[8933], (modelica_real)data->simulationInfo->realParameter[8934], (modelica_real)data->simulationInfo->realParameter[8935], (modelica_real)data->simulationInfo->realParameter[8936], (modelica_real)data->simulationInfo->realParameter[8937]); + data->localData[0]->realVars[802] /* points[5]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10972], data->localData[0]->realVars[204] /* T[5] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_229(DATA*,threadData_t*); +void Graph_eqFunction_230(DATA*,threadData_t*); +void Graph_eqFunction_231(DATA*,threadData_t*); +void Graph_eqFunction_232(DATA*,threadData_t*); +void Graph_eqFunction_233(DATA*,threadData_t*); +void Graph_eqFunction_234(DATA*,threadData_t*); +void Graph_eqFunction_235(DATA*,threadData_t*); +void Graph_eqFunction_236(DATA*,threadData_t*); +void Graph_eqFunction_237(DATA*,threadData_t*); +void Graph_eqFunction_238(DATA*,threadData_t*); +void Graph_eqFunction_239(DATA*,threadData_t*); +void Graph_eqFunction_240(DATA*,threadData_t*); +void Graph_eqFunction_241(DATA*,threadData_t*); +void Graph_eqFunction_242(DATA*,threadData_t*); +void Graph_eqFunction_243(DATA*,threadData_t*); +void Graph_eqFunction_244(DATA*,threadData_t*); +void Graph_eqFunction_245(DATA*,threadData_t*); +/* + equation index: 246 + indexNonlinear: 5 + type: NONLINEAR + + vars: {T[6]} + eqns: {229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245} + */ +void Graph_eqFunction_246(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,246}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 246 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[5].nlsxOld[0] = data->localData[0]->realVars[205] /* T[6] variable */; + retValue = solve_nonlinear_system(data, threadData, 5); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,246}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 246 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[205] /* T[6] variable */ = data->simulationInfo->nonlinearSystemData[5].nlsx[0]; + TRACE_POP +} + +/* + equation index: 247 + type: SIMPLE_ASSIGN + y[6,1] = 1.0 - 0.8717948717948718 * points[6].K[2] + */ +void Graph_eqFunction_247(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,247}; + data->localData[0]->realVars[1044] /* y[6,1] variable */ = 1.0 - ((0.8717948717948718) * (data->localData[0]->realVars[726] /* points[6]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 248 + type: SIMPLE_ASSIGN + y[6,2] = 0.8717948717948718 * points[6].K[2] + */ +void Graph_eqFunction_248(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,248}; + data->localData[0]->realVars[1045] /* y[6,2] variable */ = (0.8717948717948718) * (data->localData[0]->realVars[726] /* points[6]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 249 + type: SIMPLE_ASSIGN + points[6]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[6].comp[2].LiqDen[1], points[6].comp[2].LiqDen[2], points[6].comp[2].LiqDen[3], points[6].comp[2].LiqDen[4], points[6].comp[2].LiqDen[5], points[6].comp[2].LiqDen[6]}, points[6].comp[2].Tc, T[6], 10000.0) + */ +void Graph_eqFunction_249(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,249}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[8950], (modelica_real)data->simulationInfo->realParameter[8951], (modelica_real)data->simulationInfo->realParameter[8952], (modelica_real)data->simulationInfo->realParameter[8953], (modelica_real)data->simulationInfo->realParameter[8954], (modelica_real)data->simulationInfo->realParameter[8955]); + data->localData[0]->realVars[805] /* points[6]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10975], data->localData[0]->realVars[205] /* T[6] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 250 + type: SIMPLE_ASSIGN + points[6]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[6].comp[1].LiqDen[1], points[6].comp[1].LiqDen[2], points[6].comp[1].LiqDen[3], points[6].comp[1].LiqDen[4], points[6].comp[1].LiqDen[5], points[6].comp[1].LiqDen[6]}, points[6].comp[1].Tc, T[6], 10000.0) + */ +void Graph_eqFunction_250(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,250}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[8944], (modelica_real)data->simulationInfo->realParameter[8945], (modelica_real)data->simulationInfo->realParameter[8946], (modelica_real)data->simulationInfo->realParameter[8947], (modelica_real)data->simulationInfo->realParameter[8948], (modelica_real)data->simulationInfo->realParameter[8949]); + data->localData[0]->realVars[804] /* points[6]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10974], data->localData[0]->realVars[205] /* T[6] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_251(DATA*,threadData_t*); +void Graph_eqFunction_252(DATA*,threadData_t*); +void Graph_eqFunction_253(DATA*,threadData_t*); +void Graph_eqFunction_254(DATA*,threadData_t*); +void Graph_eqFunction_255(DATA*,threadData_t*); +void Graph_eqFunction_256(DATA*,threadData_t*); +void Graph_eqFunction_257(DATA*,threadData_t*); +void Graph_eqFunction_258(DATA*,threadData_t*); +void Graph_eqFunction_259(DATA*,threadData_t*); +void Graph_eqFunction_260(DATA*,threadData_t*); +void Graph_eqFunction_261(DATA*,threadData_t*); +void Graph_eqFunction_262(DATA*,threadData_t*); +void Graph_eqFunction_263(DATA*,threadData_t*); +void Graph_eqFunction_264(DATA*,threadData_t*); +void Graph_eqFunction_265(DATA*,threadData_t*); +void Graph_eqFunction_266(DATA*,threadData_t*); +void Graph_eqFunction_267(DATA*,threadData_t*); +/* + equation index: 268 + indexNonlinear: 6 + type: NONLINEAR + + vars: {T[7]} + eqns: {251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267} + */ +void Graph_eqFunction_268(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,268}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 268 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[6].nlsxOld[0] = data->localData[0]->realVars[206] /* T[7] variable */; + retValue = solve_nonlinear_system(data, threadData, 6); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,268}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 268 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[206] /* T[7] variable */ = data->simulationInfo->nonlinearSystemData[6].nlsx[0]; + TRACE_POP +} + +/* + equation index: 269 + type: SIMPLE_ASSIGN + y[7,1] = 1.0 - 0.8461538461538462 * points[7].K[2] + */ +void Graph_eqFunction_269(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,269}; + data->localData[0]->realVars[1046] /* y[7,1] variable */ = 1.0 - ((0.8461538461538462) * (data->localData[0]->realVars[728] /* points[7]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 270 + type: SIMPLE_ASSIGN + y[7,2] = 0.8461538461538462 * points[7].K[2] + */ +void Graph_eqFunction_270(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,270}; + data->localData[0]->realVars[1047] /* y[7,2] variable */ = (0.8461538461538462) * (data->localData[0]->realVars[728] /* points[7]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 271 + type: SIMPLE_ASSIGN + points[7]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[7].comp[2].LiqDen[1], points[7].comp[2].LiqDen[2], points[7].comp[2].LiqDen[3], points[7].comp[2].LiqDen[4], points[7].comp[2].LiqDen[5], points[7].comp[2].LiqDen[6]}, points[7].comp[2].Tc, T[7], 10000.0) + */ +void Graph_eqFunction_271(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,271}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[8962], (modelica_real)data->simulationInfo->realParameter[8963], (modelica_real)data->simulationInfo->realParameter[8964], (modelica_real)data->simulationInfo->realParameter[8965], (modelica_real)data->simulationInfo->realParameter[8966], (modelica_real)data->simulationInfo->realParameter[8967]); + data->localData[0]->realVars[807] /* points[7]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10977], data->localData[0]->realVars[206] /* T[7] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 272 + type: SIMPLE_ASSIGN + points[7]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[7].comp[1].LiqDen[1], points[7].comp[1].LiqDen[2], points[7].comp[1].LiqDen[3], points[7].comp[1].LiqDen[4], points[7].comp[1].LiqDen[5], points[7].comp[1].LiqDen[6]}, points[7].comp[1].Tc, T[7], 10000.0) + */ +void Graph_eqFunction_272(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,272}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[8956], (modelica_real)data->simulationInfo->realParameter[8957], (modelica_real)data->simulationInfo->realParameter[8958], (modelica_real)data->simulationInfo->realParameter[8959], (modelica_real)data->simulationInfo->realParameter[8960], (modelica_real)data->simulationInfo->realParameter[8961]); + data->localData[0]->realVars[806] /* points[7]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10976], data->localData[0]->realVars[206] /* T[7] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_273(DATA*,threadData_t*); +void Graph_eqFunction_274(DATA*,threadData_t*); +void Graph_eqFunction_275(DATA*,threadData_t*); +void Graph_eqFunction_276(DATA*,threadData_t*); +void Graph_eqFunction_277(DATA*,threadData_t*); +void Graph_eqFunction_278(DATA*,threadData_t*); +void Graph_eqFunction_279(DATA*,threadData_t*); +void Graph_eqFunction_280(DATA*,threadData_t*); +void Graph_eqFunction_281(DATA*,threadData_t*); +void Graph_eqFunction_282(DATA*,threadData_t*); +void Graph_eqFunction_283(DATA*,threadData_t*); +void Graph_eqFunction_284(DATA*,threadData_t*); +void Graph_eqFunction_285(DATA*,threadData_t*); +void Graph_eqFunction_286(DATA*,threadData_t*); +void Graph_eqFunction_287(DATA*,threadData_t*); +void Graph_eqFunction_288(DATA*,threadData_t*); +void Graph_eqFunction_289(DATA*,threadData_t*); +/* + equation index: 290 + indexNonlinear: 7 + type: NONLINEAR + + vars: {T[8]} + eqns: {273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289} + */ +void Graph_eqFunction_290(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,290}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 290 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[7].nlsxOld[0] = data->localData[0]->realVars[207] /* T[8] variable */; + retValue = solve_nonlinear_system(data, threadData, 7); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,290}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 290 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[207] /* T[8] variable */ = data->simulationInfo->nonlinearSystemData[7].nlsx[0]; + TRACE_POP +} + +/* + equation index: 291 + type: SIMPLE_ASSIGN + y[8,1] = 1.0 - 0.8205128205128205 * points[8].K[2] + */ +void Graph_eqFunction_291(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,291}; + data->localData[0]->realVars[1048] /* y[8,1] variable */ = 1.0 - ((0.8205128205128205) * (data->localData[0]->realVars[730] /* points[8]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 292 + type: SIMPLE_ASSIGN + y[8,2] = 0.8205128205128205 * points[8].K[2] + */ +void Graph_eqFunction_292(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,292}; + data->localData[0]->realVars[1049] /* y[8,2] variable */ = (0.8205128205128205) * (data->localData[0]->realVars[730] /* points[8]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 293 + type: SIMPLE_ASSIGN + points[8]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[8].comp[2].LiqDen[1], points[8].comp[2].LiqDen[2], points[8].comp[2].LiqDen[3], points[8].comp[2].LiqDen[4], points[8].comp[2].LiqDen[5], points[8].comp[2].LiqDen[6]}, points[8].comp[2].Tc, T[8], 10000.0) + */ +void Graph_eqFunction_293(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,293}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[8974], (modelica_real)data->simulationInfo->realParameter[8975], (modelica_real)data->simulationInfo->realParameter[8976], (modelica_real)data->simulationInfo->realParameter[8977], (modelica_real)data->simulationInfo->realParameter[8978], (modelica_real)data->simulationInfo->realParameter[8979]); + data->localData[0]->realVars[809] /* points[8]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10979], data->localData[0]->realVars[207] /* T[8] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 294 + type: SIMPLE_ASSIGN + points[8]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[8].comp[1].LiqDen[1], points[8].comp[1].LiqDen[2], points[8].comp[1].LiqDen[3], points[8].comp[1].LiqDen[4], points[8].comp[1].LiqDen[5], points[8].comp[1].LiqDen[6]}, points[8].comp[1].Tc, T[8], 10000.0) + */ +void Graph_eqFunction_294(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,294}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[8968], (modelica_real)data->simulationInfo->realParameter[8969], (modelica_real)data->simulationInfo->realParameter[8970], (modelica_real)data->simulationInfo->realParameter[8971], (modelica_real)data->simulationInfo->realParameter[8972], (modelica_real)data->simulationInfo->realParameter[8973]); + data->localData[0]->realVars[808] /* points[8]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10978], data->localData[0]->realVars[207] /* T[8] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_295(DATA*,threadData_t*); +void Graph_eqFunction_296(DATA*,threadData_t*); +void Graph_eqFunction_297(DATA*,threadData_t*); +void Graph_eqFunction_298(DATA*,threadData_t*); +void Graph_eqFunction_299(DATA*,threadData_t*); +void Graph_eqFunction_300(DATA*,threadData_t*); +void Graph_eqFunction_301(DATA*,threadData_t*); +void Graph_eqFunction_302(DATA*,threadData_t*); +void Graph_eqFunction_303(DATA*,threadData_t*); +void Graph_eqFunction_304(DATA*,threadData_t*); +void Graph_eqFunction_305(DATA*,threadData_t*); +void Graph_eqFunction_306(DATA*,threadData_t*); +void Graph_eqFunction_307(DATA*,threadData_t*); +void Graph_eqFunction_308(DATA*,threadData_t*); +void Graph_eqFunction_309(DATA*,threadData_t*); +void Graph_eqFunction_310(DATA*,threadData_t*); +void Graph_eqFunction_311(DATA*,threadData_t*); +/* + equation index: 312 + indexNonlinear: 8 + type: NONLINEAR + + vars: {T[9]} + eqns: {295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311} + */ +void Graph_eqFunction_312(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,312}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 312 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[8].nlsxOld[0] = data->localData[0]->realVars[208] /* T[9] variable */; + retValue = solve_nonlinear_system(data, threadData, 8); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,312}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 312 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[208] /* T[9] variable */ = data->simulationInfo->nonlinearSystemData[8].nlsx[0]; + TRACE_POP +} + +/* + equation index: 313 + type: SIMPLE_ASSIGN + y[9,1] = 1.0 - 0.7948717948717949 * points[9].K[2] + */ +void Graph_eqFunction_313(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,313}; + data->localData[0]->realVars[1050] /* y[9,1] variable */ = 1.0 - ((0.7948717948717949) * (data->localData[0]->realVars[732] /* points[9]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 314 + type: SIMPLE_ASSIGN + y[9,2] = 0.7948717948717949 * points[9].K[2] + */ +void Graph_eqFunction_314(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,314}; + data->localData[0]->realVars[1051] /* y[9,2] variable */ = (0.7948717948717949) * (data->localData[0]->realVars[732] /* points[9]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 315 + type: SIMPLE_ASSIGN + points[9]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[9].comp[2].LiqDen[1], points[9].comp[2].LiqDen[2], points[9].comp[2].LiqDen[3], points[9].comp[2].LiqDen[4], points[9].comp[2].LiqDen[5], points[9].comp[2].LiqDen[6]}, points[9].comp[2].Tc, T[9], 10000.0) + */ +void Graph_eqFunction_315(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,315}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[8986], (modelica_real)data->simulationInfo->realParameter[8987], (modelica_real)data->simulationInfo->realParameter[8988], (modelica_real)data->simulationInfo->realParameter[8989], (modelica_real)data->simulationInfo->realParameter[8990], (modelica_real)data->simulationInfo->realParameter[8991]); + data->localData[0]->realVars[811] /* points[9]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10981], data->localData[0]->realVars[208] /* T[9] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 316 + type: SIMPLE_ASSIGN + points[9]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[9].comp[1].LiqDen[1], points[9].comp[1].LiqDen[2], points[9].comp[1].LiqDen[3], points[9].comp[1].LiqDen[4], points[9].comp[1].LiqDen[5], points[9].comp[1].LiqDen[6]}, points[9].comp[1].Tc, T[9], 10000.0) + */ +void Graph_eqFunction_316(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,316}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[8980], (modelica_real)data->simulationInfo->realParameter[8981], (modelica_real)data->simulationInfo->realParameter[8982], (modelica_real)data->simulationInfo->realParameter[8983], (modelica_real)data->simulationInfo->realParameter[8984], (modelica_real)data->simulationInfo->realParameter[8985]); + data->localData[0]->realVars[810] /* points[9]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10980], data->localData[0]->realVars[208] /* T[9] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_317(DATA*,threadData_t*); +void Graph_eqFunction_318(DATA*,threadData_t*); +void Graph_eqFunction_319(DATA*,threadData_t*); +void Graph_eqFunction_320(DATA*,threadData_t*); +void Graph_eqFunction_321(DATA*,threadData_t*); +void Graph_eqFunction_322(DATA*,threadData_t*); +void Graph_eqFunction_323(DATA*,threadData_t*); +void Graph_eqFunction_324(DATA*,threadData_t*); +void Graph_eqFunction_325(DATA*,threadData_t*); +void Graph_eqFunction_326(DATA*,threadData_t*); +void Graph_eqFunction_327(DATA*,threadData_t*); +void Graph_eqFunction_328(DATA*,threadData_t*); +void Graph_eqFunction_329(DATA*,threadData_t*); +void Graph_eqFunction_330(DATA*,threadData_t*); +void Graph_eqFunction_331(DATA*,threadData_t*); +void Graph_eqFunction_332(DATA*,threadData_t*); +void Graph_eqFunction_333(DATA*,threadData_t*); +/* + equation index: 334 + indexNonlinear: 9 + type: NONLINEAR + + vars: {T[10]} + eqns: {317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333} + */ +void Graph_eqFunction_334(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,334}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 334 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[9].nlsxOld[0] = data->localData[0]->realVars[209] /* T[10] variable */; + retValue = solve_nonlinear_system(data, threadData, 9); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,334}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 334 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[209] /* T[10] variable */ = data->simulationInfo->nonlinearSystemData[9].nlsx[0]; + TRACE_POP +} + +/* + equation index: 335 + type: SIMPLE_ASSIGN + y[10,1] = 1.0 - 0.7692307692307692 * points[10].K[2] + */ +void Graph_eqFunction_335(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,335}; + data->localData[0]->realVars[1052] /* y[10,1] variable */ = 1.0 - ((0.7692307692307692) * (data->localData[0]->realVars[734] /* points[10]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 336 + type: SIMPLE_ASSIGN + y[10,2] = 0.7692307692307692 * points[10].K[2] + */ +void Graph_eqFunction_336(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,336}; + data->localData[0]->realVars[1053] /* y[10,2] variable */ = (0.7692307692307692) * (data->localData[0]->realVars[734] /* points[10]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 337 + type: SIMPLE_ASSIGN + points[10]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[10].comp[2].LiqDen[1], points[10].comp[2].LiqDen[2], points[10].comp[2].LiqDen[3], points[10].comp[2].LiqDen[4], points[10].comp[2].LiqDen[5], points[10].comp[2].LiqDen[6]}, points[10].comp[2].Tc, T[10], 10000.0) + */ +void Graph_eqFunction_337(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,337}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[8998], (modelica_real)data->simulationInfo->realParameter[8999], (modelica_real)data->simulationInfo->realParameter[9000], (modelica_real)data->simulationInfo->realParameter[9001], (modelica_real)data->simulationInfo->realParameter[9002], (modelica_real)data->simulationInfo->realParameter[9003]); + data->localData[0]->realVars[813] /* points[10]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10983], data->localData[0]->realVars[209] /* T[10] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 338 + type: SIMPLE_ASSIGN + points[10]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[10].comp[1].LiqDen[1], points[10].comp[1].LiqDen[2], points[10].comp[1].LiqDen[3], points[10].comp[1].LiqDen[4], points[10].comp[1].LiqDen[5], points[10].comp[1].LiqDen[6]}, points[10].comp[1].Tc, T[10], 10000.0) + */ +void Graph_eqFunction_338(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,338}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[8992], (modelica_real)data->simulationInfo->realParameter[8993], (modelica_real)data->simulationInfo->realParameter[8994], (modelica_real)data->simulationInfo->realParameter[8995], (modelica_real)data->simulationInfo->realParameter[8996], (modelica_real)data->simulationInfo->realParameter[8997]); + data->localData[0]->realVars[812] /* points[10]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10982], data->localData[0]->realVars[209] /* T[10] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_339(DATA*,threadData_t*); +void Graph_eqFunction_340(DATA*,threadData_t*); +void Graph_eqFunction_341(DATA*,threadData_t*); +void Graph_eqFunction_342(DATA*,threadData_t*); +void Graph_eqFunction_343(DATA*,threadData_t*); +void Graph_eqFunction_344(DATA*,threadData_t*); +void Graph_eqFunction_345(DATA*,threadData_t*); +void Graph_eqFunction_346(DATA*,threadData_t*); +void Graph_eqFunction_347(DATA*,threadData_t*); +void Graph_eqFunction_348(DATA*,threadData_t*); +void Graph_eqFunction_349(DATA*,threadData_t*); +void Graph_eqFunction_350(DATA*,threadData_t*); +void Graph_eqFunction_351(DATA*,threadData_t*); +void Graph_eqFunction_352(DATA*,threadData_t*); +void Graph_eqFunction_353(DATA*,threadData_t*); +void Graph_eqFunction_354(DATA*,threadData_t*); +void Graph_eqFunction_355(DATA*,threadData_t*); +/* + equation index: 356 + indexNonlinear: 10 + type: NONLINEAR + + vars: {T[11]} + eqns: {339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355} + */ +void Graph_eqFunction_356(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,356}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 356 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[10].nlsxOld[0] = data->localData[0]->realVars[210] /* T[11] variable */; + retValue = solve_nonlinear_system(data, threadData, 10); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,356}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 356 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[210] /* T[11] variable */ = data->simulationInfo->nonlinearSystemData[10].nlsx[0]; + TRACE_POP +} + +/* + equation index: 357 + type: SIMPLE_ASSIGN + y[11,1] = 1.0 - 0.7435897435897436 * points[11].K[2] + */ +void Graph_eqFunction_357(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,357}; + data->localData[0]->realVars[1054] /* y[11,1] variable */ = 1.0 - ((0.7435897435897436) * (data->localData[0]->realVars[736] /* points[11]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 358 + type: SIMPLE_ASSIGN + y[11,2] = 0.7435897435897436 * points[11].K[2] + */ +void Graph_eqFunction_358(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,358}; + data->localData[0]->realVars[1055] /* y[11,2] variable */ = (0.7435897435897436) * (data->localData[0]->realVars[736] /* points[11]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 359 + type: SIMPLE_ASSIGN + points[11]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[11].comp[2].LiqDen[1], points[11].comp[2].LiqDen[2], points[11].comp[2].LiqDen[3], points[11].comp[2].LiqDen[4], points[11].comp[2].LiqDen[5], points[11].comp[2].LiqDen[6]}, points[11].comp[2].Tc, T[11], 10000.0) + */ +void Graph_eqFunction_359(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,359}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9010], (modelica_real)data->simulationInfo->realParameter[9011], (modelica_real)data->simulationInfo->realParameter[9012], (modelica_real)data->simulationInfo->realParameter[9013], (modelica_real)data->simulationInfo->realParameter[9014], (modelica_real)data->simulationInfo->realParameter[9015]); + data->localData[0]->realVars[815] /* points[11]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10985], data->localData[0]->realVars[210] /* T[11] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 360 + type: SIMPLE_ASSIGN + points[11]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[11].comp[1].LiqDen[1], points[11].comp[1].LiqDen[2], points[11].comp[1].LiqDen[3], points[11].comp[1].LiqDen[4], points[11].comp[1].LiqDen[5], points[11].comp[1].LiqDen[6]}, points[11].comp[1].Tc, T[11], 10000.0) + */ +void Graph_eqFunction_360(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,360}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9004], (modelica_real)data->simulationInfo->realParameter[9005], (modelica_real)data->simulationInfo->realParameter[9006], (modelica_real)data->simulationInfo->realParameter[9007], (modelica_real)data->simulationInfo->realParameter[9008], (modelica_real)data->simulationInfo->realParameter[9009]); + data->localData[0]->realVars[814] /* points[11]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10984], data->localData[0]->realVars[210] /* T[11] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_361(DATA*,threadData_t*); +void Graph_eqFunction_362(DATA*,threadData_t*); +void Graph_eqFunction_363(DATA*,threadData_t*); +void Graph_eqFunction_364(DATA*,threadData_t*); +void Graph_eqFunction_365(DATA*,threadData_t*); +void Graph_eqFunction_366(DATA*,threadData_t*); +void Graph_eqFunction_367(DATA*,threadData_t*); +void Graph_eqFunction_368(DATA*,threadData_t*); +void Graph_eqFunction_369(DATA*,threadData_t*); +void Graph_eqFunction_370(DATA*,threadData_t*); +void Graph_eqFunction_371(DATA*,threadData_t*); +void Graph_eqFunction_372(DATA*,threadData_t*); +void Graph_eqFunction_373(DATA*,threadData_t*); +void Graph_eqFunction_374(DATA*,threadData_t*); +void Graph_eqFunction_375(DATA*,threadData_t*); +void Graph_eqFunction_376(DATA*,threadData_t*); +void Graph_eqFunction_377(DATA*,threadData_t*); +/* + equation index: 378 + indexNonlinear: 11 + type: NONLINEAR + + vars: {T[12]} + eqns: {361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377} + */ +void Graph_eqFunction_378(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,378}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 378 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[11].nlsxOld[0] = data->localData[0]->realVars[211] /* T[12] variable */; + retValue = solve_nonlinear_system(data, threadData, 11); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,378}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 378 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[211] /* T[12] variable */ = data->simulationInfo->nonlinearSystemData[11].nlsx[0]; + TRACE_POP +} + +/* + equation index: 379 + type: SIMPLE_ASSIGN + y[12,1] = 1.0 - 0.717948717948718 * points[12].K[2] + */ +void Graph_eqFunction_379(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,379}; + data->localData[0]->realVars[1056] /* y[12,1] variable */ = 1.0 - ((0.717948717948718) * (data->localData[0]->realVars[738] /* points[12]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 380 + type: SIMPLE_ASSIGN + y[12,2] = 0.717948717948718 * points[12].K[2] + */ +void Graph_eqFunction_380(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,380}; + data->localData[0]->realVars[1057] /* y[12,2] variable */ = (0.717948717948718) * (data->localData[0]->realVars[738] /* points[12]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 381 + type: SIMPLE_ASSIGN + points[12]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[12].comp[2].LiqDen[1], points[12].comp[2].LiqDen[2], points[12].comp[2].LiqDen[3], points[12].comp[2].LiqDen[4], points[12].comp[2].LiqDen[5], points[12].comp[2].LiqDen[6]}, points[12].comp[2].Tc, T[12], 10000.0) + */ +void Graph_eqFunction_381(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,381}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9022], (modelica_real)data->simulationInfo->realParameter[9023], (modelica_real)data->simulationInfo->realParameter[9024], (modelica_real)data->simulationInfo->realParameter[9025], (modelica_real)data->simulationInfo->realParameter[9026], (modelica_real)data->simulationInfo->realParameter[9027]); + data->localData[0]->realVars[817] /* points[12]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10987], data->localData[0]->realVars[211] /* T[12] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 382 + type: SIMPLE_ASSIGN + points[12]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[12].comp[1].LiqDen[1], points[12].comp[1].LiqDen[2], points[12].comp[1].LiqDen[3], points[12].comp[1].LiqDen[4], points[12].comp[1].LiqDen[5], points[12].comp[1].LiqDen[6]}, points[12].comp[1].Tc, T[12], 10000.0) + */ +void Graph_eqFunction_382(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,382}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9016], (modelica_real)data->simulationInfo->realParameter[9017], (modelica_real)data->simulationInfo->realParameter[9018], (modelica_real)data->simulationInfo->realParameter[9019], (modelica_real)data->simulationInfo->realParameter[9020], (modelica_real)data->simulationInfo->realParameter[9021]); + data->localData[0]->realVars[816] /* points[12]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10986], data->localData[0]->realVars[211] /* T[12] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_383(DATA*,threadData_t*); +void Graph_eqFunction_384(DATA*,threadData_t*); +void Graph_eqFunction_385(DATA*,threadData_t*); +void Graph_eqFunction_386(DATA*,threadData_t*); +void Graph_eqFunction_387(DATA*,threadData_t*); +void Graph_eqFunction_388(DATA*,threadData_t*); +void Graph_eqFunction_389(DATA*,threadData_t*); +void Graph_eqFunction_390(DATA*,threadData_t*); +void Graph_eqFunction_391(DATA*,threadData_t*); +void Graph_eqFunction_392(DATA*,threadData_t*); +void Graph_eqFunction_393(DATA*,threadData_t*); +void Graph_eqFunction_394(DATA*,threadData_t*); +void Graph_eqFunction_395(DATA*,threadData_t*); +void Graph_eqFunction_396(DATA*,threadData_t*); +void Graph_eqFunction_397(DATA*,threadData_t*); +void Graph_eqFunction_398(DATA*,threadData_t*); +void Graph_eqFunction_399(DATA*,threadData_t*); +/* + equation index: 400 + indexNonlinear: 12 + type: NONLINEAR + + vars: {T[13]} + eqns: {383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399} + */ +void Graph_eqFunction_400(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,400}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 400 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[12].nlsxOld[0] = data->localData[0]->realVars[212] /* T[13] variable */; + retValue = solve_nonlinear_system(data, threadData, 12); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,400}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 400 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[212] /* T[13] variable */ = data->simulationInfo->nonlinearSystemData[12].nlsx[0]; + TRACE_POP +} + +/* + equation index: 401 + type: SIMPLE_ASSIGN + y[13,1] = 1.0 - 0.6923076923076923 * points[13].K[2] + */ +void Graph_eqFunction_401(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,401}; + data->localData[0]->realVars[1058] /* y[13,1] variable */ = 1.0 - ((0.6923076923076923) * (data->localData[0]->realVars[740] /* points[13]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 402 + type: SIMPLE_ASSIGN + y[13,2] = 0.6923076923076923 * points[13].K[2] + */ +void Graph_eqFunction_402(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,402}; + data->localData[0]->realVars[1059] /* y[13,2] variable */ = (0.6923076923076923) * (data->localData[0]->realVars[740] /* points[13]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 403 + type: SIMPLE_ASSIGN + points[13]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[13].comp[2].LiqDen[1], points[13].comp[2].LiqDen[2], points[13].comp[2].LiqDen[3], points[13].comp[2].LiqDen[4], points[13].comp[2].LiqDen[5], points[13].comp[2].LiqDen[6]}, points[13].comp[2].Tc, T[13], 10000.0) + */ +void Graph_eqFunction_403(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,403}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9034], (modelica_real)data->simulationInfo->realParameter[9035], (modelica_real)data->simulationInfo->realParameter[9036], (modelica_real)data->simulationInfo->realParameter[9037], (modelica_real)data->simulationInfo->realParameter[9038], (modelica_real)data->simulationInfo->realParameter[9039]); + data->localData[0]->realVars[819] /* points[13]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10989], data->localData[0]->realVars[212] /* T[13] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 404 + type: SIMPLE_ASSIGN + points[13]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[13].comp[1].LiqDen[1], points[13].comp[1].LiqDen[2], points[13].comp[1].LiqDen[3], points[13].comp[1].LiqDen[4], points[13].comp[1].LiqDen[5], points[13].comp[1].LiqDen[6]}, points[13].comp[1].Tc, T[13], 10000.0) + */ +void Graph_eqFunction_404(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,404}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9028], (modelica_real)data->simulationInfo->realParameter[9029], (modelica_real)data->simulationInfo->realParameter[9030], (modelica_real)data->simulationInfo->realParameter[9031], (modelica_real)data->simulationInfo->realParameter[9032], (modelica_real)data->simulationInfo->realParameter[9033]); + data->localData[0]->realVars[818] /* points[13]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10988], data->localData[0]->realVars[212] /* T[13] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_405(DATA*,threadData_t*); +void Graph_eqFunction_406(DATA*,threadData_t*); +void Graph_eqFunction_407(DATA*,threadData_t*); +void Graph_eqFunction_408(DATA*,threadData_t*); +void Graph_eqFunction_409(DATA*,threadData_t*); +void Graph_eqFunction_410(DATA*,threadData_t*); +void Graph_eqFunction_411(DATA*,threadData_t*); +void Graph_eqFunction_412(DATA*,threadData_t*); +void Graph_eqFunction_413(DATA*,threadData_t*); +void Graph_eqFunction_414(DATA*,threadData_t*); +void Graph_eqFunction_415(DATA*,threadData_t*); +void Graph_eqFunction_416(DATA*,threadData_t*); +void Graph_eqFunction_417(DATA*,threadData_t*); +void Graph_eqFunction_418(DATA*,threadData_t*); +void Graph_eqFunction_419(DATA*,threadData_t*); +void Graph_eqFunction_420(DATA*,threadData_t*); +void Graph_eqFunction_421(DATA*,threadData_t*); +/* + equation index: 422 + indexNonlinear: 13 + type: NONLINEAR + + vars: {T[14]} + eqns: {405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421} + */ +void Graph_eqFunction_422(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,422}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 422 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[13].nlsxOld[0] = data->localData[0]->realVars[213] /* T[14] variable */; + retValue = solve_nonlinear_system(data, threadData, 13); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,422}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 422 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[213] /* T[14] variable */ = data->simulationInfo->nonlinearSystemData[13].nlsx[0]; + TRACE_POP +} + +/* + equation index: 423 + type: SIMPLE_ASSIGN + y[14,1] = 1.0 - 0.6666666666666667 * points[14].K[2] + */ +void Graph_eqFunction_423(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,423}; + data->localData[0]->realVars[1060] /* y[14,1] variable */ = 1.0 - ((0.6666666666666667) * (data->localData[0]->realVars[742] /* points[14]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 424 + type: SIMPLE_ASSIGN + y[14,2] = 0.6666666666666667 * points[14].K[2] + */ +void Graph_eqFunction_424(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,424}; + data->localData[0]->realVars[1061] /* y[14,2] variable */ = (0.6666666666666667) * (data->localData[0]->realVars[742] /* points[14]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 425 + type: SIMPLE_ASSIGN + points[14]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[14].comp[2].LiqDen[1], points[14].comp[2].LiqDen[2], points[14].comp[2].LiqDen[3], points[14].comp[2].LiqDen[4], points[14].comp[2].LiqDen[5], points[14].comp[2].LiqDen[6]}, points[14].comp[2].Tc, T[14], 10000.0) + */ +void Graph_eqFunction_425(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,425}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9046], (modelica_real)data->simulationInfo->realParameter[9047], (modelica_real)data->simulationInfo->realParameter[9048], (modelica_real)data->simulationInfo->realParameter[9049], (modelica_real)data->simulationInfo->realParameter[9050], (modelica_real)data->simulationInfo->realParameter[9051]); + data->localData[0]->realVars[821] /* points[14]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10991], data->localData[0]->realVars[213] /* T[14] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 426 + type: SIMPLE_ASSIGN + points[14]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[14].comp[1].LiqDen[1], points[14].comp[1].LiqDen[2], points[14].comp[1].LiqDen[3], points[14].comp[1].LiqDen[4], points[14].comp[1].LiqDen[5], points[14].comp[1].LiqDen[6]}, points[14].comp[1].Tc, T[14], 10000.0) + */ +void Graph_eqFunction_426(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,426}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9040], (modelica_real)data->simulationInfo->realParameter[9041], (modelica_real)data->simulationInfo->realParameter[9042], (modelica_real)data->simulationInfo->realParameter[9043], (modelica_real)data->simulationInfo->realParameter[9044], (modelica_real)data->simulationInfo->realParameter[9045]); + data->localData[0]->realVars[820] /* points[14]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10990], data->localData[0]->realVars[213] /* T[14] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_427(DATA*,threadData_t*); +void Graph_eqFunction_428(DATA*,threadData_t*); +void Graph_eqFunction_429(DATA*,threadData_t*); +void Graph_eqFunction_430(DATA*,threadData_t*); +void Graph_eqFunction_431(DATA*,threadData_t*); +void Graph_eqFunction_432(DATA*,threadData_t*); +void Graph_eqFunction_433(DATA*,threadData_t*); +void Graph_eqFunction_434(DATA*,threadData_t*); +void Graph_eqFunction_435(DATA*,threadData_t*); +void Graph_eqFunction_436(DATA*,threadData_t*); +void Graph_eqFunction_437(DATA*,threadData_t*); +void Graph_eqFunction_438(DATA*,threadData_t*); +void Graph_eqFunction_439(DATA*,threadData_t*); +void Graph_eqFunction_440(DATA*,threadData_t*); +void Graph_eqFunction_441(DATA*,threadData_t*); +void Graph_eqFunction_442(DATA*,threadData_t*); +void Graph_eqFunction_443(DATA*,threadData_t*); +/* + equation index: 444 + indexNonlinear: 14 + type: NONLINEAR + + vars: {T[15]} + eqns: {427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443} + */ +void Graph_eqFunction_444(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,444}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 444 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[14].nlsxOld[0] = data->localData[0]->realVars[214] /* T[15] variable */; + retValue = solve_nonlinear_system(data, threadData, 14); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,444}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 444 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[214] /* T[15] variable */ = data->simulationInfo->nonlinearSystemData[14].nlsx[0]; + TRACE_POP +} + +/* + equation index: 445 + type: SIMPLE_ASSIGN + y[15,1] = 1.0 - 0.641025641025641 * points[15].K[2] + */ +void Graph_eqFunction_445(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,445}; + data->localData[0]->realVars[1062] /* y[15,1] variable */ = 1.0 - ((0.641025641025641) * (data->localData[0]->realVars[744] /* points[15]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 446 + type: SIMPLE_ASSIGN + y[15,2] = 0.641025641025641 * points[15].K[2] + */ +void Graph_eqFunction_446(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,446}; + data->localData[0]->realVars[1063] /* y[15,2] variable */ = (0.641025641025641) * (data->localData[0]->realVars[744] /* points[15]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 447 + type: SIMPLE_ASSIGN + points[15]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[15].comp[2].LiqDen[1], points[15].comp[2].LiqDen[2], points[15].comp[2].LiqDen[3], points[15].comp[2].LiqDen[4], points[15].comp[2].LiqDen[5], points[15].comp[2].LiqDen[6]}, points[15].comp[2].Tc, T[15], 10000.0) + */ +void Graph_eqFunction_447(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,447}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9058], (modelica_real)data->simulationInfo->realParameter[9059], (modelica_real)data->simulationInfo->realParameter[9060], (modelica_real)data->simulationInfo->realParameter[9061], (modelica_real)data->simulationInfo->realParameter[9062], (modelica_real)data->simulationInfo->realParameter[9063]); + data->localData[0]->realVars[823] /* points[15]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10993], data->localData[0]->realVars[214] /* T[15] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 448 + type: SIMPLE_ASSIGN + points[15]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[15].comp[1].LiqDen[1], points[15].comp[1].LiqDen[2], points[15].comp[1].LiqDen[3], points[15].comp[1].LiqDen[4], points[15].comp[1].LiqDen[5], points[15].comp[1].LiqDen[6]}, points[15].comp[1].Tc, T[15], 10000.0) + */ +void Graph_eqFunction_448(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,448}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9052], (modelica_real)data->simulationInfo->realParameter[9053], (modelica_real)data->simulationInfo->realParameter[9054], (modelica_real)data->simulationInfo->realParameter[9055], (modelica_real)data->simulationInfo->realParameter[9056], (modelica_real)data->simulationInfo->realParameter[9057]); + data->localData[0]->realVars[822] /* points[15]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10992], data->localData[0]->realVars[214] /* T[15] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_449(DATA*,threadData_t*); +void Graph_eqFunction_450(DATA*,threadData_t*); +void Graph_eqFunction_451(DATA*,threadData_t*); +void Graph_eqFunction_452(DATA*,threadData_t*); +void Graph_eqFunction_453(DATA*,threadData_t*); +void Graph_eqFunction_454(DATA*,threadData_t*); +void Graph_eqFunction_455(DATA*,threadData_t*); +void Graph_eqFunction_456(DATA*,threadData_t*); +void Graph_eqFunction_457(DATA*,threadData_t*); +void Graph_eqFunction_458(DATA*,threadData_t*); +void Graph_eqFunction_459(DATA*,threadData_t*); +void Graph_eqFunction_460(DATA*,threadData_t*); +void Graph_eqFunction_461(DATA*,threadData_t*); +void Graph_eqFunction_462(DATA*,threadData_t*); +void Graph_eqFunction_463(DATA*,threadData_t*); +void Graph_eqFunction_464(DATA*,threadData_t*); +void Graph_eqFunction_465(DATA*,threadData_t*); +/* + equation index: 466 + indexNonlinear: 15 + type: NONLINEAR + + vars: {T[16]} + eqns: {449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465} + */ +void Graph_eqFunction_466(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,466}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 466 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[15].nlsxOld[0] = data->localData[0]->realVars[215] /* T[16] variable */; + retValue = solve_nonlinear_system(data, threadData, 15); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,466}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 466 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[215] /* T[16] variable */ = data->simulationInfo->nonlinearSystemData[15].nlsx[0]; + TRACE_POP +} + +/* + equation index: 467 + type: SIMPLE_ASSIGN + y[16,1] = 1.0 - 0.6153846153846154 * points[16].K[2] + */ +void Graph_eqFunction_467(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,467}; + data->localData[0]->realVars[1064] /* y[16,1] variable */ = 1.0 - ((0.6153846153846154) * (data->localData[0]->realVars[746] /* points[16]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 468 + type: SIMPLE_ASSIGN + y[16,2] = 0.6153846153846154 * points[16].K[2] + */ +void Graph_eqFunction_468(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,468}; + data->localData[0]->realVars[1065] /* y[16,2] variable */ = (0.6153846153846154) * (data->localData[0]->realVars[746] /* points[16]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 469 + type: SIMPLE_ASSIGN + points[16]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[16].comp[2].LiqDen[1], points[16].comp[2].LiqDen[2], points[16].comp[2].LiqDen[3], points[16].comp[2].LiqDen[4], points[16].comp[2].LiqDen[5], points[16].comp[2].LiqDen[6]}, points[16].comp[2].Tc, T[16], 10000.0) + */ +void Graph_eqFunction_469(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,469}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9070], (modelica_real)data->simulationInfo->realParameter[9071], (modelica_real)data->simulationInfo->realParameter[9072], (modelica_real)data->simulationInfo->realParameter[9073], (modelica_real)data->simulationInfo->realParameter[9074], (modelica_real)data->simulationInfo->realParameter[9075]); + data->localData[0]->realVars[825] /* points[16]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10995], data->localData[0]->realVars[215] /* T[16] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 470 + type: SIMPLE_ASSIGN + points[16]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[16].comp[1].LiqDen[1], points[16].comp[1].LiqDen[2], points[16].comp[1].LiqDen[3], points[16].comp[1].LiqDen[4], points[16].comp[1].LiqDen[5], points[16].comp[1].LiqDen[6]}, points[16].comp[1].Tc, T[16], 10000.0) + */ +void Graph_eqFunction_470(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,470}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9064], (modelica_real)data->simulationInfo->realParameter[9065], (modelica_real)data->simulationInfo->realParameter[9066], (modelica_real)data->simulationInfo->realParameter[9067], (modelica_real)data->simulationInfo->realParameter[9068], (modelica_real)data->simulationInfo->realParameter[9069]); + data->localData[0]->realVars[824] /* points[16]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10994], data->localData[0]->realVars[215] /* T[16] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_471(DATA*,threadData_t*); +void Graph_eqFunction_472(DATA*,threadData_t*); +void Graph_eqFunction_473(DATA*,threadData_t*); +void Graph_eqFunction_474(DATA*,threadData_t*); +void Graph_eqFunction_475(DATA*,threadData_t*); +void Graph_eqFunction_476(DATA*,threadData_t*); +void Graph_eqFunction_477(DATA*,threadData_t*); +void Graph_eqFunction_478(DATA*,threadData_t*); +void Graph_eqFunction_479(DATA*,threadData_t*); +void Graph_eqFunction_480(DATA*,threadData_t*); +void Graph_eqFunction_481(DATA*,threadData_t*); +void Graph_eqFunction_482(DATA*,threadData_t*); +void Graph_eqFunction_483(DATA*,threadData_t*); +void Graph_eqFunction_484(DATA*,threadData_t*); +void Graph_eqFunction_485(DATA*,threadData_t*); +void Graph_eqFunction_486(DATA*,threadData_t*); +void Graph_eqFunction_487(DATA*,threadData_t*); +/* + equation index: 488 + indexNonlinear: 16 + type: NONLINEAR + + vars: {T[17]} + eqns: {471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487} + */ +void Graph_eqFunction_488(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,488}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 488 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[16].nlsxOld[0] = data->localData[0]->realVars[216] /* T[17] variable */; + retValue = solve_nonlinear_system(data, threadData, 16); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,488}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 488 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[216] /* T[17] variable */ = data->simulationInfo->nonlinearSystemData[16].nlsx[0]; + TRACE_POP +} + +/* + equation index: 489 + type: SIMPLE_ASSIGN + y[17,1] = 1.0 - 0.5897435897435898 * points[17].K[2] + */ +void Graph_eqFunction_489(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,489}; + data->localData[0]->realVars[1066] /* y[17,1] variable */ = 1.0 - ((0.5897435897435898) * (data->localData[0]->realVars[748] /* points[17]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 490 + type: SIMPLE_ASSIGN + y[17,2] = 0.5897435897435898 * points[17].K[2] + */ +void Graph_eqFunction_490(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,490}; + data->localData[0]->realVars[1067] /* y[17,2] variable */ = (0.5897435897435898) * (data->localData[0]->realVars[748] /* points[17]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 491 + type: SIMPLE_ASSIGN + points[17]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[17].comp[2].LiqDen[1], points[17].comp[2].LiqDen[2], points[17].comp[2].LiqDen[3], points[17].comp[2].LiqDen[4], points[17].comp[2].LiqDen[5], points[17].comp[2].LiqDen[6]}, points[17].comp[2].Tc, T[17], 10000.0) + */ +void Graph_eqFunction_491(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,491}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9082], (modelica_real)data->simulationInfo->realParameter[9083], (modelica_real)data->simulationInfo->realParameter[9084], (modelica_real)data->simulationInfo->realParameter[9085], (modelica_real)data->simulationInfo->realParameter[9086], (modelica_real)data->simulationInfo->realParameter[9087]); + data->localData[0]->realVars[827] /* points[17]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10997], data->localData[0]->realVars[216] /* T[17] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 492 + type: SIMPLE_ASSIGN + points[17]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[17].comp[1].LiqDen[1], points[17].comp[1].LiqDen[2], points[17].comp[1].LiqDen[3], points[17].comp[1].LiqDen[4], points[17].comp[1].LiqDen[5], points[17].comp[1].LiqDen[6]}, points[17].comp[1].Tc, T[17], 10000.0) + */ +void Graph_eqFunction_492(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,492}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9076], (modelica_real)data->simulationInfo->realParameter[9077], (modelica_real)data->simulationInfo->realParameter[9078], (modelica_real)data->simulationInfo->realParameter[9079], (modelica_real)data->simulationInfo->realParameter[9080], (modelica_real)data->simulationInfo->realParameter[9081]); + data->localData[0]->realVars[826] /* points[17]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10996], data->localData[0]->realVars[216] /* T[17] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_493(DATA*,threadData_t*); +void Graph_eqFunction_494(DATA*,threadData_t*); +void Graph_eqFunction_495(DATA*,threadData_t*); +void Graph_eqFunction_496(DATA*,threadData_t*); +void Graph_eqFunction_497(DATA*,threadData_t*); +void Graph_eqFunction_498(DATA*,threadData_t*); +void Graph_eqFunction_499(DATA*,threadData_t*); +void Graph_eqFunction_500(DATA*,threadData_t*); +void Graph_eqFunction_501(DATA*,threadData_t*); +void Graph_eqFunction_502(DATA*,threadData_t*); +void Graph_eqFunction_503(DATA*,threadData_t*); +void Graph_eqFunction_504(DATA*,threadData_t*); +void Graph_eqFunction_505(DATA*,threadData_t*); +void Graph_eqFunction_506(DATA*,threadData_t*); +void Graph_eqFunction_507(DATA*,threadData_t*); +void Graph_eqFunction_508(DATA*,threadData_t*); +void Graph_eqFunction_509(DATA*,threadData_t*); +/* + equation index: 510 + indexNonlinear: 17 + type: NONLINEAR + + vars: {T[18]} + eqns: {493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509} + */ +void Graph_eqFunction_510(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,510}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 510 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[17].nlsxOld[0] = data->localData[0]->realVars[217] /* T[18] variable */; + retValue = solve_nonlinear_system(data, threadData, 17); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,510}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 510 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[217] /* T[18] variable */ = data->simulationInfo->nonlinearSystemData[17].nlsx[0]; + TRACE_POP +} + +/* + equation index: 511 + type: SIMPLE_ASSIGN + y[18,1] = 1.0 - 0.5641025641025641 * points[18].K[2] + */ +void Graph_eqFunction_511(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,511}; + data->localData[0]->realVars[1068] /* y[18,1] variable */ = 1.0 - ((0.5641025641025641) * (data->localData[0]->realVars[750] /* points[18]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 512 + type: SIMPLE_ASSIGN + y[18,2] = 0.5641025641025641 * points[18].K[2] + */ +void Graph_eqFunction_512(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,512}; + data->localData[0]->realVars[1069] /* y[18,2] variable */ = (0.5641025641025641) * (data->localData[0]->realVars[750] /* points[18]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 513 + type: SIMPLE_ASSIGN + points[18]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[18].comp[2].LiqDen[1], points[18].comp[2].LiqDen[2], points[18].comp[2].LiqDen[3], points[18].comp[2].LiqDen[4], points[18].comp[2].LiqDen[5], points[18].comp[2].LiqDen[6]}, points[18].comp[2].Tc, T[18], 10000.0) + */ +void Graph_eqFunction_513(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,513}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9094], (modelica_real)data->simulationInfo->realParameter[9095], (modelica_real)data->simulationInfo->realParameter[9096], (modelica_real)data->simulationInfo->realParameter[9097], (modelica_real)data->simulationInfo->realParameter[9098], (modelica_real)data->simulationInfo->realParameter[9099]); + data->localData[0]->realVars[829] /* points[18]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[10999], data->localData[0]->realVars[217] /* T[18] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 514 + type: SIMPLE_ASSIGN + points[18]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[18].comp[1].LiqDen[1], points[18].comp[1].LiqDen[2], points[18].comp[1].LiqDen[3], points[18].comp[1].LiqDen[4], points[18].comp[1].LiqDen[5], points[18].comp[1].LiqDen[6]}, points[18].comp[1].Tc, T[18], 10000.0) + */ +void Graph_eqFunction_514(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,514}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9088], (modelica_real)data->simulationInfo->realParameter[9089], (modelica_real)data->simulationInfo->realParameter[9090], (modelica_real)data->simulationInfo->realParameter[9091], (modelica_real)data->simulationInfo->realParameter[9092], (modelica_real)data->simulationInfo->realParameter[9093]); + data->localData[0]->realVars[828] /* points[18]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[10998], data->localData[0]->realVars[217] /* T[18] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_515(DATA*,threadData_t*); +void Graph_eqFunction_516(DATA*,threadData_t*); +void Graph_eqFunction_517(DATA*,threadData_t*); +void Graph_eqFunction_518(DATA*,threadData_t*); +void Graph_eqFunction_519(DATA*,threadData_t*); +void Graph_eqFunction_520(DATA*,threadData_t*); +void Graph_eqFunction_521(DATA*,threadData_t*); +void Graph_eqFunction_522(DATA*,threadData_t*); +void Graph_eqFunction_523(DATA*,threadData_t*); +void Graph_eqFunction_524(DATA*,threadData_t*); +void Graph_eqFunction_525(DATA*,threadData_t*); +void Graph_eqFunction_526(DATA*,threadData_t*); +void Graph_eqFunction_527(DATA*,threadData_t*); +void Graph_eqFunction_528(DATA*,threadData_t*); +void Graph_eqFunction_529(DATA*,threadData_t*); +void Graph_eqFunction_530(DATA*,threadData_t*); +void Graph_eqFunction_531(DATA*,threadData_t*); +/* + equation index: 532 + indexNonlinear: 18 + type: NONLINEAR + + vars: {T[19]} + eqns: {515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531} + */ +void Graph_eqFunction_532(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,532}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 532 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[18].nlsxOld[0] = data->localData[0]->realVars[218] /* T[19] variable */; + retValue = solve_nonlinear_system(data, threadData, 18); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,532}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 532 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[218] /* T[19] variable */ = data->simulationInfo->nonlinearSystemData[18].nlsx[0]; + TRACE_POP +} + +/* + equation index: 533 + type: SIMPLE_ASSIGN + y[19,1] = 1.0 - 0.5384615384615384 * points[19].K[2] + */ +void Graph_eqFunction_533(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,533}; + data->localData[0]->realVars[1070] /* y[19,1] variable */ = 1.0 - ((0.5384615384615384) * (data->localData[0]->realVars[752] /* points[19]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 534 + type: SIMPLE_ASSIGN + y[19,2] = 0.5384615384615384 * points[19].K[2] + */ +void Graph_eqFunction_534(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,534}; + data->localData[0]->realVars[1071] /* y[19,2] variable */ = (0.5384615384615384) * (data->localData[0]->realVars[752] /* points[19]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 535 + type: SIMPLE_ASSIGN + points[19]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[19].comp[2].LiqDen[1], points[19].comp[2].LiqDen[2], points[19].comp[2].LiqDen[3], points[19].comp[2].LiqDen[4], points[19].comp[2].LiqDen[5], points[19].comp[2].LiqDen[6]}, points[19].comp[2].Tc, T[19], 10000.0) + */ +void Graph_eqFunction_535(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,535}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9106], (modelica_real)data->simulationInfo->realParameter[9107], (modelica_real)data->simulationInfo->realParameter[9108], (modelica_real)data->simulationInfo->realParameter[9109], (modelica_real)data->simulationInfo->realParameter[9110], (modelica_real)data->simulationInfo->realParameter[9111]); + data->localData[0]->realVars[831] /* points[19]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11001], data->localData[0]->realVars[218] /* T[19] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 536 + type: SIMPLE_ASSIGN + points[19]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[19].comp[1].LiqDen[1], points[19].comp[1].LiqDen[2], points[19].comp[1].LiqDen[3], points[19].comp[1].LiqDen[4], points[19].comp[1].LiqDen[5], points[19].comp[1].LiqDen[6]}, points[19].comp[1].Tc, T[19], 10000.0) + */ +void Graph_eqFunction_536(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,536}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9100], (modelica_real)data->simulationInfo->realParameter[9101], (modelica_real)data->simulationInfo->realParameter[9102], (modelica_real)data->simulationInfo->realParameter[9103], (modelica_real)data->simulationInfo->realParameter[9104], (modelica_real)data->simulationInfo->realParameter[9105]); + data->localData[0]->realVars[830] /* points[19]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11000], data->localData[0]->realVars[218] /* T[19] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_537(DATA*,threadData_t*); +void Graph_eqFunction_538(DATA*,threadData_t*); +void Graph_eqFunction_539(DATA*,threadData_t*); +void Graph_eqFunction_540(DATA*,threadData_t*); +void Graph_eqFunction_541(DATA*,threadData_t*); +void Graph_eqFunction_542(DATA*,threadData_t*); +void Graph_eqFunction_543(DATA*,threadData_t*); +void Graph_eqFunction_544(DATA*,threadData_t*); +void Graph_eqFunction_545(DATA*,threadData_t*); +void Graph_eqFunction_546(DATA*,threadData_t*); +void Graph_eqFunction_547(DATA*,threadData_t*); +void Graph_eqFunction_548(DATA*,threadData_t*); +void Graph_eqFunction_549(DATA*,threadData_t*); +void Graph_eqFunction_550(DATA*,threadData_t*); +void Graph_eqFunction_551(DATA*,threadData_t*); +void Graph_eqFunction_552(DATA*,threadData_t*); +void Graph_eqFunction_553(DATA*,threadData_t*); +/* + equation index: 554 + indexNonlinear: 19 + type: NONLINEAR + + vars: {T[20]} + eqns: {537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553} + */ +void Graph_eqFunction_554(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,554}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 554 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[19].nlsxOld[0] = data->localData[0]->realVars[219] /* T[20] variable */; + retValue = solve_nonlinear_system(data, threadData, 19); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,554}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 554 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[219] /* T[20] variable */ = data->simulationInfo->nonlinearSystemData[19].nlsx[0]; + TRACE_POP +} + +/* + equation index: 555 + type: SIMPLE_ASSIGN + y[20,1] = 1.0 - 0.5128205128205128 * points[20].K[2] + */ +void Graph_eqFunction_555(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,555}; + data->localData[0]->realVars[1072] /* y[20,1] variable */ = 1.0 - ((0.5128205128205128) * (data->localData[0]->realVars[754] /* points[20]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 556 + type: SIMPLE_ASSIGN + y[20,2] = 0.5128205128205128 * points[20].K[2] + */ +void Graph_eqFunction_556(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,556}; + data->localData[0]->realVars[1073] /* y[20,2] variable */ = (0.5128205128205128) * (data->localData[0]->realVars[754] /* points[20]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 557 + type: SIMPLE_ASSIGN + points[20]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[20].comp[2].LiqDen[1], points[20].comp[2].LiqDen[2], points[20].comp[2].LiqDen[3], points[20].comp[2].LiqDen[4], points[20].comp[2].LiqDen[5], points[20].comp[2].LiqDen[6]}, points[20].comp[2].Tc, T[20], 10000.0) + */ +void Graph_eqFunction_557(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,557}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9118], (modelica_real)data->simulationInfo->realParameter[9119], (modelica_real)data->simulationInfo->realParameter[9120], (modelica_real)data->simulationInfo->realParameter[9121], (modelica_real)data->simulationInfo->realParameter[9122], (modelica_real)data->simulationInfo->realParameter[9123]); + data->localData[0]->realVars[833] /* points[20]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11003], data->localData[0]->realVars[219] /* T[20] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 558 + type: SIMPLE_ASSIGN + points[20]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[20].comp[1].LiqDen[1], points[20].comp[1].LiqDen[2], points[20].comp[1].LiqDen[3], points[20].comp[1].LiqDen[4], points[20].comp[1].LiqDen[5], points[20].comp[1].LiqDen[6]}, points[20].comp[1].Tc, T[20], 10000.0) + */ +void Graph_eqFunction_558(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,558}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9112], (modelica_real)data->simulationInfo->realParameter[9113], (modelica_real)data->simulationInfo->realParameter[9114], (modelica_real)data->simulationInfo->realParameter[9115], (modelica_real)data->simulationInfo->realParameter[9116], (modelica_real)data->simulationInfo->realParameter[9117]); + data->localData[0]->realVars[832] /* points[20]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11002], data->localData[0]->realVars[219] /* T[20] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_559(DATA*,threadData_t*); +void Graph_eqFunction_560(DATA*,threadData_t*); +void Graph_eqFunction_561(DATA*,threadData_t*); +void Graph_eqFunction_562(DATA*,threadData_t*); +void Graph_eqFunction_563(DATA*,threadData_t*); +void Graph_eqFunction_564(DATA*,threadData_t*); +void Graph_eqFunction_565(DATA*,threadData_t*); +void Graph_eqFunction_566(DATA*,threadData_t*); +void Graph_eqFunction_567(DATA*,threadData_t*); +void Graph_eqFunction_568(DATA*,threadData_t*); +void Graph_eqFunction_569(DATA*,threadData_t*); +void Graph_eqFunction_570(DATA*,threadData_t*); +void Graph_eqFunction_571(DATA*,threadData_t*); +void Graph_eqFunction_572(DATA*,threadData_t*); +void Graph_eqFunction_573(DATA*,threadData_t*); +void Graph_eqFunction_574(DATA*,threadData_t*); +void Graph_eqFunction_575(DATA*,threadData_t*); +/* + equation index: 576 + indexNonlinear: 20 + type: NONLINEAR + + vars: {T[21]} + eqns: {559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575} + */ +void Graph_eqFunction_576(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,576}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 576 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[20].nlsxOld[0] = data->localData[0]->realVars[220] /* T[21] variable */; + retValue = solve_nonlinear_system(data, threadData, 20); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,576}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 576 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[220] /* T[21] variable */ = data->simulationInfo->nonlinearSystemData[20].nlsx[0]; + TRACE_POP +} + +/* + equation index: 577 + type: SIMPLE_ASSIGN + y[21,1] = 1.0 - 0.4871794871794872 * points[21].K[2] + */ +void Graph_eqFunction_577(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,577}; + data->localData[0]->realVars[1074] /* y[21,1] variable */ = 1.0 - ((0.4871794871794872) * (data->localData[0]->realVars[756] /* points[21]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 578 + type: SIMPLE_ASSIGN + y[21,2] = 0.4871794871794872 * points[21].K[2] + */ +void Graph_eqFunction_578(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,578}; + data->localData[0]->realVars[1075] /* y[21,2] variable */ = (0.4871794871794872) * (data->localData[0]->realVars[756] /* points[21]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 579 + type: SIMPLE_ASSIGN + points[21]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[21].comp[2].LiqDen[1], points[21].comp[2].LiqDen[2], points[21].comp[2].LiqDen[3], points[21].comp[2].LiqDen[4], points[21].comp[2].LiqDen[5], points[21].comp[2].LiqDen[6]}, points[21].comp[2].Tc, T[21], 10000.0) + */ +void Graph_eqFunction_579(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,579}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9130], (modelica_real)data->simulationInfo->realParameter[9131], (modelica_real)data->simulationInfo->realParameter[9132], (modelica_real)data->simulationInfo->realParameter[9133], (modelica_real)data->simulationInfo->realParameter[9134], (modelica_real)data->simulationInfo->realParameter[9135]); + data->localData[0]->realVars[835] /* points[21]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11005], data->localData[0]->realVars[220] /* T[21] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 580 + type: SIMPLE_ASSIGN + points[21]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[21].comp[1].LiqDen[1], points[21].comp[1].LiqDen[2], points[21].comp[1].LiqDen[3], points[21].comp[1].LiqDen[4], points[21].comp[1].LiqDen[5], points[21].comp[1].LiqDen[6]}, points[21].comp[1].Tc, T[21], 10000.0) + */ +void Graph_eqFunction_580(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,580}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9124], (modelica_real)data->simulationInfo->realParameter[9125], (modelica_real)data->simulationInfo->realParameter[9126], (modelica_real)data->simulationInfo->realParameter[9127], (modelica_real)data->simulationInfo->realParameter[9128], (modelica_real)data->simulationInfo->realParameter[9129]); + data->localData[0]->realVars[834] /* points[21]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11004], data->localData[0]->realVars[220] /* T[21] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_581(DATA*,threadData_t*); +void Graph_eqFunction_582(DATA*,threadData_t*); +void Graph_eqFunction_583(DATA*,threadData_t*); +void Graph_eqFunction_584(DATA*,threadData_t*); +void Graph_eqFunction_585(DATA*,threadData_t*); +void Graph_eqFunction_586(DATA*,threadData_t*); +void Graph_eqFunction_587(DATA*,threadData_t*); +void Graph_eqFunction_588(DATA*,threadData_t*); +void Graph_eqFunction_589(DATA*,threadData_t*); +void Graph_eqFunction_590(DATA*,threadData_t*); +void Graph_eqFunction_591(DATA*,threadData_t*); +void Graph_eqFunction_592(DATA*,threadData_t*); +void Graph_eqFunction_593(DATA*,threadData_t*); +void Graph_eqFunction_594(DATA*,threadData_t*); +void Graph_eqFunction_595(DATA*,threadData_t*); +void Graph_eqFunction_596(DATA*,threadData_t*); +void Graph_eqFunction_597(DATA*,threadData_t*); +/* + equation index: 598 + indexNonlinear: 21 + type: NONLINEAR + + vars: {T[22]} + eqns: {581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597} + */ +void Graph_eqFunction_598(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,598}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 598 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[21].nlsxOld[0] = data->localData[0]->realVars[221] /* T[22] variable */; + retValue = solve_nonlinear_system(data, threadData, 21); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,598}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 598 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[221] /* T[22] variable */ = data->simulationInfo->nonlinearSystemData[21].nlsx[0]; + TRACE_POP +} + +/* + equation index: 599 + type: SIMPLE_ASSIGN + y[22,1] = 1.0 - 0.4615384615384616 * points[22].K[2] + */ +void Graph_eqFunction_599(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,599}; + data->localData[0]->realVars[1076] /* y[22,1] variable */ = 1.0 - ((0.4615384615384616) * (data->localData[0]->realVars[758] /* points[22]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 600 + type: SIMPLE_ASSIGN + y[22,2] = 0.4615384615384616 * points[22].K[2] + */ +void Graph_eqFunction_600(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,600}; + data->localData[0]->realVars[1077] /* y[22,2] variable */ = (0.4615384615384616) * (data->localData[0]->realVars[758] /* points[22]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 601 + type: SIMPLE_ASSIGN + points[22]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[22].comp[2].LiqDen[1], points[22].comp[2].LiqDen[2], points[22].comp[2].LiqDen[3], points[22].comp[2].LiqDen[4], points[22].comp[2].LiqDen[5], points[22].comp[2].LiqDen[6]}, points[22].comp[2].Tc, T[22], 10000.0) + */ +void Graph_eqFunction_601(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,601}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9142], (modelica_real)data->simulationInfo->realParameter[9143], (modelica_real)data->simulationInfo->realParameter[9144], (modelica_real)data->simulationInfo->realParameter[9145], (modelica_real)data->simulationInfo->realParameter[9146], (modelica_real)data->simulationInfo->realParameter[9147]); + data->localData[0]->realVars[837] /* points[22]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11007], data->localData[0]->realVars[221] /* T[22] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 602 + type: SIMPLE_ASSIGN + points[22]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[22].comp[1].LiqDen[1], points[22].comp[1].LiqDen[2], points[22].comp[1].LiqDen[3], points[22].comp[1].LiqDen[4], points[22].comp[1].LiqDen[5], points[22].comp[1].LiqDen[6]}, points[22].comp[1].Tc, T[22], 10000.0) + */ +void Graph_eqFunction_602(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,602}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9136], (modelica_real)data->simulationInfo->realParameter[9137], (modelica_real)data->simulationInfo->realParameter[9138], (modelica_real)data->simulationInfo->realParameter[9139], (modelica_real)data->simulationInfo->realParameter[9140], (modelica_real)data->simulationInfo->realParameter[9141]); + data->localData[0]->realVars[836] /* points[22]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11006], data->localData[0]->realVars[221] /* T[22] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_603(DATA*,threadData_t*); +void Graph_eqFunction_604(DATA*,threadData_t*); +void Graph_eqFunction_605(DATA*,threadData_t*); +void Graph_eqFunction_606(DATA*,threadData_t*); +void Graph_eqFunction_607(DATA*,threadData_t*); +void Graph_eqFunction_608(DATA*,threadData_t*); +void Graph_eqFunction_609(DATA*,threadData_t*); +void Graph_eqFunction_610(DATA*,threadData_t*); +void Graph_eqFunction_611(DATA*,threadData_t*); +void Graph_eqFunction_612(DATA*,threadData_t*); +void Graph_eqFunction_613(DATA*,threadData_t*); +void Graph_eqFunction_614(DATA*,threadData_t*); +void Graph_eqFunction_615(DATA*,threadData_t*); +void Graph_eqFunction_616(DATA*,threadData_t*); +void Graph_eqFunction_617(DATA*,threadData_t*); +void Graph_eqFunction_618(DATA*,threadData_t*); +void Graph_eqFunction_619(DATA*,threadData_t*); +/* + equation index: 620 + indexNonlinear: 22 + type: NONLINEAR + + vars: {T[23]} + eqns: {603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619} + */ +void Graph_eqFunction_620(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,620}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 620 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[22].nlsxOld[0] = data->localData[0]->realVars[222] /* T[23] variable */; + retValue = solve_nonlinear_system(data, threadData, 22); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,620}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 620 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[222] /* T[23] variable */ = data->simulationInfo->nonlinearSystemData[22].nlsx[0]; + TRACE_POP +} + +/* + equation index: 621 + type: SIMPLE_ASSIGN + y[23,1] = 1.0 - 0.4358974358974359 * points[23].K[2] + */ +void Graph_eqFunction_621(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,621}; + data->localData[0]->realVars[1078] /* y[23,1] variable */ = 1.0 - ((0.4358974358974359) * (data->localData[0]->realVars[760] /* points[23]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 622 + type: SIMPLE_ASSIGN + y[23,2] = 0.4358974358974359 * points[23].K[2] + */ +void Graph_eqFunction_622(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,622}; + data->localData[0]->realVars[1079] /* y[23,2] variable */ = (0.4358974358974359) * (data->localData[0]->realVars[760] /* points[23]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 623 + type: SIMPLE_ASSIGN + points[23]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[23].comp[2].LiqDen[1], points[23].comp[2].LiqDen[2], points[23].comp[2].LiqDen[3], points[23].comp[2].LiqDen[4], points[23].comp[2].LiqDen[5], points[23].comp[2].LiqDen[6]}, points[23].comp[2].Tc, T[23], 10000.0) + */ +void Graph_eqFunction_623(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,623}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9154], (modelica_real)data->simulationInfo->realParameter[9155], (modelica_real)data->simulationInfo->realParameter[9156], (modelica_real)data->simulationInfo->realParameter[9157], (modelica_real)data->simulationInfo->realParameter[9158], (modelica_real)data->simulationInfo->realParameter[9159]); + data->localData[0]->realVars[839] /* points[23]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11009], data->localData[0]->realVars[222] /* T[23] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 624 + type: SIMPLE_ASSIGN + points[23]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[23].comp[1].LiqDen[1], points[23].comp[1].LiqDen[2], points[23].comp[1].LiqDen[3], points[23].comp[1].LiqDen[4], points[23].comp[1].LiqDen[5], points[23].comp[1].LiqDen[6]}, points[23].comp[1].Tc, T[23], 10000.0) + */ +void Graph_eqFunction_624(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,624}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9148], (modelica_real)data->simulationInfo->realParameter[9149], (modelica_real)data->simulationInfo->realParameter[9150], (modelica_real)data->simulationInfo->realParameter[9151], (modelica_real)data->simulationInfo->realParameter[9152], (modelica_real)data->simulationInfo->realParameter[9153]); + data->localData[0]->realVars[838] /* points[23]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11008], data->localData[0]->realVars[222] /* T[23] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_625(DATA*,threadData_t*); +void Graph_eqFunction_626(DATA*,threadData_t*); +void Graph_eqFunction_627(DATA*,threadData_t*); +void Graph_eqFunction_628(DATA*,threadData_t*); +void Graph_eqFunction_629(DATA*,threadData_t*); +void Graph_eqFunction_630(DATA*,threadData_t*); +void Graph_eqFunction_631(DATA*,threadData_t*); +void Graph_eqFunction_632(DATA*,threadData_t*); +void Graph_eqFunction_633(DATA*,threadData_t*); +void Graph_eqFunction_634(DATA*,threadData_t*); +void Graph_eqFunction_635(DATA*,threadData_t*); +void Graph_eqFunction_636(DATA*,threadData_t*); +void Graph_eqFunction_637(DATA*,threadData_t*); +void Graph_eqFunction_638(DATA*,threadData_t*); +void Graph_eqFunction_639(DATA*,threadData_t*); +void Graph_eqFunction_640(DATA*,threadData_t*); +void Graph_eqFunction_641(DATA*,threadData_t*); +/* + equation index: 642 + indexNonlinear: 23 + type: NONLINEAR + + vars: {T[24]} + eqns: {625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641} + */ +void Graph_eqFunction_642(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,642}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 642 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[23].nlsxOld[0] = data->localData[0]->realVars[223] /* T[24] variable */; + retValue = solve_nonlinear_system(data, threadData, 23); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,642}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 642 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[223] /* T[24] variable */ = data->simulationInfo->nonlinearSystemData[23].nlsx[0]; + TRACE_POP +} + +/* + equation index: 643 + type: SIMPLE_ASSIGN + y[24,1] = 1.0 - 0.4102564102564102 * points[24].K[2] + */ +void Graph_eqFunction_643(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,643}; + data->localData[0]->realVars[1080] /* y[24,1] variable */ = 1.0 - ((0.4102564102564102) * (data->localData[0]->realVars[762] /* points[24]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 644 + type: SIMPLE_ASSIGN + y[24,2] = 0.4102564102564102 * points[24].K[2] + */ +void Graph_eqFunction_644(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,644}; + data->localData[0]->realVars[1081] /* y[24,2] variable */ = (0.4102564102564102) * (data->localData[0]->realVars[762] /* points[24]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 645 + type: SIMPLE_ASSIGN + points[24]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[24].comp[2].LiqDen[1], points[24].comp[2].LiqDen[2], points[24].comp[2].LiqDen[3], points[24].comp[2].LiqDen[4], points[24].comp[2].LiqDen[5], points[24].comp[2].LiqDen[6]}, points[24].comp[2].Tc, T[24], 10000.0) + */ +void Graph_eqFunction_645(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,645}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9166], (modelica_real)data->simulationInfo->realParameter[9167], (modelica_real)data->simulationInfo->realParameter[9168], (modelica_real)data->simulationInfo->realParameter[9169], (modelica_real)data->simulationInfo->realParameter[9170], (modelica_real)data->simulationInfo->realParameter[9171]); + data->localData[0]->realVars[841] /* points[24]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11011], data->localData[0]->realVars[223] /* T[24] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 646 + type: SIMPLE_ASSIGN + points[24]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[24].comp[1].LiqDen[1], points[24].comp[1].LiqDen[2], points[24].comp[1].LiqDen[3], points[24].comp[1].LiqDen[4], points[24].comp[1].LiqDen[5], points[24].comp[1].LiqDen[6]}, points[24].comp[1].Tc, T[24], 10000.0) + */ +void Graph_eqFunction_646(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,646}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9160], (modelica_real)data->simulationInfo->realParameter[9161], (modelica_real)data->simulationInfo->realParameter[9162], (modelica_real)data->simulationInfo->realParameter[9163], (modelica_real)data->simulationInfo->realParameter[9164], (modelica_real)data->simulationInfo->realParameter[9165]); + data->localData[0]->realVars[840] /* points[24]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11010], data->localData[0]->realVars[223] /* T[24] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_647(DATA*,threadData_t*); +void Graph_eqFunction_648(DATA*,threadData_t*); +void Graph_eqFunction_649(DATA*,threadData_t*); +void Graph_eqFunction_650(DATA*,threadData_t*); +void Graph_eqFunction_651(DATA*,threadData_t*); +void Graph_eqFunction_652(DATA*,threadData_t*); +void Graph_eqFunction_653(DATA*,threadData_t*); +void Graph_eqFunction_654(DATA*,threadData_t*); +void Graph_eqFunction_655(DATA*,threadData_t*); +void Graph_eqFunction_656(DATA*,threadData_t*); +void Graph_eqFunction_657(DATA*,threadData_t*); +void Graph_eqFunction_658(DATA*,threadData_t*); +void Graph_eqFunction_659(DATA*,threadData_t*); +void Graph_eqFunction_660(DATA*,threadData_t*); +void Graph_eqFunction_661(DATA*,threadData_t*); +void Graph_eqFunction_662(DATA*,threadData_t*); +void Graph_eqFunction_663(DATA*,threadData_t*); +/* + equation index: 664 + indexNonlinear: 24 + type: NONLINEAR + + vars: {T[25]} + eqns: {647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663} + */ +void Graph_eqFunction_664(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,664}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 664 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[24].nlsxOld[0] = data->localData[0]->realVars[224] /* T[25] variable */; + retValue = solve_nonlinear_system(data, threadData, 24); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,664}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 664 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[224] /* T[25] variable */ = data->simulationInfo->nonlinearSystemData[24].nlsx[0]; + TRACE_POP +} + +/* + equation index: 665 + type: SIMPLE_ASSIGN + y[25,1] = 1.0 - 0.3846153846153846 * points[25].K[2] + */ +void Graph_eqFunction_665(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,665}; + data->localData[0]->realVars[1082] /* y[25,1] variable */ = 1.0 - ((0.3846153846153846) * (data->localData[0]->realVars[764] /* points[25]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 666 + type: SIMPLE_ASSIGN + y[25,2] = 0.3846153846153846 * points[25].K[2] + */ +void Graph_eqFunction_666(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,666}; + data->localData[0]->realVars[1083] /* y[25,2] variable */ = (0.3846153846153846) * (data->localData[0]->realVars[764] /* points[25]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 667 + type: SIMPLE_ASSIGN + points[25]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[25].comp[2].LiqDen[1], points[25].comp[2].LiqDen[2], points[25].comp[2].LiqDen[3], points[25].comp[2].LiqDen[4], points[25].comp[2].LiqDen[5], points[25].comp[2].LiqDen[6]}, points[25].comp[2].Tc, T[25], 10000.0) + */ +void Graph_eqFunction_667(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,667}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9178], (modelica_real)data->simulationInfo->realParameter[9179], (modelica_real)data->simulationInfo->realParameter[9180], (modelica_real)data->simulationInfo->realParameter[9181], (modelica_real)data->simulationInfo->realParameter[9182], (modelica_real)data->simulationInfo->realParameter[9183]); + data->localData[0]->realVars[843] /* points[25]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11013], data->localData[0]->realVars[224] /* T[25] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 668 + type: SIMPLE_ASSIGN + points[25]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[25].comp[1].LiqDen[1], points[25].comp[1].LiqDen[2], points[25].comp[1].LiqDen[3], points[25].comp[1].LiqDen[4], points[25].comp[1].LiqDen[5], points[25].comp[1].LiqDen[6]}, points[25].comp[1].Tc, T[25], 10000.0) + */ +void Graph_eqFunction_668(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,668}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9172], (modelica_real)data->simulationInfo->realParameter[9173], (modelica_real)data->simulationInfo->realParameter[9174], (modelica_real)data->simulationInfo->realParameter[9175], (modelica_real)data->simulationInfo->realParameter[9176], (modelica_real)data->simulationInfo->realParameter[9177]); + data->localData[0]->realVars[842] /* points[25]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11012], data->localData[0]->realVars[224] /* T[25] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_669(DATA*,threadData_t*); +void Graph_eqFunction_670(DATA*,threadData_t*); +void Graph_eqFunction_671(DATA*,threadData_t*); +void Graph_eqFunction_672(DATA*,threadData_t*); +void Graph_eqFunction_673(DATA*,threadData_t*); +void Graph_eqFunction_674(DATA*,threadData_t*); +void Graph_eqFunction_675(DATA*,threadData_t*); +void Graph_eqFunction_676(DATA*,threadData_t*); +void Graph_eqFunction_677(DATA*,threadData_t*); +void Graph_eqFunction_678(DATA*,threadData_t*); +void Graph_eqFunction_679(DATA*,threadData_t*); +void Graph_eqFunction_680(DATA*,threadData_t*); +void Graph_eqFunction_681(DATA*,threadData_t*); +void Graph_eqFunction_682(DATA*,threadData_t*); +void Graph_eqFunction_683(DATA*,threadData_t*); +void Graph_eqFunction_684(DATA*,threadData_t*); +void Graph_eqFunction_685(DATA*,threadData_t*); +/* + equation index: 686 + indexNonlinear: 25 + type: NONLINEAR + + vars: {T[26]} + eqns: {669, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685} + */ +void Graph_eqFunction_686(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,686}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 686 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[25].nlsxOld[0] = data->localData[0]->realVars[225] /* T[26] variable */; + retValue = solve_nonlinear_system(data, threadData, 25); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,686}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 686 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[225] /* T[26] variable */ = data->simulationInfo->nonlinearSystemData[25].nlsx[0]; + TRACE_POP +} + +/* + equation index: 687 + type: SIMPLE_ASSIGN + y[26,1] = 1.0 - 0.3589743589743589 * points[26].K[2] + */ +void Graph_eqFunction_687(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,687}; + data->localData[0]->realVars[1084] /* y[26,1] variable */ = 1.0 - ((0.3589743589743589) * (data->localData[0]->realVars[766] /* points[26]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 688 + type: SIMPLE_ASSIGN + y[26,2] = 0.3589743589743589 * points[26].K[2] + */ +void Graph_eqFunction_688(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,688}; + data->localData[0]->realVars[1085] /* y[26,2] variable */ = (0.3589743589743589) * (data->localData[0]->realVars[766] /* points[26]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 689 + type: SIMPLE_ASSIGN + points[26]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[26].comp[2].LiqDen[1], points[26].comp[2].LiqDen[2], points[26].comp[2].LiqDen[3], points[26].comp[2].LiqDen[4], points[26].comp[2].LiqDen[5], points[26].comp[2].LiqDen[6]}, points[26].comp[2].Tc, T[26], 10000.0) + */ +void Graph_eqFunction_689(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,689}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9190], (modelica_real)data->simulationInfo->realParameter[9191], (modelica_real)data->simulationInfo->realParameter[9192], (modelica_real)data->simulationInfo->realParameter[9193], (modelica_real)data->simulationInfo->realParameter[9194], (modelica_real)data->simulationInfo->realParameter[9195]); + data->localData[0]->realVars[845] /* points[26]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11015], data->localData[0]->realVars[225] /* T[26] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 690 + type: SIMPLE_ASSIGN + points[26]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[26].comp[1].LiqDen[1], points[26].comp[1].LiqDen[2], points[26].comp[1].LiqDen[3], points[26].comp[1].LiqDen[4], points[26].comp[1].LiqDen[5], points[26].comp[1].LiqDen[6]}, points[26].comp[1].Tc, T[26], 10000.0) + */ +void Graph_eqFunction_690(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,690}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9184], (modelica_real)data->simulationInfo->realParameter[9185], (modelica_real)data->simulationInfo->realParameter[9186], (modelica_real)data->simulationInfo->realParameter[9187], (modelica_real)data->simulationInfo->realParameter[9188], (modelica_real)data->simulationInfo->realParameter[9189]); + data->localData[0]->realVars[844] /* points[26]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11014], data->localData[0]->realVars[225] /* T[26] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_691(DATA*,threadData_t*); +void Graph_eqFunction_692(DATA*,threadData_t*); +void Graph_eqFunction_693(DATA*,threadData_t*); +void Graph_eqFunction_694(DATA*,threadData_t*); +void Graph_eqFunction_695(DATA*,threadData_t*); +void Graph_eqFunction_696(DATA*,threadData_t*); +void Graph_eqFunction_697(DATA*,threadData_t*); +void Graph_eqFunction_698(DATA*,threadData_t*); +void Graph_eqFunction_699(DATA*,threadData_t*); +void Graph_eqFunction_700(DATA*,threadData_t*); +void Graph_eqFunction_701(DATA*,threadData_t*); +void Graph_eqFunction_702(DATA*,threadData_t*); +void Graph_eqFunction_703(DATA*,threadData_t*); +void Graph_eqFunction_704(DATA*,threadData_t*); +void Graph_eqFunction_705(DATA*,threadData_t*); +void Graph_eqFunction_706(DATA*,threadData_t*); +void Graph_eqFunction_707(DATA*,threadData_t*); +/* + equation index: 708 + indexNonlinear: 26 + type: NONLINEAR + + vars: {T[27]} + eqns: {691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, 705, 706, 707} + */ +void Graph_eqFunction_708(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,708}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 708 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[26].nlsxOld[0] = data->localData[0]->realVars[226] /* T[27] variable */; + retValue = solve_nonlinear_system(data, threadData, 26); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,708}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 708 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[226] /* T[27] variable */ = data->simulationInfo->nonlinearSystemData[26].nlsx[0]; + TRACE_POP +} + +/* + equation index: 709 + type: SIMPLE_ASSIGN + y[27,1] = 1.0 - 0.3333333333333334 * points[27].K[2] + */ +void Graph_eqFunction_709(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,709}; + data->localData[0]->realVars[1086] /* y[27,1] variable */ = 1.0 - ((0.3333333333333334) * (data->localData[0]->realVars[768] /* points[27]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 710 + type: SIMPLE_ASSIGN + y[27,2] = 0.3333333333333334 * points[27].K[2] + */ +void Graph_eqFunction_710(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,710}; + data->localData[0]->realVars[1087] /* y[27,2] variable */ = (0.3333333333333334) * (data->localData[0]->realVars[768] /* points[27]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 711 + type: SIMPLE_ASSIGN + points[27]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[27].comp[2].LiqDen[1], points[27].comp[2].LiqDen[2], points[27].comp[2].LiqDen[3], points[27].comp[2].LiqDen[4], points[27].comp[2].LiqDen[5], points[27].comp[2].LiqDen[6]}, points[27].comp[2].Tc, T[27], 10000.0) + */ +void Graph_eqFunction_711(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,711}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9202], (modelica_real)data->simulationInfo->realParameter[9203], (modelica_real)data->simulationInfo->realParameter[9204], (modelica_real)data->simulationInfo->realParameter[9205], (modelica_real)data->simulationInfo->realParameter[9206], (modelica_real)data->simulationInfo->realParameter[9207]); + data->localData[0]->realVars[847] /* points[27]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11017], data->localData[0]->realVars[226] /* T[27] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 712 + type: SIMPLE_ASSIGN + points[27]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[27].comp[1].LiqDen[1], points[27].comp[1].LiqDen[2], points[27].comp[1].LiqDen[3], points[27].comp[1].LiqDen[4], points[27].comp[1].LiqDen[5], points[27].comp[1].LiqDen[6]}, points[27].comp[1].Tc, T[27], 10000.0) + */ +void Graph_eqFunction_712(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,712}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9196], (modelica_real)data->simulationInfo->realParameter[9197], (modelica_real)data->simulationInfo->realParameter[9198], (modelica_real)data->simulationInfo->realParameter[9199], (modelica_real)data->simulationInfo->realParameter[9200], (modelica_real)data->simulationInfo->realParameter[9201]); + data->localData[0]->realVars[846] /* points[27]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11016], data->localData[0]->realVars[226] /* T[27] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_713(DATA*,threadData_t*); +void Graph_eqFunction_714(DATA*,threadData_t*); +void Graph_eqFunction_715(DATA*,threadData_t*); +void Graph_eqFunction_716(DATA*,threadData_t*); +void Graph_eqFunction_717(DATA*,threadData_t*); +void Graph_eqFunction_718(DATA*,threadData_t*); +void Graph_eqFunction_719(DATA*,threadData_t*); +void Graph_eqFunction_720(DATA*,threadData_t*); +void Graph_eqFunction_721(DATA*,threadData_t*); +void Graph_eqFunction_722(DATA*,threadData_t*); +void Graph_eqFunction_723(DATA*,threadData_t*); +void Graph_eqFunction_724(DATA*,threadData_t*); +void Graph_eqFunction_725(DATA*,threadData_t*); +void Graph_eqFunction_726(DATA*,threadData_t*); +void Graph_eqFunction_727(DATA*,threadData_t*); +void Graph_eqFunction_728(DATA*,threadData_t*); +void Graph_eqFunction_729(DATA*,threadData_t*); +/* + equation index: 730 + indexNonlinear: 27 + type: NONLINEAR + + vars: {T[28]} + eqns: {713, 714, 715, 716, 717, 718, 719, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729} + */ +void Graph_eqFunction_730(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,730}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 730 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[27].nlsxOld[0] = data->localData[0]->realVars[227] /* T[28] variable */; + retValue = solve_nonlinear_system(data, threadData, 27); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,730}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 730 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[227] /* T[28] variable */ = data->simulationInfo->nonlinearSystemData[27].nlsx[0]; + TRACE_POP +} + +/* + equation index: 731 + type: SIMPLE_ASSIGN + y[28,1] = 1.0 - 0.3076923076923077 * points[28].K[2] + */ +void Graph_eqFunction_731(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,731}; + data->localData[0]->realVars[1088] /* y[28,1] variable */ = 1.0 - ((0.3076923076923077) * (data->localData[0]->realVars[770] /* points[28]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 732 + type: SIMPLE_ASSIGN + y[28,2] = 0.3076923076923077 * points[28].K[2] + */ +void Graph_eqFunction_732(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,732}; + data->localData[0]->realVars[1089] /* y[28,2] variable */ = (0.3076923076923077) * (data->localData[0]->realVars[770] /* points[28]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 733 + type: SIMPLE_ASSIGN + points[28]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[28].comp[2].LiqDen[1], points[28].comp[2].LiqDen[2], points[28].comp[2].LiqDen[3], points[28].comp[2].LiqDen[4], points[28].comp[2].LiqDen[5], points[28].comp[2].LiqDen[6]}, points[28].comp[2].Tc, T[28], 10000.0) + */ +void Graph_eqFunction_733(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,733}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9214], (modelica_real)data->simulationInfo->realParameter[9215], (modelica_real)data->simulationInfo->realParameter[9216], (modelica_real)data->simulationInfo->realParameter[9217], (modelica_real)data->simulationInfo->realParameter[9218], (modelica_real)data->simulationInfo->realParameter[9219]); + data->localData[0]->realVars[849] /* points[28]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11019], data->localData[0]->realVars[227] /* T[28] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 734 + type: SIMPLE_ASSIGN + points[28]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[28].comp[1].LiqDen[1], points[28].comp[1].LiqDen[2], points[28].comp[1].LiqDen[3], points[28].comp[1].LiqDen[4], points[28].comp[1].LiqDen[5], points[28].comp[1].LiqDen[6]}, points[28].comp[1].Tc, T[28], 10000.0) + */ +void Graph_eqFunction_734(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,734}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9208], (modelica_real)data->simulationInfo->realParameter[9209], (modelica_real)data->simulationInfo->realParameter[9210], (modelica_real)data->simulationInfo->realParameter[9211], (modelica_real)data->simulationInfo->realParameter[9212], (modelica_real)data->simulationInfo->realParameter[9213]); + data->localData[0]->realVars[848] /* points[28]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11018], data->localData[0]->realVars[227] /* T[28] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_735(DATA*,threadData_t*); +void Graph_eqFunction_736(DATA*,threadData_t*); +void Graph_eqFunction_737(DATA*,threadData_t*); +void Graph_eqFunction_738(DATA*,threadData_t*); +void Graph_eqFunction_739(DATA*,threadData_t*); +void Graph_eqFunction_740(DATA*,threadData_t*); +void Graph_eqFunction_741(DATA*,threadData_t*); +void Graph_eqFunction_742(DATA*,threadData_t*); +void Graph_eqFunction_743(DATA*,threadData_t*); +void Graph_eqFunction_744(DATA*,threadData_t*); +void Graph_eqFunction_745(DATA*,threadData_t*); +void Graph_eqFunction_746(DATA*,threadData_t*); +void Graph_eqFunction_747(DATA*,threadData_t*); +void Graph_eqFunction_748(DATA*,threadData_t*); +void Graph_eqFunction_749(DATA*,threadData_t*); +void Graph_eqFunction_750(DATA*,threadData_t*); +void Graph_eqFunction_751(DATA*,threadData_t*); +/* + equation index: 752 + indexNonlinear: 28 + type: NONLINEAR + + vars: {T[29]} + eqns: {735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751} + */ +void Graph_eqFunction_752(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,752}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 752 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[28].nlsxOld[0] = data->localData[0]->realVars[228] /* T[29] variable */; + retValue = solve_nonlinear_system(data, threadData, 28); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,752}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 752 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[228] /* T[29] variable */ = data->simulationInfo->nonlinearSystemData[28].nlsx[0]; + TRACE_POP +} + +/* + equation index: 753 + type: SIMPLE_ASSIGN + y[29,1] = 1.0 - 0.2820512820512821 * points[29].K[2] + */ +void Graph_eqFunction_753(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,753}; + data->localData[0]->realVars[1090] /* y[29,1] variable */ = 1.0 - ((0.2820512820512821) * (data->localData[0]->realVars[772] /* points[29]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 754 + type: SIMPLE_ASSIGN + y[29,2] = 0.2820512820512821 * points[29].K[2] + */ +void Graph_eqFunction_754(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,754}; + data->localData[0]->realVars[1091] /* y[29,2] variable */ = (0.2820512820512821) * (data->localData[0]->realVars[772] /* points[29]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 755 + type: SIMPLE_ASSIGN + points[29]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[29].comp[2].LiqDen[1], points[29].comp[2].LiqDen[2], points[29].comp[2].LiqDen[3], points[29].comp[2].LiqDen[4], points[29].comp[2].LiqDen[5], points[29].comp[2].LiqDen[6]}, points[29].comp[2].Tc, T[29], 10000.0) + */ +void Graph_eqFunction_755(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,755}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9226], (modelica_real)data->simulationInfo->realParameter[9227], (modelica_real)data->simulationInfo->realParameter[9228], (modelica_real)data->simulationInfo->realParameter[9229], (modelica_real)data->simulationInfo->realParameter[9230], (modelica_real)data->simulationInfo->realParameter[9231]); + data->localData[0]->realVars[851] /* points[29]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11021], data->localData[0]->realVars[228] /* T[29] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 756 + type: SIMPLE_ASSIGN + points[29]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[29].comp[1].LiqDen[1], points[29].comp[1].LiqDen[2], points[29].comp[1].LiqDen[3], points[29].comp[1].LiqDen[4], points[29].comp[1].LiqDen[5], points[29].comp[1].LiqDen[6]}, points[29].comp[1].Tc, T[29], 10000.0) + */ +void Graph_eqFunction_756(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,756}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9220], (modelica_real)data->simulationInfo->realParameter[9221], (modelica_real)data->simulationInfo->realParameter[9222], (modelica_real)data->simulationInfo->realParameter[9223], (modelica_real)data->simulationInfo->realParameter[9224], (modelica_real)data->simulationInfo->realParameter[9225]); + data->localData[0]->realVars[850] /* points[29]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11020], data->localData[0]->realVars[228] /* T[29] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_757(DATA*,threadData_t*); +void Graph_eqFunction_758(DATA*,threadData_t*); +void Graph_eqFunction_759(DATA*,threadData_t*); +void Graph_eqFunction_760(DATA*,threadData_t*); +void Graph_eqFunction_761(DATA*,threadData_t*); +void Graph_eqFunction_762(DATA*,threadData_t*); +void Graph_eqFunction_763(DATA*,threadData_t*); +void Graph_eqFunction_764(DATA*,threadData_t*); +void Graph_eqFunction_765(DATA*,threadData_t*); +void Graph_eqFunction_766(DATA*,threadData_t*); +void Graph_eqFunction_767(DATA*,threadData_t*); +void Graph_eqFunction_768(DATA*,threadData_t*); +void Graph_eqFunction_769(DATA*,threadData_t*); +void Graph_eqFunction_770(DATA*,threadData_t*); +void Graph_eqFunction_771(DATA*,threadData_t*); +void Graph_eqFunction_772(DATA*,threadData_t*); +void Graph_eqFunction_773(DATA*,threadData_t*); +/* + equation index: 774 + indexNonlinear: 29 + type: NONLINEAR + + vars: {T[30]} + eqns: {757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, 769, 770, 771, 772, 773} + */ +void Graph_eqFunction_774(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,774}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 774 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[29].nlsxOld[0] = data->localData[0]->realVars[229] /* T[30] variable */; + retValue = solve_nonlinear_system(data, threadData, 29); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,774}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 774 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[229] /* T[30] variable */ = data->simulationInfo->nonlinearSystemData[29].nlsx[0]; + TRACE_POP +} + +/* + equation index: 775 + type: SIMPLE_ASSIGN + y[30,1] = 1.0 - 0.2564102564102564 * points[30].K[2] + */ +void Graph_eqFunction_775(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,775}; + data->localData[0]->realVars[1092] /* y[30,1] variable */ = 1.0 - ((0.2564102564102564) * (data->localData[0]->realVars[774] /* points[30]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 776 + type: SIMPLE_ASSIGN + y[30,2] = 0.2564102564102564 * points[30].K[2] + */ +void Graph_eqFunction_776(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,776}; + data->localData[0]->realVars[1093] /* y[30,2] variable */ = (0.2564102564102564) * (data->localData[0]->realVars[774] /* points[30]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 777 + type: SIMPLE_ASSIGN + points[30]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[30].comp[2].LiqDen[1], points[30].comp[2].LiqDen[2], points[30].comp[2].LiqDen[3], points[30].comp[2].LiqDen[4], points[30].comp[2].LiqDen[5], points[30].comp[2].LiqDen[6]}, points[30].comp[2].Tc, T[30], 10000.0) + */ +void Graph_eqFunction_777(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,777}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9238], (modelica_real)data->simulationInfo->realParameter[9239], (modelica_real)data->simulationInfo->realParameter[9240], (modelica_real)data->simulationInfo->realParameter[9241], (modelica_real)data->simulationInfo->realParameter[9242], (modelica_real)data->simulationInfo->realParameter[9243]); + data->localData[0]->realVars[853] /* points[30]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11023], data->localData[0]->realVars[229] /* T[30] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 778 + type: SIMPLE_ASSIGN + points[30]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[30].comp[1].LiqDen[1], points[30].comp[1].LiqDen[2], points[30].comp[1].LiqDen[3], points[30].comp[1].LiqDen[4], points[30].comp[1].LiqDen[5], points[30].comp[1].LiqDen[6]}, points[30].comp[1].Tc, T[30], 10000.0) + */ +void Graph_eqFunction_778(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,778}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9232], (modelica_real)data->simulationInfo->realParameter[9233], (modelica_real)data->simulationInfo->realParameter[9234], (modelica_real)data->simulationInfo->realParameter[9235], (modelica_real)data->simulationInfo->realParameter[9236], (modelica_real)data->simulationInfo->realParameter[9237]); + data->localData[0]->realVars[852] /* points[30]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11022], data->localData[0]->realVars[229] /* T[30] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_779(DATA*,threadData_t*); +void Graph_eqFunction_780(DATA*,threadData_t*); +void Graph_eqFunction_781(DATA*,threadData_t*); +void Graph_eqFunction_782(DATA*,threadData_t*); +void Graph_eqFunction_783(DATA*,threadData_t*); +void Graph_eqFunction_784(DATA*,threadData_t*); +void Graph_eqFunction_785(DATA*,threadData_t*); +void Graph_eqFunction_786(DATA*,threadData_t*); +void Graph_eqFunction_787(DATA*,threadData_t*); +void Graph_eqFunction_788(DATA*,threadData_t*); +void Graph_eqFunction_789(DATA*,threadData_t*); +void Graph_eqFunction_790(DATA*,threadData_t*); +void Graph_eqFunction_791(DATA*,threadData_t*); +void Graph_eqFunction_792(DATA*,threadData_t*); +void Graph_eqFunction_793(DATA*,threadData_t*); +void Graph_eqFunction_794(DATA*,threadData_t*); +void Graph_eqFunction_795(DATA*,threadData_t*); +/* + equation index: 796 + indexNonlinear: 30 + type: NONLINEAR + + vars: {T[31]} + eqns: {779, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795} + */ +void Graph_eqFunction_796(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,796}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 796 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[30].nlsxOld[0] = data->localData[0]->realVars[230] /* T[31] variable */; + retValue = solve_nonlinear_system(data, threadData, 30); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,796}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 796 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[230] /* T[31] variable */ = data->simulationInfo->nonlinearSystemData[30].nlsx[0]; + TRACE_POP +} + +/* + equation index: 797 + type: SIMPLE_ASSIGN + y[31,1] = 1.0 - 0.2307692307692307 * points[31].K[2] + */ +void Graph_eqFunction_797(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,797}; + data->localData[0]->realVars[1094] /* y[31,1] variable */ = 1.0 - ((0.2307692307692307) * (data->localData[0]->realVars[776] /* points[31]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 798 + type: SIMPLE_ASSIGN + y[31,2] = 0.2307692307692307 * points[31].K[2] + */ +void Graph_eqFunction_798(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,798}; + data->localData[0]->realVars[1095] /* y[31,2] variable */ = (0.2307692307692307) * (data->localData[0]->realVars[776] /* points[31]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 799 + type: SIMPLE_ASSIGN + points[31]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[31].comp[2].LiqDen[1], points[31].comp[2].LiqDen[2], points[31].comp[2].LiqDen[3], points[31].comp[2].LiqDen[4], points[31].comp[2].LiqDen[5], points[31].comp[2].LiqDen[6]}, points[31].comp[2].Tc, T[31], 10000.0) + */ +void Graph_eqFunction_799(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,799}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9250], (modelica_real)data->simulationInfo->realParameter[9251], (modelica_real)data->simulationInfo->realParameter[9252], (modelica_real)data->simulationInfo->realParameter[9253], (modelica_real)data->simulationInfo->realParameter[9254], (modelica_real)data->simulationInfo->realParameter[9255]); + data->localData[0]->realVars[855] /* points[31]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11025], data->localData[0]->realVars[230] /* T[31] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 800 + type: SIMPLE_ASSIGN + points[31]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[31].comp[1].LiqDen[1], points[31].comp[1].LiqDen[2], points[31].comp[1].LiqDen[3], points[31].comp[1].LiqDen[4], points[31].comp[1].LiqDen[5], points[31].comp[1].LiqDen[6]}, points[31].comp[1].Tc, T[31], 10000.0) + */ +void Graph_eqFunction_800(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,800}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9244], (modelica_real)data->simulationInfo->realParameter[9245], (modelica_real)data->simulationInfo->realParameter[9246], (modelica_real)data->simulationInfo->realParameter[9247], (modelica_real)data->simulationInfo->realParameter[9248], (modelica_real)data->simulationInfo->realParameter[9249]); + data->localData[0]->realVars[854] /* points[31]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11024], data->localData[0]->realVars[230] /* T[31] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_801(DATA*,threadData_t*); +void Graph_eqFunction_802(DATA*,threadData_t*); +void Graph_eqFunction_803(DATA*,threadData_t*); +void Graph_eqFunction_804(DATA*,threadData_t*); +void Graph_eqFunction_805(DATA*,threadData_t*); +void Graph_eqFunction_806(DATA*,threadData_t*); +void Graph_eqFunction_807(DATA*,threadData_t*); +void Graph_eqFunction_808(DATA*,threadData_t*); +void Graph_eqFunction_809(DATA*,threadData_t*); +void Graph_eqFunction_810(DATA*,threadData_t*); +void Graph_eqFunction_811(DATA*,threadData_t*); +void Graph_eqFunction_812(DATA*,threadData_t*); +void Graph_eqFunction_813(DATA*,threadData_t*); +void Graph_eqFunction_814(DATA*,threadData_t*); +void Graph_eqFunction_815(DATA*,threadData_t*); +void Graph_eqFunction_816(DATA*,threadData_t*); +void Graph_eqFunction_817(DATA*,threadData_t*); +/* + equation index: 818 + indexNonlinear: 31 + type: NONLINEAR + + vars: {T[32]} + eqns: {801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816, 817} + */ +void Graph_eqFunction_818(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,818}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 818 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[31].nlsxOld[0] = data->localData[0]->realVars[231] /* T[32] variable */; + retValue = solve_nonlinear_system(data, threadData, 31); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,818}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 818 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[231] /* T[32] variable */ = data->simulationInfo->nonlinearSystemData[31].nlsx[0]; + TRACE_POP +} + +/* + equation index: 819 + type: SIMPLE_ASSIGN + y[32,1] = 1.0 - 0.2051282051282052 * points[32].K[2] + */ +void Graph_eqFunction_819(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,819}; + data->localData[0]->realVars[1096] /* y[32,1] variable */ = 1.0 - ((0.2051282051282052) * (data->localData[0]->realVars[778] /* points[32]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 820 + type: SIMPLE_ASSIGN + y[32,2] = 0.2051282051282052 * points[32].K[2] + */ +void Graph_eqFunction_820(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,820}; + data->localData[0]->realVars[1097] /* y[32,2] variable */ = (0.2051282051282052) * (data->localData[0]->realVars[778] /* points[32]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 821 + type: SIMPLE_ASSIGN + points[32]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[32].comp[2].LiqDen[1], points[32].comp[2].LiqDen[2], points[32].comp[2].LiqDen[3], points[32].comp[2].LiqDen[4], points[32].comp[2].LiqDen[5], points[32].comp[2].LiqDen[6]}, points[32].comp[2].Tc, T[32], 10000.0) + */ +void Graph_eqFunction_821(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,821}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9262], (modelica_real)data->simulationInfo->realParameter[9263], (modelica_real)data->simulationInfo->realParameter[9264], (modelica_real)data->simulationInfo->realParameter[9265], (modelica_real)data->simulationInfo->realParameter[9266], (modelica_real)data->simulationInfo->realParameter[9267]); + data->localData[0]->realVars[857] /* points[32]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11027], data->localData[0]->realVars[231] /* T[32] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 822 + type: SIMPLE_ASSIGN + points[32]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[32].comp[1].LiqDen[1], points[32].comp[1].LiqDen[2], points[32].comp[1].LiqDen[3], points[32].comp[1].LiqDen[4], points[32].comp[1].LiqDen[5], points[32].comp[1].LiqDen[6]}, points[32].comp[1].Tc, T[32], 10000.0) + */ +void Graph_eqFunction_822(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,822}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9256], (modelica_real)data->simulationInfo->realParameter[9257], (modelica_real)data->simulationInfo->realParameter[9258], (modelica_real)data->simulationInfo->realParameter[9259], (modelica_real)data->simulationInfo->realParameter[9260], (modelica_real)data->simulationInfo->realParameter[9261]); + data->localData[0]->realVars[856] /* points[32]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11026], data->localData[0]->realVars[231] /* T[32] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_823(DATA*,threadData_t*); +void Graph_eqFunction_824(DATA*,threadData_t*); +void Graph_eqFunction_825(DATA*,threadData_t*); +void Graph_eqFunction_826(DATA*,threadData_t*); +void Graph_eqFunction_827(DATA*,threadData_t*); +void Graph_eqFunction_828(DATA*,threadData_t*); +void Graph_eqFunction_829(DATA*,threadData_t*); +void Graph_eqFunction_830(DATA*,threadData_t*); +void Graph_eqFunction_831(DATA*,threadData_t*); +void Graph_eqFunction_832(DATA*,threadData_t*); +void Graph_eqFunction_833(DATA*,threadData_t*); +void Graph_eqFunction_834(DATA*,threadData_t*); +void Graph_eqFunction_835(DATA*,threadData_t*); +void Graph_eqFunction_836(DATA*,threadData_t*); +void Graph_eqFunction_837(DATA*,threadData_t*); +void Graph_eqFunction_838(DATA*,threadData_t*); +void Graph_eqFunction_839(DATA*,threadData_t*); +/* + equation index: 840 + indexNonlinear: 32 + type: NONLINEAR + + vars: {T[33]} + eqns: {823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839} + */ +void Graph_eqFunction_840(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,840}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 840 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[32].nlsxOld[0] = data->localData[0]->realVars[232] /* T[33] variable */; + retValue = solve_nonlinear_system(data, threadData, 32); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,840}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 840 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[232] /* T[33] variable */ = data->simulationInfo->nonlinearSystemData[32].nlsx[0]; + TRACE_POP +} + +/* + equation index: 841 + type: SIMPLE_ASSIGN + y[33,1] = 1.0 - 0.1794871794871795 * points[33].K[2] + */ +void Graph_eqFunction_841(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,841}; + data->localData[0]->realVars[1098] /* y[33,1] variable */ = 1.0 - ((0.1794871794871795) * (data->localData[0]->realVars[780] /* points[33]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 842 + type: SIMPLE_ASSIGN + y[33,2] = 0.1794871794871795 * points[33].K[2] + */ +void Graph_eqFunction_842(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,842}; + data->localData[0]->realVars[1099] /* y[33,2] variable */ = (0.1794871794871795) * (data->localData[0]->realVars[780] /* points[33]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 843 + type: SIMPLE_ASSIGN + points[33]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[33].comp[2].LiqDen[1], points[33].comp[2].LiqDen[2], points[33].comp[2].LiqDen[3], points[33].comp[2].LiqDen[4], points[33].comp[2].LiqDen[5], points[33].comp[2].LiqDen[6]}, points[33].comp[2].Tc, T[33], 10000.0) + */ +void Graph_eqFunction_843(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,843}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9274], (modelica_real)data->simulationInfo->realParameter[9275], (modelica_real)data->simulationInfo->realParameter[9276], (modelica_real)data->simulationInfo->realParameter[9277], (modelica_real)data->simulationInfo->realParameter[9278], (modelica_real)data->simulationInfo->realParameter[9279]); + data->localData[0]->realVars[859] /* points[33]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11029], data->localData[0]->realVars[232] /* T[33] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 844 + type: SIMPLE_ASSIGN + points[33]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[33].comp[1].LiqDen[1], points[33].comp[1].LiqDen[2], points[33].comp[1].LiqDen[3], points[33].comp[1].LiqDen[4], points[33].comp[1].LiqDen[5], points[33].comp[1].LiqDen[6]}, points[33].comp[1].Tc, T[33], 10000.0) + */ +void Graph_eqFunction_844(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,844}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9268], (modelica_real)data->simulationInfo->realParameter[9269], (modelica_real)data->simulationInfo->realParameter[9270], (modelica_real)data->simulationInfo->realParameter[9271], (modelica_real)data->simulationInfo->realParameter[9272], (modelica_real)data->simulationInfo->realParameter[9273]); + data->localData[0]->realVars[858] /* points[33]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11028], data->localData[0]->realVars[232] /* T[33] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_845(DATA*,threadData_t*); +void Graph_eqFunction_846(DATA*,threadData_t*); +void Graph_eqFunction_847(DATA*,threadData_t*); +void Graph_eqFunction_848(DATA*,threadData_t*); +void Graph_eqFunction_849(DATA*,threadData_t*); +void Graph_eqFunction_850(DATA*,threadData_t*); +void Graph_eqFunction_851(DATA*,threadData_t*); +void Graph_eqFunction_852(DATA*,threadData_t*); +void Graph_eqFunction_853(DATA*,threadData_t*); +void Graph_eqFunction_854(DATA*,threadData_t*); +void Graph_eqFunction_855(DATA*,threadData_t*); +void Graph_eqFunction_856(DATA*,threadData_t*); +void Graph_eqFunction_857(DATA*,threadData_t*); +void Graph_eqFunction_858(DATA*,threadData_t*); +void Graph_eqFunction_859(DATA*,threadData_t*); +void Graph_eqFunction_860(DATA*,threadData_t*); +void Graph_eqFunction_861(DATA*,threadData_t*); +/* + equation index: 862 + indexNonlinear: 33 + type: NONLINEAR + + vars: {T[34]} + eqns: {845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861} + */ +void Graph_eqFunction_862(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,862}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 862 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[33].nlsxOld[0] = data->localData[0]->realVars[233] /* T[34] variable */; + retValue = solve_nonlinear_system(data, threadData, 33); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,862}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 862 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[233] /* T[34] variable */ = data->simulationInfo->nonlinearSystemData[33].nlsx[0]; + TRACE_POP +} + +/* + equation index: 863 + type: SIMPLE_ASSIGN + y[34,1] = 1.0 - 0.1538461538461539 * points[34].K[2] + */ +void Graph_eqFunction_863(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,863}; + data->localData[0]->realVars[1100] /* y[34,1] variable */ = 1.0 - ((0.1538461538461539) * (data->localData[0]->realVars[782] /* points[34]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 864 + type: SIMPLE_ASSIGN + y[34,2] = 0.1538461538461539 * points[34].K[2] + */ +void Graph_eqFunction_864(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,864}; + data->localData[0]->realVars[1101] /* y[34,2] variable */ = (0.1538461538461539) * (data->localData[0]->realVars[782] /* points[34]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 865 + type: SIMPLE_ASSIGN + points[34]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[34].comp[2].LiqDen[1], points[34].comp[2].LiqDen[2], points[34].comp[2].LiqDen[3], points[34].comp[2].LiqDen[4], points[34].comp[2].LiqDen[5], points[34].comp[2].LiqDen[6]}, points[34].comp[2].Tc, T[34], 10000.0) + */ +void Graph_eqFunction_865(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,865}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9286], (modelica_real)data->simulationInfo->realParameter[9287], (modelica_real)data->simulationInfo->realParameter[9288], (modelica_real)data->simulationInfo->realParameter[9289], (modelica_real)data->simulationInfo->realParameter[9290], (modelica_real)data->simulationInfo->realParameter[9291]); + data->localData[0]->realVars[861] /* points[34]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11031], data->localData[0]->realVars[233] /* T[34] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 866 + type: SIMPLE_ASSIGN + points[34]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[34].comp[1].LiqDen[1], points[34].comp[1].LiqDen[2], points[34].comp[1].LiqDen[3], points[34].comp[1].LiqDen[4], points[34].comp[1].LiqDen[5], points[34].comp[1].LiqDen[6]}, points[34].comp[1].Tc, T[34], 10000.0) + */ +void Graph_eqFunction_866(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,866}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9280], (modelica_real)data->simulationInfo->realParameter[9281], (modelica_real)data->simulationInfo->realParameter[9282], (modelica_real)data->simulationInfo->realParameter[9283], (modelica_real)data->simulationInfo->realParameter[9284], (modelica_real)data->simulationInfo->realParameter[9285]); + data->localData[0]->realVars[860] /* points[34]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11030], data->localData[0]->realVars[233] /* T[34] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_867(DATA*,threadData_t*); +void Graph_eqFunction_868(DATA*,threadData_t*); +void Graph_eqFunction_869(DATA*,threadData_t*); +void Graph_eqFunction_870(DATA*,threadData_t*); +void Graph_eqFunction_871(DATA*,threadData_t*); +void Graph_eqFunction_872(DATA*,threadData_t*); +void Graph_eqFunction_873(DATA*,threadData_t*); +void Graph_eqFunction_874(DATA*,threadData_t*); +void Graph_eqFunction_875(DATA*,threadData_t*); +void Graph_eqFunction_876(DATA*,threadData_t*); +void Graph_eqFunction_877(DATA*,threadData_t*); +void Graph_eqFunction_878(DATA*,threadData_t*); +void Graph_eqFunction_879(DATA*,threadData_t*); +void Graph_eqFunction_880(DATA*,threadData_t*); +void Graph_eqFunction_881(DATA*,threadData_t*); +void Graph_eqFunction_882(DATA*,threadData_t*); +void Graph_eqFunction_883(DATA*,threadData_t*); +/* + equation index: 884 + indexNonlinear: 34 + type: NONLINEAR + + vars: {T[35]} + eqns: {867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 881, 882, 883} + */ +void Graph_eqFunction_884(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,884}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 884 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[34].nlsxOld[0] = data->localData[0]->realVars[234] /* T[35] variable */; + retValue = solve_nonlinear_system(data, threadData, 34); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,884}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 884 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[234] /* T[35] variable */ = data->simulationInfo->nonlinearSystemData[34].nlsx[0]; + TRACE_POP +} + +/* + equation index: 885 + type: SIMPLE_ASSIGN + y[35,1] = 1.0 - 0.1282051282051282 * points[35].K[2] + */ +void Graph_eqFunction_885(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,885}; + data->localData[0]->realVars[1102] /* y[35,1] variable */ = 1.0 - ((0.1282051282051282) * (data->localData[0]->realVars[784] /* points[35]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 886 + type: SIMPLE_ASSIGN + y[35,2] = 0.1282051282051282 * points[35].K[2] + */ +void Graph_eqFunction_886(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,886}; + data->localData[0]->realVars[1103] /* y[35,2] variable */ = (0.1282051282051282) * (data->localData[0]->realVars[784] /* points[35]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 887 + type: SIMPLE_ASSIGN + points[35]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[35].comp[2].LiqDen[1], points[35].comp[2].LiqDen[2], points[35].comp[2].LiqDen[3], points[35].comp[2].LiqDen[4], points[35].comp[2].LiqDen[5], points[35].comp[2].LiqDen[6]}, points[35].comp[2].Tc, T[35], 10000.0) + */ +void Graph_eqFunction_887(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,887}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9298], (modelica_real)data->simulationInfo->realParameter[9299], (modelica_real)data->simulationInfo->realParameter[9300], (modelica_real)data->simulationInfo->realParameter[9301], (modelica_real)data->simulationInfo->realParameter[9302], (modelica_real)data->simulationInfo->realParameter[9303]); + data->localData[0]->realVars[863] /* points[35]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11033], data->localData[0]->realVars[234] /* T[35] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 888 + type: SIMPLE_ASSIGN + points[35]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[35].comp[1].LiqDen[1], points[35].comp[1].LiqDen[2], points[35].comp[1].LiqDen[3], points[35].comp[1].LiqDen[4], points[35].comp[1].LiqDen[5], points[35].comp[1].LiqDen[6]}, points[35].comp[1].Tc, T[35], 10000.0) + */ +void Graph_eqFunction_888(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,888}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9292], (modelica_real)data->simulationInfo->realParameter[9293], (modelica_real)data->simulationInfo->realParameter[9294], (modelica_real)data->simulationInfo->realParameter[9295], (modelica_real)data->simulationInfo->realParameter[9296], (modelica_real)data->simulationInfo->realParameter[9297]); + data->localData[0]->realVars[862] /* points[35]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11032], data->localData[0]->realVars[234] /* T[35] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_889(DATA*,threadData_t*); +void Graph_eqFunction_890(DATA*,threadData_t*); +void Graph_eqFunction_891(DATA*,threadData_t*); +void Graph_eqFunction_892(DATA*,threadData_t*); +void Graph_eqFunction_893(DATA*,threadData_t*); +void Graph_eqFunction_894(DATA*,threadData_t*); +void Graph_eqFunction_895(DATA*,threadData_t*); +void Graph_eqFunction_896(DATA*,threadData_t*); +void Graph_eqFunction_897(DATA*,threadData_t*); +void Graph_eqFunction_898(DATA*,threadData_t*); +void Graph_eqFunction_899(DATA*,threadData_t*); +void Graph_eqFunction_900(DATA*,threadData_t*); +void Graph_eqFunction_901(DATA*,threadData_t*); +void Graph_eqFunction_902(DATA*,threadData_t*); +void Graph_eqFunction_903(DATA*,threadData_t*); +void Graph_eqFunction_904(DATA*,threadData_t*); +void Graph_eqFunction_905(DATA*,threadData_t*); +/* + equation index: 906 + indexNonlinear: 35 + type: NONLINEAR + + vars: {T[36]} + eqns: {889, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905} + */ +void Graph_eqFunction_906(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,906}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 906 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[35].nlsxOld[0] = data->localData[0]->realVars[235] /* T[36] variable */; + retValue = solve_nonlinear_system(data, threadData, 35); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,906}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 906 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[235] /* T[36] variable */ = data->simulationInfo->nonlinearSystemData[35].nlsx[0]; + TRACE_POP +} + +/* + equation index: 907 + type: SIMPLE_ASSIGN + y[36,1] = 1.0 - 0.1025641025641025 * points[36].K[2] + */ +void Graph_eqFunction_907(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,907}; + data->localData[0]->realVars[1104] /* y[36,1] variable */ = 1.0 - ((0.1025641025641025) * (data->localData[0]->realVars[786] /* points[36]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 908 + type: SIMPLE_ASSIGN + y[36,2] = 0.1025641025641025 * points[36].K[2] + */ +void Graph_eqFunction_908(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,908}; + data->localData[0]->realVars[1105] /* y[36,2] variable */ = (0.1025641025641025) * (data->localData[0]->realVars[786] /* points[36]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 909 + type: SIMPLE_ASSIGN + points[36]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[36].comp[2].LiqDen[1], points[36].comp[2].LiqDen[2], points[36].comp[2].LiqDen[3], points[36].comp[2].LiqDen[4], points[36].comp[2].LiqDen[5], points[36].comp[2].LiqDen[6]}, points[36].comp[2].Tc, T[36], 10000.0) + */ +void Graph_eqFunction_909(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,909}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9310], (modelica_real)data->simulationInfo->realParameter[9311], (modelica_real)data->simulationInfo->realParameter[9312], (modelica_real)data->simulationInfo->realParameter[9313], (modelica_real)data->simulationInfo->realParameter[9314], (modelica_real)data->simulationInfo->realParameter[9315]); + data->localData[0]->realVars[865] /* points[36]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11035], data->localData[0]->realVars[235] /* T[36] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 910 + type: SIMPLE_ASSIGN + points[36]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[36].comp[1].LiqDen[1], points[36].comp[1].LiqDen[2], points[36].comp[1].LiqDen[3], points[36].comp[1].LiqDen[4], points[36].comp[1].LiqDen[5], points[36].comp[1].LiqDen[6]}, points[36].comp[1].Tc, T[36], 10000.0) + */ +void Graph_eqFunction_910(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,910}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9304], (modelica_real)data->simulationInfo->realParameter[9305], (modelica_real)data->simulationInfo->realParameter[9306], (modelica_real)data->simulationInfo->realParameter[9307], (modelica_real)data->simulationInfo->realParameter[9308], (modelica_real)data->simulationInfo->realParameter[9309]); + data->localData[0]->realVars[864] /* points[36]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11034], data->localData[0]->realVars[235] /* T[36] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_911(DATA*,threadData_t*); +void Graph_eqFunction_912(DATA*,threadData_t*); +void Graph_eqFunction_913(DATA*,threadData_t*); +void Graph_eqFunction_914(DATA*,threadData_t*); +void Graph_eqFunction_915(DATA*,threadData_t*); +void Graph_eqFunction_916(DATA*,threadData_t*); +void Graph_eqFunction_917(DATA*,threadData_t*); +void Graph_eqFunction_918(DATA*,threadData_t*); +void Graph_eqFunction_919(DATA*,threadData_t*); +void Graph_eqFunction_920(DATA*,threadData_t*); +void Graph_eqFunction_921(DATA*,threadData_t*); +void Graph_eqFunction_922(DATA*,threadData_t*); +void Graph_eqFunction_923(DATA*,threadData_t*); +void Graph_eqFunction_924(DATA*,threadData_t*); +void Graph_eqFunction_925(DATA*,threadData_t*); +void Graph_eqFunction_926(DATA*,threadData_t*); +void Graph_eqFunction_927(DATA*,threadData_t*); +/* + equation index: 928 + indexNonlinear: 36 + type: NONLINEAR + + vars: {T[37]} + eqns: {911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927} + */ +void Graph_eqFunction_928(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,928}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 928 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[36].nlsxOld[0] = data->localData[0]->realVars[236] /* T[37] variable */; + retValue = solve_nonlinear_system(data, threadData, 36); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,928}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 928 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[236] /* T[37] variable */ = data->simulationInfo->nonlinearSystemData[36].nlsx[0]; + TRACE_POP +} + +/* + equation index: 929 + type: SIMPLE_ASSIGN + y[37,1] = 1.0 - 0.07692307692307687 * points[37].K[2] + */ +void Graph_eqFunction_929(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,929}; + data->localData[0]->realVars[1106] /* y[37,1] variable */ = 1.0 - ((0.07692307692307687) * (data->localData[0]->realVars[788] /* points[37]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 930 + type: SIMPLE_ASSIGN + y[37,2] = 0.07692307692307687 * points[37].K[2] + */ +void Graph_eqFunction_930(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,930}; + data->localData[0]->realVars[1107] /* y[37,2] variable */ = (0.07692307692307687) * (data->localData[0]->realVars[788] /* points[37]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 931 + type: SIMPLE_ASSIGN + points[37]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[37].comp[2].LiqDen[1], points[37].comp[2].LiqDen[2], points[37].comp[2].LiqDen[3], points[37].comp[2].LiqDen[4], points[37].comp[2].LiqDen[5], points[37].comp[2].LiqDen[6]}, points[37].comp[2].Tc, T[37], 10000.0) + */ +void Graph_eqFunction_931(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,931}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9322], (modelica_real)data->simulationInfo->realParameter[9323], (modelica_real)data->simulationInfo->realParameter[9324], (modelica_real)data->simulationInfo->realParameter[9325], (modelica_real)data->simulationInfo->realParameter[9326], (modelica_real)data->simulationInfo->realParameter[9327]); + data->localData[0]->realVars[867] /* points[37]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11037], data->localData[0]->realVars[236] /* T[37] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 932 + type: SIMPLE_ASSIGN + points[37]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[37].comp[1].LiqDen[1], points[37].comp[1].LiqDen[2], points[37].comp[1].LiqDen[3], points[37].comp[1].LiqDen[4], points[37].comp[1].LiqDen[5], points[37].comp[1].LiqDen[6]}, points[37].comp[1].Tc, T[37], 10000.0) + */ +void Graph_eqFunction_932(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,932}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9316], (modelica_real)data->simulationInfo->realParameter[9317], (modelica_real)data->simulationInfo->realParameter[9318], (modelica_real)data->simulationInfo->realParameter[9319], (modelica_real)data->simulationInfo->realParameter[9320], (modelica_real)data->simulationInfo->realParameter[9321]); + data->localData[0]->realVars[866] /* points[37]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11036], data->localData[0]->realVars[236] /* T[37] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_933(DATA*,threadData_t*); +void Graph_eqFunction_934(DATA*,threadData_t*); +void Graph_eqFunction_935(DATA*,threadData_t*); +void Graph_eqFunction_936(DATA*,threadData_t*); +void Graph_eqFunction_937(DATA*,threadData_t*); +void Graph_eqFunction_938(DATA*,threadData_t*); +void Graph_eqFunction_939(DATA*,threadData_t*); +void Graph_eqFunction_940(DATA*,threadData_t*); +void Graph_eqFunction_941(DATA*,threadData_t*); +void Graph_eqFunction_942(DATA*,threadData_t*); +void Graph_eqFunction_943(DATA*,threadData_t*); +void Graph_eqFunction_944(DATA*,threadData_t*); +void Graph_eqFunction_945(DATA*,threadData_t*); +void Graph_eqFunction_946(DATA*,threadData_t*); +void Graph_eqFunction_947(DATA*,threadData_t*); +void Graph_eqFunction_948(DATA*,threadData_t*); +void Graph_eqFunction_949(DATA*,threadData_t*); +/* + equation index: 950 + indexNonlinear: 37 + type: NONLINEAR + + vars: {T[38]} + eqns: {933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949} + */ +void Graph_eqFunction_950(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,950}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 950 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[37].nlsxOld[0] = data->localData[0]->realVars[237] /* T[38] variable */; + retValue = solve_nonlinear_system(data, threadData, 37); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,950}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 950 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[237] /* T[38] variable */ = data->simulationInfo->nonlinearSystemData[37].nlsx[0]; + TRACE_POP +} + +/* + equation index: 951 + type: SIMPLE_ASSIGN + y[38,1] = 1.0 - 0.05128205128205132 * points[38].K[2] + */ +void Graph_eqFunction_951(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,951}; + data->localData[0]->realVars[1108] /* y[38,1] variable */ = 1.0 - ((0.05128205128205132) * (data->localData[0]->realVars[790] /* points[38]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 952 + type: SIMPLE_ASSIGN + y[38,2] = 0.05128205128205132 * points[38].K[2] + */ +void Graph_eqFunction_952(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,952}; + data->localData[0]->realVars[1109] /* y[38,2] variable */ = (0.05128205128205132) * (data->localData[0]->realVars[790] /* points[38]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 953 + type: SIMPLE_ASSIGN + points[38]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[38].comp[2].LiqDen[1], points[38].comp[2].LiqDen[2], points[38].comp[2].LiqDen[3], points[38].comp[2].LiqDen[4], points[38].comp[2].LiqDen[5], points[38].comp[2].LiqDen[6]}, points[38].comp[2].Tc, T[38], 10000.0) + */ +void Graph_eqFunction_953(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,953}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9334], (modelica_real)data->simulationInfo->realParameter[9335], (modelica_real)data->simulationInfo->realParameter[9336], (modelica_real)data->simulationInfo->realParameter[9337], (modelica_real)data->simulationInfo->realParameter[9338], (modelica_real)data->simulationInfo->realParameter[9339]); + data->localData[0]->realVars[869] /* points[38]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11039], data->localData[0]->realVars[237] /* T[38] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 954 + type: SIMPLE_ASSIGN + points[38]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[38].comp[1].LiqDen[1], points[38].comp[1].LiqDen[2], points[38].comp[1].LiqDen[3], points[38].comp[1].LiqDen[4], points[38].comp[1].LiqDen[5], points[38].comp[1].LiqDen[6]}, points[38].comp[1].Tc, T[38], 10000.0) + */ +void Graph_eqFunction_954(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,954}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9328], (modelica_real)data->simulationInfo->realParameter[9329], (modelica_real)data->simulationInfo->realParameter[9330], (modelica_real)data->simulationInfo->realParameter[9331], (modelica_real)data->simulationInfo->realParameter[9332], (modelica_real)data->simulationInfo->realParameter[9333]); + data->localData[0]->realVars[868] /* points[38]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11038], data->localData[0]->realVars[237] /* T[38] variable */, 10000.0); + TRACE_POP +} + +void Graph_eqFunction_955(DATA*,threadData_t*); +void Graph_eqFunction_956(DATA*,threadData_t*); +void Graph_eqFunction_957(DATA*,threadData_t*); +void Graph_eqFunction_958(DATA*,threadData_t*); +void Graph_eqFunction_959(DATA*,threadData_t*); +void Graph_eqFunction_960(DATA*,threadData_t*); +void Graph_eqFunction_961(DATA*,threadData_t*); +void Graph_eqFunction_962(DATA*,threadData_t*); +void Graph_eqFunction_963(DATA*,threadData_t*); +void Graph_eqFunction_964(DATA*,threadData_t*); +void Graph_eqFunction_965(DATA*,threadData_t*); +void Graph_eqFunction_966(DATA*,threadData_t*); +void Graph_eqFunction_967(DATA*,threadData_t*); +void Graph_eqFunction_968(DATA*,threadData_t*); +void Graph_eqFunction_969(DATA*,threadData_t*); +void Graph_eqFunction_970(DATA*,threadData_t*); +void Graph_eqFunction_971(DATA*,threadData_t*); +/* + equation index: 972 + indexNonlinear: 38 + type: NONLINEAR + + vars: {T[39]} + eqns: {955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971} + */ +void Graph_eqFunction_972(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,972}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 972 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[38].nlsxOld[0] = data->localData[0]->realVars[238] /* T[39] variable */; + retValue = solve_nonlinear_system(data, threadData, 38); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,972}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 972 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[238] /* T[39] variable */ = data->simulationInfo->nonlinearSystemData[38].nlsx[0]; + TRACE_POP +} + +/* + equation index: 973 + type: SIMPLE_ASSIGN + y[39,1] = 1.0 - 0.02564102564102566 * points[39].K[2] + */ +void Graph_eqFunction_973(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,973}; + data->localData[0]->realVars[1110] /* y[39,1] variable */ = 1.0 - ((0.02564102564102566) * (data->localData[0]->realVars[792] /* points[39]._K[2] variable */)); + TRACE_POP +} + +/* + equation index: 974 + type: SIMPLE_ASSIGN + y[39,2] = 0.02564102564102566 * points[39].K[2] + */ +void Graph_eqFunction_974(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,974}; + data->localData[0]->realVars[1111] /* y[39,2] variable */ = (0.02564102564102566) * (data->localData[0]->realVars[792] /* points[39]._K[2] variable */); + TRACE_POP +} + +/* + equation index: 975 + type: SIMPLE_ASSIGN + points[39]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[39].comp[2].LiqDen[1], points[39].comp[2].LiqDen[2], points[39].comp[2].LiqDen[3], points[39].comp[2].LiqDen[4], points[39].comp[2].LiqDen[5], points[39].comp[2].LiqDen[6]}, points[39].comp[2].Tc, T[39], 10000.0) + */ +void Graph_eqFunction_975(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,975}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9346], (modelica_real)data->simulationInfo->realParameter[9347], (modelica_real)data->simulationInfo->realParameter[9348], (modelica_real)data->simulationInfo->realParameter[9349], (modelica_real)data->simulationInfo->realParameter[9350], (modelica_real)data->simulationInfo->realParameter[9351]); + data->localData[0]->realVars[871] /* points[39]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11041], data->localData[0]->realVars[238] /* T[39] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 976 + type: SIMPLE_ASSIGN + points[39]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[39].comp[1].LiqDen[1], points[39].comp[1].LiqDen[2], points[39].comp[1].LiqDen[3], points[39].comp[1].LiqDen[4], points[39].comp[1].LiqDen[5], points[39].comp[1].LiqDen[6]}, points[39].comp[1].Tc, T[39], 10000.0) + */ +void Graph_eqFunction_976(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,976}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9340], (modelica_real)data->simulationInfo->realParameter[9341], (modelica_real)data->simulationInfo->realParameter[9342], (modelica_real)data->simulationInfo->realParameter[9343], (modelica_real)data->simulationInfo->realParameter[9344], (modelica_real)data->simulationInfo->realParameter[9345]); + data->localData[0]->realVars[870] /* points[39]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11040], data->localData[0]->realVars[238] /* T[39] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 977 + type: SIMPLE_ASSIGN + y[40,1] = 1.0 + */ +void Graph_eqFunction_977(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,977}; + data->localData[0]->realVars[1112] /* y[40,1] variable */ = 1.0; + TRACE_POP +} + +void Graph_eqFunction_978(DATA*,threadData_t*); +void Graph_eqFunction_979(DATA*,threadData_t*); +void Graph_eqFunction_980(DATA*,threadData_t*); +void Graph_eqFunction_981(DATA*,threadData_t*); +void Graph_eqFunction_982(DATA*,threadData_t*); +/* + equation index: 983 + indexNonlinear: 39 + type: NONLINEAR + + vars: {T[40]} + eqns: {978, 979, 980, 981, 982} + */ +void Graph_eqFunction_983(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,983}; + int retValue; + if(ACTIVE_STREAM(LOG_DT)) + { + infoStreamPrint(LOG_DT, 1, "Solving nonlinear system 983 (STRICT TEARING SET if tearing enabled) at time = %18.10e", data->localData[0]->timeValue); + messageClose(LOG_DT); + } + /* get old value */ + data->simulationInfo->nonlinearSystemData[39].nlsxOld[0] = data->localData[0]->realVars[239] /* T[40] variable */; + retValue = solve_nonlinear_system(data, threadData, 39); + /* check if solution process was successful */ + if (retValue > 0){ + const int indexes[2] = {1,983}; + throwStreamPrintWithEquationIndexes(threadData, indexes, "Solving non-linear system 983 failed at time=%.15g.\nFor more information please use -lv LOG_NLS.", data->localData[0]->timeValue); + } + /* write solution */ + data->localData[0]->realVars[239] /* T[40] variable */ = data->simulationInfo->nonlinearSystemData[39].nlsx[0]; + TRACE_POP +} + +/* + equation index: 984 + type: SIMPLE_ASSIGN + points[40]._density[2] = Simulator.Files.ThermodynamicFunctions.Dens({points[40].comp[2].LiqDen[1], points[40].comp[2].LiqDen[2], points[40].comp[2].LiqDen[3], points[40].comp[2].LiqDen[4], points[40].comp[2].LiqDen[5], points[40].comp[2].LiqDen[6]}, points[40].comp[2].Tc, T[40], 10000.0) + */ +void Graph_eqFunction_984(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,984}; + real_array tmp0; + array_alloc_scalar_real_array(&tmp0, 6, (modelica_real)data->simulationInfo->realParameter[9358], (modelica_real)data->simulationInfo->realParameter[9359], (modelica_real)data->simulationInfo->realParameter[9360], (modelica_real)data->simulationInfo->realParameter[9361], (modelica_real)data->simulationInfo->realParameter[9362], (modelica_real)data->simulationInfo->realParameter[9363]); + data->localData[0]->realVars[873] /* points[40]._density[2] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp0, data->simulationInfo->realParameter[11043], data->localData[0]->realVars[239] /* T[40] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 985 + type: SIMPLE_ASSIGN + points[40]._density[1] = Simulator.Files.ThermodynamicFunctions.Dens({points[40].comp[1].LiqDen[1], points[40].comp[1].LiqDen[2], points[40].comp[1].LiqDen[3], points[40].comp[1].LiqDen[4], points[40].comp[1].LiqDen[5], points[40].comp[1].LiqDen[6]}, points[40].comp[1].Tc, T[40], 10000.0) + */ +void Graph_eqFunction_985(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,985}; + real_array tmp1; + array_alloc_scalar_real_array(&tmp1, 6, (modelica_real)data->simulationInfo->realParameter[9352], (modelica_real)data->simulationInfo->realParameter[9353], (modelica_real)data->simulationInfo->realParameter[9354], (modelica_real)data->simulationInfo->realParameter[9355], (modelica_real)data->simulationInfo->realParameter[9356], (modelica_real)data->simulationInfo->realParameter[9357]); + data->localData[0]->realVars[872] /* points[40]._density[1] variable */ = omc_Simulator_Files_ThermodynamicFunctions_Dens(threadData, tmp1, data->simulationInfo->realParameter[11042], data->localData[0]->realVars[239] /* T[40] variable */, 10000.0); + TRACE_POP +} + +/* + equation index: 986 + type: SIMPLE_ASSIGN + points[40]._Gamma._tau[2,2] = 0.5032180796191645 * DIVISION(points[40].BIP[2,2,1], T[40]) + */ +void Graph_eqFunction_986(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,986}; + data->localData[0]->realVars[715] /* points[40]._Gamma._tau[2,2] variable */ = (0.5032180796191645) * (DIVISION_SIM(data->simulationInfo->realParameter[642],data->localData[0]->realVars[239] /* T[40] variable */,"T[40]",equationIndexes)); + TRACE_POP +} + +/* + equation index: 987 + type: SIMPLE_ASSIGN + points[40]._Gamma._G[2,2] = exp((-points[40].BIP[2,2,2]) * points[40].Gamma.tau[2,2]) + */ +void Graph_eqFunction_987(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,987}; + data->localData[0]->realVars[395] /* points[40]._Gamma._G[2,2] variable */ = exp(((-data->simulationInfo->realParameter[643])) * (data->localData[0]->realVars[715] /* points[40]._Gamma._tau[2,2] variable */)); + TRACE_POP +} + +/* + equation index: 988 + type: SIMPLE_ASSIGN + points[40]._Gamma._tau[2,1] = 0.5032180796191645 * DIVISION(points[40].BIP[2,1,1], T[40]) + */ +void Graph_eqFunction_988(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,988}; + data->localData[0]->realVars[714] /* points[40]._Gamma._tau[2,1] variable */ = (0.5032180796191645) * (DIVISION_SIM(data->simulationInfo->realParameter[640],data->localData[0]->realVars[239] /* T[40] variable */,"T[40]",equationIndexes)); + TRACE_POP +} + +/* + equation index: 989 + type: SIMPLE_ASSIGN + points[40]._Gamma._G[2,1] = exp((-points[40].BIP[2,1,2]) * points[40].Gamma.tau[2,1]) + */ +void Graph_eqFunction_989(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,989}; + data->localData[0]->realVars[394] /* points[40]._Gamma._G[2,1] variable */ = exp(((-data->simulationInfo->realParameter[641])) * (data->localData[0]->realVars[714] /* points[40]._Gamma._tau[2,1] variable */)); + TRACE_POP +} + +/* + equation index: 990 + type: SIMPLE_ASSIGN + points[40]._Gamma._tau[1,2] = 0.5032180796191645 * DIVISION(points[40].BIP[1,2,1], T[40]) + */ +void Graph_eqFunction_990(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,990}; + data->localData[0]->realVars[713] /* points[40]._Gamma._tau[1,2] variable */ = (0.5032180796191645) * (DIVISION_SIM(data->simulationInfo->realParameter[638],data->localData[0]->realVars[239] /* T[40] variable */,"T[40]",equationIndexes)); + TRACE_POP +} + +/* + equation index: 991 + type: SIMPLE_ASSIGN + points[40]._Gamma._sum1[2] = exp((-points[40].BIP[1,2,2]) * points[40].Gamma.tau[1,2]) + */ +void Graph_eqFunction_991(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,991}; + data->localData[0]->realVars[475] /* points[40]._Gamma._sum1[2] variable */ = exp(((-data->simulationInfo->realParameter[639])) * (data->localData[0]->realVars[713] /* points[40]._Gamma._tau[1,2] variable */)); + TRACE_POP +} + +/* + equation index: 992 + type: SIMPLE_ASSIGN + points[40]._Gamma._sum2[2] = points[40].Gamma.tau[1,2] * points[40].Gamma.sum1[2] + */ +void Graph_eqFunction_992(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,992}; + data->localData[0]->realVars[555] /* points[40]._Gamma._sum2[2] variable */ = (data->localData[0]->realVars[713] /* points[40]._Gamma._tau[1,2] variable */) * (data->localData[0]->realVars[475] /* points[40]._Gamma._sum1[2] variable */); + TRACE_POP +} + +/* + equation index: 993 + type: SIMPLE_ASSIGN + points[40]._gamma[2] = exp(DIVISION(points[40].Gamma.sum2[2], points[40].Gamma.sum1[2]) + points[40].Gamma.G[2,1] * DIVISION(points[40].Gamma.tau[2,1] - DIVISION(points[40].Gamma.sum2[1], points[40].Gamma.sum1[1]), points[40].Gamma.sum1[1])) + */ +void Graph_eqFunction_993(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,993}; + data->localData[0]->realVars[953] /* points[40]._gamma[2] variable */ = exp(DIVISION_SIM(data->localData[0]->realVars[555] /* points[40]._Gamma._sum2[2] variable */,data->localData[0]->realVars[475] /* points[40]._Gamma._sum1[2] variable */,"points[40].Gamma.sum1[2]",equationIndexes) + (data->localData[0]->realVars[394] /* points[40]._Gamma._G[2,1] variable */) * (DIVISION_SIM(data->localData[0]->realVars[714] /* points[40]._Gamma._tau[2,1] variable */ - DIVISION_SIM(data->localData[0]->realVars[554] /* points[40]._Gamma._sum2[1] variable */,data->localData[0]->realVars[474] /* points[40]._Gamma._sum1[1] variable */,"points[40].Gamma.sum1[1]",equationIndexes),data->localData[0]->realVars[474] /* points[40]._Gamma._sum1[1] variable */,"points[40].Gamma.sum1[1]",equationIndexes))); + TRACE_POP +} + +/* + equation index: 994 + type: SIMPLE_ASSIGN + points[40]._K[2] = 0.0001 * points[40].gamma[2] * Simulator.Files.ThermodynamicFunctions.Psat({points[40].comp[2].VP[1], points[40].comp[2].VP[2], points[40].comp[2].VP[3], points[40].comp[2].VP[4], points[40].comp[2].VP[5], points[40].comp[2].VP[6]}, T[40]) + */ +void Graph_eqFunction_994(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int equationIndexes[2] = {1,994}; + real_array tmp2; + array_alloc_scalar_real_array(&tmp2, 6, (modelica_real)data->simulationInfo->realParameter[11758], (modelica_real)data->simulationInfo->realParameter[11759], (modelica_real)data->simulationInfo->realParameter[11760], (modelica_real)data->simulationInfo->realParameter[11761], (modelica_real)data->simulationInfo->realParameter[11762], (modelica_real)data->simulationInfo->realParameter[11763]); + data->localData[0]->realVars[793] /* points[40]._K[2] variable */ = (0.0001) * ((data->localData[0]->realVars[953] /* points[40]._gamma[2] variable */) * (omc_Simulator_Files_ThermodynamicFunctions_Psat(threadData, tmp2, data->localData[0]->realVars[239] /* T[40] variable */))); + TRACE_POP +} +void Graph_functionInitialEquations_0(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + Graph_eqFunction_1(data, threadData); + Graph_eqFunction_2(data, threadData); + Graph_eqFunction_3(data, threadData); + Graph_eqFunction_4(data, threadData); + Graph_eqFunction_5(data, threadData); + Graph_eqFunction_6(data, threadData); + Graph_eqFunction_7(data, threadData); + Graph_eqFunction_8(data, threadData); + Graph_eqFunction_9(data, threadData); + Graph_eqFunction_10(data, threadData); + Graph_eqFunction_11(data, threadData); + Graph_eqFunction_12(data, threadData); + Graph_eqFunction_13(data, threadData); + Graph_eqFunction_14(data, threadData); + Graph_eqFunction_15(data, threadData); + Graph_eqFunction_16(data, threadData); + Graph_eqFunction_17(data, threadData); + Graph_eqFunction_18(data, threadData); + Graph_eqFunction_19(data, threadData); + Graph_eqFunction_20(data, threadData); + Graph_eqFunction_21(data, threadData); + Graph_eqFunction_22(data, threadData); + Graph_eqFunction_23(data, threadData); + Graph_eqFunction_24(data, threadData); + Graph_eqFunction_25(data, threadData); + Graph_eqFunction_26(data, threadData); + Graph_eqFunction_27(data, threadData); + Graph_eqFunction_28(data, threadData); + Graph_eqFunction_29(data, threadData); + Graph_eqFunction_30(data, threadData); + Graph_eqFunction_31(data, threadData); + Graph_eqFunction_32(data, threadData); + Graph_eqFunction_33(data, threadData); + Graph_eqFunction_34(data, threadData); + Graph_eqFunction_35(data, threadData); + Graph_eqFunction_36(data, threadData); + Graph_eqFunction_37(data, threadData); + Graph_eqFunction_38(data, threadData); + Graph_eqFunction_39(data, threadData); + Graph_eqFunction_40(data, threadData); + Graph_eqFunction_41(data, threadData); + Graph_eqFunction_42(data, threadData); + Graph_eqFunction_43(data, threadData); + Graph_eqFunction_44(data, threadData); + Graph_eqFunction_45(data, threadData); + Graph_eqFunction_46(data, threadData); + Graph_eqFunction_47(data, threadData); + Graph_eqFunction_48(data, threadData); + Graph_eqFunction_49(data, threadData); + Graph_eqFunction_50(data, threadData); + Graph_eqFunction_51(data, threadData); + Graph_eqFunction_52(data, threadData); + Graph_eqFunction_53(data, threadData); + Graph_eqFunction_54(data, threadData); + Graph_eqFunction_55(data, threadData); + Graph_eqFunction_56(data, threadData); + Graph_eqFunction_57(data, threadData); + Graph_eqFunction_58(data, threadData); + Graph_eqFunction_59(data, threadData); + Graph_eqFunction_60(data, threadData); + Graph_eqFunction_61(data, threadData); + Graph_eqFunction_62(data, threadData); + Graph_eqFunction_63(data, threadData); + Graph_eqFunction_64(data, threadData); + Graph_eqFunction_65(data, threadData); + Graph_eqFunction_66(data, threadData); + Graph_eqFunction_67(data, threadData); + Graph_eqFunction_68(data, threadData); + Graph_eqFunction_69(data, threadData); + Graph_eqFunction_70(data, threadData); + Graph_eqFunction_71(data, threadData); + Graph_eqFunction_72(data, threadData); + Graph_eqFunction_73(data, threadData); + Graph_eqFunction_74(data, threadData); + Graph_eqFunction_75(data, threadData); + Graph_eqFunction_76(data, threadData); + Graph_eqFunction_77(data, threadData); + Graph_eqFunction_78(data, threadData); + Graph_eqFunction_79(data, threadData); + Graph_eqFunction_80(data, threadData); + Graph_eqFunction_81(data, threadData); + Graph_eqFunction_82(data, threadData); + Graph_eqFunction_83(data, threadData); + Graph_eqFunction_84(data, threadData); + Graph_eqFunction_85(data, threadData); + Graph_eqFunction_86(data, threadData); + Graph_eqFunction_87(data, threadData); + Graph_eqFunction_88(data, threadData); + Graph_eqFunction_89(data, threadData); + Graph_eqFunction_90(data, threadData); + Graph_eqFunction_91(data, threadData); + Graph_eqFunction_92(data, threadData); + Graph_eqFunction_93(data, threadData); + Graph_eqFunction_94(data, threadData); + Graph_eqFunction_95(data, threadData); + Graph_eqFunction_96(data, threadData); + Graph_eqFunction_97(data, threadData); + Graph_eqFunction_98(data, threadData); + Graph_eqFunction_99(data, threadData); + Graph_eqFunction_100(data, threadData); + Graph_eqFunction_101(data, threadData); + Graph_eqFunction_102(data, threadData); + Graph_eqFunction_103(data, threadData); + Graph_eqFunction_104(data, threadData); + Graph_eqFunction_105(data, threadData); + Graph_eqFunction_106(data, threadData); + Graph_eqFunction_107(data, threadData); + Graph_eqFunction_108(data, threadData); + Graph_eqFunction_109(data, threadData); + Graph_eqFunction_110(data, threadData); + Graph_eqFunction_111(data, threadData); + Graph_eqFunction_112(data, threadData); + Graph_eqFunction_113(data, threadData); + Graph_eqFunction_114(data, threadData); + Graph_eqFunction_115(data, threadData); + Graph_eqFunction_116(data, threadData); + Graph_eqFunction_117(data, threadData); + Graph_eqFunction_118(data, threadData); + Graph_eqFunction_119(data, threadData); + Graph_eqFunction_120(data, threadData); + Graph_eqFunction_121(data, threadData); + Graph_eqFunction_122(data, threadData); + Graph_eqFunction_123(data, threadData); + Graph_eqFunction_129(data, threadData); + Graph_eqFunction_130(data, threadData); + Graph_eqFunction_131(data, threadData); + Graph_eqFunction_132(data, threadData); + Graph_eqFunction_133(data, threadData); + Graph_eqFunction_134(data, threadData); + Graph_eqFunction_135(data, threadData); + Graph_eqFunction_136(data, threadData); + Graph_eqFunction_137(data, threadData); + Graph_eqFunction_138(data, threadData); + Graph_eqFunction_139(data, threadData); + Graph_eqFunction_140(data, threadData); + Graph_eqFunction_158(data, threadData); + Graph_eqFunction_159(data, threadData); + Graph_eqFunction_160(data, threadData); + Graph_eqFunction_161(data, threadData); + Graph_eqFunction_162(data, threadData); + Graph_eqFunction_180(data, threadData); + Graph_eqFunction_181(data, threadData); + Graph_eqFunction_182(data, threadData); + Graph_eqFunction_183(data, threadData); + Graph_eqFunction_184(data, threadData); + Graph_eqFunction_202(data, threadData); + Graph_eqFunction_203(data, threadData); + Graph_eqFunction_204(data, threadData); + Graph_eqFunction_205(data, threadData); + Graph_eqFunction_206(data, threadData); + Graph_eqFunction_224(data, threadData); + Graph_eqFunction_225(data, threadData); + Graph_eqFunction_226(data, threadData); + Graph_eqFunction_227(data, threadData); + Graph_eqFunction_228(data, threadData); + Graph_eqFunction_246(data, threadData); + Graph_eqFunction_247(data, threadData); + Graph_eqFunction_248(data, threadData); + Graph_eqFunction_249(data, threadData); + Graph_eqFunction_250(data, threadData); + Graph_eqFunction_268(data, threadData); + Graph_eqFunction_269(data, threadData); + Graph_eqFunction_270(data, threadData); + Graph_eqFunction_271(data, threadData); + Graph_eqFunction_272(data, threadData); + Graph_eqFunction_290(data, threadData); + Graph_eqFunction_291(data, threadData); + Graph_eqFunction_292(data, threadData); + Graph_eqFunction_293(data, threadData); + Graph_eqFunction_294(data, threadData); + Graph_eqFunction_312(data, threadData); + Graph_eqFunction_313(data, threadData); + Graph_eqFunction_314(data, threadData); + Graph_eqFunction_315(data, threadData); + Graph_eqFunction_316(data, threadData); + Graph_eqFunction_334(data, threadData); + Graph_eqFunction_335(data, threadData); + Graph_eqFunction_336(data, threadData); + Graph_eqFunction_337(data, threadData); + Graph_eqFunction_338(data, threadData); + Graph_eqFunction_356(data, threadData); + Graph_eqFunction_357(data, threadData); + Graph_eqFunction_358(data, threadData); + Graph_eqFunction_359(data, threadData); + Graph_eqFunction_360(data, threadData); + Graph_eqFunction_378(data, threadData); + Graph_eqFunction_379(data, threadData); + Graph_eqFunction_380(data, threadData); + Graph_eqFunction_381(data, threadData); + Graph_eqFunction_382(data, threadData); + Graph_eqFunction_400(data, threadData); + Graph_eqFunction_401(data, threadData); + Graph_eqFunction_402(data, threadData); + Graph_eqFunction_403(data, threadData); + Graph_eqFunction_404(data, threadData); + Graph_eqFunction_422(data, threadData); + Graph_eqFunction_423(data, threadData); + Graph_eqFunction_424(data, threadData); + Graph_eqFunction_425(data, threadData); + Graph_eqFunction_426(data, threadData); + Graph_eqFunction_444(data, threadData); + Graph_eqFunction_445(data, threadData); + Graph_eqFunction_446(data, threadData); + Graph_eqFunction_447(data, threadData); + Graph_eqFunction_448(data, threadData); + Graph_eqFunction_466(data, threadData); + Graph_eqFunction_467(data, threadData); + Graph_eqFunction_468(data, threadData); + Graph_eqFunction_469(data, threadData); + Graph_eqFunction_470(data, threadData); + Graph_eqFunction_488(data, threadData); + Graph_eqFunction_489(data, threadData); + Graph_eqFunction_490(data, threadData); + Graph_eqFunction_491(data, threadData); + Graph_eqFunction_492(data, threadData); + Graph_eqFunction_510(data, threadData); + Graph_eqFunction_511(data, threadData); + Graph_eqFunction_512(data, threadData); + Graph_eqFunction_513(data, threadData); + Graph_eqFunction_514(data, threadData); + Graph_eqFunction_532(data, threadData); + Graph_eqFunction_533(data, threadData); + Graph_eqFunction_534(data, threadData); + Graph_eqFunction_535(data, threadData); + Graph_eqFunction_536(data, threadData); + Graph_eqFunction_554(data, threadData); + Graph_eqFunction_555(data, threadData); + Graph_eqFunction_556(data, threadData); + Graph_eqFunction_557(data, threadData); + Graph_eqFunction_558(data, threadData); + Graph_eqFunction_576(data, threadData); + Graph_eqFunction_577(data, threadData); + Graph_eqFunction_578(data, threadData); + Graph_eqFunction_579(data, threadData); + Graph_eqFunction_580(data, threadData); + Graph_eqFunction_598(data, threadData); + Graph_eqFunction_599(data, threadData); + Graph_eqFunction_600(data, threadData); + Graph_eqFunction_601(data, threadData); + Graph_eqFunction_602(data, threadData); + Graph_eqFunction_620(data, threadData); + Graph_eqFunction_621(data, threadData); + Graph_eqFunction_622(data, threadData); + Graph_eqFunction_623(data, threadData); + Graph_eqFunction_624(data, threadData); + Graph_eqFunction_642(data, threadData); + Graph_eqFunction_643(data, threadData); + Graph_eqFunction_644(data, threadData); + Graph_eqFunction_645(data, threadData); + Graph_eqFunction_646(data, threadData); + Graph_eqFunction_664(data, threadData); + Graph_eqFunction_665(data, threadData); + Graph_eqFunction_666(data, threadData); + Graph_eqFunction_667(data, threadData); + Graph_eqFunction_668(data, threadData); + Graph_eqFunction_686(data, threadData); + Graph_eqFunction_687(data, threadData); + Graph_eqFunction_688(data, threadData); + Graph_eqFunction_689(data, threadData); + Graph_eqFunction_690(data, threadData); + Graph_eqFunction_708(data, threadData); + Graph_eqFunction_709(data, threadData); + Graph_eqFunction_710(data, threadData); + Graph_eqFunction_711(data, threadData); + Graph_eqFunction_712(data, threadData); + Graph_eqFunction_730(data, threadData); + Graph_eqFunction_731(data, threadData); + Graph_eqFunction_732(data, threadData); + Graph_eqFunction_733(data, threadData); + Graph_eqFunction_734(data, threadData); + Graph_eqFunction_752(data, threadData); + Graph_eqFunction_753(data, threadData); + Graph_eqFunction_754(data, threadData); + Graph_eqFunction_755(data, threadData); + Graph_eqFunction_756(data, threadData); + Graph_eqFunction_774(data, threadData); + Graph_eqFunction_775(data, threadData); + Graph_eqFunction_776(data, threadData); + Graph_eqFunction_777(data, threadData); + Graph_eqFunction_778(data, threadData); + Graph_eqFunction_796(data, threadData); + Graph_eqFunction_797(data, threadData); + Graph_eqFunction_798(data, threadData); + Graph_eqFunction_799(data, threadData); + Graph_eqFunction_800(data, threadData); + Graph_eqFunction_818(data, threadData); + Graph_eqFunction_819(data, threadData); + Graph_eqFunction_820(data, threadData); + Graph_eqFunction_821(data, threadData); + Graph_eqFunction_822(data, threadData); + Graph_eqFunction_840(data, threadData); + Graph_eqFunction_841(data, threadData); + Graph_eqFunction_842(data, threadData); + Graph_eqFunction_843(data, threadData); + Graph_eqFunction_844(data, threadData); + Graph_eqFunction_862(data, threadData); + Graph_eqFunction_863(data, threadData); + Graph_eqFunction_864(data, threadData); + Graph_eqFunction_865(data, threadData); + Graph_eqFunction_866(data, threadData); + Graph_eqFunction_884(data, threadData); + Graph_eqFunction_885(data, threadData); + Graph_eqFunction_886(data, threadData); + Graph_eqFunction_887(data, threadData); + Graph_eqFunction_888(data, threadData); + Graph_eqFunction_906(data, threadData); + Graph_eqFunction_907(data, threadData); + Graph_eqFunction_908(data, threadData); + Graph_eqFunction_909(data, threadData); + Graph_eqFunction_910(data, threadData); + Graph_eqFunction_928(data, threadData); + Graph_eqFunction_929(data, threadData); + Graph_eqFunction_930(data, threadData); + Graph_eqFunction_931(data, threadData); + Graph_eqFunction_932(data, threadData); + Graph_eqFunction_950(data, threadData); + Graph_eqFunction_951(data, threadData); + Graph_eqFunction_952(data, threadData); + Graph_eqFunction_953(data, threadData); + Graph_eqFunction_954(data, threadData); + Graph_eqFunction_972(data, threadData); + Graph_eqFunction_973(data, threadData); + Graph_eqFunction_974(data, threadData); + Graph_eqFunction_975(data, threadData); + Graph_eqFunction_976(data, threadData); + Graph_eqFunction_977(data, threadData); + Graph_eqFunction_983(data, threadData); + Graph_eqFunction_984(data, threadData); + Graph_eqFunction_985(data, threadData); + Graph_eqFunction_986(data, threadData); + Graph_eqFunction_987(data, threadData); + Graph_eqFunction_988(data, threadData); + Graph_eqFunction_989(data, threadData); + Graph_eqFunction_990(data, threadData); + Graph_eqFunction_991(data, threadData); + Graph_eqFunction_992(data, threadData); + Graph_eqFunction_993(data, threadData); + Graph_eqFunction_994(data, threadData); + TRACE_POP +} + + +int Graph_functionInitialEquations(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + + data->simulationInfo->discreteCall = 1; + Graph_functionInitialEquations_0(data, threadData); + data->simulationInfo->discreteCall = 0; + + TRACE_POP + return 0; +} + + +int Graph_functionInitialEquations_lambda0(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + + data->simulationInfo->discreteCall = 1; + data->simulationInfo->discreteCall = 0; + + TRACE_POP + return 0; +} +int Graph_functionRemovedInitialEquations(DATA *data, threadData_t *threadData) +{ + TRACE_PUSH + const int *equationIndexes = NULL; + double res = 0.0; + + + TRACE_POP + return 0; +} + + +#if defined(__cplusplus) +} +#endif + |