---

Box.H

Go to the documentation of this file.

/* _______              __
  / ___/ /  ___  __ _  / /  ___
 / /__/ _ \/ _ \/  ' \/ _ \/ _ \
 \___/_//_/\___/_/_/_/_.__/\___/ 
*/
//
// This software is copyright (C) by the Lawrence Berkeley
// National Laboratory.  Permission is granted to reproduce
// this software for non-commercial purposes provided that
// this notice is left intact.
// 
// It is acknowledged that the U.S. Government has rights to
// this software under Contract DE-AC03-765F00098 between
// the U.S.  Department of Energy and the University of
// California.
//
// This software is provided as a professional and academic
// contribution for joint exchange. Thus it is experimental,
// is provided ``as is'', with no warranties of any kind
// whatsoever, no support, no promise of updates, or printed
// documentation. By using this software, you acknowledge
// that the Lawrence Berkeley National Laboratory and
// Regents of the University of California shall have no
// liability with respect to the infringement of other
// copyrights by any part of this software.
//

#ifndef CH_BOX_H
#define CH_BOX_H

#ifdef NODEV
#undef NODEV
#endif

#include "SPACE.H"

#ifndef WRAPPER
#include <iostream>



#include "IntVect.H"
#include "Misc.H"
#include "LoHiSide.H"


//
//@Man:
//@Memo: Cell-Based or Node-Based Indices
/*@Doc:

  The class IndexType defines an index as being cell based or node (face)
  based in each of the CH\_SPACEDIM directions.  This class defines an
  enumerated type CellIndex to be either CELL or NODE; i.e. each of the
  CH\_SPACEDIM dimensions must be either CELL or NODE.
*/

class IndexType
{
public:

  enum CellIndex { CELL = 0, NODE = 1 };


  IndexType ();


  IndexType (const IndexType& rhs);


  explicit IndexType (const IntVect& iv);


  IndexType& operator= (const IndexType& rhs);


  IndexType (D_DECL(CellIndex i, CellIndex j, CellIndex k));


  void set (int dir);


  void unset (int dir);


  bool test (int dir) const;


  void setall ();


  void clear ();


  bool any () const;


  bool ok () const;


  void flip (int i);


  bool operator== (const IndexType& t) const;


  bool operator!= (const IndexType& t) const;


  bool cellCentered () const;


  bool nodeCentered () const;


  void setType (int       dir,
                CellIndex t);


  CellIndex ixType (int dir) const;


  int operator[] (int dir) const;


  IntVect ixType () const;


  static IndexType TheCellType ();


  static IndexType TheNodeType ();


  friend std::ostream& operator<< (std::ostream&         os,
                                   const IndexType& itype);


  friend std::istream& operator>> (std::istream&   is,
                                   IndexType& itype);
private:
  //
  // Returns 1<<k.
  //
  static int mask (int k);
  //
  // An integer holding the CellIndex in bits 0 - BL\_SPACEDIM-1.
  //
  unsigned int itype;
};

//
// Inlines.
//


inline
int
IndexType::mask (int k)
{
  return 1<<k;
}

inline
IndexType::IndexType ()
  : itype(0)
{}

inline
IndexType::IndexType (const IndexType& bt)
  : itype(bt.itype)
{}

inline
IndexType& IndexType::operator= (const IndexType& bt)
{
  itype = bt.itype;
  return *this;
}

inline
IndexType::IndexType (const IntVect& iv)
{
  itype = D_TERM((iv[0]?1:0), | ((iv[1]?1:0)<<1), | ((iv[2]?1:0)<<2));
}

inline
IndexType::IndexType (D_DECL(CellIndex i, CellIndex j, CellIndex k))
{
  itype = D_TERM(i, | (j<<1), | (k<<2));
}

inline
void
IndexType::set (int dir)
{
  itype |= mask(dir);
}

inline
void
IndexType::unset (int dir)
{
  itype &= ~mask(dir);
}

inline
bool
IndexType::test (int dir) const
{
  return (itype & mask(dir)) != 0;
}

