casadi::FmuInternal Class Reference

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

Inheritance diagram for casadi::FmuInternal:

Collaboration diagram for casadi::FmuInternal:

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	get_derivatives (void *instance, double *derivatives, size_t nx) const =0
virtual int	set_time (void *instance, double t) 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, FmuMemory *m=nullptr) 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
virtual 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
virtual int	init_mem (FmuMemory *m) const
	Initalize memory block. More...
virtual FmuMemory *	alloc_mem (const FmuFunction &f) const =0
	Create memory block. More...
virtual void	free_mem (void *mem) const =0
	Free 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	set_all (FmuMemory *m, const double *values, size_t n_values) const
int	get_all (FmuMemory *m, double *values, size_t n_values) const
int	eval (FmuMemory *m) const
void	get (FmuMemory *m, size_t id, double *value) const
void	set_fwd (FmuMemory *m, casadi_int nseed, const casadi_int *id, const double *v) const
void	set_fwd (FmuMemory *m, size_t ind, const double *v) const
void	request_fwd (FmuMemory *m, casadi_int nsens, const casadi_int *id, const casadi_int *wrt_id) const
void	request_fwd (FmuMemory *m, casadi_int ind) const
int	eval_fwd (FmuMemory *m, bool independent_seeds) const
int	eval_ad (FmuMemory *m) const
int	eval_fd (FmuMemory *m, bool independent_seeds) const
void	get_fwd (FmuMemory *m, casadi_int nsens, const casadi_int *id, double *v) const
void	get_fwd (FmuMemory *m, size_t ind, double *v) const
void	set_adj (FmuMemory *m, casadi_int nseed, const casadi_int *id, const double *v) const
void	set_adj (FmuMemory *m, size_t ind, const double *v) const
void	request_adj (FmuMemory *m, casadi_int nsens, const casadi_int *id, const casadi_int *wrt_id) const
void	request_adj (FmuMemory *m, casadi_int ind) const
int	eval_adj (FmuMemory *m) const
void	get_adj (FmuMemory *m, casadi_int nsens, const casadi_int *id, double *v) const
void	get_adj (FmuMemory *m, size_t ind, double *v) const
void	gather_fwd (FmuMemory *m) const
void	gather_adj (FmuMemory *m) const
void	gather_io (FmuMemory *m) const
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 std::string	fmi3_dll_infix ()
static Dict	compile_fmu (const std::string &name, const Dict &files, const Dict &opts)
static std::string	pack_fmu (const Dict &files, const std::string &path)
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_
double	start_time_
Importer	li_
	DLL. More...
std::vector< size_t >	iind_
std::vector< size_t >	iind_map_
std::vector< size_t >	oind_
std::vector< size_t >	oind_map_
bool	has_independent_
unsigned int	independent_vr_
std::vector< double >	nominal_in_
std::vector< double >	nominal_out_
std::vector< double >	min_in_
std::vector< double >	min_out_
std::vector< double >	max_in_
std::vector< double >	max_out_
std::vector< std::string >	vn_in_
std::vector< std::string >	vn_out_
std::vector< unsigned int >	vr_in_
std::vector< unsigned int >	vr_out_
std::vector< double >	value_in_
std::vector< std::vector< size_t > >	ired_
std::vector< std::vector< size_t > >	ored_
Sparsity	jac_sp_
Sparsity	hess_sp_
bool	warning_fired_discrete_states_need_update_
bool	warning_fired_terminate_simulation_
bool	warning_fired_nominals_of_continuous_states_changed_
bool	warning_fired_values_of_continuous_states_changed_
bool	warning_fired_next_event_time_defined_
size_t	nx_
bool	do_evaluation_dance_

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

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

~FmuInternal()

casadi::FmuInternal::~FmuInternal ( )

override

Definition at line 450 of file fmu.cpp.

                          {
}

FmuInternal() [2/2]

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

explicitprotected

Definition at line 1603 of file fmu.cpp.

                                               {
  s.version("FmuInternal", 4);
  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::has_independent", has_independent_);
  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_);
  s.unpack("FmuInternal::start_time", start_time_);
  s.unpack("FmuInternal::nx", nx_);
  s.unpack("FmuInternal::do_evaluation_dance", do_evaluation_dance_);
}

