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

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	set_real (void instance, const unsigned int vr, size_t n_vr, const double *values, size_t n_values) const override

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

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

int	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

void	get_stats (FmuMemory m, Dict stats, const std::vector< std::string > &name_in, const InputStruct *in) const override
	Get stats. More...

void	finalize ()

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

int	init_mem (FmuMemory *m) const
	Initalize memory block. More...

void	set (FmuMemory m, size_t ind, const double value) const

void	request (FmuMemory *m, size_t ind) const

int	eval (FmuMemory *m) const

void	get (FmuMemory m, size_t id, double value) const

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

void	set_fwd (FmuMemory m, size_t ind, const double v) const

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

void	request_fwd (FmuMemory *m, casadi_int ind) const

int	eval_fwd (FmuMemory *m, bool independent_seeds) const

int	eval_ad (FmuMemory *m) const

int	eval_fd (FmuMemory *m, bool independent_seeds) const

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

void	get_fwd (FmuMemory m, size_t ind, double v) const

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

void	set_adj (FmuMemory m, size_t ind, const double v) const

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

void	request_adj (FmuMemory *m, casadi_int ind) const

int	eval_adj (FmuMemory *m) const

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

void	get_adj (FmuMemory m, size_t ind, double v) const

void	gather_fwd (FmuMemory *m) const

void	gather_adj (FmuMemory *m) const

void	gather_io (FmuMemory *m) const

void	serialize (SerializingStream &s) const

virtual void	serialize_type (SerializingStream &s) const

virtual void	serialize_body (SerializingStream &s) const

casadi_int	getCount () const
	Get the reference count. More...

std::string	debug_repr (const SharedObjectInternal *) const

GenericWeakRef< SharedObject, SharedObjectInternal > *	weak ()
	Get a weak reference to the object. More...


std::vector< double >	all_nominal_in (size_t i) const
	Retreive nominal values. More...

std::vector< double >	all_nominal_out (size_t i) const
	Retreive nominal values. More...

Static Public Member Functions
static void	log_message_callback (fmi3InstanceEnvironment instanceEnvironment, fmi3Status status, fmi3String category, fmi3String message)

static std::string	dll_suffix ()

static FmuInternal *	deserialize (DeserializingStream &s)

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
void	initSingleton ()

void	destroySingleton ()

B	shared_from_this ()
	Get a shared object from the current internal object. More...

const B	shared_from_this () const
	Get a shared object from the current internal object. More...

Protected Attributes
Resource	resource_

std::string	name_
	Instance name. More...

std::vector< std::string >	scheme_in_

std::vector< std::string >	scheme_out_

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

std::vector< std::string >	aux_

std::string	resource_loc_

double	fmutol_

std::string	instance_name_

std::string	instantiation_token_

bool	logging_on_

casadi_int	number_of_event_indicators_

bool	provides_directional_derivatives_

bool	provides_adjoint_derivatives_

bool	can_be_instantiated_only_once_per_process_

Importer	li_
	DLL. More...

std::vector< size_t >	iind_

std::vector< size_t >	iind_map_

std::vector< size_t >	oind_

std::vector< size_t >	oind_map_

bool	has_independent_

std::vector< double >	nominal_in_

std::vector< double >	nominal_out_

std::vector< double >	min_in_

std::vector< double >	min_out_

std::vector< double >	max_in_

std::vector< double >	max_out_

std::vector< std::string >	vn_in_

std::vector< std::string >	vn_out_

std::vector< unsigned int >	vr_in_

std::vector< unsigned int >	vr_out_

std::vector< double >	value_in_

std::vector< std::vector< size_t > >	ired_

std::vector< std::vector< size_t > >	ored_

Sparsity	jac_sp_

Sparsity	hess_sp_

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

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 457 of file fmu3.cpp.

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

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_.

◆ ~Fmu3()

casadi::Fmu3::~Fmu3 ( )

override

Definition at line 32 of file fmu3.cpp.

32 {

33 }

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 665 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 673 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_.

