org.simantics.fmil.core/native/FMILibrary/Test/FMI1/fmi_import_xml_test.c

   1 /*\r
   2     Copyright (C) 2012 Modelon AB\r
   3 \r
   4     This program is free software: you can redistribute it and/or modify\r
   5     it under the terms of the BSD style license.\r
   6 \r
   7     This program is distributed in the hope that it will be useful,\r
   8     but WITHOUT ANY WARRANTY; without even the implied warranty of\r
   9     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  10     FMILIB_License.txt file for more details.\r
  11 \r
  12     You should have received a copy of the FMILIB_License.txt file\r
  13     along with this program. If not, contact Modelon AB <http://www.modelon.com>.\r
  14 */\r
  15 \r
  16 #include <stdio.h>\r
  17 #include <stdlib.h>\r
  18 #include <stdarg.h>\r
  19 #include <assert.h>\r
  20 #include <time.h>\r
  21 \r
  22 #include "config_test.h"\r
  23 \r
  24 #include <FMI/fmi_import_context.h>\r
  25 \r
  26 #include <FMI1/fmi1_import.h>\r
  27 \r
  28 \r
  29 void mylogger(jm_callbacks* c, jm_string module, jm_log_level_enu_t log_level, jm_string message)\r
  30 {\r
  31         printf("module = %s, log level = %d: %s\n", module, log_level, message);\r
  32 }\r
  33 \r
  34 void do_exit(int code)\r
  35 {\r
  36         printf("Press 'Enter' to exit\n");\r
  37 /*      getchar(); */\r
  38         exit(code);\r
  39 }\r
  40 \r
  41 void print_int(int i,void* data) {\r
  42     printf("%d\n", i);\r
  43 }\r
  44 \r
  45 void print_dbl(double d,void* data) {\r
  46     printf("%g\n", d);\r
  47 }\r
  48 \r
  49 void printTypeInfo(fmi1_import_variable_typedef_t* vt) {\r
  50     const char* quan;\r
  51 \r
  52     if(!vt) {\r
  53         printf("No type definition\n");\r
  54         return;\r
  55     }\r
  56 \r
  57     quan = fmi1_import_get_type_quantity(vt);\r
  58 \r
  59     printf("Type %s\n description: %s\n",  fmi1_import_get_type_name(vt), fmi1_import_get_type_description(vt));\r
  60 \r
  61     printf("Base type: %s\n", fmi1_base_type_to_string(fmi1_import_get_base_type(vt)));\r
  62 \r
  63     if(quan) {\r
  64         printf("Quantity: %s\n", quan);\r
  65     }\r
  66     switch(fmi1_import_get_base_type(vt)) {\r
  67     case fmi1_base_type_real: {\r
  68         fmi1_import_real_typedef_t* rt = fmi1_import_get_type_as_real(vt);\r
  69         fmi1_real_t min = fmi1_import_get_real_type_min(rt);\r
  70         fmi1_real_t max = fmi1_import_get_real_type_max(rt);\r
  71         fmi1_real_t nom = fmi1_import_get_real_type_nominal(rt);\r
  72         fmi1_import_unit_t* u = fmi1_import_get_real_type_unit(rt);\r
  73         fmi1_import_display_unit_t* du = fmi1_import_get_type_display_unit(rt);\r
  74 \r
  75         printf("Min %g, max %g, nominal %g\n", min, max, nom);\r
  76 \r
  77         if(u) {\r
  78             printf("Unit: %s\n", fmi1_import_get_unit_name(u));\r
  79         }\r
  80         if(du) {\r
  81             printf("Display unit: %s, gain: %g, offset: %g, is relative: %s",\r
  82                    fmi1_import_get_display_unit_name(du),\r
  83                    fmi1_import_get_display_unit_gain(du),\r
  84                    fmi1_import_get_display_unit_offset(du),\r
  85                    fmi1_import_get_real_type_is_relative_quantity(rt)?"yes":"no"\r
  86                    );\r
  87         }\r
  88 \r
  89         break;\r
  90     }\r
  91     case fmi1_base_type_int:{\r
  92         fmi1_import_integer_typedef_t* it = fmi1_import_get_type_as_int(vt);\r
  93         int min = fmi1_import_get_integer_type_min(it);\r
  94         int max = fmi1_import_get_integer_type_max(it);\r
  95         printf("Min %d, max %d\n", min, max);\r
  96         break;\r
  97     }\r
  98     case fmi1_base_type_bool:{\r
  99         break;\r
 100     }\r
 101     case fmi1_base_type_str:{\r
 102         break;\r
 103     }\r
 104     case fmi1_base_type_enum:{\r
 105         fmi1_import_enumeration_typedef_t* et = fmi1_import_get_type_as_enum(vt);\r
 106         int min = fmi1_import_get_enum_type_min(et);\r
 107         int max = fmi1_import_get_enum_type_max(et);\r
 108         printf("Min %d, max %d\n", min, max);\r
 109         {\r
 110             size_t ni;\r
 111                         unsigned i;\r
 112             ni = fmi1_import_get_enum_type_size(et);\r
 113                         i = (unsigned)(ni);\r
 114                         assert( i == ni);\r
 115             printf("There are %u items \n",(unsigned)ni);\r
 116             for(i = 0; i < ni; i++) {\r
 117                 printf("[%u] %s (%s) \n", (unsigned)i+1, fmi1_import_get_enum_type_item_name(et, i), fmi1_import_get_enum_type_item_description(et, i));\r
 118             }\r
 119         }\r
 120         break;\r
 121     }\r
 122     default:\r
 123         printf("Error in fmiGetBaseType()\n");\r
 124     }\r
 125 \r
 126 }\r
 127 \r
 128 void testVariableSearch(fmi1_import_t* fmu,\r
 129         fmi1_import_variable_t* v) {\r
 130 \r
 131                 const char * a_name = fmi1_import_get_variable_name(v);\r
 132                 fmi1_import_variable_t* found = fmi1_import_get_variable_by_name(fmu, a_name);\r
 133                 if(found != v) {\r
 134                         printf("Searching by name %s found var %s\n", a_name, found?fmi1_import_get_variable_name(found):"nothing");\r
 135                         do_exit(1);\r
 136                 }\r
 137                 else {\r
 138                         printf("Searching by name worked fine\n");\r
 139                 }\r
 140                 found = fmi1_import_get_variable_by_vr(fmu, fmi1_import_get_variable_base_type(v),fmi1_import_get_variable_vr(v));\r
 141                 if(!found) {\r
 142                         printf("Searching by vr failed for variable '%s'\n", a_name);\r
 143                         do_exit(1);\r
 144                 }\r
 145                 else if(fmi1_import_get_variable_base_type(v) != fmi1_import_get_variable_base_type(found)) {                   \r
 146                         printf("Searching %s found var %s", a_name, fmi1_import_get_variable_name(found));\r
 147                         do_exit(1);\r
 148                 }\r
 149                 else if(fmi1_import_get_variable_vr(v) != fmi1_import_get_variable_vr(found)) {                 \r
 150                         printf("Searching %s found var %s", a_name, fmi1_import_get_variable_name(found));\r
 151                         do_exit(1);\r
 152                 }\r
 153                 else {\r
 154                         printf("Searching by vr worked fine\n");\r
 155                 }\r
 156 }\r
 157 \r
 158 void printVariableInfo(fmi1_import_t* fmu,\r
 159                        fmi1_import_variable_t* v) {\r
 160     fmi1_base_type_enu_t bt;\r
 161     printf("Variable name: %s\n", fmi1_import_get_variable_name(v));\r
 162     printf("Description: %s\n", fmi1_import_get_variable_description(v));\r
 163     printf("VR: %d\n", fmi1_import_get_variable_vr(v));\r
 164     printf("Variability: %s\n", fmi1_variability_to_string(fmi1_import_get_variability(v)));\r
 165     printf("Causality: %s\n", fmi1_causality_to_string(fmi1_import_get_causality(v)));\r
 166 \r
 167     bt = fmi1_import_get_variable_base_type(v);\r
 168     printf("Base type: %s\n", fmi1_base_type_to_string(bt));\r
 169 \r
 170     printTypeInfo(fmi1_import_get_variable_declared_type(v));\r
 171     if(bt == fmi1_base_type_real) {\r
 172         fmi1_import_real_variable_t *rv = fmi1_import_get_variable_as_real(v);\r
 173         fmi1_import_unit_t * u = fmi1_import_get_real_variable_unit(rv);\r
 174         fmi1_import_display_unit_t * du = fmi1_import_get_real_variable_display_unit(rv);\r
 175         printf("Unit: %s, display unit: %s\n", u ? fmi1_import_get_unit_name(u):0, du?fmi1_import_get_display_unit_name(du):0);\r
 176     }\r
 177 \r
 178     if(fmi1_import_get_variable_has_start(v)) {\r
 179         printf("There is a start value, fixed attribute is '%s'\n", (fmi1_import_get_variable_is_fixed(v))?"true":"false");\r
 180 \r
 181         switch(fmi1_import_get_variable_base_type(v)) {\r
 182         case fmi1_base_type_real: {\r
 183             fmi1_import_real_variable_t *rv = fmi1_import_get_variable_as_real(v);\r
 184             printf("start =%g\n", fmi1_import_get_real_variable_start(rv));\r
 185             break;\r
 186         }\r
 187         case fmi1_base_type_int:{\r
 188             printf("start =%d\n", fmi1_import_get_integer_variable_start(fmi1_import_get_variable_as_integer(v)));\r
 189             break;\r
 190         }\r
 191         case fmi1_base_type_bool:{\r
 192             printf("start = %d\n", fmi1_import_get_boolean_variable_start(fmi1_import_get_variable_as_boolean(v)));\r
 193             break;\r
 194         }\r
 195         case fmi1_base_type_str:{\r
 196             printf("start = '%s'\n", fmi1_import_get_string_variable_start(fmi1_import_get_variable_as_string(v)));\r
 197             break;\r
 198         }\r
 199         case fmi1_base_type_enum:{\r
 200             printf("start = %d\n", fmi1_import_get_enum_variable_start(fmi1_import_get_variable_as_enum(v)));\r
 201             break;\r
 202         }\r
 203         default:\r
 204             printf("Error in fmiGetBaseType()\n");\r
 205         }\r
 206     }\r
 207     if(fmi1_import_get_variable_alias_kind(v) != fmi1_variable_is_not_alias) {\r
 208         printf("The variable is aliased to %s\n",\r
 209                fmi1_import_get_variable_name( fmi1_import_get_variable_alias_base(fmu, v)));\r
 210     }\r
 211     else {\r
 212         printf("The variable is not an alias\n");\r
 213     }\r
 214     {\r
 215         fmi1_import_variable_list_t* vl = fmi1_import_get_variable_aliases(fmu, v);\r
 216         size_t n = fmi1_import_get_variable_list_size(vl);\r
 217                 unsigned i = (unsigned)n;\r
 218                 assert( n == i);\r
 219         if(n>1) {\r
 220             printf("Listing aliases: \n");\r
 221             for(i = 0;i<n;i++)\r
 222                 printf("\t%s\n",fmi1_import_get_variable_name(fmi1_import_get_variable(vl, i)));\r
 223         }\r
 224         fmi1_import_free_variable_list(vl);\r
 225     }\r
 226         {\r
 227                 fmi1_import_variable_list_t* vl = fmi1_import_get_direct_dependency( fmu, v);\r
 228         size_t n = 0;\r
 229                 unsigned i;\r
 230                 if(vl) \r
 231                         n = fmi1_import_get_variable_list_size(vl);\r
 232                 i = (unsigned)n;\r
 233                 assert( n == i);                \r
 234         if(vl) {\r
 235             printf("Listing direct dependencies: \n");\r
 236             for(i = 0;i<n;i++)\r
 237                 printf("\t%s\n",fmi1_import_get_variable_name(fmi1_import_get_variable(vl, i)));\r
 238         }\r
 239         fmi1_import_free_variable_list(vl);\r
 240         }\r
 241 }\r
 242 \r
 243 void printCapabilitiesInfo(fmi1_import_capabilities_t* capabilities) {\r
 244     printf("canHandleVariableCommunicationStepSize = %u\n", fmi1_import_get_canHandleVariableCommunicationStepSize(capabilities ));\r
 245     printf("canHandleEvents = %u\n", fmi1_import_get_canHandleEvents(capabilities ));\r
 246     printf("canRejectSteps = %u\n", fmi1_import_get_canRejectSteps(capabilities ));\r
 247     printf("canInterpolateInputs = %u\n", fmi1_import_get_canInterpolateInputs(capabilities ));\r
 248     printf("maxOutputDerivativeOrder = %u\n", fmi1_import_get_maxOutputDerivativeOrder(capabilities ));\r
 249     printf("canRunAsynchronuously = %u\n", fmi1_import_get_canRunAsynchronuously(capabilities ));\r
 250     printf("canSignalEvents = %u\n", fmi1_import_get_canSignalEvents(capabilities ));\r
 251     printf("canBeInstantiatedOnlyOncePerProcess = %u\n", fmi1_import_get_canBeInstantiatedOnlyOncePerProcess(capabilities ));\r
 252     printf("canNotUseMemoryManagementFunctions = %u\n", fmi1_import_get_canNotUseMemoryManagementFunctions(capabilities ));\r
 253 }\r
 254 \r
 255 \r
 256 int main(int argc, char *argv[])\r
 257 {\r
 258     clock_t start, stop;\r
 259     double t = 0.0;\r
 260         const char* tmpPath;\r
 261         jm_callbacks callbacks;\r
 262         fmi_import_context_t* context;\r
 263 \r
 264         fmi1_import_t* fmu;\r
 265 \r
 266         if(argc < 2) {\r
 267                 printf("Usage: %s <path to a dir with modelDescription.xml>\n", argv[0]);\r
 268                 do_exit(1);\r
 269         }\r
 270 \r
 271         tmpPath = argv[1];\r
 272 \r
 273         callbacks.malloc = malloc;\r
 274     callbacks.calloc = calloc;\r
 275     callbacks.realloc = realloc;\r
 276     callbacks.free = free;\r
 277     callbacks.logger = mylogger;\r
 278     callbacks.context = 0;\r
 279         callbacks.log_level = jm_log_level_debug;\r
 280 \r
 281 #ifdef FMILIB_GENERATE_BUILD_STAMP\r
 282         printf("Library build stamp:\n%s\n", fmilib_get_build_stamp());\r
 283 #endif\r
 284 \r
 285         context = fmi_import_allocate_context(&callbacks);\r
 286 \r
 287         start = clock();\r
 288         fmu = fmi1_import_parse_xml(context, tmpPath);\r
 289 \r
 290         if(!fmu) {\r
 291                 printf("Error parsing XML, exiting\n");\r
 292         fmi_import_free_context(context);       \r
 293                 do_exit(1);\r
 294         }\r
 295 \r
 296             /* Stop timer */\r
 297     stop = clock();\r
 298     t = (double) (stop-start)/CLOCKS_PER_SEC;\r
 299 \r
 300     printf("Parsing took %g seconds\n", t);\r
 301     printf("Model name: %s\n", fmi1_import_get_model_name(fmu));\r
 302     printf("Model identifier: %s\n", fmi1_import_get_model_identifier(fmu));\r
 303     printf("Model GUID: %s\n", fmi1_import_get_GUID(fmu));\r
 304     printf("FMU kind: %s\n", fmi1_fmu_kind_to_string(fmi1_import_get_fmu_kind(fmu)));\r
 305     printf("Description: %s\n", fmi1_import_get_description(fmu));\r
 306     printf("Author: %s\n", fmi1_import_get_author(fmu));\r
 307     printf("FMI Version: %s\n", fmi1_import_get_model_standard_version(fmu));\r
 308     printf("Generation tool: %s\n", fmi1_import_get_generation_tool(fmu));\r
 309     printf("Generation date and time: %s\n", fmi1_import_get_generation_date_and_time(fmu));\r
 310     printf("Version: %s\n", fmi1_import_get_model_version(fmu));\r
 311     printf("Naming : %s\n", fmi1_naming_convention_to_string(fmi1_import_get_naming_convention(fmu)));\r
 312 \r
 313     if(fmi1_import_get_fmu_kind(fmu) != fmi1_fmu_kind_enu_me)\r
 314         printCapabilitiesInfo(fmi1_import_get_capabilities(fmu));\r
 315 \r
 316     printf("NumberOfContinuousStates = %d\n", fmi1_import_get_number_of_continuous_states(fmu));\r
 317     printf("NumberOfEventIndicators = %d\n", fmi1_import_get_number_of_event_indicators(fmu));\r
 318 \r
 319     printf("Default experiment start = %g, end = %g, tolerance = %g\n",\r
 320            fmi1_import_get_default_experiment_start(fmu),\r
 321            fmi1_import_get_default_experiment_stop(fmu),\r
 322            fmi1_import_get_default_experiment_tolerance(fmu));\r
 323     {\r
 324         fmi1_import_vendor_list_t* vl = fmi1_import_get_vendor_list(fmu);\r
 325         size_t nv = fmi1_import_get_number_of_vendors(vl);\r
 326                 unsigned i;\r
 327                 i = (unsigned)nv;\r
 328                 assert( nv == i);               \r
 329         printf("There are %u tool annotation records \n", (unsigned)nv);\r
 330         for( i = 0; i < nv; i++) {\r
 331             fmi1_import_vendor_t* vendor = fmi1_import_get_vendor(vl, i);\r
 332             if(!vendor) {\r
 333                 printf("Error getting vendor for index %u\n", (unsigned)i);\r
 334                 break;\r
 335             }\r
 336             printf("Vendor name [%d] %s", i, fmi1_import_get_vendor_name(vendor));\r
 337             {\r
 338                 unsigned j, na = fmi1_import_get_number_of_vendor_annotations(vendor);\r
 339 \r
 340                 for(j = 0; j< na; j++) {\r
 341                     fmi1_import_annotation_t* a = fmi1_import_get_vendor_annotation(vendor, j);\r
 342                     if(!a) {\r
 343                         printf("Error getting vendor for index %d (%s)\n", j, fmi1_import_get_last_error(fmu));\r
 344                         break;\r
 345                     }\r
 346 \r
 347                     printf("Annotation: %s = %s", fmi1_import_get_annotation_name(a), fmi1_import_get_annotation_value(a));\r
 348                 }\r
 349             }\r
 350         }\r
 351     }\r
 352     {\r
 353         fmi1_import_unit_definitions_t* ud = fmi1_import_get_unit_definitions(fmu);\r
 354         if(ud) {\r
 355             unsigned  i, nu = fmi1_import_get_unit_definitions_number(ud);\r
 356             printf("There are %d different units used \n", nu);\r
 357 \r
 358             for(i = 0; i < nu; i++) {\r
 359                 fmi1_import_unit_t* u = fmi1_import_get_unit(ud, i);\r
 360                 if(!u) {\r
 361                     printf("Error getting unit for index %d (%s)\n", i, fmi1_import_get_last_error(fmu));\r
 362                     break;\r
 363                 }\r
 364                 printf("Unit [%d] is %s, it has %d display units\n", i, fmi1_import_get_unit_name(u), fmi1_import_get_unit_display_unit_number(u));\r
 365             }\r
 366         }\r
 367         else\r
 368             printf("Error getting unit definitions (%s)\n", fmi1_import_get_last_error(fmu));\r
 369     }\r
 370     {\r
 371         fmi1_import_type_definitions_t* td = fmi1_import_get_type_definitions(fmu);\r
 372         if(td) {\r
 373             {\r
 374                 unsigned i, ntd = (unsigned)fmi1_import_get_type_definition_number(td);\r
 375                 printf("There are %d defs\n", ntd);\r
 376                 for(i = 0; i < ntd; i++) {\r
 377                     fmi1_import_variable_typedef_t* vt = fmi1_import_get_typedef(td, i);\r
 378                     if(!vt) {\r
 379                         printf("Error getting vartype for index %d (%s)\n", i, fmi1_import_get_last_error(fmu));\r
 380                         break;\r
 381                     }\r
 382                     printTypeInfo(vt);\r
 383                 }\r
 384             }\r
 385         }\r
 386         else\r
 387             printf("Error getting type definitions (%s)\n", fmi1_import_get_last_error(fmu));\r
 388     }\r
 389     {\r
 390         size_t nv;\r
 391                 unsigned i;\r
 392         fmi1_import_variable_list_t* vl = fmi1_import_get_variable_list(fmu);\r
 393 \r
 394         assert(vl);\r
 395         nv = fmi1_import_get_variable_list_size(vl);\r
 396                 i = (unsigned)nv;\r
 397                 assert(i == nv);\r
 398                 printf("There are %u variables in total \n",(unsigned)nv);\r
 399         for(i = 0; i < nv; i++) {\r
 400             fmi1_import_variable_t* var = fmi1_import_get_variable(vl, i);\r
 401             if(!var) {\r
 402                                 printf("Something wrong with variable %d \n",i);\r
 403                                 do_exit(1);\r
 404                         }\r
 405             else {\r
 406                 printVariableInfo(fmu, var);\r
 407                                 testVariableSearch(fmu, var);\r
 408                         }\r
 409         }\r
 410         fmi1_import_free_variable_list(vl);\r
 411     }\r
 412 \r
 413         fmi1_import_free(fmu);\r
 414         fmi_import_free_context(context);\r
 415         \r
 416         printf("Everything seems to be OK since you got this far=)!\n");\r
 417 \r
 418         do_exit(0);\r
 419 }\r
 420 \r
 421 \r