BoxLayout Class Reference

#include <BoxLayout.H>

Inheritance diagram for BoxLayout:

Detailed Description

A not-necessarily-disjoint collective of boxes.

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

A BoxLayout can be either open or closed.

Open BoxLayout:

Created by null construction or deepCopy.
Boxes may be added to it.
Non-const operations may be performed on the boxes in it.

Closed BoxLayout:

Created by constructor with vectors of Boxes and processors given explicitly.
Cannot be modified.
Represented as sorted boxes.
Many uses of BoxLayouts require a closed BoxLayout.

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 instantiations make use of a single implementation of that object and keep a tally of how many instantiations are sharing. Thus:

  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


Modification functions
void	coarsen (BoxLayout &output, const BoxLayout &input, int refinement)
void	coarsen (BoxLayout &output, const BoxLayout &input, const IntVect &refinement)
	same idea but with anisotropic refinement
void	refine (BoxLayout &output, const BoxLayout &input, int refinement)
void	refine (BoxLayout &output, const BoxLayout &input, const IntVect &refinement)
	same idea but now with anisotropic refinement. now how much would you pay?
virtual void	close ()
virtual void	closeNoSort ()
virtual void	deepCopy (const BoxLayout &a_source)
bool	coarsenable (int refRatio) const
void	growSide (int idir, int length, Side::LoHiSide a_sd)
void	surroundingNodes ()
void	convertOldToNew (const IntVect &a_permutation, const IntVect &a_sign, const IntVect &a_translation)
void	convertNewToOld (const IntVect &a_permutation, const IntVect &a_sign, const IntVect &a_translation)
void	enclosedCells ()
void	coarsen (int a_ref)
void	refine (int a_ref)
void	grow (int a_growth)
void	grow (IntVect a_growth)
void	grow (int a_dir, int a_growth)
void	shift (const IntVect &a_iv)
void	shiftHalf (const IntVect &a_iv)
void	adjCellSide (int a_dir, int a_len, Side::LoHiSide a_sd)
void	operator &= (const Box &a_box)
void	operator &= (const ProblemDomain &a_domain)
void	setProcID (const LayoutIndex &a_index, unsigned int a_procID)
void	sort ()
Public Member Functions
Vector< Box >	boxArray () const
Vector< int >	procIDs () const
unsigned int	indexI (const LayoutIndex &) const
const Vector< Entry > *	rawPtr () const
Constructors, destructors, assignments, defines
	BoxLayout ()
	BoxLayout (const Vector< Box > &a_boxes, const Vector< int > &a_procIDs)
	BoxLayout (const LayoutData< Box > &a_newLayout)
void	transform (BaseTransform &a_transform)
virtual	~BoxLayout ()
BoxLayout &	operator= (const BoxLayout &a_rhs)
virtual void	define (const Vector< Box > &a_boxes, const Vector< int > &a_procIDs)
virtual void	define (const LayoutData< Box > &a_newLayout)
Accessors
Box	operator[] (const LayoutIndex &it) const
Box	operator[] (const LayoutIterator &it) 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
bool	sameBoxes (const BoxLayout &a_layout) const
	Checks whether this layout has the same boxes in the same order as a_layout.
int	numBoxes (const int procID) const
	Returns the number of boxes assigned to a given procID.
long long	numCells () const
	Return number of cells in all boxes of entire box layout.
unsigned int	size () const
	Returns the total number of boxes in the BoxLayout.
unsigned int	index (const LayoutIndex &index) const
unsigned int	lindex (const DataIndex &index) const
Checks
bool	operator== (const BoxLayout &rhs) const
bool	operator< (const BoxLayout &rhs) const
int	refCount () const
bool	eq (const BoxLayout &rhs) const
bool	isClosed () const
bool	isSorted () const
bool	check (const LayoutIndex &index) const
bool	compatible (const BoxLayout &a_rhs) const
Iterators
DataIterator	dataIterator () const
	Parallel iterator.
TimedDataIterator	timedDataIterator () const
LayoutIterator	layoutIterator () const
	Iterator that processes through ALL the boxes in a BoxLayout.
