gerrit.simantics Code Review - simantics/sysdyn.git/blob

   1 /* Simulation code for FMUCallBeforeInitializationTestModel generated by the OpenModelica Compiler 1.8.1+ (r11690). */\r
   2 \r
   3 #include "openmodelica.h"\r
   4 #include "openmodelica_func.h"\r
   5 #include "simulation_data.h"\r
   6 #include "simulation_runtime.h"\r
   7 #include "omc_error.h"\r
   8 \r
   9 #include <assert.h>\r
  10 #include <string.h>\r
  11 \r
  12 #include "FMUCallBeforeInitializationTestModel_functions.h"\r
  13 \r
  14 #include "_FMUCallBeforeInitializationTestModel.h"\r
  15 #include "FMUCallBeforeInitializationTestModel_functions.c"\r
  16 /* dummy VARINFO and FILEINFO */\r
  17 const FILE_INFO dummyFILE_INFO = {"",-1,-1,-1,-1,1};\r
  18 const VAR_INFO dummyVAR_INFO = {-1,"","",(FILE_INFO){"",-1,-1,-1,-1,1}};\r
  19 #ifdef __cplusplus\r
  20 extern "C" {\r
  21 #endif\r
  22 #ifdef _OMC_MEASURE_TIME\r
  23 int measure_time_flag = 1;\r
  24 #else\r
  25 int measure_time_flag = 0;\r
  26 #endif\r
  27 \r
  28 void setupDataStruc(DATA *data)\r
  29 {\r
  30   ASSERT(data,"Error while initialize Data");\r
  31   data->modelData.modelName = "FMUCallBeforeInitializationTestModel";\r
  32   data->modelData.modelFilePrefix = "FMUCallBeforeInitializationTestModel";\r
  33   data->modelData.modelDir = "";\r
  34   data->modelData.modelGUID = "{f4c1919a-ebce-4a1a-baca-8e57e23985cf}";\r
  35   \r
  36   data->modelData.nStates = 3;\r
  37   data->modelData.nVariablesReal = 2*3+3;\r
  38   data->modelData.nVariablesInteger = 0;\r
  39   data->modelData.nVariablesBoolean = 0;\r
  40   data->modelData.nVariablesString = 0;\r
  41   data->modelData.nParametersReal = 2;\r
  42   data->modelData.nParametersInteger = 1;\r
  43   data->modelData.nParametersBoolean = 1;\r
  44   data->modelData.nParametersString = 0;\r
  45   data->modelData.nInputVars = 0;\r
  46   data->modelData.nOutputVars = 0;\r
  47   data->modelData.nJacobians = 4;\r
  48   data->modelData.nHelpVars = 0;\r
  49   \r
  50   data->modelData.nAliasReal = 0;\r
  51   data->modelData.nAliasInteger = 0;\r
  52   data->modelData.nAliasBoolean = 0;\r
  53   data->modelData.nAliasString = 0;\r
  54   \r
  55   data->modelData.nZeroCrossings = 0;\r
  56   data->modelData.nSamples = 0;\r
  57   data->modelData.nInitEquations = 0;\r
  58   data->modelData.nResiduals = 3;\r
  59   data->modelData.nExtObjs = 0;\r
  60   data->modelData.nFunctions = 0;\r
  61   data->modelData.nEquations = 12;\r
  62   \r
  63   data->modelData.nDelayExpressions = 0;\r
  64   \r
  65 }\r
  66 \r
  67 void setupDataStruc2(DATA *data)\r
  68 {\r
  69   const struct FUNCTION_INFO funcInfo[1] = {{-1,"",omc_dummyFileInfo}};\r
  70   memcpy(data->modelData.functionNames, &funcInfo, data->modelData.nFunctions*sizeof(FUNCTION_INFO));\r
  71   \r
  72   const VAR_INFO** equationInfo_cref1 = (const VAR_INFO**)calloc(1,sizeof(VAR_INFO*));\r
  73   equationInfo_cref1[0] = &$PvalveReal__varInfo;\r
  74   const VAR_INFO** equationInfo_cref3 = (const VAR_INFO**)calloc(1,sizeof(VAR_INFO*));\r
  75   equationInfo_cref3[0] = &$P$DER$PstockReal__varInfo;\r
  76   const VAR_INFO** equationInfo_cref5 = (const VAR_INFO**)calloc(1,sizeof(VAR_INFO*));\r
  77   equationInfo_cref5[0] = &$PvalveInteger__varInfo;\r
  78   const VAR_INFO** equationInfo_cref7 = (const VAR_INFO**)calloc(1,sizeof(VAR_INFO*));\r
  79   equationInfo_cref7[0] = &$P$DER$PstockInteger__varInfo;\r
  80   const VAR_INFO** equationInfo_cref9 = (const VAR_INFO**)calloc(1,sizeof(VAR_INFO*));\r
  81   equationInfo_cref9[0] = &$PvalveBoolean__varInfo;\r
  82   const VAR_INFO** equationInfo_cref11 = (const VAR_INFO**)calloc(1,sizeof(VAR_INFO*));\r
  83   equationInfo_cref11[0] = &$P$DER$PstockBoolean__varInfo;\r
  84   const struct EQUATION_INFO equationInfo[12] = {\r
  85     {1009,"SES_ALGORITHM 0", 0, NULL},\r
  86     {1010,"SES_SIMPLE_ASSIGN 1",1,equationInfo_cref1},\r
  87     {1011,"SES_ALGORITHM 2", 0, NULL},\r
  88     {1012,"SES_SIMPLE_ASSIGN 3",1,equationInfo_cref3},\r
  89     {1013,"SES_ALGORITHM 4", 0, NULL},\r
  90     {1014,"SES_SIMPLE_ASSIGN 5",1,equationInfo_cref5},\r
  91     {1015,"SES_ALGORITHM 6", 0, NULL},\r
  92     {1016,"SES_SIMPLE_ASSIGN 7",1,equationInfo_cref7},\r
  93     {1017,"SES_ALGORITHM 8", 0, NULL},\r
  94     {1018,"SES_SIMPLE_ASSIGN 9",1,equationInfo_cref9},\r
  95     {1019,"SES_ALGORITHM 10", 0, NULL},\r
  96     {1020,"SES_SIMPLE_ASSIGN 11",1,equationInfo_cref11}\r
  97   };\r
  98   const int n_omc_equationInfo_reverse_prof_index = 0;\r
  99   const int omc_equationInfo_reverse_prof_index[] = {\r
 100     \r
 101   };\r
 102   memcpy(data->modelData.equationInfo, &equationInfo, data->modelData.nEquations*sizeof(EQUATION_INFO));\r
 103   \r
 104   data->modelData.nProfileBlocks = n_omc_equationInfo_reverse_prof_index;\r
 105   data->modelData.equationInfo_reverse_prof_index = (int*) malloc(data->modelData.nProfileBlocks*sizeof(int));\r
 106   memcpy(data->modelData.equationInfo_reverse_prof_index, omc_equationInfo_reverse_prof_index, data->modelData.nProfileBlocks*sizeof(int));\r
 107 }\r
 108 \r
 109 /* Has to be performed after _init.xml file has been read */\r
 110 void callExternalObjectConstructors(DATA *data)\r
 111 {\r
 112   state mem_state;\r
 113   mem_state = get_memory_state();\r
 114   /* data->simulationInfo.extObjs = NULL; */\r
 115 }\r
 116 \r
 117 void callExternalObjectDestructors(DATA *data)\r
 118 {\r
 119   if (data->simulationInfo.extObjs) {\r
 120     free(data->simulationInfo.extObjs);\r
 121     data->simulationInfo.extObjs = 0;\r
 122   }\r
 123 }\r
 124 \r
 125 \r
 126 int input_function(DATA *data)\r
 127 {\r
 128   return 0;\r
 129 }\r
 130 \r
 131 int output_function(DATA *data)\r
 132 {\r
 133   return 0;\r
 134 }\r
 135 \r
 136 /* Initializes the raw time events of the simulation using the now\r
 137    calcualted parameters. */\r
 138 void function_sampleInit(DATA *data)\r
 139 {\r
 140 }\r
 141 \r
 142 int function_updateSample(DATA *data)\r
 143 {\r
 144   state mem_state;\r
 145   \r
 146   mem_state = get_memory_state();\r
 147   restore_memory_state(mem_state);\r
 148   \r
 149   return 0;\r
 150 }\r
 151 \r
 152 int function_storeDelayed(DATA *data)\r
 153 {\r
 154   state mem_state;\r
 155   \r
 156   mem_state = get_memory_state();\r
 157   restore_memory_state(mem_state);\r
 158   \r
 159   return 0;\r
 160 }\r
 161 \r
 162 int updateBoundStartValues(DATA *data)\r
 163 {\r
 164 \r
 165   \r
 166   DEBUG_INFO(LOG_INIT, "updating start-values:");\r
 167   \r
 168   return 0;\r
 169 }\r
 170 \r
 171 int initial_residual(DATA *data, double $P$_lambda, double* initialResiduals)\r
 172 {\r
 173   int i = 0;\r
 174   state mem_state;\r
 175   \r
 176   mem_state = get_memory_state();\r
 177   DEBUG_INFO(LOG_RES_INIT, "updating initial_residuals:");\r
 178   initialResiduals[i++] = ((1.0 - $P$_lambda) * ($PstockReal - $P$START$PstockReal));\r
 179   DEBUG_INFO_AL2(LOG_RES_INIT, "   residual[%d] : (1.0 - $_lambda) * (stockReal - $_start(stockReal)) = %f", i, initialResiduals[i-1]);\r
 180   initialResiduals[i++] = ((1.0 - $P$_lambda) * ($PstockInteger - $P$START$PstockInteger));\r
 181   DEBUG_INFO_AL2(LOG_RES_INIT, "   residual[%d] : (1.0 - $_lambda) * (stockInteger - $_start(stockInteger)) = %f", i, initialResiduals[i-1]);\r
 182   initialResiduals[i++] = ((1.0 - $P$_lambda) * ($PstockBoolean - $P$START$PstockBoolean));\r
 183   DEBUG_INFO_AL2(LOG_RES_INIT, "   residual[%d] : (1.0 - $_lambda) * (stockBoolean - $_start(stockBoolean)) = %f", i, initialResiduals[i-1]);\r
 184   restore_memory_state(mem_state);\r
 185   \r
 186   return 0;\r
 187 }\r
 188 \r
 189 int updateBoundParameters(DATA *data)\r
 190 {\r
 191   state mem_state;\r
 192   \r
 193   mem_state = get_memory_state();\r
 194   restore_memory_state(mem_state);\r
 195   \r
 196   return 0;\r
 197 }\r
 198 \r
 199 \r
 200 void eqFunction_0(DATA *data) {\r
 201   modelica_boolean tmp0;\r
 202   /*#modelicaLine [FMUCallBeforeInitializationTest.mo:13:2-13:93]*/\r
 203   tmp0 = initial();\r
 204   $PvalveBoolean = (((tmp0 || $Pb) || (!$Pb))?($Pb?1.0:-1.0):$P$PRE$PvalveBoolean); \r
 205   /*#endModelicaLine*/\r
 206 }\r
 207 \r
 208 \r
 209 void eqFunction_1(DATA *data) {\r
 210   /*#modelicaLine [FMUCallBeforeInitializationTest.mo:16:2-16:34]*/\r
 211   $P$DER$PstockBoolean = $PvalveBoolean; \r
 212   /*#endModelicaLine*/\r
 213 }\r
 214 \r
 215 \r
 216 void eqFunction_2(DATA *data) {\r
 217   modelica_boolean tmp1;\r
 218   modelica_boolean tmp2;\r
 219   modelica_boolean tmp3;\r
 220   /*#modelicaLine [FMUCallBeforeInitializationTest.mo:14:2-14:80]*/\r
 221   tmp1 = initial();\r
 222   RELATIONTOZC(tmp2, (modelica_integer)$Pi, (modelica_integer) 0, -1,Less,<);\r
 223   RELATIONTOZC(tmp3, (modelica_integer)$Pi, (modelica_integer) 0, -1,GreaterEq,>=);\r
 224   $PvalveInteger = (((tmp1 || tmp2) || tmp3)?((modelica_real)(modelica_integer)$Pi):$P$PRE$PvalveInteger); \r
 225   /*#endModelicaLine*/\r
 226 }\r
 227 \r
 228 \r
 229 void eqFunction_3(DATA *data) {\r
 230   /*#modelicaLine [FMUCallBeforeInitializationTest.mo:17:2-17:34]*/\r
 231   $P$DER$PstockInteger = $PvalveInteger; \r
 232   /*#endModelicaLine*/\r
 233 }\r
 234 \r
 235 \r
 236 void eqFunction_4(DATA *data) {\r
 237   modelica_boolean tmp4;\r
 238   modelica_boolean tmp5;\r
 239   modelica_boolean tmp6;\r
 240   /*#modelicaLine [FMUCallBeforeInitializationTest.mo:15:2-15:74]*/\r
 241   tmp4 = initial();\r
 242   RELATIONTOZC(tmp5, $Pr, 0.0, -1,Less,<);\r
 243   RELATIONTOZC(tmp6, $Pr, 0.0, -1,GreaterEq,>=);\r
 244   $PvalveReal = (((tmp4 || tmp5) || tmp6)?$Pr:$P$PRE$PvalveReal); \r
 245   /*#endModelicaLine*/\r
 246 }\r
 247 \r
 248 \r
 249 void eqFunction_5(DATA *data) {\r
 250   /*#modelicaLine [FMUCallBeforeInitializationTest.mo:18:2-18:28]*/\r
 251   $P$DER$PstockReal = $PvalveReal; \r
 252   /*#endModelicaLine*/\r
 253 }\r
 254 \r
 255 static void functionODE_system0(DATA *data,int omc_thread_number)\r
 256 {\r
 257   eqFunction_0(data);\r
 258   eqFunction_1(data);\r
 259   eqFunction_2(data);\r
 260   eqFunction_3(data);\r
 261   eqFunction_4(data);\r
 262   eqFunction_5(data);\r
 263 }\r
 264 static void (*functionODE_systems[1])(DATA *, int) = {\r
 265   functionODE_system0\r
 266 };\r
 267 \r
 268 void function_initMemoryState()\r
 269 {\r
 270   push_memory_states(1);\r
 271 }\r
 272 \r
 273 int functionODE(DATA *data)\r
 274 {\r
 275   int id,th_id;\r
 276   state mem_state; /* We need to have separate memory pools for separate systems... */\r
 277   mem_state = get_memory_state();\r
 278   for (id=0; id<1; id++) {\r
 279     th_id = omp_get_thread_num();\r
 280     functionODE_systems[id](data,th_id);\r
 281   }\r
 282   restore_memory_state(mem_state);\r
 283   \r
 284   return 0;\r
 285 }\r
 286 #include <simulation_inline_solver.h>\r
 287 const char *_omc_force_solver=_OMC_FORCE_SOLVER;\r
 288 const int inline_work_states_ndims=_OMC_SOLVER_WORK_STATES_NDIMS;\r
 289 int functionODE_inline(DATA* data, double stepSize)\r
 290 {\r
 291   return 0;\r
 292 }\r
 293 \r
 294 /* for continuous time variables */\r
 295 int functionAlgebraics(DATA *data)\r
 296 {\r
 297   state mem_state;\r
 298   \r
 299   mem_state = get_memory_state();\r
 300   restore_memory_state(mem_state);\r
 301   \r
 302   return 0;\r
 303 }\r
 304 \r
 305 \r
 306 void eqFunction_6(DATA *data) {\r
 307   modelica_boolean tmp10;\r
 308   modelica_boolean tmp11;\r
 309   modelica_boolean tmp12;\r
 310   /*#modelicaLine [FMUCallBeforeInitializationTest.mo:15:2-15:74]*/\r
 311   tmp10 = initial();\r
 312   SAVEZEROCROSS(tmp11, $Pr, 0.0, -1,Less,<);\r
 313   SAVEZEROCROSS(tmp12, $Pr, 0.0, -1,GreaterEq,>=);\r
 314   $PvalveReal = (((tmp10 || tmp11) || tmp12)?$Pr:$P$PRE$PvalveReal); \r
 315   /*#endModelicaLine*/\r
 316 }\r
 317 \r
 318 \r
 319 void eqFunction_7(DATA *data) {\r
 320   /*#modelicaLine [FMUCallBeforeInitializationTest.mo:18:2-18:28]*/\r
 321   $P$DER$PstockReal = $PvalveReal; \r
 322   /*#endModelicaLine*/\r
 323 }\r
 324 \r
 325 \r
 326 void eqFunction_8(DATA *data) {\r
 327   modelica_boolean tmp13;\r
 328   modelica_boolean tmp14;\r
 329   modelica_boolean tmp15;\r
 330   /*#modelicaLine [FMUCallBeforeInitializationTest.mo:14:2-14:80]*/\r
 331   tmp13 = initial();\r
 332   SAVEZEROCROSS(tmp14, (modelica_integer)$Pi, (modelica_integer) 0, -1,Less,<);\r
 333   SAVEZEROCROSS(tmp15, (modelica_integer)$Pi, (modelica_integer) 0, -1,GreaterEq,>=);\r
 334   $PvalveInteger = (((tmp13 || tmp14) || tmp15)?((modelica_real)(modelica_integer)$Pi):$P$PRE$PvalveInteger); \r
 335   /*#endModelicaLine*/\r
 336 }\r
 337 \r
 338 \r
 339 void eqFunction_9(DATA *data) {\r
 340   /*#modelicaLine [FMUCallBeforeInitializationTest.mo:17:2-17:34]*/\r
 341   $P$DER$PstockInteger = $PvalveInteger; \r
 342   /*#endModelicaLine*/\r
 343 }\r
 344 \r
 345 \r
 346 void eqFunction_10(DATA *data) {\r
 347   modelica_boolean tmp16;\r
 348   /*#modelicaLine [FMUCallBeforeInitializationTest.mo:13:2-13:93]*/\r
 349   tmp16 = initial();\r
 350   $PvalveBoolean = (((tmp16 || $Pb) || (!$Pb))?($Pb?1.0:-1.0):$P$PRE$PvalveBoolean); \r
 351   /*#endModelicaLine*/\r
 352 }\r
 353 \r
 354 \r
 355 void eqFunction_11(DATA *data) {\r
 356   /*#modelicaLine [FMUCallBeforeInitializationTest.mo:16:2-16:34]*/\r
 357   $P$DER$PstockBoolean = $PvalveBoolean; \r
 358   /*#endModelicaLine*/\r
 359 }\r
 360 \r
 361 int functionDAE(DATA *data, int *needToIterate)\r
 362 {\r
 363   state mem_state;\r
 364   *needToIterate = 0;\r
 365   \r
 366   mem_state = get_memory_state();\r
 367   eqFunction_6(data);\r
 368   eqFunction_7(data);\r
 369   eqFunction_8(data);\r
 370   eqFunction_9(data);\r
 371   eqFunction_10(data);\r
 372   eqFunction_11(data);\r
 373   restore_memory_state(mem_state);\r
 374   \r
 375   return 0;\r
 376 }\r
 377 \r
 378 int function_onlyZeroCrossings(DATA *data, double *gout,double *t)\r
 379 {\r
 380   state mem_state;\r
 381   \r
 382   mem_state = get_memory_state();\r
 383   restore_memory_state(mem_state);\r
 384   \r
 385   return 0;\r
 386 }\r
 387 \r
 388 int checkForDiscreteChanges(DATA *data)\r
 389 {\r
 390   int needToIterate = 0;\r
 391 \r
 392   \r
 393   return needToIterate;\r
 394 }\r
 395 \r
 396 /* function to check assert after a step is done */\r
 397 int checkForAsserts(DATA *data)\r
 398 {\r
 399 \r
 400   \r
 401   return 0;\r
 402 }\r
 403 \r
 404  int initialAnalyticJacobianA(DATA* data){\r
 405     return 1;\r
 406  }\r
 407 \r
 408  int initialAnalyticJacobianB(DATA* data){\r
 409     return 1;\r
 410  }\r
 411 \r
 412  int initialAnalyticJacobianC(DATA* data){\r
 413     return 1;\r
 414  }\r
 415 \r
 416  int initialAnalyticJacobianD(DATA* data){\r
 417     return 1;\r
 418  }\r
 419  int functionJacA(DATA* data, double* jac){\r
 420     return 0;\r
 421  }\r
 422 \r
 423  int functionJacB(DATA* data, double* jac){\r
 424     return 0;\r
 425  }\r
 426 \r
 427  int functionJacC(DATA* data, double* jac){\r
 428     return 0;\r
 429  }\r
 430 \r
 431  int functionJacD(DATA* data, double* jac){\r
 432     return 0;\r
 433  }\r
 434 \r
 435 const char *linear_model_frame =\r
 436   "model linear_FMUCallBeforeInitializationTestModel\n  parameter Integer n = 3; // states \n  parameter Integer k = 0; // top-level inputs \n  parameter Integer l = 0; // top-level outputs \n"\r
 437   "  parameter Real x0[3] = {%s};\n"\r
 438   "  parameter Real u0[0] = {%s};\n"\r
 439   "  parameter Real A[3,3] = [%s];\n"\r
 440   "  parameter Real B[3,0] = zeros(3,0);%s\n"\r
 441   "  parameter Real C[0,3] = zeros(0,3);%s\n"\r
 442   "  parameter Real D[0,0] = zeros(0,0);%s\n"\r
 443   "  Real x[3](start=x0);\n"\r
 444   "  input Real u[0];\n"\r
 445   "  output Real y[0];\n"\r
 446   "\n  Real x_PstockBoolean = x[1];\n  Real x_PstockInteger = x[2];\n  Real x_PstockReal = x[3];\n      \n"\r
 447   "equation\n  der(x) = A * x + B * u;\n  y = C * x + D * u;\nend linear_FMUCallBeforeInitializationTestModel;\n"\r
 448 ;\r
 449 \r
 450 #ifdef __cplusplus\r
 451 }\r
 452 #endif\r
 453 \r
 454 /* forward the main in the simulation runtime */\r
 455 extern int _main_SimulationRuntime(int argc, char**argv, DATA *data);\r
 456 \r
 457 /* call the simulation runtime main from our main! */\r
 458 int main(int argc, char**argv)\r
 459 {\r
 460   DATA data;\r
 461   setupDataStruc(&data);\r
 462   return _main_SimulationRuntime(argc, argv, &data);\r
 463 }\r
 464 \r