◆ 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";}

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

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

staticinherited

Definition at line 1417 of file fmu.cpp.

                                                             {
   std::string class_name;
   s.unpack("FmuInternal::type", class_name);
   if (class_name=="Fmu2") {
 #ifdef WITH_FMI2
     return Fmu2::deserialize(s);
 #else
     casadi_error("CasADi was not compiled with WITH_FMI2=ON.");
 #endif // WITH_FMI2
   } else if (class_name=="Fmu3") {
 #ifdef WITH_FMI3
     casadi_error("Not implemented");
 #else
     casadi_error("CasADi was not compiled with WITH_FMI2=ON.");
 #endif // WITH_FMI3
   } else {
     casadi_error("Cannot deserialize type '" + class_name + "'");
   }
 }

References casadi::SharedObjectInternal::class_name(), casadi::Fmu2::deserialize(), and casadi::DeserializingStream::unpack().

Referenced by casadi::Fmu::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 1075 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)
       casadi_warning("Discrete state update not implemented");
     if (eventmem.terminate_simulation)
       casadi_warning("Terminate solution not implemented");
     if (eventmem.nominals_of_continuous_states_changed)
       casadi_warning("Update of nominals of states not implemented");
     if (eventmem.values_of_continuous_states_changed)
       casadi_warning("Update of values of continuous states not implemented");
     if (eventmem.next_event_time_defined)
       casadi_warning("Ignoring next time defined: " + std::to_string(eventmem.next_event_time));
     // 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, casadi::EventMemory::next_event_time_defined, casadi::EventMemory::nominals_of_continuous_states_changed, casadi::EventMemory::terminate_simulation, casadi::FmuInternal::update_discrete_states(), and casadi::EventMemory::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 609 of file fmu.cpp.

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

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

◆ dll_suffix()

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

staticinherited

Definition at line 681 of file fmu.cpp.

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

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

◆ enter_continuous_time_mode()

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

overridevirtual

Implements casadi::FmuInternal.

Definition at line 258 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 238 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 1179 of file fmu.cpp.

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

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

◆ eval_ad()

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

inherited

Definition at line 746 of file fmu.cpp.

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

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

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

◆ eval_adj()

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

inherited

Definition at line 723 of file fmu.cpp.

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

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

◆ eval_fd()

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

inherited

Definition at line 775 of file fmu.cpp.

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

inherited

Definition at line 569 of file fmu.cpp.

                            {
   // Load DLL
   std::string instance_name_no_dot = instance_name_;
   std::replace(instance_name_no_dot.begin(), instance_name_no_dot.end(), '.', '_');
   std::string dll_path = resource_.path() + "/binaries/" + system_infix()
     + "/" + instance_name_no_dot + dll_suffix();
   li_ = Importer(dll_path, "dll");
  
   // Get FMI C functions
   load_functions();
  
   // Path to resource directory
   if (Filesystem::is_enabled()) {
     resource_loc_ = "file://" + Filesystem::absolute(resource_.path()) + "/resources";
   } else {
     resource_loc_ = "file://" + resource_.path();
   }
  
   // Create a temporary instance
   void* c = instantiate();
   // Set all values
   if (set_values(c)) {
     casadi_error("FmuInternal::set_values failed");
   }
   // Initialization mode begins
   if (enter_initialization_mode(c)) {
     casadi_error("FmuInternal::enter_initialization_mode failed");
   }
   // Get input values
   if (get_real(c, get_ptr(vr_in_), vr_in_.size(), get_ptr(value_in_), value_in_.size())) {
     casadi_error("FmuInternal::get_in failed");
   }
   // Get auxilliary variables
   if (get_aux(c)) {
     casadi_error("FmuInternal::get_aux failed");
   }
   // Free memory
   free_instance(c);
 }

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

◆ free_instance()

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

overridevirtual

Implements casadi::FmuInternal.

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

◆ gather_adj()

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

inherited

Definition at line 1295 of file fmu.cpp.

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

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

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

