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

#include <fmu3.hpp>

Detailed Description

Author: Joel Andersson

Date: 2024

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

Definition at line 42 of file fmu3.hpp.

Inheritance diagram for casadi::Fmu3:

[legend]

Collaboration diagram for casadi::Fmu3:

[legend]

Classes
struct	Value

Public Types
using	weak_ref_type = WeakRefInternal

Public Member Functions
	Fmu3 (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)

	~Fmu3 () 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	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 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

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	log_message_callback (fmi3InstanceEnvironment instanceEnvironment, fmi3Status status, fmi3String category, fmi3String message)

static Fmu3 *	deserialize (DeserializingStream &s)

static std::string	dll_suffix ()

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< fmi3ValueReference >	vr_real_

std::vector< fmi3ValueReference >	vr_integer_

std::vector< fmi3ValueReference >	vr_boolean_

std::vector< fmi3ValueReference >	vr_string_

std::vector< fmi3Float64 >	init_real_

std::vector< fmi3Int32 >	init_integer_

std::vector< fmi3Boolean >	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< fmi3ValueReference >	vr_aux_real_

std::vector< fmi3ValueReference >	vr_aux_integer_

std::vector< fmi3ValueReference >	vr_aux_boolean_

std::vector< fmi3ValueReference >	vr_aux_string_

fmi3InstantiateModelExchangeTYPE *	instantiate_model_exchange_

fmi3FreeInstanceTYPE *	free_instance_

fmi3ResetTYPE *	reset_

fmi3EnterInitializationModeTYPE *	enter_initialization_mode_

fmi3ExitInitializationModeTYPE *	exit_initialization_mode_

fmi3EnterContinuousTimeModeTYPE *	enter_continuous_time_mode_

fmi3SetTimeTYPE *	set_time_

fmi3GetFloat64TYPE *	get_float64_

fmi3SetFloat64TYPE *	set_float64_

fmi3GetBooleanTYPE *	get_boolean_

fmi3SetBooleanTYPE *	set_boolean_

fmi3GetInt32TYPE *	get_int32_

fmi3SetInt32TYPE *	set_int32_

fmi3GetStringTYPE *	get_string_

fmi3SetStringTYPE *	set_string_

fmi3GetDirectionalDerivativeTYPE *	get_directional_derivative_

fmi3GetAdjointDerivativeTYPE *	get_adjoint_derivative_

fmi3UpdateDiscreteStatesTYPE *	update_discrete_states_

Value	aux_value_

