Interface to binary FMU. More...

#include <fmu_impl.hpp>

Detailed Description

Internal API.

Author: Joel Andersson

Date: 2023

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

Definition at line 60 of file fmu_impl.hpp.

Inheritance diagram for casadi::FmuInternal:

[legend]

Collaboration diagram for casadi::FmuInternal:

[legend]

Public Types
using	weak_ref_type = WeakRefInternal

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

	~FmuInternal () override
	Destructor. More...

virtual void	init (const DaeBuilderInternal *dae)

virtual void	load_functions ()=0

virtual int	enter_initialization_mode (void *instance) const =0

virtual int	exit_initialization_mode (void *instance) const =0

virtual int	enter_continuous_time_mode (void *instance) const =0

virtual int	update_discrete_states (void instance, EventMemory eventmem) const =0

virtual int	set_real (void instance, const unsigned int vr, size_t n_vr, const double *values, size_t n_values) const =0

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

virtual 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 =0

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

virtual int	set_values (void *instance) const =0

virtual int	get_aux (void *instance)=0

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

virtual std::string	system_infix () const =0

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

virtual void *	instantiate () const =0

virtual void	free_instance (void *c) const =0

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

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

void	serialize (SerializingStream &s) const

virtual void	serialize_type (SerializingStream &s) const

virtual void	serialize_body (SerializingStream &s) const

virtual std::string	class_name () const =0
	Readable name of the internal class. More...

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

static FmuInternal *	deserialize (DeserializingStream &s)

Protected Member Functions
	FmuInternal (DeserializingStream &s)

void	initSingleton ()

void	destroySingleton ()

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

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

Protected Attributes
Resource	resource_

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

std::vector< std::string >	scheme_in_

std::vector< std::string >	scheme_out_

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

std::vector< std::string >	aux_

std::string	resource_loc_

double	fmutol_

std::string	instance_name_

std::string	instantiation_token_

bool	logging_on_

casadi_int	number_of_event_indicators_

bool	provides_directional_derivatives_

bool	provides_adjoint_derivatives_

bool	can_be_instantiated_only_once_per_process_

Importer	li_
	DLL. More...

std::vector< size_t >	iind_

std::vector< size_t >	iind_map_

std::vector< size_t >	oind_

std::vector< size_t >	oind_map_

bool	has_independent_

std::vector< double >	nominal_in_

std::vector< double >	nominal_out_

std::vector< double >	min_in_

std::vector< double >	min_out_

std::vector< double >	max_in_

std::vector< double >	max_out_

std::vector< std::string >	vn_in_

std::vector< std::string >	vn_out_

std::vector< unsigned int >	vr_in_

std::vector< unsigned int >	vr_out_

std::vector< double >	value_in_

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

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

Sparsity	jac_sp_

Sparsity	hess_sp_

Friends
class	Fmu

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

◆ FmuInternal() [1/2]

