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:

[legend]

Collaboration diagram for casadi::Fmu2:

[legend]

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_time (void *instance, double t) 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, FmuMemory m=nullptr) 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	set_all (FmuMemory m, const double values, size_t n_values) const

int	get_all (FmuMemory m, double values, size_t n_values) 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 std::string	dll_infix ()

static void	logger (fmi2ComponentEnvironment componentEnvironment, fmi2String instanceName, fmi2Status status, fmi2String category, fmi2String message,...)

static Fmu2 *	deserialize (DeserializingStream &s)

static std::string	dll_suffix ()

static std::string	fmi3_dll_infix ()

static Dict	compile_fmu (const std::string &name, const Dict &files, const Dict &opts)

static std::string	pack_fmu (const Dict &files, const std::string &path)

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_

double	start_time_

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_

unsigned int	independent_vr_

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 532 of file fmu2.cpp.

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

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 62 of file fmu2.cpp.

62 {

63 }

◆ Fmu2() [2/2]

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

explicitprotected

Definition at line 559 of file fmu2.cpp.

                                  : FmuInternal(s) {
   instantiate_ = nullptr;
   free_instance_ = nullptr;
   reset_ = nullptr;
   setup_experiment_ = nullptr;
   enter_initialization_mode_ = nullptr;
   exit_initialization_mode_ = nullptr;
   enter_continuous_time_mode_ = nullptr;
   set_real_ = nullptr;
   set_boolean_ = nullptr;
   get_real_ = nullptr;
   get_directional_derivative_ = nullptr;
   new_discrete_states_ = nullptr;
  
   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 707 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 715 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 54 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.

55 { return "Fmu2";}

◆ compile_fmu()

Dict casadi::FmuInternal::compile_fmu	(	const std::string &	name,
		const Dict &	files,
		const Dict &	opts
	)

staticinherited

Definition at line 781 of file fmu.cpp.

                                                                                         {
   // Options
   Dict compiler_opts;
   std::string compiler_plugin = "shell";
   std::vector<std::string> include_dirs;
   for (auto&& op : opts) {
     if (op.first == "compiler") {
       compiler_plugin = op.second.to_string();
     } else if (op.first == "compiler_options") {
       compiler_opts = op.second;
     } else if (op.first == "include_dirs") {
       include_dirs = op.second.to_string_vector();
     } else {
       casadi_error("No such option: " + op.first);
     }
   }
   // The C sources to compile are the .c entries of the export_fmu map (flat in CWD)
   std::vector<std::string> csources;
   for (auto&& kv : files) {
     const std::string& local = kv.first;
     if (local.size() > 2 && local.substr(local.size() - 2) == ".c") csources.push_back(local);
   }
   // Amalgamation translation unit: a single .c that #includes every generated source,
   // because the shell Importer compiles exactly one source file. The compile runs in
   // the working directory, so quoted includes resolve against the loose files there.
   // This is a build scratch file, NOT FMU content, so it is removed below.
   std::string amalg = name + "_all.c";
   {
     auto f = Filesystem::ofstream_ptr(amalg);
     for (const std::string& c : csources) *f << "#include \"" << c << "\"\n";
   }
   // Compile the amalgamation into a shared library via the Importer plugin.
   // Pass include dirs through the OS-agnostic 'include_dirs' option (the plugin
   // prefixes each with the compiler's own include flag: -I on gcc/clang, /I on MSVC).
   Dict cop = compiler_opts;
   if (!include_dirs.empty()) cop["include_dirs"] = include_dirs;
   Importer compiler(amalg, compiler_plugin, cop);
   // Lift the binary to a stable path before the Importer destructor removes it, then
   // discard the amalgamation scratch file (compilation is done once the Importer exists)
   std::string dll = name + dll_suffix();
   Filesystem::copy_file(compiler.library(), dll);
   Filesystem::remove(amalg);
   // Augment the file map with the compiled binary
   // (FMI-3 layout: binaries/<dll_infix>/<modelIdentifier><suffix>)
   Dict ret = files;
   ret[dll] = "binaries/" + fmi3_dll_infix() + "/" + name + dll_suffix();
   return ret;
 }

References casadi::Filesystem::copy_file(), casadi::FmuInternal::dll_suffix(), casadi::FmuInternal::fmi3_dll_infix(), casadi::Importer::library(), casadi::Filesystem::ofstream_ptr(), and casadi::Filesystem::remove().

Referenced by casadi::DaeBuilderInternal::compile_fmu().

◆ 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 850 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 553 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 1248 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 651 of file fmu.cpp.

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

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

◆ dll_infix()

std::string casadi::Fmu2::dll_infix ( )

static

Definition at line 65 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
 }

◆ dll_suffix()

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

staticinherited

Definition at line 723 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::compile_fmu(), and casadi::FmuInternal::finalize().

◆ enter_continuous_time_mode()

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

overridevirtual

Implements casadi::FmuInternal.

Definition at line 308 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 288 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 1414 of file fmu.cpp.

                                         {
   // Gather inputs and outputs
   gather_io(m);
   // Pass inputs to FMU
   if (set_all(m, get_ptr(m->v_in_), m->v_in_.size())) return 1;
   // Get outputs from FMU
   if (get_all(m, get_ptr(m->v_out_), m->v_out_.size())) 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::FmuInternal::get_all(), casadi::get_ptr(), casadi::FmuMemory::id_out_, casadi::FmuMemory::obuf_, casadi::FmuInternal::set_all(), casadi::FmuMemory::v_in_, and casadi::FmuMemory::v_out_.

◆ eval_ad()

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

inherited

Definition at line 912 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;
   // Quick return if no seeds
   if (n_known == 0) {
     std::fill(m->d_out_.begin(), m->d_out_.end(), 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, m)) {
     casadi_warning("FMU evaluation failed");
     return 1;
   }
   // Evaluate directional derivatives
   m->n_get_directional++;
   auto start = std::chrono::high_resolution_clock::now();
   int flag = 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);
   auto stop = std::chrono::high_resolution_clock::now();
   m->t_get_directional += std::chrono::duration_cast<std::chrono::microseconds>(
     stop - start).count() / 1e6;
   // Collect requested variables
   if (!flag) {
     auto it = m->d_out_.begin();
     for (size_t id : m->id_out_) {
       m->osens_[id] = *it++;
     }
   }
   // Return result of the evaluation
   return flag;
 }

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::n_get_directional, casadi::FmuMemory::osens_, casadi::FmuMemory::t_get_directional, 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 879 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;
   // Check if no seeds
   int flag;
   if (m->id_out_.size() == 0) {
     // Sensitivities are zero, trivially
     std::fill(m->d_in_.begin(), m->d_in_.end(), 0);
     flag = 0;
   } else {
     // Evaluate adjoint derivatives
     m->n_get_adjoint++;
     auto start = std::chrono::high_resolution_clock::now();
     flag = 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());
     auto stop = std::chrono::high_resolution_clock::now();
     m->t_get_adjoint += std::chrono::duration_cast<std::chrono::microseconds>(
       stop - start).count() / 1e6;
   }
   // Collect requested variables
   if (!flag) {
     auto it = m->d_in_.begin();
     for (size_t id : m->id_in_) {
       m->isens_[id] = *it++;
     }
   }
   // Return results of the evaluation
   return flag;
 }

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::n_get_adjoint, casadi::FmuMemory::t_get_adjoint, 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 948 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;
   // Quick return if no seeds
   if (n_known == 0) {
     std::fill(m->d_out_.begin(), m->d_out_.end(), 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, m)) {
     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] = {nullptr};
  
   // 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_all(m, get_ptr(m->v_pert_), m->v_pert_.size())) return 1;
     // Evaluate perturbed FMU
     if (get_all(m, yk, n_unknown)) 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) && (m->self.fd_flip_ || !m->flip_[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_all(m, get_ptr(m->v_in_), m->v_in_.size())) 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;
 }

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

◆ eval_fwd()

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

inherited

Definition at line 863 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 298 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 173 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().

◆ fmi3_dll_infix()

std::string casadi::FmuInternal::fmi3_dll_infix ( )

staticinherited

Definition at line 736 of file fmu.cpp.

                                       {
   // Architecture
   std::string arch;
 #if defined(__arm64__) || defined(__aarch64__)
   // ARM 64-bit Architecture
   arch = "aarch64";
 #elif __arm__
   if (sizeof(void*) == 4) {
     // ARM 32-bit Architecture
     arch = "aarch32";
   } else {
     // ARM 64-bit Architecture
     arch = "aarch64";
   }
 #elif defined(__ppc64__) || defined(__powerpc64__)
   // PowerPC 64-bit Architecture
   arch = "ppc64";
 #elif defined(__ppc__) || defined(__powerpc__)
   // PowerPC 32-bit Architecture
   arch = "ppc";
 #else
   if (sizeof(void*) == 4) {
     // Intel/AMD x86 32-bit
     arch = "x86";
   } else {
     // Intel/AMD x86 64-bit
     arch = "x86_64";
   }
 #endif
   // Operating system
   std::string sys;
 #if defined(_WIN32)
   // Microsoft Windows
   sys = "windows";
 #elif defined(__APPLE__)
   // Darwin (macOS, iOS, watchOS, tvOS, audioOS)
   sys = "darwin";
 #else
   // Linux
   sys = "linux";
 #endif
   // Return platform tuple, according to Section 2.5.1.4.1. of the FMI 3 specification
   return arch + "-" + sys;
 }