inline
void
IndexType::setall ()
{
  itype = (1 << SpaceDim) - 1;
}

inline
void
IndexType::clear ()
{
  itype = 0;
}

inline
bool
IndexType::any () const
{
  return itype != 0;
}

inline
bool
IndexType::ok () const
{
  return itype < (1 << SpaceDim);
}

inline
void
IndexType::flip (int i)
{
  itype ^= mask(i);
}

inline
bool
IndexType::operator== (const IndexType& t) const
{
  return t.itype == itype;
}

inline
bool
IndexType::operator!= (const IndexType& t) const
{
  return t.itype != itype;
}

inline
bool
IndexType::cellCentered () const
{
  return itype == 0;
}

inline
bool
IndexType::nodeCentered () const
{
  return itype == (1<<SpaceDim)-1;
}

inline
void
IndexType::setType (int       dir,
                    CellIndex t)
{
  t == CELL ? unset(dir) : set(dir);
}

inline
IndexType::CellIndex
IndexType::ixType (int dir) const
{
  return (CellIndex) ((itype & (1<<dir)) >> dir);
}

inline
int
IndexType::operator[] (int dir) const
{
  return test(dir);
}

inline
IntVect
IndexType::ixType () const
{
  return IntVect(D_DECL(itype&1, (itype>>1)&1, (itype>>2)&1));
}

#endif /* WRAPPER */

//
//@Man:
//@Memo: A Rectangular Domain on an Integer Lattice
/*@Doc: 

  A Box is an abstraction for defining discrete rectangular regions of
  SpaceDim-dimensioned indexing space.  Boxes have an IndexType, which
  defines IndexType::CELL or IndexType::NODE based points for each
  direction and a low and high IntVect which defines the lower and
  upper corners of the Box.  Boxes can exist in positive and negative
  indexing space.

  There is a set of canonical Empty Boxes, once for each centering
  type.  The cell-centered Empty Box can be accessed as Box::Empty.

  Box is a dimension dependent class, so SpaceDim must be 
  defined as either 1, 2, or 3 when compiling.  

*/

class Box
{
public:



  Box ();


  ~Box () {;}



  Box (const IntVect& small,
       const IntVect& big);


  void define(const IntVect& small, const IntVect& big);


  Box (const IntVect& small,
       const int*     vec_len);


  Box (const IntVect& small,
       const IntVect& big,
       const IntVect& typ);


  Box (const IntVect&   small,
       const IntVect&   big,
       const IndexType& t);


  Box (const Box& b);

  void define(const Box& b);

  Box copy() const {return *this;}



  const IntVect& smallEnd () const;


  IntVect sideEnd(Side::LoHiSide a_side) const;



  int smallEnd (int dir) const;


  const IntVect& bigEnd () const;


  int bigEnd (int dir) const;


  const int* loVect () const;


  const int* hiVect () const;


  const int* getVect () const;


  long index (const IntVect& v) const;



  IndexType ixType () const;


  IntVect type () const;


  IndexType::CellIndex type (int dir) const;



  const IntVect& size () const;


  int size (int dir) const;


  bool numPtsOK () const;


  long numPts () const;


  bool volumeOK () const;


  long volume () const;


  int longside (int& dir) const;


  int longside () const;


  int shortside (int& dir) const;


  int shortside () const;




  bool isEmpty () const;


  bool contains (const IntVect& p) const;


  bool contains (const Box& b) const;


  bool intersects (const Box& b) const;


  bool intersectsNotEmpty (const Box& b) const;


  bool sameSize (const Box& b) const;


  bool sameType (const Box &b) const;


  bool operator== (const Box& b) const;

  bool eq(const Box& b) const;

  bool operator!= (const Box& b) const;

  bool neq(const Box& b) const;

  bool cellCentered () const;

  // following operators added Sept. 14, 1999.  bvs

  bool operator < (const Box& rhs) const;

  bool lt(const Box& rhs) const;




  Box& operator= (const Box& b);


  Box& setSmall (const IntVect& sm);


  Box& setSmall (int dir,
                 int sm_index);


  Box& setBig (const IntVect& bg);


