Blockstructured Adaptive Mesh Refinement in object-oriented C++

---

       

---

GridUnitList.C

Go to the documentation of this file.

#ifdef DEBUG_PRINT
#include "CommServer.h" 
#endif

#include "GridUnitList.h"


/*
*************************************************************************
*                                                                       *
* GridUnitList constructors from an array of GridUnitLists per level    *
* (The other constructors are in the GridUnitList.inline file)          *
*                                                                       *
*************************************************************************
*/
GridUnitList::GridUnitList(GridUnitList**& levarray)
        : Bucket<GridUnit>(DefBucketSize), num(0)
  {
   register GridUnitList *gul = levarray[0];
   if (gul == GridUnitListNULL) return;
   register GridUnit const *tmpgu = gul->first();
   register const int nlev = tmpgu->guLevels();

   for (;tmpgu;tmpgu=gul->next()) add(*tmpgu);

   for (register int i=1;i<nlev;i++) {
     if (levarray[i])  {
       gul = levarray[i];
       tmpgu = gul->first();
       register GridUnit const *gu = first();
       for (;tmpgu;tmpgu=gul->next()) {
         //assert (tmpgu && gu);
         GridUnit helptmpgu = *tmpgu;
         for (;gu;gu=next()) {
           GridUnit helpgu = *gu;
           if (helptmpgu == helpgu)
             { refine(); gu=next(); break; }
           else if (helpgu >= helptmpgu) {
             if (helpgu.guExtent(helpgu.crslev) <= 0) {
               refine(); break;
             }
             else {  
               decompose(helptmpgu.baselev - helpgu.baselev);
             }
           }
           else if (helpgu <= helptmpgu)
             { gul->decompose(helpgu.baselev - helptmpgu.baselev); break; }
         }
         if (tmpgu && !gu) gu = first();
       }
     }
   }
  }

/*
*************************************************************************
*                                                                       *
* The overloaded assignment operator                                    *
*                                                                       *
*************************************************************************
*/

GridUnitList& GridUnitList::operator = (const GridUnitList& cother)
  {
    GridUnitList &other = (GridUnitList &)cother;
    union record *tmpcur == other.currec();
    if (num != 0) empty();
    GridUnit *gu = 0;
    for (gu=other.first();gu;gu=other.next()) {
      add(*gu);
    }
#ifdef DEBUG_PRINT
    assert(num==other.num);
#endif
    other.setcurrec(tmpcur);
    return *this;
  }

/*
*************************************************************************
*                                                                       *
* Operate between GridUnitLists !                                       *
* -= : difference (deletes all overlaps with the rhs)                   *
* *= : intersetion                                                      *
* The following allocate a new GUL and returns a pointer to it          *
* -  : abs difference (returns a GUl with all GU in lhs or rhs but      *
       not both)                                                        *
* *  : intersection                                                     *
* +  : union                                                            *
*                                                                       *
*************************************************************************
*/

void GridUnitList::operator -= (GridUnitList const &rhs)
  {
   GridUnitList *diff = this;
   GridUnitList r(rhs);
   register GridUnit const *rhsgu = r.first();
   register GridUnit *gu = diff->first();
   for (;rhsgu;rhsgu=r.next())  {
     GridUnit helprhsgu = *rhsgu;
     for (;gu;gu=diff->next()) {
       GridUnit helpgu = *gu;
       if (helprhsgu == helpgu)
         { diff->remove(); break; }
       else if (helpgu >= helprhsgu)
         diff->decompose(helprhsgu.baselev - helpgu.baselev);
       else if (helpgu <= helprhsgu)
         { r.decompose(helpgu.baselev - helprhsgu.baselev); break; }
     }
     if (!gu) {
       gu=diff->first();
     }
   }
  }

