dae_builder.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_HPP
#define CASADI_DAE_BUILDER_HPP
 
#include "function.hpp"
 
namespace casadi {
 
// Forward declarations
class DaeBuilderInternal;
 
class CASADI_EXPORT DaeBuilder
  : public SharedObject,
    public SWIG_IF_ELSE(PrintableCommon, Printable<DaeBuilder>) {
 public:
 
  std::string type_name() const {return "DaeBuilder";}
 
  DaeBuilder();
 
  explicit DaeBuilder(const std::string& name, const std::string& path = "",
    const Dict& opts = Dict());
 
  const std::string& name() const;
 
 
  const MX& time() const;
 
  std::vector<std::string> t_new() const {return all("t");}
 
  std::vector<std::string> x() const {return all("x");}
 
  std::vector<std::string> y() const;
 
  std::vector<MX> ode() const;
 
  std::vector<std::string> z() const {return all("z");}
 
  std::vector<MX> alg() const;
 
  std::vector<std::string> q() const {return all("q");}
 
  std::vector<MX> quad() const;
 
  std::vector<MX> zero() const;
 
  std::vector<MX> ydef() const;
 
  std::vector<std::string> u() const {return all("u");}
 
  std::vector<std::string> p() const {return all("p");}
 
  std::vector<std::string> c() const {return all("c");}
 
  std::vector<MX> cdef() const;
 
  std::vector<std::string> d() const {return all("d");}
 
  std::vector<MX> ddef() const;
 
  std::vector<std::string> w() const {return all("w");}
 
  std::vector<MX> wdef() const;
 
  std::vector<MX> init_lhs() const;
 
  std::vector<MX> init_rhs() const;
 
  std::vector<std::string> outputs() const;
 
  std::vector<std::string> derivatives() const;
 
  std::vector<std::string> initial_unknowns() const;
 
 
  bool has_t() const;
 
  casadi_int nx() const;
 
  casadi_int nz() const;
 
  casadi_int nq() const;
 
  casadi_int nzero() const;
 
  casadi_int ny() const;
 
  casadi_int nu() const;
 
  casadi_int np() const;
 
  casadi_int nc() const;
 
  casadi_int nd() const;
 
  casadi_int nw() const;
 
 
  MX add(const std::string& name,
    const std::string& causality,
    const std::string& variability,
    const Dict& opts=Dict());
 
  MX add(const std::string& name,
    const std::string& causality,
    const Dict& opts=Dict());
 
  MX add(const std::string& name,
    const Dict& opts=Dict());
 
  void add(const std::string& name,
    const std::string& causality,
    const std::string& variability,
    const MX& expr,
    const Dict& opts=Dict());
 
#ifdef WITH_DEPRECATED_FEATURES
  const MX& t() const { return time();}
 
  MX add_t(const std::string& name="t");
 
  MX add_p(const std::string& name=std::string());
 
  MX add_u(const std::string& name=std::string());
 
  MX add_x(const std::string& name=std::string());
 
  MX add_z(const std::string& name=std::string());
 
  MX add_q(const std::string& name=std::string());
 
  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_beq(const std::string& name, const MX& val);
 
  #endif  // WITH_DEPRECATED_FEATURES
 
  void eq(const MX& lhs, const MX& rhs, const Dict& opts=Dict());
 
  void when(const MX& cond, const std::vector<std::string>& eqs, const Dict& opts=Dict());
 
  std::string assign(const std::string& name, const MX& val);
 
  std::string reinit(const std::string& name, const MX& val);
 
  void set_init(const std::string& name, const MX& init_rhs);
 
#ifdef WITH_DEPRECATED_FEATURES
  void set_ode(const std::string& name, const MX& ode_rhs) {
    eq(var(name), ode_rhs);
  }
 
  void set_alg(const std::string& name, const MX& alg_rhs) {
    (void)name;
    eq(0, alg_rhs);
  }
 
  void add_init(const MX& lhs, const MX& rhs) {
    set_init(lhs.name(), rhs);
  }
 
  casadi_int ne() const {return nzero();}
 
  std::vector<std::string> e() const {return all("zero");}
 
  #endif  // WITH_DEPRECATED_FEATURES
 
  void sanity_check() const;
 
  void reorder(const std::string& cat, const std::vector<std::string>& v);
 
#ifdef WITH_DEPRECATED_FEATURES
  void clear_all(const std::string& v);
 
  void set_all(const std::string& v, const std::vector<std::string>& name);
 
  void register_t(const std::string& name);
  void register_p(const std::string& name);
  void register_u(const std::string& name);
  void register_x(const std::string& name);
  void register_z(const std::string& name);
  void register_q(const std::string& name);
  void register_c(const std::string& name);
  void register_d(const std::string& name);
  void register_w(const std::string& name);
  void register_y(const std::string& name);
  void register_e(const std::string& name);
 
  void eliminate_d();
 
  void eliminate_w();
 
  void eliminate_quad();
 
  void sort_d();
 
  void sort_w();
 
  void sort_z(const std::vector<std::string>& z_order);
 
  #endif // WITH_DEPRECATED_FEATURES
 
 
 
  void eliminate(const std::string& cat);
 
  void sort(const std::string& cat);
 
  void lift(bool lift_shared = true, bool lift_calls = true);
 
  void prune(bool prune_p = true, bool prune_u = true);
 
  void tear();
 
 
  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);
 
  Function add_fun(const std::string& name, const Importer& compiler,
                   const Dict& opts=Dict());
 
  bool has_fun(const std::string& name) const;
 
  Function fun(const std::string& name) const;
 
  std::vector<Function> fun() const;
 
  void gather_fun(casadi_int max_depth = -1);
 
  void parse_fmi(const std::string& filename) {load_fmi_description(filename); }
 
  bool provides_directional_derivatives() const;
 
  bool provides_directional_derivative() const {return provides_directional_derivatives();}
 
  void load_fmi_description(const std::string& filename);
 
  std::vector<std::string> export_fmu(const Dict& opts=Dict());
 
  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, bool sx, bool lifted_calls = false) const;
 
  Function create(const std::string& name,
    const std::vector<std::string>& name_in,
    const std::vector<std::string>& name_out,
    const Dict& opts=Dict()) const;
 
  Function create(const std::string& fname, const Dict& opts=Dict()) const;
 
  Function create() const {return create(name() + "_dae");}
 
  Function dependent_fun(const std::string& fname,
      const std::vector<std::string>& s_in,
      const std::vector<std::string>& s_out) const;
 
  Function transition(const std::string& fname, casadi_int index) const;
 
  Function transition(const std::string& fname) const;
 
  Function transition() const {return transition(name() + "_transition");}
 
  MX var(const std::string& name) const;
  MX operator()(const std::string& name) const {return var(name);}
 
  std::vector<std::string> der(const std::vector<std::string>& name) const;
 
  MX der(const MX& v) const;
  MX der(const MX& v);
 
  std::vector<std::string> pre(const std::vector<std::string>& name) const;
 
  MX pre(const MX& v) const;
 
  bool has_beq(const std::string& name) const;
 
  MX beq(const std::string& name) const;
 
  casadi_int value_reference(const std::string& name) const;
  void set_value_reference(const std::string& name, casadi_int val);
 
  std::string description(const std::string& name) const;
  void set_description(const std::string& name, const std::string& val);
 
  std::string type(const std::string& name, casadi_int fmi_version = 3) const;
  void set_type(const std::string& name, const std::string& val);
 
  std::string causality(const std::string& name) const;
 
  void set_causality(const std::string& name, const std::string& val);
 
  std::string variability(const std::string& name) const;
 
  void set_variability(const std::string& name, const std::string& val);
 
  std::string category(const std::string& name) const;
 
  void set_category(const std::string& name, const std::string& val);
 
  std::string initial(const std::string& name) const;
  void set_initial(const std::string& name, const std::string& val);
 
  std::string unit(const std::string& name) const;
  void set_unit(const std::string& name, const std::string& val);
 
  std::string display_unit(const std::string& name) const;
  void set_display_unit(const std::string& name, const std::string& val);
 
  casadi_int numel(const std::string& name) const;
 
  std::vector<casadi_int> dimension(const std::string& name) const;
 
  double start_time() const;
 
  void set_start_time(double val);
 
  double stop_time() const;
 
  void set_stop_time(double val);
 
  double tolerance() const;
 
  void set_tolerance(double val);
 
  double step_size() const;
 
  void set_step_size(double val);
 
  // The following routines are not needed in MATLAB and would cause ambiguity
  // Note that a multirow strings can be interpreted as a vector of strings
#if !(defined(SWIG) && defined(SWIGMATLAB))
  std::string der(const std::string& name) const;
 
  std::string pre(const std::string& name) const;
 
  double attribute(const std::string& a, const std::string& name) const;
 
  void set_attribute(const std::string& a, const std::string& name, double val);
 
  double min(const std::string& name) const;
 
  void set_min(const std::string& name, double val);
 
  double max(const std::string& name) const;
 
  void set_max(const std::string& name, double val);
 
  double nominal(const std::string& name) const;
 
  void set_nominal(const std::string& name, double val);
 
  std::vector<double> start(const std::string& name) const;
 
  void set_start(const std::string& name, double val);
 
  void set_start(const std::string& name, const std::vector<double>& val);
 
  // Clear all set values
  void reset();
 
  // Set the current value, single value
  void set(const std::string& name, double val);
 
  // Set the current value, single value (string)
  void set(const std::string& name, const std::string& val);
 
  GenericType get(const std::string& name) const;
 
#endif  // !SWIGMATLAB
 
  std::vector<double> attribute(const std::string& a, const std::vector<std::string>& name) const;
 
  void set_attribute(const std::string& a, const std::vector<std::string>& name,
    const std::vector<double>& val);
 
  std::vector<double> min(const std::vector<std::string>& name) const;
 
  void set_min(const std::vector<std::string>& name, const std::vector<double>& val);
 
  std::vector<double> max(const std::vector<std::string>& name) const;
 
  void set_max(const std::vector<std::string>& name, const std::vector<double>& val);
 
  std::vector<double> nominal(const std::vector<std::string>& name) const;
 
  void set_nominal(const std::vector<std::string>& name, const std::vector<double>& val);
 
  std::vector<double> start(const std::vector<std::string>& name) const;
 
  void set_start(const std::vector<std::string>& name, const std::vector<double>& val);
 
  void set(const std::vector<std::string>& name, const std::vector<double>& val);
 
  void set(const std::vector<std::string>& name, const std::vector<std::string>& val);
 
  std::vector<GenericType> get(const std::vector<std::string>& name) const;
 
  bool has(const std::string& name) const;
 
  std::vector<std::string> all() const;
 
  std::vector<std::string> all(const std::string& cat) const;
 
#ifdef WITH_DEPRECATED_FEATURES
  MX add_variable(const std::string& name, casadi_int n=1);
 
  MX add_variable(const std::string& name, const Sparsity& sp);
 
  void add_variable(const MX& new_v);
 
  size_t add_variable_new(const std::string& name, casadi_int n=1);
 
  size_t add_variable_new(const std::string& name, const Sparsity& sp);
 
  size_t add_variable_new(const MX& new_v);
 
  bool has_variable(const std::string& name) const {return has(name);}
 
  std::vector<std::string> all_variables() const {return all();}
#endif // WITH_DEPRECATED_FEATURES
 
  Function oracle(bool sx = false, bool elim_w = false, bool lifted_calls = false) const;
 
  Sparsity jac_sparsity(const std::vector<std::string>& onames,
    const std::vector<std::string>& inames) const;
 
#ifndef SWIG
#ifdef WITH_DEPRECATED_FEATURES
  Variable& new_variable(const std::string& name, casadi_int numel = 1);
 
  Variable& variable(const std::string& name);
  const Variable& variable(const std::string& name) const;
  Variable& variable(size_t ind);
  const Variable& variable(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 std::string& name(size_t ind) const;
  std::vector<std::string> name(const std::vector<size_t>& ind) const;
 
  const MX& var(size_t ind) const;
  std::vector<MX> var(const std::vector<size_t>& ind) const;
 
#endif // WITH_DEPRECATED_FEATURES
 
  const DaeBuilderInternal* operator->() const;
 
  DaeBuilderInternal* operator->();
 
  static bool test_cast(const SharedObjectInternal* ptr);
 
#endif // SWIG
};
 
} // namespace casadi
 
#endif // CASADI_DAE_BUILDER_HPP