Referenced by casadi::FmuInternal::compile_fmu(), and casadi::Fmu3::dll_infix().

◆ free_instance()

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

overridevirtual

Implements casadi::FmuInternal.

Definition at line 269 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 58 of file fmu2.cpp.

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

◆ gather_adj()

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

inherited

Definition at line 1520 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();
   // 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;
   }
   // 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 1504 of file fmu.cpp.

                                                {
   // Gather input and output indices
   gather_io(m);
   // Number of outputs
   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;
   }
   // 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 1477 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();
   m->v_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->v_out_.push_back(nan);
       m->omarked_[id] = false;
     }
   }
 }

References casadi::FmuMemory::ibuf_, casadi::FmuMemory::id_in_, casadi::FmuMemory::id_out_, casadi::FmuMemory::imarked_, casadi::nan, casadi::FmuMemory::omarked_, casadi::FmuMemory::v_in_, casadi::FmuMemory::v_out_, 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 1430 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 1232 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 1238 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 586 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_all()

int casadi::FmuInternal::get_all	(	FmuMemory *	m,
		double *	values,
		size_t	n_values
	)		const

inherited

Definition at line 1400 of file fmu.cpp.

                                                                             {
   // Quick return if nothing to get
   if (n_values == 0) return 0;
   // Retrieve from FMU
   m->n_get_all++;
   auto start = std::chrono::high_resolution_clock::now();
   int flag = get_real(m->instance, get_ptr(m->vr_out_), m->vr_out_.size(), values, n_values, m);
   auto stop = std::chrono::high_resolution_clock::now();
   m->t_get_all += std::chrono::duration_cast<std::chrono::microseconds>(
     stop - start).count() / 1e6;
   // Return result of the evaluation
   return flag;
 }

References casadi::get_ptr(), casadi::FmuInternal::get_real(), casadi::FmuMemory::instance, casadi::FmuMemory::n_get_all, casadi::FmuMemory::t_get_all, and casadi::FmuMemory::vr_out_.

Referenced by casadi::FmuInternal::eval(), and casadi::FmuInternal::eval_fd().

◆ get_aux()

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

overridevirtual

Implements casadi::FmuInternal.