  Box& setBig (int dir,
               int bg_index);


  Box& setRange (int dir,
                 int sm_index,
                 int n_cells = 1);



  Box& convert (IndexType typ);


  Box& convert (const IntVect& typ);


  Box& convert (int                  dir,
                IndexType::CellIndex typ);


  Box& surroundingNodes ();


  Box& surroundingNodes (int dir);

  Box& surroundingNodes_int(int dir);

  friend  Box surroundingNodes (const Box& b,
                                int        dir);

  

  friend Box surroundingNodes (const Box& b);


  Box& enclosedCells ();


  Box& enclosedCells (int dir);

  Box& enclosedCells_int (int dir);


  friend Box enclosedCells (const Box& b,
                            int        dir);


  friend Box enclosedCells (const Box& b);



  Box& shift (int dir,
              int nzones);


  Box& shift (const IntVect& iv);
  
  Box& shift_intvect (const IntVect& iv);


  Box& shiftHalf (int dir,
                  int num_halfs);


  Box& shiftHalf (const IntVect& iv);
  Box& shiftHalf_intvect (const IntVect& iv);


  Box& operator+= (const IntVect& v);


  Box  operator+  (const IntVect& v) const;


  Box& operator-= (const IntVect& v);


  Box  operator-  (const IntVect& v) const;


  friend Box bdryBox(const Box& b,
                     int        dir,
                     Side::LoHiSide a_sd,
                     int        len);



  friend Box bdryLo (const Box& b,
                     int        dir,
                     int        len);


  friend Box bdryHi (const Box& b,
                     int        dir,
                     int        len);


  friend Box adjCellLo (const Box& b,
                        int        dir,
                        int        len);


  friend Box adjCellHi (const Box& b,
                        int        dir,
                        int        len);




  Box operator& (const Box&) const;


  Box& operator&= (const Box&);


  friend Box adjCellBox (const Box& b,
                         int        dir,
                         Side::LoHiSide a_side,
                         int        len);

  Box& minBox (const Box& b);


  friend Box minBox (const Box& b1,
                     const Box& b2);



  Box& grow (int i);


  friend Box grow (const Box& b,
                   int        i);


  Box& grow (const IntVect& v);


  friend  Box grow (const Box&     b,
                    const IntVect& v);


  Box& grow (int idir,
             int n_cell);


  Box& growLo (int idir,
               int n_cell=1);


  Box& growDir (int a_idir,
                const Side::LoHiSide& a_sd,
                int a_cell);


  Box& growHi (int idir,
               int n_cell=1);



  Box& refine (int refinement_ratio);


  friend Box refine (const Box& b,
                     int        refinement_ratio);


  Box& refine (const IntVect& refinement_ratio);


  friend Box refine (const Box&     b,
                     const IntVect& refinement_ratio);



  Box& coarsen (int refinement_ratio);


  friend Box coarsen (const Box& b,
                      int        refinement_ratio);


  Box& coarsen (const IntVect& refinement_ratio);


  friend Box coarsen (const Box&     b,
                      const IntVect& refinement_ratio);

  // next(...) is out of favor.  use BoxIterator.
  /*
    Step through the rectangle.  It is a runtime error to give
    a point not inside rectangle.  Iteration may not be efficient.
  */
  void next (IntVect &) const;

  /*
    Scan argument IntVect over object second arg is
    increment vector.  Runtime error if IntVect is not
    contained in object Box.  Iteration may not be efficient.
  */
  void next (IntVect&   p,
             const int* shv) const;




  Box chop (int dir,
            int chop_pnt);



  friend std::ostream& operator<< (std::ostream&   os,
                                   const Box& bx);


  friend std::istream& operator>> (std::istream& os,
                                   Box&     bx);



  void p() const;


  void dumpOn (std::ostream& strm) const;



  //static const Box Empty;


  // TheUnitBox is out of favor.
  /*
    This static member function returns a constant reference to 
    an object of type Box representing the unit box in
    BL\_SPACEDIM-dimensional space.
  */

  //static const Box& TheUnitBox ();

