LayeredGrid.h

Go to the documentation of this file.

#ifndef _LayeredGrid_
#define _LayeredGrid_
#include <vapor/common.h>
#include "RegularGrid.h"
#include "StretchedGrid.h"
 
namespace VAPoR {
 
//
class VDF_API LayeredGrid : public StructuredGrid {
public:
    LayeredGrid(const DimsType &dims, const DimsType &bs, const std::vector<float *> &blks, const std::vector<double> &xcoords, const std::vector<double> &ycoords, const RegularGrid &rg);
    LayeredGrid(const std::vector<size_t> &dims, const std::vector<size_t> &bs, const std::vector<float *> &blks, const std::vector<double> &xcoords, const std::vector<double> &ycoords,
                const RegularGrid &rg);
 
    LayeredGrid() = default;
    virtual ~LayeredGrid() = default;
 
    virtual size_t GetGeometryDim() const override { return (3); }
 
    virtual DimsType GetCoordDimensions(size_t dim) const override;
 
    static std::string GetClassType() { return ("Layered"); }
    std::string        GetType() const override { return (GetClassType()); }
 
    float GetValue(const CoordType &coords) const override;
 
    //
    virtual int GetInterpolationOrder() const override { return _interpolationOrder; };
 
    virtual void SetInterpolationOrder(int order) override;
 
    virtual void GetBoundingBox(const DimsType &min, const DimsType &max, CoordType &minu, CoordType &maxu) const override;
 
    virtual void GetUserCoordinates(const DimsType &indices, CoordType &coords) const override;
 
    // For grandparent inheritance of
    // Grid::GetUserCoordinates(const size_t indices[], double coords[])
    //
    using Grid::GetUserCoordinates;
 
    virtual bool GetIndicesCell(const CoordType &coords, DimsType &indices) const override;
 
    // For grandparent inheritance of
    // Grid::GetIndicesCell(const double coords[3], size_t indices[3])
    //
    using Grid::GetIndicesCell;
 
    bool InsideGrid(const CoordType &coords) const override;
 
    //
    virtual void SetPeriodic(const std::vector<bool> &periodic) override
    {
        VAssert(periodic.size() == 3);
        std::vector<bool> myPeriodic = periodic;
        myPeriodic[2] = false;
        Grid::SetPeriodic(myPeriodic);
    }
 
    const RegularGrid &GetZRG() const { return (_zrg); };
 
    class ConstCoordItrLayered : public Grid::ConstCoordItrAbstract {
    public:
        ConstCoordItrLayered(const LayeredGrid *rg, bool begin);
        ConstCoordItrLayered(const ConstCoordItrLayered &rhs);
 
        ConstCoordItrLayered();
        virtual ~ConstCoordItrLayered() {}
 
        virtual void            next();
        virtual void            next(const long &offset);
        virtual ConstCoordType &deref() const { return (_coords); }
        virtual const void *    address() const { return this; };
 
        virtual bool equal(const void *rhs) const
        {
            const ConstCoordItrLayered *itrptr = static_cast<const ConstCoordItrLayered *>(rhs);
 
            return (_zCoordItr == itrptr->_zCoordItr);
        }
 
        virtual std::unique_ptr<ConstCoordItrAbstract> clone() const { return std::unique_ptr<ConstCoordItrAbstract>(new ConstCoordItrLayered(*this)); };
 
    private:
        const LayeredGrid *          _lg;
        size_t                       _nElements2D;
        CoordType                    _coords;
        size_t                       _index2D;
        ConstIterator                _zCoordItr;
        StretchedGrid::ConstCoordItr _itr2D;
    };
 
    virtual ConstCoordItr ConstCoordBegin() const override { return ConstCoordItr(std::unique_ptr<ConstCoordItrAbstract>(new ConstCoordItrLayered(this, true))); }
    virtual ConstCoordItr ConstCoordEnd() const override { return ConstCoordItr(std::unique_ptr<ConstCoordItrAbstract>(new ConstCoordItrLayered(this, false))); }
 
protected:
    virtual void GetUserExtentsHelper(CoordType &minu, CoordType &maxu) const override;
 
private:
    StretchedGrid       _sg2d;    // horizontal coordinates maintained in stretched grid
    RegularGrid         _zrg;     // vertical coords are the values of a regular grid
    std::vector<double> _xcoords;
    std::vector<double> _ycoords;
    CoordType           _minu = {{0.0, 0.0, 0.0}};
    CoordType           _maxu = {{0.0, 0.0, 0.0}};
    int                 _interpolationOrder;
 
    void _layeredGrid(const DimsType &dims, const DimsType &bs, const std::vector<float *> &blks, const std::vector<double> &xcoords, const std::vector<double> &ycoords, const RegularGrid &rg);
 
    virtual float GetValueNearestNeighbor(const CoordType &coords) const override;
 
    virtual float GetValueLinear(const CoordType &coords) const override;
 
    //
    void _getBilinearWeights(const double coords[3], double &iwgt, double &jwgt) const;
 
 
    double _bilinearElevation(size_t i0, size_t i1, size_t j0, size_t j1, size_t k0, double iwgt, double jwgt) const;
 
    double _bilinearInterpolation(size_t i0, size_t i1, size_t j0, size_t j1, size_t k0, double iwgt, double jwgt) const;
 
    float _getValueQuadratic(const double coords[3]) const;
 
    double _verticalLinearInterpolation(double x, double y, double z) const;
 
    double _interpolateVaryingCoord(size_t i0, size_t j0, size_t k0, double x, double y) const;
 
    bool _insideGrid(const CoordType &coords, DimsType &indices, double wgts[3]) const;
};
};    // namespace VAPoR
#endif