IntVectSet.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 _INTVECTSET_H_
#define _INTVECTSET_H_

#include "SPACE.H"

#ifndef WRAPPER
#include <iostream>
#include "Box.H"
#include "IntVect.H"
#include "TreeIntVectSet.H"
#include "DenseIntVectSet.H"
#include "parstream.H"

#endif


class IntVectSet
{
public:
  friend
  class IVSIterator;


  ~IntVectSet();

  IntVectSet();
  void
  define();

  IntVectSet(const IntVectSet& ivs);
  void
  define(const IntVectSet& ivs);
  void
  define_intvectset(const IntVectSet& ivs){ define(ivs);}
  IntVectSet
  copy() const {return *this;}

  explicit
  IntVectSet(const DenseIntVectSet& a_dense);
  void
  define (const DenseIntVectSet& a_dense);
  explicit
  IntVectSet(const TreeIntVectSet& a_tree);
  void
  define (const TreeIntVectSet& a_tree);


  explicit
  IntVectSet(const IntVect& iv);
  void
  define(const IntVect& iv);
  void
  define_intvect(const IntVect& iv){define(iv);}


  explicit
  IntVectSet(const Box& b);

  void
  define(const Box& b);
  void
  define_box(const Box& b){define(b);}


  IntVectSet&
  operator|=(const IntVectSet& ivs);

  void
  or_intvectset(const IntVectSet& ivs) { *this |= ivs;}

  IntVectSet&
  operator|=(const IntVect& iv);
  void
  or_intvect(const IntVect& ivs) { *this |= ivs;}

  IntVectSet&
  operator|=(const Box& b);
  void
  or_box(const Box& b) { *this |= b;}

  friend
  IntVectSet
  operator|(const IntVectSet& ivs1, const IntVectSet& ivs2);

  friend
  IntVectSet
  operator|(const IntVectSet& ivs, const IntVect& iv);

  friend
  IntVectSet
  operator|(const IntVect& iv, const IntVectSet& ivs);

  friend
  IntVectSet
  operator|(const IntVectSet& ivs, const Box& b);

  friend
  IntVectSet
  operator|(const Box& b, const IntVectSet& ivs);


  IntVectSet
  operator-(const IntVectSet& ivs) const;

  IntVectSet
  operator-(const Box& b) const;

  IntVectSet
  operator-(const IntVect& iv) const;


  IntVectSet&
  operator-=(const IntVectSet& ivs);
  void
  minus(const IntVectSet& ivs){*this -= ivs;}


  IntVectSet&
  operator-=(const Box& b);
  void
  minus_box(const Box& b){ *this -=b;}


  IntVectSet&
  operator-=(const IntVect& iv);
  void
  minus_intvect(const IntVect& iv){ *this -=iv;}



  friend
  IntVectSet
  operator&(const IntVectSet& ivs1, const IntVectSet& ivs2);


  friend
  IntVectSet
  operator&(const IntVectSet& ivs, const Box& b);


  friend
  IntVectSet
  operator&(const Box& b, const IntVectSet& ivs);

  IntVectSet&
  operator&=(const IntVectSet& ivs);
  void
  and_intvectset(const IntVectSet& ivs){*this &= ivs;}

  IntVectSet&
  operator&=(const Box& b);
  void
  and_box(const Box& b){*this &= b;}

  IntVectSet&
  operator&=(const ProblemDomain& domain);
  void
  and_domain(const ProblemDomain& d){*this &= d;}



  void
  grow(int igrow);


  friend
  IntVectSet
  grow(const IntVectSet& ivs, int igrow);


  IntVectSet&
  grow(int idir, int igrow);
  void
  grow_dir(int idir, int igrow){grow(idir, igrow);}


  IntVectSet&
  refine(int iref = 2);


  friend
  IntVectSet
  refine(const IntVectSet& ivs, int iref = 2);


  IntVectSet&
  coarsen(int iref = 2);


