SAMRAI::pdat::SideData

SAMRAI::pdat::SideData< DIM, TYPE > Class Template Reference

Class SideData<DIM> provides an implementation for data defined at cell sides (faces) on AMR patches. It is derived from the hier::PatchData interface common to all SAMRAI patch data types. Given a CELL-centered AMR index space box, a side data object represents data of some template TYPE and depth on the sides (faces) of the cells in the box. Here, depth indicates the number of data values at each side index location. The SideGeometry class provides the translation between the standard SAMRAI cell-centered AMR index space and side-centered data. More...

#include <source/patchdata/side/SideData.h>

Inheritance diagram for SAMRAI::pdat::SideData< DIM, TYPE >:

[legend]List of all members.


Public Types
typedef SideIterator< DIM >	Iterator
Public Member Functions
	SideData (const hier::Box< DIM > &box, int depth, const hier::IntVector< DIM > &ghosts, const hier::IntVector< DIM > &directions=hier::IntVector< DIM >(1), tbox::Pointer< tbox::Arena > pool=tbox::Pointer< tbox::Arena >((0)))
	The constructor for a side data object.
virtual	~SideData ()
	The virtual destructor for a side data object.
const hier::IntVector< DIM > &	getDirectionVector () const
	Return constant reference to vector describing which coordinate directions have data associated with this side data object.
int	getDepth () const
	Return the depth (e.g., the number of components in each spatial location) of the array.
TYPE *	getPointer (int side_normal, int depth=0)
	Get a pointer to the beginning of a particular side normal and depth component of the side centered array.
const TYPE *	getPointer (int side_normal, int depth=0) const
	Get a const pointer to the beginning of a particular side normal and depth component of the side centered array.
TYPE &	operator() (const SideIndex< DIM > &i, int depth=0)
	Return a reference to the data entry corresponding to a given side index and depth.
const TYPE &	operator() (const SideIndex< DIM > &i, int depth=0) const
	Return a const reference to the data entry corresponding to a given side index and depth.
ArrayData< DIM, TYPE > &	getArrayData (int side_normal)
	Return a reference to the array data object for the given side normal of the side centered data object.
const ArrayData< DIM, TYPE > &	getArrayData (int side_normal) const
	Return a const reference to the array data object for the given side normal of the side centered data object.
virtual void	copy (const hier::PatchData< DIM > &src)
	A fast copy from source to destination (i.e., this) patch data object.
virtual void	copy2 (hier::PatchData< DIM > &dst) const
	A fast copy from source (i.e., this) to destination patch data object.
virtual void	copy (const hier::PatchData< DIM > &src, const hier::BoxOverlap< DIM > &overlap)
	Copy data from source to destination (i.e., this) patch data object on the given overlap.
virtual void	copy2 (hier::PatchData< DIM > &dst, const hier::BoxOverlap< DIM > &overlap) const
	Copy data from source (i.e., this) to destination patch data object on the given overlap.
void	copyOnBox (const SideData< DIM, TYPE > &src, const hier::Box< DIM > &box)
	Copy data from source to destination (i.e., this) patch data object on the given CELL-centered AMR index box.
void	copyDepth (int dst_depth, const SideData< DIM, TYPE > &src, int src_depth)
	Fast copy (i.e., source and this side data objects are defined over the same box) to this destination side data object from the given source side data object at the specified depths.
virtual bool	canEstimateStreamSizeFromBox () const
	Return true if the patch data object can estimate the stream size required to fit its data using only index space information (i.e., a box).
virtual int	getDataStreamSize (const hier::BoxOverlap< DIM > &overlap) const
	Return the number of bytes needed to stream the data in this patch data object lying in the specified box overlap region.
virtual void	packStream (tbox::AbstractStream &stream, const hier::BoxOverlap< DIM > &overlap) const
	Pack data in this patch data object lying in the specified box overlap region into the stream. The overlap must be an SideOverlap of the same DIM.
virtual void	unpackStream (tbox::AbstractStream &stream, const hier::BoxOverlap< DIM > &overlap)
	Unpack data from stream into this patch data object over the specified box overlap region. The overlap must be an SideOverlap of the same DIM.
