fmi_version_enu_t fmi_import_get_fmi_version( fmi_import_context_t* c, const char* fileName, const char* dirName) { fmi_version_enu_t ret = fmi_version_unknown_enu; jm_status_enu_t status; char* mdpath; jm_log_verbose(c->callbacks, MODULE, "Detecting FMI standard version"); if(!fileName || !*fileName) { jm_log_fatal(c->callbacks, MODULE, "No FMU filename specified"); return fmi_version_unknown_enu; } if(!dirName || !*dirName) { jm_log_fatal(c->callbacks, MODULE, "No temporary directory name specified"); return fmi_version_unknown_enu; } status = fmi_zip_unzip(fileName, dirName, c->callbacks); if(status == jm_status_error) return fmi_version_unknown_enu; mdpath = fmi_import_get_model_description_path(dirName, c->callbacks); ret = fmi_xml_get_fmi_version(c, mdpath); jm_log_info(c->callbacks, MODULE, "XML specifies FMI standard version %s", fmi_version_to_string(ret)); c->callbacks->free(mdpath); return ret; }
jm_status_enu_t fmi1_cs_simulate(fmu_check_data_t* cdata) { fmi1_status_t fmistatus; jm_status_enu_t jmstatus = jm_status_success; jm_callbacks* cb = &cdata->callbacks; fmi1_import_t* fmu = cdata->fmu1; fmi1_string_t fmuGUID = fmi1_import_get_GUID(fmu); fmi1_string_t mimeType; fmi1_real_t timeout = 0.0; fmi1_boolean_t visible = fmi1_false; fmi1_boolean_t interactive = fmi1_false; fmi1_real_t tstart = fmi1_import_get_default_experiment_start(fmu); fmi1_real_t tcur = tstart; fmi1_real_t hstep; fmi1_real_t tend = fmi1_import_get_default_experiment_stop(fmu); fmi1_boolean_t StopTimeDefined = fmi1_true; mimeType = fmi1_import_get_mime_type(fmu); if( (cdata->fmu1_kind == fmi1_fmu_kind_enu_cs_standalone) || !mimeType || !mimeType[0]) { mimeType = "application/x-fmu-sharedlibrary"; } else { if( strcmp(mimeType, "application/x-fmu-sharedlibrary") != 0 ) { jm_log_info(cb, fmu_checker_module,"The FMU requests simulator with MIME type '%s'.", mimeType); printf("\nPlease, start a simulator program for MIME type '%s'\nPress enter to continue.\n", mimeType); getchar(); } } if(cdata->stopTime > 0) { tend = cdata->stopTime; } if(cdata->stepSize > 0) { hstep = cdata->stepSize; } else { hstep = (tend - tstart) / cdata->numSteps; } cdata->instanceName = "Test FMI 1.0 CS"; jm_log_verbose(cb, fmu_checker_module, "Checker will instantiate the slave with \n" "\tFMU location ='%s'\n\tMIME type = '%s'", cdata->fmuLocation, mimeType); jmstatus = fmi1_import_instantiate_slave(fmu, cdata->instanceName, cdata->fmuLocation, mimeType, timeout, visible, interactive); if (jmstatus == jm_status_error) { jm_log_fatal(cb, fmu_checker_module, "Could not instantiate the model"); return jm_status_error; } fmistatus = fmi1_import_initialize_slave(fmu, tstart, StopTimeDefined, tend); if((fmistatus == fmi1_status_ok) || (fmistatus == fmi1_status_warning)) { jm_log_info(cb, fmu_checker_module, "Initialized FMU for simulation starting at time %g", tstart); fmistatus = fmi1_status_ok; } else { jm_log_fatal(cb, fmu_checker_module, "Failed to initialize FMU for simulation (FMU status: %s)", fmi1_status_to_string(fmistatus)); jmstatus = jm_status_error; } if(jmstatus != jm_status_error) { jm_log_verbose(cb, fmu_checker_module, "Writing simulation output for start time"); if(fmi1_write_csv_data(cdata, tstart) != jm_status_success){ jmstatus = jm_status_error; } } while ((tcur < tend) && (jmstatus != jm_status_error)) { fmi1_boolean_t newStep = fmi1_true; fmi1_real_t tnext = tcur + hstep; if(tnext > tend - 1e-3*hstep) { /* last step should be on tend */ hstep = tend - tcur; tnext = tend; } jm_log_verbose(cb, fmu_checker_module, "Simulation step from time: %g until: %g", tcur, tnext); fmistatus = fmi1_import_do_step(fmu, tcur, hstep, newStep); tcur = tnext; if(fmi1_write_csv_data(cdata, tcur) != jm_status_success){ jmstatus = jm_status_error; } if((fmistatus == fmi1_status_ok) || (fmistatus == fmi1_status_warning)) { fmistatus = fmi1_status_ok; } else jmstatus = jm_status_error; } if((fmistatus != fmi1_status_ok) && (fmistatus != fmi1_status_warning)) { jm_log_fatal(cb, fmu_checker_module, "Simulation loop terminated at time %g since FMU returned status: %s", tcur, fmi1_status_to_string(fmistatus)); jmstatus = jm_status_error; } else if(jmstatus != jm_status_error) { jm_log_info(cb, fmu_checker_module, "Simulation finished successfully at time %g", tcur); } fmistatus = fmi1_import_terminate_slave(fmu); if( fmistatus != fmi1_status_ok) { jm_log_error(cb, fmu_checker_module, "fmiTerminateSlave returned status: %s", fmi1_status_to_string(fmistatus)); } fmi1_import_free_slave_instance(fmu); return jmstatus; }
/* Load and destroy functions */ jm_status_enu_t fmi2_import_create_dllfmu(fmi2_import_t* fmu, fmi2_fmu_kind_enu_t fmuKind, const fmi2_callback_functions_t* callBackFunctions) { char curDir[FILENAME_MAX + 2]; char* dllDirPath = 0; char* dllFileName = 0; const char* modelIdentifier; fmi2_callback_functions_t defaultCallbacks; if (fmu == NULL) { assert(0); return jm_status_error; } if(fmu -> capi) { if(fmi2_capi_get_fmu_kind(fmu -> capi) == fmuKind) { jm_log_warning(fmu->callbacks, module, "FMU binary is already loaded"); return jm_status_success; } else fmi2_import_destroy_dllfmu(fmu); } if(fmuKind == fmi2_fmu_kind_me) modelIdentifier = fmi2_import_get_model_identifier_ME(fmu); else if(fmuKind == fmi2_fmu_kind_cs) modelIdentifier = fmi2_import_get_model_identifier_CS(fmu); else { assert(0); return jm_status_error; } if (modelIdentifier == NULL) { jm_log_error(fmu->callbacks, module, "No model identifier given"); return jm_status_error; } if( jm_portability_get_current_working_directory(curDir, FILENAME_MAX+1) != jm_status_success) { jm_log_warning(fmu->callbacks, module, "Could not get current working directory (%s)", strerror(errno)); curDir[0] = 0; }; dllDirPath = fmi_construct_dll_dir_name(fmu->callbacks, fmu->dirPath); dllFileName = fmi_construct_dll_file_name(fmu->callbacks, dllDirPath, modelIdentifier); if (!dllDirPath ||!dllFileName) { fmu->callbacks->free(dllDirPath); return jm_status_error; } if(!callBackFunctions) { jm_callbacks* cb = fmu->callbacks; defaultCallbacks.allocateMemory = cb->calloc; defaultCallbacks.freeMemory = cb->free; defaultCallbacks.componentEnvironment = fmu; defaultCallbacks.logger = fmi2_log_forwarding; defaultCallbacks.stepFinished = 0; callBackFunctions = &defaultCallbacks; } if(jm_portability_set_current_working_directory(dllDirPath) != jm_status_success) { jm_log_fatal(fmu->callbacks, module, "Could not change to the DLL directory %s", dllDirPath); if(ENOENT == errno) jm_log_fatal(fmu->callbacks, module, "No binary for this platform?"); else jm_log_fatal(fmu->callbacks, module, "System error: %s", strerror(errno)); } else { /* Allocate memory for the C-API struct */ fmu -> capi = fmi2_capi_create_dllfmu(fmu->callbacks, dllFileName, modelIdentifier, callBackFunctions, fmuKind); } /* Load the DLL handle */ if (fmu -> capi) { jm_log_info(fmu->callbacks, module, "Loading '" FMI_PLATFORM "' binary with '%s' platform types", fmi2_get_types_platform() ); if(fmi2_capi_load_dll(fmu -> capi) == jm_status_error) { fmi2_capi_destroy_dllfmu(fmu -> capi); fmu -> capi = NULL; } } if(curDir[0] && (jm_portability_set_current_working_directory(curDir) != jm_status_success)) { jm_log_error(fmu->callbacks, module, "Could not restore current working directory (%s)", strerror(errno)); } fmu->callbacks->free((jm_voidp)dllDirPath); fmu->callbacks->free((jm_voidp)dllFileName); if (fmu -> capi == NULL) { return jm_status_error; } /* Load the DLL functions */ if (fmi2_capi_load_fcn(fmu -> capi, fmi2_xml_get_capabilities(fmu->md)) == jm_status_error) { fmi2_capi_free_dll(fmu -> capi); fmi2_capi_destroy_dllfmu(fmu -> capi); fmu -> capi = NULL; return jm_status_error; } jm_log_verbose(fmu->callbacks, module, "Successfully loaded all the interface functions"); return jm_status_success; }