Blockstructured Adaptive Mesh Refinement in object-oriented C++

---

       

---

BBoxList.C

Go to the documentation of this file.

#include "BBoxList.h"

/*************************************************************************/
/* overloaded assignment */
/*************************************************************************/
BBoxList&  BBoxList::operator = (const BBoxList& cother)
  {
    BBoxList &other = (BBoxList &) cother;
    union record *tmpcur == other.currec();

    empty();
    BBox *bb = 0;
    for (bb=other.first();bb;bb=other.next()) {
      add(*bb);
    }

    assert(num==other.num);
    other.setcurrec(tmpcur);
    return *this;
  }

/*************************************************************************/
/* difference */
/*************************************************************************/
int BBoxList::difference(BBoxList& bbl, 
                         const BBox& lhs,
                         const BBox& rhs)
{
  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)) {
      BBox* newbb = bbl.insert(BBox(lhslb,lhsub,s)); bbl.prev();
      newbb->lower(d) = rhsub(d) + s(d);
      lhsub(d) = rhsub(d);
    }
    if (lhslb(d) < rhslb(d)) {
      BBox* newbb = bbl.insert(BBox(lhslb,lhsub,s)); bbl.prev();
      newbb->upper(d) = rhslb(d) - s(d);
      lhslb(d) = rhslb(d);
    }
  }
  return DAGHTrue;
}

/*************************************************************************/
/* intersection */
/*************************************************************************/
int BBoxList::intersection(BBoxList& bbl, 
                           const BBox& lhs,
                           const BBox& rhs)
{
  if (lhs.intersects(rhs)) {
    bbl.prev();
    BBox* newbb = bbl.insert(lhs); 
    *newbb *= rhs;
    bbl.next();
    return DAGHTrue;
  }
  else 
    return DAGHFalse;
}

/*************************************************************************/
/* operator -= */
/*************************************************************************/
void BBoxList::operator -= (const BBoxList& rhs)
{
  BBoxList& diff = *this;

  BBoxList& r = (BBoxList&) rhs;
  union record *tmpcur == r.currec();
  
  short flag = DAGHFalse;
  
  register const BBox* rhsbb = r.first();
  register BBox* bb = 0;
  for (;rhsbb;rhsbb=r.next())  {
    for (bb=diff.first();(bb || flag);
         bb=diff.next(),flag=DAGHFalse) {
      BBox bbhelp = *bb;
      if (difference(diff,bbhelp,*rhsbb)) {
        diff.remove();   
        if (!bb) flag = DAGHTrue;
      }
    }     
  }  
  r.setcurrec(tmpcur);
}

void BBoxList::operator -= (const BBox& rhs)
{
  BBoxList& diff = *this;

  short flag = DAGHFalse;
  
  register BBox* bb = 0;
  for (bb=diff.first();(bb || flag);
       bb=diff.next(),flag=DAGHFalse) {
    BBox bbhelp = *bb;
    if (difference(diff,bbhelp,rhs)) {
      diff.remove();     
      if (!bb) flag = DAGHTrue;
    }
  }     
}

/*************************************************************************/
/* operator *= */
/*************************************************************************/
void BBoxList::operator *= (const BBoxList &rhs) 
{
  BBoxList& intersect = *this;

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

  register const BBox* rhsbb = r.first();
  register BBox* bb = intersect.first();
  for (;bb;bb=intersect.next()) {
    BBox bbhelp = *bb;
    for (;rhsbb;rhsbb=r.next())  
      intersection(intersect,bbhelp,*rhsbb);
    if (!rhsbb) {
      intersect.remove();
      rhsbb = r.first();
    }
  }  
  r.setcurrec(tmpcur);   
}

void BBoxList::operator *= (const BBox &rhs) 
{
  BBoxList& intersect = *this;

  register BBox* bb = intersect.first();
  for (;bb;bb=intersect.next()) {
    BBox bbhelp = *bb;
    intersection(intersect,bbhelp,rhs);
  }  
}

/*************************************************************************/
/* nest in another list */
/*************************************************************************/
void BBoxList::nest (const BBoxList &crhs)
  {
   BBoxList &rhs = (BBoxList &) crhs;
   union record *tmpcur == rhs.currec();

   register BBox *rhsbb = rhs.first();
   register BBox *bb = first();
   if (num == 0) {
     for (;rhsbb;rhsbb=rhs.next()) 
        add(*rhsbb);
   }
   else {
     for (;rhsbb;rhsbb=rhs.next())  {
       for (;bb;bb=next()) {
         if (*rhsbb == *bb) break;
         else {
           BBox intersection = *rhsbb * *bb;
           if (!intersection.empty()) {
             *bb += *rhsbb;
           }
         }
       }
       if (!bb) bb = first();
     }
   }

   rhs.setcurrec(tmpcur);
  }