casadi::FmuInternal::FmuInternal	(	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 432 of file fmu.cpp.

437 : name_(name), scheme_in_(scheme_in), scheme_out_(scheme_out), scheme_(scheme), aux_(aux) {

438 }

casadi::FmuInternal::scheme_out_

std::vector< std::string > scheme_out_

Definition: fmu_impl.hpp:277

casadi::FmuInternal::name_

std::string name_

Instance name.

Definition: fmu_impl.hpp:274

casadi::FmuInternal::aux_

std::vector< std::string > aux_

Definition: fmu_impl.hpp:281

casadi::FmuInternal::scheme_

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

Definition: fmu_impl.hpp:278

casadi::FmuInternal::scheme_in_

std::vector< std::string > scheme_in_

Definition: fmu_impl.hpp:277

◆ ~FmuInternal()

casadi::FmuInternal::~FmuInternal ( )

override

Definition at line 440 of file fmu.cpp.

440 {

441 }

◆ FmuInternal() [2/2]

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

explicitprotected

Definition at line 1377 of file fmu.cpp.

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

References aux_, can_be_instantiated_only_once_per_process_, fmutol_, hess_sp_, iind_, iind_map_, instance_name_, instantiation_token_, ired_, jac_sp_, logging_on_, max_in_, max_out_, min_in_, min_out_, name_, nominal_in_, nominal_out_, number_of_event_indicators_, oind_, oind_map_, ored_, provides_adjoint_derivatives_, provides_directional_derivatives_, resource_, scheme_, scheme_in_, scheme_out_, casadi::DeserializingStream::unpack(), value_in_, casadi::DeserializingStream::version(), vn_in_, vn_out_, vr_in_, and vr_out_.

Member Function Documentation

◆ all_nominal_in()

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

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 ired_, and nominal_in_.

◆ all_nominal_out()

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

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 nominal_out_, and ored_.

◆ class_name()

virtual std::string casadi::SharedObjectInternal::class_name ( ) const

pure virtualinherited

Implemented in casadi::SymbolicQr, casadi::Sqpmethod, casadi::ShellCompiler, casadi::Scpgen, casadi::RungeKutta, casadi::Qrsqp, casadi::Qrqp, casadi::QpToNlp, casadi::Newton, casadi::Lsqr, casadi::LinsolTridiag, casadi::LinsolQr, casadi::LinsolLdl, casadi::LinearInterpolantJac, casadi::LinearInterpolant, casadi::Ipqp, casadi::ImplicitToNlp, casadi::Feasiblesqpmethod, casadi::FastNewton, casadi::Collocation, casadi::BSplineInterpolant, casadi::WorhpInterface, casadi::TinyXmlInterface, casadi::SuperscsInterface, casadi::KinsolInterface, casadi::IdasInterface, casadi::CvodesInterface, casadi::SqicInterface, casadi::SnoptInterface, casadi::SlicotExpm, casadi::SlicotDple, casadi::SLEQPInterface, casadi::QpoasesInterface, casadi::ProxqpInterface, casadi::OsqpInterface, casadi::OoqpInterface, casadi::MumpsInterface, casadi::MadnlpInterface, casadi::LapackQr, casadi::LapackLu, casadi::KnitroInterface, casadi::IpoptInterface, casadi::Ma27Interface, casadi::HpmpcInterface, casadi::HpipmInterface, casadi::HighsInterface, casadi::GurobiInterface, casadi::FatropInterface, casadi::FatropConicInterface, casadi::DaqpInterface, casadi::CsparseInterface, casadi::CSparseCholeskyInterface, casadi::CplexInterface, casadi::ClpInterface, casadi::ClarabelInterface, casadi::ClangCompiler, casadi::CbcInterface, casadi::BonminInterface, casadi::Blocksqp, casadi::AmplInterface, casadi::AlpaqaInterface, casadi::SXFunction, casadi::Switch, casadi::SparsityInternal, casadi::WeakRefInternal, casadi::ZipMemResource, casadi::ZipResource, casadi::DirResource, casadi::OptiNode, casadi::Nlpsol, casadi::MXNode, casadi::MXFunction, casadi::MapSum, casadi::ThreadMap, casadi::OmpMap, casadi::Map, casadi::JitFunction, casadi::Interpolant, casadi::DllLibrary, casadi::ImporterInternal, casadi::GenericTypeInternal< ID, T >, casadi::FmuFunction, casadi::Fmu3, casadi::Fmu2, casadi::Smoothing, casadi::CentralDiff, casadi::BackwardDiff, casadi::ForwardDiff, casadi::External, casadi::DaeBuilderInternal, casadi::CallbackInternal, and casadi::BlazingSplineFunction.

◆ 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

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_, max_in_, min_in_, nominal_in_, and vn_in_.

Referenced by eval_fd().

◆ deserialize()

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

static

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

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, update_discrete_states(), and casadi::EventMemory::values_of_continuous_states_changed.

Referenced by init_mem().

◆ disp()

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

overridevirtual

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

◆ dll_suffix()

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

static

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

◆ enter_continuous_time_mode()

virtual int casadi::FmuInternal::enter_continuous_time_mode ( void * instance ) const

pure virtual

Implemented in casadi::Fmu3, and casadi::Fmu2.

Referenced by init_mem().

◆ enter_initialization_mode()

virtual int casadi::FmuInternal::enter_initialization_mode ( void * instance ) const

pure virtual

Implemented in casadi::Fmu3, and casadi::Fmu2.

Referenced by finalize(), and init_mem().

◆ eval()

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

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 gather_io(), casadi::get_ptr(), get_real(), casadi::FmuMemory::id_in_, casadi::FmuMemory::id_out_, casadi::FmuMemory::instance, n_out(), casadi::FmuMemory::obuf_, 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

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_, get_directional_derivative(), casadi::get_ptr(), 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 eval_fwd().

◆ eval_adj()

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

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_, gather_adj(), 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

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

◆ eval_fwd()

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

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 eval_ad(), eval_fd(), gather_fwd(), casadi::FmuMemory::self, casadi::FmuFunction::uses_directional_derivatives_, and casadi::FmuFunction::validate_forward_.

◆ exit_initialization_mode()

virtual int casadi::FmuInternal::exit_initialization_mode ( void * instance ) const

pure virtual

Implemented in casadi::Fmu3, and casadi::Fmu2.

Referenced by init_mem().

◆ finalize()

void casadi::FmuInternal::finalize ( )

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);
 }

References casadi::Filesystem::absolute(), dll_suffix(), enter_initialization_mode(), free_instance(), get_aux(), casadi::get_ptr(), get_real(), instance_name_, instantiate(), casadi::Filesystem::is_enabled(), li_, load_functions(), casadi::Resource::path(), resource_, resource_loc_, set_values(), system_infix(), value_in_, and vr_in_.

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

◆ free_instance()

virtual void casadi::FmuInternal::free_instance ( void * c ) const

pure virtual

Implemented in casadi::Fmu3, and casadi::Fmu2.

Referenced by finalize().

◆ gather_adj()

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

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_, gather_io(), casadi::FmuMemory::id_in_, casadi::FmuMemory::id_out_, casadi::FmuMemory::osens_, and casadi::FmuMemory::v_in_.

Referenced by eval_adj().

◆ gather_fwd()

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

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_, gather_io(), casadi::FmuMemory::id_in_, casadi::FmuMemory::id_out_, casadi::FmuMemory::isens_, and casadi::FmuMemory::v_out_.

Referenced by eval_fwd().

◆ gather_io()

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

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_, vr_in_, casadi::FmuMemory::vr_out_, and vr_out_.

Referenced by eval(), gather_adj(), and gather_fwd().

◆ get()

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

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

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

◆ get_adj() [2/2]

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

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 get_adj(), and ired_.

◆ get_adjoint_derivative()

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

virtual

Reimplemented in casadi::Fmu3.

Definition at line 562 of file fmu.cpp.

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

References casadi::SharedObjectInternal::class_name().

Referenced by eval_adj().

◆ get_aux()

virtual int casadi::FmuInternal::get_aux ( void * instance )

pure virtual

Implemented in casadi::Fmu3, and casadi::Fmu2.

Referenced by finalize().

◆ get_directional_derivative()

virtual int casadi::FmuInternal::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

pure virtual

Implemented in casadi::Fmu3, and casadi::Fmu2.

Referenced by eval_ad().

◆ get_fwd() [1/2]

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

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

◆ get_fwd() [2/2]

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

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 get_fwd(), and ored_.

◆ get_real()

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

pure virtual

Implemented in casadi::Fmu3, and casadi::Fmu2.

Referenced by eval(), eval_ad(), eval_fd(), and finalize().

◆ get_stats()

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

pure virtual

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

Implemented in casadi::Fmu3, and casadi::Fmu2.

◆ 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

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 hess_sp_, and casadi::Sparsity::sub().

◆ index_in()

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

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

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

◆ index_out()

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

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

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

◆ init()

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

virtual

Reimplemented in casadi::Fmu3, and casadi::Fmu2.

