dae_builder_internal.hpp

/*
 *    This file is part of CasADi.
 *
 *    CasADi -- A symbolic framework for dynamic optimization.
 *    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
 *                            KU Leuven. All rights reserved.
 *    Copyright (C) 2011-2014 Greg Horn
 *
 *    CasADi is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 3 of the License, or (at your option) any later version.
 *
 *    CasADi is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with CasADi; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */
 
 
#ifndef CASADI_DAE_BUILDER_INTERNAL_HPP
#define CASADI_DAE_BUILDER_INTERNAL_HPP
 
#include <unordered_map>
 
#include "dae_builder.hpp"
#include "shared_object_internal.hpp"
#include "casadi_enum.hpp"
 
namespace casadi {
 
// Forward declarations
struct XmlNode;
 
enum class TypeFmi2 {REAL, INTEGER, BOOLEAN, STRING, ENUM, NUMEL};
 
enum class Type {FLOAT32, FLOAT64, INT8, UINT8, INT16, UINT16, INT32, UINT32, INT64, UINT64,
  BOOLEAN, STRING, BINARY, ENUMERATION, CLOCK, NUMEL};
 
enum class Causality {PARAMETER, CALCULATED_PARAMETER, INPUT, OUTPUT, LOCAL, INDEPENDENT, NUMEL};
 
enum class Variability {CONSTANT, FIXED, TUNABLE, DISCRETE, CONTINUOUS, NUMEL};
 
enum class Initial {EXACT, APPROX, CALCULATED, NA, NUMEL};
 
// Attributes
enum class Attribute {MIN, MAX, NOMINAL, START, VALUE, STRINGVALUE, NUMEL};
 
// Permitted dependenciesKind values
enum class DependenciesKind {DEPENDENT, CONSTANT, FIXED, TUNABLE, DISCRETE, NUMEL};
 
struct CASADI_EXPORT Variable {
  friend class DaeBuilderInternal;
 
 private:
  Variable(casadi_int index, casadi_int numel, const std::string& name, const MX& v);
 
 public:
  casadi_int index;
 
  casadi_int numel;
 
  std::vector<casadi_int> dimension;
 
  std::string name;
  unsigned int value_reference;
  std::string description;
  Type type;
  Causality causality;
  Variability variability;
 
  // std::string declared_type;
  std::string unit;
  std::string display_unit;
  Initial initial;
  // std::string quantity;
  // bool relative_quantity;
  // bool unbounded;
  double min;
  double max;
  double nominal;
  std::vector<double> start;
  casadi_int der_of;  // 'derivative' in FMI specification
  // bool reinit;
 
  // corresponding residual variable
  casadi_int alg;
 
  // corresponding derivative variable
  casadi_int der;
 
  std::vector<double> value;
 
  std::string stringvalue;
 
  bool dependency;
 
  mutable std::vector<casadi_int> dependencies;
 
  mutable std::vector<DependenciesKind> dependenciesKind;
 
  MX v;
 
  MX beq;
 
  double attribute(Attribute a) const;
 
  void set_attribute(Attribute a, double val);
 
  std::string string_attribute(Attribute a) const;
 
  void set_string_attribute(Attribute a, const std::string& val);
 
  // Default initial attribute, per specification
  static Initial default_initial(Causality causality, Variability variability);
 
  // Export as XML
  XmlNode export_xml(const DaeBuilderInternal& self) const;
 
  // Is the variable real?
  bool is_real() const {return type == Type::FLOAT32 || type == Type::FLOAT64;}
 
  // Does the variable need a start attribute?
  bool has_start() const;
};
 
class CASADI_EXPORT DaeBuilderInternal : public SharedObjectInternal {
  friend class DaeBuilder;
  friend class Fmu2;
  friend class FmuFunction;
 
 public:
 
  explicit DaeBuilderInternal(const std::string& name, const std::string& path, const Dict& opts);
 
  ~DaeBuilderInternal() override;
 
  std::string class_name() const override {return "DaeBuilderInternal";}
 
  void sanity_check() const;
 
 
  void eliminate_w();
 
  void lift(bool lift_shared, bool lift_calls);
 
  void eliminate_quad();
 
  void sort_d();
 
  void sort_w();
 
  void sort_z(const std::vector<std::string>& z_order);
 
  std::vector<size_t>& ind_in(const std::string& v);
 
  const std::vector<size_t>& ind_in(const std::string& v) const;
 
  void clear_all(const std::string& v);
 
  void set_all(const std::string& v, const std::vector<std::string>& name);
 
  void prune(bool prune_p, bool prune_u);
 
  void tearing_variables(std::vector<std::string>* res, std::vector<std::string>* iv,
    std::vector<std::string>* iv_on_hold) const;
 
  void tear();
 
  void load_fmi_description(const std::string& filename);
 
  static std::string iso_8601_time();
 
  // Generate a random 32 digit hexadecimal number
  static std::string generate_guid();
 
  std::vector<std::string> export_fmu(const Dict& opts) const;
 
  std::string generate_wrapper(const std::string& guid, const CodeGenerator& gen) const;
 
  std::string generate_build_description(const std::vector<std::string>& cfiles) const;
 
  std::string generate_model_description(const std::string& guid) const;
 
  XmlNode generate_model_variables() const;
 
  XmlNode generate_model_structure() const;
 
  void update_dependencies() const;
 
  static std::string generate(const std::vector<size_t>& v);
  static std::string generate(const std::vector<double>& v);
 
  // Input convension in codegen
  enum DaeBuilderInternalIn {
    DAE_BUILDER_T,
    DAE_BUILDER_C,
    DAE_BUILDER_P,
    DAE_BUILDER_D,
    DAE_BUILDER_W,
    DAE_BUILDER_U,
    DAE_BUILDER_X,
    DAE_BUILDER_Z,
    DAE_BUILDER_Q,
    DAE_BUILDER_Y,
    DAE_BUILDER_NUM_IN
  };
 
  // Output convension in codegen
  enum DaeBuilderInternalOut {
    DAE_BUILDER_ODE,
    DAE_BUILDER_ALG,
    DAE_BUILDER_QUAD,
    DAE_BUILDER_DDEF,
    DAE_BUILDER_WDEF,
    DAE_BUILDER_YDEF,
    DAE_BUILDER_NUM_OUT
  };
 
  // Get input expression, given enum
  std::vector<MX> input(DaeBuilderInternalIn ind) const;
 
  // Get output expression, given enum
  std::vector<MX> output(DaeBuilderInternalOut ind) const;
 
  // Get input expression, given enum
  std::vector<MX> input(const std::vector<DaeBuilderInternalIn>& ind) const;
 
  // Get output expression, given enum
  std::vector<MX> output(const std::vector<DaeBuilderInternalOut>& ind) const;
 
  void add_lc(const std::string& name, const std::vector<std::string>& f_out);
 
  Function create(const std::string& fname,
      const std::vector<std::string>& name_in,
      const std::vector<std::string>& name_out,
      const Dict& opts, bool sx, bool lifted_calls) const;
 
  Function fmu_fun(const std::string& fname,
      const std::vector<std::string>& name_in,
      const std::vector<std::string>& name_out,
      const Dict& opts) const;
 
  Function dependent_fun(const std::string& fname,
      const std::vector<std::string>& s_in,
      const std::vector<std::string>& s_out) const;
 
  Function gather_eq() const;
 
  const MX& var(const std::string& name) const;
 
  MX der(const std::string& name) const;
 
  MX der(const MX& var) const;
 
  std::string type_name() const {return "DaeBuilderInternal";}
 
  void disp(std::ostream& stream, bool more) const override;
 
  std::string get_str(bool more=false) const {
    std::stringstream ss;
    disp(ss, more);
    return ss.str();
  }
 
  Variable& new_variable(const std::string& name, casadi_int numel = 1, const MX& v = MX());
 
  bool has_variable(const std::string& name) const;
 
  std::vector<std::string> all_variables() const;
 
  size_t n_variables() const {return variables_.size();}
 
  size_t n_mem() const;
 
  std::vector<double> start_all() const;
 
  Variable& variable(size_t ind) {return *variables_.at(ind);}
  const Variable& variable(size_t ind) const {return *variables_.at(ind);}
 
  Variable& variable(const std::string& name) {return variable(find(name));}
  const Variable& variable(const std::string& name) const {return variable(find(name));}
 
  const MX& var(size_t ind) const;
 
  std::vector<MX> var(const std::vector<size_t>& ind) const;
 
  size_t find(const std::string& name) const;
 
  std::vector<size_t> find(const std::vector<std::string>& name) const;
 
  const Function& oracle(bool sx = false, bool elim_w = false, bool lifted_calls = false) const;
 
  Sparsity jac_sparsity(const std::vector<size_t>& oind, const std::vector<size_t>& iind) const;
 
  Sparsity hess_sparsity(const std::vector<size_t>& oind, const std::vector<size_t>& iind) const;
 
  // Internal methods
protected:
 
  static std::string qualified_name(const XmlNode& nn);
 
  // User-set options
  bool debug_;
  double fmutol_;
 
  // FMI attributes
  std::string fmi_version_;
  std::string model_name_;
  std::string guid_;
  std::string description_;
  std::string author_;
  std::string copyright_;
  std::string license_;
  std::string generation_tool_;
  std::string generation_date_and_time_;
  std::string variable_naming_convention_;
  casadi_int number_of_event_indicators_;
 
  // Model Exchange
  std::string model_identifier_;
  bool provides_directional_derivative_;
  std::vector<std::string> source_files_;
 
  std::string name_;
 
  // Path to FMU, if any
  std::string path_;
 
  // Symbolic representation of the model equations?
  bool symbolic_;
 
  std::vector<Variable*> variables_;
 
  // Model structure
  std::vector<size_t> outputs_, derivatives_, initial_unknowns_;
 
  std::unordered_map<std::string, size_t> varind_;
 
  std::vector<size_t> t_, p_, u_, x_, z_, q_, c_, d_, w_, y_;
 
  std::vector<MX> aux_;
  std::vector<MX> init_lhs_, init_rhs_;
  std::vector<MX> when_cond_, when_lhs_, when_rhs_;
 
  std::vector<MX> cdef() const;
 
  std::vector<MX> ddef() const;
 
  std::vector<MX> wdef() const;
 
  std::vector<MX> ydef() const;
 
  std::vector<MX> ode() const;
 
  std::vector<MX> alg() const;
 
  std::vector<MX> quad() const;
 
  MX add_t(const std::string& name);
  MX add_p(const std::string& name);
  MX add_u(const std::string& name);
  MX add_x(const std::string& name);
  MX add_z(const std::string& name);
  MX add_q(const std::string& name);
  MX add_c(const std::string& name, const MX& new_cdef);
  MX add_d(const std::string& name, const MX& new_ddef);
  MX add_w(const std::string& name, const MX& new_wdef);
  MX add_y(const std::string& name, const MX& new_ydef);
  void set_ode(const std::string& name, const MX& ode_rhs);
  void set_alg(const std::string& name, const MX& alg_rhs);
 
  Function::AuxOut lc_;
 
  std::vector<Function> fun_;
 
  mutable Function oracle_[2][2][2];
 
  mutable bool clear_cache_;
 
  MX read_expr(const XmlNode& node);
 
  Variable& read_variable(const XmlNode& node);
 
  // Read ModelExchange
  void import_model_exchange(const XmlNode& n);
 
  // Read ModelVariables
  void import_model_variables(const XmlNode& modvars);
 
  // Read ModelStructure
  void import_model_structure(const XmlNode& n);
 
  void clear_cache() const;
 
  Function add_fun(const std::string& name,
                   const std::vector<std::string>& arg,
                   const std::vector<std::string>& res, const Dict& opts=Dict());
 
  Function add_fun(const Function& f);
 
  bool has_fun(const std::string& name) const;
 
  Function fun(const std::string& name) const;
 
  // Reset value attributes
  void reset();
 
  double attribute(Attribute a, const std::string& name) const;
  std::vector<double> attribute(Attribute a, const std::vector<std::string>& name) const;
 
  void set_attribute(Attribute a, const std::string& name, double val);
  void set_attribute(Attribute a, const std::vector<std::string>& name,
    const std::vector<double>& val);
 
  std::string string_attribute(Attribute a, const std::string& name) const;
  std::vector<std::string> string_attribute(Attribute a,
    const std::vector<std::string>& name) const;
 
  void set_string_attribute(Attribute a, const std::string& name, const std::string& val);
  void set_string_attribute(Attribute a, const std::vector<std::string>& name,
    const std::vector<std::string>& val);
 
 
  struct CallIO {
    // Function instances
    Function f, adj1_f, J, H;
    // Index in v and vdef
    std::vector<size_t> v, vdef;
    // Nondifferentiated inputs
    std::vector<MX> arg;
    // Nondifferentiated inputs
    std::vector<MX> res;
    // Jacobian outputs
    std::vector<MX> jac_res;
    // Adjoint seeds
    std::vector<MX> adj1_arg;
    // Adjoint sensitivities
    std::vector<MX> adj1_res;
    // Hessian outputs
    std::vector<MX> hess_res;
    // Calculate Jacobian blocks
    void calc_jac();
    // Calculate gradient of Lagrangian
    void calc_grad();
    // Calculate Hessian of Lagrangian
    void calc_hess();
    // Access a specific Jacobian block
    const MX& jac(casadi_int oind, casadi_int iind) const;
    // Access a specific Hessian block
    const MX& hess(casadi_int iind1, casadi_int iind2) const;
  };
 
  MX jac_vdef_v_from_calls(std::map<MXNode*, CallIO>& call_nodes,
    const std::vector<casadi_int>& h_offsets) const;
 
  MX hess_v_v_from_calls(std::map<MXNode*, CallIO>& call_nodes,
    const std::vector<casadi_int>& h_offsets) const;
 
  // Sort dependent variables/parameters
  static void sort_dependent(std::vector<MX>& v, std::vector<MX>& vdef);
};
 
template<> struct enum_traits<DaeBuilderInternal::DaeBuilderInternalIn> {
  static const size_t n_enum = DaeBuilderInternal::DAE_BUILDER_NUM_IN;
};
template<> struct enum_traits<DaeBuilderInternal::DaeBuilderInternalOut> {
  static const size_t n_enum = DaeBuilderInternal::DAE_BUILDER_NUM_OUT;
};
 
CASADI_EXPORT Type from_fmi2(TypeFmi2 v);
CASADI_EXPORT TypeFmi2 to_fmi2(Type v);
 
CASADI_EXPORT std::string to_string(TypeFmi2 v);
CASADI_EXPORT std::string to_string(Type v);
CASADI_EXPORT std::string to_string(Causality v);
CASADI_EXPORT std::string to_string(Variability v);
CASADI_EXPORT std::string to_string(Initial v);
CASADI_EXPORT std::string to_string(Attribute v);
CASADI_EXPORT std::string to_string(DependenciesKind v);
CASADI_EXPORT std::string to_string(DaeBuilderInternal::DaeBuilderInternalIn v);
CASADI_EXPORT std::string to_string(DaeBuilderInternal::DaeBuilderInternalOut v);
 
 
} // namespace casadi
 
#endif // CASADI_DAE_BUILDER_INTERNAL_HPP