fmu2 Class Reference

#include <mbdynFMI.h>

Inheritance diagram for fmu2:

Collaboration diagram for fmu2:

Public Member Functions
void	parseXML (fmi_import_context_t *context, const char *dirPath)
void	setCallBackFunction ()
	fmu2 (fmi_import_context_t *text, int type)
void	ImportCreateDLL (void)
bool	CheckInput (const std::string)
int	GetNumOfContinousStates (void)
int	GetNumOfEventIndicators (void)
int	GetNumOfVar (void)
void	Initialize (double dTol, double time, double rTol)
void	EventIndicatorInit (void)
void	SetRelativeTol (double dTol)
void	SetTime (double time)
void	SetStates (double *states)
void	SetValuesByVariable (const std::string, double)
int	GetRefValueFromString (const char *s)
double	GetStateFromRefValue (unsigned int i)
void	GetStateDerivatives (double *)
void	GetStates (double *)
void	GetDirectionalDerivatives (FullMatrixHandler *, int *, int, double *)
bool	SupportsDirectionalDerivatives ()
bool	CheckInterrupts (double, double *)
void	InitializeAsSlave (const char *, double, double)
void	CSPropogate (double tcur, double dt)
virtual	~fmu2 (void)
Public Member Functions inherited from fmu
	fmu (fmi_import_context_t *text, int type)
virtual	~fmu (void)

Private Attributes
fmi2_callback_functions_t	callBackFunctions
fmi2_import_t *	fmu
fmi2_status_t	fmistatus
jm_status_enu_t	jmstatus
fmi2_real_t	currTime
fmi2_real_t	relativeTolerance
fmi2_event_info_t	eventInfo
size_t	nEventIndicators
fmi2_real_t *	eventIndicators
fmi2_real_t *	eventIndicatorsPrev
fmi2_import_variable_t *	v
fmi2_boolean_t	callEventUpdate
fmi2_boolean_t	terminateSimulation
int	numOfContStates
fmi2_value_reference_t *	vrs
fmi2_boolean_t	intermediateResults

Additional Inherited Members
Public Types inherited from fmu
enum	SimulationTypes { IMPORT, COSIM }
Public Attributes inherited from fmu
int	simType
fmi_import_context_t *	context

Detailed Description

Definition at line 179 of file mbdynFMI.h.

Constructor & Destructor Documentation

fmu2::fmu2 ( fmi_import_context_t *  text, int  type  )

inline

Definition at line 208 of file mbdynFMI.h.

References NO_OP.

                                                  :fmu::fmu(text, type){
                NO_OP;
        }

fmu2::~fmu2 ( void  )

virtual

Definition at line 335 of file mbdynFMI.cc.

References fmu::context, eventIndicators, eventIndicatorsPrev, fmistatus, fmu::IMPORT, fmu::simType, and STATUSCHECK.

               {
        
        fmi_import_free_context(context);

        if (simType == IMPORT ){
                delete[] eventIndicators;
                delete[] eventIndicatorsPrev;

                fmi2_import_free_instance(fmu);
                fmi2_import_destroy_dllfmu(fmu);
                fmi2_import_free(fmu);

        } else {

                fmistatus = fmi2_import_terminate(fmu);
                STATUSCHECK(fmistatus);
                fmi2_import_free_instance(fmu);
                fmi2_import_destroy_dllfmu(fmu);
                fmi2_import_free(fmu);

        }

}

Member Function Documentation

bool fmu2::CheckInput ( const std::string  s )

virtual

Implements fmu.

Definition at line 310 of file mbdynFMI.cc.

References v.

                                      {
        v = fmi2_import_get_variable_by_name(fmu, s.c_str());
        if(v==NULL){
                silent_cout(s.c_str()<<" is not defined in XML, hence ");
                return false;
        }
        return ((fmi2_import_get_causality(v))==2);
}

bool fmu2::CheckInterrupts ( double  currTime, double *  states  )

virtual

Implements fmu.

Definition at line 373 of file mbdynFMI.cc.

