Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

BoxLayout Class Reference

A not-necessarily disjoint collective of boxes. More...

#include <BoxLayout.H>

Inheritance diagram for BoxLayout:

Inheritance graph
Collaboration diagram for BoxLayout:

Collaboration graph
List of all members.

Public Methods

 BoxLayout ()
 BoxLayout (const Vector< Box > &a_boxes, const Vector< int > &a_procIDs)
virtual ~BoxLayout ()
BoxLayout & operator= (const BoxLayout &a_rhs)
 refcounted assignment

virtual void define (const Vector< Box > &a_boxes, const Vector< int > &a_procIDs)
const Boxoperator[] (const LayoutIndex &it) const
Boxoperator[] (const LayoutIndex &it)
bool operator== (const BoxLayout &rhs) const
bool eq (const BoxLayout &rhs) const
bool check (const LayoutIndex &index) const
DataIndex addBox (const Box &box, int procID)
virtual void close ()
virtual void deepCopy (const BoxLayout &a_source)
Box get (const LayoutIndex &it) const
bool isClosed () const
bool isSorted () const
DataIterator dataIterator () const
LayoutIterator layoutIterator () const
void print () const
 invokes cout<<*this; pretty-print dump of BoxLayout

void p () const
unsigned int procID (const LayoutIndex &a_index) const
int numBoxes (const int procID) const
void setProcID (const LayoutIndex &a_index, unsigned int a_procID)
unsigned int size () const
void sort ()
unsigned int index (const LayoutIndex &index) const

Protected Methods

void setIndexVector ()

Protected Attributes

RefCountedPtr< Vector< Entry > > m_boxes
RefCountedPtr< Vector< unsigned
int > > 
RefCountedPtr< int > m_layout
RefCountedPtr< bool > m_closed
RefCountedPtr< DataIteratorm_dataIterator


class LayoutIterator
class DataIterator
void coarsen (BoxLayout &output, const BoxLayout &input, int refinement)
void refine (BoxLayout &output, const BoxLayout &input, int refinement)

Detailed Description

A not-necessarily disjoint collective of boxes.

A BoxLayout is a collection of Box objects that are assigned to a process number. Each box is associated with only one process. processes are numbered from 0 to n-1 (for an n process parallel job)

BoxLayout can be either open or closed. null construction or deepcopy creates an open BoxLayout. Boxes may be added to an open BoxLayout. non-const operations may be performed on the boxes existing in an open BoxLayout. closed BoxLayouts are sorted. Many uses of BoxLayouts require a closed BoxLayout. A closed BoxLayout cannot be modified.

Ref-counting ------------ BoxLayout is an explicitly ref-counted object.

Assignment and copy are compiler generated. They increment the refcount on the contained data members. They perform shallow, ref-counted operations.

Refcounting is a process whereby multiple instaniations make use of a single implementation of that object and keep a tally of how many instantiations are sharing. Thus

\begin{verbatim} BoxLayout b1(boxes, procIDs);

b1 ----> refcount = 1 ----> m_boxes ----> m_processors

BoxLayout b2(b1)

b1 ----> refcount = 2 <---- b2 ----> m_boxes <---- ----> m_processors <----

BoxLayout b3; b3 = b2;

b1 ----> refcount = 3 <---- b2 ----> m_boxes <---- ----> m_processors <---- ^^^ ||| b3 \end{verbatim}

Constructor & Destructor Documentation


BoxLayout::BoxLayout const Vector< Box > &    a_boxes,
const Vector< int > &    a_procIDs

Construct from a Vector of Boxes and a Vector of processor assignments. On exit, the BoxLayout will be closed.

virtual BoxLayout::~BoxLayout   [virtual]

Ref-counted destruction. Once the last reference to the implementation of this class is destroyed, the data members are cleaned up

Member Function Documentation

DataIndex BoxLayout::addBox const Box   box,
int    procID

add a box to this BoxLayout. Takes the processor assignment. The input 'box' is copied. BoxLayout must be 'open' for this operation, otherwise a runtime error will occur.

bool BoxLayout::check const LayoutIndex   index const [inline]

virtual void BoxLayout::close   [virtual]

Mark this BoxLayout as complete and unchangeable.

Reimplemented in DisjointBoxLayout.

DataIterator BoxLayout::dataIterator   const

virtual void BoxLayout::deepCopy const BoxLayout &    a_source [virtual]

Actual deep copy operation. New object created with copied data. This object disassociates itself with original implementation safely. This object now is considered 'open' and can be non-const modified. There is no assurance that the order in which this BoxLayout is indexed corresponds to the indexing of a_source.

BoxLayout b1(boxes, procIDs); \begin{verbatim} b1 ----> refcount = 1 ----> m_boxes ----> m_processors

BoxLayout b2(b1)

b1 ----> refcount = 2 <---- b2 ----> m_boxes <---- ----> m_processors <----

BoxLayout b3; b3.deepCopy(b2); b1 ----> refcount = 2 <---- b2 b3 ----> refcount = 1 ----> m_boxes <---- ----> m_boxes ----> m_processors <---- ----> m_processors \end{verbatim}

Reimplemented in DisjointBoxLayout.

virtual void BoxLayout::define const Vector< Box > &    a_boxes,
const Vector< int > &    a_procIDs

Define this BoxLayout from a Vector of Boxes and a Vector of processor assignments. Any pre-existing layout will be lost (ref-count dropped by one). The processor assignment Vector must be the same length as the Box Vector. On exit, the BoxLayout will be closed.

Reimplemented in DisjointBoxLayout.

bool BoxLayout::eq const BoxLayout &    rhs const [inline]

Box BoxLayout::get const LayoutIndex   it const [inline]

As a consquence of the C++ compiler being free to choose which version of operator[] when the object is technically non-const, we very often get 'BoxLayout closed' errors. This is a non-overloaded get method.

unsigned int BoxLayout::index const LayoutIndex   index const [inline]

bool BoxLayout::isClosed   const [inline]

return true if close() has been called. closed BoxLayout is always sorted.

bool BoxLayout::isSorted   const [inline]

return true if sort() has been called

LayoutIterator BoxLayout::layoutIterator   const

If BoxLayout is closed, then LayoutIterator will return the Box's in sorted order. Processes through ALL the boxes in a BoxLayout

int BoxLayout::numBoxes const int    procID const

BoxLayout& BoxLayout::operator= const BoxLayout &    a_rhs

refcounted assignment

bool BoxLayout::operator== const BoxLayout &    rhs const [inline]

Refcounted pointer check. True if these two objects share the same implementation.

Box & BoxLayout::operator[] const LayoutIndex   it [inline]

const Box & BoxLayout::operator[] const LayoutIndex   it const [inline]

const accessor operator. see also {\tt get(const DataIndex&)}

void BoxLayout::p   const [inline]

void BoxLayout::print   const

invokes cout<<*this; pretty-print dump of BoxLayout

unsigned int BoxLayout::procID const LayoutIndex   a_index const [inline]

Returns the processor to which this box has been assigned. Not a user function, at least, not a new user function. It can be used safely at anytime, closed or open. A person needing this level of knowledge of the processor assignment should have non-trivial needs, like writing your own load balancer or such. Most user level parallel coding needs can be addressed using the DataIterator class.

void BoxLayout::setIndexVector   [protected]

void BoxLayout::setProcID const LayoutIndex   a_index,
unsigned int    a_procID

Assign a Box in the BoxLayout to a processor. Requires the BoxLayout to be open.

unsigned int BoxLayout::size   const [inline]

void BoxLayout::sort  

Sort the boxes.

Friends And Related Function Documentation

void coarsen BoxLayout &    output,
const BoxLayout &    input,
int    refinement

'output' must be open, 'input' must be closed, 'refinement' must be a positive non-zero integer. 'output' and 'input' do not share an implementation. 'output' is first deepcopy'ed from 'input', then coarsen(refinement) is called on each box of 'output'. 'output' returns from this function closed. LayoutIterators from 'input' and 'output' can perform interchangeably.

friend class DataIterator [friend]

friend class LayoutIterator [friend]

void refine BoxLayout &    output,
const BoxLayout &    input,
int    refinement

see 'coarsen ' and substitute the word "refine" for "coarsen"

Member Data Documentation

RefCountedPtr<Vector<Entry> > BoxLayout::m_boxes [protected]

RefCountedPtr<bool> BoxLayout::m_closed [protected]

RefCountedPtr<DataIterator> BoxLayout::m_dataIterator [protected]

RefCountedPtr<Vector<unsigned int> > BoxLayout::m_index [protected]

RefCountedPtr<int> BoxLayout::m_layout [protected]

The documentation for this class was generated from the following file:
Generated on Thu Aug 29 11:07:37 2002 for Chombo&INS by doxygen1.2.16