  //
  // Sets the 'len' element of the Box.  Aborts on integer overflow.
  //
  void computeBoxLen ();
  void computeBoxLenNotEmpty();

protected:
  friend class HDF5Handle;
  //
  // A helper function for numPtsOK() and numPts().
  //
  bool numPtsOK (long& N) const;
  //
  // A helper function for volumeOK() and volume().
  //
  bool volumeOK (long& N) const;

  IntVect   smallend;
  IntVect   bigend;
  IntVect   len;
  IndexType btype;

};

// global function prototypes
Box surroundingNodes (const Box& b,
                      int        dir);
Box surroundingNodes (const Box& b);
Box enclosedCells (const Box& b,
                   int        dir);
Box enclosedCells (const Box& b);
Box bdryBox(const Box& b,
            int        dir,
            Side::LoHiSide a_sd,
            int        len=1);
Box bdryLo (const Box& b,
            int        dir,
            int        len=1);
Box bdryHi (const Box& b,
            int        dir,
            int        len=1);
Box adjCellLo (const Box& b,
               int        dir,
               int        len=1);
Box adjCellHi (const Box& b,
               int        dir,
               int        len=1);
Box minBox (const Box& b1,
            const Box& b2);
//
// Inlines. 
//

#ifndef WRAPPER

inline
Box::Box (const Box& b)
  : smallend(b.smallend),
    bigend(b.bigend),
    btype(b.btype)
{
  D_EXPR(len[0] = b.len[0],
         len[1] = b.len[1],
         len[2] = b.len[2]);
}

inline
Box&
Box::operator= (const Box& b)
{
  smallend = b.smallend;
  bigend = b.bigend;
  btype = b.btype;
  D_EXPR(len[0] = b.len[0],
         len[1] = b.len[1],
         len[2] = b.len[2]);
  return *this;
}

inline
IntVect
Box::sideEnd(Side::LoHiSide a_side) const
{
  IntVect retval;
  if(a_side == Side::Lo)
    retval = smallEnd();
  else
    retval = bigEnd();
  return retval;
}

inline
const IntVect&
Box::smallEnd () const
{
  return smallend;
}

inline
int
Box::smallEnd (int dir) const
{
  return smallend[dir];
}

inline
const IntVect&
Box::bigEnd () const
{
  return bigend;
}

inline
int
Box::bigEnd (int dir) const
{
  return bigend[dir];
}

inline
IndexType
Box::ixType () const
{
  return btype;
}

inline
IntVect
Box::type () const
{
  return btype.ixType();
}

inline
IndexType::CellIndex
Box::type (int dir) const
{
  return btype.ixType(dir);
}

inline
const IntVect&
Box::size () const
{
  return len;
}

inline
int
Box::size (int dir) const
{
  return len[dir];
}

inline
const int*
Box::loVect () const
{
  return smallend.getVect();
}

inline
const int*
Box::hiVect () const
{
  return bigend.getVect();
}

inline
const int*
Box::getVect () const
{
  return smallend.getVect();
}


inline
bool
Box::numPtsOK () const
{
  long ignore;
  return numPtsOK(ignore);
}

inline
bool
Box::isEmpty () const
{
  //    return numPts() == 0;
  return (!(bigend >= smallend));
}

inline
bool
Box::contains (const IntVect& p) const
{

  return ( !isEmpty() && (p >= smallend && p <= bigend) );
}

inline
bool
Box::sameType (const Box &b) const
{
  return btype == b.btype;
}

inline
bool
Box::contains (const Box& b) const
{
  assert(sameType(b));
  return ( !isEmpty() && !b.isEmpty() && 
           (b.smallend >= smallend && b.bigend <= bigend) );
}

inline
bool
Box::sameSize (const Box& b) const
{
  assert(sameType(b));
  return D_TERM(len[0] == b.len[0],
                && len[1]==b.len[1],
                && len[2]==b.len[2]);
}

inline
bool
Box::operator== (const Box& b) const
{
  return smallend == b.smallend && bigend == b.bigend && b.btype == btype;
}