void	fill (const TYPE &t, int d=0)
	Fill all values at depth d with the value t.
void	fill (const TYPE &t, const hier::Box< DIM > &box, int d=0)
	Fill all values at depth d within the box with the value t.
void	fillAll (const TYPE &t)
	Fill all depth components with value t.
void	fillAll (const TYPE &t, const hier::Box< DIM > &box)
	Fill all depth components within the box with value t.
void	print (const hier::Box< DIM > &box, std::ostream &os=tbox::plog, int prec=12) const
	Print all side data values residing in the specified box. If the depth of the array is greater than one, all depths are printed.
void	print (const hier::Box< DIM > &box, int depth, std::ostream &os=tbox::plog, int prec=12) const
	Print all side data values at the given array depth in the specified box.
void	printAxis (int side_normal, const hier::Box< DIM > &box, std::ostream &os=tbox::plog, int prec=12) const
	Print all side centered data values for specified side normal direction residing in the specified box. If the depth of the data is greater than one, all depths are printed.
void	printAxis (int side_normal, const hier::Box< DIM > &box, int depth, std::ostream &os=tbox::plog, int prec=12) const
	Print all side centered data values for specified side normal direction residing in the specified box. If the depth of the data is greater than one, all depths are printed.
virtual void	getSpecializedFromDatabase (tbox::Pointer< tbox::Database > database)
virtual void	putSpecializedToDatabase (tbox::Pointer< tbox::Database > database)
Static Public Member Functions
static size_t	getSizeOfData (const hier::Box< DIM > &box, int depth, const hier::IntVector< DIM > &ghosts, const hier::IntVector< DIM > &directions)
	Calculate the amount of memory needed to represent side- centered data over a CELL-centered AMR index space box.

Detailed Description

template<int DIM, class TYPE>
class SAMRAI::pdat::SideData< DIM, TYPE >

IMPORTANT: The FaceData<DIM> class provides the same storage as this side data class, except that the coordinate directions of the individual arrays are permuted in the face data implementation.

Side data is stored in DIM arrays, each of which contains the data for the sides normal to a corresponding coordinate direction. Memory allocation is in column-major ordering (e.g., Fortran style) so that the leftmost index runs fastest in memory. For example, a three-dimensional side data object created over a CELL-centered AMR index space [l0:u0,l1:u1,l2:u2] allocates three data arrays dimensioned as follows:


   side normal 0
     [ l0 : u0+1 ,
       l1 : u1 ,
       l2 : u2 , d ]   ,

   side normal 1
     [ l0 : u0 ,
       l1 : u1+1 ,
       l2 : u2 , d ]   ,

   side normal 2
     [ l0 : u0 ,
       l1 : u1 ,
       l2 : u2+1 , d ]   ,
      
 *

Here the side normal directions 0, 1, 2 can be thought of as the x, y, and z side normal directions, respectively, and d is the depth index (i.e., number of values at each side index location). Other spatial dimensions are represented similarly.

Note also that it is possible to create a side data object for managing data at cell sides associated with a single coordinate direction only. See the constructor for more information. All operations are defined only for the case where data storage is alike between two side data objects.

The data type TYPE must define a default constructor (that takes no arguments) and also the assignment operator.

See also:

pdat::ArrayData

hier::PatchData

pdat::SideDataFactory

pdat::SideIndex

pdat::SideIterator

pdat::SideGeometry

Member Typedef Documentation

template<int DIM, class TYPE>

typedef SideIterator<DIM> SAMRAI::pdat::SideData< DIM, TYPE >::Iterator

The side iterator iterates over the elements on one axis of a side centered box geometry. This typedef is a convenience for using the SideIterator<DIM> class.

Constructor & Destructor Documentation

template<int DIM, class TYPE>