References do_event_iteration(), eventIndicators, eventIndicatorsPrev, eventInfo, fmistatus, nEventIndicators, numOfContStates, and STATUSCHECK.

                                                         {
        int zeroCrossningEvent = 0;

        fmistatus = fmi2_import_get_event_indicators(fmu, eventIndicators, nEventIndicators);
        STATUSCHECK(fmistatus);
        for (unsigned int k = 0; k < nEventIndicators; k++) {
              if (eventIndicators[k]*eventIndicatorsPrev[k] < 0) {
                      zeroCrossningEvent = 1;
                      break;
              }
        }

        if ( zeroCrossningEvent || (eventInfo.nextEventTimeDefined && currTime == eventInfo.nextEventTime)) {
                fmistatus = fmi2_import_enter_event_mode(fmu);
                do_event_iteration(fmu, &eventInfo);
                fmistatus = fmi2_import_enter_continuous_time_mode(fmu);
                fmistatus = fmi2_import_get_continuous_states(fmu, states, numOfContStates);
                fmistatus = fmi2_import_get_event_indicators(fmu, eventIndicatorsPrev, nEventIndicators);


                return true;
        } else {
                return false;
        }
}

Here is the call graph for this function:

void fmu2::CSPropogate ( double  tcur, double  dt  )

virtual

Implements fmu.

Definition at line 462 of file mbdynFMI.cc.

References fmistatus, and STATUSCHECK.

                                            {
        fmistatus = fmi2_import_do_step(fmu, tcur, dt, fmi2_true);
        STATUSCHECK(fmistatus);
}

void fmu2::EventIndicatorInit ( void  )

virtual

Implements fmu.

Definition at line 276 of file mbdynFMI.cc.

References eventIndicators, eventIndicatorsPrev, fmistatus, and nEventIndicators.

                                 {
        nEventIndicators = fmi2_import_get_number_of_event_indicators(fmu);

        eventIndicators = new fmi2_real_t [nEventIndicators];
        eventIndicatorsPrev = new fmi2_real_t [nEventIndicators];

        fmistatus = fmi2_import_get_event_indicators(fmu, eventIndicatorsPrev, nEventIndicators);

        if(fmistatus){
                silent_cout("This FMU does triggers events. Warning: Event triggers not supported by MBDyn\n");
        }       
}

void fmu2::GetDirectionalDerivatives ( FullMatrixHandler *  jacobian, int *  inputStatesVRef, int  inputLength, double *  seedVector  )

virtual

Implements fmu.

Definition at line 238 of file mbdynFMI.cc.

References fmistatus, numOfContStates, output(), FullMatrixHandler::PutCoef(), and STATUSCHECK.

                                                                                                                          {
//Seed Vector (the state value)

        fmi2_import_variable_list_t* derivativeList = fmi2_import_get_derivatives_list(fmu);
        size_t derivativeListSize = fmi2_import_get_variable_list_size(derivativeList);

        fmi2_import_variable_t *var;
        fmi2_import_real_variable_t *varCont;
        fmi2_value_reference_t* derList = new fmi2_value_reference_t[derivativeListSize];
        fmi2_value_reference_t* stateList = new fmi2_value_reference_t[derivativeListSize + inputLength];

        for (unsigned int i=0; i<derivativeListSize; i++){
                var          = fmi2_import_get_variable(derivativeList, i);
                derList[i]   = fmi2_import_get_variable_vr(var);
                varCont      = fmi2_import_get_real_variable_derivative_of((fmi2_import_real_variable_t*)var);
                stateList[i] = fmi2_import_get_variable_vr((fmi2_import_variable_t*)varCont);
        }

        for (int i=numOfContStates; i<inputLength+numOfContStates; i++){
                stateList[i] = inputStatesVRef[i-numOfContStates];
        }

        fmi2_real_t output[numOfContStates + inputLength];      

        for (int i=0; i<numOfContStates; i++){
                fmistatus = fmi2_import_get_directional_derivative(fmu, stateList, numOfContStates + inputLength, &derList[i], 1, output , seedVector);
                STATUSCHECK(fmistatus);

                for (int j=0; j<numOfContStates + inputLength; j++){
                        jacobian->PutCoef(i+1, j+1, output[j]);
                }
        }
        delete[] derList;
        delete[] stateList;
}

Here is the call graph for this function:

int fmu2::GetNumOfContinousStates ( void  )

virtual

Implements fmu.

Definition at line 171 of file mbdynFMI.cc.

References numOfContStates.

                                     {
        numOfContStates = fmi2_import_get_number_of_continuous_states(fmu);
        
        return numOfContStates;
}

int fmu2::GetNumOfEventIndicators ( void  )

virtual

Implements fmu.

Definition at line 177 of file mbdynFMI.cc.

                                     {
        return fmi2_import_get_number_of_event_indicators(fmu);
}

int fmu2::GetNumOfVar ( void  )

virtual

Implements fmu.

Definition at line 181 of file mbdynFMI.cc.

                         {
        fmi2_import_variable_list_t* vl;
        vl = fmi2_import_get_variable_list(fmu, 0);
        return fmi2_import_get_variable_list_size(vl);
}

int fmu2::GetRefValueFromString ( const char *  s )

virtual

Implements fmu.

Definition at line 319 of file mbdynFMI.cc.

References v.

                                            {
        v = fmi2_import_get_variable_by_name(fmu, s);
        return  static_cast<int>(fmi2_import_get_variable_vr(v));

}

void fmu2::GetStateDerivatives ( double *  derivatives )

virtual

Implements fmu.

Definition at line 360 of file mbdynFMI.cc.

References fmistatus, numOfContStates, and STATUSCHECK.

                                                 {
    
        fmistatus = fmi2_import_get_derivatives(fmu, derivatives, numOfContStates);

        STATUSCHECK(fmistatus);

}

double fmu2::GetStateFromRefValue ( unsigned int  i )

virtual

Implements fmu.

Definition at line 325 of file mbdynFMI.cc.

References fmistatus, and STATUSCHECK.

                                               {
        double realValue[1];
        fmi1_value_reference_t valueReference = {i};
        fmistatus = fmi2_import_get_real(fmu, &valueReference, 1, realValue);
        STATUSCHECK(fmistatus);

        return realValue[0];

}

void fmu2::GetStates ( double *  states )

virtual

Implements fmu.

Definition at line 368 of file mbdynFMI.cc.

References fmistatus, numOfContStates, and STATUSCHECK.

                                  {
        fmistatus = fmi2_import_get_continuous_states(fmu, states, numOfContStates);
        STATUSCHECK(fmistatus);
}

void fmu2::ImportCreateDLL ( void  )

virtual

Implements fmu.

Definition at line 150 of file mbdynFMI.cc.

References callBackFunctions, fmu::COSIM, fmu::IMPORT, jmstatus, MBDYN_EXCEPT_ARGS, fmu::simType, and STATUSCHECK.

                          {

        if(simType != fmi2_import_get_fmu_kind(fmu)-1){
                silent_cout("This FMU does not support the specified simulation type");
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }


        if(simType == IMPORT){
                jmstatus = fmi2_import_create_dllfmu(fmu, fmi2_fmu_kind_me, &callBackFunctions);
        }
        else if (simType == COSIM){
                jmstatus = fmi2_import_create_dllfmu(fmu, fmi2_fmu_kind_cs, &callBackFunctions);
        }
        else{
                std::cout<<"Unknown Type";
        }

        STATUSCHECK(jmstatus);
}

void fmu2::Initialize ( double  dTol, double  time, double  rTol  )

virtual

Implements fmu.

Definition at line 187 of file mbdynFMI.cc.

References do_event_iteration(), eventInfo, fmistatus, jmstatus, and STATUSCHECK.

                                                          {
        jmstatus = fmi2_import_instantiate(fmu, "Test ME model instance",fmi2_model_exchange,0,0);
        STATUSCHECK(jmstatus);

        if (rTol ==0){
                rTol = 0.001;
        }

        fmistatus = fmi2_import_setup_experiment(fmu, dTol, rTol, time, fmi2_false, 0.0);
        STATUSCHECK(fmistatus);
        fmistatus = fmi2_import_enter_initialization_mode(fmu);
        STATUSCHECK(fmistatus);
        fmistatus = fmi2_import_exit_initialization_mode(fmu);
        STATUSCHECK(fmistatus);
        
        do_event_iteration(fmu, &eventInfo);
        fmi2_import_enter_continuous_time_mode(fmu);
        fmistatus = fmi2_import_set_time(fmu, time);
        STATUSCHECK(fmistatus);

        eventInfo.newDiscreteStatesNeeded           = fmi2_false;
        eventInfo.terminateSimulation               = fmi2_false;
        eventInfo.nominalsOfContinuousStatesChanged = fmi2_false;
        eventInfo.valuesOfContinuousStatesChanged   = fmi2_true;
        eventInfo.nextEventTimeDefined              = fmi2_false;
        eventInfo.nextEventTime                     = -0.0;

}

Here is the call graph for this function:

void fmu2::InitializeAsSlave ( const char *  location, double  tstart, double  tend  )