  friend
  IntVectSet
  coarsen(const IntVectSet& ivs, int iref = 2);

  void
  shift(const IntVect& iv);


  void
  nestingRegion(int radius, const Box& domain, int granularity  = 1);


  void
  nestingRegion(int radius, const ProblemDomain& probdomain, int granularity = 1);
  void
  nestingRegion_prob(int radius, const ProblemDomain& probdomain)
  {
    nestingRegion(radius, probdomain);
  }

  void
  makeEmpty();


  IntVectSet
  chop(int dir, int chop_pnt);


  void setMaxDense(const int& a_maxDense);


  int
  numPts() const;

  const Box&
  minBox() const;

  void
  recalcMinBox() const;

  bool
  isEmpty() const;

  bool
  isDense() const;

  bool
  contains(const IntVect& iv) const;

  bool
  contains(const IntVectSet& ivs) const;
  bool
  contains_intvectset(const IntVectSet& ivs) const {return contains(ivs);}


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


  Vector<Box>
  boxes() const;


  void
  compact() const;


  int
  linearSize() const;

  void
  linearIn(const void* const a_inBuf);


  void
  linearOut(void* const a_outBuf) const;


  bool
  operator==(const IntVectSet& a_ivs) const;

  bool
  operator<(const IntVectSet& a_ivs) const;

  void
  printBoxes(std::ostream& a_ostream) const;

  void
  p() const { printBoxes(pout());}

  friend
  std::ostream&
  operator<<(std::ostream& os, const IntVectSet& ivs);

  void convert() const; // turn dense rep into Tree rep.  very costly.
                        // it is 'logically' const, but does modify data structures;

  // not for public consumption.  used in memory tracking.
  static long int count;
  static long int peakcount;

  //set to 10000 as default.  resettable.
  static int s_maxDense;

private:

  bool m_isdense;
  TreeIntVectSet m_ivs;
  DenseIntVectSet m_dense;
  // not a user function.  called by memory tracking system on
  // exit to clean up static allocation pools used for the optimization
  // of these routines.
  friend void dumpmemoryatexit();
  static void clearStaticMemory(); // after this functon is called, you cannot
                              // do any other operations with IntVectSet.
};


class IVSIterator
{
public:

  IVSIterator():m_isdense(true)
  {}

  IVSIterator(const IntVectSet& ivs);

  ~IVSIterator()
  {}

  void define(const IntVectSet& ivs);

  const IntVect& operator()() const ;

  const IntVect& iv() const { return this->operator()();}

  bool ok() const;

  void operator++();

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

  void begin();

  void reset();


  void end();

private:
  bool m_isdense;
  DenseIntVectSetIterator m_dense;
  TreeIntVectSetIterator  m_tree;
};

#ifndef WRAPPER

inline const IntVect& IVSIterator::operator()() const
{
  if(m_isdense) return m_dense();
  return m_tree();
}

inline bool IVSIterator::ok() const
{
  if(m_isdense) return m_dense.ok();
  return m_tree.ok();
}

inline void  IVSIterator::operator++()
{
  if(m_isdense) ++m_dense;
  else          ++m_tree;
}
inline void IVSIterator::reset()
{
  begin();
}

inline void IVSIterator::begin()
{
  if(m_isdense) m_dense.begin();
  else          m_tree.begin();
}

inline void IVSIterator::end()
{
  if(m_isdense) m_dense.end();
  else          m_tree.end();
}

inline IntVectSet::IntVectSet(): m_isdense(true)
{
  count++;
  if(count > peakcount) peakcount = count;
}

inline void IntVectSet::define(const IntVectSet& ige_in)
{
  *this = ige_in;
}

inline IntVectSet::IntVectSet(const IntVectSet& ige_in)
{
  count++;
  if(count > peakcount) peakcount = count;

  *this = ige_in;
}

inline   bool
IntVectSet::isDense() const
{
  return m_isdense;
}

#endif /* WRAPPER */

#endif

---