BoxLayout.H

Go to the documentation of this file.

#ifdef CH_LANG_CC
/*
*      _______              __
*     / ___/ /  ___  __ _  / /  ___
*    / /__/ _ \/ _ \/  V \/ _ \/ _ \
*    \___/_//_/\___/_/_/_/_.__/\___/
*    Please refer to Copyright.txt, in Chombo's root directory.
*/
#endif


#ifndef _BOXLAYOUT_H_
#define _BOXLAYOUT_H_

#include "Box.H"
#include "Vector.H"
#include "RefCountedPtr.H"
#include "DataIndex.H"
#include "SPMD.H"
#include "NamespaceHeader.H"

class DataIterator;
class TimedDataIterator;
class LayoutIterator;

#ifndef DOXYGEN

struct Entry
{
  Entry()
    :
    m_procID(procID())
  {}

  Entry(const Box& a_box)
    :
    box(a_box),
    m_procID(procID())
  {}

  Entry(const Box& a_box, const unsigned int a_index)
    :
    box(a_box),
    index(a_index),
    m_procID(procID())
  {}

  bool operator < (const Entry& rhs) const
  {
    return box < rhs.box;
  }

  Box box;
  unsigned int index;
  unsigned int m_procID;// not used in serial code.
};

#endif


class BoxLayout
{
public:



  BoxLayout();


  BoxLayout(const Vector<Box>& a_boxes,
            const Vector<int>& a_procIDs);



  virtual
  ~BoxLayout();


  BoxLayout& operator=(const BoxLayout& a_rhs);


  virtual void
  define(const Vector<Box>& a_boxes,
         const Vector<int>& a_procIDs);





  const Box&
  operator[](const LayoutIndex& it) const;


  Box& ref(const LayoutIndex& it);


  const Box&
  operator[](const LayoutIterator& it) const;


  const Box&
  operator[](const DataIterator& it) const;


  Box get(const LayoutIndex& it) const;



  Box get(const DataIterator& it) const;


  Box get(const LayoutIterator& it) const;


  unsigned int
  procID(const LayoutIndex& a_index) const ;






  int numBoxes(const int procID) const;


  long long numCells() const;


  unsigned int
  size() const ;

  unsigned int index(const LayoutIndex& index) const;

  unsigned int lindex(const DataIndex& index) const;


  inline bool
  operator==(const BoxLayout& rhs) const ;

  inline bool operator<(const BoxLayout& rhs) const ;

  int refCount() const
  {
    return m_boxes.refCount();
  }

  bool eq(const BoxLayout& rhs) const { return *this == rhs;}

  bool
  isClosed() const;


  bool
  isSorted() const {return isClosed();}

  bool check(const LayoutIndex& index) const
    { return index.m_layoutIntPtr == m_layout;}



  bool compatible(const BoxLayout& a_rhs) const
  {
    return m_layout == a_rhs.m_layout;
  }



 //  DataIndex
//   addBox(const Box& box, int procID);
  void addBox(const Box& box, int procID);


  virtual void
  close();

  // not for general consumption.
  virtual void
  closeNoSort();



  virtual void
  deepCopy(const BoxLayout& a_source);


  bool coarsenable(int refRatio) const;


  friend void coarsen(BoxLayout& output,
                      const BoxLayout& input,
                      int refinement);


  friend void refine(BoxLayout& output,
                     const BoxLayout& input,
                     int refinement);


  void
  setProcID(const LayoutIndex& a_index, unsigned int a_procID);

  //const or non-const operation ?.....I can think of usages either way...bvs

  void
  sort();

  void aliasAddBox(const Box& box);

  void aliasClose();



  DataIterator
  dataIterator() const;

  TimedDataIterator
  timedDataIterator() const;


  LayoutIterator
  layoutIterator() const;


#ifndef WRAPPER

  void
  print() const;
#endif

  void p() const { print();}

  /* Return all the constituent boxes. */
  Vector<Box> boxArray() const;

  Vector<int> procIDs() const;

  inline unsigned int indexI(const LayoutIndex&) const;

protected:

  void setIndexVector();
  void buildDataIndex();
  friend class LayoutIterator;
  friend class DataIterator;

  RefCountedPtr<Vector<Entry> >        m_boxes;
  RefCountedPtr<Vector<unsigned int> > m_index;
  RefCountedPtr<Vector<unsigned int> > m_localIndex;
  RefCountedPtr<int>                   m_layout;
  RefCountedPtr<bool>                  m_closed;
  RefCountedPtr<DataIterator>          m_dataIterator;

#ifdef CH_MPI
  RefCountedPtr<Vector<DataIndex> >    m_dataIndex;
#endif

  void checkDefine(const Vector<Box>& a_boxes, const Vector<int>& procIDs);
private:

};

void coarsen_bl(BoxLayout& output, const BoxLayout& input, int refinement);

void refine_bl(BoxLayout& output, const BoxLayout& input, int refinement);

#ifndef WRAPPER

inline
void coarsen_bl(BoxLayout& output, const BoxLayout& input, int refinement)
{ coarsen(output, input, refinement);}

inline
void refine_bl(BoxLayout& output, const BoxLayout& input, int refinement)
{ refine(output, input, refinement);}

void mortonOrdering(Vector<Box>& a_boxes);

//========================================================

// inlined functions
// =================

// constructors
// ============

/*
inline
BoxLayout::BoxLayout(int a_boxes)
  :m_boxes(new std::vector<Entry>(a_boxes)),
   m_index(new std::vector<unsigned int>(a_boxes)),
   m_layout(new int),
   m_closed(new bool(false))
{
  std::vector<Entry>& boxes = *m_boxes;
  std::vector<unsigned int>& index = *m_index;
  for(unsigned int i=0; i<boxes.size(); ++i)
    {
      boxes[i].index = i;
      index[i] = i;
    }
}
*/

// operators
// =========

inline unsigned int BoxLayout::indexI(const LayoutIndex& index) const
{
  return m_index->operator[](index.m_index);
}

inline unsigned int BoxLayout::lindex(const DataIndex& index) const
{
  return m_localIndex->operator[](index.m_index);
}

inline const Box&
BoxLayout::operator[](const LayoutIndex& index) const
{
  CH_assert(check(index));// make sure this LayoutIndex came from my own iterator
  return m_boxes->operator[](m_index->operator[](index.m_index)).box;
}


inline Box&
BoxLayout::ref(const LayoutIndex& index)
{
  if(*m_closed)
    {
      MayDay::Error("attempt to modify closed BoxLayout");
    }
  CH_assert(check(index)); // make sure this LayoutIndex came from my own iterator
  return m_boxes->operator[](m_index->operator[](index.m_index)).box;
}

inline bool
BoxLayout::operator==(const BoxLayout& rhs) const
{
  return m_boxes == rhs.m_boxes;
}

inline bool
BoxLayout::operator<(const BoxLayout& rhs) const
{
  return m_boxes < rhs.m_boxes;
}

// member functions
// ================

inline  Box
BoxLayout::get(const LayoutIndex& index) const
{
  CH_assert(check(index)); // make sure this LayoutIndex came from my own iterator
  return m_boxes->operator[](m_index->operator[](index.m_index)).box;
}



inline unsigned int
BoxLayout::index(const LayoutIndex& a_index) const
{
  return m_index->operator[](a_index.m_index);
}

inline bool
BoxLayout::isClosed() const
{
  return *m_closed;
}

inline unsigned int
BoxLayout::procID(const LayoutIndex& a_index) const
{
  CH_assert(check(a_index));
  return m_boxes->operator[](m_index->operator[](a_index.m_index)).m_procID;
}


inline void
BoxLayout::setProcID(const LayoutIndex& a_index, unsigned int a_procID)
{
  CH_assert(check(a_index));
  m_boxes->operator[](m_index->operator[](a_index.m_index)).m_procID = a_procID;
}

// global functions
// ================

std::ostream& operator<<(std::ostream& os, const BoxLayout& a_layout);

#endif /*WRAPPER*/

#include "NamespaceFooter.H"
#endif

---