References aux_, can_be_instantiated_only_once_per_process_, do_evaluation_dance_, fmutol_, has_independent_, 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_, nx_, oind_, oind_map_, ored_, provides_adjoint_derivatives_, provides_directional_derivatives_, resource_, scheme_, scheme_in_, scheme_out_, start_time_, 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 707 of file fmu.cpp.

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

References 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 715 of file fmu.cpp.

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

References nominal_out_, and ored_.

alloc_mem()

virtual FmuMemory* casadi::FmuInternal::alloc_mem ( const FmuFunction &  f ) const

pure virtual

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

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

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::XpressInterface, casadi::WorhpInterface, casadi::UnoInterface, 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::PiqpInterface, casadi::OsqpInterface, casadi::OnnxRuntimeInterface, casadi::OoqpInterface, casadi::Onnx, casadi::MumpsInterface, casadi::MosekInterface, casadi::MadnlpInterface, casadi::LapackQr, casadi::LapackLu, casadi::LaceModelica, 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::ConoptInterface, casadi::ClpInterface, casadi::ClarabelInterface, casadi::ClangCompiler, casadi::MadmpecInterface, casadi::CbcInterface, casadi::BonminInterface, casadi::Blocksqp, casadi::AmplInterface, casadi::AlpaqaInterface, casadi::SXFunction, casadi::Switch, casadi::SparsityInternal, casadi::WeakRefInternal, casadi::ZipMemResource, casadi::ZipResource, casadi::TemporaryDirResource, 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::GraphModelInternal, casadi::GraphBuilderInternal, 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.

Referenced by casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::call_reverse(), casadi::FunctionInternal::codegen_body(), casadi::ProtoFunction::construct(), deserialize(), casadi::ResourceInternal::deserialize(), casadi::LinsolInternal::det(), disp(), casadi::FunctionInternal::disp(), casadi::LinsolInternal::disp(), casadi::XmlFileInternal::dump(), casadi::FunctionInternal::eval(), casadi::FunctionInternal::eval_dm(), casadi::FunctionInternal::eval_sx(), casadi::FunctionInternal::export_code(), casadi::LinsolInternal::generate(), casadi::FunctionInternal::generate_dependencies(), casadi::LinsolInternal::generate_det(), casadi::Conic::generateNativeCode(), get_adjoint_derivative(), casadi::FunctionInternal::get_forward(), casadi::FunctionInternal::get_function(), casadi::FunctionInternal::get_jacobian(), casadi::FunctionInternal::get_reverse(), casadi::FiniteDiff::init(), casadi::FunctionInternal::instruction_constant(), casadi::FunctionInternal::instruction_id(), casadi::FunctionInternal::instruction_input(), casadi::FunctionInternal::instruction_MX(), casadi::FunctionInternal::instruction_output(), casadi::FunctionInternal::instructions_sx(), casadi::LinsolInternal::linsol_eval_sx(), casadi::FunctionInternal::n_instructions(), casadi::FunctionInternal::n_nodes(), casadi::LinsolInternal::neig(), casadi::LinsolInternal::nfact(), casadi::FunctionInternal::open_trace(), casadi::FunctionInternal::oracle(), casadi::XmlFileInternal::parse(), casadi::ModelicaParserInternal::parse(), serialize_type(), casadi::ResourceInternal::serialize_type(), casadi::FunctionInternal::simplify_passes(), and casadi::LinsolInternal::solve().

compile_fmu()

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

static

Definition at line 781 of file fmu.cpp.

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

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

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

debug_repr()

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

inherited

Definition at line 62 of file generic_shared_internal.hpp.

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

desc_in()

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

Definition at line 850 of file fmu.cpp.

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

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

Referenced by eval_fd().

deserialize()

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

static

Definition at line 1647 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
    return Fmu3::deserialize(s);
#else
    casadi_error("CasADi was not compiled with WITH_FMI3=ON.");
#endif // WITH_FMI3
  } else {
    casadi_error("Cannot deserialize type '" + class_name + "'");
  }
}

References casadi::SharedObjectInternal::class_name(), casadi::Fmu2::deserialize(), casadi::Fmu3::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 1248 of file fmu.cpp.

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