GridUnitList *GridUnitList::operator - (GridUnitList const &rhs)
  {
   GridUnitList *diff = new GridUnitList(*this);
   GridUnitList r(rhs);
   GridUnitList tmpd;
   register GridUnit const *rhsgu = r.first();
   register GridUnit *gu = diff->first();
   for (;rhsgu;rhsgu=r.next())  {
     GridUnit helprhsgu = *rhsgu;
     for (;gu;gu=diff->next()) {
       GridUnit helpgu = *gu;
       if (helprhsgu == helpgu)
         { diff->remove(); break; }
       else if (helpgu >= helprhsgu)
         diff->decompose(helprhsgu.baselev - helpgu.baselev);
       else if (helpgu <= helprhsgu)
         { r.decompose(helpgu.baselev - helprhsgu.baselev); break; }
     }
     if (!gu) {
       tmpd.add(helprhsgu);
       gu=diff->first();
     }
   }
   register GridUnit const *tmpgu = tmpd.first();
   gu=diff->first();
   for (;tmpgu;tmpgu=tmpd.next()) {
     for (;gu;gu=diff->next()) {
       if (tmpgu->guBaseIndex() < gu->guBaseIndex())
         { diff->prev(); diff->insert(*tmpgu); gu = diff->next(); break; }
     }
     if (!gu) diff->add(*tmpgu);
   }
   
   return diff;
  }

void GridUnitList::operator *= (GridUnitList const &rhs)
  {
   GridUnitList *intersect = this;
   GridUnitList r(rhs);
   register GridUnit const *rhsgu = r.first();
   register GridUnit *gu = intersect->first();
   for (;gu;gu=intersect->next()) {
     GridUnit helpgu = *gu;
     for (;rhsgu;rhsgu=r.next())  {
       GridUnit helprhsgu = *rhsgu;
       if (helprhsgu == helpgu) break;
       else if (helpgu >= helprhsgu)
         { intersect->decompose(helprhsgu.baselev - helpgu.baselev); break; }
       else if (helpgu <= helprhsgu)
         { r.decompose(helpgu.baselev - helprhsgu.baselev); }
     }
     if (!rhsgu) {
       intersect->remove();
       rhsgu = r.first();
     }
   }
  }

GridUnitList *GridUnitList::operator * (GridUnitList const &rhs)
  {
   GridUnitList *intersect = new GridUnitList(*this);
   GridUnitList r(rhs);
   register GridUnit const *rhsgu = r.first();
   register GridUnit *gu = intersect->first();
   for (;gu;gu=intersect->next()) {
     GridUnit helpgu = *gu;
     for (;rhsgu;rhsgu=r.next())  {
       GridUnit helprhsgu = *rhsgu;
       if (helprhsgu == helpgu) break;
       else if (helpgu >= helprhsgu)
         { intersect->decompose(helprhsgu.baselev - helpgu.baselev); break; }
       else if (helpgu <= helprhsgu)
         { r.decompose(helpgu.baselev - helprhsgu.baselev); }
     }
     if (!rhsgu) {
       intersect->remove();
       rhsgu = r.first();
     }
   }
   
   return intersect;
  }

GridUnitList *GridUnitList::operator + (GridUnitList const &rhs)
  {
   GridUnitList *sum = new GridUnitList(*this);
   GridUnitList r(rhs);
   GridUnitList tmpu;
   register GridUnit const *rhsgu = r.first();
   register GridUnit *gu = sum->first();
   for (;rhsgu;rhsgu=r.next())  {
     GridUnit helprhsgu = *rhsgu;
     for (;gu;gu=sum->next()) {
       GridUnit helpgu = *gu;
       if (helprhsgu == helpgu) break;
       else if (helpgu >= helprhsgu)
         sum->decompose(helprhsgu.baselev - helpgu.baselev);
       else if (helpgu <= helprhsgu)
         { r.decompose(helpgu.baselev - helprhsgu.baselev); break; }
     }
     if (!gu) {
       tmpu.add(helprhsgu);
       gu=sum->first();
     }
   }

   register GridUnit const *tmpgu = tmpu.first();
   gu=sum->first();
   for (;tmpgu;tmpgu=tmpu.next()) {
     for (;gu;gu=sum->next()) {
       if (tmpgu->guBaseIndex() < gu->guBaseIndex())
         { sum->prev(); sum->insert(*tmpgu); gu = sum->next(); break; }
     }
     if (!gu) sum->add(*tmpgu);
   }
   
   return sum;
  }

/*
*************************************************************************
*                                                                       *
* Operations with a BBox & BBoxList                                     *
* *= : intersetion                                                      *
* *  : intersection                                                     *
* intersect : a more specialized intersection                           *
* Note: * allocates a new GUL and returns a pointer to it               *
*                                                                       *
*************************************************************************
*/

void GridUnitList::operator *= (BBox const &rhs)
  {
   if (rhs.empty()) {
     empty();
   }
   else {
     register GridUnit *gu = first();
     BBox bb;
     for (;gu;gu=next()) {
       int lev = gu->guFineLev();
       bb = gu->guBBox(lev);
       if (bb <= rhs) ;
       else if (!(bb*rhs).empty()) decompose();
       else remove(); 
     }
   }
  }

GridUnitList *GridUnitList::operator * (BBox const &rhs)
  {
   GridUnitList *intersect = new GridUnitList;

   if (!rhs.empty()) {
     register GridUnit *gu = first();
     BBox bb;
     for (;gu;gu=next()) {
      int lev = gu->guFineLev();
       bb = gu->guBBox(lev);
       if (!(rhs * bb).empty()) {
          intersect->add(*gu);
       }
     }
   }
   return intersect;
  }

GridUnitList *GridUnitList::operator * (BBoxList const &crhs)
  {
   BBoxList &rhs = (BBoxList &) crhs;
   union record *tmpcur == rhs.currec();

   GridUnitList *intersect = new GridUnitList;

   register BBox *rhsbb = 0;

   BBox bb;
   int lev = 0;
   register GridUnit *gu = first();
   for (;gu;gu=next()) {
     lev = gu->guFineLev();
     bb = gu->guBBox(lev);
     for (rhsbb=rhs.first();rhsbb;rhsbb=rhs.next()) {
       if (!rhsbb->empty() && !(*rhsbb * bb).empty()) {
         intersect->add(*gu);
         break;
       }
     }
   }
   rhs.setcurrec(tmpcur);
   return intersect;
  }

void GridUnitList::intersect(BBox const &rhs, const int lev,
                             GridUnitList &gul, const int olap,
                             const int extgh)
  {
   gul.empty();
   if (!rhs.empty()) {
     register GridUnit *gu = first();
     BBox bb;
     for (;gu;gu=next()) {
       bb = gu->guBBox(lev,olap,extgh);
       if (!(rhs * bb).empty()) {
          gul.add(*gu);
       }
     }
   }
  }

void GridUnitList::intersect(BBoxList const &crhs, const int lev,
                             GridUnitList &gul, const int olap, 
                             const int extgh)
  {
   BBoxList &rhs = (BBoxList &) crhs;
   union record *tmpcur == rhs.currec();

   gul.empty();

   register BBox *rhsbb = 0;

   BBox bb;
   register GridUnit *gu = first();
   for (;gu;gu=next()) {
     bb = gu->guBBox(lev,olap,extgh);
     if(!bb.empty()) { 
       for (rhsbb=rhs.first();rhsbb;rhsbb=rhs.next()) {
         if (!rhsbb->empty() && !(*rhsbb * bb).empty()) {
           gul.add(*gu);
           break;
         }
       }
     }
   }

   rhs.setcurrec(tmpcur);
  }

void GridUnitList::intersect(BBox const &rhs, const int lev,
                             GridUnitList &gul, const short* olap,
                             const int extgh)
  {
   gul.empty();
   if (!rhs.empty()) {
     register GridUnit *gu = first();
     BBox bb;
     for (;gu;gu=next()) {
       bb = gu->guBBox(lev,olap,extgh);
       if (!(rhs * bb).empty()) {
          gul.add(*gu);
       }
     }
   }
  }

void GridUnitList::intersect(BBoxList const &crhs, const int lev,
                             GridUnitList &gul, const short* olap, 
                             const int extgh)
  {
   BBoxList &rhs = (BBoxList &) crhs;
   union record *tmpcur == rhs.currec();

   gul.empty();

   register BBox *rhsbb = 0;

   BBox bb;
   register GridUnit *gu = first();
   for (;gu;gu=next()) {
     bb = gu->guBBox(lev,olap,extgh);
     if(!bb.empty()) { 
       for (rhsbb=rhs.first();rhsbb;rhsbb=rhs.next()) {
         if (!rhsbb->empty() && !(*rhsbb * bb).empty()) {
           gul.add(*gu);
           break;
         }
       }
     }
   }

   rhs.setcurrec(tmpcur);
  }

/*
*************************************************************************
*                                                                       *
* Set GridUnit information based on a sub GUL                           *
*                                                                       *
*************************************************************************
*/

void GridUnitList::setindex(const GridUnitList& cgul, const int idx)
  {
   GridUnitList &gul = (GridUnitList &) cgul;
   union record *rhstmpcur == gul.currec();
   union record *tmpcur == currec();

   register GridUnit *rhsg = 0;
   for ( rhsg = gul.first(); rhsg != GridUnitNULL;  rhsg = gul.next() ) {
     register GridUnit *g = first();
     for ( ; g != GridUnitNULL;  g = next() )
       if (*g == *rhsg) { g->index = idx; break; }
   }

   gul.setcurrec(rhstmpcur);
   setcurrec(tmpcur);
  }

void GridUnitList::setowner(const GridUnitList& cgul, const int p)
  {
   GridUnitList &gul = (GridUnitList &) cgul;
   union record *rhstmpcur == gul.currec();
   union record *tmpcur == currec();

   register GridUnit *rhsg = 0;
   for ( rhsg = gul.first(); rhsg != GridUnitNULL;  rhsg = gul.next() ) {
     register GridUnit *g = first();
     for ( ; g != GridUnitNULL;  g = next() )
       if (*g == *rhsg) { g->owner = p; break; }
   }

   gul.setcurrec(rhstmpcur);
   setcurrec(tmpcur);
  }

    
/*
*************************************************************************
*                                                                       *
* Get GUL for the levels                                                *
* levellist : GUL for a paticular level                                 *
* levelarray : An array of GULs for the levels                          *
*                                                                       *
*************************************************************************
*/

void GridUnitList::levellist(GridUnitList &gul, const int lev)
  { 
    if(!gul.isempty()) gul.empty();

    register GridUnit *tmpgu = first();
    for (;tmpgu;tmpgu=next()) {
      if (tmpgu->guContains(lev)) {
        tmpgu->guSetLevels(*(gul.add(*tmpgu)),lev);
      }
    }
  }

void GridUnitList::levellist(GridUnitList &gul, 
                             const int minlev,
                             const int maxlev)
  { 
    if(!gul.isempty()) gul.empty();

    register int flev = 0;
    register int clev = 0;
    register GridUnit *tmpgu = first();
    for (;tmpgu;tmpgu=next()) {
      flev = tmpgu->guFineLev();
      clev = tmpgu->guCrsLev();
      if (minlev > flev || maxlev < clev) continue;
      else if (maxlev >= flev) {
        tmpgu->guSetLevels(*(gul.add(*tmpgu)),flev);
      }
      else if (maxlev < flev) {
        tmpgu->guSetLevels(*(gul.add(*tmpgu)),maxlev);
      }
    }
  }
    
void GridUnitList::levelarray(GridUnitList**& levarray, const int levels)
  { 
    if (!levarray) {
      levarray = new GridUnitList *[levels];
      for (register int i=0;i<levels;i++)
        levarray[i] = GridUnitListNULL;
    }
    else {
      for (register int i=0;i<levels;i++)
        if (levarray[i]) levarray[i]->empty();
    }

    register int idx = 0;
    register GridUnit *tmpgu = first();
    for (;tmpgu;tmpgu=next()) {
      for (register int l=tmpgu->crslev;
           l<=tmpgu->finelev;l+=tmpgu->levstep) {
        idx = tmpgu->guLevIndex(l);
        if (!levarray[idx]) 
          levarray[idx] = new GridUnitList(SimpleBucketVoid::blks(),0);
        tmpgu->guSetLevels(*(levarray[idx]->add(*tmpgu)),l);
      }
    }
  }
    
/*
*************************************************************************
*                                                                       *
* Get a BBoxList corresponding to a particular level                    *
*                                                                       *
*************************************************************************
*/
void GridUnitList::bboxlistfinest(BBoxList &bbl, 
                                  const int lev) 
  {
    if(!bbl.isempty()) bbl.empty();

    register GridUnit *tmpgu = first();
    for (;tmpgu;tmpgu=next()) {
      if (tmpgu->guFineLev() == lev)
        bbl.add(tmpgu->guBBox());
    }
  }

