fmi_import_cs_test.c

Go to the documentation of this file.

/*
    Copyright (C) 2012 Modelon AB

    This program is free software: you can redistribute it and/or modify
    it under the terms of the BSD style license.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    FMILIB_License.txt file for more details.

    You should have received a copy of the FMILIB_License.txt file
    along with this program. If not, contact Modelon AB <http://www.modelon.com>.
*/

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>

#include "config_test.h"

#include <fmilib.h>


#define BUFFER 1000

void importlogger(jm_callbacks* c, jm_string module, jm_log_level_enu_t log_level, jm_string message)
{
        printf("module = %s, log level = %s: %s\n", module, jm_log_level_to_string(log_level), message);
}

/* Logger function used by the FMU internally */

void fmilogger(fmi1_component_t c, fmi1_string_t instanceName, fmi1_status_t status, fmi1_string_t category, fmi1_string_t message, ...)
{
        /* char msg[BUFFER];*/
        va_list argp;
        va_start(argp, message);
        /* vsnprintf(msg, BUFFER, message, argp); */
        fmi1_log_forwarding_v(c, instanceName, status, category, message, argp);
        va_end(argp);
}

void do_exit(int code)
{
        printf("Press 'Enter' to exit\n");
        /* getchar(); */
        exit(code);
}

/* Testing "...Test\FMI1\fmu_dummy\modelDescription_cs_tc.xml" */
void test_xml_modelDescription_cs_tc(const char* xmlFileName, fmi1_import_t* fmu)
{
    fmi1_import_variable_t* v;

    { /* Test variable "INTEGER" */
        fmi1_import_integer_variable_t* vi;
        const char* name = "INTEGER";
        printf("Testing ScalarVariable %s\n", name);
        v = fmi1_import_get_variable_by_name(fmu, name);
        vi = fmi1_import_get_variable_as_integer(v);

        /* Test min attr */
        if (1 != fmi1_import_get_integer_variable_min(vi)) {
            printf("Test of XML file \"%s\" failed. min attribute value missmatch.\n", xmlFileName);
            do_exit(CTEST_RETURN_FAIL);
        }

        /* Test max attr */
        if (11 != fmi1_import_get_integer_variable_max(vi)) {
            printf("Test of XML file \"%s\" failed. max attribute value missmatch.\n", xmlFileName);
            do_exit(CTEST_RETURN_FAIL);
        }
    }

    { /* Test variable "INTEGER_DECLAREDTYPE" */
        fmi1_import_integer_variable_t* vi;
        const char* name = "INTEGER_DECLAREDTYPE";
        printf("Testing ScalarVariable %s\n", name);
        v = fmi1_import_get_variable_by_name(fmu, name);
        vi = fmi1_import_get_variable_as_integer(v);

        /* Test min attr */
        if (2 != fmi1_import_get_integer_variable_min(vi)) {
            printf("Test of XML file \"%s\" failed. min attribute value missmatch.\n", xmlFileName);
            do_exit(CTEST_RETURN_FAIL);
        }

        /* Test max attr */
        if (22 != fmi1_import_get_integer_variable_max(vi)) {
            printf("Test of XML file \"%s\" failed. max attribute value missmatch.\n", xmlFileName);
            do_exit(CTEST_RETURN_FAIL);
        }
    }

    { /* Test variable "INTEGER_DECLAREDTYPE_OVERWRITE" */
        fmi1_import_integer_variable_t* vi;
        const char* name = "INTEGER_DECLAREDTYPE_OVERWRITE";
        printf("Testing ScalarVariable %s\n", name);
        v = fmi1_import_get_variable_by_name(fmu, name);
        vi = fmi1_import_get_variable_as_integer(v);

        /* Test min attr */
        if (1 != fmi1_import_get_integer_variable_min(vi)) {
            printf("Test of XML file \"%s\" failed. min attribute value missmatch.\n", xmlFileName);
            do_exit(CTEST_RETURN_FAIL);
        }

        /* Test max attr */
        if (11 != fmi1_import_get_integer_variable_max(vi)) {
            printf("Test of XML file \"%s\" failed. max attribute value missmatch.\n", xmlFileName);
            do_exit(CTEST_RETURN_FAIL);
        }
    }

    { /* Test variable "ENUMERATION_DECLAREDTYPE" */
        fmi1_import_enum_variable_t* vi;
        const char* name = "ENUMERATION_DECLAREDTYPE";
        printf("Testing ScalarVariable %s\n", name);
        v = fmi1_import_get_variable_by_name(fmu, name);
        vi = fmi1_import_get_variable_as_enum(v);

        /* Test min attr */
        if (1 != fmi1_import_get_enum_variable_min(vi)) {
            printf("Test of XML file \"%s\" failed. min attribute value missmatch.\n", xmlFileName);
            do_exit(CTEST_RETURN_FAIL);
        }

        /* Test max attr */
        if (5 != fmi1_import_get_enum_variable_max(vi)) {
            printf("Test of XML file \"%s\" failed. max attribute value missmatch.\n", xmlFileName);
            do_exit(CTEST_RETURN_FAIL);
        }
    }

    { /* Test variable "ENUMERATION_DECLAREDTYPE_OVERWRITE" */
        fmi1_import_enum_variable_t* vi;
        const char* name = "ENUMERATION_DECLAREDTYPE_OVERWRITE";
        printf("Testing ScalarVariable %s\n", name);
        v = fmi1_import_get_variable_by_name(fmu, name);
        vi = fmi1_import_get_variable_as_enum(v);

        /* Test min attr */
        if (2 != fmi1_import_get_enum_variable_min(vi)) {
            printf("Test of XML file \"%s\" failed. min attribute value missmatch.\n", xmlFileName);
            do_exit(CTEST_RETURN_FAIL);
        }

        /* Test max attr */
        if (3 != fmi1_import_get_enum_variable_max(vi)) {
            printf("Test of XML file \"%s\" failed. max attribute value missmatch.\n", xmlFileName);
            do_exit(CTEST_RETURN_FAIL);
        }
    }
}

