amroc/hds/GridUnitList.h

Go to the documentation of this file.

// -*- C++ -*-

#ifndef _included_GridUnitList_h
#define _included_GridUnitList_h

#include "DAGHDefaults.h"
#include "BBoxList.h"
#include "GridUnit.h"
#include "BucketType.h"
#include "ObjectCounter.h"

#include <iosfwd>
#include <cstdlib>

#ifndef DefGridUnitListSize
#define DefGridUnitListSize (128)
#endif

#ifndef DefMinimumGUExtent
#define DefMinimumGUExtent  (1)
#endif

class GridUnitList : public Bucket<GridUnit>, public ObjectCounter
{
public:
    /*************************************************************************/
    /*** Constructors ***/
    /*************************************************************************/
    inline GridUnitList()
        : Bucket<GridUnit>(DefGridUnitListSize) {}

    // Declare single-arg constructors explicit to avoid unintended conversions
    explicit GridUnitList(const unsigned int maxnum)
        : Bucket<GridUnit>(maxnum) {}

    inline GridUnitList(const void* package, const unsigned int size, 
                        const int n)
        : Bucket<GridUnit>(package, size, n) {}

    GridUnitList(const GridUnitList& other)
        : Bucket<GridUnit>(other) {}

    GridUnitList(GridUnitList**& levarray);

    /*************************************************************************/
    /*** Assignment operator ***/
    /*************************************************************************/
    GridUnitList& operator=(const GridUnitList&);

    /*************************************************************************/
    /*** The destructor ***/
    /*************************************************************************/
    inline ~GridUnitList(void) {}

    /*************************************************************************/
    /*** For the object counter ***/
    /*************************************************************************/
    inline GridUnitList* alias()
        { return dynamic_cast<GridUnitList*>(ObjectCounter::alias()); }

    /*************************************************************************/
    /*** GUL operators ***/
    /*************************************************************************/
    void operator-=(const GridUnitList &rhs); /* Difference */
    void operator*=(const GridUnitList &rhs); /* Intersaction */
    GridUnitList* operator-(const GridUnitList &rhs); /* Abs Difference */
    GridUnitList* operator*(const GridUnitList &rhs); /* Intersection */
    GridUnitList* operator+(const GridUnitList &rhs); /* Union */

    /*************************************************************************/
    /*** GUL operations with a BBox & BBoxList ***/
    /*************************************************************************/
public: 
    void operator*=(const BBox &rhs); /* Intersection */
private: 
    GridUnitList* operator*(const BBox &rhs); /* Intersection */
    GridUnitList* operator*(const BBoxList &rhs); /* Intersection */
 
    /*************************************************************************/
    /*** GUL intersection with a BBox & BBoxList ***/
    /*************************************************************************/
public:
    void intersect(const BBox &rhs, const int lev, GridUnitList &gul, 
                   const int olap, const int extgh=0);
    void intersect(const BBoxList &rhs, const int lev, GridUnitList &gul, 
                   const int olap, const int extgh=0);
    void intersect(const BBox &rhs, const int lev, GridUnitList &gul, 
                   const short* olap, const int extgh=0);
    void intersect(const BBoxList &rhs, const int lev, GridUnitList &gul,
                   const short* olap, const int extgh=0);

    /*************************************************************************/
    /*** Query functions ***/
    /*************************************************************************/
public:
    unsigned long load(const int olap);
    unsigned long load(const int lev, const int olap);
    unsigned long numelems(const int olap);
    unsigned long numelems(const int lev, const int olap);
  
    unsigned long load(const short* olap);
    unsigned long load(const int lev, const short* olap);
    unsigned long numelems(const short* olap);
    unsigned long numelems(const int lev, const short* olap);

    int levels(void);
    int finest(void);
    int smallest(const int level);
    int highestbaselevel();
    dMapIndex lowest();
    dMapIndex lowest(const int level, const int owner, const int index);
    int maxindex(void);

    /*************************************************************************/
    /*** Set list stats ***/
    /*************************************************************************/
private:
    void setindex(void);
    void setindex(const int idx);
    void setindex(const GridUnitList& cgul, const int idx);
    void setbbox();
public:
    void setowner(const int p);
    void setowner(const GridUnitList& cgul, const int p);

    /*************************************************************************/
    /*** Array of GridUnitList's for the levels ***/
    /*************************************************************************/
    void levelarray(GridUnitList **& levarray, const int levels);

    /*************************************************************************/
    /*** GridUnitList for a particular level ***/
    /*************************************************************************/
    void levellist(GridUnitList &gul, const int lev);
    void levellist(GridUnitList &gul, const int minlev, const int maxlev);

    /*************************************************************************/
    /*** BBoxList for a particular level ***/
    /*************************************************************************/
public:
    void bboxlistfinest(BBoxList &bbl, const int lev);
    void bboxlist(BBoxList &bbl, const int lev, const int olap);
    void bboxlist(BBoxList &bbl, const int lev, const int olap, 
                  const int levid); 
    void bboxlist(BBoxList &bbl, const int lev, const short* olap,
                  const int extgh);
    void bboxlist(BBoxList &bbl, const int lev, const short* olap, 
                  const int levid, const int extgh);
    /*************************************************************************/
    /*************************************************************************/
    GridUnitList* refinelist(const int atlev, const int levs=1);

    /*************************************************************************/
    /*** Refine as per bounding box list ***/
    /*************************************************************************/
    GridUnitList* refinelist(const BBoxList &bblist, 
                             const int atlev, 
                             const int minw);
   
    void refinethislist(const BBoxList& bblist, 
                        const int atlev, 
                        const int minw);

    /*************************************************************************/
    /*** Operations on the current GridUnit ***/
    /*************************************************************************/
private:
    inline void refine(const int lev = 1)
        { current()->guRefine(lev); }
    inline void coarsen(const int lev = 1)
        { current()->guCoarsen(lev); }

public:
    void decompose(const int lev = 1);

    /*************************************************************************/
    /*** Functions I'd like to have.... ***/
    /*************************************************************************/
    //void merge(GridUnitList const *levellist, const int level);
    //void coalesce(GridUnitList**& gularray, BBoxList const &bblist, 
    //              int &cnt, const int lev);
};

// overloaded i/o functions
std::ostream& operator<<(std::ostream& os, const GridUnitList& gul);
std::ofstream& operator<<(std::ofstream& ofs, const GridUnitList& gul);
std::ifstream& operator>>(std::ifstream& ifs, GridUnitList& gul);
std::stringstream& operator<<(std::stringstream& ofs, const GridUnitList& gul);
std::stringstream& operator>>(std::stringstream& ifs, GridUnitList& gul);

#endif

---