Definition at line 443 of file fmu.cpp.

                                                     {
   // Copy info from DaeBuilder
   resource_ = dae->resource_;
   fmutol_ = dae->fmutol_;
   instance_name_ = dae->model_identifier_;
   instantiation_token_ = dae->instantiation_token_;
   logging_on_ = dae->debug_;
   number_of_event_indicators_ = dae->number_of_event_indicators_;
   provides_directional_derivatives_ = dae->provides_directional_derivatives_;
   provides_adjoint_derivatives_ = dae->provides_adjoint_derivatives_;
   can_be_instantiated_only_once_per_process_ = dae->can_be_instantiated_only_once_per_process_;
  
   // Mark input indices
   size_t numel = 0;
   std::vector<bool> lookup(dae->n_variables(), false);
   for (auto&& n : scheme_in_) {
     for (size_t i : scheme_.at(n)) {
       casadi_assert(!lookup.at(i), "Duplicate variable: " + dae->variable(i).name);
       lookup.at(i) = true;
       numel++;
     }
   }
   // Input mappings
   iind_.reserve(numel);
   iind_map_.reserve(lookup.size());
   for (size_t k = 0; k < lookup.size(); ++k) {
     if (lookup[k]) {
       iind_map_.push_back(iind_.size());
       iind_.push_back(k);
     } else {
       iind_map_.push_back(-1);
     }
   }
   // Mark output indices
   numel = 0;
   std::fill(lookup.begin(), lookup.end(), false);
   for (auto&& n : scheme_out_) {
     for (size_t i : scheme_.at(n)) {
       casadi_assert(!lookup.at(i), "Duplicate variable: " + dae->variable(i).name);
       lookup.at(i) = true;
       numel++;
     }
   }
   // Construct mappings
   oind_.reserve(numel);
   oind_map_.reserve(lookup.size());
   for (size_t k = 0; k < lookup.size(); ++k) {
     if (lookup[k]) {
       oind_map_.push_back(oind_.size());
       oind_.push_back(k);
     } else {
       oind_map_.push_back(-1);
     }
   }
   // Inputs
   ired_.resize(scheme_in_.size());
   for (size_t i = 0; i < ired_.size(); ++i) {
     auto&& s = scheme_.at(scheme_in_[i]);
     ired_[i].resize(s.size());
     for (size_t k = 0; k < s.size(); ++k) {
       ired_[i][k] = iind_map_.at(s[k]);
     }
   }
   // Outputs
   ored_.resize(scheme_out_.size());
   for (size_t i = 0; i < ored_.size(); ++i) {
     auto&& s = scheme_.at(scheme_out_[i]);
     ored_[i].resize(s.size());
     for (size_t k = 0; k < s.size(); ++k) {
       ored_[i][k] = oind_map_.at(s[k]);
     }
   }
  
   // Is there an independent variable?
   has_independent_ = false;
  
   // Collect meta information for inputs
   nominal_in_.reserve(iind_.size());
   min_in_.reserve(iind_.size());
   max_in_.reserve(iind_.size());
   vn_in_.reserve(iind_.size());
   vr_in_.reserve(iind_.size());
   for (size_t i : iind_) {
     const Variable& v = dae->variable(i);
     nominal_in_.push_back(v.nominal);
     min_in_.push_back(v.min);
     max_in_.push_back(v.max);
     vn_in_.push_back(v.name);
     vr_in_.push_back(v.value_reference);
     if (v.causality == Causality::INDEPENDENT) {
       if (i != 0) casadi_error("Independent variable must be first input of FMU");
       has_independent_ = true;
     }
   }
   // Collect meta information for outputs
   nominal_out_.reserve(oind_.size());
   min_out_.reserve(oind_.size());
   max_out_.reserve(oind_.size());
   vn_out_.reserve(oind_.size());
   vr_out_.reserve(oind_.size());
   for (size_t i : oind_) {
     const Variable& v = dae->variable(i);
     nominal_out_.push_back(v.nominal);
     min_out_.push_back(v.min);
     max_out_.push_back(v.max);
     vn_out_.push_back(v.name);
     vr_out_.push_back(v.value_reference);
   }
  
   // Numerical values for inputs
   value_in_.resize(iind_.size());
  
   // Get Jacobian sparsity information
   jac_sp_ = dae->jac_sparsity(oind_, iind_);
  
   // Get Hessian sparsity information
   hess_sp_ = dae->hess_sparsity(oind_, iind_);
 }

Referenced by casadi::Fmu2::init(), and casadi::Fmu3::init().

