AMRCore.h

#ifndef gridripper_amr1d_AMRCore_h
#define gridripper_amr1d_AMRCore_h

#include <gridripper/lang/IllegalArgumentException.h>
#include <gridripper/amr1d/io/GridBDataWriter.h>
#include <gridripper/math/expr/Evaluator.h>
#include "Grid.h"
#include "InitCond.h"

namespace gridripper { namespace amr1d {

class PDE;
class AMError;
class Integrator;

using namespace gridripper::math::expr;
using namespace gridripper::amr1d::io;

class AMRCore
{
private:
    bool debugMode;
    PDE* thePDE;
    AMError* amError;
    Integrator* integratorProto;
    Regridder* regridderProto;
    int refinementRatio;
    tvalarray< tvector<Grid*> > grids;
    Evaluator::Function* dtdxFunc;
    GReal_t deltaT0;
    GReal_t currentDeltaT0;
    bool currentDeltaT0Computed;
//    int lastRefinedTimeStep; // last time when adaptive time step
                             // was smaller than the default time step
    int finestLevel;
    int maxAllowedLevel;
    double errorTolerance;
    int errorCheckFreq;
    int regridFreq;
    int bufferZoneSize;
    int currentLevel;
    bool onInitialHypersurface;
    bool physicalFieldUsed;
    bool running;
    bool forceConstraints;
    bool energyWritten;

protected:
    AMRCore(const AMRCore& ai);

public:
    AMRCore(PDE* pde, InitCond& ini, bool constrforced,
            Integrator* gi, Regridder* rgdproto,
            const string& dtdx, int maxi, int npabovemax,
            int maxl, int r,
            AMError* amerr, double maxerr,
            int errchkf, int regridf, int bufzoner)
                throw(InitCond::Exception&, IllegalArgumentException&);

    virtual ~AMRCore();

    virtual AMRCore* cloneAMRCore() const =0;

    bool isRunning() const {
        return running;
    }

    void setRunning(bool r) {
        running = r;
    }

    virtual void output() =0;

    int getRefinementRatio() const {
        return refinementRatio;
    }

    int getMaxAllowedLevel() const {
        return maxAllowedLevel;
    }

    bool getDebug() const {
        return debugMode;
    }

    void setDebug(bool v) {
        debugMode = v;
    }

    bool isPhysicalFieldUsed() const {
        return physicalFieldUsed;
    }

    void setPhysicalFieldUsed(bool v) {
        physicalFieldUsed = v;
    }

    PDE& getPDE() const {
        return *thePDE;
    }

    double getErrorTolerance() const {
        return errorTolerance;
    }

    double getErrorToleranceDt(int l) const;

    int getErrorCheckFreq() const {
        return errorCheckFreq;
    }

    int getRegridFreq() const {
        return regridFreq;
    }

    int getBufferZoneSize() const {
        return bufferZoneSize;
    }

    int getCurrentLevel() const {
        return currentLevel;
    }

protected:
    void setCurrentLevel(int l) {
        currentLevel = l;
    }

    virtual bool isLastTime(const Grid& g) const =0;

public:
    Grid& getBaseGrid() const {
        return *grids[0][0];
    }

    GReal_t getDeltaT0() const {
        return deltaT0;
    }

    GReal_t getDeltaT() const {
        return currentDeltaT0;
    }

    bool isCurrentDeltaT0Computed() const {
        return currentDeltaT0Computed;
    }

    GReal_t getDeltaT(GReal_t dt, int l) const;

    bool isConstraintForced() const {
        return forceConstraints;
    }

    void setConstraintForced(bool v) {
        forceConstraints = v;
    }

    bool isEnergyWritten() const {
        return energyWritten;
    }

    void setEnergyWritten(bool v) {
        energyWritten = v;
    }

    GridBDataWriter* createBDataWriter() const;

    void integrate();

protected:
    virtual void coarseStepped(GReal_t t);

private:
    void evolve_hierarchy(int level, GReal_t dt, GReal_t dt_next,
                          int ir, int absrefinement);

    void evaluateEqs(Grid& g, GReal_t dt, int ir);

    void regrid(int level, GReal_t dt);

    void regrid(int level, GReal_t dt, int minLevel);

    GReal_t computeAdaptiveDeltaT() const;

    GReal_t computeExplicitDeltaT() const;
};

} } // namespace gridripper::amr1d

#endif /* gridripper_amr1d_AMRCore_h */