BoundedGrid.h

#ifndef gridripper_amr1d_BoundedGrid_h
#define gridripper_amr1d_BoundedGrid_h

#include "Grid.h"
#include <gridripper/lang/IllegalArgumentException.h>
#include <gridripper/tvalarray.h>

namespace gridripper { namespace amr1d {

using namespace std;

class BoundedGrid: public Grid
{
private:
    int marginLeft;

    int marginRight;

    int marginDecreaseLeft;

    int marginDecreaseRight;

    int leftmostI;

    int rightmostI;

    int numPointsAboveMaxX;

    bool insidePeriodicGrid;

protected:
    BoundedGrid(const BoundedGrid& g);

    BoundedGrid(const BoundedGrid& p,
                int dmargin_L, int dmargin_R, GReal_t xshift);

    BoundedGrid(Grid* p, int r1, int loci, int maxi, int margin,
                          int vmargin, int minLevel);

public:
    BoundedGrid(GReal_t minx, GReal_t maxx, int maxi, int npabovemax,
                int nc, Integrator* proto, Regridder* refproto, int r);

    Grid* cloneGrid() const {
        return new BoundedGrid(*this);
    }

    int getLeftmostI() const {
        return leftmostI;
    }

    int getRightmostI() const {
        return rightmostI;
    }

    bool isPeriodic() const {
        return false;
    }

    int getMarginLeft(int ir) const {
        return marginLeft - ir*marginDecreaseLeft;
    }

    int getMarginRight(int ir) const {
        return marginRight - ir*marginDecreaseRight;
    }

    int distanceFromLeft(int i) const {
        return i + marginLeft;
    }

    int distanceFromRight(int i) const {
        return getMaxI() + marginRight - i;
    }

    virtual int getNumPointsAboveMaxX() const {
        return numPointsAboveMaxX;
    }

    GReal_t getLocationX(int i) const;

    GReal_t getSizeX() const {
        return getMaxI()*getDeltaX();
    }

public:
    void initRefinedDataExistenceArray();

    bool hasRefinedData(int i) const {
        if(refinedDataExists.size() == 0) {
            return false;
        }
        int ml = marginLeft;
        int r = getRefinementRatio();
        int j = r*ml + i;
        if(j >= 0 && j < (int)refinedDataExists.size()) {
            return refinedDataExists[j];
        } else {
            return false;
        }
    }

    void getRefinedData(int i, GReal_t yout[]) const {
        int ml = marginLeft;
        int r = getRefinementRatio();
        unsigned nc = getNumComponents();
        int k = nc*(r*ml + i);
        for(unsigned i = 0; i < nc; ++i) {
            yout[i] = theData[k + i];
        }
    }

    Grid* createTemporaryGrid(int dmargin_L, int dmargin_R, GReal_t xshift) {
        return new BoundedGrid(*this, dmargin_L, dmargin_R, xshift);
    }

    void setTemporaryGridMargins(const Grid& p, int dmargin_L, int dmargin_R);

    Grid* createRefinedGrid(IntervalList* iv, int margin,
                            int vmargin, int minLevel, int r1);

    void interpolateMargins(PDE* pde);

    int getAbsoluteIndex(int i, int mul) const;

protected:
    int getInternalIndex(int i) const {
        return i + marginLeft;
    }

    int getSubgridIndexFromIndex(const Grid* g, int i) const {
        int r = getRefinementRatio();
        int j = r*i - g->getLocationI();
        return j;
    }

    int getIndexFromSubgridIndex(const Grid* g, int j) const {
        int r = getRefinementRatio();
        int i = (g->getLocationI() + j)/r;
        return i;
    }

    void fillRefinedDataArray();

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

    int getFirstIndexForRefinement(const tvalarray<unsigned char>& pf) const {
        return 0;
    }

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

    int intervalRefinedSize(const IntervalList* iv, int r) const;

    int gridIndexLeftOf(int i, int dmax) const {
        return i > dmax? i - dmax : 0;
    }

    int gridIndexRightOf(int i, int dmax) const {
        return i < getMaxI() - dmax? i + dmax : getMaxI();
    }

    void fixSubgridNearBounds(IntervalList* left, IntervalList* right,
                              int margin) const;

    int calcNewSubSubgridLocation(int ssloc, int osloc, int nsloc) {
        return ssloc + getRefinementRatio()*(osloc - nsloc);
    }
};

} } // namespace gridripper::amr1d

#endif /* gridripper_amr1d_BoundedGrid_h */