SAMRAI::pdat::SideData< DIM, TYPE >::SideData	(	const hier::Box< DIM > &	box,
		int	depth,
		const hier::IntVector< DIM > &	ghosts,
		const hier::IntVector< DIM > &	directions = `hier::IntVector< DIM >(1)`,
		tbox::Pointer< tbox::Arena >	pool = `tbox::Pointer< tbox::Arena >((0))`
	)

The constructor for a side data object.

Parameters:

	box	const Box reference describing the interior of the standard CELL-centered index box over which the side data object will be created.
	depth	gives the number of components for each spatial location in the array.
	ghosts	const IntVector reference indicating the width of the ghost cell region around the box over which the side data will be allocated.
	directions	const IntVector reference indicating which coordinate directions will have data associated with them. The default state is to create data for all coordinate directions.
	pool	memory arena. If not given, then the standard arena is used.

template<int DIM, class TYPE>

SAMRAI::pdat::SideData< DIM, TYPE >::~SideData ( ) [virtual]

The virtual destructor for a side data object.

Member Function Documentation

template<int DIM, class TYPE>

size_t SAMRAI::pdat::SideData< DIM, TYPE >::getSizeOfData	(	const hier::Box< DIM > &	box,
		int	depth,
		const hier::IntVector< DIM > &	ghosts,
		const hier::IntVector< DIM > &	directions
	)			`[static]`

Calculate the amount of memory needed to represent side- centered data over a CELL-centered AMR index space box.

This function assumes that the amount of memory needed for TYPE is sizeof(TYPE). If this is not the case, then a specialized function must be defined.

Parameters:

	box	const Box reference describing the interior of the standard CELL-centered index box over which the side data object will be created.
	depth	gives the number of components for each spatial location in the array.
	ghosts	const IntVector reference indicating the width of the ghost cell region around the box over which the side data will be allocated.
	directions	const IntVector reference indicating which coordinate directions are assumed to have data for the purposes of the calculation.

template<int DIM, class TYPE>

const hier::IntVector< DIM > & SAMRAI::pdat::SideData< DIM, TYPE >::getDirectionVector ( ) const [inline]

Return constant reference to vector describing which coordinate directions have data associated with this side data object.

A vector entry of zero indicates that there is no data array allocated for the corresponding coordinate direction. A non-zero value indicates that a valid data array is maintained for that coordinate direction.

template<int DIM, class TYPE>

int SAMRAI::pdat::SideData< DIM, TYPE >::getDepth ( ) const [inline]

Return the depth (e.g., the number of components in each spatial location) of the array.

template<int DIM, class TYPE>

TYPE * SAMRAI::pdat::SideData< DIM, TYPE >::getPointer	(	int	side_normal,
		int	depth = `0`
	)			`[inline]`

Get a pointer to the beginning of a particular side normal and depth component of the side centered array.

template<int DIM, class TYPE>

const TYPE * SAMRAI::pdat::SideData< DIM, TYPE >::getPointer	(	int	side_normal,
		int	depth = `0`
	)			const `[inline]`

Get a const pointer to the beginning of a particular side normal and depth component of the side centered array.

template<int DIM, class TYPE>

TYPE & SAMRAI::pdat::SideData< DIM, TYPE >::operator()	(	const SideIndex< DIM > &	i,
		int	depth = `0`
	)			`[inline]`

Return a reference to the data entry corresponding to a given side index and depth.

template<int DIM, class TYPE>

const TYPE & SAMRAI::pdat::SideData< DIM, TYPE >::operator()	(	const SideIndex< DIM > &	i,
		int	depth = `0`
	)			const `[inline]`

Return a const reference to the data entry corresponding to a given side index and depth.

template<int DIM, class TYPE>

ArrayData< DIM, TYPE > & SAMRAI::pdat::SideData< DIM, TYPE >::getArrayData ( int side_normal ) [inline]

Return a reference to the array data object for the given side normal of the side centered data object.

template<int DIM, class TYPE>

const ArrayData< DIM, TYPE > & SAMRAI::pdat::SideData< DIM, TYPE >::getArrayData ( int side_normal ) const [inline]

Return a const reference to the array data object for the given side normal of the side centered data object.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::copy ( const hier::PatchData< DIM > & src ) [virtual]

