Regridder.h

#ifndef gridripper_amr1d_Regridder_h
#define gridripper_amr1d_Regridder_h

#include <gridripper/config.h>
#include <gridripper/tvalarray.h>

namespace gridripper { namespace amr1d {

class Grid;
class Integrator;
class IntervalList;

class Regridder
{
    friend class Grid;

public:
    virtual ~Regridder() { }

    virtual Regridder* newRegridder(const Grid& p) =0;

    virtual Regridder* cloneRegridder() =0;

    virtual bool isDynamic() {
        return false;
    }

    virtual bool isFlagged(int i) {
        return false;
    }

    virtual void setFlagged(int i, bool v);

    virtual int getInvFreqUnit() =0;

    virtual bool isErrorEstimated() =0;

    virtual void setLastRegridTime(int t) =0;

    virtual int getLastRegridTime() =0;

    virtual bool checkRegriddingIsDue(Grid& g, int maxAllowedLevel,
                                      bool onInitialHypersurface,
                                      int r, int ir,
                                      int errorCheckFreq,
                                      int regridFreq) =0;

    virtual void init(int maxi) {
    }

    virtual void checkErrors(Integrator* integrator, double critical) {
    }

    virtual IntervalList* getIntervalList(const Grid& grid,
            tvalarray<Grid*>& newSubSubgrids, int minl, int maxl,
            int numvel, int margin, int bufzoneradius, int tsc) =0;

    virtual void beginTimeStep(const Grid& baseg) =0;

    virtual void endTimeStep(GReal_t t) =0;

protected:
    virtual bool hasUncoveredFlaggedPoint(const Grid& grid,
                                          const tvalarray<Grid*>& subGrids,
                                          int margin) =0;

    static void blur(const Grid& g, tvalarray<unsigned char>& pf, int i);

    int getFirstIndexForRefinement(const Grid& g,
                                   const tvalarray<unsigned char>& pf) const;

    int findIntervalEndForRefinement(const Grid& g,
                                     const tvalarray<unsigned char>& pf,
                                     int i) const;

    int intervalRefinedSize(const Grid& g, const IntervalList* iv, int r)
            const;

    int gridIndexLeftOf(const Grid& g, int i, int dmax);

    int gridIndexRightOf(const Grid& g, int i, int dmax);

    static void fixSubgridNearBounds(const Grid& g,
                                     IntervalList* l, IntervalList* r,
                                     int margin);
};

} } // namespace gridripper::amr1d

#endif /* gridripper_amr1d_Regridder_h */