ProblemDomain.H

Go to the documentation of this file.

/*   _______              __
    / ___/ /  ___  __ _  / /  ___
   / /__/ _ \/ _ \/  V \/ _ \/ _ \
   \___/_//_/\___/_/_/_/_.__/\___/
*/
// CHOMBO Copyright (c) 2000-2004, The Regents of the University of
// California, through Lawrence Berkeley National Laboratory (subject to
// receipt of any required approvals from U.S. Dept. of Energy).  All
// rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// (1) Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// (2) Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// (3) Neither the name of Lawrence Berkeley National Laboratory, U.S.
// Dept. of Energy nor the names of its contributors may be used to endorse
// or promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// You are under no obligation whatsoever to provide any bug fixes,
// patches, or upgrades to the features, functionality or performance of
// the source code ("Enhancements") to anyone; however, if you choose to
// make your Enhancements available either publicly, or directly to
// Lawrence Berkeley National Laboratory, without imposing a separate
// written license agreement for such Enhancements, then you hereby grant
// the following license: a non-exclusive, royalty-free perpetual license
// to install, use, modify, prepare derivative works, incorporate into
// other computer software, distribute, and sublicense such Enhancements or
// derivative works thereof, in binary and source code form.
//
// TRADEMARKS. Product and company names mentioned herein may be the
// trademarks of their respective owners.  Any rights not expressly granted
// herein are reserved.
//

#ifndef _PROBLEMDOMAIN_H_
#define _PROBLEMDOMAIN_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;

};


class ProblemDomain
{
public:

  // Constructors


  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);


  void define(const Box& a_domBox);


  void define(const Box& a_domBox, const bool* a_isPeriodic);


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


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


  void  define (const IntVect& small,
                const int*     vec_len);
  

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

  void define (const ProblemDomain& a_src);
  
  //  Accessors


  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;


  bool operator== (const ProblemDomain& a_otherDomain);


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


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

  //  Modification Functions


  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);

  // Intersection functions


  Box operator& (const Box& a_b) const;

  // refinement


    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);

  // coarsening


  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);

  // I/O Functions


  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
{
 CH_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
bool
ProblemDomain::operator== (const ProblemDomain& a_otherDomain)
{
  bool result = true;

  if (m_domainBox != a_otherDomain.m_domainBox)
  {
    result = false;
  }
  else
  {
    for (int dir=0; dir<SpaceDim; dir++)
    {
      if (m_isPeriodic[dir] != a_otherDomain.m_isPeriodic[dir])
      {
        result = false;
        break;
      }
    }
  }

  return result;
}

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

---