typedef struct {
        const char* filename;
        int performTest;
        void (*fcn)(const char* xmlFileName, fmi1_import_t* fmu);
} xml_test_files_t;

xml_test_files_t xml_test_files[] = {
        {"modelDescription_cs_tc.xml", 1, test_xml_modelDescription_cs_tc},
        {"modelDescription_cs.xml", 0, NULL}
};

void test_xml(const char* xmlFileName, fmi1_import_t* fmu)
{
    int k;
    int foundxml = 0;

    for (k = 0; k < sizeof(xml_test_files)/sizeof(*xml_test_files); k++) {
        foundxml = strcmp(xmlFileName, xml_test_files[k].filename) == 0 ? 1 : 0;
        if (foundxml) {
            if (xml_test_files[k].performTest) {
                xml_test_files[k].fcn(xmlFileName, fmu); /* Run specific file XML file test */
            }
            return;
        }
    }

    if (!foundxml) {
        printf("XML file test is not properly implemented in " __FILE__ " . Could not find the XML \"%s\" in the list of expected XML-files", xmlFileName);
        do_exit(CTEST_RETURN_FAIL);
    }
}


int test_simulate_cs(fmi1_import_t* fmu)
{
        fmi1_status_t fmistatus;
        jm_status_enu_t jmstatus;

        fmi1_string_t instanceName = "Test CS model instance";
        fmi1_string_t fmuGUID;
        fmi1_string_t fmuLocation = "";
        fmi1_string_t mimeType = "";
        fmi1_real_t timeout = 0.0;
        fmi1_boolean_t visible = fmi1_false;
        fmi1_boolean_t interactive = fmi1_false;
/*      fmi1_boolean_t loggingOn = fmi1_true; */

        /* fmi1_real_t simulation_results[] = {-0.001878, -1.722275}; */
        fmi1_real_t simulation_results[] = {0.0143633,   -1.62417};
        fmi1_value_reference_t compare_real_variables_vr[] = {0, 1};
        size_t k;

        fmi1_real_t tstart = 0.0;
        fmi1_real_t tcur = tstart;
        fmi1_real_t hstep = 0.1;
        fmi1_real_t tend = 2.0;
        fmi1_boolean_t StopTimeDefined = fmi1_false;

        if (sizeof(compare_real_variables_vr)/sizeof(fmi1_value_reference_t) != sizeof(simulation_results)/sizeof(fmi1_real_t)) {
                printf("Number of simulation values and reference values are different\n");
                do_exit(CTEST_RETURN_FAIL);
        }

        printf("Version returned from FMU:   %s\n", fmi1_import_get_version(fmu));
        printf("Platform type returned:      %s\n", fmi1_import_get_types_platform(fmu));

        fmuGUID = fmi1_import_get_GUID(fmu);
    printf("GUID:      %s\n", fmuGUID);


        jmstatus = fmi1_import_instantiate_slave(fmu, instanceName, fmuLocation, mimeType, timeout, visible, interactive);
        if (jmstatus == jm_status_error) {
                printf("fmi1_import_instantiate_model failed\n");
                do_exit(CTEST_RETURN_FAIL);
        }

        fmistatus = fmi1_import_initialize_slave(fmu, tstart, StopTimeDefined, tend);
    if(fmistatus != fmi1_status_ok) {
        printf("fmi1_import_initialize_slave failed\n");
                do_exit(CTEST_RETURN_FAIL);
    }

        tcur = tstart;
        printf("%10s %10s\n", "Ball height", "Ball speed");
        while (tcur < tend) {
                fmi1_boolean_t newStep = fmi1_true;
#if 0 /* Prints a real value.. */
                fmi1_real_t rvalue;
                fmi1_value_reference_t vr = 0;

                fmistatus = fmi1_import_get_real(fmu, &vr, 1, &rvalue);
                printf("rvalue = %f\n", rvalue);
#endif
                fmistatus = fmi1_import_do_step(fmu, tcur, hstep, newStep);

                for (k = 0; k < sizeof(compare_real_variables_vr)/sizeof(fmi1_value_reference_t); k++) {
                        fmi1_value_reference_t vr = compare_real_variables_vr[k];
                        fmi1_real_t rvalue;
                        fmistatus = fmi1_import_get_real(fmu, &vr, 1, &rvalue);
                }
                {
                        fmi1_real_t val[2];
                        fmi1_import_get_real(fmu, compare_real_variables_vr, 2, val);
                        printf("%10g %10g\n", val[0],val[1]);
                }

                tcur += hstep;
        }

        printf("Simulation finished. Checking results\n");

        /* Validate result */
        for (k = 0; k < sizeof(compare_real_variables_vr)/sizeof(fmi1_value_reference_t); k++) {
                fmi1_value_reference_t vr = compare_real_variables_vr[k];
                fmi1_real_t rvalue;
                fmi1_real_t res;
                fmistatus = fmi1_import_get_real(fmu, &vr, 1, &rvalue);
                res = rvalue - simulation_results[k];
                res = res > 0 ? res: -res; /* Take abs */
                if (res > 3e-3) {
                        printf("Simulation results is wrong!\n");
                        printf("State [%u]  %g != %g, |res| = %g\n", (unsigned)k, rvalue, simulation_results[k], res);
                        printf("\n");
                        do_exit(CTEST_RETURN_FAIL);
                }
        }

        fmistatus = fmi1_import_terminate_slave(fmu);

        fmi1_import_free_slave_instance(fmu);

        return 0;
}

