| Home | Libraries | People | FAQ | More

## Class template symplectic_nystroem_stepper_base

boost::numeric::odeint::symplectic_nystroem_stepper_base — Base class for all symplectic steppers of Nystroem type.

## Synopsis

    // In header: <boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp>

    template<size_t NumOfStages, unsigned short Order, typename Coor,
             typename Momentum, typename Value, typename CoorDeriv,
             typename MomentumDeriv, typename Time, typename Algebra,
             typename Operations, typename Resizer>
    class symplectic_nystroem_stepper_base :
      public boost::numeric::odeint::algebra_stepper_base< Algebra, Operations >
    {
    public:
      // types
      typedef algebra_stepper_base< Algebra, Operations >       algebra_stepper_base_type;
      typedef algebra_stepper_base_type::algebra_type           algebra_type;
      typedef algebra_stepper_base_type::operations_type        operations_type;
      typedef Coor                                              coor_type;
      typedef Momentum                                          momentum_type;
      typedef std::pair< coor_type, momentum_type >             state_type;
      typedef CoorDeriv                                         coor_deriv_type;
      typedef state_wrapper< coor_deriv_type >                  wrapped_coor_deriv_type;
      typedef MomentumDeriv                                     momentum_deriv_type;
      typedef state_wrapper< momentum_deriv_type >              wrapped_momentum_deriv_type;
      typedef std::pair< coor_deriv_type, momentum_deriv_type > deriv_type;
      typedef Value                                             value_type;
      typedef Time                                              time_type;
      typedef Resizer                                           resizer_type;
      typedef stepper_tag                                       stepper_category;
      typedef unsigned short                                    order_type;
      typedef boost::array< value_type, num_of_stages >         coef_type;

      // public member functions
       m_coef_a(coef_a);
       m_coef_b(coef_b);
       m_dqdt_resizer();
       m_dpdt_resizer();
       m_dqdt();
       m_dpdt();
      order_type order(void) const;
      template<typename System, typename StateInOut>
        void do_step(System, const StateInOut &, time_type, time_type);
      template<typename System, typename StateInOut>
        void do_step(System, StateInOut &, time_type, time_type);
      template<typename System, typename CoorInOut, typename MomentumInOut>
        void do_step(System, CoorInOut &, MomentumInOut &, time_type, time_type);
      template<typename System, typename CoorInOut, typename MomentumInOut>
        void do_step(System, const CoorInOut &, const MomentumInOut &, time_type,
                     time_type);
      template<typename System, typename StateIn, typename StateOut>
        void do_step(System, const StateIn &, time_type, StateOut &, time_type);
      template<typename StateType> void adjust_size(const StateType &);
      const coef_type & coef_a(void) const;
      const coef_type & coef_b(void) const;
      const algebra_type & algebra() const;

      // private member functions
      template<typename System, typename StateIn, typename StateOut>
        void do_step_impl(System, const StateIn &, time_type, StateOut &,
                          time_type, boost::mpl::true_);
      template<typename System, typename StateIn, typename StateOut>
        void do_step_impl(System, const StateIn &, time_type, StateOut &,
                          time_type, boost::mpl::false_);
      template<typename StateIn> bool resize_dqdt(const StateIn &);
      template<typename StateIn> bool resize_dpdt(const StateIn &);

      // public data members
      static const size_t num_of_stages;
      static const order_type order_value;
       __pad0__;
    };

## Description

This class is the base class for the symplectic Runge-Kutta-Nystroem steppers. Symplectic steppers are usually used to solve Hamiltonian systems and they conserve the phase space volume, see en.wikipedia.org/wiki/Symplectic_integrator. Furthermore, the energy is conserved in average. In detail this class of steppers can be used to solve separable Hamiltonian systems which can be written in the form H(q,p) = H1(p) + H2(q). q is usually called the coordinate, while p is the momentum. The equations of motion are dq/dt = dH1/dp, dp/dt = -dH2/dq.

ToDo : add formula for solver and explanation of the coefficients

symplectic_nystroem_stepper_base uses odeints algebra and operation system. Step size and error estimation are not provided for this class of solvers. It derives from algebra_stepper_base. Several `do_step` variants are provided:

- `do_step( sys , x , t , dt )` - The classical `do_step` method. The sys can be either a pair of function objects for the coordinate or the momentum part or one function object for the momentum part. `x` is a pair of coordinate and momentum. The state is updated in-place.

- `do_step( sys , q , p , t , dt )` - This method is similar to the method above with the difference that the coordinate and the momentum are passed explicitly and not packed into a pair.

- `do_step( sys , x_in , t , x_out , dt )` - This method transforms the state out-of-place. `x_in` and `x_out` are here pairs of coordinate and momentum.

### Template Parameters

1.     size_t NumOfStages

   Number of stages.

2.     unsigned short Order

   The order of the stepper.

3.     typename Coor

   The type representing the coordinates q.

4.     typename Momentum

   The type representing the coordinates p.

5.     typename Value

   The basic value type. Should be something like float, double or a high-precision type.

6.     typename CoorDeriv

   The type representing the time derivative of the coordinate dq/dt.