/*************************************************************************/
/* merge the  boxes */
/*************************************************************************/
void BBoxList::mergeboxes(const short* olap)
  {
   if (num == 0) return;

   const int rank = (first())->rank;

   BBoxList mergebbl = *this;
   BBoxList bbl;

   register int onum = 0;
   register int rstrt = 0;
   register int d = 0;
   while (onum != mergebbl.num) {
     onum = mergebbl.num;

   //for (register int d=rank-1; d>=0 ; d--) {
   for (register int dd=0; dd<rank ; dd++) {
     d = (rstrt + dd)%rank;
     bbl = mergebbl;
     mergebbl.empty();
     for (BBox *bb=bbl.first();bb;bb=bbl.next()) {
       if (!bb->empty()) {
         BBox mbb = *bb; 
         for (BBox *withbb=mergebbl.first();withbb;withbb=mergebbl.next()) {
           if (mbb.mergable(*withbb, d, olap[d]) || (*withbb)<=mbb) {
             mbb += *withbb;
             mergebbl.remove();
           }
         }
         mergebbl.add(mbb);
       }
       bbl.remove();
     }
     assert(bbl.isempty());
   } }

   empty();
   *this = mergebbl;
   rstrt++;
  }

/*************************************************************************/
/* reduce into a single bounding box */
/*************************************************************************/
BBox BBoxList::reduce()
  {
   if (num == 0) return BBox::_empty_bbox;

   union record *tmpcur == currec();
   
   BBox rbbox;
   register BBox *bb = first();
   rbbox.rank = bb->rank;
   for (;bb;bb=next()) rbbox += *bb;

   setcurrec(tmpcur);
   return rbbox;
  }

/*************************************************************************/
/* combine two lists */
/*************************************************************************/
void BBoxList::combine(const BBoxList &crhs)
  {
   BBoxList &rhs = (BBoxList &) crhs;
   union record *tmpcur == rhs.currec();

   register BBox *rhsbb = rhs.first();
   for (;rhsbb;rhsbb=rhs.next()) add(*rhsbb);

   rhs.setcurrec(tmpcur);
  }

/*************************************************************************/
/* and print it out... */
/*************************************************************************/
ostream&  operator << (ostream& os, const BBoxList& cbbl)
  {
   if (&cbbl == BBoxListNULL) return os;

   BBoxList &bbl = (BBoxList &) cbbl;
   union record *tmpcur == bbl.currec();

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

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

   BBox *b = 0;
   os << *bbl.first();
   os << "\n**********************************\n";

   while ( (b=bbl.next()) != BBoxNULL ) {
        os << *b;
        os << "\n**********************************\n";
        os << flush;
   }

   bbl.setcurrec(tmpcur);
   return os;
  }

/*
*************************************************************************
*                                                                       *
* And overload BINARY << for the BBL class....                          *
*                                                                       *
*************************************************************************
*/

ofstream&  operator << (ofstream& ofs, const BBoxList& cbbl)
  {
   if (&cbbl == BBoxListNULL) return ofs;

   BBoxList &bbl = (BBoxList &) cbbl;
   union record *tmpcur == bbl.currec();
 
   ofs.write((char*)&bbl.num,sizeof(int));

   if (bbl.num == 0) return ofs;
   
   BBox *b = 0;
   for (b = bbl.first(); b != BBoxNULL; b = bbl.next())
     ofs << *b;

   bbl.setcurrec(tmpcur);

   return ofs;
  }

ifstream&  operator >> (ifstream& ifs, BBoxList& cbbl)
  {
   if (&cbbl == BBoxListNULL) return ifs;

   BBoxList &bbl = (BBoxList &) cbbl;
   union record *tmpcur == bbl.currec();
 
   int numin;
   ifs.read((char*)&numin,sizeof(int));

   if (numin == 0) return ifs;

   BBox bb;
   for (register int n=0; n<numin; n++) {
     ifs >> bb;
     bbl.add(bb);
   }

   bbl.setcurrec(tmpcur);

   return ifs;
  }

strstream&  operator << (strstream& ofs, const BBoxList& cbbl)
  {
   if (&cbbl == BBoxListNULL) return ofs;

   BBoxList &bbl = (BBoxList &) cbbl;
   union record *tmpcur == bbl.currec();
 
   ofs.write((char*)&bbl.num,sizeof(int));

   if (bbl.num == 0) return ofs;
   
   BBox *b = 0;
   for (b = bbl.first(); b != BBoxNULL; b = bbl.next())
     ofs << *b;

   bbl.setcurrec(tmpcur);

   return ofs;
  }

strstream&  operator >> (strstream& ifs, BBoxList& cbbl)
  {
   if (&cbbl == BBoxListNULL) return ifs;

   BBoxList &bbl = (BBoxList &) cbbl;
   union record *tmpcur == bbl.currec();
 
   int numin;
   ifs.read((char*)&numin,sizeof(int));

   if (numin == 0) return ifs;

   BBox bb;
   for (register int n=0; n<numin; n++) {
     ifs >> bb;
     bbl.add(bb);
   }

   bbl.setcurrec(tmpcur);

   return ifs;
  }

---

Quickstart     Users Guide     Programmers Reference     Installation      Examples     Download

---

AMROC Main      Home      Contact

last update: 06/01/04