fortranODEfunction.h

#include "DoubleVector.h"
#include "VectorFunction.h"

#ifndef __FORTRAN_ODE_FUNCTION__
#define __FORTRAN_ODE_FUNCTION__
//
//#####################################################################
//                  fortranODEfunction.h
//#####################################################################
//
//            Class fortranODEfunction Declaration
//
//#####################################################################
/**
   \class fortranODEfunction
   
   \brief A wrapper class for a VectorFunction instance that 
   allows its evaluate(...) method to be accessed using a 
   function prototype of the form <code> int (*f)(double*t, double*y, double*yp)</code>.
 
   <p>
   This function prototype is that required by the f2c translation of 
   rkf45, a Runge-Kutta-Fehlberg 45 implementation. 
 
   <p>Since the VectorFunction class has no explicit t dependence, the t argument 
   is ignored in the evaluation process.
 
   <p> yp is determined from y using the evaluate member function
   of the associated VectorFunction. 

   <p>
   <p> Typical use: <br>
   <OL>
   <LI>   Set the dimension </LI>
   <LI>  Set the associated VectorFunction (or class derived from VectorFunction)</LI>
   <LI> Pass the function fortranODEfunction::f to the external routine.</LI>
   </OL>
   
   <p> Samples of setting the dimension and setting the function are
   <pre>
     fortranODEfunction::setDimension(2);
     fortranODEfunction::setFunction(&F);
   </pre>
 
   <p> The function fortranODEfunction::f has type 
   <code> int (*f)(double*, double*, double*) </code> and so 
  
   <pre> fortranODEfunction::f </pre>
 
    may be passed to function whose argument is a function  pointer of that type.
    
    <p> Fortran routines require that the member function of a 
    class passed into it be a static member function, hence there can only one
    instance of this class in use in a specific program. 
        
*/ 
//#####################################################################
// Chris Anderson (C) UCLA                               Jan. 22, 2009
//#####################################################################
//
class fortranODEfunction
{
    public :

    static VectorFunction* fODE;
    
    static int f(double* /* t */, double*y, double*yp) 
    {
    static long i;

    for(i =0; i < Vin.getSize(); i++) // pack y data into Vin
    {Vin(i) = y[i];}                 

    Vout  = fODE->evaluate(Vin);      // evaluate 

    for(i =0; i < Vout.getSize(); i++)// pack Vout data into yp
    {yp[i] = Vout(i);}

    return 0;
    }

    /// Sets the dimension of the VectorFunction argument. 
    
    static void setDimension(long idim)
    {Vin.initialize(idim); Vout.initialize(idim);}
    
    /// Sets the VectorFunction instance whose evaluate(...) member function will be called.
    static void setFunction(VectorFunction* Fptr)
    {fODE = Fptr;}

    static DoubleVector Vin;
    static DoubleVector Vout;
};
#endif

---