DefaultRegridder.h

#ifndef gridripper_amr1d_regridder_DefaultRegridder_h
#define gridripper_amr1d_regridder_DefaultRegridder_h

#include <gridripper/amr1d/Regridder.h>
#include <gridripper/tvalarray.h>

namespace gridripper { namespace amr1d { namespace regridder {

using namespace gridripper::amr1d;

class DefaultRegridder: public Regridder
{
protected:
    tvalarray<bool> pointFlags;

private:
    int lastRegridTime;

public:
    DefaultRegridder();

protected:
    DefaultRegridder(const Grid& p);

    DefaultRegridder(const DefaultRegridder& r);

public:
    virtual Regridder* newRegridder(const Grid& p) {
        return new DefaultRegridder(p);
    }

    virtual Regridder* cloneRegridder() {
        return new DefaultRegridder(*this);
    }

    bool isFlagged(int i) {
        return pointFlags[i];
    }

    bool isDynamic() {
        return true;
    }

    void setFlagged(int i, bool v) {
        pointFlags[i] = v;
    }

    int getInvFreqUnit() {
        return 1;
    }

    bool isErrorEstimated() {
        return true;
    }

    void setLastRegridTime(int t) {
        lastRegridTime = t;
    }

    int getLastRegridTime() {
        return lastRegridTime;
    }

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

    void init(int maxi) {
        pointFlags.resize(maxi + 1);
    }

    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);

    virtual void beginTimeStep(const Grid& baseg) {
    }

    virtual void endTimeStep(GReal_t t) {
    }

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

private:
    tvalarray<unsigned char> blurPointFlags(const Grid& grid, int radius);

    static void fillInterval(tvalarray<Grid*>& d, IntervalList* iv, Grid* g);
};

} } } // namespace gridripper::amr1d::regridder

#endif /* gridripper_amr1d_regridder_DefaultRegridder_h */