---

BoxLayout.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 _BOXLAYOUT_H_
#define _BOXLAYOUT_H_

#ifndef WRAPPER
#include "Box.H"
#include "Vector.H"
class DataIterator;
class LayoutIterator;
#include "RefCountedPtr.H"
#include "DataIndex.H"
#include "SPMD.H"
#endif /*WRAPPER*/

#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&
  operator[](const LayoutIndex& it);


  Box get(const LayoutIndex& it) const;


  Box get(const LayoutIterator& it) const;


  Box get(const DataIterator& it) const;


  unsigned int
  procID(const LayoutIndex& a_index) const ;


  int numBoxes(const int procID) const;


  inline unsigned int
  size() const ;

  unsigned int index(const LayoutIndex& index) const;



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


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



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


  virtual void
  close();


  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;


  LayoutIterator
  layoutIterator() const;


#ifndef WRAPPER


  void
  print() const;
#endif


  void p() const { print();}

protected:

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

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

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

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

// 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 const Box&
BoxLayout::operator[](const LayoutIndex& index) const
{
  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::operator[](const LayoutIndex& index)
{
  if(*m_closed)
    {
      MayDay::Error("attempt to modify closed BoxLayout");
    }
  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;
}

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

inline  Box
BoxLayout::get(const LayoutIndex& index) const
{
  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
{
  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)
{
  assert(check(a_index));
  m_boxes->operator[](m_index->operator[](a_index.m_index)).m_procID = a_procID;
}

inline unsigned int
BoxLayout::size() const
{
  return m_boxes->size();
}

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

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

#endif /*WRAPPER*/

#endif // DATAPLAN_H

---