org.simantics.fmil/native/FMUSimulator/src/fmu_control.cpp

   1 /* ------------------------------------------------------------------------- \r
   2  * fmu_control.c\r
   3  * Simulation controls for fmus\r
   4  *\r
   5  * Free libraries and tools used to implement this simulator:\r
   6  *  - header files from the FMU specification\r
   7  *  - eXpat 2.0.1 XML parser, see http://expat.sourceforge.net\r
   8  *  - 7z.exe 4.57 zip and unzip tool, see http://www.7-zip.org <---------- Replace with zlib\r
   9  * Author: Teemu Lempinen\r
  10  * Copyright 2012 Semantum Oy\r
  11  * -------------------------------------------------------------------------\r
  12  */\r
  13 \r
  14 #include <stdlib.h>\r
  15 #include <stdio.h>\r
  16 #include <string.h>\r
  17 #include <map>\r
  18 #include <string>\r
  19 #include <vector>\r
  20 #include <iostream>\r
  21 #include <regex>\r
  22 \r
  23 #include <org_simantics_fmil_FMILJNI.h>\r
  24 \r
  25 extern "C" {\r
  26         #include "fmi_me.h"\r
  27         #include "sim_support.h"\r
  28 }\r
  29 \r
  30 #include "fmi1_cs.h"\r
  31 \r
  32 #define PRINT(fmt,args) { FILE *fp = fopen("R:\\Simantics\\Sysdyn\\log.txt", "ab"); fprintf(fp, fmt, args); fclose(fp); }\r
  33 \r
  34 #include <direct.h>\r
  35 #define GetCurrentDir _getcwd\r
  36 \r
  37 using namespace std;\r
  38 \r
  39 struct FMI1 {\r
  40 \r
  41         void *fmu;\r
  42 \r
  43         vector<string> variables;\r
  44         vector<string> descriptions;\r
  45         vector<int> valueReferences;\r
  46         vector<int> types;\r
  47         vector<int> variabilities;\r
  48         vector<int> causalities;\r
  49 \r
  50         vector<int> subscription;\r
  51         double currentTime;\r
  52         double timeStep;\r
  53 \r
  54 };\r
  55 \r
  56 struct FMUControlStruct {\r
  57         double step;                                    // simulation step length\r
  58         fmiReal currentTime;                    // current simulation time\r
  59 \r
  60         fmiComponent c;                                 // instance of the fmu \r
  61         ScalarVariable** vars;                  // model variables\r
  62 \r
  63         fmiEventInfo eventInfo;         // updated by calls to initialize and eventUpdate\r
  64         const char* guid;               // global unique id of the fmu\r
  65         fmiCallbackFunctions callbacks; // called by the model during simulation\r
  66         fmiStatus fmiFlag;              // return code of the fmu functions\r
  67 \r
  68         map<string,int> indexes;                // indexes for variable names in vars-table\r
  69         map<string,int>::iterator it;\r
  70 \r
  71         int nx;                                                 // number of state variables\r
  72         double *x;                                              // continuous states\r
  73         double *xdot;                                   // the crresponding derivatives in same order\r
  74         int nz;                         // number of state event indicators\r
  75         double *z;                                              // state event indicators\r
  76         double *prez;                                   // previous values of state event indicators\r
  77         \r
  78         bool initialized;                               // has the fmu been initialized\r
  79 \r
  80         vector<fmiValueReference> subscription;         // result subscriptions\r
  81         vector<string> allVariables;    // all variables in an initialized model\r
  82         vector<fmiValueReference> fmiValueReferences;           // all value references\r
  83 \r
  84         string lastErrorMessage;\r
  85 \r
  86         FMU fmu;\r
  87 };\r
  88 \r
  89 vector<FMI1> fmus;\r
  90 \r
  91 //map<string,FMUControlStruct> fmus;            // indexes for variable names in vars-table\r
  92 \r
  93 int throwException(JNIEnv *env, string message) {\r
  94         jclass newExcCls;\r
  95     newExcCls = env->FindClass("java/lang/Exception");\r
  96     if (newExcCls == NULL) {\r
  97         /* Unable to find the exception class, give up. */\r
  98         return 0;\r
  99     }\r
 100         env->ThrowNew(newExcCls, message.c_str());\r
 101         return 0;\r
 102 }\r
 103 \r
 104 /*\r
 105 bool exists(string id) {\r
 106         map<string,FMUControlStruct>::iterator it = fmus.find(id);\r
 107         if(it != fmus.end()) {\r
 108                 return true;\r
 109         } else {\r
 110                 return false;\r
 111         }\r
 112 }\r
 113 */\r
 114 \r
 115 \r
 116 \r
 117 JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_loadFMUFile_1 \r
 118         (JNIEnv *env, jobject obj, jstring path, jstring tempDir) {\r
 119 \r
 120         HMODULE module = NULL;\r
 121         FMI1 fmi1;\r
 122         FMIL_Variable *vars;\r
 123         int variableCount = 0;\r
 124 \r
 125     const char *fmuPath = env->GetStringUTFChars(path, 0);\r
 126         const char *fmuTempDir = env->GetStringUTFChars(tempDir, 0);\r
 127 \r
 128         fmi1.currentTime = 0;\r
 129         fmi1.timeStep = 0.1;\r
 130         fmi1.fmu = FMI1_CS_LOAD(fmuPath, fmuTempDir);\r
 131         if(!fmi1.fmu)\r
 132           return throwException(env, "No FMU loaded");\r
 133 \r
 134    vars = FMI1_CS_GET_VARIABLES(fmi1.fmu, &variableCount);\r
 135    for(int i=0;i<variableCount;i++) {\r
 136            fmi1.variables.push_back(string(vars[i].name));\r
 137            if(vars[i].description)\r
 138                         fmi1.descriptions.push_back(string(vars[i].description));\r
 139            else\r
 140                         fmi1.descriptions.push_back(string(""));\r
 141            fmi1.types.push_back(vars[i].type);\r
 142            fmi1.causalities.push_back(vars[i].causality);\r
 143            fmi1.variabilities.push_back(vars[i].variability);\r
 144            fmi1.valueReferences.push_back(vars[i].vr);\r
 145    }\r
 146 \r
 147    fmus.push_back(fmi1);\r
 148 \r
 149         env->ReleaseStringUTFChars(path, fmuPath);\r
 150         env->ReleaseStringUTFChars(tempDir, fmuTempDir);\r
 151 \r
 152         return fmus.size() - 1;\r
 153 \r
 154 }\r
 155 \r
 156 JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_setStepLength_1 \r
 157         (JNIEnv *env, jobject obj, jint id, jdouble stepLength) {\r
 158         fmus[id].timeStep = stepLength;\r
 159         return 1;\r
 160 }\r
 161 \r
 162 JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_subscribe_1\r
 163   (JNIEnv *env, jobject obj, jint id, jintArray vrs) {\r
 164 \r
 165         jboolean isCopy;\r
 166         jint* elements = env -> GetIntArrayElements(vrs, &isCopy);\r
 167         jsize n = env -> GetArrayLength(vrs);\r
 168 \r
 169         int i;\r
 170         for (i = 0; i < n; i++) {\r
 171                 fmus[id].subscription.push_back(elements[i]);\r
 172         } \r
 173           \r
 174         if (isCopy == JNI_TRUE) {\r
 175                 env -> ReleaseIntArrayElements(vrs, elements, 0);\r
 176         }\r
 177 \r
 178         return 1;\r
 179 \r
 180 }\r
 181 \r
 182 bool referenceExists(FMUControlStruct fmuStruct, string variable) {\r
 183         map<string,int>::iterator it = fmuStruct.indexes.find(variable);\r
 184         if(it != fmuStruct.indexes.end()) {\r
 185                 return true;\r
 186         } else {\r
 187                 return false;\r
 188         }\r
 189 }\r
 190 \r
 191 // Remember to check if reference exists\r
 192 fmiValueReference getReference(FMUControlStruct fmuStruct, string variable) {\r
 193         return fmuStruct.fmiValueReferences[fmuStruct.indexes[variable]];\r
 194 }\r
 195 \r
 196 // Get string representation of a scalar variable type\r
 197 string getTypeString(ScalarVariable* sv) {\r
 198         switch (sv->typeSpec->type){\r
 199                 case elm_Integer:\r
 200                         return "Integer";\r
 201                 case elm_Enumeration:\r
 202                         return "Enumeration";\r
 203                 case elm_Real:\r
 204                         return "Real";\r
 205                 case elm_Boolean:\r
 206                         return "Boolean";\r
 207                 default:\r
 208                         return "No type";\r
 209         }\r
 210 }\r
 211 \r
 212 JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_setRealValue_1\r
 213   (JNIEnv *env, jobject obj, jint id, jint vr, jdouble value) {\r
 214 \r
 215           FMI1_CS_SET_REAL(fmus[id].fmu, vr, value);\r
 216           return 1;\r
 217 \r
 218 }\r
 219 \r
 220 JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_setIntegerValue_1\r
 221   (JNIEnv *env, jobject obj, jstring id, jstring parameter, jint value) {\r
 222           /*\r
 223         const char *fmuId = env->GetStringUTFChars(id, 0);\r
 224         if(exists(fmuId)) {\r
 225                 FMUControlStruct& fmuStruct = fmus[fmuId];\r
 226                 const char *name = env->GetStringUTFChars(parameter, 0);\r
 227                 string nameString = name;\r
 228                 string modelId = fmuId;\r
 229                 if(!referenceExists(fmuStruct, name)) {\r
 230                         string errorMessage = "setIntegerValue: Model (id " + modelId + ") does not contain variable: " + nameString;\r
 231                         env->ReleaseStringUTFChars(parameter, name);\r
 232                         env->ReleaseStringUTFChars(id, fmuId);\r
 233                         return throwException(env, errorMessage);\r
 234                 } else {\r
 235                         // Check variable type\r
 236                         ScalarVariable* sv = fmuStruct.vars[fmuStruct.indexes[name]];\r
 237                         switch (sv->typeSpec->type){\r
 238                                 case elm_Integer:\r
 239                                         break; // ok\r
 240                                 default: {\r
 241                                         string errorMessage = "setIntegerValue: " + nameString + " is not of type Integer. (type: + " + getTypeString(sv) + ")";\r
 242                                         env->ReleaseStringUTFChars(parameter, name);\r
 243                                         env->ReleaseStringUTFChars(id, fmuId);\r
 244                                         return throwException(env, errorMessage);\r
 245                                 }\r
 246                         }\r
 247 \r
 248                         // Change value\r
 249                         fmiValueReference vr = getReference(fmuStruct, name);\r
 250                         const int intValue = (int) value;\r
 251                         fmuStruct.fmu.setInteger(fmuStruct.c, &vr, 1, &intValue);\r
 252                         env->ReleaseStringUTFChars(parameter, name);\r
 253                         env->ReleaseStringUTFChars(id, fmuId);\r
 254                         return 1;\r
 255                 }\r
 256         }  else {\r
 257                 string message = fmuId;\r
 258                 env->ReleaseStringUTFChars(id, fmuId);\r
 259                 return throwException(env, "setIntegerValue: Model id " + message + " not found");\r
 260         }\r
 261         */\r
 262           return 1;\r
 263 }\r
 264 \r
 265 JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_setBooleanValue_1\r
 266   (JNIEnv *env, jobject obj, jstring id, jstring parameter, jboolean value) {\r
 267           /*\r
 268         const char *fmuId = env->GetStringUTFChars(id, 0);\r
 269         if(exists(fmuId)) {\r
 270                 FMUControlStruct& fmuStruct = fmus[fmuId];\r
 271                 const char *name = env->GetStringUTFChars(parameter, 0);\r
 272                 string nameString = name;\r
 273                 string modelId = fmuId;\r
 274                 if(!referenceExists(fmuStruct, name)) {\r
 275                         string errorMessage = "setBooleanValue: Model (id " + modelId + ") does not contain variable: " + nameString;\r
 276                         env->ReleaseStringUTFChars(parameter, name);\r
 277                         env->ReleaseStringUTFChars(id, fmuId);\r
 278                         return throwException(env, errorMessage);\r
 279                 } else {\r
 280                         // Check variable type\r
 281                         ScalarVariable* sv = fmuStruct.vars[fmuStruct.indexes[name]];\r
 282                         switch (sv->typeSpec->type){\r
 283                                 case elm_Boolean:\r
 284                                         break; // ok\r
 285                                 default: {\r
 286                                         string errorMessage = "setBooleanValue: " + nameString + " is not of type Boolean. (type: + " + getTypeString(sv) + ")";\r
 287                                         env->ReleaseStringUTFChars(parameter, name);\r
 288                                         env->ReleaseStringUTFChars(id, fmuId);\r
 289                                         return throwException(env, errorMessage);\r
 290                                 }\r
 291                         }\r
 292 \r
 293                         // Change value\r
 294                         fmiValueReference vr = getReference(fmuStruct, name);\r
 295                         fmiBoolean result = 1;\r
 296                         if(value == 0)\r
 297                                 result = 0;\r
 298                         fmuStruct.fmu.setBoolean(fmuStruct.c, &vr, 1, &result);\r
 299                         env->ReleaseStringUTFChars(parameter, name);\r
 300                         env->ReleaseStringUTFChars(id, fmuId);\r
 301                         return 1;\r
 302                 }\r
 303         }  else {\r
 304                 string message = fmuId;\r
 305                 env->ReleaseStringUTFChars(id, fmuId);\r
 306                 return throwException(env, "setBooleanValue: Model id " + message + " not found");\r
 307         }*/\r
 308           return 1;\r
 309 }\r
 310 \r
 311 JNIEXPORT jboolean JNICALL Java_org_simantics_fmil_FMIL_isInitialized_1\r
 312   (JNIEnv *env, jobject obj, jstring id) {\r
 313           /*\r
 314         const char *fmuId = env->GetStringUTFChars(id, 0);\r
 315         if(exists(fmuId)) {\r
 316                 FMUControlStruct& fmuStruct = fmus[fmuId];\r
 317                 env->ReleaseStringUTFChars(id, fmuId);\r
 318                 return fmuStruct.initialized;\r
 319         } else {\r
 320                 env->ReleaseStringUTFChars(id, fmuId);\r
 321                 return false;\r
 322         }\r
 323         */\r
 324           return 1;\r
 325 }\r
 326 \r
 327 \r
 328 JNIEXPORT jdouble JNICALL Java_org_simantics_fmil_FMIL_getTime_1\r
 329   (JNIEnv *env, jobject obj, jint id) {\r
 330           return fmus[id].currentTime;\r
 331 }\r
 332 \r
 333 double getRealValue(FMUControlStruct fmuStruct, int index) {\r
 334         ScalarVariable *sv = fmuStruct.vars[index];\r
 335         fmiValueReference vr = fmuStruct.fmiValueReferences[index];\r
 336         double real;\r
 337         fmiInteger integer;\r
 338         fmiBoolean fmibool;\r
 339 \r
 340         switch (sv->typeSpec->type){\r
 341         case elm_Real:\r
 342                         fmuStruct.fmu.getReal(fmuStruct.c, &vr, 1, &real);\r
 343             break;\r
 344         case elm_Integer:\r
 345         case elm_Enumeration:\r
 346             fmuStruct.fmu.getInteger(fmuStruct.c, &vr, 1, &integer);\r
 347                         real = (double)integer;\r
 348             break;\r
 349         case elm_Boolean:\r
 350             fmuStruct.fmu.getBoolean(fmuStruct.c, &vr, 1, &fmibool);\r
 351                         if(fmibool == fmiTrue)\r
 352                                 real = 1.0;\r
 353                         else\r
 354                                 real = 0.0;\r
 355             break;\r
 356         }\r
 357         return real;\r
 358 }\r
 359 \r
 360 JNIEXPORT jdoubleArray JNICALL Java_org_simantics_fmil_FMIL_getSubscribedResults_1\r
 361   (JNIEnv *env, jobject obj, jint id, jdoubleArray result) {\r
 362 \r
 363         jboolean isCopy;\r
 364         jdouble* resultElements = env -> GetDoubleArrayElements(result, &isCopy);\r
 365         jsize n = env -> GetArrayLength(result);\r
 366         int *vrs;\r
 367         if(n > 0) {\r
 368                 vrs = &(fmus[id].subscription[0]);\r
 369                 FMI1_CS_GET_REALS(fmus[id].fmu, vrs, resultElements, n);\r
 370         }\r
 371         if (isCopy == JNI_TRUE) {\r
 372                 env -> ReleaseDoubleArrayElements(result, resultElements, 0);\r
 373         }\r
 374 \r
 375         return result;\r
 376         \r
 377 }\r
 378 \r
 379 JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_instantiateSimulation_1\r
 380   (JNIEnv *env, jobject obj, jint id) {\r
 381 \r
 382           int asd = FMI1_CS_INSTANTIATE(fmus[id].fmu);\r
 383           if(asd != 0)\r
 384                 return throwException(env, "No FMU loaded");\r
 385 \r
 386           return 1;\r
 387 \r
 388 }\r
 389 \r
 390 JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_initializeSimulation_1\r
 391   (JNIEnv *env, jobject obj, jint id) {\r
 392 \r
 393           int asd = FMI1_CS_INITIALIZE(fmus[id].fmu);\r
 394           if(asd != 0)\r
 395                 return throwException(env, "No FMU loaded");\r
 396 \r
 397           return 1;\r
 398 \r
 399 }\r
 400 \r
 401 JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_setTime_1\r
 402   (JNIEnv *env, jobject obj, jstring id, jdouble time) {\r
 403           return 1;\r
 404 }\r
 405 \r
 406 JNIEXPORT jobjectArray JNICALL Java_org_simantics_fmil_FMIL_getAllVariables_1\r
 407   (JNIEnv *env, jobject obj, jint id) {\r
 408 \r
 409         jobjectArray ret= (jobjectArray)env->NewObjectArray(fmus[id].variables.size(),  \r
 410                         env->FindClass("java/lang/String"),  \r
 411                         env->NewStringUTF(""));  \r
 412    \r
 413         for(int i=0;i<fmus[id].variables.size();i++) {  \r
 414                 env->SetObjectArrayElement(ret,i,env->NewStringUTF(fmus[id].variables[i].c_str()));  \r
 415         }  \r
 416 \r
 417         return ret;  \r
 418 \r
 419 }\r
 420 \r
 421 JNIEXPORT jobjectArray JNICALL Java_org_simantics_fmil_FMIL_getAllVariableDescriptions_1\r
 422   (JNIEnv *env, jobject obj, jint id) {\r
 423 \r
 424         jobjectArray ret= (jobjectArray)env->NewObjectArray(fmus[id].descriptions.size(),  \r
 425                         env->FindClass("java/lang/String"),  \r
 426                         env->NewStringUTF(""));  \r
 427    \r
 428         for(int i=0;i<fmus[id].descriptions.size();i++) {  \r
 429                 env->SetObjectArrayElement(ret,i,env->NewStringUTF(fmus[id].descriptions[i].c_str()));  \r
 430         }  \r
 431 \r
 432         return ret;  \r
 433 \r
 434 }\r
 435 \r
 436 JNIEXPORT jintArray JNICALL Java_org_simantics_fmil_FMIL_getAllVariableReferences_1\r
 437   (JNIEnv *env, jobject obj, jint id, jintArray result) {\r
 438 \r
 439         jboolean isCopy;\r
 440         jint* resultElements = env -> GetIntArrayElements(result, &isCopy);\r
 441         jsize n = env -> GetArrayLength(result);\r
 442 \r
 443         int i;\r
 444         for (i = 0; i < n; i++) {\r
 445                 resultElements[i] = fmus[id].valueReferences[i];\r
 446         } \r
 447           \r
 448         if (isCopy == JNI_TRUE) {\r
 449                 env -> ReleaseIntArrayElements(result, resultElements, 0);\r
 450         }\r
 451 \r
 452         return result;\r
 453 \r
 454 }\r
 455 \r
 456 JNIEXPORT jintArray JNICALL Java_org_simantics_fmil_FMIL_getAllVariableTypes_1\r
 457   (JNIEnv *env, jobject obj, jint id, jintArray result) {\r
 458 \r
 459         jboolean isCopy;\r
 460         jint* resultElements = env -> GetIntArrayElements(result, &isCopy);\r
 461         jsize n = env -> GetArrayLength(result);\r
 462 \r
 463         int i;\r
 464         for (i = 0; i < n; i++) {\r
 465                 resultElements[i] = fmus[id].types[i];\r
 466         } \r
 467           \r
 468         if (isCopy == JNI_TRUE) {\r
 469                 env -> ReleaseIntArrayElements(result, resultElements, 0);\r
 470         }\r
 471 \r
 472         return result;\r
 473 \r
 474 }\r
 475 \r
 476 JNIEXPORT jintArray JNICALL Java_org_simantics_fmil_FMIL_getAllVariableVariabilities_1\r
 477   (JNIEnv *env, jobject obj, jint id, jintArray result) {\r
 478 \r
 479         jboolean isCopy;\r
 480         jint* resultElements = env -> GetIntArrayElements(result, &isCopy);\r
 481         jsize n = env -> GetArrayLength(result);\r
 482 \r
 483         int i;\r
 484         for (i = 0; i < n; i++) {\r
 485                 resultElements[i] = fmus[id].variabilities[i];\r
 486         } \r
 487           \r
 488         if (isCopy == JNI_TRUE) {\r
 489                 env -> ReleaseIntArrayElements(result, resultElements, 0);\r
 490         }\r
 491 \r
 492         return result;\r
 493 \r
 494 }\r
 495 \r
 496 JNIEXPORT jintArray JNICALL Java_org_simantics_fmil_FMIL_getAllVariableCausalities_1\r
 497   (JNIEnv *env, jobject obj, jint id, jintArray result) {\r
 498 \r
 499         jboolean isCopy;\r
 500         jint* resultElements = env -> GetIntArrayElements(result, &isCopy);\r
 501         jsize n = env -> GetArrayLength(result);\r
 502 \r
 503         int i;\r
 504         for (i = 0; i < n; i++) {\r
 505                 resultElements[i] = fmus[id].causalities[i];\r
 506         } \r
 507           \r
 508         if (isCopy == JNI_TRUE) {\r
 509                 env -> ReleaseIntArrayElements(result, resultElements, 0);\r
 510         }\r
 511 \r
 512         return result;\r
 513 \r
 514 }\r
 515 \r
 516 /*\r
 517 JNIEXPORT jobjectArray JNICALL Java_org_simantics_fmil_FMIL_filterVariables_1\r
 518   (JNIEnv *env, jobject obj, jstring id, jstring regexp) {\r
 519          const char *rx = env->GetStringUTFChars(regexp, 0);\r
 520          jobjectArray result = filterVariables(env, obj, id, rx);\r
 521          env->ReleaseStringUTFChars(regexp, rx);\r
 522          return result;\r
 523 }\r
 524 */\r
 525 \r
 526 JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_simulateStep_1\r
 527   (JNIEnv *env, jobject obj, jint id) {\r
 528 \r
 529           int asd = FMI1_CS_STEP(fmus[id].fmu, fmus[id].currentTime, fmus[id].timeStep);\r
 530           if(asd != 0)\r
 531                 return throwException(env, "No FMU loaded");\r
 532 \r
 533           fmus[id].currentTime += fmus[id].timeStep;\r
 534 \r
 535           return 1;\r
 536 \r
 537           /*\r
 538         const char *fmuId = env->GetStringUTFChars(id, 0);\r
 539         if(exists(fmuId)) {\r
 540                 FMUControlStruct& fmuStruct = fmus[fmuId];\r
 541                 env->ReleaseStringUTFChars(id, fmuId);\r
 542 \r
 543                 if(&fmuStruct.fmu == NULL || fmuStruct.fmu.modelDescription == NULL || &fmuStruct.vars == NULL) {\r
 544                         return throwException(env, "Simulate step failed - fmu not loaded");\r
 545                 }\r
 546 \r
 547                 if(fmuStruct.x == NULL) {\r
 548                         return throwException(env, "Simulate step failed - fmu not instantiated");\r
 549                 }\r
 550 \r
 551                 if(fmuStruct.initialized == false) {\r
 552                         fmiBoolean toleranceControlled = fmiFalse;\r
 553                         fmuStruct.fmiFlag =  fmuStruct.fmu.initialize(fmuStruct.c, toleranceControlled, fmuStruct.currentTime, &(fmuStruct.eventInfo));\r
 554                         if (fmuStruct.fmiFlag > fmiWarning)  return throwException(env, "could not initialize model");\r
 555                         fmuStruct.initialized = true;\r
 556                 }\r
 557 \r
 558                 FMU& fmu = fmuStruct.fmu;\r
 559                 int debug = 0; // DEBUG ON = 1, OFF = 0\r
 560 \r
 561                 int i;\r
 562                 double dt, tPre, tEnd = fmuStruct.currentTime + fmuStruct.step;\r
 563 \r
 564                 fmiBoolean timeEvent, stateEvent, stepEvent;\r
 565                 fmiStatus fmiFlag;                      // return code of the fmu functions\r
 566                 fmiValueReference vr;\r
 567 \r
 568 \r
 569                 */\r
 570                 /* Simulate the duration of one step. The simulation may be done in \r
 571                  * multiple parts if events occur\r
 572                  */ /*\r
 573                 while (fmuStruct.currentTime < tEnd) {\r
 574                         // get current state and derivatives\r
 575                         fmiFlag = fmu.getContinuousStates(fmuStruct.c, fmuStruct.x, fmuStruct.nx);\r
 576                         if (fmiFlag > fmiWarning) \r
 577                                 return throwException(env, "could not retrieve states");\r
 578 \r
 579                         fmiFlag = fmu.getDerivatives(fmuStruct.c, fmuStruct.xdot, fmuStruct.nx);\r
 580                         if (fmiFlag > fmiWarning) \r
 581                                 return throwException(env, "could not retrieve derivatives");\r
 582 \r
 583                          // advance time\r
 584                         tPre = fmuStruct.currentTime;\r
 585                         fmuStruct.currentTime = min(fmuStruct.currentTime+fmuStruct.step, tEnd);\r
 586                         timeEvent = fmuStruct.eventInfo.upcomingTimeEvent && fmuStruct.eventInfo.nextEventTime < fmuStruct.currentTime;  \r
 587                 \r
 588                         if (timeEvent) fmuStruct.currentTime = fmuStruct.eventInfo.nextEventTime;\r
 589                         dt = fmuStruct.currentTime - tPre; \r
 590                         fmiFlag = fmu.setTime(fmuStruct.c, fmuStruct.currentTime);\r
 591                         if (fmiFlag > fmiWarning) throwException(env, "could not set time");\r
 592 \r
 593                         if(referenceExists(fmuStruct, "time")) {\r
 594                                 vr = getReference(fmuStruct, "time");\r
 595                                 if(vr != NULL) {\r
 596                                         fmu.setReal(fmuStruct.c, &vr, 1, &(fmuStruct.currentTime));\r
 597                                 }\r
 598                         }\r
 599 \r
 600                         if(debug)\r
 601                                 printf("Actual time: %lf\n", fmuStruct.currentTime);\r
 602 \r
 603                         if (fmiFlag > fmiWarning) \r
 604                                 return throwException(env, "could not set time");\r
 605 \r
 606                         // perform one step\r
 607                         for (i=0; i<fmuStruct.nx; i++) \r
 608                                 fmuStruct.x[i] += dt*fmuStruct.xdot[i]; // forward Euler method\r
 609 \r
 610                         fmiFlag = fmu.setContinuousStates(fmuStruct.c, fmuStruct.x, fmuStruct.nx);\r
 611                         if (fmiFlag > fmiWarning) \r
 612                                 return throwException(env, "could not set states");\r
 613 \r
 614                         // Check for step event, e.g. dynamic state selection\r
 615                         fmiFlag = fmu.completedIntegratorStep(fmuStruct.c, &stepEvent);\r
 616                         if (fmiFlag > fmiWarning) return throwException(env, "could not complete intgrator step");\r
 617                         */\r
 618 /*                      for (i=0; i<fmuStruct.nz; i++) fmuStruct.prez[i] = fmuStruct.z[i]; \r
 619                         fmiFlag = fmu.getEventIndicators(fmuStruct.c, fmuStruct.z, fmuStruct.nz);\r
 620                         if (fmiFlag > fmiWarning) return throwException(env, "could not retrieve event indicators");\r
 621                         stateEvent = FALSE;\r
 622                         for (i=0; i<fmuStruct.nz; i++) \r
 623                                 stateEvent = stateEvent || (fmuStruct.prez[i] * fmuStruct.z[i] < 0);  \r
 624      \r
 625 \r
 626                         stepEvent = fmiTrue;\r
 627                         // handle events\r
 628                         if (timeEvent || stateEvent || stepEvent) {\r
 629         \r
 630                                 // event iteration in one step, ignoring intermediate results\r
 631                                 fmiFlag = fmu.eventUpdate(fmuStruct.c, fmiFalse, &(fmuStruct.eventInfo));\r
 632                                 if (fmiFlag > fmiWarning) return throwException(env, "could not perform event update");\r
 633       \r
 634                         } // if event\r
 635                         */\r
 636         \r
 637 /*              }\r
 638 \r
 639                 fflush(stdout);\r
 640                 return 1;\r
 641 \r
 642         } else {\r
 643                 string message = fmuId;\r
 644                 env->ReleaseStringUTFChars(id, fmuId);\r
 645                 return throwException(env, "simulateStep: Model id " + message + " not found");\r
 646         }*/\r
 647         return 1;\r
 648 }\r
 649 \r
 650 JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_unloadFMU_1\r
 651   (JNIEnv *env, jobject obj, jint id) {\r
 652 \r
 653           int asd = FMI1_CS_UNLOAD(fmus[id].fmu);\r
 654           return asd;\r
 655 \r
 656 }\r
 657 \r
 658 JNIEXPORT jstring JNICALL Java_org_simantics_fmil_FMIL_getLastErrorMessage_1\r
 659   (JNIEnv *env, jobject obj, jstring id) {\r
 660           return env->NewStringUTF("No errors");\r
 661 }\r
 662 \r
 663 JNIEXPORT jdouble JNICALL Java_org_simantics_fmil_FMIL_getRealValue_1\r
 664   (JNIEnv *env, jobject obj, jint id, jint vr) {\r
 665           return FMI1_CS_GET_REAL(fmus[id].fmu, vr);\r
 666 }\r
 667 \r
 668 JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_getIntegerValue_1\r
 669   (JNIEnv *env, jobject obj, jstring id, jstring variable) {\r
 670           /*\r
 671         const char *fmuId = env->GetStringUTFChars(id, 0);\r
 672         if(exists(fmuId)) {\r
 673                 FMUControlStruct fmuStruct = fmus[fmuId];\r
 674                 env->ReleaseStringUTFChars(id, fmuId);\r
 675                 const char *name = env->GetStringUTFChars(variable, 0);\r
 676 \r
 677                 if(referenceExists(fmuStruct, name)) {\r
 678                         fmiValueReference vr = getReference(fmuStruct, name);\r
 679                         int result;\r
 680                         fmuStruct.fmu.getInteger(fmuStruct.c, &vr, 1, &result);\r
 681                         env->ReleaseStringUTFChars(variable, name);\r
 682                         return result;\r
 683 \r
 684                 } else {\r
 685                          string nameString = name;\r
 686                          string message = "Variable " + nameString + " not found";\r
 687                          env->ReleaseStringUTFChars(variable, name);\r
 688                          return throwException(env, message);\r
 689                 }\r
 690 \r
 691         } else {\r
 692                 string message = fmuId;\r
 693                 env->ReleaseStringUTFChars(id, fmuId);\r
 694                 return throwException(env, "unloadFMU: Model id " + message + " not found");\r
 695         }\r
 696         */\r
 697           return 1;\r
 698 \r
 699 }\r
 700 \r
 701 JNIEXPORT jboolean JNICALL Java_org_simantics_fmil_FMIL_getBooleanValue_1\r
 702   (JNIEnv *env, jobject obj, jstring id, jstring variable) {\r
 703           /*\r
 704         const char *fmuId = env->GetStringUTFChars(id, 0);\r
 705         if(exists(fmuId)) {\r
 706                 FMUControlStruct fmuStruct = fmus[fmuId];\r
 707                 env->ReleaseStringUTFChars(id, fmuId);\r
 708                 const char *name = env->GetStringUTFChars(variable, 0);\r
 709 \r
 710                 if(referenceExists(fmuStruct, name)) {\r
 711                         fmiValueReference vr = getReference(fmuStruct, name);\r
 712                         fmiBoolean result;\r
 713                         fmuStruct.fmu.getBoolean(fmuStruct.c, &vr, 1, &result);\r
 714                         env->ReleaseStringUTFChars(variable, name);\r
 715                         return result;\r
 716 \r
 717                 } else {\r
 718                          string nameString = name;\r
 719                          string message = "Variable " + nameString + " not found";\r
 720                          env->ReleaseStringUTFChars(variable, name);\r
 721                          return throwException(env, message);\r
 722                 }\r
 723 \r
 724         } else {\r
 725                 string message = fmuId;\r
 726                 env->ReleaseStringUTFChars(id, fmuId);\r
 727                 return throwException(env, "unloadFMU: Model id " + message + " not found");\r
 728         }*/\r
 729           return 1;\r
 730 \r
 731 }\r
 732 \r
 733 JNIEXPORT jstring JNICALL Java_org_simantics_fmil_FMIL_getStringValue_1\r
 734   (JNIEnv *env, jobject obj, jstring id, jstring variable) {\r
 735           /*\r
 736         const char *fmuId = env->GetStringUTFChars(id, 0);\r
 737         if(exists(fmuId)) {\r
 738                 FMUControlStruct fmuStruct = fmus[fmuId];\r
 739                 env->ReleaseStringUTFChars(id, fmuId);\r
 740                 const char *name = env->GetStringUTFChars(variable, 0);\r
 741 \r
 742                 if(referenceExists(fmuStruct, name)) {\r
 743                         fmiValueReference vr = getReference(fmuStruct, name);\r
 744                         fmiString result;\r
 745                         fmuStruct.fmu.getString(fmuStruct.c, &vr, 1, &result);\r
 746                         env->ReleaseStringUTFChars(variable, name);\r
 747                         return env->NewStringUTF(result);\r
 748 \r
 749                 } else {\r
 750                          string nameString = name;\r
 751                          string message = "Variable " + nameString + " not found";\r
 752                          env->ReleaseStringUTFChars(variable, name);\r
 753                          return 0; //throwException(env, message);\r
 754                 }\r
 755 \r
 756         } else {\r
 757                 string message = fmuId;\r
 758                 env->ReleaseStringUTFChars(id, fmuId);\r
 759                 return 0; //throwException(env, "unloadFMU: Model id " + message + " not found");\r
 760         }\r
 761         */\r
 762           return 0;\r
 763 \r
 764 }