Definition at line 489 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 447 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 318 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 380 of file fmu2.cpp.

                                                      {
   // Consistency checks
   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");
   // Quick return if zero dimension
   if (n_in == 0 || n_out == 0) return 0;
   // No directional derivatives w.r.t. automatically added independent variable
   if (has_independent_ && n_in > 0 && *vr_in == static_cast<unsigned int>(-1)) {
     n_in--;
     vr_in++;
     n_seed--;
     seed++;
     // Quick return if now zero dimension
     if (n_in == 0) {
       std::fill(sensitivity, sensitivity + n_sensitivity, 0.0);
       return 0;
     }
   }
   // Retrieve from FMU and return
   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::has_independent_, 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 1176 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 1182 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,
		FmuMemory *	m = `nullptr`
	)		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_ && mem) {
     auto *m = static_cast<Fmu2Memory*>(mem);
     // Dummy call to trigger rtOneStep
     fmi2Status status = get_real_(instance, nullptr, 0, nullptr);
     if (status != fmi2OK) return 1;
     // Dummy call to trigger computation of derivatives, possibly read later via get_real
     status = get_derivatives_(instance, get_ptr(m->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 493 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 696 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 665 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 675 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 82 of file fmu2.cpp.

                                              {
   // Initialize base classes
   FmuInternal::init(dae);
  
   // Add prefix to resource location, cf. FMI specification 2.0.5, section 2.1.5
   resource_loc_ = "file://" + resource_loc_;
  
   // 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::FmuInternal::resource_loc_, 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 41 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());
   // Allocate scratch space for evaluation dance
   if (do_evaluation_dance_) m->derivate_dump.resize(nx_);
   return 0;
 }

References casadi::FmuInternal::do_evaluation_dance_, casadi::FmuInternal::init_mem(), casadi::FmuInternal::nx_, 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 251 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 == nullptr) 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 685 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 386 of file fmu_impl.hpp.

                                                       {
   // Load the function
   signal_t f = li_.get_function(symname);
   // Ensure that it was found
   casadi_assert(f != nullptr, "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 184 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 = nullptr;
   functions_.componentEnvironment = nullptr;
 }

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 219 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 130 of file fmu_impl.hpp.

130 { return iind_.size();}

casadi::FmuInternal::iind_

std::vector< size_t > iind_

Definition: fmu_impl.hpp:350

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 135 of file fmu_impl.hpp.

135 { return oind_.size();}

casadi::FmuInternal::oind_

std::vector< size_t > oind_

Definition: fmu_impl.hpp:350

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

◆ pack_fmu()

std::string casadi::FmuInternal::pack_fmu	(	const Dict &	files,
		const std::string &	path
	)

staticinherited

Definition at line 830 of file fmu.cpp.

                                                                         {
   casadi_assert(Archiver::has_plugin("libzip"),
     "pack_fmu requires libzip. Compile CasADi with WITH_LIBZIP=ON.");
   // The {local_file -> archive path} map is exactly the set of zip entries: no staging
   // directory or copies required.
   std::vector<std::pair<std::string, std::string>> entries;
   for (auto&& kv : files) {
     std::string arc = kv.second.to_string();
     if (arc.substr(0, 2) == "./") arc = arc.substr(2);  // zip entries are root-relative
     entries.push_back({kv.first, arc});
   }
   std::string out = path;
   if (out.size() < 4 || out.substr(out.size() - 4) != ".fmu") out += ".fmu";
   casadi_assert(Archiver::getPlugin("libzip").exposed.pack_entries(entries, out),
     "Packing FMU '" + out + "' failed.");
   // Clean up the loose files
   for (auto&& e : entries) Filesystem::remove(e.first);
   return out;
 }

References casadi::PluginInterface< Archiver >::getPlugin(), casadi::PluginInterface< Archiver >::has_plugin(), casadi::path(), and casadi::Filesystem::remove().

Referenced by casadi::DaeBuilderInternal::pack_fmu().

◆ request()

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

inherited

Definition at line 1363 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 1223 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 1214 of file fmu.cpp.

                                     {
   for (casadi_int i = 0; i < nsens; ++i) {
     m->imarked_.at(*id) = true;
     m->wrt_.at(*id) = wrt_id ? *wrt_id++ : -1;
     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 1468 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 1459 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 278 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 1550 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 594 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 1555 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 1342 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 1192 of file fmu.cpp.

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

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 1204 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_all()

int casadi::FmuInternal::set_all	(	FmuMemory *	m,
		const double *	values,
		size_t	n_values
	)		const

inherited

Definition at line 1372 of file fmu.cpp.

                                                                                   {
   // Quick return if nothing to set
   if (n_values == 0) return 0;
   // Value references
   const unsigned int* vr = get_ptr(m->vr_in_);
   size_t n_vr = m->vr_in_.size();
   // Set time variable, if any
   if (has_independent_ && *vr == independent_vr_) {
     // Update FMU time
     if (set_time(m->instance, *values)) return 1;
     // Skip when setting remaining variables
     vr++;
     n_vr--;
     values++;
     n_values--;
     // Quick return if nothing left to set
     if (n_vr == 0) return 0;
   }
  
   // Set remaining variables
   if (set_real(m->instance, vr, n_vr, values, n_values)) {
     casadi_warning("Setting FMU variables failed");
     return 1;
   }
  
   return 0;
 }

References casadi::get_ptr(), casadi::FmuInternal::has_independent_, casadi::FmuInternal::independent_vr_, casadi::FmuMemory::instance, casadi::FmuInternal::set_real(), casadi::FmuInternal::set_time(), and casadi::FmuMemory::vr_in_.

Referenced by casadi::FmuInternal::eval(), and casadi::FmuInternal::eval_fd().

◆ 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 1437 of file fmu.cpp.

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

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 1449 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 355 of file fmu2.cpp.

                                                  {
   casadi_assert(n_vr == n_values, "Vector-valued variables not supported in FMI 2");
  
   fmi2Status status = set_real_(instance, vr, n_vr, values);
   return status != fmi2OK;
 }

References set_real_.

◆ set_time()

int casadi::Fmu2::set_time	(	void *	instance,
		double	t
	)		const

overridevirtual

Implements casadi::FmuInternal.

Definition at line 350 of file fmu2.cpp.

                                                  {
   fmi2Status status = set_time_(instance, t);
   return status != fmi2OK;
 }

References set_time_.

◆ set_values()

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

overridevirtual

Implements casadi::FmuInternal.

Definition at line 406 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

inlineoverridevirtual

Implements casadi::FmuInternal.

Definition at line 130 of file fmu2.hpp.

130 { return dll_infix(); }

casadi::Fmu2::dll_infix

static std::string dll_infix()

Definition: fmu2.cpp:65

◆ update_discrete_states()

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

overridevirtual

Implements casadi::FmuInternal.

Definition at line 328 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.

                                                                                   {
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     auto* w = weak_ref_.load(std::memory_order_acquire);
     if (!w) {
       auto* nw = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
       GenericWeakRef<Shared, Internal>* expected = nullptr;
       if (weak_ref_.compare_exchange_strong(
             expected, nw, std::memory_order_release, std::memory_order_acquire)) {
         w = nw;
       } else {
         delete nw; // lost the race; another thread published first
         w = expected;
       }
     }
     return w;
 #else
     if (weak_ref_==nullptr) {
       weak_ref_ = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
     }
     return weak_ref_;
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
   }

Member Data Documentation

◆ aux_

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

protectedinherited

Definition at line 317 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 341 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 382 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::FmuInternal(), get_real(), casadi::FmuInternal::init(), init_mem(), 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 323 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 353 of file fmu_impl.hpp.

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

◆ hess_sp_

Sparsity casadi::FmuInternal::hess_sp_

protectedinherited

Definition at line 372 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 350 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 350 of file fmu_impl.hpp.

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

◆ independent_vr_

unsigned int casadi::FmuInternal::independent_vr_

protectedinherited

Definition at line 356 of file fmu_impl.hpp.

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

◆ 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 326 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 329 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 369 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 372 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 347 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 332 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 361 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 361 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 360 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 360 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 310 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 359 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 359 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 335 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 380 of file fmu_impl.hpp.

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

◆ oind_

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

protectedinherited

Definition at line 350 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 350 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 369 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 338 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 338 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 307 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 320 of file fmu_impl.hpp.

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

◆ scheme_

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

protectedinherited

Definition at line 314 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 313 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 313 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_time().

◆ setup_experiment_

fmi2SetupExperimentTYPE* casadi::Fmu2::setup_experiment_

Definition at line 98 of file fmu2.hpp.

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

◆ start_time_

double casadi::FmuInternal::start_time_

protectedinherited

Definition at line 344 of file fmu_impl.hpp.

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

◆ value_in_

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

protectedinherited

Definition at line 366 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 362 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 362 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 363 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::finalize(), casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::gather_io(), casadi::FmuInternal::init(), casadi::FmuInternal::serialize_body(), 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 363 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 374 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 378 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 376 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 375 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 377 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:

Detailed Description

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Member Typedef Documentation

◆ weak_ref_type

Constructor & Destructor Documentation

◆ Fmu2() [1/2]

◆ ~Fmu2()

◆ Fmu2() [2/2]

Member Function Documentation

◆ all_nominal_in()

◆ all_nominal_out()

◆ alloc_mem()

◆ class_name()

◆ compile_fmu()

◆ debug_repr()

◆ desc_in()

◆ deserialize()

◆ destroySingleton()

◆ discrete_states_iter()

◆ disp()

◆ dll_infix()

◆ dll_suffix()

◆ enter_continuous_time_mode()

◆ enter_initialization_mode()

◆ eval()

◆ eval_ad()

◆ eval_adj()

◆ eval_fd()

◆ eval_fwd()

◆ exit_initialization_mode()

◆ finalize()

◆ fmi3_dll_infix()

◆ free_instance()

◆ free_mem()

◆ gather_adj()

◆ gather_fwd()

◆ gather_io()

◆ get()

◆ get_adj() [1/2]

◆ get_adj() [2/2]

◆ get_adjoint_derivative()

◆ get_all()

◆ get_aux()

◆ get_aux_impl()

◆ get_derivatives()

◆ get_directional_derivative()

◆ get_fwd() [1/2]

◆ get_fwd() [2/2]

◆ get_real()

◆ get_stats()

◆ getCount()

◆ hess_sparsity()

◆ index_in()

◆ index_out()

◆ init()

◆ init_mem()

◆ initSingleton()

◆ instantiate()

◆ jac_sparsity()

◆ load_function()

◆ load_functions()

◆ logger()

◆ n_in()

◆ n_out()

◆ pack_fmu()

◆ request()

◆ request_adj() [1/2]

◆ request_adj() [2/2]

◆ request_fwd() [1/2]

◆ request_fwd() [2/2]

◆ reset()

◆ serialize()

◆ serialize_body()

◆ serialize_type()