Limit number of steps in boost::odeint integration - c++

Question

Say that I have the following boost::odeint code:
#include <iostream>
#include <boost/array.hpp>
#include <boost/numeric/odeint.hpp>
using namespace std;
using namespace boost::numeric::odeint;
const double sigma = 10.0;
const double R = 28.0;
const double b = 8.0 / 3.0;
typedef boost::array< double , 3 > state_type;
void lorenz( const state_type &x , state_type &dxdt , double t ){
dxdt[0] = sigma * ( x[1] - x[0] );
dxdt[1] = R * x[0] - x[1] - x[0] * x[2];
dxdt[2] = -b * x[2] + x[0] * x[1];
}
void write_lorenz( const state_type &x , const double t ){
cout << t << '\t' << x[0] << '\t' << x[1] << '\t' << x[2] << endl;
}
int main(int argc, char **argv){
state_type x = { 10.0 , 1.0 , 1.0 }; // initial conditions
cout<<"Steps: "<<integrate( lorenz , x , 0.0 , 25.0 , 0.1 , write_lorenz )<<endl;
}
How can I modify the code so that integrate will break after a certain number of steps? I'm running a large number of integrations and want to avoid spending too much time on integrating any particular system.
I've thought of using integrate_n_steps(), but this may mean that the integration proceeds past the end time I am interested in.

Answer 1

there is no integrate routine for this task at the moment. Nevertheless, you have several options:
First, use an observer in integrate() and throw an exception there if you exceed the number of maximal steps. Of course, this is not very elegant:
struct write_lorenz_and_check_steps
{
size_t m_steps;
write_lorenz_and_check_steps( void ) : m_steps( 0 ) { }
void operator()( const state_type &x , const double t ) const {
cout << t << '\t' << x[0] << '\t' << x[1] << '\t' << x[2] << endl;
++m_steps;
if( m_steps > max_steps ) throw runtime_error( "Too much steps" );
}
};
// ...
size_t steps = 0;
try {
steps = integrate( lorenz , x , 0.0 , 25.0 , 0.1 , write_lorenz );
} catch( ... ) { steps = max_steps; }
cout << steps << endl;
Second, you can write the stepping loop yourself:
// Attention: the code has not been check to compile
double tmax = 25.0;
size_t imax = 1000;
size_t i = 0;
auto stepper = make_dense_output( 1.0e-6 , 1.0e-6 , runge_kutta_dopri5< state_type >() );
stepper.initialize( x , t , dt );
while ( ( stepper.current_time() < tmax ) && ( i < imax ) )
{
observer( stepper.current_state() , stepper.current_time() );
stepper.do_step( lorenz() );
++i;
}
x = stepper.current_state();
In this example you also work directly with stepper.current_state() and stepper.current_time() instead of calling the observer. Furthermore, if you compiler does not support auto, i.e. you have a C++03 compiler just use
typedef runge_kutta_dopri5< state_type > stepper_type;
result_of::make_dense_output< stepper_type >::type stepper =
make_dense_output( 1.0e-6 , 1.0e-6 , stepper_type() );
We are also developing a special integrate routine exactly for this task. But it will still take some weeks until it is finished. Furthermore, we develop ode iterators which could also be used and which will be ready very soon (I hope at the next of next week).