References casadi::EventMemory::discrete_states_need_update, casadi::EventMemory::next_event_time_defined, casadi::EventMemory::nominals_of_continuous_states_changed, casadi::EventMemory::terminate_simulation, update_discrete_states(), casadi::EventMemory::values_of_continuous_states_changed, warning_fired_discrete_states_need_update_, warning_fired_next_event_time_defined_, warning_fired_nominals_of_continuous_states_changed_, warning_fired_terminate_simulation_, and warning_fired_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 651 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 723 of file fmu.cpp.

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

Referenced by compile_fmu(), and 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 1414 of file fmu.cpp.

                                        {
  // Gather inputs and outputs
  gather_io(m);
  // Pass inputs to FMU
  if (set_all(m, get_ptr(m->v_in_), m->v_in_.size())) return 1;
  // Get outputs from FMU
  if (get_all(m, get_ptr(m->v_out_), m->v_out_.size())) return 1;
  // Collect requested variables
  auto it = m->v_out_.begin();
  for (size_t id : m->id_out_) {
    m->obuf_[id] = *it++;
  }
  // Successful return
  return 0;
}

References gather_io(), get_all(), casadi::get_ptr(), casadi::FmuMemory::id_out_, casadi::FmuMemory::obuf_, set_all(), casadi::FmuMemory::v_in_, and casadi::FmuMemory::v_out_.

eval_ad()

int casadi::FmuInternal::eval_ad

(

FmuMemory *

m

)

const

Definition at line 912 of file fmu.cpp.

                                           {
  // Number of inputs and outputs
  size_t n_known = m->id_in_.size();
  size_t n_unknown = m->id_out_.size();
  // Quick return if nothing to be calculated
  if (n_unknown == 0) return 0;
  // Quick return if no seeds
  if (n_known == 0) {
    std::fill(m->d_out_.begin(), m->d_out_.end(), 0);
    return 0;
  }
  // Evalute (should not be necessary)
  if (get_real(m->instance, get_ptr(m->vr_out_), n_unknown, get_ptr(m->v_out_), n_unknown, m)) {
    casadi_warning("FMU evaluation failed");
    return 1;
  }
  // Evaluate directional derivatives
  m->n_get_directional++;
  auto start = std::chrono::high_resolution_clock::now();
  int flag = get_directional_derivative(m->instance,
    get_ptr(m->vr_out_), n_unknown, get_ptr(m->vr_in_), n_known,
    get_ptr(m->d_in_), n_known, get_ptr(m->d_out_), n_unknown);
  auto stop = std::chrono::high_resolution_clock::now();
  m->t_get_directional += std::chrono::duration_cast<std::chrono::microseconds>(
    stop - start).count() / 1e6;
  // Collect requested variables
  if (!flag) {
    auto it = m->d_out_.begin();
    for (size_t id : m->id_out_) {
      m->osens_[id] = *it++;
    }
  }
  // Return result of the evaluation
  return flag;
}

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

Referenced by eval_fwd().

eval_adj()

int casadi::FmuInternal::eval_adj

(

FmuMemory *

m

)

const

Definition at line 879 of file fmu.cpp.

                                            {
  // Gather input and output indices
  gather_adj(m);
  // Quick return if nothing to be calculated
  if (m->id_in_.size() == 0) return 0;
  // Check if no seeds
  int flag;
  if (m->id_out_.size() == 0) {
    // Sensitivities are zero, trivially
    std::fill(m->d_in_.begin(), m->d_in_.end(), 0);
    flag = 0;
  } else {
    // Evaluate adjoint derivatives
    m->n_get_adjoint++;
    auto start = std::chrono::high_resolution_clock::now();
    flag = get_adjoint_derivative(m->instance,
      get_ptr(m->vr_out_), m->id_out_.size(), get_ptr(m->vr_in_), m->id_in_.size(),
      get_ptr(m->d_out_), m->id_out_.size(), get_ptr(m->d_in_), m->id_in_.size());
    auto stop = std::chrono::high_resolution_clock::now();
    m->t_get_adjoint += std::chrono::duration_cast<std::chrono::microseconds>(
      stop - start).count() / 1e6;
  }
  // Collect requested variables
  if (!flag) {
    auto it = m->d_in_.begin();
    for (size_t id : m->id_in_) {
      m->isens_[id] = *it++;
    }
  }
  // Return results of the evaluation
  return flag;
}

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