7.     typename MomentumDeriv

8.     typename Time

   The type representing the time t.

9.     typename Algebra

   The algebra.

10.     typename Operations

    The operations.

11.     typename Resizer

    The resizer policy.

### `symplectic_nystroem_stepper_base` public member functions

1.      m_coef_a(coef_a);

2.      m_coef_b(coef_b);

3.      m_dqdt_resizer();

4.      m_dpdt_resizer();

5.      m_dqdt();

6.      m_dpdt();

7.     order_type order(void) const;

   Returns: | Returns the order of the stepper.

8.     template<typename System, typename StateInOut>
         void do_step(System system, const StateInOut & state, time_type t,
                      time_type dt);

   This method performs one step. The system can be either a pair of two function object describing the momentum part and the coordinate part or one function object describing only the momentum part. In this case the coordinate is assumed to be trivial dq/dt = p. The state is updated in-place.

   | Note
   boost::ref or std::ref can be used for the system as well as for the state. So, it is correct to write `stepper.do_step( make_pair( std::ref( fq ) , std::ref( fp ) ) , make_pair( std::ref( q ) , std::ref( p ) ) , t , dt )`. This method solves the forwarding problem.

   Parameters: |
   `dt` | The time step.
   `state` | The state of the ODE. It is a pair of Coor and Momentum. The state is updated in-place, therefore, the new value of the state will be written into this variable.
   `system` | The system, can be represented as a pair of two function object or one function object. See above.
   `t` | The time of the ODE. It is not advanced by this method.

9.     template<typename System, typename StateInOut>
         void do_step(System system, StateInOut & state, time_type t, time_type dt);

   Same function as above. It differs only in a different const specifier in order to solve the forwarding problem, can be used with Boost.Range.

10.     template<typename System, typename CoorInOut, typename MomentumInOut>
          void do_step(System system, CoorInOut & q, MomentumInOut & p, time_type t,
                       time_type dt);

    This method performs one step. The system can be either a pair of two function object describing the momentum part and the coordinate part or one function object describing only the momentum part. In this case the coordinate is assumed to be trivial dq/dt = p. The state is updated in-place.

    | Note
    boost::ref or std::ref can be used for the system. So, it is correct to write `stepper.do_step( make_pair( std::ref( fq ) , std::ref( fp ) ) , q , p , t , dt )`. This method solves the forwarding problem.

    Parameters: |
    `dt` | The time step.
    `p` | The momentum of the ODE. It is updated in-place. Therefore, the new value of the momentum will be written info this variable.
    `q` | The coordinate of the ODE. It is updated in-place. Therefore, the new value of the coordinate will be written into this variable.
    `system` | The system, can be represented as a pair of two function object or one function object. See above.
    `t` | The time of the ODE. It is not advanced by this method.

11.     template<typename System, typename CoorInOut, typename MomentumInOut>
          void do_step(System system, const CoorInOut & q, const MomentumInOut & p,
                       time_type t, time_type dt);

    Same function as do_step( system , q , p , t , dt ). It differs only in a different const specifier in order to solve the forwarding problem, can be called with Boost.Range.

12.     template<typename System, typename StateIn, typename StateOut>
          void do_step(System system, const StateIn & in, time_type t, StateOut & out,
                       time_type dt);

    This method performs one step. The system can be either a pair of two function object describing the momentum part and the coordinate part or one function object describing only the momentum part. In this case the coordinate is assumed to be trivial dq/dt = p. The state is updated out-of-place.

    | Note
    boost::ref or std::ref can be used for the system. So, it is correct to write `stepper.do_step( make_pair( std::ref( fq ) , std::ref( fp ) ) , x_in , t , x_out , dt )`. This method NOT solve the forwarding problem.

    Parameters: |
    `dt` | The time step.
    `in` | The state of the ODE, which is a pair of coordinate and momentum. The state is updated out-of-place, therefore the new value is written into out
    `out` | The new state of the ODE.
    `system` | The system, can be represented as a pair of two function object or one function object. See above.
    `t` | The time of the ODE. It is not advanced by this method.

13.     template<typename StateType> void adjust_size(const StateType & x);

    Adjust the size of all temporaries in the stepper manually.

    Parameters: |
    `x` | A state from which the size of the temporaries to be resized is deduced.

14.     const coef_type & coef_a(void) const;

    Returns the coefficients a.

15.     const coef_type & coef_b(void) const;

    Returns the coefficients b.

16.     const algebra_type & algebra() const;

    Returns: | A reference to the algebra which is held by this class. A const reference to the algebra which is held by this class.

### `symplectic_nystroem_stepper_base` private member functions

1.     template<typename System, typename StateIn, typename StateOut>
         void do_step_impl(System system, const StateIn & in, time_type t,
                           StateOut & out, time_type dt, boost::mpl::true_);

2.     template<typename System, typename StateIn, typename StateOut>
         void do_step_impl(System system, const StateIn & in, time_type,
                           StateOut & out, time_type dt, boost::mpl::false_);

3.     template<typename StateIn> bool resize_dqdt(const StateIn & x);

4.     template<typename StateIn> bool resize_dpdt(const StateIn & x);