SAMRAI::pdat::OuterfaceData

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

Class OuterfaceData<DIM> provides an implementation for data defined at cell faces on the boundaries of 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, an outerface data object represents data of some template TYPE and depth on the cell faces on the boundary of the box. Here, depth indicates the number of data values at each face index location. The OuteredgfaceGeometry class provides the translation between the standard SAMRAI cell-centered AMR index space and outerface-centered data. More...

#include <source/patchdata/outerface/OuterfaceData.h>

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

Inheritance graph
[legend]
List of all members.

Public Member Functions

 OuterfaceData (const hier::Box< DIM > &box, int depth, tbox::Pointer< tbox::Arena > pool=tbox::Pointer< tbox::Arena >(NULL))
 Constructor for an outerface data object.
virtual ~OuterfaceData ()
 Virtual destructor for a outerface data object.
int getDepth () const
 Return the depth (i.e., the number of data values for each spatial location) of the array.
TYPE * getPointer (int face_normal, int side, int depth=0)
 Get a pointer to the beginning of a particular face normal, side, and depth component of the outerface centered array.
const TYPE * getPointer (int face_normal, int side, int depth=0) const
 Get a const pointer to the beginning of a particular face normal, side location, and depth component of the outerface centered array.
TYPE & operator() (const FaceIndex< DIM > &i, int side, int depth=0)
 Return a reference to data entry corresponding to a given face index, side location, and depth.
const TYPE & operator() (const FaceIndex< DIM > &i, int side, int depth=0) const
 Return a const reference to data entry corresponding to a given face index, side location, and depth.
ArrayData< DIM, TYPE > & getArrayData (int face_normal, int side)
 Return a reference to the array data object for face normal and side location of the outerface centered array.
const ArrayData< DIM, TYPE > & getArrayData (int face_normal, int side) const
 Return a const reference to the array data object for face normal and side location of the outerface centered array.
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 copyDepth (int dst_depth, const FaceData< DIM, TYPE > &src, int src_depth)
 Fast copy (i.e., assumes face and outerface data objects are defined over the same box) from the given face source data object to this destination outerface data object at the specified depths.
void copyDepth2 (int dst_depth, FaceData< DIM, TYPE > &dst, int src_depth) const
 Fast copy (i.e., assumes face and outerface data objects are defined over the same box) to the given face destination data object from this source outerface 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 FaceOverlap 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 FaceOverlap 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 outerface 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 outerface data values at the given array depth in the specified box.
void printAxisFace (int face_normal, int side, const hier::Box< DIM > &box, std::ostream &os=tbox::plog, int prec=12) const
 Print all outerface centered data values for specified face_normal and side residing in the specified box. If the depth of the data is greater than one, all depths are printed.
void printAxisFace (int face_normal, int side, const hier::Box< DIM > &box, int depth, std::ostream &os=tbox::plog, int prec=12) const
 Print all outerface centered data values for specified face_normal, side, and depth residing in the specified box.
virtual void getSpecializedFromDatabase (tbox::Pointer< tbox::Database > database)
 Check that class version and restart file version are equal. If so, read data members from the database.
virtual void putSpecializedToDatabase (tbox::Pointer< tbox::Database > database)
 Write out the class version number and other data members to the database.

Static Public Member Functions

static size_t getSizeOfData (const hier::Box< DIM > &box, int depth)
 Calculate the amount of memory needed to represent outerface- centered data over a CELL-centered AMR index space box.

Detailed Description

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

Class OuterfaceData<DIM> provides an implementation for data defined at cell faces on the boundaries of 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, an outerface data object represents data of some template TYPE and depth on the cell faces on the boundary of the box. Here, depth indicates the number of data values at each face index location. The OuteredgfaceGeometry class provides the translation between the standard SAMRAI cell-centered AMR index space and outerface-centered data.

