Integrator.h

#ifndef gridripper_amr1d_Integrator_h
#define gridripper_amr1d_Integrator_h

#include <gridripper/config.h>
#include <gridripper/tvalarray.h>
#include "Grad.h"
#include "Sigma.h"
#include <string>

namespace gridripper { namespace amr1d {

using namespace std;

class PDE;
class Grid;
class GridInterpolator;
class AMError;

class Integrator
{
    friend class Grid;

private:
    tvalarray<double> errors;

    PDE& thePDE;

    Grid* theGrid;

    GReal_t deltaT;

    bool ownsInterpolator;

    GridInterpolator* interpolator;

    int interpolatorType;

    Sigma* theSigma;

protected:
    Grad* gradOp;
    Grad* gradOp2;

protected:
    int timeStepCount;

    Integrator(const Integrator& gi, Grid& g);

    Integrator(Grid* g, PDE& pde, const tvalarray<string>* optsarr,
               int deftype, Sigma* sigma);

    Integrator(Grid* g, PDE& pde, Grad* d, Grad* d2, int deftype,
               Sigma* sigma);

    void calcErrors(const AMError& amerr, const Grid& g, const Grid& g2,
                    double c);

public:
    virtual ~Integrator();

    Grad& getGrad() const {
        return *gradOp;
    }

    const GridInterpolator* getInterpolator() const {
        return interpolator;
    }

    int getInterpolatorType() const {
        return interpolatorType;
    }

    int getInterpolationBufferSize() const {
        int t = interpolatorType;
        if(t == 5) {
            return 4;
        } else if(t == 3) {
            return 2;
        } else {
            return 0;
        }
    }

    virtual void integrate(int ir) =0;

    virtual void richardson(const AMError& amerr, int ir) =0;

    double getError(int i) const {
        return errors[i];
    }

    void setTimeStepCount(int tsc) {
        timeStepCount = tsc;
    }

    int getTimeStepCount() const {
        return timeStepCount;
    }

    virtual void getResult(int i, tvalarray<GReal_t>& w) const =0;

    virtual int getNumVelocity() const =0;

    virtual Integrator* createIntegrator(Grid& g, const Sigma* sigma) const =0;

    virtual Integrator* cloneIntegrator(Grid& g) const =0;

    const Sigma& getSigma() const {
        return *theSigma;
    }

    GReal_t getDeltaT() const {
        return deltaT;
    }

    void setDeltaT(GReal_t dt) {
        deltaT = dt;
    }

    Grid* getGrid() const {
        return theGrid;
    }

    PDE& getPDE() const {
        return thePDE;
    }

    void updateGrid(int ir);
};

} } // namespace gridripper::amr1d

#endif /* gridripper_amr1d_Integrator_h */