eval_fd()

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

Definition at line 948 of file fmu.cpp.

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

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

Referenced by eval_fwd().

eval_fwd()

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

Definition at line 863 of file fmu.cpp.

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

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

virtual

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

Definition at line 593 of file fmu.cpp.

                           {
  warning_fired_discrete_states_need_update_ = false;
  warning_fired_terminate_simulation_ = false;
  warning_fired_nominals_of_continuous_states_changed_ = false;
  warning_fired_values_of_continuous_states_changed_ = false;
  warning_fired_next_event_time_defined_ = false;
  // 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();
 
  // 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 (!value_in_.empty()) {
    // Value references
    const unsigned int* vr = get_ptr(vr_in_);
    size_t n_vr = vr_in_.size();
    // Values
    double* value = get_ptr(value_in_);
    size_t n_value = value_in_.size();
    // Set time variable, if any
    if (has_independent_) {
      *value = start_time_;
      // Skip when getting remaining inputs
      vr++;
      n_vr--;
      value++;
      n_value--;
    }
    // Set remaining
    if (n_value > 0) {
      if (get_real(c, vr, n_vr, value, n_value)) {
        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 dll_suffix(), enter_initialization_mode(), free_instance(), get_aux(), casadi::get_ptr(), get_real(), has_independent_, instance_name_, instantiate(), li_, load_functions(), casadi::Resource::path(), resource_, set_values(), start_time_, system_infix(), value_in_, vr_in_, warning_fired_discrete_states_need_update_, warning_fired_next_event_time_defined_, warning_fired_nominals_of_continuous_states_changed_, warning_fired_terminate_simulation_, and warning_fired_values_of_continuous_states_changed_.

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

fmi3_dll_infix()

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

static

Definition at line 736 of file fmu.cpp.

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

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

free_instance()

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

pure virtual

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

Referenced by finalize().

free_mem()

virtual void casadi::FmuInternal::free_mem ( void *  mem ) const

pure virtual

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

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

gather_adj()

void casadi::FmuInternal::gather_adj

(

FmuMemory *

m

)

const

Definition at line 1520 of file fmu.cpp.

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

References casadi::FmuMemory::d_in_, casadi::FmuMemory::d_out_, 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 1504 of file fmu.cpp.

                                               {
  // Gather input and output indices
  gather_io(m);
  // Number of outputs
  size_t n_unknown = m->id_out_.size();
  // Get/clear seeds
  m->d_in_.clear();
  for (size_t id : m->id_in_) {
    m->d_in_.push_back(m->isens_[id]);
    m->isens_[id] = 0;
  }
  // Allocate result vectors
  m->v_out_.resize(n_unknown);
  m->d_out_.resize(n_unknown);
}

References casadi::FmuMemory::d_in_, casadi::FmuMemory::d_out_, 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 1477 of file fmu.cpp.

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

References casadi::FmuMemory::ibuf_, casadi::FmuMemory::id_in_, casadi::FmuMemory::id_out_, casadi::FmuMemory::imarked_, casadi::nan, casadi::FmuMemory::omarked_, casadi::FmuMemory::v_in_, casadi::FmuMemory::v_out_, casadi::FmuMemory::vr_in_, 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 1430 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 1232 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 1238 of file fmu.cpp.

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

References 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 586 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_all()

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

Definition at line 1400 of file fmu.cpp.

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

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

Referenced by eval(), and eval_fd().

get_aux()

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

pure virtual

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

Referenced by finalize().

get_derivatives()

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

pure virtual

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

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 1176 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 1182 of file fmu.cpp.

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

References 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, FmuMemory *  m = nullptr  ) const

pure virtual

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

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

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

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

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

index_in()

size_t casadi::FmuInternal::index_in

(

const std::string &

n

)

const

Definition at line 665 of file fmu.cpp.

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

References 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 675 of file fmu.cpp.

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

References 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 453 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->nzero_;
  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_;
  start_time_ = dae->start_time_;
  nx_ = dae->size(Category::X);
  do_evaluation_dance_ = dae->generation_tool_.rfind("Simulink", 0) == 0;
 
  // Mark input indices
  size_t numel = 0;
  std::vector<bool> lookup(dae->n_variables(), false);
  for (auto&& n : scheme_in_) {
    casadi_assert(scheme_.find(n) != scheme_.end(), "Unsupported input: '" + n + "'");
    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_) {
    casadi_assert(scheme_.find(n) != scheme_.end(), "Unsupported output: '" + n + "'");
    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 the first model variable");
      has_independent_ = true;
      independent_vr_ = vr_in_.back();
    }
  }
  // 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_);
 
  // Path to resource directory
  resource_loc_ = resource_.path();
  if (Filesystem::is_enabled()) resource_loc_ = Filesystem::absolute(resource_loc_);
  resource_loc_ += "/resources";
 
  // Use forward slashes (supported by all file systems)
  std::replace(resource_loc_.begin(), resource_loc_.end(), '\\', '/');
}