◆ gather_fwd()

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

inherited

Definition at line 1276 of file fmu.cpp.

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

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

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

◆ gather_io()

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

inherited

Definition at line 1251 of file fmu.cpp.

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

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

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

◆ get()

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

inherited

Definition at line 1207 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 1059 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 1065 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 320 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_aux()

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

overridevirtual

Implements casadi::FmuInternal.

Definition at line 372 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), vr_aux_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), vr_aux_integer_.size());
     if (status != fmi3OK) {
       casadi_warning("fmi3GetInt32 failed");
       return 1;
     }
   }
   // Get boolean auxilliary variables
   if (!vr_aux_boolean_.empty()) {
     casadi_error("Broken");
     // nullptr -> get_ptr(v->v_boolean)
     fmi3Status status = get_boolean_(c, get_ptr(vr_aux_boolean_), vr_aux_boolean_.size(),
       nullptr, vr_aux_boolean_.size());
     if (status != fmi3OK) {
       casadi_warning("fmi3GetBoolean failed");
       return 1;
     }
   }
   // 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 aux_value_, get_boolean_, get_float64_, get_int32_, casadi::get_ptr(), set_string_, casadi::str(), 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_.

◆ 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 312 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 1006 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 1012 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
	)		const

overridevirtual

Implements casadi::FmuInternal.

Definition at line 306 of file fmu3.cpp.

                                            {
   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 416 of file fmu3.cpp.

                                                                       {
   // To do: Use auxillary variables from last evaluation
   (void)m;  // unused
   // Auxilliary values to be copied
   const Value& v = aux_value_;
   // 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 aux_value_, 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 654 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 623 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 633 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

Allocate numerical values for initial auxilliary variables

Reimplemented from casadi::FmuInternal.

Definition at line 74 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));
     }
   }
  
   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());
 }

◆ init_mem()

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

inherited

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

Definition at line 1105 of file fmu.cpp.

                                             {
   // Ensure not already instantiated
   casadi_assert(m->instance == 0, "Already instantiated");
   // Create instance
   m->instance = instantiate();
   // Set all values
   if (set_values(m->instance)) {
     casadi_warning("FmuInternal::set_values failed");
     return 1;
   }
   // Initialization mode begins
   if (enter_initialization_mode(m->instance)) return 1;
   // Initialization mode ends
   if (exit_initialization_mode(m->instance)) return 1;
   // Initial event iteration
   if (discrete_states_iter(m->instance)) return 1;
   // Continuous-time mode
   if (enter_continuous_time_mode(m->instance)) return 1;
   // Allocate/reset input buffer
   m->ibuf_.resize(iind_.size());
   std::fill(m->ibuf_.begin(), m->ibuf_.end(), casadi::nan);
   // Allocate/reset output buffer
   m->obuf_.resize(oind_.size());
   std::fill(m->obuf_.begin(), m->obuf_.end(), casadi::nan);
   // Maximum input or output
   size_t max_io = std::max(iind_.size(), oind_.size());
   // Allocate/reset seeds
   m->isens_.resize(max_io);
   std::fill(m->isens_.begin(), m->isens_.end(), 0);
   // Allocate/reset sensitivities
   m->osens_.resize(max_io);
   std::fill(m->osens_.begin(), m->osens_.end(), 0);
   // Allocate/reset changed
   m->imarked_.resize(max_io);
   std::fill(m->imarked_.begin(), m->imarked_.end(), false);
   // Allocate/reset requested
   m->omarked_.resize(max_io);
   std::fill(m->omarked_.begin(), m->omarked_.end(), false);
   // Also allocate memory for corresponding Jacobian entry (for debugging)
   m->wrt_.resize(max_io);
   // Successful return
   return 0;
 }