I/O functions
void	print () const
void	p () const
Protected Member Functions
void	buildDataIndex ()
void	checkDefine (const Vector< Box > &a_boxes, const Vector< int > &procIDs)
Protected Attributes
RefCountedPtr< Vector< Entry > >	m_boxes
RefCountedPtr< int >	m_layout
RefCountedPtr< bool >	m_closed
RefCountedPtr< bool >	m_sorted
RefCountedPtr< DataIterator >	m_dataIterator
RefCountedPtr< Vector < LayoutIndex > >	m_indicies
Friends
class	LayoutIterator
class	DataIterator

Constructor & Destructor Documentation

BoxLayout::BoxLayout ( )

Construct BoxLayout with no boxes.

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.

BoxLayout::BoxLayout ( const LayoutData< Box > & a_newLayout )

Construct from a LayoutData<Box>. 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

void BoxLayout::transform ( BaseTransform & a_transform )

BoxLayout& BoxLayout::operator= ( const BoxLayout & a_rhs )

Ref-counted assignment.

virtual void BoxLayout::define	(	const Vector< Box > &	a_boxes,
		const Vector< int > &	a_procIDs
	)			`[virtual]`

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.

Referenced by regionGather().

virtual void BoxLayout::define ( const LayoutData< Box > & a_newLayout ) [virtual]

Define this BoxLayout from a LayoutData<Box>. We can iterate through the new BoxLayout by the same iterator as through the underlying BoxLayout of the LayoutData<Box>. Each Box in the new BoxLayout is in the same position as each Box in the LayoutData<Box>. On exit, the BoxLayout will be closed, and NOT re-sorted.

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

const accessor operator. See also get(const LayoutIndex&).

References CH_assert, check(), m_boxes, and LayoutIndex::m_index.

Box BoxLayout::operator[] ( const LayoutIterator & it ) const

accessor operator. See also get(const LayoutIndex&).

Box BoxLayout::operator[] ( const DataIterator & it ) const

accessor operator. See also get(const LayoutIndex&).

Box BoxLayout::get ( const LayoutIndex & it ) const [inline]

Get box indexed by it.

As a consequence 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.

References CH_assert, check(), m_boxes, and LayoutIndex::m_index.

Referenced by LevelData< T >::apply(), LayoutData< T >::box(), PetscSolver< T >::create_mat_vec(), LevelDataOps< T >::dotProduct(), LevelDataOps< T >::mDotProduct(), PetscSolver< T >::putChomboInPetsc(), PetscSolver< T >::putPetscInChombo(), PetscSolver< T >::solve_mfree_private(), and PetscSolver< T >::solve_private().

Box BoxLayout::get ( const DataIterator & it ) const

Get box indexed by it. equivalent to get(it()), just does the extra() for you.

Box BoxLayout::get ( const LayoutIterator & it ) const

Get box indexed by it. equivalent to get(it()), just does the extra() for you.

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

References CH_assert, check(), m_boxes, and LayoutIndex::m_index.

bool BoxLayout::sameBoxes ( const BoxLayout & a_layout ) const

Checks whether this layout has the same boxes in the same order as a_layout.

int BoxLayout::numBoxes ( const int procID ) const

Returns the number of boxes assigned to a given procID.

long long BoxLayout::numCells ( ) const

Return number of cells in all boxes of entire box layout.

unsigned int BoxLayout::size ( ) const

Returns the total number of boxes in the BoxLayout.

Referenced by blockWriteBufferToFile(), getOffsets(), DataIterator::getPeak(), DataIterator::getTime(), LayoutIterator::ok(), read(), DataIterator::size(), and WriteMultiData< T >::WriteMultiData().

unsigned int BoxLayout::index ( const LayoutIndex & index ) const [inline]

Not a user function. Used in I/O routine.

References LayoutIndex::m_index.

Referenced by LayoutData< T >::allocate(), getOffsets(), read(), write(), and WriteMultiData< T >::writeData().

unsigned int BoxLayout::lindex ( const DataIndex & index ) const

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

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

References m_boxes, and m_layout.

