casadi::Fmu2 Class Reference

Interface to a binary FMU, adhering to FMI version 2.0. More...

#include <fmu2.hpp>

Detailed Description

Author

Joel Andersson

Date

2023

Extra doc: https://github.com/casadi/casadi/wiki/L_2at

Definition at line 42 of file fmu2.hpp.

Inheritance diagram for casadi::Fmu2:

Collaboration diagram for casadi::Fmu2:

Classes
struct	Value

Public Types
using	weak_ref_type = WeakRefInternal

Public Member Functions
	Fmu2 (const std::string &name, const std::vector< std::string > &scheme_in, const std::vector< std::string > &scheme_out, const std::map< std::string, std::vector< size_t >> &scheme, const std::vector< std::string > &aux)
	~Fmu2 () override
	Destructor. More...
std::string	class_name () const override
	Get type name. More...
void	init (const DaeBuilderInternal *dae) override
int	init_mem (FmuMemory *m) const override
	Initalize memory block. More...
FmuMemory *	alloc_mem (const FmuFunction &f) const override
	Create memory block. More...
void	free_mem (void *mem) const override
	Free memory block. More...
void	finalize () override
void	load_functions () override
std::string	system_infix () const override
void *	instantiate () const override
void	free_instance (void *instance) const override
int	reset (void *instance)
int	enter_initialization_mode (void *instance) const override
int	exit_initialization_mode (void *instance) const override
int	enter_continuous_time_mode (void *instance) const override
int	update_discrete_states (void *instance, EventMemory *eventmem) const override
int	get_derivatives (void *instance, double *derivatives, size_t nx) const override
int	set_real (void *instance, const unsigned int *vr, size_t n_vr, const double *values, size_t n_values) const override
int	get_real (void *instance, const unsigned int *vr, size_t n_vr, double *values, size_t n_values) const override
int	get_directional_derivative (void *instance, const unsigned int *vr_out, size_t n_out, const unsigned int *vr_in, size_t n_in, const double *seed, size_t n_seed, double *sensitivity, size_t n_sensitivity) const override
int	set_values (void *instance) const override
int	get_aux (void *instance) override
int	get_aux_impl (void *instance, Value &aux_value) const
void	get_stats (FmuMemory *m, Dict *stats, const std::vector< std::string > &name_in, const InputStruct *in) const override
	Get stats. More...
void	serialize_body (SerializingStream &s) const override
virtual int	get_adjoint_derivative (void *instance, const unsigned int *vr_out, size_t n_out, const unsigned int *vr_in, size_t n_in, const double *seed, size_t n_seed, double *sensitivity, size_t n_sensitivity) const
void	disp (std::ostream &stream, bool more) const override
	Print. More...
size_t	n_in () const
	Get the number of scheme inputs. More...
size_t	n_out () const
	Get the number of scheme outputs. More...
size_t	index_in (const std::string &n) const
size_t	index_out (const std::string &n) const
Sparsity	jac_sparsity (const std::vector< size_t > &osub, const std::vector< size_t > &isub) const
Sparsity	hess_sparsity (const std::vector< size_t > &r, const std::vector< size_t > &c) const
std::string	desc_in (FmuMemory *m, size_t id, bool more=true) const
template<typename T >
T *	load_function (const std::string &symname)
int	discrete_states_iter (void *instance) const
void	set (FmuMemory *m, size_t ind, const double *value) const
void	request (FmuMemory *m, size_t ind) const
int	eval (FmuMemory *m) const
void	get (FmuMemory *m, size_t id, double *value) const
void	set_fwd (FmuMemory *m, casadi_int nseed, const casadi_int *id, const double *v) const
void	set_fwd (FmuMemory *m, size_t ind, const double *v) const
void	request_fwd (FmuMemory *m, casadi_int nsens, const casadi_int *id, const casadi_int *wrt_id) const
void	request_fwd (FmuMemory *m, casadi_int ind) const
int	eval_fwd (FmuMemory *m, bool independent_seeds) const
int	eval_ad (FmuMemory *m) const
int	eval_fd (FmuMemory *m, bool independent_seeds) const
void	get_fwd (FmuMemory *m, casadi_int nsens, const casadi_int *id, double *v) const
void	get_fwd (FmuMemory *m, size_t ind, double *v) const
void	set_adj (FmuMemory *m, casadi_int nseed, const casadi_int *id, const double *v) const
void	set_adj (FmuMemory *m, size_t ind, const double *v) const
void	request_adj (FmuMemory *m, casadi_int nsens, const casadi_int *id, const casadi_int *wrt_id) const
void	request_adj (FmuMemory *m, casadi_int ind) const
int	eval_adj (FmuMemory *m) const
void	get_adj (FmuMemory *m, casadi_int nsens, const casadi_int *id, double *v) const
void	get_adj (FmuMemory *m, size_t ind, double *v) const
void	gather_fwd (FmuMemory *m) const
void	gather_adj (FmuMemory *m) const
void	gather_io (FmuMemory *m) const
void	serialize (SerializingStream &s) const
virtual void	serialize_type (SerializingStream &s) const
casadi_int	getCount () const
	Get the reference count. More...
std::string	debug_repr (const SharedObjectInternal *) const
GenericWeakRef< SharedObject, SharedObjectInternal > *	weak ()
	Get a weak reference to the object. More...
std::vector< double >	all_nominal_in (size_t i) const
	Retreive nominal values. More...
std::vector< double >	all_nominal_out (size_t i) const
	Retreive nominal values. More...

Static Public Member Functions
static void	logger (fmi2ComponentEnvironment componentEnvironment, fmi2String instanceName, fmi2Status status, fmi2String category, fmi2String message,...)
static Fmu2 *	deserialize (DeserializingStream &s)
static std::string	dll_suffix ()

Public Attributes
std::vector< fmi2ValueReference >	vr_real_
std::vector< fmi2ValueReference >	vr_integer_
std::vector< fmi2ValueReference >	vr_boolean_
std::vector< fmi2ValueReference >	vr_string_
std::vector< fmi2Real >	init_real_
std::vector< fmi2Integer >	init_integer_
std::vector< fmi2Boolean >	init_boolean_
std::vector< std::string >	init_string_
std::vector< std::string >	vn_aux_real_
std::vector< std::string >	vn_aux_integer_
std::vector< std::string >	vn_aux_boolean_
std::vector< std::string >	vn_aux_string_
std::vector< fmi2ValueReference >	vr_aux_real_
std::vector< fmi2ValueReference >	vr_aux_integer_
std::vector< fmi2ValueReference >	vr_aux_boolean_
std::vector< fmi2ValueReference >	vr_aux_string_
fmi2InstantiateTYPE *	instantiate_
fmi2FreeInstanceTYPE *	free_instance_
fmi2ResetTYPE *	reset_
fmi2SetupExperimentTYPE *	setup_experiment_
fmi2EnterInitializationModeTYPE *	enter_initialization_mode_
fmi2ExitInitializationModeTYPE *	exit_initialization_mode_
fmi2EnterContinuousTimeModeTYPE *	enter_continuous_time_mode_
fmi2GetDerivativesTYPE *	get_derivatives_
fmi2SetTimeTYPE *	set_time_
fmi2GetRealTYPE *	get_real_
fmi2SetRealTYPE *	set_real_
fmi2GetBooleanTYPE *	get_boolean_
fmi2SetBooleanTYPE *	set_boolean_
fmi2GetIntegerTYPE *	get_integer_
fmi2SetIntegerTYPE *	set_integer_
fmi2GetStringTYPE *	get_string_
fmi2SetStringTYPE *	set_string_
fmi2GetDirectionalDerivativeTYPE *	get_directional_derivative_
fmi2NewDiscreteStatesTYPE *	new_discrete_states_
fmi2CallbackFunctions	functions_
Value	aux_value_

Protected Member Functions
	Fmu2 (DeserializingStream &s)
void	initSingleton ()
void	destroySingleton ()
B	shared_from_this ()
	Get a shared object from the current internal object. More...
const B	shared_from_this () const
	Get a shared object from the current internal object. More...

Protected Attributes
Resource	resource_
std::string	name_
	Instance name. More...
std::vector< std::string >	scheme_in_
std::vector< std::string >	scheme_out_
std::map< std::string, std::vector< size_t > >	scheme_
std::vector< std::string >	aux_
std::string	resource_loc_
double	fmutol_
std::string	instance_name_
std::string	instantiation_token_
bool	logging_on_
casadi_int	number_of_event_indicators_
bool	provides_directional_derivatives_
bool	provides_adjoint_derivatives_
bool	can_be_instantiated_only_once_per_process_
Importer	li_
	DLL. More...
std::vector< size_t >	iind_
std::vector< size_t >	iind_map_
std::vector< size_t >	oind_
std::vector< size_t >	oind_map_
bool	has_independent_
std::vector< double >	nominal_in_
std::vector< double >	nominal_out_
std::vector< double >	min_in_
std::vector< double >	min_out_
std::vector< double >	max_in_
std::vector< double >	max_out_
std::vector< std::string >	vn_in_
std::vector< std::string >	vn_out_
std::vector< unsigned int >	vr_in_
std::vector< unsigned int >	vr_out_
std::vector< double >	value_in_
std::vector< std::vector< size_t > >	ired_
std::vector< std::vector< size_t > >	ored_
Sparsity	jac_sp_
Sparsity	hess_sp_
bool	warning_fired_discrete_states_need_update_
bool	warning_fired_terminate_simulation_
bool	warning_fired_nominals_of_continuous_states_changed_
bool	warning_fired_values_of_continuous_states_changed_
bool	warning_fired_next_event_time_defined_
size_t	nx_
bool	do_evaluation_dance_

Member Typedef Documentation

weak_ref_type

using casadi::SharedObjectInternal::weak_ref_type = WeakRefInternal

inherited

Definition at line 152 of file shared_object.hpp.

Constructor & Destructor Documentation

Fmu2() [1/2]

casadi::Fmu2::Fmu2	(	const std::string &	name,
		const std::vector< std::string > &	scheme_in,
		const std::vector< std::string > &	scheme_out,
		const std::map< std::string, std::vector< size_t >> &	scheme,
		const std::vector< std::string > &	aux
	)

Definition at line 517 of file fmu2.cpp.

    : FmuInternal(name, scheme_in, scheme_out, scheme, aux) {
  instantiate_ = 0;
  free_instance_ = 0;
  reset_ = 0;
  setup_experiment_ = 0;
  enter_initialization_mode_ = 0;
  exit_initialization_mode_ = 0;
  enter_continuous_time_mode_ = 0;
  set_time_ = 0;
  set_real_ = 0;
  set_boolean_ = 0;
  get_real_ = 0;
  get_directional_derivative_ = 0;
  new_discrete_states_ = 0;
}

References enter_continuous_time_mode_, enter_initialization_mode_, exit_initialization_mode_, free_instance_, get_directional_derivative_, get_real_, instantiate_, new_discrete_states_, reset_, set_boolean_, set_real_, set_time_, and setup_experiment_.

Referenced by deserialize().

~Fmu2()

casadi::Fmu2::~Fmu2 ( )

override

Definition at line 58 of file fmu2.cpp.

            {
}

Fmu2() [2/2]

casadi::Fmu2::Fmu2 ( DeserializingStream &  s )

explicitprotected

Definition at line 544 of file fmu2.cpp.

                                 : FmuInternal(s) {
  instantiate_ = 0;
  free_instance_ = 0;
  reset_ = 0;
  setup_experiment_ = 0;
  enter_initialization_mode_ = 0;
  exit_initialization_mode_ = 0;
  enter_continuous_time_mode_ = 0;
  set_real_ = 0;
  set_boolean_ = 0;
  get_real_ = 0;
  get_directional_derivative_ = 0;
  new_discrete_states_ = 0;
 
  s.version("Fmu2", 2);
  s.unpack("Fmu2::vr_real", vr_real_);
  s.unpack("Fmu2::vr_integer", vr_integer_);
  s.unpack("Fmu2::vr_boolean", vr_boolean_);
  s.unpack("Fmu2::vr_string", vr_string_);
  s.unpack("Fmu2::init_real", init_real_);
  s.unpack("Fmu2::init_integer", init_integer_);
  s.unpack("Fmu2::init_boolean", init_boolean_);
  s.unpack("Fmu2::init_string", init_string_);
 
  s.unpack("Fmu2::vn_aux_real", vn_aux_real_);
  s.unpack("Fmu2::vn_aux_integer", vn_aux_integer_);
  s.unpack("Fmu2::vn_aux_boolean", vn_aux_boolean_);
  s.unpack("Fmu2::vn_aux_string", vn_aux_string_);
  s.unpack("Fmu2::vr_aux_real", vr_aux_real_);
  s.unpack("Fmu2::vr_aux_integer", vr_aux_integer_);
  s.unpack("Fmu2::vr_aux_boolean", vr_aux_boolean_);
  s.unpack("Fmu2::vr_aux_string", vr_aux_string_);
}

