Interface for implementing dynamical systems. More...

#include <DynamicalSystem.hpp>

Inheritance diagram for DynamicalSystem:

[legend]

Public Member Functions
Constructors/Destructor
	DynamicalSystem (int order, double tau, Eigen::VectorXd initial_state, Eigen::VectorXd attractor_state, std::string name)
	Initialization constructor. More...

virtual	~DynamicalSystem (void)
	Destructor.

virtual DynamicalSystem *	clone (void) const =0
	Return a pointer to a deep copy of the DynamicalSystem object. More...

Main DynamicalSystem functions
virtual void	differentialEquation (const Eigen::Ref< const Eigen::VectorXd > &x, Eigen::Ref< Eigen::VectorXd > xd) const =0
	The differential equation which defines the system. More...

virtual void	analyticalSolution (const Eigen::VectorXd &ts, Eigen::MatrixXd &xs, Eigen::MatrixXd &xds) const =0
	Return analytical solution of the system at certain times. More...

virtual void	integrateStart (Eigen::Ref< Eigen::VectorXd > x, Eigen::Ref< Eigen::VectorXd > xd) const
	Start integrating the system. More...

void	integrateStart (const Eigen::VectorXd &x_init, Eigen::Ref< Eigen::VectorXd > x, Eigen::Ref< Eigen::VectorXd > xd)
	Start integrating the system with a new initial state. More...

virtual void	integrateStep (double dt, const Eigen::Ref< const Eigen::VectorXd > x, Eigen::Ref< Eigen::VectorXd > x_updated, Eigen::Ref< Eigen::VectorXd > xd_updated) const
	Integrate the system one time step. More...

Protected Member Functions
	DynamicalSystem (void)
	Default constructor. More...

Friends
class	boost::serialization::access
	Give boost serialization access to private members. More...

Input/Output
std::ostream &	operator<< (std::ostream &output, const DynamicalSystem &dyn_sys)
	Write a DynamicalSystem to an output stream. More...

virtual std::string	toString (void) const =0
	Returns a string representation of the object. More...

Accessor functions
enum	IntegrationMethod { EULER, RUNGE_KUTTA }
	The possible integration methods that can be used. More...

void	set_integration_method (IntegrationMethod integration_method)
	Choose the integration method. More...

int	dim (void) const
	Get the dimensionality of the dynamical system, i.e. More...

int	dim_orig (void) const
	Get the dimensionality of the dynamical system, i.e. More...

double	tau (void) const
	Accessor function for the time constant. More...

virtual void	set_tau (double tau)
	Mutator function for the time constant. More...

Eigen::VectorXd	initial_state (void) const
	Accessor function for the initial state of the dynamical system. More...

void	initial_state (Eigen::VectorXd &initial_state) const
	Accessor function for the initial state of the dynamical system. More...

virtual void	set_initial_state (const Eigen::VectorXd &initial_state)
	Mutator function for the initial state of the dynamical system. More...

Eigen::VectorXd	attractor_state (void) const
	Accessor function for the attractor state of the dynamical system. More...

void	attractor_state (Eigen::VectorXd &attractor_state) const
	Accessor function for the attractor state of the dynamical system. More...

virtual void	set_attractor_state (const Eigen::Ref< const Eigen::VectorXd > &attractor_state)
	Mutator function for the attractor state of the dynamical system. More...

std::string	name (void) const
	Accessor function for the name of the dynamical system. More...

virtual void	set_name (std::string name)
	Mutator function for the name of the dynamical system. More...

void	set_dim (int dim)
	Set the dimensionality of the dynamical system, i.e. More...

Detailed Description

Interface for implementing dynamical systems.

Other dynamical systems should inherit from this class.

Two pure virtual functions that each DynamicalSystem subclass should implement are

differentialEquation() : The differential equation that defines the system
analyticalSolution() : The analytical solution to the system at given times

This class provides accesor/mutator methods for some variables typically found in dynamical systems:

dim() The dimensionality of the system, i.e. the number of variables in the state vector.
tau() The time constant of the system
initial_state() The initial state of the system
attractor_state() The attractor state, i.e. the state to which the system will converge

This class also provides functionality for integrating a dynamical system by repeatidly calling it's differentialEquation, and doing simple Euler or 4th-order Runge-Kutta integration. The related functions are:

set_integration_method(IntegrationMethod), i.e. EULER or RUNGE_KUTTA
integrateStep() Integrate the system one time step, using the current integration method
integrateStart() Start integrating the system (does not require the current state to be passed)

Definition at line 62 of file DynamicalSystem.hpp.

Member Enumeration Documentation

enum IntegrationMethod

The possible integration methods that can be used.

EULER: simple Euler method (http://en.wikipedia.org/wiki/Euler_integration)
RUNGE_KUTTA: 4th-order Runge-Kutta (http://en.wikipedia.org/wiki/List_of_Runge%E2%80%93Kutta_methods#Classic_fourth-order_method)

Definition at line 190 of file DynamicalSystem.hpp.

190 { EULER, RUNGE_KUTTA };

Constructor & Destructor Documentation

DynamicalSystem	(	int	order,
		double	tau,
		Eigen::VectorXd	initial_state,
		Eigen::VectorXd	attractor_state,
		std::string	name
	)

Initialization constructor.

Parameters

order	Order of the system
tau	Time constant, see tau()
initial_state	Initial state, see initial_state()
attractor_state	Attractor state, see attractor_state()
name	A name you give, see name()

Definition at line 35 of file DynamicalSystem.cpp.

   : 
   // For 1st order systems, the dimensionality of the state vector 'x' is 'dim'
   // For 2nd order systems, the system is expanded to x = [y z], where 'y' and
   // 'z' are both of dimensionality 'dim'. Therefore dim(x) is 2*dim
   dim_(initial_state.size()*order),
   // The dimensionality of the system before a potential rewrite
   dim_orig_(initial_state.size()),
   tau_(tau),initial_state_(initial_state),attractor_state_(attractor_state),
   name_(name),integration_method_(RUNGE_KUTTA)
 {
   assert(order==1 || order==2);
   assert(initial_state.size()==attractor_state.size());
 }

DynamicalSystem ( void )

inlineprotected

Default constructor.

Remarks: This default constuctor is required for boost::serialization to work. See Boost serialization issues

Definition at line 375 of file DynamicalSystem.hpp.

375 {};

Here is the call graph for this function:

Member Function Documentation

virtual DynamicalSystem* clone ( void ) const

pure virtual

Return a pointer to a deep copy of the DynamicalSystem object.

Returns: Pointer to a deep copy

Implemented in Dmp, DmpWithGainSchedules, SpringDamperSystem, ExponentialSystem, TimeSystem, and SigmoidSystem.

virtual void differentialEquation	(	const Eigen::Ref< const Eigen::VectorXd > &	x,
		Eigen::Ref< Eigen::VectorXd >	xd
	)		const

pure virtual

The differential equation which defines the system.

It relates state values to rates of change of those state values

Parameters

[in]	x	current state (column vector of size dim() X 1)
[out]	xd	rate of change in state (column vector of size dim() X 1)

Remarks: x and xd should be of size dim() X 1. This forces you to pre-allocate memory, which speeds things up (and also makes Eigen's Ref functionality easier to deal with).

Implemented in Dmp, SpringDamperSystem, ExponentialSystem, TimeSystem, and SigmoidSystem.

virtual void analyticalSolution	(	const Eigen::VectorXd &	ts,
		Eigen::MatrixXd &	xs,
		Eigen::MatrixXd &	xds
	)		const

pure virtual

Return analytical solution of the system at certain times.

Parameters

[in]	ts	A vector of times for which to compute the analytical solutions
[out]	xs	Sequence of state vectors. T x D or D x T matrix, where T is the number of times (the length of 'ts'), and D the size of the state (i.e. dim())
[out]	xds	Sequence of state vectors (rates of change). T x D or D x T matrix, where T is the number of times (the length of 'ts'), and D the size of the state (i.e. dim())

Remarks: The output xs and xds will be of size D x T only if the matrix x you pass as an argument of size D x T. In all other cases (i.e. including passing an empty matrix) the size of x will be T x D. This feature has been added so that you may pass matrices of either size.

Implemented in Dmp, SpringDamperSystem, ExponentialSystem, TimeSystem, and SigmoidSystem.

void integrateStart	(	Eigen::Ref< Eigen::VectorXd >	x,
		Eigen::Ref< Eigen::VectorXd >	xd
	)		const

virtual

Start integrating the system.

Parameters

[out]	x	- The first vector of state variables
[out]	xd	- The first vector of rates of change of the state variables

Remarks: x and xd should be of size dim() X 1. This forces you to pre-allocate memory, which speeds things up (and also makes Eigen's Ref functionality easier to deal with).

Reimplemented in Dmp.

Definition at line 60 of file DynamicalSystem.cpp.

                                                                                                 {
   // Check size. Leads to faster numerical integration and makes Eigen::Ref easier to deal with   
   assert(x.size()==dim());
   assert(xd.size()==dim());
   
   // Return value for state variables
   // Pad the end with zeros: Why? In the spring-damper system, the state consists of x = [y z]. 
   // The initial state only applies to y. Therefore, we set x = [y 0]; 
   x.fill(0);
   x.segment(0,initial_state_.size()) = initial_state_;
   
   // Return value (rates of change)
   differentialEquation(x,xd);
 }

Here is the call graph for this function:

void integrateStart	(	const Eigen::VectorXd &	x_init,
		Eigen::Ref< Eigen::VectorXd >	x,
		Eigen::Ref< Eigen::VectorXd >	xd
	)

Start integrating the system with a new initial state.

Parameters

[in]	x_init	- The initial state vector
[out]	x	- The first vector of state variable
[out]	xd	- The first vector of rates of change of the state variables

Definition at line 54 of file DynamicalSystem.cpp.

 {
   set_initial_state(x_init);
   integrateStart(x,xd);
 }

Here is the call graph for this function:

void integrateStep	(	double	dt,
		const Eigen::Ref< const Eigen::VectorXd >	x,
		Eigen::Ref< Eigen::VectorXd >	x_updated,
		Eigen::Ref< Eigen::VectorXd >	xd_updated
	)		const

virtual

Integrate the system one time step.

Parameters

[in]	dt	Duration of the time step
[in]	x	Current state
[out]	x_updated	Updated state, dt time later.
[out]	xd_updated	Updated rates of change of state, dt time later.

Remarks: x should be of size dim() X 1. This forces you to pre-allocate memory, which speeds things up (and also makes Eigen's Ref functionality easier to deal with).

Definition at line 75 of file DynamicalSystem.cpp.

 {
   assert(dt>0.0);
   // Check size. Leads to faster numerical integration and makes Eigen::Ref easier to deal with   
   assert(x.size()==dim());
   if (integration_method_ == RUNGE_KUTTA)
     integrateStepRungeKutta(dt, x, x_updated, xd_updated);
   else
     integrateStepEuler(dt, x, x_updated, xd_updated);
 }

Here is the call graph for this function:

virtual std::string toString ( void ) const

pure virtual

Returns a string representation of the object.

Returns: A string representation of the object.

Implemented in Dmp, ExponentialSystem, SpringDamperSystem, SigmoidSystem, and TimeSystem.

void set_integration_method ( IntegrationMethod integration_method )

inline

Choose the integration method.

Parameters

[in] integration_method The integration method, see DynamicalSystem::IntegrationMethod.

Definition at line 195 of file DynamicalSystem.hpp.

                                                                            {
     integration_method_ = integration_method;
   }

int dim ( void ) const

inline

Get the dimensionality of the dynamical system, i.e.

the length of its state vector.

Returns: Dimensionality of the dynamical system

Definition at line 203 of file DynamicalSystem.hpp.

                              {
     return dim_;
   }

int dim_orig ( void ) const

inline

Get the dimensionality of the dynamical system, i.e.

the length of its output.

2nd order systems are represented as 1st order systems with an expanded state. The SpringDamperSystem for instance is represented as x = [y z], xd = [yd zd]. DynamicalSystem::dim() returns dim(x) = dim([y z]) = 2*dim(y) DynamicalSystem::dim_orig() returns dim(y) = dim()/2

For Dynamical Movement Primitives, dim_orig() may be for instance 3, if the output of the DMP represents x,y,z coordinates. However, dim() will have a much larger dimensionality, because it also contains the variables of all the subsystems (phase system, gating system, etc.)

Returns: Original dimensionality of the dynamical system

Definition at line 221 of file DynamicalSystem.hpp.

                                    {
     return dim_orig_;
    }

double tau ( void ) const

inline

Accessor function for the time constant.

Returns: Time constant

Definition at line 229 of file DynamicalSystem.hpp.

229 { return tau_; }

virtual void set_tau ( double tau )

inlinevirtual

Mutator function for the time constant.

Parameters

[in] tau Time constant

Reimplemented in Dmp, and SigmoidSystem.

Definition at line 235 of file DynamicalSystem.hpp.

                                           {
     assert(tau>0.0);
     tau_ = tau;
   }

Here is the call graph for this function:

Eigen::VectorXd initial_state ( void ) const

inline

Accessor function for the initial state of the dynamical system.

Returns: Initial state of the dynamical system.

Definition at line 244 of file DynamicalSystem.hpp.

244 { return initial_state_; }

void initial_state ( Eigen::VectorXd & initial_state ) const

inline

Accessor function for the initial state of the dynamical system.

Parameters

[out] initial_state Initial state of the dynamical system.

Definition at line 250 of file DynamicalSystem.hpp.

   { 
     initial_state=initial_state_;
   }

virtual void set_initial_state ( const Eigen::VectorXd & initial_state )

inlinevirtual

Mutator function for the initial state of the dynamical system.

Parameters

[in] initial_state Initial state of the dynamical system.

Reimplemented in Dmp, and SigmoidSystem.

Definition at line 258 of file DynamicalSystem.hpp.

                                                                             {
     assert(initial_state.size()==dim_orig_);
     initial_state_ = initial_state;
   }

Here is the call graph for this function:

Eigen::VectorXd attractor_state ( void ) const

inline

Accessor function for the attractor state of the dynamical system.

Returns: Attractor state of the dynamical system.

Definition at line 267 of file DynamicalSystem.hpp.

267 { return attractor_state_; }

void attractor_state ( Eigen::VectorXd & attractor_state ) const

inline

Accessor function for the attractor state of the dynamical system.

Parameters

[out] attractor_state Attractor state of the dynamical system.

Definition at line 273 of file DynamicalSystem.hpp.

   { 
     attractor_state=attractor_state_;
   }

virtual void set_attractor_state ( const Eigen::Ref< const Eigen::VectorXd > & attractor_state )

inlinevirtual

Mutator function for the attractor state of the dynamical system.

Parameters

[in] attractor_state Attractor state of the dynamical system.

Definition at line 281 of file DynamicalSystem.hpp.

                                                                                                 {
     assert(attractor_state.size()==dim_orig_);
     attractor_state_ = attractor_state;
   }

Here is the call graph for this function:

std::string name ( void ) const

inline

Accessor function for the name of the dynamical system.

Returns: Name of the dynamical system.

Definition at line 290 of file DynamicalSystem.hpp.

290 { return name_; }

virtual void set_name ( std::string name )

inlinevirtual

Mutator function for the name of the dynamical system.

Parameters

[in] name Name of the dynamical system.

Definition at line 295 of file DynamicalSystem.hpp.

                                                {
     name_ = name;
   }

Here is the call graph for this function:

void set_dim ( int dim )

inlineprotected

Set the dimensionality of the dynamical system, i.e.

the length of its state vector.

Parameters

[in] dim Dimensionality of the dynamical system

Definition at line 304 of file DynamicalSystem.hpp.

                                {
     dim_ = dim;
   }

Here is the call graph for this function:

Friends And Related Function Documentation

friend class boost::serialization::access

friend

Give boost serialization access to private members.

Definition at line 375 of file DynamicalSystem.hpp.

std::ostream& operator<<	(	std::ostream &	output,
		const DynamicalSystem &	dyn_sys
	)

friend

Write a DynamicalSystem to an output stream.

Parameters

[in]	output	Output stream to which to write to
[in]	dyn_sys	Dynamical system to write

Returns: Output stream

Remarks: Calls pure virtual function toString(), which must be implemented by all subclasses: http://stackoverflow.com/questions/4571611/virtual-operator

Definition at line 169 of file DynamicalSystem.hpp.

                                                                                     {
     output << dyn_sys.toString();
     return output;
   }

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

Public Member Functions

Protected Member Functions

Friends

Input/Output

Accessor functions

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation