Box.H

Go to the documentation of this file.

/*
** (c) 1996-2000 The Regents of the University of California (through
** E.O. Lawrence Berkeley National Laboratory), subject to approval by
** the U.S. Department of Energy.  Your use of this software is under
** license -- the license agreement is attached and included in the
** directory as license.txt or you may contact Berkeley Lab's Technology
** Transfer Department at TTD@lbl.gov.  NOTICE OF U.S. GOVERNMENT RIGHTS.
** The Software was developed under funding from the U.S. Government
** which consequently retains certain rights as follows: the
** U.S. Government has been granted for itself and others acting on its
** behalf a paid-up, nonexclusive, irrevocable, worldwide license in the
** Software to reproduce, prepare derivative works, and perform publicly
** and display publicly.  Beginning five (5) years after the date
** permission to assert copyright is obtained from the U.S. Department of
** Energy, and subject to any subsequent five (5) year renewals, the
** U.S. Government is granted for itself and others acting on its behalf
** a paid-up, nonexclusive, irrevocable, worldwide license in the
** Software to reproduce, prepare derivative works, distribute copies to
** the public, perform publicly and display publicly, and to permit
** others to do so.
*/

#ifndef BL_BOX_H
#define BL_BOX_H
//
// $Id: Box.H,v 1.25 2001/10/10 20:12:44 car Exp $
//
#ifdef NODEV
#undef NODEV
#endif

#include <iosfwd>

#include <ccse-mpi.H>
#include <IntVect.H>
#include <IndexType.H>
#include <Orientation.H>
#include <SPACE.H>
//
// Forward declaration.
//
class Box;

namespace BoxLib
{
    Box grow (const Box& b, int i);
    //
    //
    Box grow (const Box& b, const IntVect& v);

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

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

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

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

    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 bdryLo (const Box& b, int dir, int len=1);

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

    Box bdryNode (const Box& b, const Orientation& face, int len=1);

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

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

    Box adjCell (const Box& b, const Orientation& face, int len=1);

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

//
//
std::ostream& operator<< (std::ostream& os, const Box& bx);
//
//
std::istream& operator>> (std::istream& os, Box& bx);

//
// :

class Box
{
    friend MPI_Datatype ParallelDescriptor::Mpi_typemap<Box>::type();
public:

    Box ();
    //
    //
    Box (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);
    //
    //
    const IntVect& smallEnd () const;
    //
    //
    int smallEnd (int dir) const;
    //
    //
    const IntVect& bigEnd () const;
    //
    //
    int bigEnd (int dir) const;
    //
    //
    IndexType ixType () const;
    //
    //
    IntVect type () const;
    //
    //
    IndexType::CellIndex type (int dir) const;
    //
    //
    const IntVect& length () const;
    //
    //
    int length (int dir) const;
 
    const int* loVect () const;
 
    const int* hiVect () const;
 
    const int* getVect () const;
    //
    //
    int operator[] (const Orientation& face) const;
    //
    //
    bool isEmpty () const;
    //
    //
    bool ok () const;
    //
    //
    bool contains (const IntVect& p) const;
 
    bool contains (const Box& b) const;
 
    bool intersects (const Box& b) const;
 
    bool sameSize (const Box& b) const;
    //
    //
    bool sameType (const Box &b) const;
    //
    //
    bool operator== (const Box& b) const;
    //
    //
    bool operator!= (const Box& b) const;
    //
    //
    bool cellCentered () 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;
 
    long index (const IntVect& v) const;
    //
    //
    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& shift (int dir,
                int nzones);
    //
    //
    Box& shift (const IntVect& iv);
 
    Box& shiftHalf (int dir,
                    int num_halfs);
    //
    //
    Box& shiftHalf (const IntVect& iv);
 
    Box& convert (IndexType typ);

    Box& convert (const IntVect& typ);
    //
    //
    Box& surroundingNodes ();
    //
    //
    Box& surroundingNodes (int dir);
    //
    //
    Box& enclosedCells ();
    //
    //
    Box& enclosedCells (int dir);
 
    Box operator& (const Box&) const;

    Box& operator&= (const Box&);
 
    Box& minBox (const Box &);
    //
    //
    Box& operator+= (const IntVect& v);
    //
    //
    Box  operator+  (const IntVect& v) const;
    //
    //
    Box& operator-= (const IntVect& v);
    //
    //
    Box  operator-  (const IntVect& v) const;

    Box chop (int dir,
              int chop_pnt);

    Box& grow (int i);
    //
    //
    Box& grow (const IntVect& v);

    Box& grow (int idir,
               int n_cell);

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

    Box& growHi (int idir,
                 int n_cell=1);
    //
    //
    Box& grow (const Orientation& face,
               int                n_cell=1);

    Box& refine (int refinement_ratio);

    Box& refine (const IntVect& refinement_ratio);

    Box& coarsen (int refinement_ratio);

    Box& coarsen (const IntVect& refinement_ratio);

    void next (IntVect &) const;

    void next (IntVect&   p,
               const int* shv) const;

    static const Box& TheUnitBox ();

protected:
    //
    // 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;
    mutable IntVect len;
    IndexType       btype;
};

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
int
Box::length (int dir) const
{
    return bigend[dir] - smallend[dir] + 1;
}

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
int
Box::operator[] (const Orientation& face) const
{
    const int dir = face.coordDir();
    return face.isLow() ? smallend[dir] : bigend[dir];
}

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

inline
bool
Box::isEmpty () const
{
    return numPts() == 0;
}

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

inline
bool
Box::contains (const IntVect& p) const
{
    return p >= smallend && p <= bigend;
}

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

inline
bool
Box::sameSize (const Box& b) const
{
    BL_ASSERT(sameType(b));
    return D_TERM(length(0) == b.length(0),
                  && length(1)==b.length(1),
                  && length(2)==b.length(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::ok () const
{
    return (bigend >= smallend) && btype.ok();
}

inline
const IntVect&
Box::length () const
{
    D_EXPR(len[0] = bigend[0]-smallend[0] + 1,
           len[1] = bigend[1]-smallend[1] + 1,
           len[2] = bigend[2]-smallend[2] + 1);

    return len;
}

#endif /*BL_BOX_H*/

---