void GridUnitList::bboxlist(BBoxList &bbl, const int lev, 
                            const int olap) //, const int extgh)
  {
    const int extgh = 0;
    if(!bbl.isempty()) bbl.empty();

    register GridUnit *tmpgu = first();
    for (;tmpgu;tmpgu=next()) {
      bbl.add(tmpgu->guBBox(lev,olap,extgh));
    }
  }

/* I actually want the bboxlist for the shadow (i.e. lev-levid) but only
   if the main (i.e. lev) exits */
void GridUnitList::bboxlist(BBoxList &bbl, const int lev,
                            const int olap, const int levid)
                            //,const int extgh)
  {
    const int extgh = 0;
    if(!bbl.isempty()) bbl.empty();

    register GridUnit *tmpgu = first();
    for (;tmpgu;tmpgu=next()) {
      if (tmpgu->guContains(lev))
        bbl.add(tmpgu->guBBoxAbs(lev-levid,olap,extgh));
      else {
        (bbl.add())->setempty();
      }
    }
  }

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

    GridUnit levgu;
    register GridUnit *tmpgu = first();
    for (;tmpgu;tmpgu=next()) {
      bbl.add(tmpgu->guBBox(lev,olap,extgh));
    }
  }

/* I actually want the bboxlist for the shadow (i.e. lev-levid) but only
   if the main (i.e. lev) exits */
void GridUnitList::bboxlist(BBoxList &bbl, const int lev,
                            const short* olap, const int levid, 
                            const int extgh)
  {
    if(!bbl.isempty()) bbl.empty();

    GridUnit levgu;
    register GridUnit *tmpgu = first();
    for (;tmpgu;tmpgu=next()) {
      if (tmpgu->guContains(lev))
        bbl.add(tmpgu->guBBoxAbs(lev-levid,olap,extgh));
      else {
        (bbl.add())->setempty();
      }
    }
  }

/*
*************************************************************************
*                                                                       *
* Refine the GUL                                                        *
*                                                                       *
*************************************************************************
*/

GridUnitList *GridUnitList::refinelist(const int atlev, const int levs)
  {
   GridUnitList *refgul = new GridUnitList;

   GridUnitList levgul;
   levellist(levgul,atlev);
   register GridUnit *levgu = levgul.first();
   for (;levgu;levgu=levgul.next()) {
     levgu->guSetRefine(*(refgul->add(*levgu)),levs); 
   }
   return refgul;
  }

GridUnitList *GridUnitList::refinelist(const BBoxList &cbblist, 
                                       const int atlev, 
                                       const int minw)
  {
   BBoxList bblist = cbblist;
   union record *tmpcur == bblist.currec();

   GridUnitList *refgul = new GridUnitList;

   GridUnitList levgul;
   levellist(levgul,atlev);
   register GridUnit *levgu = levgul.first();
   register BBox *bb = 0;

   for (;levgu;levgu=levgul.next()) {
     BBox levbb = levgu->guBBox(atlev);
     for (bb=bblist.first();bb;bb=bblist.next()) {
       BBox helpbb = *bb;
       if (!helpbb.empty()) {
         BBox interestion(helpbb * levbb);
         if (interestion.empty() ) { 
         }
         else if (helpbb == levbb) { 
           levgu->guSetRefine(*(refgul->add(*levgu))); 
           levgul.remove();
           break;
         }
         else if (interestion == levbb) { 
           levgu->guSetRefine(*(refgul->add(*levgu))); 
           levgul.remove();
           break;
         }
         else if (interestion < levbb && 
                  (levgu->guExtent(atlev) <= DefMinimumGUExtent || 
                   levgu->guExtentAbs(levgu->minlev) <= minw)) {
           levgu->guSetRefine(*(refgul->add(*levgu))); 
           levgul.remove();
           BBox bbhelp = helpbb+levbb;
           bb = bblist.insert(bbhelp);
           bblist.prev();
           // Changed --- RD
           // bblist.remove();
           // bblist.next();
           break;
         }
         else if (interestion < levbb && 
                  levgu->guExtent(atlev) > DefMinimumGUExtent &&
                  levgu->guExtentAbs(levgu->minlev) > minw) {
           levgul.decompose();
           break;
         }
       } 
     }
   }
   bblist.setcurrec(tmpcur);
   return refgul;
  }