◆ init_mem()

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

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 discrete_states_iter(), enter_continuous_time_mode(), enter_initialization_mode(), exit_initialization_mode(), casadi::FmuMemory::ibuf_, iind_, casadi::FmuMemory::imarked_, casadi::FmuMemory::instance, instantiate(), casadi::FmuMemory::isens_, casadi::nan, casadi::FmuMemory::obuf_, oind_, casadi::FmuMemory::omarked_, casadi::FmuMemory::osens_, 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()

virtual void* casadi::FmuInternal::instantiate ( ) const

pure virtual

Implemented in casadi::Fmu3, and casadi::Fmu2.

Referenced by finalize(), and init_mem().

◆ jac_sparsity()

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

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 jac_sp_, and casadi::Sparsity::sub().

◆ load_function()

template<typename T >

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

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(), li_, and casadi::T.

◆ load_functions()

virtual void casadi::FmuInternal::load_functions ( )

pure virtual

Implemented in casadi::Fmu3, and casadi::Fmu2.

Referenced by finalize().

◆ n_in()

size_t casadi::FmuInternal::n_in ( ) const

inline

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 casadi::Fmu3::get_adjoint_derivative(), casadi::Fmu2::get_directional_derivative(), and casadi::Fmu3::get_directional_derivative().

◆ n_out()

size_t casadi::FmuInternal::n_out ( ) const

inline

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 eval(), casadi::Fmu3::get_adjoint_derivative(), casadi::Fmu2::get_directional_derivative(), and casadi::Fmu3::get_directional_derivative().

◆ request()

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

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_, ored_, and casadi::FmuMemory::wrt_.

◆ request_adj() [1/2]

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

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 ired_, and 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

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

◆ request_fwd() [1/2]

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

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 ored_, and 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

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

◆ serialize()

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

Definition at line 1328 of file fmu.cpp.

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

References serialize_body(), and serialize_type().

◆ serialize_body()

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

virtual

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_);
 }

References aux_, can_be_instantiated_only_once_per_process_, fmutol_, hess_sp_, iind_, iind_map_, instance_name_, instantiation_token_, ired_, jac_sp_, logging_on_, max_in_, max_out_, min_in_, min_out_, name_, nominal_in_, nominal_out_, number_of_event_indicators_, oind_, oind_map_, ored_, casadi::SerializingStream::pack(), provides_adjoint_derivatives_, provides_directional_derivatives_, resource_, scheme_, scheme_in_, scheme_out_, value_in_, casadi::SerializingStream::version(), vn_in_, vn_out_, vr_in_, and vr_out_.

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

◆ serialize_type()

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

virtual

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

◆ set()

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

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

◆ set_adj() [1/2]

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

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

◆ set_adj() [2/2]

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

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 ored_, and set_adj().

◆ set_fwd() [1/2]

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

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

◆ set_fwd() [2/2]

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

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 ired_, and set_fwd().

◆ set_real()

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

pure virtual

Implemented in casadi::Fmu3, and casadi::Fmu2.

Referenced by eval(), and eval_fd().

◆ set_values()

virtual int casadi::FmuInternal::set_values ( void * instance ) const

pure virtual

Implemented in casadi::Fmu3, and casadi::Fmu2.

Referenced by finalize(), and init_mem().

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

virtual std::string casadi::FmuInternal::system_infix ( ) const

pure virtual

Implemented in casadi::Fmu3, and casadi::Fmu2.

References casadi::T.

Referenced by finalize().

◆ update_discrete_states()

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

pure virtual

Implemented in casadi::Fmu3, and casadi::Fmu2.

Referenced by discrete_states_iter().

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

Friends And Related Function Documentation

◆ Fmu

friend class Fmu

friend

Definition at line 61 of file fmu_impl.hpp.

Member Data Documentation

◆ aux_

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

protected

Definition at line 281 of file fmu_impl.hpp.

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

◆ can_be_instantiated_only_once_per_process_

bool casadi::FmuInternal::can_be_instantiated_only_once_per_process_

protected

Definition at line 305 of file fmu_impl.hpp.

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

◆ fmutol_

double casadi::FmuInternal::fmutol_

protected

Definition at line 287 of file fmu_impl.hpp.

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

◆ has_independent_

bool casadi::FmuInternal::has_independent_

protected

Definition at line 314 of file fmu_impl.hpp.

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