virtual

Implements fmu.

Definition at line 436 of file mbdynFMI.cc.

References fmistatus, jmstatus, relativeTolerance, and STATUSCHECK.

                                                                            {

        std::stringstream resourceLocation;
        std::string strLocation = location;

        resourceLocation << "file://" << strLocation;
        fmi2_boolean_t visible = fmi2_false;
        jmstatus = fmi2_import_instantiate(fmu, "Model for CS", fmi2_cosimulation, resourceLocation.str().c_str(), visible);
        STATUSCHECK(jmstatus);

        if (tend == std::numeric_limits<double>::max()){
                fmistatus = fmi2_import_setup_experiment(fmu, fmi2_true, relativeTolerance, tstart, fmi2_false, 0);
        } else {
                fmistatus = fmi2_import_setup_experiment(fmu, fmi2_true, relativeTolerance, tstart, fmi2_true, tend);
        }

        STATUSCHECK(fmistatus);

        fmistatus = fmi2_import_enter_initialization_mode(fmu);
        STATUSCHECK(fmistatus);

        fmistatus = fmi2_import_exit_initialization_mode(fmu);
        STATUSCHECK(fmistatus);
        
}

void fmu2::parseXML ( fmi_import_context_t *  context, const char *  dirPath  )

virtual

Implements fmu.

Definition at line 131 of file mbdynFMI.cc.

References annotation_callbacks, and MBDYN_EXCEPT_ARGS.

                                                                     {

        fmu = fmi2_import_parse_xml(context, dirPath, &annotation_callbacks);
        if (!fmu){
                silent_cout("Error parsing XML 2.0\n");
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        } else { 
                silent_cout("XML Parsed successfully\n");
        }
}

void fmu2::setCallBackFunction ( )

virtual

Implements fmu.

Definition at line 142 of file mbdynFMI.cc.

References callBackFunctions, and stepFinished().

                              {
        callBackFunctions.logger = fmi2_log_forwarding;
        callBackFunctions.allocateMemory = calloc;
        callBackFunctions.freeMemory = free;
        callBackFunctions.stepFinished = stepFinished;
        callBackFunctions.componentEnvironment = 0;
}

Here is the call graph for this function:

void fmu2::SetRelativeTol ( double  dTol )

virtual

Implements fmu.

Definition at line 289 of file mbdynFMI.cc.

References relativeTolerance.

                                    {
        relativeTolerance = (fmi1_real_t)dTol;
}

void fmu2::SetStates ( double *  states )

virtual

Implements fmu.

Definition at line 299 of file mbdynFMI.cc.

References callEventUpdate, fmistatus, numOfContStates, STATUSCHECK, and terminateSimulation.

                                  {
        callEventUpdate = fmi2_false;
        terminateSimulation = fmi2_false;
        fmistatus = fmi2_import_set_continuous_states(fmu, states, numOfContStates);
        STATUSCHECK(fmistatus);

        fmistatus = fmi2_import_completed_integrator_step(fmu, fmi2_true, &callEventUpdate, &terminateSimulation);
        STATUSCHECK(fmistatus);

}

void fmu2::SetTime ( double  time )

virtual

Implements fmu.

Definition at line 293 of file mbdynFMI.cc.

References currTime, fmistatus, and STATUSCHECK.

                             {
        currTime = time;
        fmistatus = fmi2_import_set_time(fmu, currTime);
        STATUSCHECK(fmistatus); 
}

void fmu2::SetValuesByVariable ( const std::string  s, double  value  )

virtual

Implements fmu.

Definition at line 399 of file mbdynFMI.cc.

References fmistatus, MBDYN_EXCEPT_ARGS, STATUSCHECK, and v.

                                                             {
        fmi2_value_reference_t ref;
        fmi2_variable_alias_kind_enu_t aliasKind;
        fmi2_base_type_enu_t baseType;

        fmi2_import_variable_t* v = fmi2_import_get_variable_by_name(fmu, s.c_str());

        ref = fmi2_import_get_variable_vr(v);
        aliasKind = fmi2_import_get_variable_alias_kind(v);
        baseType = fmi2_import_get_variable_base_type(v);

        if (aliasKind == fmi2_variable_is_not_alias){
                if(baseType != fmi2_base_type_bool){
                        value = -value;
                }
                else{
                        value = (bool)!value;
                }
        }

        if (baseType == fmi2_base_type_real){
                fmistatus = fmi2_import_set_real(fmu, &ref, 1, &value);
        }
        else if (baseType == fmi2_base_type_int){
                fmistatus = fmi2_import_set_integer(fmu, &ref, 1, (const int*)&value);
        }
        else if (baseType == fmi2_base_type_bool){
                fmistatus = fmi2_import_set_boolean(fmu, &ref, 1, (const fmi2_boolean_t*)&value);
        }
        else{
                silent_cerr("Input type not Supported");
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }
        STATUSCHECK(fmistatus);
}

