Blockstructured Adaptive Mesh Refinement in object-oriented C++

---

       

---

GridBoxList.C

Go to the documentation of this file.

#include "GridBoxList.h"

/*************************************************************************/
/* Overloaded assignment operator for GridBoxList */
/*************************************************************************/
GridBoxList& GridBoxList::operator = (const GridBoxList& cother)
  {
    GridBoxList &other = (GridBoxList &)cother;
    union record *tmpcur == other.currec();
    if (num != 0) empty(); 
    GridBox *gb = 0;
    for (gb=other.first();gb;gb=other.next()) add(*gb);
    assert(num==other.num);
    other.setcurrec(tmpcur);
    return *this;
  }

/*************************************************************************/
/* difference
   This method breaks a GridBox lhs against GridBox rhs and adds the pieces
   not contained in rhs to the GridBoxList.
*/
/*************************************************************************/
int GridBoxList:: difference(GridBoxList& gbl, 
                             const GridBox& lhsgb,
                             const GridBox& rhsgb)
{
  const BBox lhs = lhsgb.gbBBox();
  const BBox rhs = rhsgb.gbBBox();
  const Coords& s(lhs.stepsize());

  if (!lhs.intersects(rhs)) return DAGHFalse;
  if (lhs == rhs) return DAGHTrue;

  Coords lhslb = lhs.lower();
  Coords lhsub = lhs.upper();
  const Coords& rhslb = rhs.lower();
  const Coords& rhsub = rhs.upper();

  for (register int d=0;d<lhs.rank;d++) {
    if (lhsub(d) > rhsub(d)) {
      GridBox* newgb = gbl.insert(lhsgb); gbl.prev();
      newgb->bbox.lower(d) = rhsub(d) + s(d);
      lhsub(d) = rhsub(d);
    }
    if (lhslb(d) < rhslb(d)) {
      GridBox* newgb = gbl.insert(lhsgb); gbl.prev();
      newgb->bbox.upper(d) = rhslb(d) - s(d);
      lhslb(d) = rhslb(d);
    }
  }
  return DAGHTrue;
}

/*************************************************************************/
/* intersection
   This method adds the intersection of the lhs and rhs GridBox's to the GridBoxList. */
/*************************************************************************/
int GridBoxList:: intersection(GridBoxList& gbl, 
                               const GridBox& lhsgb,
                               const GridBox& rhsgb)
{
  const BBox lhs = lhsgb.gbBBox();
  const BBox rhs = rhsgb.gbBBox();

  if (lhs.intersects(rhs)) {
    gbl.prev();
    GridBox* newgb = gbl.insert(lhsgb); 
    newgb->bbox *= rhs;
    gbl.next();
    return DAGHTrue;
  }
  else 
    return DAGHFalse;
}

/*************************************************************************/
/* operator -=
   Difference operator for GBL = retain only those regions that are not in rhs
*/
/*************************************************************************/
void GridBoxList::operator -= (const GridBoxList& rhs)
  {
   GridBoxList& diff = *this;

   GridBoxList& r = (GridBoxList&) rhs;
   union record *tmpcur == r.currec();

   short flag = DAGHFalse;

   register const GridBox* rhsgb = r.first();
   register GridBox* gb = 0;
   for (;rhsgb;rhsgb=r.next())  {
     for (gb=diff.first();(gb || flag);
          gb=diff.next(),flag=DAGHFalse) {
       GridBox gbhelp = *gb;
       if (difference(diff,gbhelp,*rhsgb)) {
         diff.remove();  
         if (!gb) flag = DAGHTrue;
       }
     }
     
   }  
   r.setcurrec(tmpcur);
  }

/*************************************************************************/
/* operator *=
   Intersection operator for GBL = retain only those regions that are common
*/
/*************************************************************************/
void GridBoxList::operator *= (const GridBoxList& rhs)
  {
   GridBoxList& intersect = *this;

   GridBoxList& r = (GridBoxList&) rhs;
   union record *tmpcur == r.currec();

   register const GridBox* rhsgb = r.first();
   register GridBox* gb = intersect.first();
   for (;gb;gb=intersect.next()) {
     GridBox gbhelp = *gb;
     for (;rhsgb;rhsgb=r.next())  {
       intersection(intersect,gbhelp,*rhsgb);
     }
     if (!rhsgb) {
       intersect.remove();
       rhsgb = r.first();
     }
   }  
   r.setcurrec(tmpcur);
  }

/*************************************************************************/
/* index
   Finds the index in the list which intersects with bb.
*/
/*************************************************************************/
int GridBoxList::index(const BBox& bb)
  {
   union record *tmpcur == currec();
   register GridBox *g = first();
   for ( ; g != GridBoxNULL;  g = next() ) 
     if ((g->gbBBox()).intersects(bb)) break;
   setcurrec(tmpcur);
   return  (g->gbIndex());
  }

/*************************************************************************/
/* maxindex
   Returns the max value of index in the list
*/
/*************************************************************************/
int GridBoxList::maxindex()
  {
   union record *tmpcur == currec();
   register GridBox *g = first();
   int mi = 0;
   int i = 0;
   for ( ; g != GridBoxNULL;  g = next() ) 
     { mi = ((i=g->index) > mi) ? i : mi; }
   setcurrec(tmpcur);
   return (mi);
  }

/*************************************************************************/
/* find
   Finds a particular GridBox in the list.
*/
/*************************************************************************/
const GridBox& GridBoxList::find(const BBox& bb)
  {
   union record *tmpcur == currec();
   register GridBox *g = first();
   for ( ; g != GridBoxNULL;  g = next() ) 
     if ((g->gbBBox()).intersects(bb)) break;
   setcurrec(tmpcur);
   return  (*g);
  }

/*************************************************************************/
/* intersect
   Intersection of GridBox with BBox and BBoxList
*/
/*************************************************************************/
void GridBoxList::intersect(const BBox& rhs, GridBoxList& gbl)
{
  if (!gbl.isempty()) gbl.empty();
  if (rhs.empty()) return;
  register GridBox *gb = first();
  for (;gb;gb=next())
    if ((gb->gbBBox()).intersects(rhs)) 
      gbl.add(*gb);
}

void GridBoxList::intersect(const BBox& rhs, GridBoxList& gbl, 
                             const int olap, const int extgh)
{
  if (!gbl.isempty()) gbl.empty();
  if (rhs.empty()) return;
  register GridBox *gb = first();
  for (;gb;gb=next())
    if ((gb->gbBBox(olap,extgh)).intersects(rhs)) 
      gbl.add(*gb);
}

void GridBoxList::intersect(const BBoxList& crhs, GridBoxList& gbl, 
                             const int olap, const int extgh)
{
  BBoxList &rhs = (BBoxList &) crhs;
  union record *tmpcur == rhs.currec();
  
  if (!gbl.isempty()) gbl.empty();
  
  register BBox *rhsbb = 0;
  
  BBox bb;
  register GridBox *gb = first();
  for (;gb;gb=next()) {
    bb = gb->gbBBox(olap,extgh);
    if(!bb.empty()) { 
      for (rhsbb=rhs.first();rhsbb;rhsbb=rhs.next()) {
        if (!rhsbb->empty() && bb.intersects(*rhsbb)) {
          gbl.add(*gb);
          break;
        }
      }
    }
  }
  
  rhs.setcurrec(tmpcur);
}

void GridBoxList::intersect(const BBox& rhs, GridBoxList& gbl, 
                             const short* olap, const int extgh)
{
  if (!gbl.isempty()) gbl.empty();
  if (rhs.empty()) return;
  register GridBox *gb = first();
  for (;gb;gb=next())
    if ((gb->gbBBox(olap,extgh)).intersects(rhs)) 
      gbl.add(*gb);
}

void GridBoxList::intersect(const BBoxList& crhs, GridBoxList& gbl, 
                             const short* olap, const int extgh)
{
  BBoxList &rhs = (BBoxList &) crhs;
  union record *tmpcur == rhs.currec();
  
  if (!gbl.isempty()) gbl.empty();
  
  register BBox *rhsbb = 0;
  
  BBox bb;
  register GridBox *gb = first();
  for (;gb;gb=next()) {
    bb = gb->gbBBox(olap,extgh);
    if(!bb.empty()) { 
      for (rhsbb=rhs.first();rhsbb;rhsbb=rhs.next()) {
        if (!rhsbb->empty() && bb.intersects(*rhsbb)) {
          gbl.add(*gb);
          break;
        }
      }
    }
  }
  
  rhs.setcurrec(tmpcur);
}

