---

ProblemDomain.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_PROBDOMAIN_H
#define CH_PROBDOMAIN_H

#ifndef WRAPPER
#include <iostream>

#include "Vector.H"
#include "IntVect.H"
#include "Box.H"
#include "Misc.H"
#endif

#include "SPACE.H"


class ShiftIterator
{
public:
  ShiftIterator();

  ShiftIterator(const bool* a_isPeriodic);

  ShiftIterator(const ShiftIterator& a_shiftIt);

  ~ShiftIterator();

  ShiftIterator& operator=(const ShiftIterator& a_src);

  void computeShifts(const bool* a_isPeriodic);

  inline IntVect operator()() const;
  IntVect i() const {return this->operator()();}

  inline void operator++();
  void incr(){++(*this);}

  inline bool ok() const;

  inline void reset();
  
  inline void begin();


  void end();

private:

  unsigned int m_index;

  Vector<IntVect> m_shift_vectors;

};



//
//@Man:
//@Memo: A class to facilitate interaction with physical boundary conditions
/*@Doc: 

  ProblemDomain is a class which facilitates the application of physical 
  boundary conditions, both periodic and non-periodic.  This class contains 
  much of the functionality of the Box class, since logically the 
  computational domain is generally a Box.  
  
  Intersection with a ProblemDomain object will result in only removing 
  regions which are outside the physical domain in non-periodic directions.
  Regions outside the logical computational domain in periodic directions will
  be treated as ghost cells which can be filled with an exchange() function 
  or through suitable interpolation from a coarser domain.

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

  Note that this implementation of ProblemDomain is inherently 
  cell-centered.


*/
class ProblemDomain
{
public:



    ProblemDomain ();


  ProblemDomain(const Box& a_domBox);


  ProblemDomain(const Box& a_domBox, const bool* a_isPeriodic);


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



    ProblemDomain (const IntVect& small,
                   const IntVect& big,
                   const bool* a_isPeriodic);



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



    ProblemDomain (const IntVect& small,
                   const int*     vec_len,
                   const bool* a_isPeriodic);



    ProblemDomain (const ProblemDomain& a_src);



  const Box& domainBox() const;
  


  bool isPeriodic(int a_dir) const;


  bool isPeriodic() const;
  
  

  ShiftIterator shiftIterator() const;



  bool isEmpty () const;
  

  bool contains (const IntVect& p) const;

  bool image (IntVect& p) const;
  

    bool contains (const Box& b) const;
  bool contains_box(const Box& b) const {return contains(b);}


  bool intersects (const Box& a_box) const;


    bool intersectsNotEmpty (const Box& a_box) const;



  bool intersects(const Box& box1, const Box& box2) const;


  friend void operator &=(Box& a_box, const ProblemDomain& a_probomain);


  friend Box operator & (const Box& a_box, const ProblemDomain& a_probdomain);



  ProblemDomain& operator= (const ProblemDomain& b);


  void setPeriodic(int a_dir, bool a_isPeriodic);
  

  inline ProblemDomain& grow (int i);


  friend inline ProblemDomain grow(const ProblemDomain& pd, 
                                   int i);


  inline ProblemDomain& grow(const IntVect& v);


  friend inline ProblemDomain grow (const ProblemDomain& pd,
                                     const IntVect& v);


  inline ProblemDomain& grow(int idir, int n_cell);


  inline ProblemDomain& growLo(int idir, int n_cell=1);


  inline ProblemDomain& growHi(int idir, int n_cell=1);
     



  friend Box bdryLo (const ProblemDomain& a_pd,
                     int        a_dir,
                     int        a_len=1);
  

  friend Box bdryHi (const ProblemDomain& a_pd,
                     int        a_dir,
                     int        a_len=1);
  

  friend Box adjCellLo (const ProblemDomain& a_pd,
                        int        a_dir,
                        int        a_len=1);
  

  friend Box adjCellHi (const ProblemDomain& a_pd,
                        int        a_dir,
                        int        a_len=1);
  
  
  

  Box operator& (const Box& a_b) const;
  





    ProblemDomain& refine (int a_refinement_ratio);


  friend ProblemDomain refine (const ProblemDomain& a_probdomain,
                               int   a_refinement_ratio);
  

  ProblemDomain& refine (const IntVect& a_refinement_ratio);
  

  friend ProblemDomain refine (const ProblemDomain&     a_probdomain,
                            const IntVect& a_refinement_ratio);

  

  ProblemDomain& coarsen (int a_refinement_ratio);
  

  friend ProblemDomain coarsen (const ProblemDomain& a_probdomain,
                             int        a_refinement_ratio);
  

  ProblemDomain& coarsen (const IntVect& refinement_ratio);
  

  friend ProblemDomain coarsen (const ProblemDomain&  a_probdomain,
                             const IntVect& a_refinement_ratio);
  


  

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


  friend std::istream& operator>> (std::istream& is,
                                   ProblemDomain&     bx);
  

  void dumpOn (std::ostream& strm) const;
  
  
protected:
  friend class HDF5Handle;

  bool m_isPeriodic[SpaceDim];

  Box m_domainBox;

  ShiftIterator m_shiftIt;



};

//
// Inlines.
//
#ifndef WRAPPER

inline
ShiftIterator::ShiftIterator()
  : m_index(100), m_shift_vectors()
{
}

inline 
ShiftIterator::ShiftIterator(const ShiftIterator& a_src)
{
  m_index = a_src.m_index;
  m_shift_vectors = a_src.m_shift_vectors;
}

inline
ShiftIterator&
ShiftIterator::operator=(const ShiftIterator& a_src)
{
  m_index = a_src.m_index;
  m_shift_vectors = a_src.m_shift_vectors;
  return *this;
}