bool fmu2::SupportsDirectionalDerivatives ( )

virtual

Implements fmu.

Definition at line 216 of file mbdynFMI.cc.

References fmu::COSIM, fmu::IMPORT, and fmu::simType.

                                         {
        unsigned int capability = 0;

        if(simType == COSIM){
                fmi2_capabilities_enu_t id = fmi2_cs_providesDirectionalDerivatives;
                capability = fmi2_xml_get_capability(fmu->md, id);
        } else if (simType == IMPORT){
                fmi2_capabilities_enu_t id = fmi2_me_providesDirectionalDerivatives;
                capability = fmi2_xml_get_capability(fmu->md, id);
        }

        if (!capability){
                silent_cout("This FMU does not support Directional Derivatives\n");
                return false;
        }
        
        silent_cout("This FMU supports Directional Derivatives\n");
        return true;


}

Member Data Documentation

fmi2_callback_functions_t fmu2::callBackFunctions

private

Definition at line 181 of file mbdynFMI.h.

Referenced by ImportCreateDLL(), and setCallBackFunction().

fmi2_boolean_t fmu2::callEventUpdate

private

Definition at line 195 of file mbdynFMI.h.

Referenced by SetStates().

fmi2_real_t fmu2::currTime

private

Definition at line 187 of file mbdynFMI.h.

Referenced by SetTime().

fmi2_real_t* fmu2::eventIndicators

private

Definition at line 192 of file mbdynFMI.h.

Referenced by CheckInterrupts(), EventIndicatorInit(), and ~fmu2().

fmi2_real_t* fmu2::eventIndicatorsPrev

private

Definition at line 193 of file mbdynFMI.h.

Referenced by CheckInterrupts(), EventIndicatorInit(), and ~fmu2().

fmi2_event_info_t fmu2::eventInfo

private

Definition at line 189 of file mbdynFMI.h.

Referenced by CheckInterrupts(), and Initialize().

fmi2_status_t fmu2::fmistatus

private

Definition at line 184 of file mbdynFMI.h.

Referenced by CheckInterrupts(), CSPropogate(), EventIndicatorInit(), GetDirectionalDerivatives(), GetStateDerivatives(), GetStateFromRefValue(), GetStates(), Initialize(), InitializeAsSlave(), SetStates(), SetTime(), SetValuesByVariable(), and ~fmu2().

fmi2_import_t* fmu2::fmu

private

Definition at line 182 of file mbdynFMI.h.

fmi2_boolean_t fmu2::intermediateResults

private

Definition at line 201 of file mbdynFMI.h.

jm_status_enu_t fmu2::jmstatus

private

Definition at line 185 of file mbdynFMI.h.

Referenced by ImportCreateDLL(), Initialize(), and InitializeAsSlave().

size_t fmu2::nEventIndicators

private

Definition at line 191 of file mbdynFMI.h.

Referenced by CheckInterrupts(), and EventIndicatorInit().

int fmu2::numOfContStates

private

Definition at line 198 of file mbdynFMI.h.

Referenced by CheckInterrupts(), GetDirectionalDerivatives(), GetNumOfContinousStates(), GetStateDerivatives(), GetStates(), and SetStates().

fmi2_real_t fmu2::relativeTolerance

private

Definition at line 188 of file mbdynFMI.h.

Referenced by InitializeAsSlave(), and SetRelativeTol().

fmi2_boolean_t fmu2::terminateSimulation

private

Definition at line 196 of file mbdynFMI.h.

Referenced by SetStates().

fmi2_import_variable_t* fmu2::v

private

Definition at line 194 of file mbdynFMI.h.

Referenced by CheckInput(), GetRefValueFromString(), and SetValuesByVariable().

fmi2_value_reference_t* fmu2::vrs

private

Definition at line 199 of file mbdynFMI.h.

---

The documentation for this class was generated from the following files:

• mbdynFMI.h
• mbdynFMI.cc