void GridUnitList::refinethislist(const BBoxList &cbblist, 
                                  const int atlev, 
                                  const int minw)
  {
   if (num == 0) return;

   BBoxList bblist = cbblist;
   union record *tmpcur == bblist.currec();

   register GridUnit *levgu = first();
   const int levstep = levgu->guLevStep();

   register BBox *bb = 0;
   register int fl = 0;
   register int levs = 0;

   for (;levgu;levgu=next()) {
     if ((fl=levgu->guFineLev()) > atlev) {
       levgu->guCoarsen((fl-atlev)/levstep);
       fl = levgu->guFineLev();
     }
     levs = 1 + (atlev-fl)/levstep;
     BBox levbb = levgu->guBBox(atlev);

     for (bb=bblist.first();bb;bb=bblist.next()) {
       BBox helpbb = *bb;
       if (!helpbb.empty()) {
         BBox interestion(helpbb * levbb);
         if (interestion.empty() ) { 
         }
         else if (helpbb == levbb) {     
           refine(levs); 
           break;
         }
         else if (interestion == levbb) { 
           refine(levs); 
           break;
         }
         else if (interestion < levbb && 
                  (levgu->guExtent(atlev) <= DefMinimumGUExtent || 
                   levgu->guExtentAbs(levgu->minlev) <= minw)) {
           refine(levs); 
           BBox bbhelp = helpbb+levbb;
           bb = bblist.insert(bbhelp);
           bblist.prev();
           // Changed --- RD
           // bblist.prev();
           // bblist.next();
           break;
         }
         else if (interestion < levbb && 
                  levgu->guExtent(atlev) > DefMinimumGUExtent &&
                  levgu->guExtentAbs(levgu->minlev) > minw) {
           decompose();
           break;
         }
       } 
     }
   }
   bblist.setcurrec(tmpcur);
  }

/*
*************************************************************************
*                                                                       *
* Operations on the current GU                                          *
* decompose                                                             *
*                                                                       *
*************************************************************************
*/
void GridUnitList::decompose(const int lev)
  {
   GridUnit *tmpgu = current();
   if (tmpgu == GridUnitNULL) return;

   const int cnt = 
     (tmpgu->guBaseIndex()).GetCardinality(lev);

   GridUnit helptmpgu = *tmpgu;
   if (cnt > 0) {
     for(register int i=cnt-1;i>=0;i--) {
       GridUnit* workgu = insert(helptmpgu);
       assert(workgu->extent>0 && workgu->levstep>0);
       helptmpgu.guSetDecompose(*workgu,lev,i);
       prev(); 
     }
     remove();
   }
  }

/*
*************************************************************************
*                                                                       *
*  The originally inlined methods                   *
*                                                                       *
*************************************************************************
*/
unsigned long GridUnitList::load(const int olap)
  {
   unsigned long ld = 0;
   union record *tmpcur == currec();
   register GridUnit *g = first();
   for ( ; g != GridUnitNULL;  g = next() ) 
     { ld += g->guWork(olap); }
   setcurrec(tmpcur);
   return ld;
  }

unsigned long GridUnitList::load(const int lev, const int olap) 
  {
   unsigned long ld = 0;
   union record *tmpcur == currec();
   register GridUnit *g = first();
   for ( ; g != GridUnitNULL;  g = next() ) 
     { ld += g->guWork(lev,olap); }
   setcurrec(tmpcur);
   return ld;
  }

unsigned long GridUnitList::numelems(const int olap)
  {
   unsigned long gelem = 0;
   union record *tmpcur == currec();
   register GridUnit *g = first();
   for ( ; g != GridUnitNULL;  g = next() ) 
     { gelem += g->guNum(olap); }
   setcurrec(tmpcur);
   return gelem;
  }

unsigned long GridUnitList::numelems(const int lev, const int olap)
  {
   unsigned long gelem = 0;
   union record *tmpcur == currec();
   register GridUnit *g = first();
   for ( ; g != GridUnitNULL;  g = next() ) 
     { gelem += g->guNum(lev,olap); }
   setcurrec(tmpcur);
   return gelem;
  }