Outerface data is stored in 2*DIM arrays, each of which contains data associated with face indices normal to a coordinate axis direction and an upper or lower box face in the face normal direction. The data layout in the outerface data arrays matches the corresponding array sections provided by the face data implementation. Specifically, within each array, the data indices are cyclically permuted to be consistent with the FaceData<DIM> implementation. Also, in each of array, 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 outerface data object created over a CELL-centered AMR index space [l0:u0,l1:u1,l2:u2] allocates six data arrays dimensioned as follows: 


   face normal 0:
     lower face      [ l0:l0     , l1:u1 , l2:u2 , d ]
     upper face      [ u0+1:u0+1 , l1:u1 , l2:u2 , d ]

   face normal 1:
     lower face      [ l1:l1     , l2:u2 , l0:u0 , d ]
     upper face      [ u1+1:u1+1 , l2:u2 , l0:u0 , d ]

   face normal 2:
     lower face      [ l2:l2     , l0:u0 , l1:u1 , d ]
     upper face      [ u2+1:u2+1 , l0:u0 , l1:u1 , d ]

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

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

IMPORTANT: The OutersideData<DIM> class provides the same storage as this outerface data class, except that the coordinate directions of the individual arrays are not permuted; i.e., OutersideData is consistent with the SideData implementation.

See also:
pdat::ArrayData

hier::PatchData

pdat::OuterfaceDataFactory

pdat::OuterfaceGeometry

pdat::FaceIterator

pdat::FaceIndex

Constructor & Destructor Documentation

template<int DIM, class TYPE>
SAMRAI::pdat::OuterfaceData< DIM, TYPE >::OuterfaceData ( const hier::Box< DIM > &  box,
int  depth,
tbox::Pointer< tbox::Arena >  pool = tbox::Pointer< tbox::Arena >(NULL) 
)

Constructor for an outerface data object.

Note: Outerface data always has ghost cell width of zero.

Parameters:
box const Box reference describing the interior of the standard CELL-centered index box over which the outerface data object will be created.
depth gives the number of data values for each spatial location in the array.
pool memory arena. If not given, then the standard arena is used.

template<int DIM, class TYPE>
SAMRAI::pdat::OuterfaceData< DIM, TYPE >::~OuterfaceData (  )  [virtual]

Virtual destructor for a outerface data object.

Member Function Documentation

template<int DIM, class TYPE>
size_t SAMRAI::pdat::OuterfaceData< DIM, TYPE >::getSizeOfData ( const hier::Box< DIM > &  box,
int  depth 
) [static]

Calculate the amount of memory needed to represent outerface- 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 outerface data object will be created. Note: the ghost cell width is assumed to be zero.
depth gives the number of data values for each spatial location in the array.

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

Return the depth (i.e., the number of data values for each spatial location) of the array.

template<int DIM, class TYPE>
TYPE * SAMRAI::pdat::OuterfaceData< DIM, TYPE >::getPointer ( int  face_normal,
int  side,
int  depth = 0 
) [inline]

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

Parameters:
face_normal integer face normal direction for data, must satisfy 0 <= face_normal < DIM
side integer lower (0) or upper (1) side of outerface data array
depth integer depth component, must satisfy 0 <= depth < actual depth of data array

template<int DIM, class TYPE>
const TYPE * SAMRAI::pdat::OuterfaceData< DIM, TYPE >::getPointer ( int  face_normal,
int  side,
int  depth = 0 
) const [inline]

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

Parameters:
face_normal integer face normal direction for data, must satisfy 0 <= face_normal < DIM
side integer lower (0) or upper (1) side of outerface data array
depth integer depth component, must satisfy 0 <= depth < actual depth of data array

template<int DIM, class TYPE>
TYPE & SAMRAI::pdat::OuterfaceData< DIM, TYPE >::operator() ( const FaceIndex< DIM > &  i,
int  side,
int  depth = 0 
) [inline]

Return a reference to data entry corresponding to a given face index, side location, and depth.

Parameters:
i const reference to FaceIndex, MUST be an index on the outerface of the box.
side integer (lower/upper location of outerface data), must satisfy 0 <= side <= 1
depth integer depth component, must satisfy 0 <= depth < actual depth of data array

template<int DIM, class TYPE>
const TYPE & SAMRAI::pdat::OuterfaceData< DIM, TYPE >::operator() ( const FaceIndex< DIM > &  i,
int  side,
int  depth = 0 
) const [inline]

Return a const reference to data entry corresponding to a given face index, side location, and depth.