References enter_continuous_time_mode_, enter_initialization_mode_, exit_initialization_mode_, free_instance_, get_directional_derivative_, get_real_, init_boolean_, init_integer_, init_real_, init_string_, instantiate_, new_discrete_states_, reset_, set_boolean_, set_real_, setup_experiment_, casadi::DeserializingStream::unpack(), casadi::DeserializingStream::version(), vn_aux_boolean_, vn_aux_integer_, vn_aux_real_, vn_aux_string_, vr_aux_boolean_, vr_aux_integer_, vr_aux_real_, vr_aux_string_, vr_boolean_, vr_integer_, vr_real_, and vr_string_.

Member Function Documentation

all_nominal_in()

std::vector< double > casadi::FmuInternal::all_nominal_in ( size_t  i ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_26r

Definition at line 687 of file fmu.cpp.

                                                            {
  auto&& ind = ired_.at(i);
  std::vector<double> n;
  n.reserve(ind.size());
  for (size_t k : ind) n.push_back(nominal_in_.at(k));
  return n;
}

References casadi::FmuInternal::ired_, and casadi::FmuInternal::nominal_in_.

all_nominal_out()

std::vector< double > casadi::FmuInternal::all_nominal_out ( size_t  i ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_26r

Definition at line 695 of file fmu.cpp.

                                                             {
  auto&& ind = ored_.at(i);
  std::vector<double> n;
  n.reserve(ind.size());
  for (size_t k : ind) n.push_back(nominal_out_.at(k));
  return n;
}

References casadi::FmuInternal::nominal_out_, and casadi::FmuInternal::ored_.

alloc_mem()

FmuMemory * casadi::Fmu2::alloc_mem ( const FmuFunction &  f ) const

overridevirtual

Extra doc: https://github.com/casadi/casadi/wiki/L_2dp

Implements casadi::FmuInternal.

Definition at line 50 of file fmu2.cpp.

                                                     {
  return new Fmu2Memory(f);
}

class_name()

std::string casadi::Fmu2::class_name ( ) const

inlineoverridevirtual

Extra doc: https://github.com/casadi/casadi/wiki/L_2au

Implements casadi::SharedObjectInternal.

Definition at line 55 of file fmu2.hpp.

{ return "Fmu2";}

debug_repr()

std::string casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::debug_repr ( const Internal *  i ) const

inherited

Definition at line 62 of file generic_shared_internal.hpp.

                                                                                       {
    // Note: i != this because of something something multiple inheritance
    return str( (casadi_int)(i)) + "/" + static_cast<const Internal*>(this)->class_name();
  }

desc_in()

std::string casadi::FmuInternal::desc_in ( FmuMemory *  m, size_t  id, bool  more = true  ) const

inherited

Definition at line 716 of file fmu.cpp.

                                                                       {
  // Create description
  if (more) {
    // Detailed description
    std::stringstream ss;
    ss << vn_in_[id] << " = " << m->ibuf_[id] << " (nominal " << nominal_in_[id]
    << ", min " << min_in_[id] << ", max " << max_in_[id] << ")";
    return ss.str();
  } else {
    return vn_in_[id];
  }
}

References casadi::FmuMemory::ibuf_, casadi::FmuInternal::max_in_, casadi::FmuInternal::min_in_, casadi::FmuInternal::nominal_in_, and casadi::FmuInternal::vn_in_.

Referenced by casadi::FmuInternal::eval_fd().

deserialize()

Fmu2 * casadi::Fmu2::deserialize ( DeserializingStream &  s )

static

Definition at line 538 of file fmu2.cpp.

                                              {
  Fmu2* ret = new Fmu2(s);
  ret->finalize();
  return ret;
}

References finalize(), and Fmu2().

Referenced by casadi::FmuInternal::deserialize().

destroySingleton()

void casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::destroySingleton ( )

inlineprotectedinherited

Called in the destructor of singletons

Definition at line 77 of file generic_shared_internal.hpp.

                            {
      static_cast<Internal*>(this)->count--;
    }

discrete_states_iter()

int casadi::FmuInternal::discrete_states_iter ( void *  instance ) const

inherited

Definition at line 1098 of file fmu.cpp.

                                                          {
  // Helper function: update_discrete_states
  EventMemory eventmem;
  const size_t max_update_iter = 10;
  for (size_t update_iter = 0; update_iter < max_update_iter; ++update_iter) {
    if (update_discrete_states(instance, &eventmem)) {
      casadi_warning("update_discrete_states");
      return 1;
    }
    // Not implemented
    if (eventmem.discrete_states_need_update) {
      if (!warning_fired_discrete_states_need_update_) {
        warning_fired_discrete_states_need_update_ = true;
        casadi_warning("Discrete state update not implemented");
      }
    }
    if (eventmem.terminate_simulation) {
      if (!warning_fired_terminate_simulation_) {
        warning_fired_terminate_simulation_ = true;
        casadi_warning("Terminate simulation not implemented");
      }
    }
    if (eventmem.nominals_of_continuous_states_changed) {
      if (!warning_fired_nominals_of_continuous_states_changed_) {
        warning_fired_nominals_of_continuous_states_changed_ = true;
        casadi_warning("Nominals of continuous states not implemented");
      }
    }
    if (eventmem.values_of_continuous_states_changed) {
      if (!warning_fired_values_of_continuous_states_changed_) {
        warning_fired_values_of_continuous_states_changed_ = true;
        casadi_warning("Values of continuous states not implemented");
      }
    }
    if (eventmem.next_event_time_defined) {
      if (!warning_fired_next_event_time_defined_) {
        warning_fired_next_event_time_defined_ = true;
        casadi_warning("Next event time not implemented");
      }
    }
    // Successful return
    if (!eventmem.discrete_states_need_update) {
      return 0;
    }
  }
  // Too many iterations
  casadi_warning("Discrete state update failed");
  return 1;
}

References casadi::EventMemory::discrete_states_need_update, casadi::EventMemory::next_event_time_defined, casadi::EventMemory::nominals_of_continuous_states_changed, casadi::EventMemory::terminate_simulation, casadi::FmuInternal::update_discrete_states(), casadi::EventMemory::values_of_continuous_states_changed, casadi::FmuInternal::warning_fired_discrete_states_need_update_, casadi::FmuInternal::warning_fired_next_event_time_defined_, casadi::FmuInternal::warning_fired_nominals_of_continuous_states_changed_, casadi::FmuInternal::warning_fired_terminate_simulation_, and casadi::FmuInternal::warning_fired_values_of_continuous_states_changed_.

Referenced by casadi::FmuInternal::init_mem().

disp()

void casadi::FmuInternal::disp ( std::ostream &  stream, bool  more  ) const

overridevirtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_26m

Implements casadi::SharedObjectInternal.

Definition at line 631 of file fmu.cpp.

                                                          {
  (void)more;  // unused
  stream << name_ << " " << class_name();
}

References casadi::SharedObjectInternal::class_name(), and casadi::FmuInternal::name_.

dll_suffix()

std::string casadi::FmuInternal::dll_suffix ( )

staticinherited

Definition at line 703 of file fmu.cpp.

                                  {
#if defined(_WIN32)
  // Windows system
  return ".dll";
#elif defined(__APPLE__)
  // OSX
  return ".dylib";
#else
  // Linux
  return ".so";
#endif
}

Referenced by casadi::FmuInternal::finalize().

enter_continuous_time_mode()

int casadi::Fmu2::enter_continuous_time_mode ( void *  instance ) const

overridevirtual

Implements casadi::FmuInternal.

Definition at line 301 of file fmu2.cpp.

                                                         {
  auto c = static_cast<fmi2Component>(instance);
  fmi2Status status = enter_continuous_time_mode_(c);
  if (status != fmi2OK) {
    casadi_warning("fmi2EnterContinuousTimeMode failed");
    return 1;
  }
  return 0;
}

References enter_continuous_time_mode_.

enter_initialization_mode()

int casadi::Fmu2::enter_initialization_mode ( void *  instance ) const

overridevirtual

Implements casadi::FmuInternal.

Definition at line 281 of file fmu2.cpp.

                                                        {
  auto c = static_cast<fmi2Component>(instance);
  fmi2Status status = enter_initialization_mode_(c);
  if (status != fmi2OK) {
    casadi_warning("fmi2EnterInitializationMode failed: " + str(status));
    return 1;
  }
  return 0;
}

References enter_initialization_mode_, and casadi::str().

eval()

int casadi::FmuInternal::eval ( FmuMemory *  m ) const

inherited

Definition at line 1222 of file fmu.cpp.

                                        {
  // Gather inputs and outputs
  gather_io(m);
  // Number of inputs and outputs
  size_t n_set = m->id_in_.size();
  size_t n_out = m->id_out_.size();
  // Set all variables
  if (set_real(m->instance, get_ptr(m->vr_in_), n_set, get_ptr(m->v_in_), n_set)) {
    casadi_warning("Setting FMU variables failed");
    return 1;
  }
  // Quick return if nothing requested
  if (n_out == 0) return 0;
  // Calculate all variables
  m->v_out_.resize(n_out);
  if (get_real(m->instance, get_ptr(m->vr_out_), n_out, get_ptr(m->v_out_), n_out)) {
    casadi_warning("Evaluation failed");
    return 1;
  }
  // Collect requested variables
  auto it = m->v_out_.begin();
  for (size_t id : m->id_out_) {
    m->obuf_[id] = *it++;
  }
  // Successful return
  return 0;
}

References casadi::FmuInternal::gather_io(), casadi::get_ptr(), casadi::FmuInternal::get_real(), casadi::FmuMemory::id_in_, casadi::FmuMemory::id_out_, casadi::FmuMemory::instance, casadi::FmuInternal::n_out(), casadi::FmuMemory::obuf_, casadi::FmuInternal::set_real(), casadi::FmuMemory::v_in_, casadi::FmuMemory::v_out_, casadi::FmuMemory::vr_in_, and casadi::FmuMemory::vr_out_.

eval_ad()

int casadi::FmuInternal::eval_ad ( FmuMemory *  m ) const

inherited

Definition at line 768 of file fmu.cpp.

                                           {
  // Number of inputs and outputs
  size_t n_known = m->id_in_.size();
  size_t n_unknown = m->id_out_.size();
  // Quick return if nothing to be calculated
  if (n_unknown == 0) return 0;
  // Evalute (should not be necessary)
  if (get_real(m->instance, get_ptr(m->vr_out_), n_unknown, get_ptr(m->v_out_), n_unknown)) {
    casadi_warning("FMU evaluation failed");
    return 1;
  }
  // Evaluate directional derivatives
  if (get_directional_derivative(m->instance,
      get_ptr(m->vr_out_), n_unknown,
      get_ptr(m->vr_in_), n_known,
      get_ptr(m->d_in_), n_known,
      get_ptr(m->d_out_), n_unknown)) {
    casadi_warning("FMU directional derivative failed");
    return 1;
  }
  // Collect requested variables
  auto it = m->d_out_.begin();
  for (size_t id : m->id_out_) {
    m->osens_[id] = *it++;
  }
  // Successful return
  return 0;
}

References casadi::FmuMemory::d_in_, casadi::FmuMemory::d_out_, casadi::FmuInternal::get_directional_derivative(), casadi::get_ptr(), casadi::FmuInternal::get_real(), casadi::FmuMemory::id_in_, casadi::FmuMemory::id_out_, casadi::FmuMemory::instance, casadi::FmuMemory::osens_, casadi::FmuMemory::v_out_, casadi::FmuMemory::vr_in_, and casadi::FmuMemory::vr_out_.

Referenced by casadi::FmuInternal::eval_fwd().

eval_adj()

int casadi::FmuInternal::eval_adj ( FmuMemory *  m ) const

inherited

Definition at line 745 of file fmu.cpp.

                                            {
  // Gather input and output indices
  gather_adj(m);
  // Quick return if nothing to be calculated
  if (m->id_in_.size() == 0) return 0;
  // Evaluate adjoint derivatives
  if (get_adjoint_derivative(m->instance,
      get_ptr(m->vr_out_), m->id_out_.size(),
      get_ptr(m->vr_in_), m->id_in_.size(),
      get_ptr(m->d_out_), m->id_out_.size(),
      get_ptr(m->d_in_), m->id_in_.size())) {
    casadi_warning("FMU adjoint derivative failed");
    return 1;
  }
  // Collect requested variables
  auto it = m->d_in_.begin();
  for (size_t id : m->id_in_) {
    m->isens_[id] = *it++;
  }
  // Successful return
  return 0;
}

References casadi::FmuMemory::d_in_, casadi::FmuMemory::d_out_, casadi::FmuInternal::gather_adj(), casadi::FmuInternal::get_adjoint_derivative(), casadi::get_ptr(), casadi::FmuMemory::id_in_, casadi::FmuMemory::id_out_, casadi::FmuMemory::instance, casadi::FmuMemory::isens_, casadi::FmuMemory::vr_in_, and casadi::FmuMemory::vr_out_.

eval_fd()

int casadi::FmuInternal::eval_fd ( FmuMemory *  m, bool  independent_seeds  ) const

inherited

Definition at line 797 of file fmu.cpp.

                                                                   {
  // Number of inputs and outputs
  size_t n_known = m->id_in_.size();
  size_t n_unknown = m->id_out_.size();
  // Quick return if nothing to be calculated
  if (n_unknown == 0) return 0;
  // Evalute (should not be necessary)
  if (get_real(m->instance, get_ptr(m->vr_out_), n_unknown, get_ptr(m->v_out_), n_unknown)) {
    casadi_warning("Evaluating FMU failed");
    return 1;
  }
  // Make outputs dimensionless
  for (size_t k = 0; k < n_unknown; ++k) m->v_out_[k] /= nominal_out_[m->id_out_[k]];
  // Number of points in FD stencil
  casadi_int n_points = n_fd_points(m->self.fd_);
  // Offset for points
  casadi_int offset = fd_offset(m->self.fd_);
  // Memory for perturbed outputs
  m->fd_out_.resize(n_points * n_unknown);
  // Which inputs are in bounds
  m->in_bounds_.resize(n_known);
  // Memory for perturbed inputs
  m->v_pert_.resize(n_known);
  // Do any any inputs need flipping?
  m->flip_.resize(n_known);
  size_t first_flip = -1;
  for (size_t i = 0; i < n_known; ++i) {
    // Try to take step
    double test = m->v_in_[i] + m->self.step_ * m->d_in_[i];
    // Check if in bounds
    size_t id = m->id_in_[i];
    if (test >= min_in_[id] && test <= max_in_[id]) {
      // Positive perturbation is fine
      m->flip_[i] = false;
    } else {
      // Try negative direction instead
      test = m->v_in_[i] - m->self.step_ * m->d_in_[i];
      casadi_assert(test >= min_in_[id] && test <= max_in_[id],
        "Cannot perturb " + vn_in_[id] + " at " + str(m->v_in_[i]) + ", min " + str(min_in_[id])
        + ", max " + str(max_in_[id]) + ", nominal " + str(nominal_in_[id]));
      m->flip_[i] = true;
      if (first_flip == size_t(-1)) first_flip = i;
    }
  }
  // If seeds are not independent, we have to flip the sign for all of the seeds or none
  if (first_flip != size_t(-1) && !independent_seeds) {
    // Flip the rest of the seeds
    for (size_t i = 0; i < n_known; ++i) {
      if (!m->flip_[i]) {
        // Test negative direction
        double test = m->v_in_[i] - m->self.step_ * m->d_in_[i];
        size_t id = m->id_in_[i];
        casadi_assert(test >= min_in_[id] && test <= max_in_[id],
          "Cannot perturb both " + vn_in_[id] + " and " + vn_in_[first_flip]);
        // Flip it too
        m->flip_[i] = true;
      }
    }
  }
  // All perturbed outputs
  const double* yk_all[5] = {0};
 
  // Calculate all perturbed outputs
  for (casadi_int k = 0; k < n_points; ++k) {
    // Where to save the perturbed outputs
    double* yk = &m->fd_out_[n_unknown * k];
    casadi_assert_dev(k < 5);
    yk_all[k] = yk;
    // If unperturbed output, quick return
    if (k == offset) {
      casadi_copy(get_ptr(m->v_out_), n_unknown, yk);
      continue;
    }
    // Perturbation size
    double pert = (k - offset) * m->self.step_;
    // Perturb inputs, if allowed
    for (size_t i = 0; i < n_known; ++i) {
      // Try to take step
      double sign = m->flip_[i] ? -1 : 1;
      double test = m->v_in_[i] + pert * sign * m->d_in_[i];
      // Check if in bounds
      size_t id = m->id_in_[i];
      m->in_bounds_[i] = test >= min_in_[id] && test <= max_in_[id];
      // Take step, if allowed
      m->v_pert_[i] = m->in_bounds_[i] ? test : m->v_in_[i];
    }
    // Pass perturbed inputs to FMU
    if (set_real(m->instance, get_ptr(m->vr_in_), n_known, get_ptr(m->v_pert_), n_known)) {
      casadi_warning("Setting FMU variables failed");
      return 1;
    }
    // Evaluate perturbed FMU
    if (get_real(m->instance, get_ptr(m->vr_out_), n_unknown, yk, n_unknown)) {
      casadi_warning("Evaluation failed");
      return 1;
    }
    // Post-process yk if there was any scaling
    if (independent_seeds) {
      for (size_t i = 0; i < n_unknown; ++i) {
        // Variable id
        size_t id = m->id_out_[i];
        // Differentiation with respect to what variable
        size_t wrt_id = m->wrt_.at(id);
        // Find the corresponding input variable
        size_t wrt_i;
        for (wrt_i = 0; wrt_i < n_known; ++wrt_i) {
          if (m->id_in_[wrt_i] == wrt_id) break;
        }
        // Check if in bounds
        if (m->in_bounds_.at(wrt_i)) {
          // Input was in bounds: Keep output, make dimensionless
          yk[i] /= nominal_out_[m->id_out_[i]];
        } else {
          // Input was out of bounds: Discard output
          yk[i] = nan;
        }
      }
    }
  }
  // Restore FMU inputs
  if (set_real(m->instance, get_ptr(m->vr_in_), n_known, get_ptr(m->v_in_), n_known)) {
    casadi_warning("Setting FMU variables failed");
    return 1;
  }
  // Step size
  double h = m->self.step_;
 
  // Calculate FD approximation
  finite_diff(m->self.fd_, yk_all, get_ptr(m->d_out_), h, n_unknown, eps);
 
  // If seeds are dependent, quick return
  if (!independent_seeds) {
    // Simpy copy the results to output (no validation)
    for (size_t ind = 0; ind < m->id_out_.size(); ++ind) {
      m->osens_[m->id_out_[ind]] = m->d_out_[ind];
    }
    return 0;
  }
 
  // Collect requested variables
  for (size_t ind = 0; ind < m->id_out_.size(); ++ind) {
    // Variable id
    size_t id = m->id_out_[ind];
    // With respect to what variable
    size_t wrt = m->wrt_[id];
    // Find the corresponding input variable
    size_t wrt_i;
    for (wrt_i = 0; wrt_i < n_known; ++wrt_i) {
      if (m->id_in_[wrt_i] == wrt) break;
    }
    // Nominal value
    double n = nominal_out_[id];
    // Get the value
    double d_fd = m->d_out_[ind] * n;
    // Correct sign, if necessary
    if (m->flip_[wrt_i]) d_fd = -d_fd;
    // Use FD instead of AD or to compare with AD
    if (m->self.validate_forward_) {
      // Value to compare with
      double d_ad = m->osens_[id];
      // Nominal value used as seed
      d_ad /= nominal_in_[wrt];
      d_fd /= nominal_in_[wrt];
      // Is it a not a number?
      bool d_is_nan = d_ad != d_ad;
      // Magnitude of derivatives
      double d_max = std::fmax(std::fabs(d_fd), std::fabs(d_ad));
      // Check if NaN or error exceeds thresholds
      if (d_is_nan || (d_max > n * m->self.abstol_
          && std::fabs(d_ad - d_fd) > d_max * m->self.reltol_)) {
        // Offset for printing the stencil
        double off = m->fd_out_.at(ind + offset * n_unknown);
        // Warning or add to file
        std::stringstream ss;
        if (m->self.validate_ad_file_.empty()) {
          // Issue warning
          ss << (d_is_nan ? "NaN" : "Inconsistent") << " derivatives of " << vn_out_[id]
            << " w.r.t. " << desc_in(m, wrt) << ", got " << d_ad
            << " for AD vs. " << d_fd << " for FD[" << to_string(m->self.fd_) << "].";
          // Print the stencil:
          ss << "\nValues for step size " << h << ": " << (n * off) << " + [";
          for (casadi_int k = 0; k < n_points; ++k) {
            if (k > 0) ss << ", ";
            ss << (n * (m->fd_out_.at(ind + k * n_unknown) - off));
          }
          ss << "]";
          // Issue warning
          casadi_warning(ss.str());
        } else {
          // Output
          ss << vn_out_[id] << " ";
          // Input
          ss << vn_in_[wrt] << " ";
          // Value
          ss << m->ibuf_[wrt] << " ";
          // Noninal
          ss << nominal_in_[wrt] << " ";
          // Min
          ss << min_in_[wrt] << " ";
          // Max
          ss << max_in_[wrt] << " ";
          // AD
          ss << d_ad << " ";
          // FD
          ss << d_fd << " ";
          // Step
          ss << h << " ";
          // Offset
          ss << off << " ";
          // Stencil
          ss << "[";
          for (casadi_int k = 0; k < n_points; ++k) {
            if (k > 0) ss << ",";
            ss << (n * (m->fd_out_.at(ind + k * n_unknown) - off));
          }
          ss << "]" << std::endl;
          // Append to file
          auto valfile_ptr = Filesystem::ofstream_ptr(m->self.validate_ad_file_,
            std::ios_base::app);
          std::ostream& valfile = *valfile_ptr;
          valfile << ss.str();
        }
      }
    } else {
      // Use instead of AD
      m->osens_[id] = d_fd;
    }
  }
  // Successful return
  return 0;
}

References casadi::FmuFunction::abstol_, casadi::casadi_copy(), casadi::FmuMemory::d_in_, casadi::FmuMemory::d_out_, casadi::FmuInternal::desc_in(), casadi::eps, casadi::FmuFunction::fd_, casadi::fd_offset(), casadi::FmuMemory::fd_out_, casadi::finite_diff(), casadi::FmuMemory::flip_, casadi::get_ptr(), casadi::FmuInternal::get_real(), casadi::FmuMemory::ibuf_, casadi::FmuMemory::id_in_, casadi::FmuMemory::id_out_, casadi::FmuMemory::in_bounds_, casadi::FmuMemory::instance, casadi::FmuInternal::max_in_, casadi::FmuInternal::min_in_, casadi::n_fd_points(), casadi::nan, casadi::FmuInternal::nominal_in_, casadi::FmuInternal::nominal_out_, casadi::Filesystem::ofstream_ptr(), casadi::FmuMemory::osens_, casadi::FmuFunction::reltol_, casadi::FmuMemory::self, casadi::FmuInternal::set_real(), casadi::sign(), casadi::FmuFunction::step_, casadi::str(), casadi::to_string(), casadi::FmuMemory::v_in_, casadi::FmuMemory::v_out_, casadi::FmuMemory::v_pert_, casadi::FmuFunction::validate_ad_file_, casadi::FmuFunction::validate_forward_, casadi::FmuInternal::vn_in_, casadi::FmuInternal::vn_out_, casadi::FmuMemory::vr_in_, casadi::FmuMemory::vr_out_, and casadi::FmuMemory::wrt_.

Referenced by casadi::FmuInternal::eval_fwd().

eval_fwd()

int casadi::FmuInternal::eval_fwd ( FmuMemory *  m, bool  independent_seeds  ) const

inherited

Definition at line 729 of file fmu.cpp.

                                                                    {
  // Gather input and output indices
  gather_fwd(m);
  // Calculate derivatives using FMU directional derivative support
  if (m->self.uses_directional_derivatives_) {
    // Evaluate using AD
    if (eval_ad(m)) return 1;
  }
  // Calculate derivatives using finite differences
  if (!m->self.uses_directional_derivatives_ || m->self.validate_forward_) {
    // Evaluate using FD
    if (eval_fd(m, independent_seeds)) return 1;
  }
  return 0;
}

References casadi::FmuInternal::eval_ad(), casadi::FmuInternal::eval_fd(), casadi::FmuInternal::gather_fwd(), casadi::FmuMemory::self, casadi::FmuFunction::uses_directional_derivatives_, and casadi::FmuFunction::validate_forward_.

exit_initialization_mode()

int casadi::Fmu2::exit_initialization_mode ( void *  instance ) const

overridevirtual

Implements casadi::FmuInternal.

Definition at line 291 of file fmu2.cpp.

                                                       {
  auto c = static_cast<fmi2Component>(instance);
  fmi2Status status = exit_initialization_mode_(c);
  if (status != fmi2OK) {
    casadi_warning("fmi2ExitInitializationMode failed");
    return 1;
  }
  return 0;
}

References exit_initialization_mode_.

finalize()

void casadi::Fmu2::finalize ( )

overridevirtual

Allocate numerical values for initial auxilliary variables

Reimplemented from casadi::FmuInternal.

Definition at line 166 of file fmu2.cpp.

                    {
  aux_value_.v_real.resize(vn_aux_real_.size());
  aux_value_.v_integer.resize(vn_aux_integer_.size());
  aux_value_.v_boolean.resize(vn_aux_boolean_.size());
  aux_value_.v_string.resize(vn_aux_string_.size());
 
  // Recursive call
  FmuInternal::finalize();
}

References aux_value_, casadi::FmuInternal::finalize(), casadi::Fmu2::Value::v_boolean, casadi::Fmu2::Value::v_integer, casadi::Fmu2::Value::v_real, casadi::Fmu2::Value::v_string, vn_aux_boolean_, vn_aux_integer_, vn_aux_real_, and vn_aux_string_.

Referenced by deserialize().

free_instance()

void casadi::Fmu2::free_instance ( void *  instance ) const

overridevirtual

Implements casadi::FmuInternal.

Definition at line 262 of file fmu2.cpp.

                                             {
  if (free_instance_) {
    auto c = static_cast<fmi2Component>(instance);
    free_instance_(c);
  } else {
    casadi_warning("No free_instance function pointer available");
  }
}

References free_instance_.

free_mem()

void casadi::Fmu2::free_mem ( void *  mem ) const

overridevirtual

Extra doc: https://github.com/casadi/casadi/wiki/L_2du

Implements casadi::FmuInternal.

Definition at line 54 of file fmu2.cpp.

                                   {
  delete static_cast<Fmu2Memory*>(mem);
}

gather_adj()

void casadi::FmuInternal::gather_adj ( FmuMemory *  m ) const

inherited

Definition at line 1338 of file fmu.cpp.

                                               {
  // Gather input and output indices
  gather_io(m);
  // Number of inputs and outputs
  size_t n_known = m->id_in_.size();
  size_t n_unknown = m->id_out_.size();
  // Get/clear seeds
  m->d_out_.clear();
  for (size_t id : m->id_out_) {
    m->d_out_.push_back(m->osens_[id]);
    m->osens_[id] = 0;
  }
  // Ensure at least one seed
  casadi_assert(n_unknown != 0, "No seeds");
  // Allocate result vectors
  m->v_in_.resize(n_known);
  m->d_in_.resize(n_known);
}

References casadi::FmuMemory::d_in_, casadi::FmuMemory::d_out_, casadi::FmuInternal::gather_io(), casadi::FmuMemory::id_in_, casadi::FmuMemory::id_out_, casadi::FmuMemory::osens_, and casadi::FmuMemory::v_in_.

Referenced by casadi::FmuInternal::eval_adj().

gather_fwd()

void casadi::FmuInternal::gather_fwd ( FmuMemory *  m ) const

inherited

Definition at line 1319 of file fmu.cpp.

                                               {
  // Gather input and output indices
  gather_io(m);
  // Number of inputs and outputs
  size_t n_known = m->id_in_.size();
  size_t n_unknown = m->id_out_.size();
  // Get/clear seeds
  m->d_in_.clear();
  for (size_t id : m->id_in_) {
    m->d_in_.push_back(m->isens_[id]);
    m->isens_[id] = 0;
  }
  // Ensure at least one seed
  casadi_assert(n_known != 0, "No seeds");
  // Allocate result vectors
  m->v_out_.resize(n_unknown);
  m->d_out_.resize(n_unknown);
}

References casadi::FmuMemory::d_in_, casadi::FmuMemory::d_out_, casadi::FmuInternal::gather_io(), casadi::FmuMemory::id_in_, casadi::FmuMemory::id_out_, casadi::FmuMemory::isens_, and casadi::FmuMemory::v_out_.

Referenced by casadi::FmuInternal::eval_fwd().

gather_io()

void casadi::FmuInternal::gather_io ( FmuMemory *  m ) const

inherited

Definition at line 1294 of file fmu.cpp.

                                              {
  // Collect input indices and corresponding value references and values
  m->id_in_.clear();
  m->vr_in_.clear();
  m->v_in_.clear();
  for (size_t id = 0; id < m->imarked_.size(); ++id) {
    if (m->imarked_[id]) {
      m->id_in_.push_back(id);
      m->vr_in_.push_back(vr_in_[id]);
      m->v_in_.push_back(m->ibuf_[id]);
      m->imarked_[id] = false;
    }
  }
  // Collect output indices, corresponding value references
  m->id_out_.clear();
  m->vr_out_.clear();
  for (size_t id = 0; id < m->omarked_.size(); ++id) {
    if (m->omarked_[id]) {
      m->id_out_.push_back(id);
      m->vr_out_.push_back(vr_out_[id]);
      m->omarked_[id] = false;
    }
  }
}

References casadi::FmuMemory::ibuf_, casadi::FmuMemory::id_in_, casadi::FmuMemory::id_out_, casadi::FmuMemory::imarked_, casadi::FmuMemory::omarked_, casadi::FmuMemory::v_in_, casadi::FmuMemory::vr_in_, casadi::FmuInternal::vr_in_, casadi::FmuMemory::vr_out_, and casadi::FmuInternal::vr_out_.

Referenced by casadi::FmuInternal::eval(), casadi::FmuInternal::gather_adj(), and casadi::FmuInternal::gather_fwd().

get()

void casadi::FmuInternal::get ( FmuMemory *  m, size_t  id, double *  value  ) const

inherited

Definition at line 1250 of file fmu.cpp.

                                                                   {
  // Save to return
  for (size_t id : ored_[ind]) {
    *value++ = m->obuf_.at(id);
  }
}

References casadi::FmuMemory::obuf_, and casadi::FmuInternal::ored_.

Referenced by casadi::Fmu::get().

get_adj() [1/2]

void casadi::FmuInternal::get_adj ( FmuMemory *  m, casadi_int  nsens, const casadi_int *  id, double *  v  ) const

inherited

Definition at line 1082 of file fmu.cpp.

                                                                                               {
  for (casadi_int i = 0; i < nsens; ++i) {
    *v++ = m->isens_.at(*id++);
  }
}

References casadi::FmuMemory::isens_.

Referenced by casadi::FmuInternal::get_adj().

get_adj() [2/2]

void casadi::FmuInternal::get_adj ( FmuMemory *  m, size_t  ind, double *  v  ) const

inherited

Definition at line 1088 of file fmu.cpp.

                                                                   {
  // Quick return if not needed
  if (!v) return;
  // Retrieve all sensitivities FIXME(@jaeandersson): should use compatible types
  for (size_t id : ired_[ind]) {
    casadi_int id2 = id;
    get_adj(m, 1, &id2, v++);
  }
}

References casadi::FmuInternal::get_adj(), and casadi::FmuInternal::ired_.

get_adjoint_derivative()

int casadi::FmuInternal::get_adjoint_derivative ( void *  instance, const unsigned int *  vr_out, size_t  n_out, const unsigned int *  vr_in, size_t  n_in, const double *  seed, size_t  n_seed, double *  sensitivity, size_t  n_sensitivity  ) const

virtualinherited

Reimplemented in casadi::Fmu3.

Definition at line 572 of file fmu.cpp.

                                                     {
  casadi_error("Adjoint derivatives not supported for " + class_name());
  return 1;
}

References casadi::SharedObjectInternal::class_name().

Referenced by casadi::FmuInternal::eval_adj().

get_aux()

int casadi::Fmu2::get_aux ( void *  instance )

overridevirtual

Implements casadi::FmuInternal.

Definition at line 474 of file fmu2.cpp.

                                {
  return get_aux_impl(instance, aux_value_);
}

References aux_value_, and get_aux_impl().

get_aux_impl()

int casadi::Fmu2::get_aux_impl	(	void *	instance,
		Value &	aux_value
	)		const

Definition at line 432 of file fmu2.cpp.

                                                             {
  auto c = static_cast<fmi2Component>(instance);
  // Get real auxilliary variables
  if (!vr_aux_real_.empty()) {
    fmi2Status status = get_real_(c, get_ptr(vr_aux_real_), vr_aux_real_.size(),
      get_ptr(aux_value.v_real));
    if (status != fmi2OK) {
      casadi_warning("fmi2GetReal failed");
      return 1;
    }
  }
  // Get integer/enum auxilliary variables
  if (!vr_aux_integer_.empty()) {
    fmi2Status status = get_integer_(c, get_ptr(vr_aux_integer_), vr_aux_integer_.size(),
      get_ptr(aux_value.v_integer));
    if (status != fmi2OK) {
      casadi_warning("fmi2GetInteger failed");
      return 1;
    }
  }
  // Get boolean auxilliary variables
  if (!vr_aux_boolean_.empty()) {
    fmi2Status status = get_boolean_(c, get_ptr(vr_aux_boolean_), vr_aux_boolean_.size(),
      get_ptr(aux_value.v_boolean));
    if (status != fmi2OK) {
      casadi_warning("fmi2GetBoolean failed");
      return 1;
    }
  }
  // Get string auxilliary variables
  for (size_t k = 0; k < vr_aux_string_.size(); ++k) {
    fmi2ValueReference vr = vr_aux_string_[k];
    fmi2String value = aux_value.v_string.at(k).c_str();
    fmi2Status status = set_string_(c, &vr, 1, &value);
    if (status != fmi2OK) {
      casadi_error("fmi2GetString failed for value reference " + str(vr));
    }
  }
  // Successful return
  return 0;
}

References get_boolean_, get_integer_, casadi::get_ptr(), get_real_, set_string_, casadi::str(), casadi::Fmu2::Value::v_boolean, casadi::Fmu2::Value::v_integer, casadi::Fmu2::Value::v_real, casadi::Fmu2::Value::v_string, vr_aux_boolean_, vr_aux_integer_, vr_aux_real_, and vr_aux_string_.

Referenced by get_aux(), and get_stats().

get_derivatives()

int casadi::Fmu2::get_derivatives ( void *  instance, double *  derivatives, size_t  nx  ) const

overridevirtual

Implements casadi::FmuInternal.

Definition at line 311 of file fmu2.cpp.

                                                                              {
  auto c = static_cast<fmi2Component>(instance);
  fmi2Status status = get_derivatives_(c, derivatives, nx);
  if (status != fmi2OK) {
    casadi_warning("fmi2GetDerivatives failed");
    return 1;
  }
  return 0;
}

References get_derivatives_.

get_directional_derivative()

int casadi::Fmu2::get_directional_derivative ( void *  instance, const unsigned int *  vr_out, size_t  n_out, const unsigned int *  vr_in, size_t  n_in, const double *  seed, size_t  n_seed, double *  sensitivity, size_t  n_sensitivity  ) const

overridevirtual

Implements casadi::FmuInternal.

Definition at line 381 of file fmu2.cpp.

                                                     {
  casadi_assert(n_in == n_seed, "Vector-valued variables not supported in FMI 2");
  casadi_assert(n_out == n_sensitivity, "Vector-valued variables not supported in FMI 2");
  fmi2Status status = get_directional_derivative_(instance, vr_out, n_out, vr_in, n_in,
    seed, sensitivity);
  return status != fmi2OK;
}

References get_directional_derivative_, casadi::FmuInternal::n_in(), and casadi::FmuInternal::n_out().

get_fwd() [1/2]

void casadi::FmuInternal::get_fwd ( FmuMemory *  m, casadi_int  nsens, const casadi_int *  id, double *  v  ) const

inherited

Definition at line 1029 of file fmu.cpp.

                                                                                               {
  for (casadi_int i = 0; i < nsens; ++i) {
    *v++ = m->osens_.at(*id++);
  }
}

References casadi::FmuMemory::osens_.

Referenced by casadi::FmuInternal::get_fwd().

get_fwd() [2/2]

void casadi::FmuInternal::get_fwd ( FmuMemory *  m, size_t  ind, double *  v  ) const

inherited

Definition at line 1035 of file fmu.cpp.

                                                                   {
  // Quick return if not needed
  if (!v) return;
  // Retrieve all sensitivities FIXME(@jaeandersson): should use compatible types
  for (size_t id : ored_[ind]) {
    casadi_int id2 = id;
    get_fwd(m, 1, &id2, v++);
  }
}

References casadi::FmuInternal::get_fwd(), and casadi::FmuInternal::ored_.

get_real()

int casadi::Fmu2::get_real ( void *  instance, const unsigned int *  vr, size_t  n_vr, double *  values, size_t  n_values  ) const

overridevirtual

Implements casadi::FmuInternal.

Definition at line 363 of file fmu2.cpp.

                                           {
  casadi_assert(n_vr == n_values, "Vector-valued variables not supported in FMI 2");
  if (do_evaluation_dance_) {
    // Dummy call to trigger rtOneStep
    fmi2Status status = get_real_(instance, nullptr, 0, nullptr);
    if (status != fmi2OK) return 1;
    // Scratch space to write derivative to (not used)
    static thread_local std::vector<double> derivate_dump;
    if (derivate_dump.size() < nx_) derivate_dump.resize(nx_);
    // Dummy call to trigger computation of derivatives, possibly read later via get_real
    status = get_derivatives_(instance, get_ptr(derivate_dump), nx_);
    if (status != fmi2OK) return 1;
  }
  fmi2Status status = get_real_(instance, vr, n_vr, values);
  return status != fmi2OK;
}

References casadi::FmuInternal::do_evaluation_dance_, get_derivatives_, casadi::get_ptr(), get_real_, and casadi::FmuInternal::nx_.

get_stats()

void casadi::Fmu2::get_stats ( FmuMemory *  m, Dict *  stats, const std::vector< std::string > &  name_in, const InputStruct *  in  ) const

overridevirtual

Extra doc: https://github.com/casadi/casadi/wiki/L_2av

Implements casadi::FmuInternal.

Definition at line 478 of file fmu2.cpp.

                                                                      {
  Value& v = static_cast<Fmu2Memory*>(m)->aux_value;
  get_aux_impl(m->instance, v);
  // Collect auxilliary variables
  Dict aux;
  // Real
  for (size_t k = 0; k < vn_aux_real_.size(); ++k) {
    aux[vn_aux_real_[k]] = static_cast<double>(v.v_real[k]);
  }
  // Integer
  for (size_t k = 0; k < vn_aux_integer_.size(); ++k) {
    aux[vn_aux_integer_[k]] = static_cast<casadi_int>(v.v_integer[k]);
  }
  // Boolean
  for (size_t k = 0; k < vn_aux_boolean_.size(); ++k) {
    aux[vn_aux_boolean_[k]] = static_cast<bool>(v.v_boolean[k]);
  }
  // String
  for (size_t k = 0; k < vn_aux_string_.size(); ++k) {
    aux[vn_aux_string_[k]] = v.v_string[k];
  }
  // Copy to stats
  (*stats)["aux"] = aux;
  // Loop over input variables
  for (size_t k = 0; k < name_in.size(); ++k) {
    // Only consider regular inputs
    if (in[k].type == InputType::REG) {
      // Get the indices
      const std::vector<size_t>& iind = ired_.at(in[k].ind);
      // Collect values
      std::vector<double> v(iind.size());
      for (size_t i = 0; i < v.size(); ++i) v[i] = value_in_.at(iind[i]);
      // Save to stats
      (*stats)[name_in[k]] = v;
    }
  }
}

References get_aux_impl(), casadi::FmuMemory::instance, casadi::FmuInternal::ired_, casadi::REG, casadi::Fmu2::Value::v_boolean, casadi::Fmu2::Value::v_integer, casadi::Fmu2::Value::v_real, casadi::Fmu2::Value::v_string, casadi::FmuInternal::value_in_, vn_aux_boolean_, vn_aux_integer_, vn_aux_real_, and vn_aux_string_.

getCount()

casadi_int casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::getCount

inherited

Definition at line 60 of file generic_shared_internal.hpp.

                                                                     {
    return static_cast<const Internal*>(this)->count;
  }

hess_sparsity()

Sparsity casadi::FmuInternal::hess_sparsity ( const std::vector< size_t > &  r, const std::vector< size_t > &  c  ) const

inherited

Definition at line 676 of file fmu.cpp.

                                      {
  // Convert to casadi_int type
  std::vector<casadi_int> r1(r.begin(), r.end());
  std::vector<casadi_int> c1(c.begin(), c.end());
  // Index mapping (not used)
  std::vector<casadi_int> mapping;
  // Get selection
  return hess_sp_.sub(r1, c1, mapping);
}

References casadi::FmuInternal::hess_sp_, and casadi::Sparsity::sub().

index_in()

size_t casadi::FmuInternal::index_in ( const std::string &  n ) const

inherited

Definition at line 645 of file fmu.cpp.

                                                     {
  // Linear search for the input
  for (size_t i = 0; i < scheme_in_.size(); ++i) {
    if (scheme_in_[i] == n) return i;
  }
  // Not found
  casadi_error("No such input: " + n);
  return -1;
}

References casadi::FmuInternal::scheme_in_.

Referenced by casadi::InputStruct::parse(), and casadi::OutputStruct::parse().

index_out()

size_t casadi::FmuInternal::index_out ( const std::string &  n ) const

inherited

Definition at line 655 of file fmu.cpp.

                                                      {
  // Linear search for the input
  for (size_t i = 0; i < scheme_out_.size(); ++i) {
    if (scheme_out_[i] == n) return i;
  }
  // Not found
  casadi_error("No such output: " + n);
  return -1;
}

References casadi::FmuInternal::scheme_out_.

Referenced by casadi::InputStruct::parse(), and casadi::OutputStruct::parse().

init()

void casadi::Fmu2::init ( const DaeBuilderInternal *  dae )

overridevirtual

Reimplemented from casadi::FmuInternal.

Definition at line 78 of file fmu2.cpp.

                                             {
  // Initialize base classes
  FmuInternal::init(dae);
 
  // Collect input and parameter values
  vr_real_.clear();
  vr_integer_.clear();
  vr_boolean_.clear();
  vr_string_.clear();
  init_real_.clear();
  init_integer_.clear();
  init_boolean_.clear();
  init_string_.clear();
  for (size_t i = 0; i < dae->n_variables(); ++i) {
    const Variable& v = dae->variable(i);
    casadi_assert(v.numel == 1, "Vector variable support not implemented");
    // Skip if the wrong type
    if (v.causality != Causality::PARAMETER && v.causality != Causality::INPUT) continue;
    // Variable has not been set - keep default value
    if (!v.is_set()) continue;
    // Value reference
    fmi2ValueReference vr = v.value_reference;
    // Get value
    switch (to_fmi2(v.type)) {
      case TypeFmi2::REAL:
        init_real_.push_back(static_cast<fmi2Real>(v.value.front()));
        vr_real_.push_back(vr);
        break;
      case TypeFmi2::INTEGER:
      case TypeFmi2::ENUM:
        init_integer_.push_back(static_cast<fmi2Integer>(v.value.front()));
        vr_integer_.push_back(vr);
        break;
      case TypeFmi2::BOOLEAN:
        init_boolean_.push_back(static_cast<fmi2Boolean>(v.value.front()));
        vr_boolean_.push_back(vr);
        break;
      case TypeFmi2::STRING:
        init_string_.push_back(v.stringvalue);
        vr_string_.push_back(vr);
        break;
      default:
        casadi_warning("Ignoring " + v.name + ", type: " + to_string(v.type));
    }
  }
 
  // Collect auxilliary variables
  vn_aux_real_.clear();
  vn_aux_integer_.clear();
  vn_aux_boolean_.clear();
  vn_aux_string_.clear();
  vr_aux_real_.clear();
  vr_aux_integer_.clear();
  vr_aux_boolean_.clear();
  vr_aux_string_.clear();
  for (auto&& s : aux_) {
    const Variable& v = dae->variable(s);
    // Convert to expected type
    fmi2ValueReference vr = v.value_reference;
    // Sort by type
    switch (to_fmi2(v.type)) {
      case TypeFmi2::REAL:
        // Real
        vn_aux_real_.push_back(v.name);
        vr_aux_real_.push_back(vr);
        break;
      case TypeFmi2::INTEGER:
      case TypeFmi2::ENUM:
        // Integer or enum
        vn_aux_integer_.push_back(v.name);
        vr_aux_integer_.push_back(vr);
        break;
      case TypeFmi2::BOOLEAN:
        // Boolean
        vn_aux_boolean_.push_back(v.name);
        vr_aux_boolean_.push_back(vr);
        break;
      case TypeFmi2::STRING:
        // String
        vn_aux_string_.push_back(v.name);
        vr_aux_string_.push_back(vr);
        break;
      default:
        casadi_warning("Ignoring " + v.name + ", type: " + to_string(v.type));
    }
  }
}

References casadi::FmuInternal::aux_, casadi::BOOLEAN, casadi::Variable::causality, casadi::ENUM, casadi::FmuInternal::init(), init_boolean_, init_integer_, init_real_, init_string_, casadi::INPUT, casadi::INTEGER, casadi::Variable::is_set(), casadi::DaeBuilderInternal::n_variables(), casadi::Variable::name, casadi::Variable::numel, casadi::PARAMETER, casadi::REAL, casadi::STRING, casadi::Variable::stringvalue, casadi::to_fmi2(), casadi::to_string(), casadi::Variable::type, casadi::Variable::value, casadi::Variable::value_reference, casadi::DaeBuilderInternal::variable(), vn_aux_boolean_, vn_aux_integer_, vn_aux_real_, vn_aux_string_, vr_aux_boolean_, vr_aux_integer_, vr_aux_real_, vr_aux_string_, vr_boolean_, vr_integer_, vr_real_, and vr_string_.

init_mem()

int casadi::Fmu2::init_mem ( FmuMemory *  m ) const

overridevirtual

Extra doc: https://github.com/casadi/casadi/wiki/L_2do

Allocate numerical values for initial auxilliary variables

Reimplemented from casadi::FmuInternal.

Definition at line 39 of file fmu2.cpp.

                                       {
  if (FmuInternal::init_mem(mem)) return 1;
  auto m = static_cast<Fmu2Memory*>(mem);
  m->aux_value.v_real.resize(vn_aux_real_.size());
  m->aux_value.v_integer.resize(vn_aux_integer_.size());
  m->aux_value.v_boolean.resize(vn_aux_boolean_.size());
  m->aux_value.v_string.resize(vn_aux_string_.size());
  return 0;
}

References casadi::FmuInternal::init_mem(), vn_aux_boolean_, vn_aux_integer_, vn_aux_real_, and vn_aux_string_.

initSingleton()

void casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::initSingleton ( )

inlineprotectedinherited

Called in the constructor of singletons to avoid that the counter reaches zero

Definition at line 71 of file generic_shared_internal.hpp.

                         {
      casadi_assert_dev(static_cast<Internal*>(this)->count==0);
      static_cast<Internal*>(this)->count++;
    }

instantiate()

void * casadi::Fmu2::instantiate ( ) const

overridevirtual

Implements casadi::FmuInternal.

Definition at line 244 of file fmu2.cpp.

                              {
  // Instantiate FMU
  fmi2String instanceName = instance_name_.c_str();
  fmi2Type fmuType = fmi2ModelExchange;
  fmi2String fmuGUID = instantiation_token_.c_str();
  fmi2String fmuResourceLocation = resource_loc_.c_str();
  fmi2Boolean visible = fmi2False;
  fmi2Component c = instantiate_(instanceName, fmuType, fmuGUID, fmuResourceLocation,
    &functions_, visible, logging_on_);
  if (c == 0) casadi_error("fmi2Instantiate failed");
 
  // Call fmi2SetupExperiment
  fmi2Status status = setup_experiment_(c, fmutol_ > 0, fmutol_, 0., fmi2True, 1.);
  casadi_assert(status == fmi2OK, "fmi2SetupExperiment failed");
 
  return c;
}

References casadi::FmuInternal::fmutol_, functions_, casadi::FmuInternal::instance_name_, instantiate_, casadi::FmuInternal::instantiation_token_, casadi::FmuInternal::logging_on_, casadi::FmuInternal::resource_loc_, and setup_experiment_.

jac_sparsity()

Sparsity casadi::FmuInternal::jac_sparsity ( const std::vector< size_t > &  osub, const std::vector< size_t > &  isub  ) const

inherited

Definition at line 665 of file fmu.cpp.

                                         {
  // Convert to casadi_int type
  std::vector<casadi_int> osub1(osub.begin(), osub.end());
  std::vector<casadi_int> isub1(isub.begin(), isub.end());
  // Index mapping (not used)
  std::vector<casadi_int> mapping;
  // Get selection
  return jac_sp_.sub(osub1, isub1, mapping);
}

References casadi::FmuInternal::jac_sp_, and casadi::Sparsity::sub().

load_function()

template<typename T >

T * casadi::FmuInternal::load_function ( const std::string &  symname )

inherited

Definition at line 357 of file fmu_impl.hpp.

                                                      {
  // Load the function
  signal_t f = li_.get_function(symname);
  // Ensure that it was found
  casadi_assert(f != 0, "Cannot retrieve '" + symname + "'");
  // Return function with the right type
  return reinterpret_cast<T*>(f);
}

References casadi::Importer::get_function(), casadi::FmuInternal::li_, and casadi::T.

load_functions()

void casadi::Fmu2::load_functions ( )

overridevirtual

Implements casadi::FmuInternal.

Definition at line 177 of file fmu2.cpp.

                          {
  instantiate_ = load_function<fmi2InstantiateTYPE>("fmi2Instantiate");
  free_instance_ = load_function<fmi2FreeInstanceTYPE>("fmi2FreeInstance");
  reset_ = load_function<fmi2ResetTYPE>("fmi2Reset");
  setup_experiment_ = load_function<fmi2SetupExperimentTYPE>("fmi2SetupExperiment");
  enter_initialization_mode_ = load_function<fmi2EnterInitializationModeTYPE>(
    "fmi2EnterInitializationMode");
  exit_initialization_mode_ = load_function<fmi2ExitInitializationModeTYPE>(
    "fmi2ExitInitializationMode");
  enter_continuous_time_mode_ = load_function<fmi2EnterContinuousTimeModeTYPE>(
    "fmi2EnterContinuousTimeMode");
  get_derivatives_ = load_function<fmi2GetDerivativesTYPE>("fmi2GetDerivatives");
  set_time_ = load_function<fmi2SetTimeTYPE>("fmi2SetTime");
  get_real_ = load_function<fmi2GetRealTYPE>("fmi2GetReal");
  set_real_ = load_function<fmi2SetRealTYPE>("fmi2SetReal");
  get_integer_ = load_function<fmi2GetIntegerTYPE>("fmi2GetInteger");
  set_integer_ = load_function<fmi2SetIntegerTYPE>("fmi2SetInteger");
  get_boolean_ = load_function<fmi2GetBooleanTYPE>("fmi2GetBoolean");
  set_boolean_ = load_function<fmi2SetBooleanTYPE>("fmi2SetBoolean");
  get_string_ = load_function<fmi2GetStringTYPE>("fmi2GetString");
  set_string_ = load_function<fmi2SetStringTYPE>("fmi2SetString");
  if (provides_directional_derivatives_) {
    get_directional_derivative_ =
      load_function<fmi2GetDirectionalDerivativeTYPE>("fmi2GetDirectionalDerivative");
  }
  new_discrete_states_ = load_function<fmi2NewDiscreteStatesTYPE>("fmi2NewDiscreteStates");
 
  // Callback functions
  functions_.logger = logger;
  functions_.allocateMemory = calloc;
  functions_.freeMemory = free;
  functions_.stepFinished = 0;
  functions_.componentEnvironment = 0;
}

References enter_continuous_time_mode_, enter_initialization_mode_, exit_initialization_mode_, free_instance_, functions_, get_boolean_, get_derivatives_, get_directional_derivative_, get_integer_, get_real_, get_string_, instantiate_, logger(), new_discrete_states_, casadi::FmuInternal::provides_directional_derivatives_, reset_, set_boolean_, set_integer_, set_real_, set_string_, set_time_, and setup_experiment_.

logger()

void casadi::Fmu2::logger ( fmi2ComponentEnvironment  componentEnvironment, fmi2String  instanceName, fmi2Status  status, fmi2String  category, fmi2String  message,   ...  )

static

Definition at line 212 of file fmu2.cpp.

                             {
  // Variable number of arguments
  va_list args;
  va_start(args, message);
  // Static & dynamic buffers
  char buf[256];
  size_t buf_sz = sizeof(buf);
  char* buf_dyn = nullptr;
  // Try to print with a small buffer
  int n = vsnprintf(buf, buf_sz, message, args);
  // Need a larger buffer?
  if (n > buf_sz) {
    buf_sz = n + 1;
    buf_dyn = new char[buf_sz];
    n = vsnprintf(buf_dyn, buf_sz, message, args);
  }
  // Print buffer content
  if (n >= 0) {
    uout() << "[" << instanceName << ":" << category << "] "
      << (buf_dyn ? buf_dyn : buf) << std::endl;
  }
  // Cleanup
  delete[] buf_dyn;
  va_end(args);
  // Throw error if failure
  casadi_assert(n>=0, "Print failure while processing '" + std::string(message) + "'");
}

References casadi::uout().

Referenced by load_functions().

n_in()

size_t casadi::FmuInternal::n_in ( ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_270

Definition at line 127 of file fmu_impl.hpp.

{ return iind_.size();}

Referenced by casadi::Fmu3::get_adjoint_derivative(), get_directional_derivative(), and casadi::Fmu3::get_directional_derivative().

n_out()

size_t casadi::FmuInternal::n_out ( ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_26o

Definition at line 132 of file fmu_impl.hpp.

{ return oind_.size();}

Referenced by casadi::FmuInternal::eval(), casadi::Fmu3::get_adjoint_derivative(), get_directional_derivative(), and casadi::Fmu3::get_directional_derivative().

request()

void casadi::FmuInternal::request ( FmuMemory *  m, size_t  ind  ) const

inherited

Definition at line 1213 of file fmu.cpp.

                                                        {
  for (size_t id : ored_[ind]) {
    // Mark as requested
    m->omarked_.at(id) = true;
    // Also log corresponding input index
    m->wrt_.at(id) = -1;
  }
}

References casadi::FmuMemory::omarked_, casadi::FmuInternal::ored_, and casadi::FmuMemory::wrt_.

request_adj() [1/2]

void casadi::FmuInternal::request_adj ( FmuMemory *  m, casadi_int  ind  ) const

inherited

Definition at line 1073 of file fmu.cpp.

                                                                {
  // Request all sensitivities FIXME(@jaeandersson): should use compatible types
  casadi_int wrt_id = -1;
  for (size_t id : ired_[ind]) {
    casadi_int id2 = id;
    request_adj(m, 1, &id2, &wrt_id);
  }
}

References casadi::FmuInternal::ired_, and casadi::FmuInternal::request_adj().

request_adj() [2/2]

void casadi::FmuInternal::request_adj ( FmuMemory *  m, casadi_int  nsens, const casadi_int *  id, const casadi_int *  wrt_id  ) const

inherited

Definition at line 1064 of file fmu.cpp.

                                    {
  for (casadi_int i = 0; i < nsens; ++i) {
    m->imarked_.at(*id) = true;
    m->wrt_.at(*id) = *wrt_id++;
    id++;
  }
}

References casadi::FmuMemory::imarked_, and casadi::FmuMemory::wrt_.

Referenced by casadi::FmuInternal::request_adj().

request_fwd() [1/2]

void casadi::FmuInternal::request_fwd ( FmuMemory *  m, casadi_int  ind  ) const

inherited

Definition at line 1285 of file fmu.cpp.

                                                                {
  // Request all sensitivities FIXME(@jaeandersson): should use compatible types
  casadi_int wrt_id = -1;
  for (size_t id : ored_[ind]) {
    casadi_int id2 = id;
    request_fwd(m, 1, &id2, &wrt_id);
  }
}

References casadi::FmuInternal::ored_, and casadi::FmuInternal::request_fwd().

request_fwd() [2/2]

void casadi::FmuInternal::request_fwd ( FmuMemory *  m, casadi_int  nsens, const casadi_int *  id, const casadi_int *  wrt_id  ) const

inherited

Definition at line 1276 of file fmu.cpp.

                                    {
  for (casadi_int i = 0; i < nsens; ++i) {
    m->omarked_.at(*id) = true;
    m->wrt_.at(*id) = *wrt_id++;
    id++;
  }
}

References casadi::FmuMemory::omarked_, and casadi::FmuMemory::wrt_.

Referenced by casadi::FmuInternal::request_fwd().

reset()

int casadi::Fmu2::reset

(

void *

instance

)

Definition at line 271 of file fmu2.cpp.

                              {
  auto c = static_cast<fmi2Component>(instance);
  fmi2Status status = reset_(c);
  if (status != fmi2OK) {
    casadi_warning("fmi2Reset failed");
    return 1;
  }
  return 0;
}

References reset_.

serialize()

void casadi::FmuInternal::serialize ( SerializingStream &  s ) const

inherited

Definition at line 1371 of file fmu.cpp.

                                                      {
  serialize_type(s);
  serialize_body(s);
}

References casadi::FmuInternal::serialize_body(), and casadi::FmuInternal::serialize_type().

serialize_body()

void casadi::Fmu2::serialize_body ( SerializingStream &  s ) const

overridevirtual

Reimplemented from casadi::FmuInternal.

Definition at line 579 of file fmu2.cpp.

                                                    {
  FmuInternal::serialize_body(s);
 
  s.version("Fmu2", 2);
  s.pack("Fmu2::vr_real", vr_real_);
  s.pack("Fmu2::vr_integer", vr_integer_);
  s.pack("Fmu2::vr_boolean", vr_boolean_);
  s.pack("Fmu2::vr_string", vr_string_);
  s.pack("Fmu2::init_real", init_real_);
  s.pack("Fmu2::init_integer", init_integer_);
  s.pack("Fmu2::init_boolean", init_boolean_);
  s.pack("Fmu2::init_string", init_string_);
 
  s.pack("Fmu2::vn_aux_real", vn_aux_real_);
  s.pack("Fmu2::vn_aux_integer", vn_aux_integer_);
  s.pack("Fmu2::vn_aux_boolean", vn_aux_boolean_);
  s.pack("Fmu2::vn_aux_string", vn_aux_string_);
  s.pack("Fmu2::vr_aux_real", vr_aux_real_);
  s.pack("Fmu2::vr_aux_integer", vr_aux_integer_);
  s.pack("Fmu2::vr_aux_boolean", vr_aux_boolean_);
  s.pack("Fmu2::vr_aux_string", vr_aux_string_);
}

References init_boolean_, init_integer_, init_real_, init_string_, casadi::SerializingStream::pack(), casadi::FmuInternal::serialize_body(), casadi::SerializingStream::version(), vn_aux_boolean_, vn_aux_integer_, vn_aux_real_, vn_aux_string_, vr_aux_boolean_, vr_aux_integer_, vr_aux_real_, vr_aux_string_, vr_boolean_, vr_integer_, vr_real_, and vr_string_.

serialize_type()

void casadi::FmuInternal::serialize_type ( SerializingStream &  s ) const

virtualinherited

Definition at line 1376 of file fmu.cpp.

                                                           {
  s.pack("FmuInternal::type", class_name());
}

References casadi::SharedObjectInternal::class_name(), and casadi::SerializingStream::pack().

Referenced by casadi::FmuInternal::serialize().

set()

void casadi::FmuInternal::set ( FmuMemory *  m, size_t  ind, const double *  value  ) const

inherited

Definition at line 1192 of file fmu.cpp.

                                                                         {
  if (value) {
    // Argument is given
    for (size_t id : ired_[ind]) {
      if (*value != m->ibuf_.at(id)) {
        m->ibuf_.at(id) = *value;
        m->imarked_.at(id) = true;
      }
      value++;
    }
  } else {
    // Argument is null - all zeros
    for (size_t id : ired_[ind]) {
      if (0 != m->ibuf_.at(id)) {
        m->ibuf_.at(id) = 0;
        m->imarked_.at(id) = true;
      }
    }
  }
}

References casadi::FmuMemory::ibuf_, casadi::FmuMemory::imarked_, and casadi::FmuInternal::ired_.

set_adj() [1/2]

void casadi::FmuInternal::set_adj ( FmuMemory *  m, casadi_int  nseed, const casadi_int *  id, const double *  v  ) const

inherited

Definition at line 1045 of file fmu.cpp.

                                                 {
  for (casadi_int i = 0; i < nseed; ++i) {
    m->osens_.at(*id) = *v++;
    m->omarked_.at(*id) = true;
    id++;
  }
}

References casadi::FmuMemory::omarked_, and casadi::FmuMemory::osens_.

Referenced by casadi::FmuInternal::set_adj().

set_adj() [2/2]

void casadi::FmuInternal::set_adj ( FmuMemory *  m, size_t  ind, const double *  v  ) const

inherited

Definition at line 1054 of file fmu.cpp.

                                                                         {
  // If seeds are zero, no need to add to seed buffers
  if (!v) return;
  // Pass all seeds FIXME(@jaeandersson): should use compatible types
  for (size_t id : ored_[ind]) {
    casadi_int id2 = id;
    set_adj(m, 1, &id2, v++);
  }
}

References casadi::FmuInternal::ored_, and casadi::FmuInternal::set_adj().

set_fwd() [1/2]

void casadi::FmuInternal::set_fwd ( FmuMemory *  m, casadi_int  nseed, const casadi_int *  id, const double *  v  ) const

inherited

Definition at line 1257 of file fmu.cpp.

                                                 {
  for (casadi_int i = 0; i < nseed; ++i) {
    m->isens_.at(*id) = *v++;
    m->imarked_.at(*id) = true;
    id++;
  }
}

References casadi::FmuMemory::imarked_, and casadi::FmuMemory::isens_.

Referenced by casadi::FmuInternal::set_fwd().

set_fwd() [2/2]

void casadi::FmuInternal::set_fwd ( FmuMemory *  m, size_t  ind, const double *  v  ) const

inherited

Definition at line 1266 of file fmu.cpp.

                                                                         {
  // If seeds are zero, no need to add to seed buffers
  if (!v) return;
  // Pass all seeds FIXME(@jaeandersson): should use compatible types
  for (size_t id : ired_[ind]) {
    casadi_int id2 = id;
    set_fwd(m, 1, &id2, v++);
  }
}

References casadi::FmuInternal::ired_, and casadi::FmuInternal::set_fwd().

set_real()

int casadi::Fmu2::set_real ( void *  instance, const unsigned int *  vr, size_t  n_vr, const double *  values, size_t  n_values  ) const

overridevirtual

Implements casadi::FmuInternal.

Definition at line 343 of file fmu2.cpp.

                                                 {
  casadi_assert(n_vr == n_values, "Vector-valued variables not supported in FMI 2");
 
  // Set time variable, if any
  if (has_independent_ && n_vr > 0 && *vr == vr_in_[0]) {
    // Update FMU time
    fmi2Status status = set_time_(instance, *values);
    if (status != fmi2OK) return 1;
    // Skip when setting remaining variables
    vr++;
    n_vr--;
    values++;
    n_values--;
  }
 
  fmi2Status status = set_real_(instance, vr, n_vr, values);
  return status != fmi2OK;
}

References casadi::FmuInternal::has_independent_, set_real_, set_time_, and casadi::FmuInternal::vr_in_.

set_values()

int casadi::Fmu2::set_values ( void *  instance ) const

overridevirtual

Implements casadi::FmuInternal.

Definition at line 391 of file fmu2.cpp.

                                         {
  auto c = static_cast<fmi2Component>(instance);
  // Pass real values before initialization
  if (!vr_real_.empty()) {
    fmi2Status status = set_real_(c, get_ptr(vr_real_), vr_real_.size(), get_ptr(init_real_));
    if (status != fmi2OK) {
      casadi_warning("fmi2SetReal failed");
      return 1;
    }
  }
  // Pass integer values before initialization (also enums)
  if (!vr_integer_.empty()) {
    fmi2Status status = set_integer_(c, get_ptr(vr_integer_), vr_integer_.size(),
      get_ptr(init_integer_));
    if (status != fmi2OK) {
      casadi_warning("fmi2SetInteger failed");
      return 1;
    }
  }
  // Pass boolean values before initialization
  if (!vr_boolean_.empty()) {
    fmi2Status status = set_boolean_(c, get_ptr(vr_boolean_), vr_boolean_.size(),
      get_ptr(init_boolean_));
    if (status != fmi2OK) {
      casadi_warning("fmi2SetBoolean failed");
      return 1;
    }
  }
  // Pass string values before initialization
  for (size_t k = 0; k < vr_string_.size(); ++k) {
    fmi2ValueReference vr = vr_string_[k];
    fmi2String value = init_string_[k].c_str();
    fmi2Status status = set_string_(c, &vr, 1, &value);
    if (status != fmi2OK) {
      casadi_error("fmi2SetString failed for value reference " + str(vr));
    }
  }
  // Successful return
  return 0;
}

References casadi::get_ptr(), init_boolean_, init_integer_, init_real_, init_string_, set_boolean_, set_integer_, set_real_, set_string_, casadi::str(), vr_boolean_, vr_integer_, vr_real_, and vr_string_.

shared_from_this() [1/2]

B casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::shared_from_this ( )

inlineprotectedinherited

Definition at line 83 of file generic_shared_internal.hpp.

                         {
      casadi_assert_dev(B::test_cast(static_cast<Internal*>(this)));
      B ret;
      ret.own(static_cast<Internal*>(this));
      return ret;
    }

shared_from_this() [2/2]

const B casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::shared_from_this ( ) const

inlineprotectedinherited

Definition at line 92 of file generic_shared_internal.hpp.

                                     {
      casadi_assert_dev(B::test_cast(static_cast<const Internal*>(this)));
      B ret;
      ret.own(const_cast<Internal*>(static_cast<const Internal*>(this)));
      return ret;
    }

system_infix()

std::string casadi::Fmu2::system_infix ( ) const

overridevirtual

Implements casadi::FmuInternal.

Definition at line 61 of file fmu2.cpp.

                                   {
#if defined(_WIN32)
  // Windows system
#ifdef _WIN64
  return "win64";
#else
  return "win32";
#endif
#elif defined(__APPLE__)
  // OSX
  return sizeof(void*) == 4 ? "darwin32" : "darwin64";
#else
  // Linux
  return sizeof(void*) == 4 ? "linux32" : "linux64";
#endif
}

update_discrete_states()

int casadi::Fmu2::update_discrete_states ( void *  instance, EventMemory *  eventmem  ) const

overridevirtual

Implements casadi::FmuInternal.

Definition at line 321 of file fmu2.cpp.

                                                                            {
  auto c = static_cast<fmi2Component>(instance);
  // Return arguments in FMI types
  fmi2EventInfo eventInfo;
  eventInfo.newDiscreteStatesNeeded = fmi2False;
  eventInfo.terminateSimulation = fmi2False;
  eventInfo.nominalsOfContinuousStatesChanged = fmi2False;
  eventInfo.valuesOfContinuousStatesChanged = fmi2False;
  eventInfo.nextEventTimeDefined = fmi2False;
  eventInfo.nextEventTime = 0.0;
  // Call FMU
  fmi2Status status = new_discrete_states_(c, &eventInfo);
  // Pass to event iteration memory
  eventmem->discrete_states_need_update = eventInfo.newDiscreteStatesNeeded;
  eventmem->terminate_simulation = eventInfo.terminateSimulation;
  eventmem->nominals_of_continuous_states_changed = eventInfo.nominalsOfContinuousStatesChanged;
  eventmem->values_of_continuous_states_changed = eventInfo.valuesOfContinuousStatesChanged;
  eventmem->next_event_time_defined = eventInfo.nextEventTimeDefined;
  eventmem->next_event_time = eventInfo.nextEventTime;
  return status != fmi2OK;
}

References casadi::EventMemory::discrete_states_need_update, new_discrete_states_, casadi::EventMemory::next_event_time, casadi::EventMemory::next_event_time_defined, casadi::EventMemory::nominals_of_continuous_states_changed, casadi::EventMemory::terminate_simulation, and casadi::EventMemory::values_of_continuous_states_changed.

weak()

GenericWeakRef< SharedObject , SharedObjectInternal > * casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::weak

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1ai

Definition at line 67 of file generic_shared_internal.hpp.

                                                                                  {
    if (weak_ref_==nullptr) {
      weak_ref_ = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
    }
    return weak_ref_;
  }

Member Data Documentation

aux_

std::vector<std::string> casadi::FmuInternal::aux_

protectedinherited

Definition at line 294 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), init(), casadi::Fmu3::init(), and casadi::FmuInternal::serialize_body().

aux_value_

Value casadi::Fmu2::aux_value_

Definition at line 126 of file fmu2.hpp.

Referenced by finalize(), and get_aux().

can_be_instantiated_only_once_per_process_

bool casadi::FmuInternal::can_be_instantiated_only_once_per_process_

protectedinherited

Definition at line 318 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

do_evaluation_dance_

bool casadi::FmuInternal::do_evaluation_dance_

protectedinherited

Definition at line 353 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), get_real(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

enter_continuous_time_mode_

fmi2EnterContinuousTimeModeTYPE* casadi::Fmu2::enter_continuous_time_mode_

Definition at line 101 of file fmu2.hpp.

Referenced by enter_continuous_time_mode(), Fmu2(), and load_functions().

enter_initialization_mode_

fmi2EnterInitializationModeTYPE* casadi::Fmu2::enter_initialization_mode_

Definition at line 99 of file fmu2.hpp.

Referenced by enter_initialization_mode(), Fmu2(), and load_functions().

exit_initialization_mode_

fmi2ExitInitializationModeTYPE* casadi::Fmu2::exit_initialization_mode_

Definition at line 100 of file fmu2.hpp.

Referenced by exit_initialization_mode(), Fmu2(), and load_functions().

fmutol_

double casadi::FmuInternal::fmutol_

protectedinherited

Definition at line 300 of file fmu_impl.hpp.

Referenced by casadi::Fmu3::enter_initialization_mode(), casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), instantiate(), and casadi::FmuInternal::serialize_body().

free_instance_

fmi2FreeInstanceTYPE* casadi::Fmu2::free_instance_

Definition at line 96 of file fmu2.hpp.

Referenced by Fmu2(), free_instance(), and load_functions().

functions_

fmi2CallbackFunctions casadi::Fmu2::functions_

Definition at line 116 of file fmu2.hpp.

Referenced by instantiate(), and load_functions().

get_boolean_

fmi2GetBooleanTYPE* casadi::Fmu2::get_boolean_

Definition at line 106 of file fmu2.hpp.

Referenced by get_aux_impl(), and load_functions().

get_derivatives_

fmi2GetDerivativesTYPE* casadi::Fmu2::get_derivatives_

Definition at line 102 of file fmu2.hpp.

Referenced by get_derivatives(), get_real(), and load_functions().

get_directional_derivative_

fmi2GetDirectionalDerivativeTYPE* casadi::Fmu2::get_directional_derivative_

Definition at line 112 of file fmu2.hpp.

Referenced by Fmu2(), get_directional_derivative(), and load_functions().

get_integer_

fmi2GetIntegerTYPE* casadi::Fmu2::get_integer_

Definition at line 108 of file fmu2.hpp.

Referenced by get_aux_impl(), and load_functions().

get_real_

fmi2GetRealTYPE* casadi::Fmu2::get_real_

Definition at line 104 of file fmu2.hpp.

Referenced by Fmu2(), get_aux_impl(), get_real(), and load_functions().

get_string_

fmi2GetStringTYPE* casadi::Fmu2::get_string_

Definition at line 110 of file fmu2.hpp.

Referenced by load_functions().

has_independent_

bool casadi::FmuInternal::has_independent_

protectedinherited

Definition at line 327 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), casadi::FmuInternal::serialize_body(), set_real(), and casadi::Fmu3::set_real().

hess_sp_

Sparsity casadi::FmuInternal::hess_sp_

protectedinherited

Definition at line 343 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::hess_sparsity(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

iind_

std::vector<size_t> casadi::FmuInternal::iind_

protectedinherited

Definition at line 324 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), casadi::FmuInternal::init_mem(), and casadi::FmuInternal::serialize_body().

iind_map_

std::vector<size_t> casadi::FmuInternal::iind_map_

protectedinherited

Definition at line 324 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

init_boolean_

std::vector<fmi2Boolean> casadi::Fmu2::init_boolean_

Definition at line 85 of file fmu2.hpp.

Referenced by Fmu2(), init(), serialize_body(), and set_values().

init_integer_

std::vector<fmi2Integer> casadi::Fmu2::init_integer_

Definition at line 84 of file fmu2.hpp.

Referenced by Fmu2(), init(), serialize_body(), and set_values().

init_real_

std::vector<fmi2Real> casadi::Fmu2::init_real_

Definition at line 83 of file fmu2.hpp.

Referenced by Fmu2(), init(), serialize_body(), and set_values().

init_string_

std::vector<std::string> casadi::Fmu2::init_string_

Definition at line 86 of file fmu2.hpp.

Referenced by Fmu2(), init(), serialize_body(), and set_values().

instance_name_

std::string casadi::FmuInternal::instance_name_

protectedinherited

Definition at line 303 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::finalize(), casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), instantiate(), casadi::Fmu3::instantiate(), and casadi::FmuInternal::serialize_body().

