2 Copyright (C) 2012 Modelon AB
\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
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
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
22 #include "config_test.h"
\r
24 #include <FMI/fmi_import_context.h>
\r
26 #include <FMI1/fmi1_import.h>
\r
29 void mylogger(jm_callbacks* c, jm_string module, jm_log_level_enu_t log_level, jm_string message)
\r
31 printf("module = %s, log level = %d: %s\n", module, log_level, message);
\r
34 void do_exit(int code)
\r
36 printf("Press 'Enter' to exit\n");
\r
41 void print_int(int i,void* data) {
\r
45 void print_dbl(double d,void* data) {
\r
49 void printTypeInfo(fmi1_import_variable_typedef_t* vt) {
\r
53 printf("No type definition\n");
\r
57 quan = fmi1_import_get_type_quantity(vt);
\r
59 printf("Type %s\n description: %s\n", fmi1_import_get_type_name(vt), fmi1_import_get_type_description(vt));
\r
61 printf("Base type: %s\n", fmi1_base_type_to_string(fmi1_import_get_base_type(vt)));
\r
64 printf("Quantity: %s\n", quan);
\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
75 printf("Min %g, max %g, nominal %g\n", min, max, nom);
\r
78 printf("Unit: %s\n", fmi1_import_get_unit_name(u));
\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
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
98 case fmi1_base_type_bool:{
\r
101 case fmi1_base_type_str:{
\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
112 ni = fmi1_import_get_enum_type_size(et);
\r
113 i = (unsigned)(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
123 printf("Error in fmiGetBaseType()\n");
\r
128 void testVariableSearch(fmi1_import_t* fmu,
\r
129 fmi1_import_variable_t* v) {
\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
134 printf("Searching by name %s found var %s\n", a_name, found?fmi1_import_get_variable_name(found):"nothing");
\r
138 printf("Searching by name worked fine\n");
\r
140 found = fmi1_import_get_variable_by_vr(fmu, fmi1_import_get_variable_base_type(v),fmi1_import_get_variable_vr(v));
\r
142 printf("Searching by vr failed for variable '%s'\n", a_name);
\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
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
154 printf("Searching by vr worked fine\n");
\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
167 bt = fmi1_import_get_variable_base_type(v);
\r
168 printf("Base type: %s\n", fmi1_base_type_to_string(bt));
\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
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
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
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
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
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
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
204 printf("Error in fmiGetBaseType()\n");
\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
212 printf("The variable is not an alias\n");
\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
220 printf("Listing aliases: \n");
\r
222 printf("\t%s\n",fmi1_import_get_variable_name(fmi1_import_get_variable(vl, i)));
\r
224 fmi1_import_free_variable_list(vl);
\r
227 fmi1_import_variable_list_t* vl = fmi1_import_get_direct_dependency( fmu, v);
\r
231 n = fmi1_import_get_variable_list_size(vl);
\r
235 printf("Listing direct dependencies: \n");
\r
237 printf("\t%s\n",fmi1_import_get_variable_name(fmi1_import_get_variable(vl, i)));
\r
239 fmi1_import_free_variable_list(vl);
\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
256 int main(int argc, char *argv[])
\r
258 clock_t start, stop;
\r
260 const char* tmpPath;
\r
261 jm_callbacks callbacks;
\r
262 fmi_import_context_t* context;
\r
264 fmi1_import_t* fmu;
\r
267 printf("Usage: %s <path to a dir with modelDescription.xml>\n", argv[0]);
\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
281 #ifdef FMILIB_GENERATE_BUILD_STAMP
\r
282 printf("Library build stamp:\n%s\n", fmilib_get_build_stamp());
\r
285 context = fmi_import_allocate_context(&callbacks);
\r
288 fmu = fmi1_import_parse_xml(context, tmpPath);
\r
291 printf("Error parsing XML, exiting\n");
\r
292 fmi_import_free_context(context);
\r
298 t = (double) (stop-start)/CLOCKS_PER_SEC;
\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
313 if(fmi1_import_get_fmu_kind(fmu) != fmi1_fmu_kind_enu_me)
\r
314 printCapabilitiesInfo(fmi1_import_get_capabilities(fmu));
\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
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
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
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
333 printf("Error getting vendor for index %u\n", (unsigned)i);
\r
336 printf("Vendor name [%d] %s", i, fmi1_import_get_vendor_name(vendor));
\r
338 unsigned j, na = fmi1_import_get_number_of_vendor_annotations(vendor);
\r
340 for(j = 0; j< na; j++) {
\r
341 fmi1_import_annotation_t* a = fmi1_import_get_vendor_annotation(vendor, j);
\r
343 printf("Error getting vendor for index %d (%s)\n", j, fmi1_import_get_last_error(fmu));
\r
347 printf("Annotation: %s = %s", fmi1_import_get_annotation_name(a), fmi1_import_get_annotation_value(a));
\r
353 fmi1_import_unit_definitions_t* ud = fmi1_import_get_unit_definitions(fmu);
\r
355 unsigned i, nu = fmi1_import_get_unit_definitions_number(ud);
\r
356 printf("There are %d different units used \n", nu);
\r
358 for(i = 0; i < nu; i++) {
\r
359 fmi1_import_unit_t* u = fmi1_import_get_unit(ud, i);
\r
361 printf("Error getting unit for index %d (%s)\n", i, fmi1_import_get_last_error(fmu));
\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
368 printf("Error getting unit definitions (%s)\n", fmi1_import_get_last_error(fmu));
\r
371 fmi1_import_type_definitions_t* td = fmi1_import_get_type_definitions(fmu);
\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
379 printf("Error getting vartype for index %d (%s)\n", i, fmi1_import_get_last_error(fmu));
\r
387 printf("Error getting type definitions (%s)\n", fmi1_import_get_last_error(fmu));
\r
392 fmi1_import_variable_list_t* vl = fmi1_import_get_variable_list(fmu);
\r
395 nv = fmi1_import_get_variable_list_size(vl);
\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
402 printf("Something wrong with variable %d \n",i);
\r
406 printVariableInfo(fmu, var);
\r
407 testVariableSearch(fmu, var);
\r
410 fmi1_import_free_variable_list(vl);
\r
413 fmi1_import_free(fmu);
\r
414 fmi_import_free_context(context);
\r
416 printf("Everything seems to be OK since you got this far=)!\n");
\r