References casadi::FmuInternal::discrete_states_iter(), casadi::FmuInternal::enter_continuous_time_mode(), casadi::FmuInternal::enter_initialization_mode(), casadi::FmuInternal::exit_initialization_mode(), casadi::FmuMemory::ibuf_, casadi::FmuInternal::iind_, casadi::FmuMemory::imarked_, casadi::FmuMemory::instance, casadi::FmuInternal::instantiate(), casadi::FmuMemory::isens_, casadi::nan, casadi::FmuMemory::obuf_, casadi::FmuInternal::oind_, casadi::FmuMemory::omarked_, casadi::FmuMemory::osens_, casadi::FmuInternal::set_values(), and casadi::FmuMemory::wrt_.

◆ 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 206 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 = 0;
   fmi3Instance c = instantiate_model_exchange_(instanceName, instantiationToken, resourcePath,
     visible, logging_on_, instanceEnvironment, log_message_callback);
   if (c == 0) 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 643 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 334 of file fmu_impl.hpp.

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

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

◆ load_functions()

void casadi::Fmu3::load_functions ( )

overridevirtual

Implements casadi::FmuInternal.

Definition at line 168 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 200 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 124 of file fmu_impl.hpp.

124 { return iind_.size();}

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

129 { return oind_.size();}

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

◆ request()

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

inherited

Definition at line 1170 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 1050 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 1041 of file fmu.cpp.

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

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

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

◆ request_fwd() [1/2]

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

inherited

Definition at line 1242 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 1233 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 228 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 1328 of file fmu.cpp.

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

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

◆ serialize_body()

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

virtualinherited

Reimplemented in casadi::Fmu2.

Definition at line 1337 of file fmu.cpp.

                                                            {
   s.version("FmuInternal", 3);
   s.pack("FmuInternal::name", name_);
   s.pack("FmuInternal::scheme_in", scheme_in_);
   s.pack("FmuInternal::scheme_out", scheme_out_);
   s.pack("FmuInternal::scheme", scheme_);
   s.pack("FmuInternal::aux", aux_);
   s.pack("FmuInternal::iind", iind_);
   s.pack("FmuInternal::iind_map", iind_map_);
   s.pack("FmuInternal::oind", oind_);
   s.pack("FmuInternal::oind_map", oind_map_);
   s.pack("FmuInternal::nominal_in", nominal_in_);
   s.pack("FmuInternal::nominal_out", nominal_out_);
   s.pack("FmuInternal::min_in", min_in_);
   s.pack("FmuInternal::min_out", min_out_);
   s.pack("FmuInternal::max_in", max_in_);
   s.pack("FmuInternal::max_out", max_out_);
   s.pack("FmuInternal::vn_in", vn_in_);
   s.pack("FmuInternal::vn_out", vn_out_);
   s.pack("FmuInternal::vr_in", vr_in_);
   s.pack("FmuInternal::vr_out", vr_out_);
  
   s.pack("FmuInternal::value_in", value_in_);
   s.pack("FmuInternal::ired", ired_);
   s.pack("FmuInternal::ored", ored_);
   s.pack("FmuInternal::jac_sp", jac_sp_);
   s.pack("FmuInternal::hess_sp", hess_sp_);
  
   s.pack("FmuInternal::resource", resource_);
   s.pack("FmuInternal::fmutol", fmutol_);
   s.pack("FmuInternal::instance_name", instance_name_);
   s.pack("FmuInternal::instantiation_token", instantiation_token_);
   s.pack("FmuInternal::logging_on", logging_on_);
   s.pack("FmuInternal::number_of_event_indicators", number_of_event_indicators_);
   s.pack("FmuInternal::provides_directional_derivatives", provides_directional_derivatives_);
   s.pack("FmuInternal::provides_adjoint_derivatives", provides_adjoint_derivatives_);
   s.pack("FmuInternal::can_be_instantiated_only_once_per_process",
     can_be_instantiated_only_once_per_process_);
 }

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

◆ serialize_type()

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

virtualinherited

Definition at line 1333 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 1149 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 1022 of file fmu.cpp.

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

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

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

◆ set_adj() [2/2]

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

inherited

Definition at line 1031 of file fmu.cpp.

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

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

◆ set_fwd() [1/2]

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