A fast copy from source to destination (i.e., this) patch data object.

Data is copied where there is overlap in the underlying index space. The copy is performed on the interior plus the ghost cell width (for both the source and destination). Currently, source data must be an SideData of the same DIM and TYPE. If not, then an unrecoverable error results.

Implements SAMRAI::hier::PatchData< DIM >.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::copy2 ( hier::PatchData< DIM > & dst ) const [virtual]

A fast copy from source (i.e., this) to destination patch data object.

Data is copied where there is overlap in the underlying index space. The copy is performed on the interior plus the ghost cell width (for both the source and destination). Currently, destination data must be an SideData of the same DIM and TYPE. If not, then an unrecoverable error results.

Implements SAMRAI::hier::PatchData< DIM >.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::copy	(	const hier::PatchData< DIM > &	src,
		const hier::BoxOverlap< DIM > &	overlap
	)			`[virtual]`

Copy data from source to destination (i.e., this) patch data object on the given overlap.

Currently, source data must be SideData of the same DIM and TYPE and the overlap must be a SideOverlap of the same DIM. If not, then an unrecoverable error results.

Implements SAMRAI::hier::PatchData< DIM >.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::copy2	(	hier::PatchData< DIM > &	dst,
		const hier::BoxOverlap< DIM > &	overlap
	)			const `[virtual]`

Copy data from source (i.e., this) to destination patch data object on the given overlap.

Currently, destination data must be SideData of the same DIM and TYPE and the overlap must be a SideOverlap of the same DIM. If not, then an unrecoverable error results.

Implements SAMRAI::hier::PatchData< DIM >.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::copyOnBox	(	const SideData< DIM, TYPE > &	src,
		const hier::Box< DIM > &	box
	)			`[inline]`

Copy data from source to destination (i.e., this) patch data object on the given CELL-centered AMR index box.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::copyDepth	(	int	dst_depth,
		const SideData< DIM, TYPE > &	src,
		int	src_depth
	)

Fast copy (i.e., source and this side data objects are defined over the same box) to this destination side data object from the given source side data object at the specified depths.

template<int DIM, class TYPE>

bool SAMRAI::pdat::SideData< DIM, TYPE >::canEstimateStreamSizeFromBox ( ) const [virtual]

Return true if the patch data object can estimate the stream size required to fit its data using only index space information (i.e., a box).

This routine is defined for the standard types (bool, char, double, float, int, and dcomplex).

Implements SAMRAI::hier::PatchData< DIM >.

template<int DIM, class TYPE>

int SAMRAI::pdat::SideData< DIM, TYPE >::getDataStreamSize ( const hier::BoxOverlap< DIM > & overlap ) const [virtual]

Return the number of bytes needed to stream the data in this patch data object lying in the specified box overlap region.

This routine is defined for the standard types (bool, char, double, float, int, and dcomplex).

Implements SAMRAI::hier::PatchData< DIM >.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::packStream	(	tbox::AbstractStream &	stream,
		const hier::BoxOverlap< DIM > &	overlap
	)			const `[virtual]`

Pack data in this patch data object lying in the specified box overlap region into the stream. The overlap must be an SideOverlap of the same DIM.

Implements SAMRAI::hier::PatchData< DIM >.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::unpackStream	(	tbox::AbstractStream &	stream,
		const hier::BoxOverlap< DIM > &	overlap
	)			`[virtual]`

Unpack data from stream into this patch data object over the specified box overlap region. The overlap must be an SideOverlap of the same DIM.

Implements SAMRAI::hier::PatchData< DIM >.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::fill	(	const TYPE &	t,
		int	d = `0`
	)

Fill all values at depth d with the value t.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::fill	(	const TYPE &	t,
		const hier::Box< DIM > &	box,
		int	d = `0`
	)

Fill all values at depth d within the box with the value t.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::fillAll ( const TYPE & t )

Fill all depth components with value t.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::fillAll	(	const TYPE &	t,
		const hier::Box< DIM > &	box
	)