Parameters:
i const reference to FaceIndex, MUST be an index on the outerface of the box.
side integer (lower/upper location of outerface data), must satisfy 0 <= side <= 1
depth integer depth component, must satisfy 0 <= depth < actual depth of data array

template<int DIM, class TYPE>
ArrayData< DIM, TYPE > & SAMRAI::pdat::OuterfaceData< DIM, TYPE >::getArrayData ( int  face_normal,
int  side 
) [inline]

Return a reference to the array data object for face normal and side location of the outerface centered array.

Parameters:
face_normal integer face normal direction for data, must satisfy 0 <= face_normal < DIM
side integer lower (0) or upper (1) side of outerface data array

template<int DIM, class TYPE>
const ArrayData< DIM, TYPE > & SAMRAI::pdat::OuterfaceData< DIM, TYPE >::getArrayData ( int  face_normal,
int  side 
) const [inline]

Return a const reference to the array data object for face normal and side location of the outerface centered array.

Parameters:
face_normal integer face normal direction for data, must satisfy 0 <= face_normal < DIM
side integer lower (0) or upper (1) side of outerface data array

template<int DIM, class TYPE>
void SAMRAI::pdat::OuterfaceData< 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 FaceData 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::OuterfaceData< 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 FaceData 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::OuterfaceData< 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.

IMPORTANT: this routine is not yet implemented!

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

template<int DIM, class TYPE>
void SAMRAI::pdat::OuterfaceData< 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 FaceData of the same DIM and TYPE and the overlap must be a FaceOverlap of the same DIM. If not, then an unrecoverable error results.

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

template<int DIM, class TYPE>
void SAMRAI::pdat::OuterfaceData< DIM, TYPE >::copyDepth ( int  dst_depth,
const FaceData< DIM, TYPE > &  src,
int  src_depth 
)

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

template<int DIM, class TYPE>
void SAMRAI::pdat::OuterfaceData< DIM, TYPE >::copyDepth2 ( int  dst_depth,
FaceData< DIM, TYPE > &  dst,
int  src_depth 
) const

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

template<int DIM, class TYPE>
bool SAMRAI::pdat::OuterfaceData< 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::OuterfaceData< 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::OuterfaceData< 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 FaceOverlap of the same DIM.

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

template<int DIM, class TYPE>
void SAMRAI::pdat::OuterfaceData< 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 FaceOverlap of the same DIM.

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

template<int DIM, class TYPE>
void SAMRAI::pdat::OuterfaceData< 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::OuterfaceData< 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::OuterfaceData< DIM, TYPE >::fillAll ( const TYPE &  t  ) 

Fill all depth components with value t.

template<int DIM, class TYPE>
void SAMRAI::pdat::OuterfaceData< 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::OuterfaceData< DIM, TYPE >::print ( const hier::Box< DIM > &  box,
std::ostream &  os = tbox::plog,
int  prec = 12 
) const

Print all outerface 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 face 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::OuterfaceData< DIM, TYPE >::print ( const hier::Box< DIM > &  box,
int  depth,
std::ostream &  os = tbox::plog,
int  prec = 12 
) const

Print all outerface 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 face 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::OuterfaceData< DIM, TYPE >::printAxisFace ( int  face_normal,
int  side,
const hier::Box< DIM > &  box,
std::ostream &  os = tbox::plog,
int  prec = 12 
) const

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

Parameters:
face_normal integer face normal direction for data, must satisfy 0 <= face_normal < DIM
side integer lower (0) or upper (1) side of outerface data array
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 face 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::OuterfaceData< DIM, TYPE >::printAxisFace ( int  face_normal,
int  side,
const hier::Box< DIM > &  box,
int  depth,
std::ostream &  os = tbox::plog,
int  prec = 12 
) const

Print all outerface centered data values for specified face_normal, side, and depth residing in the specified box.

Parameters:
face_normal integer face normal direction for data, must satisfy 0 <= face_normal < DIM
side integer lower (0) or upper (1) side of outerface data array
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 face 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::OuterfaceData< 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::OuterfaceData< 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:
Generated on Thu Jun 18 11:28:54 2009 for SAMRAI by  doxygen 1.5.1