bool BoxLayout::operator< ( const BoxLayout & rhs ) const [inline]

RefCounted pointer compare. Need this to use DisjointBoxLayout as a Key in a std::map

References m_boxes, and m_layout.

int BoxLayout::refCount ( ) const [inline]

current ref count for this object

References m_boxes, and RefCountedPtr< T, OP >::refCount().

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

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

bool BoxLayout::isClosed ( ) const [inline]

Return true if close() has been called. Closed BoxLayout is always sorted.

References m_closed.

Referenced by BoxLayoutData< T >::BoxLayoutData(), LevelData< T >::define(), LayoutData< T >::define(), BoxLayoutData< T >::define(), LayoutData< T >::LayoutData(), and LevelData< T >::LevelData().

bool BoxLayout::isSorted ( ) const [inline]

Return true if sort() has been called.

References m_sorted.

bool BoxLayout::check ( const LayoutIndex & index ) const [inline]

not a user function

References m_layout, and LayoutIndex::m_layoutIntPtr.

Referenced by get(), LayoutData< T >::operator[](), operator[](), procID(), and setProcID().

bool BoxLayout::compatible ( const BoxLayout & a_rhs ) const [inline]

returns 'true' if you can use the same LayoutIterator and DataIterator on these two layouts and data holders built on top of these layouts

References m_layout.

virtual void BoxLayout::close ( ) [virtual]

Mark this BoxLayout as complete and unchangeable.

Reimplemented in DisjointBoxLayout.

Referenced by LayoutData< T >::LayoutData().

virtual void BoxLayout::closeNoSort ( ) [virtual]

Reimplemented in DisjointBoxLayout.

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

            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

Reimplemented in DisjointBoxLayout.

bool BoxLayout::coarsenable ( int refRatio ) const

returns true iff:

every Box in the BoxLayout can be coarsened by refRatio and return back to the original Box when refined by refRatio.
refRatio must be a positive non-zero integer.

void BoxLayout::growSide	(	int	idir,
		int	length,
		Side::LoHiSide	a_sd
	)

if a_sd == side::lo, do growLo, else do grow hi with the other arguments.

void BoxLayout::surroundingNodes ( )

Do surroundingNodes on each box.

void BoxLayout::convertOldToNew	(	const IntVect &	a_permutation,
		const IntVect &	a_sign,
		const IntVect &	a_translation
	)

multiblock stuff.

void BoxLayout::convertNewToOld	(	const IntVect &	a_permutation,
		const IntVect &	a_sign,
		const IntVect &	a_translation
	)

multiblock stuff.

void BoxLayout::enclosedCells ( )

Do enclosedCells on each box.

void BoxLayout::coarsen ( int a_ref )

coarsen each box by a_ref

void BoxLayout::refine ( int a_ref )

refine each box by a_ref

void BoxLayout::grow ( int a_growth )

grow each box by a_growth

void BoxLayout::grow ( IntVect a_growth )

grow each box by a_growth

void BoxLayout::grow	(	int	a_dir,
		int	a_growth
	)

grow each box in a_dir by a_growth

void BoxLayout::shift ( const IntVect & a_iv )

shift each box by a_iv

void BoxLayout::shiftHalf ( const IntVect & a_iv )

shift each box by a_iv

void BoxLayout::adjCellSide	(	int	a_dir,
		int	a_len,
		Side::LoHiSide	a_sd
	)

set each box to the appropriate adjCellSide call if a_sd == side::lo, do adjCellLo, else do adjCellhi with the other arguments.

void BoxLayout::operator &= ( const Box & a_box )

intersect all boxes with incoming box

void BoxLayout::operator &= ( const ProblemDomain & a_domain )

intersect all boxes with incoming box

void BoxLayout::setProcID	(	const LayoutIndex &	a_index,
		unsigned int	a_procID
	)			`[inline]`

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

References CH_assert, check(), m_boxes, and LayoutIndex::m_index.

void BoxLayout::sort ( )

Sort the boxes of an open BoxLayout. No change if the BoxLayout is closed.

DataIterator BoxLayout::dataIterator ( ) const