References casadi::Filesystem::absolute(), casadi::DaeBuilderInternal::can_be_instantiated_only_once_per_process_, can_be_instantiated_only_once_per_process_, casadi::Variable::causality, casadi::DaeBuilderInternal::debug_, do_evaluation_dance_, casadi::DaeBuilderInternal::fmutol_, fmutol_, casadi::DaeBuilderInternal::generation_tool_, has_independent_, hess_sp_, casadi::DaeBuilderInternal::hess_sparsity(), iind_, iind_map_, casadi::INDEPENDENT, independent_vr_, instance_name_, casadi::DaeBuilderInternal::instantiation_token_, instantiation_token_, ired_, casadi::Filesystem::is_enabled(), jac_sp_, casadi::DaeBuilderInternal::jac_sparsity(), logging_on_, casadi::Variable::max, max_in_, max_out_, casadi::Variable::min, min_in_, min_out_, casadi::DaeBuilderInternal::model_identifier_, casadi::DaeBuilderInternal::n_variables(), casadi::Variable::name, casadi::Variable::nominal, nominal_in_, nominal_out_, number_of_event_indicators_, nx_, casadi::DaeBuilderInternal::nzero_, oind_, oind_map_, ored_, casadi::Resource::path(), casadi::DaeBuilderInternal::provides_adjoint_derivatives_, provides_adjoint_derivatives_, casadi::DaeBuilderInternal::provides_directional_derivatives_, provides_directional_derivatives_, casadi::DaeBuilderInternal::resource_, resource_, resource_loc_, scheme_, scheme_in_, scheme_out_, casadi::DaeBuilderInternal::size(), casadi::DaeBuilderInternal::start_time_, start_time_, value_in_, casadi::Variable::value_reference, casadi::DaeBuilderInternal::variable(), vn_in_, vn_out_, vr_in_, vr_out_, and casadi::X.

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

init_mem()

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

virtual

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

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