unsigned long GridUnitList::load(const short* olap)
  {
   unsigned long ld = 0;
   union record *tmpcur == currec();
   register GridUnit *g = first();
   for ( ; g != GridUnitNULL;  g = next() ) 
     { ld += g->guWork(olap); }
   setcurrec(tmpcur);
   return ld;
  }

unsigned long GridUnitList::load(const int lev, const short* olap) 
  {
   unsigned long ld = 0;
   union record *tmpcur == currec();
   register GridUnit *g = first();
   for ( ; g != GridUnitNULL;  g = next() ) 
     { ld += g->guWork(lev,olap); }
   setcurrec(tmpcur);
   return ld;
  }

unsigned long GridUnitList::numelems(const short* olap)
  {
   unsigned long gelem = 0;
   union record *tmpcur == currec();
   register GridUnit *g = first();
   for ( ; g != GridUnitNULL;  g = next() ) 
     { gelem += g->guNum(olap); }
   setcurrec(tmpcur);
   return gelem;
  }

unsigned long GridUnitList::numelems(const int lev, const short* olap)
  {
   unsigned long gelem = 0;
   union record *tmpcur == currec();
   register GridUnit *g = first();
   for ( ; g != GridUnitNULL;  g = next() ) 
     { gelem += g->guNum(lev,olap); }
   setcurrec(tmpcur);
   return gelem;
  }

int GridUnitList::levels(void)
  {
   int levels = 0;
   union record *tmpcur == currec();
   register GridUnit *g = first();
   if (g) levels = g->guLevels();
   setcurrec(tmpcur);
   return (levels);
  }

int GridUnitList::finest(void)
  {
   int flev = 0;
   union record *tmpcur == currec();
   register GridUnit *g = first();
   for ( ; g != GridUnitNULL;  g = next() ) 
     { flev = (g->finelev > flev) ? g->finelev : flev; }
   setcurrec(tmpcur);
   return (flev);
  }

int GridUnitList::smallest(const int level)
  {
   union record *tmpcur == currec();
   register GridUnit *g = first();
   int sext = 0;
   int e = 0;
   if (g) sext = g->guExtentAbs(level);
   for ( ; g != GridUnitNULL; g = next() ) 
     { sext = ((e=g->guExtentAbs(level)) < sext) ? e : sext; }
   setcurrec(tmpcur);
   return (sext);
  }

int GridUnitList::highestbaselevel(void)
  {
   register int low=0;
   union record *tmpcur == currec();
   register GridUnit *g = first();
   if (g) low = g->baselev;
   for ( ; g != GridUnitNULL;  g = next() ) 
     { if (g->baselev > low)  low = g->baselev; }
   setcurrec(tmpcur);
   return (low);
  }

dMapIndex GridUnitList::lowest(void)
  {
   dMapIndex low;
   union record *tmpcur == currec();
   register GridUnit *g = first();
   if (g) low = g->baseindex;
   for ( ; g != GridUnitNULL;  g = next() ) 
     { if (g->baseindex < low)  low = g->baseindex; }
   setcurrec(tmpcur);
   return (low);
  }

dMapIndex GridUnitList::lowest(const int level, const int owner, const int index)
  {
   dMapIndex low;
   union record *tmpcur == currec();
   register GridUnit *g = first();
   for ( ; g != GridUnitNULL;  g = next() ) 
     if (g->owner == owner && g->index == index  &&
         g->guContains(level)) 
       { low = g->baseindex; break; }
   for ( ; g != GridUnitNULL;  g = next() )
     { if (g->owner == owner &&
           g->index == index  &&
           g->guContains(level) &&
           g->baseindex < low)  low = g->baseindex; }
   setcurrec(tmpcur);
   return (low);
  }

int GridUnitList::maxindex()
  {
   union record *tmpcur == currec();
   register GridUnit *g = first();
   int mi = g->index;
   int i = 0;
   for ( ; g != GridUnitNULL;  g = next() ) 
     { mi = ((i=g->index) > mi) ? i : mi; }
   setcurrec(tmpcur);
   return (mi);
  }

void GridUnitList::setindex(void)
  {
   register int idx = 0;
   union record *tmpcur == currec();
   register GridUnit *g = first();
   for ( ; g != GridUnitNULL;  idx++, g = next() ) 
     { g->index = idx; }
   setcurrec(tmpcur);
  }

void GridUnitList::setindex(const int idx)
  {
   union record *tmpcur == currec();
   register GridUnit *g = first();
   for ( ; g != GridUnitNULL;  g = next() ) 
     { g->index = idx; }
   setcurrec(tmpcur);
  }

void GridUnitList::setowner(const int p)
  {
   union record *tmpcur == currec();
   register GridUnit *g = first();
   for ( ; g != GridUnitNULL;  g = next() ) 
     { g->owner = p; }
   setcurrec(tmpcur);
  }

void GridUnitList::setbbox()
  {
   union record *tmpcur == currec();
   register GridUnit *g = first();
   for ( ; g != GridUnitNULL;  g = next() ) 
     { g->guSetBBox(); }
   setcurrec(tmpcur);
  }

void GridUnitList::split(GridUnitList& gul)
  {
   Bucket<GridUnit>::split((Bucket<GridUnit> &) gul); 
   gul.setstats();
   num -= gul.num;
  }


/*
*************************************************************************
*                                                                       *
* And overload << for the GUL class....                                 *
*                                                                       *
*************************************************************************
*/
ostream&  operator << (ostream& os, const GridUnitList& cgul)
  {
   if (&cgul == GridUnitListNULL) return os;

   GridUnitList &gul = (GridUnitList &) cgul;
   union record *tmpcur == gul.currec();
 
   os << "Num:" << gul.num << " ";
   os <<  "\n";

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

   GridUnit *g = 0;
   os << *gul.first();
   os << "\n**********************************\n";

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

   gul.setcurrec(tmpcur);

   return os;
  }

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

ofstream&  operator << (ofstream& ofs, const GridUnitList& cgul)
  {
   if (&cgul == GridUnitListNULL) return ofs;

   GridUnitList &gul = (GridUnitList &) cgul;
   union record *tmpcur == gul.currec();
 
   ofs.write((char*)&gul.num,sizeof(int));

   if (gul.num == 0) return ofs;
   
   GridUnit *g = 0;
   for (g = gul.first(); g != GridUnitNULL; g = gul.next())
     ofs << *g;

   gul.setcurrec(tmpcur);

   return ofs;
  }

ifstream&  operator >> (ifstream& ifs, GridUnitList& cgul)
  {
   if (&cgul == GridUnitListNULL) return ifs;

   GridUnitList &gul = (GridUnitList &) cgul;
   union record *tmpcur == gul.currec();
 
   int numin;
   ifs.read((char*)&numin,sizeof(int));

   if (numin == 0) return ifs;

   register GridUnit* gu = 0;
   for (register int n=0; n<numin; n++) {
     gu = gul.add();
     ifs >> *gu;
   }

   gul.setcurrec(tmpcur);

   return ifs;
  }

strstream&  operator << (strstream& ofs, const GridUnitList& cgul)
  {
   if (&cgul == GridUnitListNULL) return ofs;

   GridUnitList &gul = (GridUnitList &) cgul;
   union record *tmpcur == gul.currec();
 
   ofs.write((char*)&gul.num,sizeof(int));

   if (gul.num == 0) return ofs;
   
   GridUnit *g = 0;
   for (g = gul.first(); g != GridUnitNULL; g = gul.next())
     ofs << *g;

   gul.setcurrec(tmpcur);

   return ofs;
  }

strstream&  operator >> (strstream& ifs, GridUnitList& cgul)
  {
   if (&cgul == GridUnitListNULL) return ifs;

   GridUnitList &gul = (GridUnitList &) cgul;
   union record *tmpcur == gul.currec();
 
   int numin;
   ifs.read((char*)&numin,sizeof(int));

   if (numin == 0) return ifs;

   register GridUnit* gu = 0;
   for (register int n=0; n<numin; n++) {
     gu = gul.add();
     ifs >> *gu;
   }

   gul.setcurrec(tmpcur);

   return ifs;
  }

---

Quickstart     Users Guide     Programmers Reference     Installation      Examples     Download

---

AMROC Main      Home      Contact

last update: 06/01/04