instantiate_

fmi2InstantiateTYPE* casadi::Fmu2::instantiate_

Definition at line 95 of file fmu2.hpp.

Referenced by Fmu2(), instantiate(), and load_functions().

instantiation_token_

std::string casadi::FmuInternal::instantiation_token_

protectedinherited

Definition at line 306 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), instantiate(), casadi::Fmu3::instantiate(), and casadi::FmuInternal::serialize_body().

ired_

std::vector<std::vector<size_t> > casadi::FmuInternal::ired_

protectedinherited

Definition at line 340 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::all_nominal_in(), casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::get_adj(), get_stats(), casadi::Fmu3::get_stats(), casadi::FmuInternal::init(), casadi::FmuInternal::request_adj(), casadi::FmuInternal::serialize_body(), casadi::FmuInternal::set(), and casadi::FmuInternal::set_fwd().

jac_sp_

Sparsity casadi::FmuInternal::jac_sp_

protectedinherited

Definition at line 343 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), casadi::FmuInternal::jac_sparsity(), and casadi::FmuInternal::serialize_body().

li_

Importer casadi::FmuInternal::li_

protectedinherited

Definition at line 321 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::finalize(), and casadi::FmuInternal::load_function().

logging_on_

bool casadi::FmuInternal::logging_on_