Protected Member Functions
	Fmu3 (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

◆ Fmu3() [1/2]

casadi::Fmu3::Fmu3	(	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 511 of file fmu3.cpp.

     : FmuInternal(name, scheme_in, scheme_out, scheme, aux) {
   instantiate_model_exchange_ = nullptr;
   free_instance_ = nullptr;
   reset_ = nullptr;
   enter_initialization_mode_ = nullptr;
   exit_initialization_mode_ = nullptr;
   enter_continuous_time_mode_ = nullptr;
   set_time_ = nullptr;
   set_float64_ = nullptr;
   set_boolean_ = nullptr;
   get_float64_ = nullptr;
   get_directional_derivative_ = nullptr;
   get_adjoint_derivative_ = nullptr;
   update_discrete_states_ = nullptr;
 }

References enter_continuous_time_mode_, enter_initialization_mode_, exit_initialization_mode_, free_instance_, get_adjoint_derivative_, get_directional_derivative_, get_float64_, instantiate_model_exchange_, reset_, set_boolean_, set_float64_, set_time_, and update_discrete_states_.

Referenced by deserialize().

◆ ~Fmu3()

casadi::Fmu3::~Fmu3 ( )

override

Definition at line 58 of file fmu3.cpp.

58 {

59 }

◆ Fmu3() [2/2]

casadi::Fmu3::Fmu3 ( DeserializingStream & s )

explicitprotected

Definition at line 539 of file fmu3.cpp.

                                  : FmuInternal(s) {
   instantiate_model_exchange_ = nullptr;
   free_instance_ = nullptr;
   reset_ = nullptr;
   enter_initialization_mode_ = nullptr;
   exit_initialization_mode_ = nullptr;
   enter_continuous_time_mode_ = nullptr;
   set_time_ = nullptr;
   set_float64_ = nullptr;
   set_boolean_ = nullptr;
   get_float64_ = nullptr;
   get_directional_derivative_ = nullptr;
   get_adjoint_derivative_ = nullptr;
   update_discrete_states_ = nullptr;
  
   s.version("Fmu3", 1);
   s.unpack("Fmu3::vr_real", vr_real_);
   s.unpack("Fmu3::vr_integer", vr_integer_);
   s.unpack("Fmu3::vr_boolean", vr_boolean_);
   s.unpack("Fmu3::vr_string", vr_string_);
   s.unpack("Fmu3::init_real", init_real_);
   s.unpack("Fmu3::init_integer", init_integer_);
   s.unpack("Fmu3::init_boolean", init_boolean_);
   s.unpack("Fmu3::init_string", init_string_);
  
   s.unpack("Fmu3::vn_aux_real", vn_aux_real_);
   s.unpack("Fmu3::vn_aux_integer", vn_aux_integer_);
   s.unpack("Fmu3::vn_aux_boolean", vn_aux_boolean_);
   s.unpack("Fmu3::vn_aux_string", vn_aux_string_);
   s.unpack("Fmu3::vr_aux_real", vr_aux_real_);
   s.unpack("Fmu3::vr_aux_integer", vr_aux_integer_);
   s.unpack("Fmu3::vr_aux_boolean", vr_aux_boolean_);
   s.unpack("Fmu3::vr_aux_string", vr_aux_string_);
 }

References enter_continuous_time_mode_, enter_initialization_mode_, exit_initialization_mode_, free_instance_, get_adjoint_derivative_, get_directional_derivative_, get_float64_, init_boolean_, init_integer_, init_real_, init_string_, instantiate_model_exchange_, reset_, set_boolean_, set_float64_, set_time_, casadi::DeserializingStream::unpack(), update_discrete_states_, 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::Fmu3::alloc_mem ( const FmuFunction & f ) const

overridevirtual

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

Implements casadi::FmuInternal.

Definition at line 50 of file fmu3.cpp.

                                                      {
   return new Fmu3Memory(f);
 }

◆ class_name()

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

inlineoverridevirtual

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

Implements casadi::SharedObjectInternal.

Definition at line 55 of file fmu3.hpp.

55 { return "Fmu3";}

◆ compile_fmu()

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

staticinherited

Definition at line 736 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/" + Fmu3::dll_infix() + "/" + name + dll_suffix();
   return ret;
 }

References casadi::Filesystem::copy_file(), dll_infix(), casadi::FmuInternal::dll_suffix(), 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 805 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()

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

static

Definition at line 533 of file fmu3.cpp.

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

References finalize(), and Fmu3().

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 1197 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::Fmu3::dll_infix ( )

static

Definition at line 61 of file fmu3.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().

◆ 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::Fmu3::enter_continuous_time_mode ( void * instance ) const

overridevirtual

Implements casadi::FmuInternal.

Definition at line 295 of file fmu3.cpp.

                                                          {
   auto *c = static_cast<fmi3Instance>(instance);
   fmi3Status status = enter_continuous_time_mode_(c);
   if (status != fmi3OK) {
     casadi_warning("fmi3EnterContinuousTimeMode failed");
     return 1;
   }
   return 0;
 }

References enter_continuous_time_mode_.

◆ enter_initialization_mode()

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

overridevirtual

Implements casadi::FmuInternal.

Definition at line 275 of file fmu3.cpp.

                                                         {
   auto *c = static_cast<fmi3Instance>(instance);
   fmi3Status status = enter_initialization_mode_(c, fmutol_ > 0, fmutol_, 0., fmi3True, 1.);
   if (status != fmi3OK) {
     casadi_warning("fmi3EnterInitializationMode failed: " + str(status));
     return 1;
   }
   return 0;
 }

References enter_initialization_mode_, casadi::FmuInternal::fmutol_, and casadi::str().

◆ eval()

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

inherited

Definition at line 1361 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 863 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
   if (get_directional_derivative(m->instance,
       get_ptr(m->vr_out_), n_unknown,
       get_ptr(m->vr_in_), n_known,
       get_ptr(m->d_in_), n_known,
       get_ptr(m->d_out_), n_unknown)) {
     casadi_warning("FMU directional derivative failed");
     return 1;
   }
   // Collect requested variables
   auto it = m->d_out_.begin();
   for (size_t id : m->id_out_) {
     m->osens_[id] = *it++;
   }
   // Successful return
   return 0;
 }

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

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

◆ eval_adj()

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

inherited