◆ hess_sp_

Sparsity casadi::FmuInternal::hess_sp_

protected

Definition at line 330 of file fmu_impl.hpp.

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

◆ iind_

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

protected

Definition at line 311 of file fmu_impl.hpp.

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

◆ iind_map_

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

protected

Definition at line 311 of file fmu_impl.hpp.

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

◆ instance_name_

std::string casadi::FmuInternal::instance_name_

protected

Definition at line 290 of file fmu_impl.hpp.

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

◆ instantiation_token_

std::string casadi::FmuInternal::instantiation_token_

protected

Definition at line 293 of file fmu_impl.hpp.

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

◆ ired_

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

protected

Definition at line 327 of file fmu_impl.hpp.

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

◆ jac_sp_

Sparsity casadi::FmuInternal::jac_sp_

protected

Definition at line 330 of file fmu_impl.hpp.

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

◆ li_

Importer casadi::FmuInternal::li_

protected

Definition at line 308 of file fmu_impl.hpp.

Referenced by finalize(), and load_function().

◆ logging_on_

bool casadi::FmuInternal::logging_on_

protected

Definition at line 296 of file fmu_impl.hpp.

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

◆ max_in_

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

protected

Definition at line 319 of file fmu_impl.hpp.

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

◆ max_out_

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

protected

Definition at line 319 of file fmu_impl.hpp.

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

◆ min_in_

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

protected

Definition at line 318 of file fmu_impl.hpp.

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

◆ min_out_

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

protected

Definition at line 318 of file fmu_impl.hpp.

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

◆ name_

std::string casadi::FmuInternal::name_

protected

Definition at line 274 of file fmu_impl.hpp.

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

◆ nominal_in_

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

protected

Definition at line 317 of file fmu_impl.hpp.

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

◆ nominal_out_

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

protected

Definition at line 317 of file fmu_impl.hpp.

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

◆ number_of_event_indicators_

casadi_int casadi::FmuInternal::number_of_event_indicators_

protected

Definition at line 299 of file fmu_impl.hpp.

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

◆ oind_

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

protected

Definition at line 311 of file fmu_impl.hpp.

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

◆ oind_map_

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

protected

Definition at line 311 of file fmu_impl.hpp.

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

◆ ored_

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

protected

Definition at line 327 of file fmu_impl.hpp.

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

◆ provides_adjoint_derivatives_

bool casadi::FmuInternal::provides_adjoint_derivatives_

protected

Definition at line 302 of file fmu_impl.hpp.

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

◆ provides_directional_derivatives_

bool casadi::FmuInternal::provides_directional_derivatives_

protected

Definition at line 302 of file fmu_impl.hpp.

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

◆ resource_

Resource casadi::FmuInternal::resource_

protected

Definition at line 271 of file fmu_impl.hpp.

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

◆ resource_loc_

std::string casadi::FmuInternal::resource_loc_

protected

Definition at line 284 of file fmu_impl.hpp.

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

◆ scheme_

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

protected

Definition at line 278 of file fmu_impl.hpp.

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

◆ scheme_in_

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

protected

Definition at line 277 of file fmu_impl.hpp.

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

◆ scheme_out_

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

protected

Definition at line 277 of file fmu_impl.hpp.

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

◆ value_in_

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

protected

Definition at line 324 of file fmu_impl.hpp.

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

◆ vn_in_

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

protected

Definition at line 320 of file fmu_impl.hpp.

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

◆ vn_out_

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

protected

Definition at line 320 of file fmu_impl.hpp.

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

◆ vr_in_

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

protected

Definition at line 321 of file fmu_impl.hpp.

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

◆ vr_out_

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

protected

Definition at line 321 of file fmu_impl.hpp.

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

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

Detailed Description

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Member Typedef Documentation

◆ weak_ref_type

Constructor & Destructor Documentation

◆ FmuInternal() [1/2]

◆ ~FmuInternal()

◆ FmuInternal() [2/2]

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

◆ n_in()

◆ n_out()

◆ request()

◆ request_adj() [1/2]

◆ request_adj() [2/2]

◆ request_fwd() [1/2]

◆ request_fwd() [2/2]

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

◆ update_discrete_states()

◆ weak()