Parallel iterator.

Returns DataIndex object that corresponds to boxes on the local processor only.

Referenced by blockLocalOffsets(), LayoutData< T >::dataIterator(), DataIterator::DataIterator(), VCAMRPoissonOp2::diagonalScale(), NWOViscousTensorOp::diagonalScale(), NWOEBViscousTensorOp::diagonalScale(), ViscousTensorOp::diagonalScale(), EBViscousTensorOp::diagonalScale(), VCAMRPoissonOp2::divideByIdentityCoef(), NWOViscousTensorOp::divideByIdentityCoef(), NWOEBViscousTensorOp::divideByIdentityCoef(), ViscousTensorOp::divideByIdentityCoef(), EBViscousTensorOp::divideByIdentityCoef(), MultilevelLinearOp< T >::dotProduct(), LevelDataOps< T >::dotProduct(), LevelDataOps< T >::mDotProduct(), and EBFastFR::reflux().

TimedDataIterator BoxLayout::timedDataIterator ( ) const

Referenced by LayoutData< T >::timedDataIterator().

LayoutIterator BoxLayout::layoutIterator ( ) const

Iterator that processes through ALL the boxes in a BoxLayout.

If BoxLayout is closed, then LayoutIterator will return the Boxes in sorted order.

Referenced by MultilevelLinearOp< T >::dotProduct(), getOffsets(), and MergeSolver< T >::solve().

void BoxLayout::print ( ) const

Invokes cout<<*this; pretty-print dump of BoxLayout.

Referenced by p().

void BoxLayout::p ( ) const [inline]

Invokes cout<<*this; pretty-print dump of BoxLayout.

References print().

Vector<Box> BoxLayout::boxArray ( ) const

Referenced by TimedDataIterator::getBoxes(), and DataIterator::getBoxes().

Vector<int> BoxLayout::procIDs ( ) const

Return the processor id numbers corresponding to the boxes as returned by this->boxArray().

unsigned int BoxLayout::indexI ( const LayoutIndex & ) const [inline]

const Vector<Entry>* BoxLayout::rawPtr ( ) const [inline]

References m_boxes.

void BoxLayout::buildDataIndex ( ) [protected]

void BoxLayout::checkDefine	(	const Vector< Box > &	a_boxes,
		const Vector< int > &	procIDs
	)			`[protected]`

Friends And Related Function Documentation

friend class LayoutIterator [friend]

friend class DataIterator [friend]

void coarsen	(	BoxLayout &	output,
		const BoxLayout &	input,
		int	refinement
	)			`[friend]`

Coarsen a BoxLayout:

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 and DataIterators from input and output can be used interchangeably.

void coarsen	(	BoxLayout &	output,
		const BoxLayout &	input,
		const IntVect &	refinement
	)			`[friend]`

same idea but with anisotropic refinement

void refine	(	BoxLayout &	output,
		const BoxLayout &	input,
		int	refinement
	)			`[friend]`

Refine a BoxLayout:

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 refine(refinement) is called on each box of output.

output returns from this function closed.

LayoutIterators and DataIterators from input and output can be used interchangeably.

void refine	(	BoxLayout &	output,
		const BoxLayout &	input,
		const IntVect &	refinement
	)			`[friend]`

same idea but now with anisotropic refinement. now how much would you pay?

Member Data Documentation

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

Referenced by get(), operator<(), operator==(), operator[](), procID(), rawPtr(), refCount(), and setProcID().

RefCountedPtr<int> BoxLayout::m_layout [protected]

Referenced by check(), compatible(), operator<(), and operator==().

RefCountedPtr<bool> BoxLayout::m_closed [protected]

Referenced by isClosed().

RefCountedPtr<bool> BoxLayout::m_sorted [protected]

Referenced by isSorted().

RefCountedPtr<DataIterator> BoxLayout::m_dataIterator [protected]

RefCountedPtr<Vector<LayoutIndex> > BoxLayout::m_indicies [protected]

The documentation for this class was generated from the following file:

BoxLayout.H

BoxLayout Class Reference

Detailed Description

Modification functions

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation