integrator.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_INTEGRATOR_HPP
#define CASADI_INTEGRATOR_HPP
 
#include "function.hpp"
#include "linsol.hpp"
#include "rootfinder.hpp"
#include "casadi_enum.hpp"
 
namespace casadi {
 
  CASADI_EXPORT Function integrator(const std::string& name, const std::string& solver,
    const SXDict& dae, const Dict& opts=Dict());
  CASADI_EXPORT Function integrator(const std::string& name, const std::string& solver,
    const MXDict& dae, const Dict& opts=Dict());
  CASADI_EXPORT Function integrator(const std::string& name, const std::string& solver,
    const Function& dae, const Dict& opts=Dict());
  CASADI_EXPORT Function integrator(const std::string& name, const std::string& solver,
    const SXDict& dae, double t0, const std::vector<double>& tout, const Dict& opts=Dict());
  CASADI_EXPORT Function integrator(const std::string& name, const std::string& solver,
    const MXDict& dae, double t0, const std::vector<double>& tout, const Dict& opts=Dict());
  CASADI_EXPORT Function integrator(const std::string& name, const std::string& solver,
    const Function& dae, double t0, const std::vector<double>& tout, const Dict& opts=Dict());
#ifndef SWIGMATLAB
  CASADI_EXPORT Function integrator(const std::string& name, const std::string& solver,
    const SXDict& dae, double t0, double tf, const Dict& opts=Dict());
  CASADI_EXPORT Function integrator(const std::string& name, const std::string& solver,
    const MXDict& dae, double t0, double tf, const Dict& opts=Dict());
  CASADI_EXPORT Function integrator(const std::string& name, const std::string& solver,
    const Function& dae, double t0, double tf, const Dict& opts=Dict());
#endif // SWIGMATLAB
 
  CASADI_EXPORT bool has_integrator(const std::string& name);
 
  CASADI_EXPORT void load_integrator(const std::string& name);
 
  CASADI_EXPORT std::string doc_integrator(const std::string& name);
 
  CASADI_EXPORT std::vector<std::string> integrator_in();
 
  CASADI_EXPORT std::vector<std::string> integrator_out();
 
  CASADI_EXPORT std::string integrator_in(casadi_int ind);
 
  CASADI_EXPORT std::string integrator_out(casadi_int ind);
 
  CASADI_EXPORT casadi_int integrator_n_in();
 
  CASADI_EXPORT casadi_int integrator_n_out();
 
  CASADI_EXPORT std::vector<std::string> dyn_in();
 
  CASADI_EXPORT std::vector<std::string> dyn_out();
 
  CASADI_EXPORT std::string dyn_in(casadi_int ind);
 
  CASADI_EXPORT std::string dyn_out(casadi_int ind);
 
  CASADI_EXPORT casadi_int dyn_n_in();
 
  CASADI_EXPORT casadi_int dyn_n_out();
 
  CASADI_EXPORT std::vector<std::string> event_in();
 
  CASADI_EXPORT std::vector<std::string> event_out();
#ifndef SWIG
enum DynIn {
  DYN_T,
  DYN_X,
  DYN_Z,
  DYN_P,
  DYN_U,
  DYN_NUM_IN};
 
enum DynOut {
  DYN_ODE,
  DYN_ALG,
  DYN_QUAD,
  DYN_ZERO,
  DYN_NUM_OUT};
 
enum EventIn {
  EVENT_INDEX,
  EVENT_T,
  EVENT_X,
  EVENT_Z,
  EVENT_P,
  EVENT_U,
  EVENT_NUM_IN};
 
enum EventOut {
  EVENT_POST_X,
  EVENT_POST_Z,
  EVENT_NUM_OUT};
 
enum IntegratorInput {
  INTEGRATOR_X0,
  INTEGRATOR_Z0,
  INTEGRATOR_P,
  INTEGRATOR_U,
  INTEGRATOR_ADJ_XF,
  INTEGRATOR_ADJ_ZF,
  INTEGRATOR_ADJ_QF,
  INTEGRATOR_NUM_IN
};
 
enum IntegratorOutput {
  INTEGRATOR_XF,
  INTEGRATOR_ZF,
  INTEGRATOR_QF,
  INTEGRATOR_ADJ_X0,
  INTEGRATOR_ADJ_Z0,
  INTEGRATOR_ADJ_P,
  INTEGRATOR_ADJ_U,
  INTEGRATOR_NUM_OUT
};
 
template<> struct enum_traits<DynIn> {
  static const size_t n_enum = DYN_NUM_IN;
};
template<> struct enum_traits<DynOut> {
  static const size_t n_enum = DYN_NUM_OUT;
};
template<> struct enum_traits<EventIn> {
  static const size_t n_enum = EVENT_NUM_IN;
};
template<> struct enum_traits<EventOut> {
  static const size_t n_enum = EVENT_NUM_OUT;
};
 
CASADI_EXPORT std::string to_string(DynIn v);
CASADI_EXPORT std::string to_string(DynOut v);
CASADI_EXPORT std::string to_string(EventIn v);
CASADI_EXPORT std::string to_string(EventOut v);
 
#endif // SWIG
 
} // namespace casadi
 
#endif // CASADI_INTEGRATOR_HPP