GridUnit.h

Go to the documentation of this file.

// -*- C++ -*-

#ifndef _included_GridUnit_h
#define _included_GridUnit_h

#include "DAGHParams.h"
#include "DAGHSfc.h"
#include "BBox.h"

#include <iosfwd>
#include <cstdlib>

#define GridUnitNULL ((GridUnit *) 0)

class GridUnit 
  {
   friend std::ostream& operator<<(std::ostream&, const GridUnit&);
   friend std::ofstream& operator<<(std::ofstream&, const GridUnit&);
   friend std::ifstream& operator>>(std::ifstream&, GridUnit&);
   friend std::stringstream& operator<<(std::stringstream&, const GridUnit&);
   friend std::stringstream& operator>>(std::stringstream&, GridUnit&);
   friend class GridUnitList;

protected:
   short int owner;
   short int index;
   short int rank;
   short int baselev;
   short int crslev;
   short int finelev;
   short int maxlev;
   short int minlev;
   short int levstep;

   short int extent;
   int work;                      
   dMapIndex baseindex;         
   BBox fbb;                   

public:
   inline GridUnit(void)
        : owner(DAGHNoBody), index(DAGHNull), rank(0), 
          baselev(0), crslev(0), finelev(0), 
          maxlev(0), minlev(0), levstep(0), 
          extent(0), work(0) { }

   GridUnit(const int nrank, const int clev, const int* bcoords,
            const int ext, const int mlev, const int lstep, 
            const int reflev);

   GridUnit(const int nrank, const int clev, const int bindex, 
            const int ext, const int mlev, const int lstep, 
            const int reflev);

   inline GridUnit(GridUnit const &other)
        : owner(other.owner), index(other.index),
          rank(other.rank), baselev(other.baselev),
          crslev(other.crslev), finelev(other.finelev),
          maxlev(other.maxlev), minlev(other.minlev), 
          levstep(other.levstep), extent(other.extent), 
          work(other.work), baseindex(other.baseindex),
          fbb(other.fbb) 
     { }

   inline ~GridUnit(void) {}

   GridUnit const &operator= (GridUnit const &other);

public:
   inline int guOwner(void) const { return (owner); }
   inline int guIndex(void) const { return (index); }
   inline int guRank(void) const { return (rank); }
   inline int guBaseLev(void) const { return (baselev); }
   inline int guFineLev(void) const { return (finelev); }
   inline int guCrsLev(void) const { return (crslev); }
   inline int guNumLev(void) const { return ((finelev-crslev)/levstep+1); }
   inline int guMaxLev(void) const { return (maxlev); }
   inline int guMinLev(void) const { return (minlev); }
   inline int guLevStep(void) const { return (levstep); }
   inline int guLevels(void) const { return ((maxlev-minlev)/levstep+1); }

   inline int guExtent(const int lev) const
   { return ((lev<=finelev && lev>=crslev && extent>=(finelev-lev)) 
            ? extent-(finelev-lev) : 0); }
   inline int guExtentAbs(const int lev) const
   { return ((extent>=(finelev-lev)) ? extent-(finelev-lev) : 0); }
   
   inline void guSetWorkload(const int w) { work = w; }
   unsigned inline long guNum(const int overlap) const { return work; }
   unsigned inline long guWork(const int overlap) const { return work; }
   unsigned inline long guNum(const int lev, const int overlap) const { return work; }
   unsigned inline long guWork(const int lev, const int overlap) const { return work; }

   unsigned inline long guNum(const short* overlap) const { return work; }
   unsigned inline long guWork(const short* overlap) const { return work; }
   unsigned inline long guNum(const int lev, const short* overlap) const { return work; }
   unsigned inline long guWork(const int lev, const short* overlap) const { return work; }

   inline int guContains(const int lev) const
        { return (lev<=finelev && lev>=crslev); }
   inline int guContains(const int minlev, const int maxlev) const
        { return (minlev<=finelev && maxlev>=crslev); }

   inline int guLevIndex(const int lev) const
        { return ((lev-minlev)/levstep); }

   //inline void guSetIndex(const int idx) { index = idx; }
   inline void guSetOwner(const int p) { owner = p; }

   inline const dMapIndex& guBaseIndex(void) const { return (baseindex); }

   dMapIndex guTopIndex(const int lev) const;
   dMapIndex guMaxIndex(const int lev) const;

private:
   void guLCoords(int *c, const int lev) const;
   Coords guLCoords(const int lev) const;

   void guUCoords(int *c, const int lev) const;
   Coords guUCoords(const int lev) const;

   void guSetBBox(); 

public:
   const BBox& guBBox() const { return (fbb); }

   BBox guBBox(const int lev, const int olap=0, const int extgh=0) const;
   BBox guBBoxAbs(const int lev, const int olap=0, const int extgh=0) const;

   BBox guBBox(const int lev, const short* olap, const int extgh=0) const;
   BBox guBBoxAbs(const int lev, const short* olap, const int extgh=0) const;

   BBox guBBox(const int minl, const int maxl,
               const short* olap, const int extgh=0) const;

   int guInside(const BBox& bbox, const int lev) const;

   int operator== (GridUnit const &other) const;
   int operator>= (GridUnit const &other) const;
   int operator<= (GridUnit const &other) const;

   /* Operations on a GridUnit */
   void guRefine(const int levs = 1);
   void guRefine(GridUnit &gu, const int levs = 1);

   void guCoarsen(const int levs = 1);
   void guCoarsen(GridUnit &gu, const int levs = 1);

   void guDecompose(GridUnit**& gu, int& cnt, const int levs = 1) const;
   void guDecomposeReplicate(GridUnit**& gu, int& cnt, const int minext, 
                                        const int levs = 1) const;
   
   /* An operator I would like to have */
   //void guRecompose(GridUnit**& gu, const int cnt) const;

   void guGetLevels(GridUnit** &gu) const;
   void guGetLevels(GridUnit &gu, const int lev) const;

   inline void guSetDecompose(GridUnit& gu,
                              const int lev,
                              const int cnt)
     { gu.baselev+=lev; gu.extent-=lev; 
       gu.baseindex.SetIndex(cnt,gu.baselev,lev); gu.guSetBBox();
       gu.guSetWorkload ( gu.guWork(0)/gu.baseindex.GetCardinality(lev) );
     }

   inline void guSetLevels(GridUnit& gu,
                           const int lev)
     { gu.extent-=(gu.finelev-lev);
       gu.crslev=lev; gu.finelev=lev; 
       gu.baselev = gu.finelev-gu.extent; gu.guSetBBox(); }

   inline void guSetRefineLevel(GridUnit& gu,
                                const int levs=1)
     { gu.crslev=gu.finelev+gu.levstep; gu.finelev+=(levs*gu.levstep);
       gu.extent+=levs*gu.levstep; gu.baselev=gu.finelev-gu.extent; 
       gu.guSetBBox(); }

   inline void guSetCoarsen(GridUnit& gu,
                            const int levs=1)
     { gu.finelev-=(levs*gu.levstep); gu.extent-=levs*gu.levstep; 
       gu.baselev=gu.finelev-gu.extent; gu.guSetBBox(); }
   inline void guSetRefine(GridUnit& gu,
                           const int levs=1)
     { gu.finelev+=(levs*gu.levstep); gu.extent+=levs*gu.levstep; 
       gu.baselev=gu.finelev-gu.extent; gu.guSetBBox(); }
  };   

std::ostream&  operator << (std::ostream& os, const GridUnit& gu);
std::ofstream& operator << (std::ofstream& ofs, const GridUnit& gu);
std::ifstream& operator >> (std::ifstream& ifs, GridUnit& gu);
std::stringstream& operator << (std::stringstream& ofs, const GridUnit& gu);
std::stringstream& operator >> (std::stringstream& ifs, GridUnit& gu);

#endif

---