/*************************************************************************/
/* bboxlist
  Get the corresponding BBoxlist.
*/
/*************************************************************************/
void GridBoxList::bboxlist(BBoxList& bbl, const int olap)
  {
    const int extgh = 0;
    if(!bbl.isempty()) bbl.empty();

    GridBox levgb;
    register GridBox *tmpgb = first();
    for (;tmpgb;tmpgb=next()) {
      bbl.add(tmpgb->gbBBox(olap,extgh));
    }
  }

void GridBoxList::bboxlist(BBoxList& bbl, const short* olap, const int extgh)
  {
    if(!bbl.isempty()) bbl.empty();

    GridBox levgb;
    register GridBox *tmpgb = first();
    for (;tmpgb;tmpgb=next()) {
      bbl.add(tmpgb->gbBBox(olap,extgh));
    }
  }


/*************************************************************************/
/* operator <<
   Overloaded output operator
*/
/*************************************************************************/
ostream&  operator << (ostream& os, const GridBoxList& cgbl)
  {
   if (&cgbl == GridBoxListNULL) return os;

   GridBoxList &gbl = (GridBoxList &) cgbl;
   union record *tmpcur == gbl.currec();

   os << "Num:" << gbl.num << " ";
   os <<  "\n";

   if (gbl.num == 0) return os;

   GridBox *g = 0;
   os << *gbl.first();
   os << "\n**********************************\n";

   while ( (g=gbl.next()) != GridBoxNULL ) {
        os << *g;
        os << "\n**********************************\n";
        os << flush;
   }

   gbl.setcurrec(tmpcur);

   return os;
  }

ofstream&  operator << (ofstream& ofs, const GridBoxList& cgbl)
  {
   if (&cgbl == GridBoxListNULL) return ofs;

   GridBoxList &gbl = (GridBoxList &) cgbl;
   union record *tmpcur == gbl.currec();
 
   ofs.write((char*)&gbl.num,sizeof(int));

   if (gbl.num == 0) return ofs;
   
   GridBox *g = 0;
   for (g = gbl.first(); g != GridBoxNULL; g = gbl.next())
     ofs << *g;

   gbl.setcurrec(tmpcur);

   return ofs;
  }

strstream&  operator << (strstream& ofs, const GridBoxList& cgbl)
  {
   if (&cgbl == GridBoxListNULL) return ofs;

   GridBoxList &gbl = (GridBoxList &) cgbl;
   union record *tmpcur == gbl.currec();
 
   ofs.write((char*)&gbl.num,sizeof(int));

   if (gbl.num == 0) return ofs;
   
   GridBox *g = 0;
   for (g = gbl.first(); g != GridBoxNULL; g = gbl.next())
     ofs << *g;

   gbl.setcurrec(tmpcur);

   return ofs;
  }

/*************************************************************************/
/* operator >>
   Overloaded binary input operator
*/
/*************************************************************************/
ifstream&  operator >> (ifstream& ifs, GridBoxList& cgbl)
  {
   if (&cgbl == GridBoxListNULL) return ifs;

   GridBoxList &gbl = (GridBoxList &) cgbl;
   union record *tmpcur == gbl.currec();
 
   int numin;
   ifs.read((char*)&numin,sizeof(int));

   if (numin == 0) return ifs;

   register GridBox* gb = 0;
   for (register int n=0; n<numin; n++) {
     gb = gbl.add();
     ifs >> *gb;
   }

   gbl.setcurrec(tmpcur);

   return ifs;
  }

strstream&  operator >> (strstream& ifs, GridBoxList& cgbl)
  {
   if (&cgbl == GridBoxListNULL) return ifs;

   GridBoxList &gbl = (GridBoxList &) cgbl;
   union record *tmpcur == gbl.currec();
 
   int numin;
   ifs.read((char*)&numin,sizeof(int));

   if (numin == 0) return ifs;

   register GridBox* gb = 0;
   for (register int n=0; n<numin; n++) {
     gb = gbl.add();
     ifs >> *gb;
   }

   gbl.setcurrec(tmpcur);

   return ifs;
  }
/*************************************************************************/

---

Quickstart     Users Guide     Programmers Reference     Installation      Examples     Download

---

AMROC Main      Home      Contact

last update: 06/01/04