List of all members | Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Friends
casadi::FmuInternal Class Referenceabstract

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:
Inheritance graph
[legend]
Collaboration diagram for casadi::FmuInternal:
Collaboration graph
[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 get_derivatives (void *instance, double *derivatives, size_t nx) 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
 
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 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_
 
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 440 of file fmu.cpp.

445  : name_(name), scheme_in_(scheme_in), scheme_out_(scheme_out), scheme_(scheme), aux_(aux) {
446 }
casadi::FmuInternal::scheme_out_
std::vector< std::string > scheme_out_
Definition: fmu_impl.hpp:290
casadi::FmuInternal::name_
std::string name_
Instance name.
Definition: fmu_impl.hpp:287
casadi::FmuInternal::aux_
std::vector< std::string > aux_
Definition: fmu_impl.hpp:294
casadi::FmuInternal::scheme_
std::map< std::string, std::vector< size_t > > scheme_
Definition: fmu_impl.hpp:291
casadi::FmuInternal::scheme_in_
std::vector< std::string > scheme_in_
Definition: fmu_impl.hpp:290

◆ ~FmuInternal()

casadi::FmuInternal::~FmuInternal ( )
override

Definition at line 448 of file fmu.cpp.

448  {
449 }

◆ FmuInternal() [2/2]

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

Definition at line 1423 of file fmu.cpp.

1423  {
1424  s.version("FmuInternal", 4);
1425  s.unpack("FmuInternal::name", name_);
1426  s.unpack("FmuInternal::scheme_in", scheme_in_);
1427  s.unpack("FmuInternal::scheme_out", scheme_out_);
1428  s.unpack("FmuInternal::scheme", scheme_);
1429  s.unpack("FmuInternal::aux", aux_);
1430  s.unpack("FmuInternal::iind", iind_);
1431  s.unpack("FmuInternal::iind_map", iind_map_);
1432  s.unpack("FmuInternal::oind", oind_);
1433  s.unpack("FmuInternal::oind_map", oind_map_);
1434  s.unpack("FmuInternal::has_independent", has_independent_);
1435  s.unpack("FmuInternal::nominal_in", nominal_in_);
1436  s.unpack("FmuInternal::nominal_out", nominal_out_);
1437  s.unpack("FmuInternal::min_in", min_in_);
1438  s.unpack("FmuInternal::min_out", min_out_);
1439  s.unpack("FmuInternal::max_in", max_in_);
1440  s.unpack("FmuInternal::max_out", max_out_);
1441  s.unpack("FmuInternal::vn_in", vn_in_);
1442  s.unpack("FmuInternal::vn_out", vn_out_);
1443  s.unpack("FmuInternal::vr_in", vr_in_);
1444  s.unpack("FmuInternal::vr_out", vr_out_);
1445 
1446  s.unpack("FmuInternal::value_in", value_in_);
1447  s.unpack("FmuInternal::ired", ired_);
1448  s.unpack("FmuInternal::ored", ored_);
1449  s.unpack("FmuInternal::jac_sp", jac_sp_);
1450  s.unpack("FmuInternal::hess_sp", hess_sp_);
1451 
1452  s.unpack("FmuInternal::resource", resource_);
1453  s.unpack("FmuInternal::fmutol", fmutol_);
1454  s.unpack("FmuInternal::instance_name", instance_name_);
1455  s.unpack("FmuInternal::instantiation_token", instantiation_token_);
1456  s.unpack("FmuInternal::logging_on", logging_on_);
1457  s.unpack("FmuInternal::number_of_event_indicators", number_of_event_indicators_);
1458  s.unpack("FmuInternal::provides_directional_derivatives", provides_directional_derivatives_);
1459  s.unpack("FmuInternal::provides_adjoint_derivatives", provides_adjoint_derivatives_);
1460  s.unpack("FmuInternal::can_be_instantiated_only_once_per_process",
1461  can_be_instantiated_only_once_per_process_);
1462  s.unpack("FmuInternal::nx", nx_);
1463  s.unpack("FmuInternal::do_evaluation_dance", do_evaluation_dance_);
1464 }
casadi::FmuInternal::instantiation_token_
std::string instantiation_token_
Definition: fmu_impl.hpp:306
casadi::FmuInternal::max_in_
std::vector< double > max_in_
Definition: fmu_impl.hpp:332
casadi::FmuInternal::provides_adjoint_derivatives_
bool provides_adjoint_derivatives_
Definition: fmu_impl.hpp:315
casadi::FmuInternal::vr_out_
std::vector< unsigned int > vr_out_
Definition: fmu_impl.hpp:334
casadi::FmuInternal::vn_out_
std::vector< std::string > vn_out_
Definition: fmu_impl.hpp:333
casadi::FmuInternal::iind_
std::vector< size_t > iind_
Definition: fmu_impl.hpp:324
casadi::FmuInternal::ired_
std::vector< std::vector< size_t > > ired_
Definition: fmu_impl.hpp:340
casadi::FmuInternal::ored_
std::vector< std::vector< size_t > > ored_
Definition: fmu_impl.hpp:340
casadi::FmuInternal::nominal_out_
std::vector< double > nominal_out_
Definition: fmu_impl.hpp:330
casadi::FmuInternal::vn_in_
std::vector< std::string > vn_in_
Definition: fmu_impl.hpp:333
casadi::FmuInternal::oind_
std::vector< size_t > oind_
Definition: fmu_impl.hpp:324
casadi::FmuInternal::vr_in_
std::vector< unsigned int > vr_in_
Definition: fmu_impl.hpp:334
casadi::FmuInternal::min_out_
std::vector< double > min_out_
Definition: fmu_impl.hpp:331
casadi::FmuInternal::can_be_instantiated_only_once_per_process_
bool can_be_instantiated_only_once_per_process_
Definition: fmu_impl.hpp:318
casadi::FmuInternal::nominal_in_
std::vector< double > nominal_in_
Definition: fmu_impl.hpp:330
casadi::FmuInternal::max_out_
std::vector< double > max_out_
Definition: fmu_impl.hpp:332
casadi::FmuInternal::min_in_
std::vector< double > min_in_
Definition: fmu_impl.hpp:331
casadi::FmuInternal::value_in_
std::vector< double > value_in_
Definition: fmu_impl.hpp:337
casadi::FmuInternal::number_of_event_indicators_
casadi_int number_of_event_indicators_
Definition: fmu_impl.hpp:312
casadi::FmuInternal::oind_map_
std::vector< size_t > oind_map_
Definition: fmu_impl.hpp:324
casadi::FmuInternal::instance_name_
std::string instance_name_
Definition: fmu_impl.hpp:303
casadi::FmuInternal::provides_directional_derivatives_
bool provides_directional_derivatives_
Definition: fmu_impl.hpp:315
casadi::FmuInternal::iind_map_
std::vector< size_t > iind_map_
Definition: fmu_impl.hpp:324

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_, 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 687 of file fmu.cpp.

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

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

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

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

Referenced by casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::call_reverse(), casadi::FunctionInternal::codegen_body(), casadi::ProtoFunction::construct(), deserialize(), casadi::ResourceInternal::deserialize(), 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::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::oracle(), casadi::XmlFileInternal::parse(), casadi::LinsolInternal::rank(), serialize_type(), casadi::ResourceInternal::serialize_type(), and casadi::LinsolInternal::solve().

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

162  {
163  // Note: i != this because of something something multiple inheritance
164  return str( (casadi_int)(i)) + "/" + static_cast<const Internal*>(this)->class_name();
165  }
casadi::str
std::string str(const T &v)
String representation, any type.
Definition: casadi_common.hpp:247

◆ desc_in()

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

Definition at line 716 of file fmu.cpp.

716  {
717  // Create description
718  if (more) {
719  // Detailed description
720  std::stringstream ss;
721  ss << vn_in_[id] << " = " << m->ibuf_[id] << " (nominal " << nominal_in_[id]
722  << ", min " << min_in_[id] << ", max " << max_in_[id] << ")";
723  return ss.str();
724  } else {
725  return vn_in_[id];
726  }
727 }

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

1466  {
1467  std::string class_name;
1468  s.unpack("FmuInternal::type", class_name);
1469  if (class_name=="Fmu2") {
1470 #ifdef WITH_FMI2
1471  return Fmu2::deserialize(s);
1472 #else
1473  casadi_error("CasADi was not compiled with WITH_FMI2=ON.");
1474 #endif // WITH_FMI2
1475  } else if (class_name=="Fmu3") {
1476 #ifdef WITH_FMI3
1477 return Fmu3::deserialize(s);
1478 #else
1479  casadi_error("CasADi was not compiled with WITH_FMI2=ON.");
1480 #endif // WITH_FMI3
1481  } else {
1482  casadi_error("Cannot deserialize type '" + class_name + "'");
1483  }
1484 }
casadi::Fmu2::deserialize
static Fmu2 * deserialize(DeserializingStream &s)
Definition: fmu2.cpp:538
casadi::Fmu3::deserialize
static Fmu3 * deserialize(DeserializingStream &s)
Definition: fmu3.cpp:522
casadi::SharedObjectInternal::class_name
virtual std::string class_name() const =0
Readable name of the internal class.

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.

77  {
78  static_cast<Internal*>(this)->count--;
79  }

◆ discrete_states_iter()

int casadi::FmuInternal::discrete_states_iter ( void *  instance) const

Definition at line 1098 of file fmu.cpp.

1098  {
1099  // Helper function: update_discrete_states
1100  EventMemory eventmem;
1101  const size_t max_update_iter = 10;
1102  for (size_t update_iter = 0; update_iter < max_update_iter; ++update_iter) {
1103  if (update_discrete_states(instance, &eventmem)) {
1104  casadi_warning("update_discrete_states");
1105  return 1;
1106  }
1107  // Not implemented
1108  if (eventmem.discrete_states_need_update) {
1109  if (!warning_fired_discrete_states_need_update_) {
1110  warning_fired_discrete_states_need_update_ = true;
1111  casadi_warning("Discrete state update not implemented");
1112  }
1113  }
1114  if (eventmem.terminate_simulation) {
1115  if (!warning_fired_terminate_simulation_) {
1116  warning_fired_terminate_simulation_ = true;
1117  casadi_warning("Terminate simulation not implemented");
1118  }
1119  }
1120  if (eventmem.nominals_of_continuous_states_changed) {
1121  if (!warning_fired_nominals_of_continuous_states_changed_) {
1122  warning_fired_nominals_of_continuous_states_changed_ = true;
1123  casadi_warning("Nominals of continuous states not implemented");
1124  }
1125  }
1126  if (eventmem.values_of_continuous_states_changed) {
1127  if (!warning_fired_values_of_continuous_states_changed_) {
1128  warning_fired_values_of_continuous_states_changed_ = true;
1129  casadi_warning("Values of continuous states not implemented");
1130  }
1131  }
1132  if (eventmem.next_event_time_defined) {
1133  if (!warning_fired_next_event_time_defined_) {
1134  warning_fired_next_event_time_defined_ = true;
1135  casadi_warning("Next event time not implemented");
1136  }
1137  }
1138  // Successful return
1139  if (!eventmem.discrete_states_need_update) {
1140  return 0;
1141  }
1142  }
1143  // Too many iterations
1144  casadi_warning("Discrete state update failed");
1145  return 1;
1146 }
casadi::FmuInternal::warning_fired_values_of_continuous_states_changed_
bool warning_fired_values_of_continuous_states_changed_
Definition: fmu_impl.hpp:348
casadi::FmuInternal::warning_fired_next_event_time_defined_
bool warning_fired_next_event_time_defined_
Definition: fmu_impl.hpp:349
casadi::FmuInternal::warning_fired_nominals_of_continuous_states_changed_
bool warning_fired_nominals_of_continuous_states_changed_
Definition: fmu_impl.hpp:347
casadi::FmuInternal::warning_fired_terminate_simulation_
bool warning_fired_terminate_simulation_
Definition: fmu_impl.hpp:346
casadi::FmuInternal::warning_fired_discrete_states_need_update_
bool warning_fired_discrete_states_need_update_
Definition: fmu_impl.hpp:345
casadi::FmuInternal::update_discrete_states
virtual int update_discrete_states(void *instance, EventMemory *eventmem) const =0

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

631  {
632  (void)more; // unused
633  stream << name_ << " " << class_name();
634 }

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

◆ dll_suffix()

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

Definition at line 703 of file fmu.cpp.

703  {
704 #if defined(_WIN32)
705  // Windows system
706  return ".dll";
707 #elif defined(__APPLE__)
708  // OSX
709  return ".dylib";
710 #else
711  // Linux
712  return ".so";
713 #endif
714 }

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

1222  {
1223  // Gather inputs and outputs
1224  gather_io(m);
1225  // Number of inputs and outputs
1226  size_t n_set = m->id_in_.size();
1227  size_t n_out = m->id_out_.size();
1228  // Set all variables
1229  if (set_real(m->instance, get_ptr(m->vr_in_), n_set, get_ptr(m->v_in_), n_set)) {
1230  casadi_warning("Setting FMU variables failed");
1231  return 1;
1232  }
1233  // Quick return if nothing requested
1234  if (n_out == 0) return 0;
1235  // Calculate all variables
1236  m->v_out_.resize(n_out);
1237  if (get_real(m->instance, get_ptr(m->vr_out_), n_out, get_ptr(m->v_out_), n_out)) {
1238  casadi_warning("Evaluation failed");
1239  return 1;
1240  }
1241  // Collect requested variables
1242  auto it = m->v_out_.begin();
1243  for (size_t id : m->id_out_) {
1244  m->obuf_[id] = *it++;
1245  }
1246  // Successful return
1247  return 0;
1248 }
casadi::FmuInternal::get_real
virtual int get_real(void *instance, const unsigned int *vr, size_t n_vr, double *values, size_t n_values) const =0
casadi::FmuInternal::gather_io
void gather_io(FmuMemory *m) const
Definition: fmu.cpp:1294
casadi::FmuInternal::set_real
virtual int set_real(void *instance, const unsigned int *vr, size_t n_vr, const double *values, size_t n_values) const =0
casadi::FmuInternal::n_out
size_t n_out() const
Get the number of scheme outputs.
Definition: fmu_impl.hpp:132
casadi::get_ptr
T * get_ptr(std::vector< T > &v)
Get a pointer to the data contained in the vector.
Definition: casadi_misc.hpp:871

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

768  {
769  // Number of inputs and outputs
770  size_t n_known = m->id_in_.size();
771  size_t n_unknown = m->id_out_.size();
772  // Quick return if nothing to be calculated
773  if (n_unknown == 0) return 0;
774  // Evalute (should not be necessary)
775  if (get_real(m->instance, get_ptr(m->vr_out_), n_unknown, get_ptr(m->v_out_), n_unknown)) {
776  casadi_warning("FMU evaluation failed");
777  return 1;
778  }
779  // Evaluate directional derivatives
780  if (get_directional_derivative(m->instance,
781  get_ptr(m->vr_out_), n_unknown,
782  get_ptr(m->vr_in_), n_known,
783  get_ptr(m->d_in_), n_known,
784  get_ptr(m->d_out_), n_unknown)) {
785  casadi_warning("FMU directional derivative failed");
786  return 1;
787  }
788  // Collect requested variables
789  auto it = m->d_out_.begin();
790  for (size_t id : m->id_out_) {
791  m->osens_[id] = *it++;
792  }
793  // Successful return
794  return 0;
795 }
casadi::FmuInternal::get_directional_derivative
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

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

745  {
746  // Gather input and output indices
747  gather_adj(m);
748  // Quick return if nothing to be calculated
749  if (m->id_in_.size() == 0) return 0;
750  // Evaluate adjoint derivatives
751  if (get_adjoint_derivative(m->instance,
752  get_ptr(m->vr_out_), m->id_out_.size(),
753  get_ptr(m->vr_in_), m->id_in_.size(),
754  get_ptr(m->d_out_), m->id_out_.size(),
755  get_ptr(m->d_in_), m->id_in_.size())) {
756  casadi_warning("FMU adjoint derivative failed");
757  return 1;
758  }
759  // Collect requested variables
760  auto it = m->d_in_.begin();
761  for (size_t id : m->id_in_) {
762  m->isens_[id] = *it++;
763  }
764  // Successful return
765  return 0;
766 }
casadi::FmuInternal::get_adjoint_derivative
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
Definition: fmu.cpp:572
casadi::FmuInternal::gather_adj
void gather_adj(FmuMemory *m) const
Definition: fmu.cpp:1338

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

797  {
798  // Number of inputs and outputs
799  size_t n_known = m->id_in_.size();
800  size_t n_unknown = m->id_out_.size();
801  // Quick return if nothing to be calculated
802  if (n_unknown == 0) return 0;
803  // Evalute (should not be necessary)
804  if (get_real(m->instance, get_ptr(m->vr_out_), n_unknown, get_ptr(m->v_out_), n_unknown)) {
805  casadi_warning("Evaluating FMU failed");
806  return 1;
807  }
808  // Make outputs dimensionless
809  for (size_t k = 0; k < n_unknown; ++k) m->v_out_[k] /= nominal_out_[m->id_out_[k]];
810  // Number of points in FD stencil
811  casadi_int n_points = n_fd_points(m->self.fd_);
812  // Offset for points
813  casadi_int offset = fd_offset(m->self.fd_);
814  // Memory for perturbed outputs
815  m->fd_out_.resize(n_points * n_unknown);
816  // Which inputs are in bounds
817  m->in_bounds_.resize(n_known);
818  // Memory for perturbed inputs
819  m->v_pert_.resize(n_known);
820  // Do any any inputs need flipping?
821  m->flip_.resize(n_known);
822  size_t first_flip = -1;
823  for (size_t i = 0; i < n_known; ++i) {
824  // Try to take step
825  double test = m->v_in_[i] + m->self.step_ * m->d_in_[i];
826  // Check if in bounds
827  size_t id = m->id_in_[i];
828  if (test >= min_in_[id] && test <= max_in_[id]) {
829  // Positive perturbation is fine
830  m->flip_[i] = false;
831  } else {
832  // Try negative direction instead
833  test = m->v_in_[i] - m->self.step_ * m->d_in_[i];
834  casadi_assert(test >= min_in_[id] && test <= max_in_[id],
835  "Cannot perturb " + vn_in_[id] + " at " + str(m->v_in_[i]) + ", min " + str(min_in_[id])
836  + ", max " + str(max_in_[id]) + ", nominal " + str(nominal_in_[id]));
837  m->flip_[i] = true;
838  if (first_flip == size_t(-1)) first_flip = i;
839  }
840  }
841  // If seeds are not independent, we have to flip the sign for all of the seeds or none
842  if (first_flip != size_t(-1) && !independent_seeds) {
843  // Flip the rest of the seeds
844  for (size_t i = 0; i < n_known; ++i) {
845  if (!m->flip_[i]) {
846  // Test negative direction
847  double test = m->v_in_[i] - m->self.step_ * m->d_in_[i];
848  size_t id = m->id_in_[i];
849  casadi_assert(test >= min_in_[id] && test <= max_in_[id],
850  "Cannot perturb both " + vn_in_[id] + " and " + vn_in_[first_flip]);
851  // Flip it too
852  m->flip_[i] = true;
853  }
854  }
855  }
856  // All perturbed outputs
857  const double* yk_all[5] = {0};
858 
859  // Calculate all perturbed outputs
860  for (casadi_int k = 0; k < n_points; ++k) {
861  // Where to save the perturbed outputs
862  double* yk = &m->fd_out_[n_unknown * k];
863  casadi_assert_dev(k < 5);
864  yk_all[k] = yk;
865  // If unperturbed output, quick return
866  if (k == offset) {
867  casadi_copy(get_ptr(m->v_out_), n_unknown, yk);
868  continue;
869  }
870  // Perturbation size
871  double pert = (k - offset) * m->self.step_;
872  // Perturb inputs, if allowed
873  for (size_t i = 0; i < n_known; ++i) {
874  // Try to take step
875  double sign = m->flip_[i] ? -1 : 1;
876  double test = m->v_in_[i] + pert * sign * m->d_in_[i];
877  // Check if in bounds
878  size_t id = m->id_in_[i];
879  m->in_bounds_[i] = test >= min_in_[id] && test <= max_in_[id];
880  // Take step, if allowed
881  m->v_pert_[i] = m->in_bounds_[i] ? test : m->v_in_[i];
882  }
883  // Pass perturbed inputs to FMU
884  if (set_real(m->instance, get_ptr(m->vr_in_), n_known, get_ptr(m->v_pert_), n_known)) {
885  casadi_warning("Setting FMU variables failed");
886  return 1;
887  }
888  // Evaluate perturbed FMU
889  if (get_real(m->instance, get_ptr(m->vr_out_), n_unknown, yk, n_unknown)) {
890  casadi_warning("Evaluation failed");
891  return 1;
892  }
893  // Post-process yk if there was any scaling
894  if (independent_seeds) {
895  for (size_t i = 0; i < n_unknown; ++i) {
896  // Variable id
897  size_t id = m->id_out_[i];
898  // Differentiation with respect to what variable
899  size_t wrt_id = m->wrt_.at(id);
900  // Find the corresponding input variable
901  size_t wrt_i;
902  for (wrt_i = 0; wrt_i < n_known; ++wrt_i) {
903  if (m->id_in_[wrt_i] == wrt_id) break;
904  }
905  // Check if in bounds
906  if (m->in_bounds_.at(wrt_i)) {
907  // Input was in bounds: Keep output, make dimensionless
908  yk[i] /= nominal_out_[m->id_out_[i]];
909  } else {
910  // Input was out of bounds: Discard output
911  yk[i] = nan;
912  }
913  }
914  }
915  }
916  // Restore FMU inputs
917  if (set_real(m->instance, get_ptr(m->vr_in_), n_known, get_ptr(m->v_in_), n_known)) {
918  casadi_warning("Setting FMU variables failed");
919  return 1;
920  }
921  // Step size
922  double h = m->self.step_;
923 
924  // Calculate FD approximation
925  finite_diff(m->self.fd_, yk_all, get_ptr(m->d_out_), h, n_unknown, eps);
926 
927  // If seeds are dependent, quick return
928  if (!independent_seeds) {
929  // Simpy copy the results to output (no validation)
930  for (size_t ind = 0; ind < m->id_out_.size(); ++ind) {
931  m->osens_[m->id_out_[ind]] = m->d_out_[ind];
932  }
933  return 0;
934  }
935 
936  // Collect requested variables
937  for (size_t ind = 0; ind < m->id_out_.size(); ++ind) {
938  // Variable id
939  size_t id = m->id_out_[ind];
940  // With respect to what variable
941  size_t wrt = m->wrt_[id];
942  // Find the corresponding input variable
943  size_t wrt_i;
944  for (wrt_i = 0; wrt_i < n_known; ++wrt_i) {
945  if (m->id_in_[wrt_i] == wrt) break;
946  }
947  // Nominal value
948  double n = nominal_out_[id];
949  // Get the value
950  double d_fd = m->d_out_[ind] * n;
951  // Correct sign, if necessary
952  if (m->flip_[wrt_i]) d_fd = -d_fd;
953  // Use FD instead of AD or to compare with AD
954  if (m->self.validate_forward_) {
955  // Value to compare with
956  double d_ad = m->osens_[id];
957  // Nominal value used as seed
958  d_ad /= nominal_in_[wrt];
959  d_fd /= nominal_in_[wrt];
960  // Is it a not a number?
961  bool d_is_nan = d_ad != d_ad;
962  // Magnitude of derivatives
963  double d_max = std::fmax(std::fabs(d_fd), std::fabs(d_ad));
964  // Check if NaN or error exceeds thresholds
965  if (d_is_nan || (d_max > n * m->self.abstol_
966  && std::fabs(d_ad - d_fd) > d_max * m->self.reltol_)) {
967  // Offset for printing the stencil
968  double off = m->fd_out_.at(ind + offset * n_unknown);
969  // Warning or add to file
970  std::stringstream ss;
971  if (m->self.validate_ad_file_.empty()) {
972  // Issue warning
973  ss << (d_is_nan ? "NaN" : "Inconsistent") << " derivatives of " << vn_out_[id]
974  << " w.r.t. " << desc_in(m, wrt) << ", got " << d_ad
975  << " for AD vs. " << d_fd << " for FD[" << to_string(m->self.fd_) << "].";
976  // Print the stencil:
977  ss << "\nValues for step size " << h << ": " << (n * off) << " + [";
978  for (casadi_int k = 0; k < n_points; ++k) {
979  if (k > 0) ss << ", ";
980  ss << (n * (m->fd_out_.at(ind + k * n_unknown) - off));
981  }
982  ss << "]";
983  // Issue warning
984  casadi_warning(ss.str());
985  } else {
986  // Output
987  ss << vn_out_[id] << " ";
988  // Input
989  ss << vn_in_[wrt] << " ";
990  // Value
991  ss << m->ibuf_[wrt] << " ";
992  // Noninal
993  ss << nominal_in_[wrt] << " ";
994  // Min
995  ss << min_in_[wrt] << " ";
996  // Max
997  ss << max_in_[wrt] << " ";
998  // AD
999  ss << d_ad << " ";
1000  // FD
1001  ss << d_fd << " ";
1002  // Step
1003  ss << h << " ";
1004  // Offset
1005  ss << off << " ";
1006  // Stencil
1007  ss << "[";
1008  for (casadi_int k = 0; k < n_points; ++k) {
1009  if (k > 0) ss << ",";
1010  ss << (n * (m->fd_out_.at(ind + k * n_unknown) - off));
1011  }
1012  ss << "]" << std::endl;
1013  // Append to file
1014  auto valfile_ptr = Filesystem::ofstream_ptr(m->self.validate_ad_file_,
1015  std::ios_base::app);
1016  std::ostream& valfile = *valfile_ptr;
1017  valfile << ss.str();
1018  }
1019  }
1020  } else {
1021  // Use instead of AD
1022  m->osens_[id] = d_fd;
1023  }
1024  }
1025  // Successful return
1026  return 0;
1027 }
casadi::Filesystem::ofstream_ptr
static std::unique_ptr< std::ostream > ofstream_ptr(const std::string &path, std::ios_base::openmode mode=std::ios_base::out)
Definition: filesystem.cpp:115
casadi::FmuInternal::desc_in
std::string desc_in(FmuMemory *m, size_t id, bool more=true) const
Definition: fmu.cpp:716
casadi::eps
const double eps
Machine epsilon.
Definition: calculus.hpp:56
casadi::n_fd_points
casadi_int n_fd_points(FdMode v)
Length of FD stencil, including unperturbed input.
Definition: finite_differences.cpp:41
casadi::fd_offset
casadi_int fd_offset(FdMode v)
Offset for FD stencil, i.e. index of unperturbed input.
Definition: finite_differences.cpp:52
casadi::sign
double sign(double x)
Sign function, note that sign(nan) == nan.
Definition: calculus.hpp:264
casadi::casadi_copy
void casadi_copy(const T1 *x, casadi_int n, T1 *y)
COPY: y <-x.
casadi::to_string
std::string to_string(TypeFmi2 v)
Definition: dae_builder_internal.cpp:94
casadi::nan
const double nan
Not a number.
Definition: calculus.hpp:53
casadi::finite_diff
CASADI_EXPORT void finite_diff(FdMode v, const T1 **yk, T1 *J, T1 h, casadi_int n_y, T1 smoothing)
Calculate FD estimate.
Definition: finite_differences.hpp:49

References casadi::FmuFunction::abstol_, casadi::casadi_copy(), casadi::FmuMemory::d_in_, casadi::FmuMemory::d_out_, desc_in(), casadi::eps, casadi::FmuFunction::fd_, casadi::fd_offset(), casadi::FmuMemory::fd_out_, casadi::finite_diff(), casadi::FmuMemory::flip_, 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_real(), 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_in_, 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 729 of file fmu.cpp.

729  {
730  // Gather input and output indices
731  gather_fwd(m);
732  // Calculate derivatives using FMU directional derivative support
733  if (m->self.uses_directional_derivatives_) {
734  // Evaluate using AD
735  if (eval_ad(m)) return 1;
736  }
737  // Calculate derivatives using finite differences
738  if (!m->self.uses_directional_derivatives_ || m->self.validate_forward_) {
739  // Evaluate using FD
740  if (eval_fd(m, independent_seeds)) return 1;
741  }
742  return 0;
743 }
casadi::FmuInternal::gather_fwd
void gather_fwd(FmuMemory *m) const
Definition: fmu.cpp:1319
casadi::FmuInternal::eval_fd
int eval_fd(FmuMemory *m, bool independent_seeds) const
Definition: fmu.cpp:797
casadi::FmuInternal::eval_ad
int eval_ad(FmuMemory *m) const
Definition: fmu.cpp:768

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

579  {
580  warning_fired_discrete_states_need_update_ = false;
581  warning_fired_terminate_simulation_ = false;
582  warning_fired_nominals_of_continuous_states_changed_ = false;
583  warning_fired_values_of_continuous_states_changed_ = false;
584  warning_fired_next_event_time_defined_ = false;
585  // Load DLL
586  std::string instance_name_no_dot = instance_name_;
587  std::replace(instance_name_no_dot.begin(), instance_name_no_dot.end(), '.', '_');
588  std::string dll_path = resource_.path() + "/binaries/" + system_infix()
589  + "/" + instance_name_no_dot + dll_suffix();
590  li_ = Importer(dll_path, "dll");
591 
592  // Get FMI C functions
593  load_functions();
594 
595  // Path to resource directory
596  std::string url = "";
597  if (Filesystem::is_enabled()) {
598  url = "file://" + Filesystem::absolute(resource_.path()) + "/resources";
599  } else {
600  url = "file://" + resource_.path() + "/resources";
601  }
602  // Forward slashes
603  std::replace(url.begin(), url.end(), '\\', '/');
604 
605  resource_loc_ = url;
606 
607  // Create a temporary instance
608  void* c = instantiate();
609  // Set all values
610  if (set_values(c)) {
611  casadi_error("FmuInternal::set_values failed");
612  }
613  // Initialization mode begins
614  if (enter_initialization_mode(c)) {
615  casadi_error("FmuInternal::enter_initialization_mode failed");
616  }
617  // Get input values
618  if (!value_in_.empty()) {
619  if (get_real(c, get_ptr(vr_in_), vr_in_.size(), get_ptr(value_in_), value_in_.size())) {
620  casadi_error("FmuInternal::get_in failed");
621  }
622  }
623  // Get auxilliary variables
624  if (get_aux(c)) {
625  casadi_error("FmuInternal::get_aux failed");
626  }
627  // Free memory
628  free_instance(c);
629 }
casadi::Filesystem::absolute
static std::string absolute(const std::string &path)
Definition: filesystem.cpp:78
casadi::Filesystem::is_enabled
static bool is_enabled()
Definition: filesystem.cpp:83
casadi::FmuInternal::free_instance
virtual void free_instance(void *c) const =0
casadi::FmuInternal::get_aux
virtual int get_aux(void *instance)=0
casadi::FmuInternal::load_functions
virtual void load_functions()=0
casadi::FmuInternal::instantiate
virtual void * instantiate() const =0
casadi::FmuInternal::set_values
virtual int set_values(void *instance) const =0
casadi::FmuInternal::resource_loc_
std::string resource_loc_
Definition: fmu_impl.hpp:297
casadi::FmuInternal::dll_suffix
static std::string dll_suffix()
Definition: fmu.cpp:703
casadi::FmuInternal::li_
Importer li_
DLL.
Definition: fmu_impl.hpp:321
casadi::FmuInternal::enter_initialization_mode
virtual int enter_initialization_mode(void *instance) const =0
casadi::FmuInternal::system_infix
virtual std::string system_infix() const =0
casadi::Resource::path
const std::string & path() const
Get path for a consumer.
Definition: resource.cpp:70

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

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

1338  {
1339  // Gather input and output indices
1340  gather_io(m);
1341  // Number of inputs and outputs
1342  size_t n_known = m->id_in_.size();
1343  size_t n_unknown = m->id_out_.size();
1344  // Get/clear seeds
1345  m->d_out_.clear();
1346  for (size_t id : m->id_out_) {
1347  m->d_out_.push_back(m->osens_[id]);
1348  m->osens_[id] = 0;
1349  }
1350  // Ensure at least one seed
1351  casadi_assert(n_unknown != 0, "No seeds");
1352  // Allocate result vectors
1353  m->v_in_.resize(n_known);
1354  m->d_in_.resize(n_known);
1355 }

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

1319  {
1320  // Gather input and output indices
1321  gather_io(m);
1322  // Number of inputs and outputs
1323  size_t n_known = m->id_in_.size();
1324  size_t n_unknown = m->id_out_.size();
1325  // Get/clear seeds
1326  m->d_in_.clear();
1327  for (size_t id : m->id_in_) {
1328  m->d_in_.push_back(m->isens_[id]);
1329  m->isens_[id] = 0;
1330  }
1331  // Ensure at least one seed
1332  casadi_assert(n_known != 0, "No seeds");
1333  // Allocate result vectors
1334  m->v_out_.resize(n_unknown);
1335  m->d_out_.resize(n_unknown);
1336 }

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

1294  {
1295  // Collect input indices and corresponding value references and values
1296  m->id_in_.clear();
1297  m->vr_in_.clear();
1298  m->v_in_.clear();
1299  for (size_t id = 0; id < m->imarked_.size(); ++id) {
1300  if (m->imarked_[id]) {
1301  m->id_in_.push_back(id);
1302  m->vr_in_.push_back(vr_in_[id]);
1303  m->v_in_.push_back(m->ibuf_[id]);
1304  m->imarked_[id] = false;
1305  }
1306  }
1307  // Collect output indices, corresponding value references
1308  m->id_out_.clear();
1309  m->vr_out_.clear();
1310  for (size_t id = 0; id < m->omarked_.size(); ++id) {
1311  if (m->omarked_[id]) {
1312  m->id_out_.push_back(id);
1313  m->vr_out_.push_back(vr_out_[id]);
1314  m->omarked_[id] = false;
1315  }
1316  }
1317 }

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

1250  {
1251  // Save to return
1252  for (size_t id : ored_[ind]) {
1253  *value++ = m->obuf_.at(id);
1254  }
1255 }

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

1082  {
1083  for (casadi_int i = 0; i < nsens; ++i) {
1084  *v++ = m->isens_.at(*id++);
1085  }
1086 }

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

1088  {
1089  // Quick return if not needed
1090  if (!v) return;
1091  // Retrieve all sensitivities FIXME(@jaeandersson): should use compatible types
1092  for (size_t id : ired_[ind]) {
1093  casadi_int id2 = id;
1094  get_adj(m, 1, &id2, v++);
1095  }
1096 }
casadi::FmuInternal::get_adj
void get_adj(FmuMemory *m, casadi_int nsens, const casadi_int *id, double *v) const
Definition: fmu.cpp:1082

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

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

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

1029  {
1030  for (casadi_int i = 0; i < nsens; ++i) {
1031  *v++ = m->osens_.at(*id++);
1032  }
1033 }

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

1035  {
1036  // Quick return if not needed
1037  if (!v) return;
1038  // Retrieve all sensitivities FIXME(@jaeandersson): should use compatible types
1039  for (size_t id : ored_[ind]) {
1040  casadi_int id2 = id;
1041  get_fwd(m, 1, &id2, v++);
1042  }
1043 }
casadi::FmuInternal::get_fwd
void get_fwd(FmuMemory *m, casadi_int nsens, const casadi_int *id, double *v) const
Definition: fmu.cpp:1029

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.

186  {
187  return static_cast<const Internal*>(this)->count;
188  }

◆ hess_sparsity()

Sparsity casadi::FmuInternal::hess_sparsity ( const std::vector< size_t > &  r,
const std::vector< size_t > &  c 
) const

Definition at line 676 of file fmu.cpp.

677  {
678  // Convert to casadi_int type
679  std::vector<casadi_int> r1(r.begin(), r.end());
680  std::vector<casadi_int> c1(c.begin(), c.end());
681  // Index mapping (not used)
682  std::vector<casadi_int> mapping;
683  // Get selection
684  return hess_sp_.sub(r1, c1, mapping);
685 }
casadi::Sparsity::sub
Sparsity sub(const std::vector< casadi_int > &rr, const std::vector< casadi_int > &cc, std::vector< casadi_int > &mapping, bool ind1=false) const
Get a submatrix.
Definition: sparsity.cpp:334

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

◆ index_in()

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

Definition at line 645 of file fmu.cpp.

645  {
646  // Linear search for the input
647  for (size_t i = 0; i < scheme_in_.size(); ++i) {
648  if (scheme_in_[i] == n) return i;
649  }
650  // Not found
651  casadi_error("No such input: " + n);
652  return -1;
653 }

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

655  {
656  // Linear search for the input
657  for (size_t i = 0; i < scheme_out_.size(); ++i) {
658  if (scheme_out_[i] == n) return i;
659  }
660  // Not found
661  casadi_error("No such output: " + n);
662  return -1;
663 }

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

451  {
452  // Copy info from DaeBuilder
453  resource_ = dae->resource_;
454  fmutol_ = dae->fmutol_;
455  instance_name_ = dae->model_identifier_;
456  instantiation_token_ = dae->instantiation_token_;
457  logging_on_ = dae->debug_;
458  number_of_event_indicators_ = dae->number_of_event_indicators_;
459  provides_directional_derivatives_ = dae->provides_directional_derivatives_;
460  provides_adjoint_derivatives_ = dae->provides_adjoint_derivatives_;
461  can_be_instantiated_only_once_per_process_ = dae->can_be_instantiated_only_once_per_process_;
462  nx_ = dae->size(Category::X);
463  do_evaluation_dance_ = dae->generation_tool_.rfind("Simulink", 0) == 0;
464 
465  // Mark input indices
466  size_t numel = 0;
467  std::vector<bool> lookup(dae->n_variables(), false);
468  for (auto&& n : scheme_in_) {
469  for (size_t i : scheme_.at(n)) {
470  casadi_assert(!lookup.at(i), "Duplicate variable: " + dae->variable(i).name);
471  lookup.at(i) = true;
472  numel++;
473  }
474  }
475  // Input mappings
476  iind_.reserve(numel);
477  iind_map_.reserve(lookup.size());
478  for (size_t k = 0; k < lookup.size(); ++k) {
479  if (lookup[k]) {
480  iind_map_.push_back(iind_.size());
481  iind_.push_back(k);
482  } else {
483  iind_map_.push_back(-1);
484  }
485  }
486  // Mark output indices
487  numel = 0;
488  std::fill(lookup.begin(), lookup.end(), false);
489  for (auto&& n : scheme_out_) {
490  for (size_t i : scheme_.at(n)) {
491  casadi_assert(!lookup.at(i), "Duplicate variable: " + dae->variable(i).name);
492  lookup.at(i) = true;
493  numel++;
494  }
495  }
496  // Construct mappings
497  oind_.reserve(numel);
498  oind_map_.reserve(lookup.size());
499  for (size_t k = 0; k < lookup.size(); ++k) {
500  if (lookup[k]) {
501  oind_map_.push_back(oind_.size());
502  oind_.push_back(k);
503  } else {
504  oind_map_.push_back(-1);
505  }
506  }
507  // Inputs
508  ired_.resize(scheme_in_.size());
509  for (size_t i = 0; i < ired_.size(); ++i) {
510  auto&& s = scheme_.at(scheme_in_[i]);
511  ired_[i].resize(s.size());
512  for (size_t k = 0; k < s.size(); ++k) {
513  ired_[i][k] = iind_map_.at(s[k]);
514  }
515  }
516  // Outputs
517  ored_.resize(scheme_out_.size());
518  for (size_t i = 0; i < ored_.size(); ++i) {
519  auto&& s = scheme_.at(scheme_out_[i]);
520  ored_[i].resize(s.size());
521  for (size_t k = 0; k < s.size(); ++k) {
522  ored_[i][k] = oind_map_.at(s[k]);
523  }
524  }
525 
526  // Is there an independent variable?
527  has_independent_ = false;
528 
529  // Collect meta information for inputs
530  nominal_in_.reserve(iind_.size());
531  min_in_.reserve(iind_.size());
532  max_in_.reserve(iind_.size());
533  vn_in_.reserve(iind_.size());
534  vr_in_.reserve(iind_.size());
535  for (size_t i : iind_) {
536  const Variable& v = dae->variable(i);
537  nominal_in_.push_back(v.nominal);
538  min_in_.push_back(v.min);
539  max_in_.push_back(v.max);
540  vn_in_.push_back(v.name);
541  vr_in_.push_back(v.value_reference);
542  if (v.causality == Causality::INDEPENDENT) {
543  if (i != 0) casadi_error("Independent variable must be first input of FMU");
544  has_independent_ = true;
545  }
546  }
547  // Collect meta information for outputs
548  nominal_out_.reserve(oind_.size());
549  min_out_.reserve(oind_.size());
550  max_out_.reserve(oind_.size());
551  vn_out_.reserve(oind_.size());
552  vr_out_.reserve(oind_.size());
553  for (size_t i : oind_) {
554  const Variable& v = dae->variable(i);
555  nominal_out_.push_back(v.nominal);
556  min_out_.push_back(v.min);
557  max_out_.push_back(v.max);
558  vn_out_.push_back(v.name);
559  vr_out_.push_back(v.value_reference);
560  }
561 
562  // Numerical values for inputs
563  value_in_.resize(iind_.size());
564 
565  // Get Jacobian sparsity information
566  jac_sp_ = dae->jac_sparsity(oind_, iind_);
567 
568  // Get Hessian sparsity information
569  hess_sp_ = dae->hess_sparsity(oind_, iind_);
570 }
casadi::IndexReduction::Variable
struct VariableStruct Variable
Definition: integration_tools.cpp:452

References 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, instance_name_, casadi::DaeBuilderInternal::instantiation_token_, instantiation_token_, ired_, 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_, casadi::DaeBuilderInternal::number_of_event_indicators_, number_of_event_indicators_, nx_, oind_, oind_map_, ored_, casadi::DaeBuilderInternal::provides_adjoint_derivatives_, provides_adjoint_derivatives_, casadi::DaeBuilderInternal::provides_directional_derivatives_, provides_directional_derivatives_, casadi::DaeBuilderInternal::resource_, resource_, scheme_, scheme_in_, scheme_out_, casadi::DaeBuilderInternal::size(), 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 1148 of file fmu.cpp.

1148  {
1149  // Ensure not already instantiated
1150  casadi_assert(m->instance == 0, "Already instantiated");
1151  // Create instance
1152  m->instance = instantiate();
1153  // Set all values
1154  if (set_values(m->instance)) {
1155  casadi_warning("FmuInternal::set_values failed");
1156  return 1;
1157  }
1158  // Initialization mode begins
1159  if (enter_initialization_mode(m->instance)) return 1;
1160  // Initialization mode ends
1161  if (exit_initialization_mode(m->instance)) return 1;
1162  // Initial event iteration
1163  if (discrete_states_iter(m->instance)) return 1;
1164  // Continuous-time mode
1165  if (enter_continuous_time_mode(m->instance)) return 1;
1166  // Allocate/reset input buffer
1167  m->ibuf_.resize(iind_.size());
1168  std::fill(m->ibuf_.begin(), m->ibuf_.end(), casadi::nan);
1169  // Allocate/reset output buffer
1170  m->obuf_.resize(oind_.size());
1171  std::fill(m->obuf_.begin(), m->obuf_.end(), casadi::nan);
1172  // Maximum input or output
1173  size_t max_io = std::max(iind_.size(), oind_.size());
1174  // Allocate/reset seeds
1175  m->isens_.resize(max_io);
1176  std::fill(m->isens_.begin(), m->isens_.end(), 0);
1177  // Allocate/reset sensitivities
1178  m->osens_.resize(max_io);
1179  std::fill(m->osens_.begin(), m->osens_.end(), 0);
1180  // Allocate/reset changed
1181  m->imarked_.resize(max_io);
1182  std::fill(m->imarked_.begin(), m->imarked_.end(), false);
1183  // Allocate/reset requested
1184  m->omarked_.resize(max_io);
1185  std::fill(m->omarked_.begin(), m->omarked_.end(), false);
1186  // Also allocate memory for corresponding Jacobian entry (for debugging)
1187  m->wrt_.resize(max_io);
1188  // Successful return
1189  return 0;
1190 }
casadi::FmuInternal::discrete_states_iter
int discrete_states_iter(void *instance) const
Definition: fmu.cpp:1098
casadi::FmuInternal::exit_initialization_mode
virtual int exit_initialization_mode(void *instance) const =0
casadi::FmuInternal::enter_continuous_time_mode
virtual int enter_continuous_time_mode(void *instance) const =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.

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

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

666  {
667  // Convert to casadi_int type
668  std::vector<casadi_int> osub1(osub.begin(), osub.end());
669  std::vector<casadi_int> isub1(isub.begin(), isub.end());
670  // Index mapping (not used)
671  std::vector<casadi_int> mapping;
672  // Get selection
673  return jac_sp_.sub(osub1, isub1, mapping);
674 }

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

◆ load_function()

template<typename T >
T * casadi::FmuInternal::load_function ( const std::string &  symname)

Definition at line 357 of file fmu_impl.hpp.

357  {
358  // Load the function
359  signal_t f = li_.get_function(symname);
360  // Ensure that it was found
361  casadi_assert(f != 0, "Cannot retrieve '" + symname + "'");
362  // Return function with the right type
363  return reinterpret_cast<T*>(f);
364 }
casadi::Importer::get_function
signal_t get_function(const std::string &symname)
Get a function pointer for numerical evaluation.
Definition: importer.cpp:79
casadi::signal_t
void(* signal_t)(void)
Function pointer types for the C API.
Definition: casadi_common.hpp:139

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

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

132 { 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 1213 of file fmu.cpp.

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

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

1073  {
1074  // Request all sensitivities FIXME(@jaeandersson): should use compatible types
1075  casadi_int wrt_id = -1;
1076  for (size_t id : ired_[ind]) {
1077  casadi_int id2 = id;
1078  request_adj(m, 1, &id2, &wrt_id);
1079  }
1080 }
casadi::FmuInternal::request_adj
void request_adj(FmuMemory *m, casadi_int nsens, const casadi_int *id, const casadi_int *wrt_id) const
Definition: fmu.cpp:1064

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

1065  {
1066  for (casadi_int i = 0; i < nsens; ++i) {
1067  m->imarked_.at(*id) = true;
1068  m->wrt_.at(*id) = *wrt_id++;
1069  id++;
1070  }
1071 }

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

1285  {
1286  // Request all sensitivities FIXME(@jaeandersson): should use compatible types
1287  casadi_int wrt_id = -1;
1288  for (size_t id : ored_[ind]) {
1289  casadi_int id2 = id;
1290  request_fwd(m, 1, &id2, &wrt_id);
1291  }
1292 }
casadi::FmuInternal::request_fwd
void request_fwd(FmuMemory *m, casadi_int nsens, const casadi_int *id, const casadi_int *wrt_id) const
Definition: fmu.cpp:1276

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

1277  {
1278  for (casadi_int i = 0; i < nsens; ++i) {
1279  m->omarked_.at(*id) = true;
1280  m->wrt_.at(*id) = *wrt_id++;
1281  id++;
1282  }
1283 }

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

Referenced by request_fwd().

◆ serialize()

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

Definition at line 1371 of file fmu.cpp.

1371  {
1372  serialize_type(s);
1373  serialize_body(s);
1374 }
casadi::FmuInternal::serialize_body
virtual void serialize_body(SerializingStream &s) const
Definition: fmu.cpp:1380
casadi::FmuInternal::serialize_type
virtual void serialize_type(SerializingStream &s) const
Definition: fmu.cpp:1376

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

1380  {
1381  s.version("FmuInternal", 4);
1382  s.pack("FmuInternal::name", name_);
1383  s.pack("FmuInternal::scheme_in", scheme_in_);
1384  s.pack("FmuInternal::scheme_out", scheme_out_);
1385  s.pack("FmuInternal::scheme", scheme_);
1386  s.pack("FmuInternal::aux", aux_);
1387  s.pack("FmuInternal::iind", iind_);
1388  s.pack("FmuInternal::iind_map", iind_map_);
1389  s.pack("FmuInternal::oind", oind_);
1390  s.pack("FmuInternal::oind_map", oind_map_);
1391  s.pack("FmuInternal::has_independent", has_independent_);
1392  s.pack("FmuInternal::nominal_in", nominal_in_);
1393  s.pack("FmuInternal::nominal_out", nominal_out_);
1394  s.pack("FmuInternal::min_in", min_in_);
1395  s.pack("FmuInternal::min_out", min_out_);
1396  s.pack("FmuInternal::max_in", max_in_);
1397  s.pack("FmuInternal::max_out", max_out_);
1398  s.pack("FmuInternal::vn_in", vn_in_);
1399  s.pack("FmuInternal::vn_out", vn_out_);
1400  s.pack("FmuInternal::vr_in", vr_in_);
1401  s.pack("FmuInternal::vr_out", vr_out_);
1402 
1403  s.pack("FmuInternal::value_in", value_in_);
1404  s.pack("FmuInternal::ired", ired_);
1405  s.pack("FmuInternal::ored", ored_);
1406  s.pack("FmuInternal::jac_sp", jac_sp_);
1407  s.pack("FmuInternal::hess_sp", hess_sp_);
1408 
1409  s.pack("FmuInternal::resource", resource_);
1410  s.pack("FmuInternal::fmutol", fmutol_);
1411  s.pack("FmuInternal::instance_name", instance_name_);
1412  s.pack("FmuInternal::instantiation_token", instantiation_token_);
1413  s.pack("FmuInternal::logging_on", logging_on_);
1414  s.pack("FmuInternal::number_of_event_indicators", number_of_event_indicators_);
1415  s.pack("FmuInternal::provides_directional_derivatives", provides_directional_derivatives_);
1416  s.pack("FmuInternal::provides_adjoint_derivatives", provides_adjoint_derivatives_);
1417  s.pack("FmuInternal::can_be_instantiated_only_once_per_process",
1418  can_be_instantiated_only_once_per_process_);
1419  s.pack("FmuInternal::nx", nx_);
1420  s.pack("FmuInternal::do_evaluation_dance", do_evaluation_dance_);
1421 }

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_, 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 1376 of file fmu.cpp.

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

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

1192  {
1193  if (value) {
1194  // Argument is given
1195  for (size_t id : ired_[ind]) {
1196  if (*value != m->ibuf_.at(id)) {
1197  m->ibuf_.at(id) = *value;
1198  m->imarked_.at(id) = true;
1199  }
1200  value++;
1201  }
1202  } else {
1203  // Argument is null - all zeros
1204  for (size_t id : ired_[ind]) {
1205  if (0 != m->ibuf_.at(id)) {
1206  m->ibuf_.at(id) = 0;
1207  m->imarked_.at(id) = true;
1208  }
1209  }
1210  }
1211 }

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

1046  {
1047  for (casadi_int i = 0; i < nseed; ++i) {
1048  m->osens_.at(*id) = *v++;
1049  m->omarked_.at(*id) = true;
1050  id++;
1051  }
1052 }

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

1054  {
1055  // If seeds are zero, no need to add to seed buffers
1056  if (!v) return;
1057  // Pass all seeds FIXME(@jaeandersson): should use compatible types
1058  for (size_t id : ored_[ind]) {
1059  casadi_int id2 = id;
1060  set_adj(m, 1, &id2, v++);
1061  }
1062 }
casadi::FmuInternal::set_adj
void set_adj(FmuMemory *m, casadi_int nseed, const casadi_int *id, const double *v) const
Definition: fmu.cpp:1045

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

1258  {
1259  for (casadi_int i = 0; i < nseed; ++i) {
1260  m->isens_.at(*id) = *v++;
1261  m->imarked_.at(*id) = true;
1262  id++;
1263  }
1264 }

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

1266  {
1267  // If seeds are zero, no need to add to seed buffers
1268  if (!v) return;
1269  // Pass all seeds FIXME(@jaeandersson): should use compatible types
1270  for (size_t id : ired_[ind]) {
1271  casadi_int id2 = id;
1272  set_fwd(m, 1, &id2, v++);
1273  }
1274 }
casadi::FmuInternal::set_fwd
void set_fwd(FmuMemory *m, casadi_int nseed, const casadi_int *id, const double *v) const
Definition: fmu.cpp:1257

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.

83  {
84  casadi_assert_dev(B::test_cast(static_cast<Internal*>(this)));
85  B ret;
86  ret.own(static_cast<Internal*>(this));
87  return ret;
88  }

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

92  {
93  casadi_assert_dev(B::test_cast(static_cast<const Internal*>(this)));
94  B ret;
95  ret.own(const_cast<Internal*>(static_cast<const Internal*>(this)));
96  return ret;
97  }

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

191  {
192  if (weak_ref_==nullptr) {
193  weak_ref_ = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
194  }
195  return weak_ref_;
196  }

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 294 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 318 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 353 of file fmu_impl.hpp.

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

◆ fmutol_

double casadi::FmuInternal::fmutol_
protected

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

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

◆ hess_sp_

Sparsity casadi::FmuInternal::hess_sp_
protected

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

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

◆ instance_name_

std::string casadi::FmuInternal::instance_name_
protected

Definition at line 303 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 306 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 340 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 343 of file fmu_impl.hpp.

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

◆ li_

Importer casadi::FmuInternal::li_
protected

Definition at line 321 of file fmu_impl.hpp.

Referenced by finalize(), and load_function().

◆ logging_on_

bool casadi::FmuInternal::logging_on_
protected

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

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

◆ name_

std::string casadi::FmuInternal::name_
protected

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

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

◆ nx_

size_t casadi::FmuInternal::nx_
protected

Definition at line 351 of file fmu_impl.hpp.

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

◆ oind_

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

Definition at line 324 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 324 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 340 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 315 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 315 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 284 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 297 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 291 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 290 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 290 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 337 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 333 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 333 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 334 of file fmu_impl.hpp.

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

◆ vr_out_

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

Definition at line 334 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 345 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 349 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 347 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 346 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 348 of file fmu_impl.hpp.

Referenced by discrete_states_iter(), and finalize().

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