int main(int argc, char *argv[])
{
        fmi1_callback_functions_t callBackFunctions;
        const char* FMUPath;
        const char* tmpPath;
        const char* xmlFileName;
        jm_callbacks callbacks;
        fmi_import_context_t* context;
        fmi_version_enu_t version;
        jm_status_enu_t status;
        int k;

        fmi1_import_t* fmu;

        if(argc < 4) {
                printf("Usage: %s <fmu_file> <temporary_dir> <modelDescription_file>\n", argv[0]);
                do_exit(CTEST_RETURN_FAIL);
        }
        for (k = 0; k < argc; k ++)
                printf("argv[%d] = %s\n", k, argv[k]);

        FMUPath = argv[1];
        tmpPath = argv[2];
        xmlFileName = argv[3];

        callbacks.malloc = malloc;
    callbacks.calloc = calloc;
    callbacks.realloc = realloc;
    callbacks.free = free;
    callbacks.logger = importlogger;
        callbacks.log_level = jm_log_level_debug;
    callbacks.context = 0;

        callBackFunctions.logger = fmi1_log_forwarding;
        callBackFunctions.allocateMemory = calloc;
        callBackFunctions.freeMemory = free;

#ifdef FMILIB_GENERATE_BUILD_STAMP
        printf("Library build stamp:\n%s\n", fmilib_get_build_stamp());
#endif

        context = fmi_import_allocate_context(&callbacks);

        version = fmi_import_get_fmi_version(context, FMUPath, tmpPath);

        if(version != fmi_version_1_enu) {
                printf("Only version 1.0 is supported so far\n");
                do_exit(CTEST_RETURN_FAIL);
        }

        fmu = fmi1_import_parse_xml(context, tmpPath);

        if(!fmu) {
                printf("Error parsing XML, exiting\n");
                do_exit(CTEST_RETURN_FAIL);
        }


        status = fmi1_import_create_dllfmu(fmu, callBackFunctions, 1);
        if (status == jm_status_error) {
                printf("Could not create the DLL loading mechanism(C-API) (error: %s).\n", fmi1_import_get_last_error(fmu));
                do_exit(CTEST_RETURN_FAIL);
        }

        test_simulate_cs(fmu);
        test_xml(xmlFileName, fmu);

        fmi1_import_destroy_dllfmu(fmu);

        fmi1_import_free(fmu);
        fmi_import_free_context(context);

        printf("Everything seems to be OK since you got this far=)!\n");

        do_exit(CTEST_RETURN_SUCCESS);

        return 0;
}