inline
bool
Box::operator!= (const Box& b) const
{
  return !operator==(b);
}

inline
bool
Box::cellCentered () const
{
  return !btype.any();
}

inline
bool
Box::volumeOK () const
{
  return numPtsOK();
}

inline
long
Box::index (const IntVect& v) const
{
  long result = v.vect[0]-smallend.vect[0];
#if   CH_SPACEDIM==2
  result += len[0]*(v.vect[1]-smallend.vect[1]);
#elif CH_SPACEDIM==3
  result += len[0]*(v.vect[1]-smallend.vect[1]
                    +(v.vect[2]-smallend.vect[2])*len[1]);
#endif
  return result;
}

inline
void
Box::computeBoxLen ()
{
  if (isEmpty())
    {
      len = IntVect::Zero;
    }
  else
    {
      D_EXPR(len[0] = bigend[0]-smallend[0] + 1,
             len[1] = bigend[1]-smallend[1] + 1,
             len[2] = bigend[2]-smallend[2] + 1);
    }
}

inline
void
Box::computeBoxLenNotEmpty()
{
  D_EXPR(len[0] = bigend[0]-smallend[0] + 1,
         len[1] = bigend[1]-smallend[1] + 1,
         len[2] = bigend[2]-smallend[2] + 1);
}

inline
Box&
Box::setSmall (const IntVect& sm)
{
  assert (sm <= bigend);

  smallend = sm;
  computeBoxLen();
  return *this;
}

inline
Box&
Box::setSmall (int dir,
               int sm_index)
{
  assert (sm_index <= bigend[dir]);

  smallend.setVal(dir,sm_index);
  computeBoxLen();
  return *this;
}

inline
Box&
Box::setBig (const IntVect& bg)
{
  assert (bg >= smallend);

  bigend = bg;
  computeBoxLen();
  return *this;
}

inline
Box&
Box::setBig (int dir,
             int bg_index)
{
  assert (bg_index >= smallend[dir]);

  bigend.setVal(dir,bg_index);
  computeBoxLen();
  return *this;
}

inline
Box&
Box::setRange (int dir,
               int sm_index,
               int n_cells)
{
  assert (n_cells > 0);

  smallend.setVal(dir,sm_index);
  bigend.setVal(dir,sm_index+n_cells-1);
  computeBoxLen();
  return *this;
}

inline
Box&
Box::shift (int dir,
            int nzones)
{
  if (!isEmpty())
    {
      smallend.shift(dir,nzones);
      bigend.shift(dir,nzones);
    }
  return *this;
}

inline
Box&
Box::shift (const IntVect& iv)
{
  if (!isEmpty())
    {
      smallend.shift(iv);
      bigend.shift(iv);
    }
  return *this;
}

inline
Box&
Box::convert (const IntVect& typ)
{
  assert(typ >= IntVect::TheZeroVector() && typ <= IntVect::TheUnitVector());
  if (!isEmpty())
    {
      IntVect shft(typ - btype.ixType());
      bigend += shft;
    }
  btype = IndexType(typ);
  computeBoxLen();
  return *this;
}

inline
Box&
Box::surroundingNodes (int dir)
{
  if (!(btype[dir]))
    {
      if (!isEmpty())
        {
          bigend.shift(dir,1);
        }
      //
      // Set dir'th bit to 1 = IndexType::NODE.
      //
      btype.set(dir);
      computeBoxLen();
    }
  return *this;
}

inline
Box&
Box::enclosedCells (int dir)
{
  if (btype[dir])
    {
      if (!isEmpty())
        {
          bigend.shift(dir,-1);
        }
      //
      // Set dir'th bit to 0 = IndexType::CELL.
      //
      btype.unset(dir);
      computeBoxLen();
    }
  return *this;
}

inline
Box
surroundingNodes (const Box& b,
                  int        dir)
{
  Box bx(b);
  return bx.surroundingNodes(dir);
}

inline
Box
surroundingNodes (const Box& b)
{
  Box bx(b);
  return bx.surroundingNodes();
}