Definition at line 834 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
   if (m->id_out_.size() == 0) {
     // Sensitivities are zero, trivially
     std::fill(m->d_in_.begin(), m->d_in_.end(), 0);
   } else {
     // Evaluate adjoint derivatives
     if (get_adjoint_derivative(m->instance,
         get_ptr(m->vr_out_), m->id_out_.size(),
         get_ptr(m->vr_in_), m->id_in_.size(),
         get_ptr(m->d_out_), m->id_out_.size(),
         get_ptr(m->d_in_), m->id_in_.size())) {
       casadi_warning("FMU adjoint derivative failed");
       return 1;
     }
   }
   // Collect requested variables
   auto it = m->d_in_.begin();
   for (size_t id : m->id_in_) {
     m->isens_[id] = *it++;
   }
   // Successful return
   return 0;
 }

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

◆ eval_fd()

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

inherited

Definition at line 897 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_[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 818 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::Fmu3::exit_initialization_mode ( void * instance ) const

overridevirtual

Implements casadi::FmuInternal.

Definition at line 285 of file fmu3.cpp.

                                                        {
   auto *c = static_cast<fmi3Instance>(instance);
   fmi3Status status = exit_initialization_mode_(c);
   if (status != fmi3OK) {
     casadi_warning("fmi3ExitInitializationMode failed");
     return 1;
   }
   return 0;
 }

References exit_initialization_mode_.

◆ finalize()

void casadi::Fmu3::finalize ( )

overridevirtual

Allocate numerical values for initial auxilliary variables

Reimplemented from casadi::FmuInternal.

Definition at line 194 of file fmu3.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::Fmu3::Value::v_boolean, casadi::Fmu3::Value::v_integer, casadi::Fmu3::Value::v_real, casadi::Fmu3::Value::v_string, vn_aux_boolean_, vn_aux_integer_, vn_aux_real_, and vn_aux_string_.

Referenced by deserialize().

◆ free_instance()

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

overridevirtual

Implements casadi::FmuInternal.

Definition at line 256 of file fmu3.cpp.

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

References free_instance_.

◆ free_mem()

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

overridevirtual

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

Implements casadi::FmuInternal.

Definition at line 54 of file fmu3.cpp.

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

◆ gather_adj()

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

inherited

Definition at line 1467 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 1451 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 1424 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 1377 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 1181 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 1187 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::Fmu3::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

overridevirtual

Reimplemented from casadi::FmuInternal.

Definition at line 367 of file fmu3.cpp.

                                                      {
   fmi3Status status = get_adjoint_derivative_(instance, vr_out, n_out, vr_in, n_in,
     seed, n_seed, sensitivity, n_sensitivity);
   return status != fmi3OK;
 }

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

◆ get_all()

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

inherited

Definition at line 1349 of file fmu.cpp.

                                                                             {
   // Quick return if nothing to get
   if (n_values == 0) return 0;
   // Retrieve from FMU
   if (get_real(m->instance, get_ptr(m->vr_out_), m->vr_out_.size(), values, n_values, m)) {
     casadi_warning("Evaluation failed");
     return 1;
   }
   // Successful return
   return 0;
 }

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

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

◆ get_aux()

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

overridevirtual

Implements casadi::FmuInternal.

Definition at line 420 of file fmu3.cpp.

                                 {
   return get_aux_impl(instance, aux_value_);
 }

References aux_value_, and get_aux_impl().

◆ get_aux_impl()

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

Definition at line 424 of file fmu3.cpp.

                                                              {
   auto *c = static_cast<fmi3Instance>(instance);
   // Get real auxilliary variables
   if (!vr_aux_real_.empty()) {
     fmi3Status status = get_float64_(c, get_ptr(vr_aux_real_), vr_aux_real_.size(),
       get_ptr(aux_value.v_real), aux_value.v_real.size());
     if (status != fmi3OK) {
       casadi_warning("fmi3GetFloat64 failed");
       return 1;
     }
   }
  
   // Get integer/enum auxilliary variables
   if (!vr_aux_integer_.empty()) {
     fmi3Status status = get_int32_(c, get_ptr(vr_aux_integer_), vr_aux_integer_.size(),
       get_ptr(aux_value.v_integer), aux_value.v_integer.size());
     if (status != fmi3OK) {
       casadi_warning("fmi3GetInt32 failed");
       return 1;
     }
   }
  
   // Get boolean auxilliary variables
   casadi_assert(vr_aux_boolean_.size() == aux_value.v_boolean.size(),
     "Vector valued variables not supported");
   for (size_t k = 0; k < vr_aux_boolean_.size(); ++k) {
     fmi3Boolean value;
     fmi3Status status = get_boolean_(c, &vr_aux_boolean_[k], 1, &value, 1);
     if (status != fmi3OK) {
       casadi_warning("fmi3GetBoolean failed for value reference " + str(vr_aux_boolean_[k]));
       return 1;
     }
     aux_value.v_boolean[k] = value;
   }
  
   // Get string auxilliary variables
   for (size_t k = 0; k < vr_aux_string_.size(); ++k) {
     fmi3ValueReference vr = vr_aux_string_[k];
     fmi3String value = aux_value.v_string.at(k).c_str();
     fmi3Status status = set_string_(c, &vr, 1, &value, 1);
     if (status != fmi3OK) {
       casadi_error("fmi3GetString failed for value reference " + str(vr));
     }
   }
   // Successful return
   return 0;
 }

References get_boolean_, get_float64_, get_int32_, casadi::get_ptr(), set_string_, casadi::str(), casadi::Fmu3::Value::v_boolean, casadi::Fmu3::Value::v_integer, casadi::Fmu3::Value::v_real, casadi::Fmu3::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::Fmu3::get_derivatives	(	void *	instance,
		double *	derivatives,
		size_t	nx
	)		const

overridevirtual

Implements casadi::FmuInternal.

Definition at line 325 of file fmu3.cpp.

                                                                               {
   return 0;
 }

◆ get_directional_derivative()

int casadi::Fmu3::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 359 of file fmu3.cpp.

                                                      {
   fmi3Status status = get_directional_derivative_(instance, vr_out, n_out, vr_in, n_in,
     seed, n_seed, sensitivity, n_sensitivity);
   return status != fmi3OK;
 }

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

◆ get_fwd() [1/2]

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

inherited

Definition at line 1125 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 1131 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::Fmu3::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 352 of file fmu3.cpp.

                                                          {
   (void)m;  // unused
   fmi3Status status = get_float64_(instance, vr, n_vr, values, n_values);
   return status != fmi3OK;
 }

References get_float64_.

◆ get_stats()

void casadi::Fmu3::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_2bc

Implements casadi::FmuInternal.

Definition at line 472 of file fmu3.cpp.

                                                                       {
   Value& v = static_cast<Fmu3Memory*>(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::Fmu3::Value::v_boolean, casadi::Fmu3::Value::v_integer, casadi::Fmu3::Value::v_real, casadi::Fmu3::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::Fmu3::init ( const DaeBuilderInternal * dae )

overridevirtual

Reimplemented from casadi::FmuInternal.

Definition at line 106 of file fmu3.cpp.

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

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

◆ init_mem()

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

overridevirtual

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

Allocate numerical values for initial auxilliary variables

Reimplemented from casadi::FmuInternal.

Definition at line 39 of file fmu3.cpp.

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

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

◆ initSingleton()

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

inlineprotectedinherited

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

Definition at line 71 of file generic_shared_internal.hpp.

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

◆ instantiate()

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

overridevirtual

Implements casadi::FmuInternal.

Definition at line 243 of file fmu3.cpp.

                               {
   // Instantiate FMU
   fmi3String instanceName = instance_name_.c_str();
   fmi3String instantiationToken = instantiation_token_.c_str();
   fmi3String resourcePath = resource_loc_.c_str();
   fmi3Boolean visible = fmi3False;
   fmi3InstanceEnvironment instanceEnvironment = nullptr;
   fmi3Instance c = instantiate_model_exchange_(instanceName, instantiationToken, resourcePath,
     visible, logging_on_, instanceEnvironment, log_message_callback);
   if (c == nullptr) casadi_error("fmi3Instantiate failed");
   return c;
 }

References casadi::FmuInternal::instance_name_, instantiate_model_exchange_, casadi::FmuInternal::instantiation_token_, log_message_callback(), casadi::FmuInternal::logging_on_, and casadi::FmuInternal::resource_loc_.

◆ 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 381 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::Fmu3::load_functions ( )

overridevirtual

Implements casadi::FmuInternal.

Definition at line 205 of file fmu3.cpp.

                           {
   instantiate_model_exchange_ = load_function<fmi3InstantiateModelExchangeTYPE>(
     "fmi3InstantiateModelExchange");
   free_instance_ = load_function<fmi3FreeInstanceTYPE>("fmi3FreeInstance");
   reset_ = load_function<fmi3ResetTYPE>("fmi3Reset");
   enter_initialization_mode_ = load_function<fmi3EnterInitializationModeTYPE>(
     "fmi3EnterInitializationMode");
   exit_initialization_mode_ = load_function<fmi3ExitInitializationModeTYPE>(
     "fmi3ExitInitializationMode");
   enter_continuous_time_mode_ = load_function<fmi3EnterContinuousTimeModeTYPE>(
     "fmi3EnterContinuousTimeMode");
   set_time_ = load_function<fmi3SetTimeTYPE>("fmi3SetTime");
   get_float64_ = load_function<fmi3GetFloat64TYPE>("fmi3GetFloat64");
   set_float64_ = load_function<fmi3SetFloat64TYPE>("fmi3SetFloat64");
   get_int32_ = load_function<fmi3GetInt32TYPE>("fmi3GetInt32");
   set_int32_ = load_function<fmi3SetInt32TYPE>("fmi3SetInt32");
   get_boolean_ = load_function<fmi3GetBooleanTYPE>("fmi3GetBoolean");
   set_boolean_ = load_function<fmi3SetBooleanTYPE>("fmi3SetBoolean");
   get_string_ = load_function<fmi3GetStringTYPE>("fmi3GetString");
   set_string_ = load_function<fmi3SetStringTYPE>("fmi3SetString");
   if (provides_directional_derivatives_) {
     get_directional_derivative_ =
       load_function<fmi3GetDirectionalDerivativeTYPE>("fmi3GetDirectionalDerivative");
   }
   if (provides_adjoint_derivatives_) {
     get_adjoint_derivative_ =
       load_function<fmi3GetAdjointDerivativeTYPE>("fmi3GetAdjointDerivative");
   }
   update_discrete_states_ =
     load_function<fmi3UpdateDiscreteStatesTYPE>("fmi3UpdateDiscreteStates");
 }

References enter_continuous_time_mode_, enter_initialization_mode_, exit_initialization_mode_, free_instance_, get_adjoint_derivative_, get_boolean_, get_directional_derivative_, get_float64_, get_int32_, get_string_, instantiate_model_exchange_, casadi::FmuInternal::provides_adjoint_derivatives_, casadi::FmuInternal::provides_directional_derivatives_, reset_, set_boolean_, set_float64_, set_int32_, set_string_, set_time_, and update_discrete_states_.

◆ log_message_callback()

void casadi::Fmu3::log_message_callback	(	fmi3InstanceEnvironment	instanceEnvironment,
		fmi3Status	status,
		fmi3String	category,
		fmi3String	message
	)

static

Definition at line 237 of file fmu3.cpp.

                                                                 {
   // Print message content
   uout() << "[" << category << "] " << message << std::endl;
 }

References casadi::uout().

Referenced by instantiate().

◆ 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:345

Referenced by get_adjoint_derivative(), casadi::Fmu2::get_directional_derivative(), and 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:345

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

◆ pack_fmu()

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

staticinherited

Definition at line 785 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 1312 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 1172 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 1163 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 1415 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 1406 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::Fmu3::reset ( void * instance )

Definition at line 265 of file fmu3.cpp.

                               {
   auto *c = static_cast<fmi3Instance>(instance);
   fmi3Status status = reset_(c);
   if (status != fmi3OK) {
     casadi_warning("fmi3Reset failed");
     return 1;
   }
   return 0;
 }

References reset_.

◆ serialize()

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

inherited

Definition at line 1497 of file fmu.cpp.

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

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

◆ serialize_body()

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

overridevirtual

Reimplemented from casadi::FmuInternal.

Definition at line 575 of file fmu3.cpp.

                                                     {
   FmuInternal::serialize_body(s);
  
   s.version("Fmu3", 1);
   s.pack("Fmu3::vr_real", vr_real_);
   s.pack("Fmu3::vr_integer", vr_integer_);
   s.pack("Fmu3::vr_boolean", vr_boolean_);
   s.pack("Fmu3::vr_string", vr_string_);
   s.pack("Fmu3::init_real", init_real_);
   s.pack("Fmu3::init_integer", init_integer_);
   s.pack("Fmu3::init_boolean", init_boolean_);
   s.pack("Fmu3::init_string", init_string_);
  
   s.pack("Fmu3::vn_aux_real", vn_aux_real_);
   s.pack("Fmu3::vn_aux_integer", vn_aux_integer_);
   s.pack("Fmu3::vn_aux_boolean", vn_aux_boolean_);
   s.pack("Fmu3::vn_aux_string", vn_aux_string_);
   s.pack("Fmu3::vr_aux_real", vr_aux_real_);
   s.pack("Fmu3::vr_aux_integer", vr_aux_integer_);
   s.pack("Fmu3::vr_aux_boolean", vr_aux_boolean_);
   s.pack("Fmu3::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 1502 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 1291 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 1141 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 1153 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 1321 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 1384 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 1396 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::Fmu3::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 334 of file fmu3.cpp.

                                                  {
   // Set time variable, if any
   if (has_independent_ && n_vr > 0 && *vr == vr_in_[0]) {
     // Update FMU time
     fmi3Status status = set_time_(instance, *values);
     if (status != fmi3OK) return 1;
     // Skip when setting remaining variables
     vr++;
     n_vr--;
     values++;
     n_values--;
   }
   // Set remaining variables
   fmi3Status status = set_float64_(instance, vr, n_vr, values, n_values);
   return status != fmi3OK;
 }

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

◆ set_time()

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

overridevirtual

Implements casadi::FmuInternal.

Definition at line 329 of file fmu3.cpp.

                                                  {
   fmi3Status status = set_time_(instance, t);
   return status != fmi3OK;
 }

References set_time_.

◆ set_values()

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

overridevirtual

Implements casadi::FmuInternal.

Definition at line 375 of file fmu3.cpp.

                                          {
   auto *c = static_cast<fmi3Instance>(instance);
   // Pass real values before initialization
   casadi_assert(vr_real_.size() == init_real_.size(), "Vector valued variables not supported");
   for (size_t k = 0; k < vr_real_.size(); ++k) {
     fmi3Status status = set_float64_(c, &vr_real_[k], 1, &init_real_[k], 1);
     if (status != fmi3OK) {
       casadi_warning("fmi3SetFloat64 failed for value reference " + str(vr_real_[k]));
       return 1;
     }
   }
  
   // Pass integer values before initialization (also enums)
   if (!vr_integer_.empty()) {
     fmi3Status status = set_int32_(c, get_ptr(vr_integer_), vr_integer_.size(),
       get_ptr(init_integer_), init_integer_.size());
     if (status != fmi3OK) {
       casadi_warning("fmi3SetInt32 failed");
       return 1;
     }
   }
   // Pass boolean values before initialization
   if (!vr_boolean_.empty()) {
     casadi_error("Broken");
     // nullptr -> get_ptr(init_boolean_)
     fmi3Status status = set_boolean_(c, get_ptr(vr_boolean_), vr_boolean_.size(),
       nullptr, init_boolean_.size());
     if (status != fmi3OK) {
       casadi_warning("fmi3SetBoolean failed");
       return 1;
     }
   }
   // Pass string values before initialization
   for (size_t k = 0; k < vr_string_.size(); ++k) {
     fmi3ValueReference vr = vr_string_[k];
     fmi3String value = init_string_[k].c_str();
     fmi3Status status = set_string_(c, &vr, 1, &value, 1);
     if (status != fmi3OK) {
       casadi_error("fmi3SetString 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_float64_, set_int32_, 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::Fmu3::system_infix ( ) const

inlineoverridevirtual

Implements casadi::FmuInternal.

Definition at line 126 of file fmu3.hpp.

126 { return dll_infix(); }

◆ update_discrete_states()

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

overridevirtual

Implements casadi::FmuInternal.

Definition at line 305 of file fmu3.cpp.

                                                                             {
   auto *c = static_cast<fmi3Instance>(instance);
   // Return arguments in FMI types
   fmi3Boolean discreteStatesNeedUpdate, terminateSimulation, nominalsOfContinuousStatesChanged,
     valuesOfContinuousStatesChanged, nextEventTimeDefined;
   fmi3Float64 nextEventTime;
   // Call FMU
   fmi3Status status = update_discrete_states_(c, &discreteStatesNeedUpdate, &terminateSimulation,
     &nominalsOfContinuousStatesChanged, &valuesOfContinuousStatesChanged, &nextEventTimeDefined,
     &nextEventTime);
   // Pass to event iteration memory
   eventmem->discrete_states_need_update = discreteStatesNeedUpdate;
   eventmem->terminate_simulation = terminateSimulation;
   eventmem->nominals_of_continuous_states_changed = nominalsOfContinuousStatesChanged;
   eventmem->values_of_continuous_states_changed = valuesOfContinuousStatesChanged;
   eventmem->next_event_time_defined = nextEventTimeDefined;
   eventmem->next_event_time = nextEventTime;
   return status != fmi3OK;
 }

References casadi::EventMemory::discrete_states_need_update, casadi::EventMemory::next_event_time, casadi::EventMemory::next_event_time_defined, casadi::EventMemory::nominals_of_continuous_states_changed, casadi::EventMemory::terminate_simulation, update_discrete_states_, 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 312 of file fmu_impl.hpp.

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

◆ aux_value_

Value casadi::Fmu3::aux_value_

Definition at line 122 of file fmu3.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 336 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 377 of file fmu_impl.hpp.

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

◆ enter_continuous_time_mode_

fmi3EnterContinuousTimeModeTYPE* casadi::Fmu3::enter_continuous_time_mode_

Definition at line 100 of file fmu3.hpp.

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

◆ enter_initialization_mode_

fmi3EnterInitializationModeTYPE* casadi::Fmu3::enter_initialization_mode_

Definition at line 98 of file fmu3.hpp.

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

◆ exit_initialization_mode_

fmi3ExitInitializationModeTYPE* casadi::Fmu3::exit_initialization_mode_

Definition at line 99 of file fmu3.hpp.

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

◆ fmutol_

double casadi::FmuInternal::fmutol_

protectedinherited

Definition at line 318 of file fmu_impl.hpp.

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

◆ free_instance_

fmi3FreeInstanceTYPE* casadi::Fmu3::free_instance_

Definition at line 96 of file fmu3.hpp.

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

◆ get_adjoint_derivative_

fmi3GetAdjointDerivativeTYPE* casadi::Fmu3::get_adjoint_derivative_

Definition at line 111 of file fmu3.hpp.

Referenced by Fmu3(), get_adjoint_derivative(), and load_functions().

◆ get_boolean_

fmi3GetBooleanTYPE* casadi::Fmu3::get_boolean_

Definition at line 104 of file fmu3.hpp.

Referenced by get_aux_impl(), and load_functions().

◆ get_directional_derivative_

fmi3GetDirectionalDerivativeTYPE* casadi::Fmu3::get_directional_derivative_

Definition at line 110 of file fmu3.hpp.

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

◆ get_float64_

fmi3GetFloat64TYPE* casadi::Fmu3::get_float64_

Definition at line 102 of file fmu3.hpp.

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

◆ get_int32_

fmi3GetInt32TYPE* casadi::Fmu3::get_int32_

Definition at line 106 of file fmu3.hpp.

Referenced by get_aux_impl(), and load_functions().

◆ get_string_

fmi3GetStringTYPE* casadi::Fmu3::get_string_

Definition at line 108 of file fmu3.hpp.

Referenced by load_functions().

◆ has_independent_

bool casadi::FmuInternal::has_independent_

protectedinherited

Definition at line 348 of file fmu_impl.hpp.

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

◆ hess_sp_

Sparsity casadi::FmuInternal::hess_sp_

protectedinherited

Definition at line 367 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 345 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 345 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 351 of file fmu_impl.hpp.

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

◆ init_boolean_

std::vector<fmi3Boolean> casadi::Fmu3::init_boolean_

Definition at line 85 of file fmu3.hpp.

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

◆ init_integer_

std::vector<fmi3Int32> casadi::Fmu3::init_integer_

Definition at line 84 of file fmu3.hpp.

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

◆ init_real_

std::vector<fmi3Float64> casadi::Fmu3::init_real_

Definition at line 83 of file fmu3.hpp.

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

◆ init_string_

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

Definition at line 86 of file fmu3.hpp.

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

◆ instance_name_

std::string casadi::FmuInternal::instance_name_

protectedinherited

Definition at line 321 of file fmu_impl.hpp.

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

◆ instantiate_model_exchange_

fmi3InstantiateModelExchangeTYPE* casadi::Fmu3::instantiate_model_exchange_

Definition at line 95 of file fmu3.hpp.

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

◆ instantiation_token_

std::string casadi::FmuInternal::instantiation_token_

protectedinherited

Definition at line 324 of file fmu_impl.hpp.

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

◆ ired_

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

protectedinherited

Definition at line 364 of file fmu_impl.hpp.

Referenced by casadi::FmuInternal::all_nominal_in(), casadi::FmuInternal::FmuInternal(), casadi::FmuInternal::get_adj(), casadi::Fmu2::get_stats(), 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 367 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 342 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 327 of file fmu_impl.hpp.

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

◆ max_in_

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

protectedinherited

Definition at line 356 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 356 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 355 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 355 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 305 of file fmu_impl.hpp.

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

◆ nominal_in_

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

protectedinherited

Definition at line 354 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 354 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 330 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 375 of file fmu_impl.hpp.

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

◆ oind_

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

protectedinherited

Definition at line 345 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 345 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 364 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 333 of file fmu_impl.hpp.

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

◆ provides_directional_derivatives_

bool casadi::FmuInternal::provides_directional_derivatives_

protectedinherited

Definition at line 333 of file fmu_impl.hpp.

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

◆ reset_

fmi3ResetTYPE* casadi::Fmu3::reset_

Definition at line 97 of file fmu3.hpp.

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

◆ resource_

Resource casadi::FmuInternal::resource_

protectedinherited

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

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

◆ scheme_

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

protectedinherited

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

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

◆ set_boolean_

fmi3SetBooleanTYPE* casadi::Fmu3::set_boolean_

Definition at line 105 of file fmu3.hpp.

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

◆ set_float64_

fmi3SetFloat64TYPE* casadi::Fmu3::set_float64_

Definition at line 103 of file fmu3.hpp.

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

◆ set_int32_

fmi3SetInt32TYPE* casadi::Fmu3::set_int32_

Definition at line 107 of file fmu3.hpp.

Referenced by load_functions(), and set_values().

◆ set_string_

fmi3SetStringTYPE* casadi::Fmu3::set_string_

Definition at line 109 of file fmu3.hpp.

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

◆ set_time_

fmi3SetTimeTYPE* casadi::Fmu3::set_time_

Definition at line 101 of file fmu3.hpp.

Referenced by Fmu3(), load_functions(), set_real(), and set_time().

◆ start_time_

double casadi::FmuInternal::start_time_

protectedinherited

Definition at line 339 of file fmu_impl.hpp.

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

◆ update_discrete_states_

fmi3UpdateDiscreteStatesTYPE* casadi::Fmu3::update_discrete_states_

Definition at line 112 of file fmu3.hpp.

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

◆ value_in_

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

protectedinherited

Definition at line 361 of file fmu_impl.hpp.

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

◆ vn_aux_boolean_

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

Definition at line 89 of file fmu3.hpp.

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

◆ vn_aux_integer_

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

Definition at line 89 of file fmu3.hpp.

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

◆ vn_aux_real_

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

Definition at line 89 of file fmu3.hpp.

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

◆ vn_aux_string_

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

Definition at line 89 of file fmu3.hpp.

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

◆ vn_in_

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

protectedinherited

Definition at line 357 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 357 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<fmi3ValueReference> casadi::Fmu3::vr_aux_boolean_

Definition at line 90 of file fmu3.hpp.

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

◆ vr_aux_integer_

std::vector<fmi3ValueReference> casadi::Fmu3::vr_aux_integer_

Definition at line 90 of file fmu3.hpp.

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

◆ vr_aux_real_

std::vector<fmi3ValueReference> casadi::Fmu3::vr_aux_real_

Definition at line 90 of file fmu3.hpp.

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

◆ vr_aux_string_

std::vector<fmi3ValueReference> casadi::Fmu3::vr_aux_string_

Definition at line 90 of file fmu3.hpp.

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

◆ vr_boolean_

std::vector<fmi3ValueReference> casadi::Fmu3::vr_boolean_

Definition at line 82 of file fmu3.hpp.

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

◆ vr_in_

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

protectedinherited

Definition at line 358 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 set_real().

◆ vr_integer_

std::vector<fmi3ValueReference> casadi::Fmu3::vr_integer_

Definition at line 82 of file fmu3.hpp.

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

◆ vr_out_

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

protectedinherited

Definition at line 358 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<fmi3ValueReference> casadi::Fmu3::vr_real_

Definition at line 82 of file fmu3.hpp.

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

◆ vr_string_

std::vector<fmi3ValueReference> casadi::Fmu3::vr_string_

Definition at line 82 of file fmu3.hpp.

Referenced by Fmu3(), 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 369 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 373 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 371 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 370 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 372 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

◆ Fmu3() [1/2]

◆ ~Fmu3()

◆ Fmu3() [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()

◆ 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()

◆ log_message_callback()

◆ 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()

◆ set()