Fill all depth components within the box with value t.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::print	(	const hier::Box< DIM > &	box,
		std::ostream &	os = `tbox::plog`,
		int	prec = `12`
	)			const

Print all side data values residing in the specified box. If the depth of the array is greater than one, all depths are printed.

Parameters:

	box	const reference to box over whioch to print data. Note box is assumed to reside in standard cell-centered index space and will be converted to side index space.
	os	reference to output stream.
	prec	integer precision for printing floating point numbers (i.e., TYPE = float, double, or dcomplex). The default is 12 decimal places for double and complex floating point numbers, and the default is 6 decimal places floats. For other types, this value is ignored.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::print	(	const hier::Box< DIM > &	box,
		int	depth,
		std::ostream &	os = `tbox::plog`,
		int	prec = `12`
	)			const

Print all side data values at the given array depth in the specified box.

Parameters:

	box	const reference to box over whioch to print data. Note box is assumed to reside in standard cell-centered index space and will be converted to side index space.
	depth	integer depth component, must satisfy 0 <= depth < actual depth of data array
	os	reference to output stream.
	prec	integer precision for printing floating point numbers (i.e., TYPE = float, double, or dcomplex). The default is 12 decimal places for double and complex floating point numbers, and the default is 6 decimal places floats. For other types, this value is ignored.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::printAxis	(	int	side_normal,
		const hier::Box< DIM > &	box,
		std::ostream &	os = `tbox::plog`,
		int	prec = `12`
	)			const

Print all side centered data values for specified side normal direction residing in the specified box. If the depth of the data is greater than one, all depths are printed.

Parameters:

	side_normal	integer side normal coordinate direction, must satisfy 0 <= side_normal < DIM
	box	const reference to box over whioch to print data. Note box is assumed to reside in standard cell-centered index space and will be converted to side index space.
	os	reference to output stream.
	prec	integer precision for printing floating point numbers (i.e., TYPE = float, double, or dcomplex). The default is 12 decimal places for double and complex floating point numbers, and the default is 6 decimal places floats. For other types, this value is ignored.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::printAxis	(	int	side_normal,
		const hier::Box< DIM > &	box,
		int	depth,
		std::ostream &	os = `tbox::plog`,
		int	prec = `12`
	)			const

Print all side centered data values for specified side normal direction residing in the specified box. If the depth of the data is greater than one, all depths are printed.

Parameters:

	side_normal	integer side normal coordinate direction, must satisfy 0 <= side_normal < DIM
	box	const reference to box over whioch to print data. Note box is assumed to reside in standard cell-centered index space and will be converted to side index space.
	depth	integer depth component, must satisfy 0 <= depth < actual depth of data array
	os	reference to output stream.
	prec	integer precision for printing floating point numbers (i.e., TYPE = float, double, or dcomplex). The default is 12 decimal places for double and complex floating point numbers, and the default is 6 decimal places floats. For other types, this value is ignored.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::getSpecializedFromDatabase ( tbox::Pointer< tbox::Database > database ) [virtual]

Check that class version and restart file version are equal. If so, read data members from the database.

Assertions: database must be a non-null pointer.

Implements SAMRAI::hier::PatchData< DIM >.

template<int DIM, class TYPE>

void SAMRAI::pdat::SideData< DIM, TYPE >::putSpecializedToDatabase ( tbox::Pointer< tbox::Database > database ) [virtual]

Write out the class version number and other data members to the database.

Assertions: database must be a non-null pointer.

Implements SAMRAI::hier::PatchData< DIM >.

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

source/patchdata/side/SideData.h
source/patchdata/side/SideData.C
source/patchdata/side/SideData.I

Generated on Thu Jun 18 11:28:55 2009 for SAMRAI by

1.5.1

SAMRAI::pdat::SideData< DIM, TYPE > Class Template Reference

Public Types

Public Member Functions

Static Public Member Functions

Detailed Description

template<int DIM, class TYPE> class SAMRAI::pdat::SideData< DIM, TYPE >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

template<int DIM, class TYPE>
class SAMRAI::pdat::SideData< DIM, TYPE >