--- /dev/null
+/*\r
+ Copyright (C) 2012 Modelon AB\r
+\r
+ This program is free software: you can redistribute it and/or modify\r
+ it under the terms of the BSD style license.\r
+\r
+ This program is distributed in the hope that it will be useful,\r
+ but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
+ FMILIB_License.txt file for more details.\r
+\r
+ You should have received a copy of the FMILIB_License.txt file\r
+ along with this program. If not, contact Modelon AB <http://www.modelon.com>.\r
+*/\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <stdarg.h>\r
+#include <assert.h>\r
+#include <time.h>\r
+\r
+#include "config_test.h"\r
+\r
+#include <FMI/fmi_import_context.h>\r
+\r
+#include <FMI2/fmi2_import.h>\r
+\r
+int expect_error;\r
+\r
+int annotation_start_handle(void *context, const char *parentName, void *parent, const char *elm, const char **attr) {\r
+ int i = 0;\r
+ printf("Annotation element %s start (tool: %s, parent:%s)\n", elm, parentName, \r
+ parent?fmi2_import_get_variable_name((fmi2_import_variable_t*)parent):"model");\r
+ while(attr[i]) {\r
+ printf("Attribute %s = %s\n", attr[i], attr[i+1]);\r
+ i+=2;\r
+ }\r
+ printf("Annotation data:\n");\r
+ return 0;\r
+}\r
+\r
+int annotation_data_handle(void* context, const char *s, int len) {\r
+ int i;\r
+ for(i = 0; i < len; i++)\r
+ printf("%c", s[i]);\r
+ return 0;\r
+}\r
+\r
+int annotation_end_handle(void *context, const char *elm) {\r
+ printf("\nAnnotation element %s end\n", elm);\r
+ return 0;\r
+}\r
+\r
+/** \brief XML callbacks are used to process parts of XML that are not handled by the library */\r
+fmi2_xml_callbacks_t annotation_callbacks = {\r
+ annotation_start_handle,\r
+ annotation_data_handle,\r
+ annotation_end_handle, NULL};\r
+\r
+\r
+void do_exit(int code)\r
+{\r
+ printf("Press 'Enter' to exit\n");\r
+/* getchar(); */\r
+ exit(code);\r
+}\r
+\r
+void mylogger(jm_callbacks* c, jm_string module, jm_log_level_enu_t log_level, jm_string message)\r
+{\r
+ printf("[%s][%s] %s\n", module, jm_log_level_to_string(log_level), message);\r
+ if (!expect_error && log_level == jm_log_level_error) {\r
+ do_exit(1);\r
+ }\r
+}\r
+\r
+void print_int(int i,void* data) {\r
+ printf("%d\n", i);\r
+}\r
+\r
+void print_dbl(double d,void* data) {\r
+ printf("%g\n", d);\r
+}\r
+\r
+void printTypeInfo(fmi2_import_variable_typedef_t* vt) {\r
+ const char* quan;\r
+\r
+ if(!vt) {\r
+ printf("No type definition\n");\r
+ return;\r
+ }\r
+\r
+ quan = fmi2_import_get_type_quantity(vt);\r
+\r
+ printf("Type %s\n description: %s\n", fmi2_import_get_type_name(vt), fmi2_import_get_type_description(vt));\r
+\r
+ printf("Base type: %s\n", fmi2_base_type_to_string(fmi2_import_get_base_type(vt)));\r
+\r
+ if(quan) {\r
+ printf("Quantity: %s\n", quan);\r
+ }\r
+ switch(fmi2_import_get_base_type(vt)) {\r
+ case fmi2_base_type_real: {\r
+ fmi2_import_real_typedef_t* rt = fmi2_import_get_type_as_real(vt);\r
+ fmi2_real_t min = fmi2_import_get_real_type_min(rt);\r
+ fmi2_real_t max = fmi2_import_get_real_type_max(rt);\r
+ fmi2_real_t nom = fmi2_import_get_real_type_nominal(rt);\r
+ fmi2_import_unit_t* u = fmi2_import_get_real_type_unit(rt);\r
+ fmi2_import_display_unit_t* du = fmi2_import_get_type_display_unit(rt);\r
+\r
+ printf("Min %g, max %g, nominal %g\n", min, max, nom);\r
+\r
+ if(u) {\r
+ char buf[1000];\r
+ fmi2_SI_base_unit_exp_to_string(fmi2_import_get_SI_unit_exponents(u), 1000, buf);\r
+ printf("Unit: %s, base unit %s, factor %g, offset %g\n", \r
+ fmi2_import_get_unit_name(u), \r
+ buf,\r
+ fmi2_import_get_SI_unit_factor(u),\r
+ fmi2_import_get_SI_unit_offset(u));\r
+ }\r
+ if(du) {\r
+ printf("Display unit: %s, factor: %g, offset: %g, is relative: %s\n",\r
+ fmi2_import_get_display_unit_name(du),\r
+ fmi2_import_get_display_unit_factor(du),\r
+ fmi2_import_get_display_unit_offset(du),\r
+ fmi2_import_get_real_type_is_relative_quantity(rt)?"yes":"no"\r
+ );\r
+ }\r
+\r
+ break;\r
+ }\r
+ case fmi2_base_type_int:{\r
+ fmi2_import_integer_typedef_t* it = fmi2_import_get_type_as_int(vt);\r
+ int min = fmi2_import_get_integer_type_min(it);\r
+ int max = fmi2_import_get_integer_type_max(it);\r
+ printf("Min %d, max %d\n", min, max);\r
+ break;\r
+ }\r
+ case fmi2_base_type_bool:{\r
+ break;\r
+ }\r
+ case fmi2_base_type_str:{\r
+ break;\r
+ }\r
+ case fmi2_base_type_enum:{\r
+ fmi2_import_enumeration_typedef_t* et = fmi2_import_get_type_as_enum(vt);\r
+ int min = fmi2_import_get_enum_type_min(et);\r
+ int max = fmi2_import_get_enum_type_max(et);\r
+ printf("Min %d, max %d\n", min, max);\r
+ {\r
+ unsigned ni, i;\r
+ ni = fmi2_import_get_enum_type_size(et);\r
+ printf("There are %d items \n",ni);\r
+ for(i = 1; i <= ni; i++) {\r
+ int val = fmi2_import_get_enum_type_item_value(et, i);\r
+ const char* str = fmi2_import_get_enum_type_value_name(et, val);\r
+ const char* itnm = fmi2_import_get_enum_type_item_name(et, i);\r
+ assert(strcmp(itnm, str)==0);\r
+ printf("[%d] %s=%d (%s) \n", i, \r
+ itnm, \r
+ val,\r
+ fmi2_import_get_enum_type_item_description(et, i));\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ default:\r
+ printf("Error in fmiGetBaseType()\n");\r
+ }\r
+\r
+}\r
+\r
+void testVariableSearch(fmi2_import_t* fmu,\r
+ fmi2_import_variable_t* v) {\r
+\r
+ const char * a_name = fmi2_import_get_variable_name(v);\r
+ fmi2_import_variable_t* found = fmi2_import_get_variable_by_name(fmu, a_name);\r
+ if(found != v) {\r
+ printf("Searching by name %s found var %s\n", a_name, found?fmi2_import_get_variable_name(found):"nothing");\r
+ do_exit(1);\r
+ }\r
+ else {\r
+ printf("Searching by name worked fine\n");\r
+ }\r
+ found = fmi2_import_get_variable_by_vr(fmu, fmi2_import_get_variable_base_type(v),fmi2_import_get_variable_vr(v));\r
+ if(!found) {\r
+ printf("Searching by vr failed for variable '%s'\n", a_name);\r
+ do_exit(1);\r
+ }\r
+ else if(fmi2_import_get_variable_base_type(v) != fmi2_import_get_variable_base_type(found)) { \r
+ printf("Searching %s found var %s", a_name, fmi2_import_get_variable_name(found));\r
+ do_exit(1);\r
+ }\r
+ else if(fmi2_import_get_variable_vr(v) != fmi2_import_get_variable_vr(found)) { \r
+ printf("Searching %s found var %s", a_name, fmi2_import_get_variable_name(found));\r
+ do_exit(1);\r
+ }\r
+ else {\r
+ printf("Searching by vr worked fine\n");\r
+ }\r
+}\r
+\r
+void printVariableInfo(fmi2_import_t* fmu,\r
+ fmi2_import_variable_t* v) {\r
+ fmi2_base_type_enu_t bt;\r
+ size_t vr = fmi2_import_get_variable_vr(v);\r
+ assert(vr == (unsigned)vr);\r
+ printf("Variable name: %s\n", fmi2_import_get_variable_name(v));\r
+ printf("Description: %s\n", fmi2_import_get_variable_description(v));\r
+ printf("VR: %u\n", (unsigned)vr);\r
+ printf("Variability: %s\n", fmi2_variability_to_string(fmi2_import_get_variability(v)));\r
+ printf("Causality: %s\n", fmi2_causality_to_string(fmi2_import_get_causality(v)));\r
+ printf("Initial: %s\n", fmi2_initial_to_string(fmi2_import_get_initial(v)));\r
+\r
+ bt = fmi2_import_get_variable_base_type(v);\r
+ printf("Base type: %s\n", fmi2_base_type_to_string(bt));\r
+\r
+ printTypeInfo(fmi2_import_get_variable_declared_type(v));\r
+ if(bt == fmi2_base_type_real) {\r
+ fmi2_import_real_variable_t *rv = fmi2_import_get_variable_as_real(v);\r
+ fmi2_import_unit_t * u = fmi2_import_get_real_variable_unit(rv);\r
+ fmi2_import_display_unit_t * du = fmi2_import_get_real_variable_display_unit(rv);\r
+ printf("Unit: %s, display unit: %s\n", u ? fmi2_import_get_unit_name(u):0, du?fmi2_import_get_display_unit_name(du):"not provided");\r
+ }\r
+\r
+ if(fmi2_import_get_variable_has_start(v)) {\r
+ printf("There is a start value\n");\r
+\r
+ switch(fmi2_import_get_variable_base_type(v)) {\r
+ case fmi2_base_type_real: {\r
+ fmi2_import_real_variable_t *rv = fmi2_import_get_variable_as_real(v);\r
+ printf("start =%g\n", fmi2_import_get_real_variable_start(rv));\r
+ break;\r
+ }\r
+ case fmi2_base_type_int:{\r
+ printf("start =%d\n", fmi2_import_get_integer_variable_start(fmi2_import_get_variable_as_integer(v)));\r
+ break;\r
+ }\r
+ case fmi2_base_type_bool:{\r
+ printf("start = %d\n", fmi2_import_get_boolean_variable_start(fmi2_import_get_variable_as_boolean(v)));\r
+ break;\r
+ }\r
+ case fmi2_base_type_str:{\r
+ printf("start = '%s'\n", fmi2_import_get_string_variable_start(fmi2_import_get_variable_as_string(v)));\r
+ break;\r
+ }\r
+ case fmi2_base_type_enum:{\r
+ printf("start = %d\n", fmi2_import_get_enum_variable_start(fmi2_import_get_variable_as_enum(v)));\r
+ break;\r
+ }\r
+ default:\r
+ printf("Error in fmiGetBaseType()\n");\r
+ }\r
+ }\r
+ if(fmi2_import_get_variable_alias_kind(v) != fmi2_variable_is_not_alias) {\r
+ printf("The variable is aliased to %s\n",\r
+ fmi2_import_get_variable_name( fmi2_import_get_variable_alias_base(fmu, v)));\r
+ }\r
+ else {\r
+ printf("The variable is not an alias\n");\r
+ }\r
+ {\r
+ fmi2_import_variable_list_t* vl = fmi2_import_get_variable_aliases(fmu, v);\r
+ size_t i, n = fmi2_import_get_variable_list_size(vl);\r
+ if(n>1) {\r
+ printf("Listing aliases: \n");\r
+ for(i = 0;i<n;i++)\r
+ printf("\t%s\n",fmi2_import_get_variable_name(fmi2_import_get_variable(vl, i)));\r
+ }\r
+ fmi2_import_free_variable_list(vl);\r
+ }\r
+}\r
+\r
+void printCapabilitiesInfo(fmi2_import_t* fmu) {\r
+ size_t i;\r
+\r
+ for( i = 0; i < fmi2_capabilities_Num; ++i) {\r
+ printf("%s = %u\n", \r
+ fmi2_capability_to_string((fmi2_capabilities_enu_t)i), \r
+ fmi2_import_get_capability(fmu, (fmi2_capabilities_enu_t)i));\r
+ }\r
+}\r
+\r
+void printDependenciesInfo( fmi2_import_t* fmu, fmi2_import_variable_list_t* rows, fmi2_import_variable_list_t* cols, size_t* start, size_t *dep, char* factor) {\r
+ size_t i, j, nr;\r
+ if(!rows || !cols || !start) {\r
+ printf("Dependencies are not available\n");\r
+ if(rows) {\r
+ nr = fmi2_import_get_variable_list_size(rows);\r
+ for(i = 0; i < nr; i++) {\r
+ printf("\t%s\n",fmi2_import_get_variable_name(fmi2_import_get_variable(rows, i)));\r
+ }\r
+ }\r
+ return;\r
+ }\r
+ nr = fmi2_import_get_variable_list_size(rows);\r
+ for(i = 0; i < nr; i++) {\r
+ if(start[i] == start[i+1]) {\r
+ printf("\t%s has no dependencies\n",fmi2_import_get_variable_name(fmi2_import_get_variable(rows, i)));\r
+ }\r
+ else if((start[i] + 1 == start[i+1]) && (dep[start[i]] == 0)) {\r
+ printf("\t%s depends on all\n",fmi2_import_get_variable_name(fmi2_import_get_variable(rows, i)));\r
+ }\r
+ else {\r
+ printf("\t%s depends on:\n",fmi2_import_get_variable_name(fmi2_import_get_variable(rows, i)));\r
+ for(j = start[i]; j < start[i+1]; j++) {\r
+ printf("\t\t%s (factor kind: %s)\n",fmi2_import_get_variable_name(fmi2_import_get_variable(cols, dep[j]-1)), \r
+ fmi2_dependency_factor_kind_to_string((fmi2_dependency_factor_kind_enu_t)factor[j]));\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+int main(int argc, char *argv[])\r
+{\r
+ clock_t start, stop;\r
+ double t = 0.0;\r
+ const char* tmpPath;\r
+ jm_callbacks callbacks;\r
+ fmi_import_context_t* context;\r
+\r
+ fmi2_import_t* fmu;\r
+\r
+ if(argc < 2) {\r
+ printf("Usage: %s <path to a dir with modelDescription.xml>\n", argv[0]);\r
+ do_exit(1);\r
+ }\r
+\r
+ tmpPath = argv[1];\r
+ expect_error = argc > 2;\r
+\r
+ callbacks.malloc = malloc;\r
+ callbacks.calloc = calloc;\r
+ callbacks.realloc = realloc;\r
+ callbacks.free = free;\r
+ callbacks.logger = mylogger;\r
+ callbacks.context = 0;\r
+ callbacks.log_level = jm_log_level_debug;\r
+\r
+#ifdef FMILIB_GENERATE_BUILD_STAMP\r
+ printf("Library build stamp:\n%s\n", fmilib_get_build_stamp());\r
+#endif\r
+\r
+ context = fmi_import_allocate_context(&callbacks);\r
+\r
+ start = clock();\r
+ fmu = fmi2_import_parse_xml(context, tmpPath, &annotation_callbacks);\r
+\r
+ /* Stop timer */\r
+ stop = clock();\r
+ t = (double) (stop-start)/CLOCKS_PER_SEC;\r
+ printf("Parsing took %g seconds\n", t);\r
+ if(!fmu) {\r
+ printf("Error parsing XML, exiting\n");\r
+ fmi_import_free_context(context);\r
+ do_exit(1);\r
+ }\r
+\r
+ printf("Model name: %s\n", fmi2_import_get_model_name(fmu));\r
+ printf("Model GUID: %s\n", fmi2_import_get_GUID(fmu));\r
+ printf("FMU kind: %s\n", fmi2_fmu_kind_to_string(fmi2_import_get_fmu_kind(fmu)));\r
+ printf("Description: %s\n", fmi2_import_get_description(fmu));\r
+ printf("Author: %s\n", fmi2_import_get_author(fmu));\r
+ printf("FMI Version: %s\n", fmi2_import_get_model_standard_version(fmu));\r
+ printf("Generation tool: %s\n", fmi2_import_get_generation_tool(fmu));\r
+ printf("Generation date and time: %s\n", fmi2_import_get_generation_date_and_time(fmu));\r
+ printf("Version: %s\n", fmi2_import_get_model_version(fmu));\r
+ printf("Naming : %s\n", fmi2_naming_convention_to_string(fmi2_import_get_naming_convention(fmu)));\r
+\r
+ if(fmi2_import_get_fmu_kind(fmu) != fmi2_fmu_kind_cs)\r
+ printf("Model identifier ME: %s\n", fmi2_import_get_model_identifier_ME(fmu));\r
+ if(fmi2_import_get_fmu_kind(fmu) != fmi2_fmu_kind_me)\r
+ printf("Model identifier CS: %s\n", fmi2_import_get_model_identifier_CS(fmu));\r
+ printCapabilitiesInfo(fmu);\r
+\r
+ printf("NumberOfContinuousStates = " FMILIB_SIZET_FORMAT "\n", fmi2_import_get_number_of_continuous_states(fmu));\r
+ printf("NumberOfEventIndicators = " FMILIB_SIZET_FORMAT "\n", fmi2_import_get_number_of_event_indicators(fmu));\r
+\r
+ printf("Default experiment start = %g, end = %g, tolerance = %g, step = %g\n",\r
+ fmi2_import_get_default_experiment_start(fmu),\r
+ fmi2_import_get_default_experiment_stop(fmu),\r
+ fmi2_import_get_default_experiment_tolerance(fmu),\r
+ fmi2_import_get_default_experiment_step(fmu));\r
+\r
+ {\r
+ int n_sources = fmi2_import_get_source_files_me_num(fmu);\r
+ int k;\r
+ printf("There are %d source files for ME\n", n_sources);\r
+ for (k=0; k < n_sources; k++) {\r
+ printf("\t%s\n", fmi2_import_get_source_file_me(fmu, k));\r
+ }\r
+ }\r
+ {\r
+ int n_sources = fmi2_import_get_source_files_cs_num(fmu);\r
+ int k;\r
+ printf("There are %d source files for CS\n", n_sources);\r
+ for (k=0; k < n_sources; k++) {\r
+ printf("\t%s\n", fmi2_import_get_source_file_cs(fmu, k));\r
+ }\r
+ }\r
+\r
+\r
+ {\r
+ size_t i, nv = fmi2_import_get_vendors_num(fmu);\r
+ printf("There are %u tool annotation records \n", (unsigned)nv);\r
+ for( i = 0; i < nv; i++) {\r
+ printf("Vendor name [%u] %s", (unsigned)i, fmi2_import_get_vendor_name(fmu, i));\r
+ }\r
+ }\r
+ {\r
+ fmi2_import_unit_definitions_t* ud = fmi2_import_get_unit_definitions(fmu);\r
+ if(ud) {\r
+ unsigned i, nu = fmi2_import_get_unit_definitions_number(ud);\r
+ printf("There are %d different units used \n", nu);\r
+\r
+ for(i = 0; i < nu; i++) {\r
+ fmi2_import_unit_t* u = fmi2_import_get_unit(ud, i);\r
+ char buf[1000];\r
+ if(!u) {\r
+ printf("Error getting unit for index %d (%s)\n", i, fmi2_import_get_last_error(fmu));\r
+ break;\r
+ }\r
+ fmi2_SI_base_unit_exp_to_string(fmi2_import_get_SI_unit_exponents(u), 1000, buf);\r
+ printf("Unit [%d] is %s, base unit %s, factor %g, offset %g, it has %d display units\n", \r
+ i, fmi2_import_get_unit_name(u), \r
+ buf,\r
+ fmi2_import_get_SI_unit_factor(u),\r
+ fmi2_import_get_SI_unit_offset(u),\r
+ fmi2_import_get_unit_display_unit_number(u));\r
+ }\r
+ }\r
+ else\r
+ printf("Error getting unit definitions (%s)\n", fmi2_import_get_last_error(fmu));\r
+ }\r
+ {\r
+ fmi2_import_type_definitions_t* td = fmi2_import_get_type_definitions(fmu);\r
+ if(td) {\r
+ {\r
+ unsigned i, ntd = fmi2_import_get_type_definition_number(td);\r
+ printf("There are %d defs\n", ntd);\r
+ for(i = 0; i < ntd; i++) {\r
+ fmi2_import_variable_typedef_t* vt = fmi2_import_get_typedef(td, i);\r
+ if(!vt) {\r
+ printf("Error getting vartype for index %d (%s)\n", i, fmi2_import_get_last_error(fmu));\r
+ break;\r
+ }\r
+ printTypeInfo(vt);\r
+ }\r
+ }\r
+ }\r
+ else\r
+ printf("Error getting type definitions (%s)\n", fmi2_import_get_last_error(fmu));\r
+ }\r
+ {\r
+ size_t nv, i;\r
+ fmi2_import_variable_list_t* vl = fmi2_import_get_variable_list(fmu, 0);\r
+/* fmi2_import_variable_list_t* ders = fmi2_import_get_derivatives_list( fmu); */\r
+ const fmi2_value_reference_t* vrl = fmi2_import_get_value_referece_list(vl);\r
+\r
+\r
+ assert(vl);\r
+ \r
+ nv = fmi2_import_get_variable_list_size(vl);\r
+ printf("There are %u variables in total \n",(unsigned)nv);\r
+ for(i = 0; i < nv; i++) {\r
+ fmi2_import_variable_t* var = fmi2_import_get_variable(vl, i);\r
+ assert(vrl[i] == fmi2_import_get_variable_vr(var));\r
+ if(!var) {\r
+ printf("Something wrong with variable %u \n",(unsigned)i);\r
+ do_exit(1);\r
+ }\r
+ else {\r
+ printVariableInfo(fmu, var);\r
+/* size_t stateIndex = fmi2_import_get_state_index(var);\r
+ if(stateIndex) {\r
+ printf("This variable is a state. Its derivative: %s\n", \r
+ fmi2_import_get_variable_name(fmi2_import_get_variable(ders, stateIndex-1)));\r
+ } */\r
+ testVariableSearch(fmu, var);\r
+ }\r
+ }\r
+ fmi2_import_free_variable_list(vl);\r
+/* fmi2_import_free_variable_list(ders); */\r
+ }\r
+/* {\r
+ fmi2_import_variable_list_t* vl = fmi2_import_get_inputs_list( fmu);\r
+ size_t i, n = 0;\r
+ if(vl) \r
+ n = fmi2_import_get_variable_list_size(vl);\r
+ if(n>0) {\r
+ printf("Listing inputs: \n");\r
+ for(i = 0;i<n;i++) \r
+ printf("\t%s\n",fmi2_import_get_variable_name(fmi2_import_get_variable(vl, i)));\r
+ }\r
+ else {\r
+ printf("There are no inputs\n");\r
+ }\r
+ fmi2_import_free_variable_list(vl);\r
+ } \r
+ {\r
+ fmi2_import_variable_list_t* states = fmi2_import_get_states_list( fmu);\r
+ fmi2_import_variable_list_t* inputs = fmi2_import_get_inputs_list( fmu);\r
+ size_t n = 0;\r
+ if(states) \r
+ n = fmi2_import_get_variable_list_size(states);\r
+ if(n>0) {\r
+ size_t *start, *dep;\r
+ char* factor;\r
+ printf("Listing states and dependencies on inputs: \n");\r
+ fmi2_import_get_dependencies_derivatives_on_inputs(fmu, &start, &dep, &factor);\r
+ printDependenciesInfo( fmu, states, inputs, start, dep, factor);\r
+\r
+ fmi2_import_get_dependencies_derivatives_on_states(fmu, &start, &dep, &factor);\r
+ if(start) {\r
+ printf("Listing states and dependencies on other states: \n");\r
+ printDependenciesInfo( fmu, states, states, start, dep, factor);\r
+ }\r
+ else {\r
+ printf("No dependencies on states available\n");\r
+ }\r
+ }\r
+ else {\r
+ printf("There are no states\n");\r
+ }\r
+ fmi2_import_free_variable_list(inputs);\r
+ fmi2_import_free_variable_list(states);\r
+ } \r
+ {\r
+ fmi2_import_variable_list_t* states = fmi2_import_get_states_list( fmu);\r
+ fmi2_import_variable_list_t* inputs = fmi2_import_get_inputs_list( fmu);\r
+ fmi2_import_variable_list_t* outputs = fmi2_import_get_outputs_list( fmu);\r
+ size_t n = 0;\r
+ if(outputs) \r
+ n = fmi2_import_get_variable_list_size(outputs);\r
+ if(n>0) {\r
+ size_t *start, *dep;\r
+ char* factor;\r
+ printf("Listing outputs and dependencies on inputs: \n");\r
+ fmi2_import_get_dependencies_outputs_on_inputs(fmu, &start, &dep, &factor);\r
+ printDependenciesInfo( fmu, outputs, inputs, start, dep, factor);\r
+\r
+ fmi2_import_get_dependencies_outputs_on_states(fmu, &start, &dep, &factor);\r
+ if(start) {\r
+ printf("Listing outputs and dependencies on states: \n");\r
+ printDependenciesInfo( fmu, outputs, states, start, dep, factor);\r
+ }\r
+ else {\r
+ printf("No dependencies on states available\n");\r
+ }\r
+ }\r
+ else {\r
+ printf("There are no outputs\n");\r
+ }\r
+ fmi2_import_free_variable_list(outputs);\r
+ fmi2_import_free_variable_list(inputs);\r
+ fmi2_import_free_variable_list(states);\r
+ } \r
+*/\r
+ fmi2_import_free(fmu);\r
+ fmi_import_free_context(context);\r
+ \r
+ printf("Everything seems to be OK since you got this far=)!\n");\r
+\r
+ do_exit(0);\r
+}\r
+\r
+\r
Code Review / simantics / fmil.git / blobdiff