Definition at line 1298 of file fmu.cpp.

                                            {
  // Ensure not already instantiated
  casadi_assert(m->instance == nullptr, "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_.

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

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

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

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

load_function()

template<typename T >

T * casadi::FmuInternal::load_function

(

const std::string &

symname

)

Definition at line 386 of file fmu_impl.hpp.

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

References casadi::Importer::get_function(), 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 130 of file fmu_impl.hpp.

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

{ return oind_.size();}

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

pack_fmu()

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

static

Definition at line 830 of file fmu.cpp.

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

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

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

request()

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

Definition at line 1363 of file fmu.cpp.

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

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

request_adj() [1/2]

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

Definition at line 1223 of file fmu.cpp.

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

References 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 1214 of file fmu.cpp.

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

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

Referenced by request_adj().

request_fwd() [1/2]

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

Definition at line 1468 of file fmu.cpp.

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

References 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 1459 of file fmu.cpp.

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

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

Referenced by request_fwd().

serialize()

void casadi::FmuInternal::serialize

(

SerializingStream &

s

)

const

Definition at line 1550 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::Fmu3, and casadi::Fmu2.

Definition at line 1559 of file fmu.cpp.

                                                           {
  s.version("FmuInternal", 4);
  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::has_independent", has_independent_);
  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_);
  s.pack("FmuInternal::start_time", start_time_);
  s.pack("FmuInternal::nx", nx_);
  s.pack("FmuInternal::do_evaluation_dance", do_evaluation_dance_);
}

References aux_, can_be_instantiated_only_once_per_process_, do_evaluation_dance_, fmutol_, has_independent_, 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_, nx_, oind_, oind_map_, ored_, casadi::SerializingStream::pack(), provides_adjoint_derivatives_, provides_directional_derivatives_, resource_, scheme_, scheme_in_, scheme_out_, start_time_, value_in_, casadi::SerializingStream::version(), vn_in_, vn_out_, vr_in_, and vr_out_.

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

serialize_type()

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

virtual

Definition at line 1555 of file fmu.cpp.

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

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

Referenced by serialize().

set()

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

Definition at line 1342 of file fmu.cpp.

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

References casadi::FmuMemory::ibuf_, casadi::FmuMemory::imarked_, and 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 1192 of file fmu.cpp.

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

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

Referenced by set_adj().

set_adj() [2/2]

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

Definition at line 1204 of file fmu.cpp.

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

References ored_, and set_adj().

set_all()

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

Definition at line 1372 of file fmu.cpp.

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

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

Referenced by eval(), and eval_fd().

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

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

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

Referenced by set_fwd().

set_fwd() [2/2]

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

Definition at line 1449 of file fmu.cpp.

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

References 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 set_all().

set_time()

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

pure virtual

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

Referenced by set_all().

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.

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

Friends And Related Function Documentation

Fmu

friend class Fmu

friend

Definition at line 62 of file fmu_impl.hpp.

Member Data Documentation

aux_

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

protected

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

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

do_evaluation_dance_

bool casadi::FmuInternal::do_evaluation_dance_

protected

Definition at line 382 of file fmu_impl.hpp.

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

fmutol_

double casadi::FmuInternal::fmutol_

protected

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

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

hess_sp_

Sparsity casadi::FmuInternal::hess_sp_

protected

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

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

independent_vr_

unsigned int casadi::FmuInternal::independent_vr_

protected

Definition at line 356 of file fmu_impl.hpp.

Referenced by init(), and set_all().

instance_name_

std::string casadi::FmuInternal::instance_name_

protected

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

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

li_

Importer casadi::FmuInternal::li_

protected

Definition at line 347 of file fmu_impl.hpp.

Referenced by finalize(), and load_function().

logging_on_

bool casadi::FmuInternal::logging_on_

protected

Definition at line 332 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 361 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 361 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 360 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 360 of file fmu_impl.hpp.

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

name_

std::string casadi::FmuInternal::name_

protected

Definition at line 310 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 359 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 359 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 335 of file fmu_impl.hpp.

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

nx_

size_t casadi::FmuInternal::nx_

protected

Definition at line 380 of file fmu_impl.hpp.

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

oind_

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

protected

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

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

scheme_

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

protected

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

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

start_time_

double casadi::FmuInternal::start_time_

protected

Definition at line 344 of file fmu_impl.hpp.

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

value_in_

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

protected

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

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

warning_fired_discrete_states_need_update_

bool casadi::FmuInternal::warning_fired_discrete_states_need_update_

mutableprotected

Definition at line 374 of file fmu_impl.hpp.

Referenced by discrete_states_iter(), and finalize().

warning_fired_next_event_time_defined_

bool casadi::FmuInternal::warning_fired_next_event_time_defined_

mutableprotected

Definition at line 378 of file fmu_impl.hpp.

Referenced by discrete_states_iter(), and finalize().

warning_fired_nominals_of_continuous_states_changed_

bool casadi::FmuInternal::warning_fired_nominals_of_continuous_states_changed_

mutableprotected

Definition at line 376 of file fmu_impl.hpp.

Referenced by discrete_states_iter(), and finalize().

warning_fired_terminate_simulation_

bool casadi::FmuInternal::warning_fired_terminate_simulation_

mutableprotected

Definition at line 375 of file fmu_impl.hpp.

Referenced by discrete_states_iter(), and finalize().

warning_fired_values_of_continuous_states_changed_

bool casadi::FmuInternal::warning_fired_values_of_continuous_states_changed_

mutableprotected

Definition at line 377 of file fmu_impl.hpp.

Referenced by discrete_states_iter(), and finalize().

---

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

• fmu_impl.hpp
• fmu.cpp