inherited

Definition at line 1214 of file fmu.cpp.

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

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

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

◆ set_fwd() [2/2]

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

inherited

Definition at line 1223 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 288 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_values()

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

overridevirtual

Implements casadi::FmuInternal.

Definition at line 328 of file fmu3.cpp.

                                          {
   auto c = static_cast<fmi3Instance>(instance);
   // Pass real values before initialization
   if (!vr_real_.empty()) {
     fmi3Status status = set_float64_(c, get_ptr(vr_real_), vr_real_.size(),
       get_ptr(init_real_), init_real_.size());
     if (status != fmi3OK) {
       casadi_warning("fmi3SetFloat64 failed");
       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

overridevirtual

Implements casadi::FmuInternal.

Definition at line 35 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";
   }
 #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;
 }

◆ update_discrete_states()

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

overridevirtual

Implements casadi::FmuInternal.

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

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

Member Data Documentation

◆ aux_

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

protectedinherited

Definition at line 281 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 104 of file fmu3.hpp.

Referenced by get_aux(), get_stats(), and init().

◆ can_be_instantiated_only_once_per_process_

bool casadi::FmuInternal::can_be_instantiated_only_once_per_process_

protectedinherited

Definition at line 305 of file fmu_impl.hpp.

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

◆ enter_continuous_time_mode_

fmi3EnterContinuousTimeModeTYPE* casadi::Fmu3::enter_continuous_time_mode_

Definition at line 82 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 80 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 81 of file fmu3.hpp.

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

◆ fmutol_

double casadi::FmuInternal::fmutol_

protectedinherited

Definition at line 287 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 78 of file fmu3.hpp.

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

◆ get_adjoint_derivative_

fmi3GetAdjointDerivativeTYPE* casadi::Fmu3::get_adjoint_derivative_

Definition at line 93 of file fmu3.hpp.

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

◆ get_boolean_

fmi3GetBooleanTYPE* casadi::Fmu3::get_boolean_

Definition at line 86 of file fmu3.hpp.

Referenced by get_aux(), and load_functions().

◆ get_directional_derivative_

fmi3GetDirectionalDerivativeTYPE* casadi::Fmu3::get_directional_derivative_

Definition at line 92 of file fmu3.hpp.

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

◆ get_float64_

fmi3GetFloat64TYPE* casadi::Fmu3::get_float64_

Definition at line 84 of file fmu3.hpp.

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

◆ get_int32_

fmi3GetInt32TYPE* casadi::Fmu3::get_int32_

Definition at line 88 of file fmu3.hpp.

Referenced by get_aux(), and load_functions().

◆ get_string_

fmi3GetStringTYPE* casadi::Fmu3::get_string_

Definition at line 90 of file fmu3.hpp.

Referenced by load_functions().

◆ has_independent_

bool casadi::FmuInternal::has_independent_

protectedinherited

Definition at line 314 of file fmu_impl.hpp.

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

◆ hess_sp_

Sparsity casadi::FmuInternal::hess_sp_

protectedinherited

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

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

◆ init_boolean_

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

Definition at line 67 of file fmu3.hpp.

Referenced by init(), and set_values().

◆ init_integer_

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

Definition at line 66 of file fmu3.hpp.

Referenced by init(), and set_values().

◆ init_real_

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

Definition at line 65 of file fmu3.hpp.

Referenced by init(), and set_values().

◆ init_string_

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

Definition at line 68 of file fmu3.hpp.

Referenced by init(), and set_values().

◆ instance_name_

std::string casadi::FmuInternal::instance_name_

protectedinherited

Definition at line 290 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 77 of file fmu3.hpp.

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

◆ instantiation_token_

std::string casadi::FmuInternal::instantiation_token_

protectedinherited

Definition at line 293 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 327 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 330 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 308 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 296 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 319 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 319 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 318 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 318 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 274 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 317 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 317 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 299 of file fmu_impl.hpp.

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

◆ oind_

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

protectedinherited

Definition at line 311 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 311 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 327 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 302 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 302 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 79 of file fmu3.hpp.

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

◆ resource_

Resource casadi::FmuInternal::resource_

protectedinherited

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

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

◆ scheme_

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

protectedinherited

Definition at line 278 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 277 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 277 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 87 of file fmu3.hpp.

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

◆ set_float64_

fmi3SetFloat64TYPE* casadi::Fmu3::set_float64_

Definition at line 85 of file fmu3.hpp.

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

◆ set_int32_

fmi3SetInt32TYPE* casadi::Fmu3::set_int32_

Definition at line 89 of file fmu3.hpp.

Referenced by load_functions(), and set_values().

◆ set_string_

fmi3SetStringTYPE* casadi::Fmu3::set_string_

Definition at line 91 of file fmu3.hpp.

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

◆ set_time_

fmi3SetTimeTYPE* casadi::Fmu3::set_time_

Definition at line 83 of file fmu3.hpp.

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

◆ update_discrete_states_

fmi3UpdateDiscreteStatesTYPE* casadi::Fmu3::update_discrete_states_

Definition at line 94 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 324 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 71 of file fmu3.hpp.

Referenced by get_stats(), and init().

◆ vn_aux_integer_

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

Definition at line 71 of file fmu3.hpp.

Referenced by get_stats(), and init().

◆ vn_aux_real_

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

Definition at line 71 of file fmu3.hpp.

Referenced by get_stats(), and init().

◆ vn_aux_string_

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

Definition at line 71 of file fmu3.hpp.

Referenced by get_stats(), and init().

◆ vn_in_

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

protectedinherited

Definition at line 320 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 320 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 72 of file fmu3.hpp.

Referenced by get_aux(), and init().

◆ vr_aux_integer_

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

Definition at line 72 of file fmu3.hpp.

Referenced by get_aux(), and init().

◆ vr_aux_real_

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

Definition at line 72 of file fmu3.hpp.

Referenced by get_aux(), and init().

◆ vr_aux_string_

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

Definition at line 72 of file fmu3.hpp.

Referenced by get_aux(), and init().

◆ vr_boolean_

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

Definition at line 64 of file fmu3.hpp.

Referenced by init(), and set_values().

◆ vr_in_

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

protectedinherited

Definition at line 321 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 64 of file fmu3.hpp.

Referenced by init(), and set_values().

◆ vr_out_

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

protectedinherited

Definition at line 321 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 64 of file fmu3.hpp.

Referenced by init(), and set_values().

◆ vr_string_

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

Definition at line 64 of file fmu3.hpp.

Referenced by init(), and set_values().

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

◆ ~Fmu3()

Member Function Documentation

◆ all_nominal_in()

◆ all_nominal_out()

◆ class_name()

◆ debug_repr()

◆ desc_in()

◆ deserialize()

◆ destroySingleton()

◆ discrete_states_iter()

◆ disp()

◆ dll_suffix()

◆ enter_continuous_time_mode()

◆ enter_initialization_mode()

◆ eval()

◆ eval_ad()

◆ eval_adj()

◆ eval_fd()

◆ eval_fwd()

◆ exit_initialization_mode()

◆ finalize()

◆ free_instance()

◆ gather_adj()

◆ gather_fwd()

◆ gather_io()

◆ get()

◆ get_adj() [1/2]

◆ get_adj() [2/2]

◆ get_adjoint_derivative()

◆ get_aux()

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

◆ request()

◆ request_adj() [1/2]

◆ request_adj() [2/2]

◆ request_fwd() [1/2]

◆ request_fwd() [2/2]

◆ reset()

◆ serialize()

◆ serialize_body()

◆ serialize_type()

◆ set()

◆ set_adj() [1/2]

◆ set_adj() [2/2]

◆ set_fwd() [1/2]

◆ set_fwd() [2/2]

◆ set_real()

◆ set_values()

◆ shared_from_this() [1/2]

◆ shared_from_this() [2/2]

◆ system_infix()