Re: LSODE speed up question

[Tatsuro MATSUOKA]

Hello

Sorry I sent the reply without finishing again:

--- Ayesha Kalra <address@hidden> wrote:

> Hi Tatsuro
> I can not furnish the whole code but, here is the heart of the code which
> solves the system of equations f
> 
> //*****************************************************************
> 
>  // initialize the solver by transfering the function f
> 
>          ODEFunc odef (f);
> 
>          // initialize the solver with XS and the initial time
> 
>          // as well as the ODEFunc object ode
> 
> 
> 
>          // LSODE options to be specified ***************************
> 
>          LSODE_options ();                // should specify a stiff solver
> 
> 
>          // *********************************************************
> 
> 
> 
>          LSODE ls(XS, 0.0, odef);
> 
>          // integrate
> 
>          y = ls.do_integrate(t);
> 
> 
> 
>          // append data
> 
>          X_and_S.insert(t,0,0);
> 
>          X_and_S.insert(y,0,1);
> 
> 
> 
> //*****************************************************************


The above is general code for LSODE in C++. (I have used a similar routine by 
myself.)
So the information is not so helpful for the discussion.


> The function f is a ColumnVector of length ~300. t is a ColumnVector of
> length 500. I got the idea to solve equations using LSODE in C++ from the
> following link


The step of t is not related to LSODE speed.  
LSODE automatically detemine the integration step 
if you do not specify it at lsode options.  
The vector t is used only for store integated data.
Only t(size-1) valuse is used to determine integration range.

Please read help lsode_options.
Those are to be set for the critical problem.

Tatsuro>Perhaps the function f is a key point.  Is your problem whether the 
your problem stiff or not?
Tatsuro>If it is not stiff, you can set lsode option to non-stiff.  
Tatsuro>At that case no Jacobian is used.  


>          LSODE_options ();                // should specify a stiff solver
Sorry you specfied stiff.

In addition, f is a ColumnVector of length ~300.  The function should be 
complex.
Olaf>A system of 300 ODEs seems a tough job to me ...

Indeed. 
f is a ColumnVector of length ~300 and stiff. Are ODEs nonlinear? Is there part 
in linear description
part to be possible.  If so such part can be speed upped by using sparse 
matrices.
However 300x300 matrix sparsing is effective or  not I do not know.
 


octave:2> help lsode_options
 -- Loadable Function:  lsode_options (OPT, VAL)
     When called with two arguments, this function allows you set
     options parameters for the function `lsode'.  Given one argument,
     `lsode_options' returns the value of the corresponding option.  If
     no arguments are supplied, the names of all the available options
     and their current values are displayed.

     Options include

    `"absolute tolerance"'
          Absolute tolerance.  May be either vector or scalar.  If a
          vector, it must match the dimension of the state vector.

    `"relative tolerance"'
          Relative tolerance parameter.  Unlike the absolute tolerance,
          this parameter may only be a scalar.

          The local error test applied at each integration step is

                 abs (local error in x(i)) <= ...
                     rtol * abs (y(i)) + atol(i)

    `"integration method"'
          A string specifying the method of integration to use to solve
          the ODE system.  Valid values are

         "adams"
         "non-stiff"
               No Jacobian used (even if it is available).

         "bdf"

         "stiff"
               Use stiff backward differentiation formula (BDF) method.
               If a function to compute the Jacobian is not supplied,
               `lsode' will compute a finite difference approximation
               of the Jacobian matrix.

    `"initial step size"'
          The step size to be attempted on the first step (default is
          determined automatically).

    `"maximum order"'
          Restrict the maximum order of the solution method.  If using
          the Adams method, this option must be between 1 and 12.
          Otherwise, it must be between 1 and 5, inclusive.

    `"maximum step size"'
          Setting the maximum stepsize will avoid passing over very
          large regions  (default is not specified).

    `"minimum step size"'
          The minimum absolute step size allowed (default is 0).

    `"step limit"'
          Maximum number of steps allowed (default is 100000). 

***************************************************
For details, please visit the page of lsode developper.

https://computation.llnl.gov/casc/odepack/odepack_home.html


Regards

Tatsuro



> http://info.ee.surrey.ac.uk/Personal/M.Michel/index.php?page=4&site=4
> 
> Your inputs are welcome.
> 
> Ayesha
> 
> On Fri, Apr 25, 2008 at 5:19 PM, Tatsuro MATSUOKA <address@hidden>
> wrote:
> 
> > If you would like to use Automatic Differentiation by Analytically,
> > please use symbolic package in octave-forge.
> > http://octave.sourceforge.net/packages.html
> > and see
> > http://wiki.octave.org/wiki.pl?CategorySymbolic
> >
> > If possible, please show the your C++ code.
> > That will make more fruitful discussion possible
> >
> >
> > Regards
> >
> > Tatsuro
> > --- Ayesha Kalra <address@hidden> wrote:
> >
> > > Hi all,
> > > I am using LSODE in a C++ program to solve a system of ~300 ODEs (500
> > time
> > > steps). I used LSODE in C++ so that I could get some performance
> > enhancement
> > > over using LSODE in Octave itself, however, there was no improvement in
> > > performance (measured in time (in sec) taken to solve the system of
> > > equations. It may be noted that in both cases, I am NOT supplying the
> > > Jacobian to LSODE. Can anyone tell me what is the bottleneck step for
> > LSODE,
> > > if it is calculation of Jacobian of the system,  I will try to calculate
> > it
> > > explicitly using some kind of Automatic Differentiation library and then
> > > supply it to LSODE (I am not sure, how to do this right now, any
> > > ideas/suggestions are welcome).
> > >
> > > Or, is there anything else I need to look/change to speed up solution by
> > > LSODE in C++.
> > >
> > > Thanks
> > > Ayesha
> > > > _______________________________________________
> > > Help-octave mailing list
> > > address@hidden
> > > https://www.cae.wisc.edu/mailman/listinfo/help-octave
> > >
> >


--------------------------------------
GANBARE! NIPPON! Win your ticket to Olympic Games 2008.
http://pr.mail.yahoo.co.jp/ganbare-nippon/