protectedinherited

Definition at line 309 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), instantiate(), casadi::Fmu3::instantiate(), and casadi::FmuInternal::serialize_body().

max_in_

std::vector<double> casadi::FmuInternal::max_in_

protectedinherited

Definition at line 332 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::desc_in(), casadi::FmuInternal::eval_fd(), casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

max_out_

std::vector<double> casadi::FmuInternal::max_out_

protectedinherited

Definition at line 332 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

min_in_

std::vector<double> casadi::FmuInternal::min_in_

protectedinherited

Definition at line 331 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::desc_in(), casadi::FmuInternal::eval_fd(), casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

min_out_

std::vector<double> casadi::FmuInternal::min_out_

protectedinherited

Definition at line 331 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

name_

std::string casadi::FmuInternal::name_

protectedinherited

Definition at line 287 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::disp(), casadi::FmuInternal::FmuInternal(), and casadi::FmuInternal::serialize_body().

new_discrete_states_

fmi2NewDiscreteStatesTYPE* casadi::Fmu2::new_discrete_states_

Definition at line 113 of file fmu2.hpp.

Referenced by Fmu2(), load_functions(), and update_discrete_states().

nominal_in_

std::vector<double> casadi::FmuInternal::nominal_in_

protectedinherited

Definition at line 330 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::all_nominal_in(), casadi::FmuInternal::desc_in(), casadi::FmuInternal::eval_fd(), casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

nominal_out_

std::vector<double> casadi::FmuInternal::nominal_out_

protectedinherited

Definition at line 330 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::all_nominal_out(), casadi::FmuInternal::eval_fd(), casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

number_of_event_indicators_

casadi_int casadi::FmuInternal::number_of_event_indicators_

protectedinherited

Definition at line 312 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

nx_

size_t casadi::FmuInternal::nx_

protectedinherited

Definition at line 351 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), get_real(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

oind_

std::vector<size_t> casadi::FmuInternal::oind_

protectedinherited

Definition at line 324 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), casadi::FmuInternal::init_mem(), and casadi::FmuInternal::serialize_body().

oind_map_

std::vector<size_t> casadi::FmuInternal::oind_map_

protectedinherited

Definition at line 324 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

ored_

std::vector<std::vector<size_t> > casadi::FmuInternal::ored_

protectedinherited

Definition at line 340 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::all_nominal_out(), casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::get(), casadi::FmuInternal::get_fwd(), casadi::FmuInternal::init(), casadi::FmuInternal::request(), casadi::FmuInternal::request_fwd(), casadi::FmuInternal::serialize_body(), and casadi::FmuInternal::set_adj().

provides_adjoint_derivatives_

bool casadi::FmuInternal::provides_adjoint_derivatives_