inline
Box
enclosedCells (const Box& b,
               int        dir)
{
  Box bx(b);
  return bx.enclosedCells(dir);
}

inline
Box
enclosedCells (const Box& b)
{
  Box bx(b);
  return bx.enclosedCells();
}

inline
Box&
Box::operator+= (const IntVect& v)
{
  if (!isEmpty())
    {
      smallend += v;
      bigend += v;
    }
  return *this;
}

inline
Box
Box::operator+  (const IntVect& v) const
{
  if (isEmpty())
    {
      return(Box().convert(btype));
    }
  else
    {
      IntVect small(smallend);
      small += v;
      IntVect big(bigend);
      big += v;
      return Box(small,big,btype);
    }
}

inline
Box&
Box::operator-= (const IntVect& v)
{
  if (!isEmpty())
    {
      smallend -= v;
      bigend -= v;
    }
  return *this;
}

inline
bool 
Box::operator < (const Box& rhs) const
{
  return(!isEmpty() && (rhs.isEmpty() || smallend.lexLT(rhs.smallend)));
}

inline
Box
Box::operator-  (const IntVect& v) const
{
  if (isEmpty())
    {
      return(Box().convert(btype));
    }
  else
    {
      IntVect small = smallend;
      small -= v;
      IntVect big = bigend;
      big -= v;
      return Box(small,big,btype);
    }
}

inline
Box&
Box::grow (int i)
{
  if (!isEmpty())
    {
      smallend.diagShift(-i);
      bigend.diagShift(i);
      if (!(bigend >= smallend)) *this = Box().convert(btype);
      computeBoxLen();
    }
  return *this;
}

inline
Box
grow (const Box& b,
      int        i)
{
  if (b.isEmpty())
    {
      return (Box().convert(b.btype));
    }
  else
    {
      IntVect small = diagShift(b.smallend,-i);
      IntVect big   = diagShift(b.bigend,i);
      if (!(big >= small))
        {
          return(Box().convert(b.btype));
        }
      else
        {
          return Box(small,big,b.btype);
        }
    }
}

inline
Box&
Box::grow (const IntVect& v)
{
  if (!isEmpty())
    {
      smallend -= v;
      bigend   += v;
      if (!(bigend >= smallend)) *this = Box().convert(btype);
      computeBoxLen();
    }
  return *this;
}

inline
Box
grow (const Box&     b,
      const IntVect& v)
{
  if (b.isEmpty())
    {
      return(Box().convert(b.btype));
    }
  else
    {
      IntVect small = b.smallend - v;
      IntVect big   = b.bigend   + v;
      if (!(big >= small))
        {
          return(Box().convert(b.btype));
        }
      else
        {
          return Box(small,big,b.btype);
        }
    }
}

inline
Box&
Box::grow (int idir,
           int n_cell)
{
  if (!isEmpty())
    {
      smallend.shift(idir, -n_cell);
      bigend.shift(idir, n_cell);
      if (!(bigend >= smallend)) *this = Box().convert(btype);
      computeBoxLen();
    }
  return *this;
}

inline
Box&
Box::growLo (int idir,
             int n_cell)
{
  if (!isEmpty())
    {
      smallend.shift(idir, -n_cell);
      if (!(bigend >= smallend)) *this = Box().convert(btype);
      computeBoxLen();
    }
  return *this;
}

inline
Box&
Box::growDir (int idir,
              const Side::LoHiSide& a_sd,
              int n_cell)
{
  if(a_sd == Side::Lo)
    {
      growLo(idir, n_cell);
    }
  else
    {
      growHi(idir, n_cell);
    }
  return *this;
}

inline
Box&
Box::growHi (int idir,
             int n_cell)
{
  if (!isEmpty())
    {
      bigend.shift(idir,n_cell);
      if (!(bigend >= smallend)) *this = Box().convert(btype);
      computeBoxLen();
    }
  return *this;
}


inline
Box
Box::operator& (const Box& rhs) const
{
  Box lhs(*this);
  return lhs &= rhs;
}

#endif /* WRAPPER */

#endif /*CH_BOX_H*/

---