inline
IntVect
ShiftIterator::operator()() const
{
  assert(ok());
  return m_shift_vectors[m_index];
}

inline
void
ShiftIterator::operator++() 
{
  m_index++;
}

inline 
bool
ShiftIterator::ok() const
{
  return (m_index < m_shift_vectors.size());
}

inline 
void
ShiftIterator::reset()
{
  m_index = 0;
}

inline
void
ShiftIterator::begin()
{
  m_index = 0;
}

inline 
void
ShiftIterator::end()
{
  m_index = m_shift_vectors.size();
}

inline
ProblemDomain::ProblemDomain ()
{
  // default is a non-periodic domain
  for (int dir=0; dir<SpaceDim; dir++) 
    {
      m_isPeriodic[dir] = false;
    }
  
}

inline
ProblemDomain::ProblemDomain (const ProblemDomain& b)
  : m_domainBox(b.m_domainBox), m_shiftIt(b.m_shiftIt)
{  
  for (int dir=0; dir<SpaceDim; dir++) 
    {
      m_isPeriodic[dir] = b.m_isPeriodic[dir];
    }
}


inline
ProblemDomain&
ProblemDomain::operator= (const ProblemDomain& b)
{  
  m_domainBox = b.m_domainBox;
  for (int dir=0; dir<SpaceDim; dir++) 
    {
      m_isPeriodic[dir] = b.m_isPeriodic[dir];
    }
  m_shiftIt = b.m_shiftIt;
  return *this;
}

inline 
const Box& 
ProblemDomain::domainBox() const
{
  return m_domainBox;
}

inline
bool
ProblemDomain::isPeriodic(int a_dir) const
{
  return m_isPeriodic[a_dir];
}

inline
bool
ProblemDomain::isPeriodic() const
{
  return D_TERM(m_isPeriodic[0],
                || m_isPeriodic[1],
                || m_isPeriodic[2]);
}

inline
ProblemDomain& 
ProblemDomain::grow(int i)
{
  m_domainBox.grow(i);
  return *this;
}

inline 
ProblemDomain 
grow(const ProblemDomain& pd, int i)
{
  ProblemDomain newPd(pd);
  newPd.grow(i);
  return newPd;
}

inline
ProblemDomain&
ProblemDomain::grow(const IntVect& v)
{
  m_domainBox.grow(v);
  return *this;
}

inline
ProblemDomain
grow(const ProblemDomain& pd, const IntVect& v)
{
  ProblemDomain newPd(pd);
  newPd.grow(v);
  return newPd;
}

inline
ProblemDomain&
ProblemDomain::grow(int idir, int n_cell)
{
  m_domainBox.grow(idir, n_cell);
  return *this;
}

inline 
ProblemDomain&
ProblemDomain::growLo(int idir, int n_cell)
{
  m_domainBox.growLo(idir, n_cell);
  return *this;
}

inline 
ProblemDomain&
ProblemDomain::growHi(int idir, int n_cell)
{
  m_domainBox.growHi(idir, n_cell);
  return *this;
}

inline 
ShiftIterator
ProblemDomain::shiftIterator() const
{
  return m_shiftIt;
}

inline
bool
ProblemDomain::isEmpty () const
{
  return (m_domainBox.isEmpty());
}

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

  // boy is this ugly!
  return ( !isEmpty() && 
           (D_TERM((m_isPeriodic[0] 
                    || (p[0]>m_domainBox.smallEnd(0) 
                        && p[0]<m_domainBox.bigEnd(0))),
                   && (m_isPeriodic[1] 
                       || (p[1]>m_domainBox.smallEnd(1) 
                           && p[1]<m_domainBox.bigEnd(1))),
                   && (m_isPeriodic[2]
                       || (p[2]>m_domainBox.smallEnd(2)
                           && p[2]<m_domainBox.bigEnd(2))))));
}
                     
inline
bool
ProblemDomain::image(IntVect& p) const
{
  if(m_domainBox.contains(p)) return true;
  if(!contains(p)) return false;

  if(m_isPeriodic[0]){
        if(p[0]<m_domainBox.smallEnd(0))    p[0]+= m_domainBox.size(0);
        else if(p[0]>m_domainBox.bigEnd(0)) p[0]-= m_domainBox.size(0);
  }
  if(m_isPeriodic[1]){
        if(p[1]<m_domainBox.smallEnd(1))    p[1]+= m_domainBox.size(1);
        else if(p[1]>m_domainBox.bigEnd(1)) p[1]-= m_domainBox.size(1);
  }
  
#if (CH_SPACEDIM == 3)
  if(m_isPeriodic[2]){
        if(p[2]<m_domainBox.smallEnd(2))    p[2]+= m_domainBox.size(2);
        else if(p[2]>m_domainBox.bigEnd(2)) p[2]-= m_domainBox.size(2);
  }
#endif
  return true;
}


inline
bool
ProblemDomain::contains (const Box& b) const
{
  // boy is this ugly!
  return ( !isEmpty() && 
           (D_TERM((m_isPeriodic[0] 
                    || (b.smallEnd(0)>=m_domainBox.smallEnd(0) 
                        && b.bigEnd(0)<=m_domainBox.bigEnd(0))),
                   && (m_isPeriodic[1] 
                       || (b.smallEnd(1)>=m_domainBox.smallEnd(1) 
                           && b.bigEnd(1)<=m_domainBox.bigEnd(1))),
                   && (m_isPeriodic[2]
                       || (b.smallEnd(2)>=m_domainBox.smallEnd(2)
                           && b.bigEnd(2)<=m_domainBox.bigEnd(2))))));
  
}

#endif /*WRAPPER*/


#endif /*CH_PROBLEM_DOMAIN_H*/

---