protectedinherited

Definition at line 315 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), casadi::Fmu3::load_functions(), and casadi::FmuInternal::serialize_body().

provides_directional_derivatives_

bool casadi::FmuInternal::provides_directional_derivatives_

protectedinherited

Definition at line 315 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), load_functions(), casadi::Fmu3::load_functions(), and casadi::FmuInternal::serialize_body().

reset_

fmi2ResetTYPE* casadi::Fmu2::reset_

Definition at line 97 of file fmu2.hpp.

Referenced by Fmu2(), load_functions(), and reset().

resource_

Resource casadi::FmuInternal::resource_

protectedinherited

Definition at line 284 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::finalize(), casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

resource_loc_

std::string casadi::FmuInternal::resource_loc_

protectedinherited

Definition at line 297 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::finalize(), instantiate(), and casadi::Fmu3::instantiate().

scheme_

std::map<std::string, std::vector<size_t> > casadi::FmuInternal::scheme_

protectedinherited

Definition at line 291 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

scheme_in_

std::vector<std::string> casadi::FmuInternal::scheme_in_

protectedinherited

Definition at line 290 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::index_in(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

scheme_out_

std::vector<std::string> casadi::FmuInternal::scheme_out_

protectedinherited

Definition at line 290 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::index_out(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

set_boolean_

fmi2SetBooleanTYPE* casadi::Fmu2::set_boolean_

Definition at line 107 of file fmu2.hpp.

Referenced by Fmu2(), load_functions(), and set_values().

set_integer_

fmi2SetIntegerTYPE* casadi::Fmu2::set_integer_

Definition at line 109 of file fmu2.hpp.

Referenced by load_functions(), and set_values().

set_real_

fmi2SetRealTYPE* casadi::Fmu2::set_real_

Definition at line 105 of file fmu2.hpp.

Referenced by Fmu2(), load_functions(), set_real(), and set_values().

set_string_

fmi2SetStringTYPE* casadi::Fmu2::set_string_

Definition at line 111 of file fmu2.hpp.

Referenced by get_aux_impl(), load_functions(), and set_values().

set_time_

fmi2SetTimeTYPE* casadi::Fmu2::set_time_

Definition at line 103 of file fmu2.hpp.

Referenced by Fmu2(), load_functions(), and set_real().

setup_experiment_

fmi2SetupExperimentTYPE* casadi::Fmu2::setup_experiment_

Definition at line 98 of file fmu2.hpp.

Referenced by Fmu2(), instantiate(), and load_functions().

value_in_

std::vector<double> casadi::FmuInternal::value_in_

protectedinherited

Definition at line 337 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::finalize(), casadi::FmuInternal::FmuInternal(), get_stats(), casadi::Fmu3::get_stats(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

vn_aux_boolean_

std::vector<std::string> casadi::Fmu2::vn_aux_boolean_

Definition at line 89 of file fmu2.hpp.

Referenced by finalize(), Fmu2(), get_stats(), init(), init_mem(), and serialize_body().

vn_aux_integer_

std::vector<std::string> casadi::Fmu2::vn_aux_integer_

Definition at line 89 of file fmu2.hpp.

Referenced by finalize(), Fmu2(), get_stats(), init(), init_mem(), and serialize_body().

vn_aux_real_

std::vector<std::string> casadi::Fmu2::vn_aux_real_

Definition at line 89 of file fmu2.hpp.

Referenced by finalize(), Fmu2(), get_stats(), init(), init_mem(), and serialize_body().

vn_aux_string_

std::vector<std::string> casadi::Fmu2::vn_aux_string_

Definition at line 89 of file fmu2.hpp.

Referenced by finalize(), Fmu2(), get_stats(), init(), init_mem(), and serialize_body().

vn_in_

std::vector<std::string> casadi::FmuInternal::vn_in_

protectedinherited

Definition at line 333 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::desc_in(), casadi::FmuInternal::eval_fd(), casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

vn_out_

std::vector<std::string> casadi::FmuInternal::vn_out_

protectedinherited

Definition at line 333 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::eval_fd(), casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

vr_aux_boolean_

std::vector<fmi2ValueReference> casadi::Fmu2::vr_aux_boolean_

Definition at line 90 of file fmu2.hpp.

Referenced by Fmu2(), get_aux_impl(), init(), and serialize_body().

vr_aux_integer_

std::vector<fmi2ValueReference> casadi::Fmu2::vr_aux_integer_

Definition at line 90 of file fmu2.hpp.

Referenced by Fmu2(), get_aux_impl(), init(), and serialize_body().

vr_aux_real_

std::vector<fmi2ValueReference> casadi::Fmu2::vr_aux_real_

Definition at line 90 of file fmu2.hpp.

Referenced by Fmu2(), get_aux_impl(), init(), and serialize_body().

vr_aux_string_

std::vector<fmi2ValueReference> casadi::Fmu2::vr_aux_string_

Definition at line 90 of file fmu2.hpp.

Referenced by Fmu2(), get_aux_impl(), init(), and serialize_body().

vr_boolean_

std::vector<fmi2ValueReference> casadi::Fmu2::vr_boolean_

Definition at line 82 of file fmu2.hpp.

Referenced by Fmu2(), init(), serialize_body(), and set_values().

vr_in_

std::vector<unsigned int> casadi::FmuInternal::vr_in_

protectedinherited

Definition at line 334 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::finalize(), casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::gather_io(), casadi::FmuInternal::init(), casadi::FmuInternal::serialize_body(), set_real(), and casadi::Fmu3::set_real().

vr_integer_

std::vector<fmi2ValueReference> casadi::Fmu2::vr_integer_

Definition at line 82 of file fmu2.hpp.

Referenced by Fmu2(), init(), serialize_body(), and set_values().

vr_out_

std::vector<unsigned int> casadi::FmuInternal::vr_out_

protectedinherited

Definition at line 334 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::gather_io(), casadi::FmuInternal::init(), and casadi::FmuInternal::serialize_body().

vr_real_

std::vector<fmi2ValueReference> casadi::Fmu2::vr_real_

Definition at line 82 of file fmu2.hpp.

Referenced by Fmu2(), init(), serialize_body(), and set_values().

vr_string_

std::vector<fmi2ValueReference> casadi::Fmu2::vr_string_

Definition at line 82 of file fmu2.hpp.

Referenced by Fmu2(), init(), serialize_body(), and set_values().

warning_fired_discrete_states_need_update_

bool casadi::FmuInternal::warning_fired_discrete_states_need_update_

mutableprotectedinherited

Definition at line 345 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::discrete_states_iter(), and casadi::FmuInternal::finalize().

warning_fired_next_event_time_defined_

bool casadi::FmuInternal::warning_fired_next_event_time_defined_

mutableprotectedinherited

Definition at line 349 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::discrete_states_iter(), and casadi::FmuInternal::finalize().

warning_fired_nominals_of_continuous_states_changed_

bool casadi::FmuInternal::warning_fired_nominals_of_continuous_states_changed_

mutableprotectedinherited

Definition at line 347 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::discrete_states_iter(), and casadi::FmuInternal::finalize().

warning_fired_terminate_simulation_

bool casadi::FmuInternal::warning_fired_terminate_simulation_

mutableprotectedinherited

Definition at line 346 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::discrete_states_iter(), and casadi::FmuInternal::finalize().

warning_fired_values_of_continuous_states_changed_

bool casadi::FmuInternal::warning_fired_values_of_continuous_states_changed_

mutableprotectedinherited

Definition at line 348 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::discrete_states_iter(), and casadi::FmuInternal::finalize().

---

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

• fmu2.hpp
• fmu2.cpp