Main Page | Namespace List | Class Hierarchy | Class List | File List | Namespace Members | Class Members | File Members | Related Pages

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

#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, const int depth, tbox::Pointer< tbox::Arena > pool=tbox::Pointer< tbox::Arena >(NULL))
virtual ~OuterfaceData ()
virtual void copy (const hier::PatchData< DIM > &src)
virtual void copy2 (hier::PatchData< DIM > &dst) const
virtual void copy (const hier::PatchData< DIM > &src, const hier::BoxOverlap< DIM > &overlap)
virtual void copy2 (hier::PatchData< DIM > &dst, const hier::BoxOverlap< DIM > &overlap) const
void copyDepth (int dst_depth, const FaceData< DIM, TYPE > &src, int src_depth)
 Fast copy between the source and destination at the specified depths.
virtual bool canEstimateStreamSizeFromBox () const
virtual int getDataStreamSize (const hier::BoxOverlap< DIM > &overlap) const
virtual void packStream (tbox::AbstractStream &stream, const hier::BoxOverlap< DIM > &overlap) const
virtual void unpackStream (tbox::AbstractStream &stream, const hier::BoxOverlap< DIM > &overlap)
int getDepth () const
TYPE * getPointer (const int axis, const int face, const int d=0)
const TYPE * getPointer (const int axis, const int face, const int d=0) const
ArrayData< DIM, TYPE > & getArrayData (const int axis, const int face)
const ArrayData< DIM, TYPE > & getArrayData (const int axis, const int face) const
TYPE & operator() (const FaceIndex< DIM > &i, const int face, const int d=0)
const TYPE & operator() (const FaceIndex< DIM > &i, const int face, const int d=0) const
void fill (const TYPE &t, const int d=0)
void fill (const TYPE &t, const hier::Box< DIM > &box, const int d=0)
void fillAll (const TYPE &t)
void fillAll (const TYPE &t, const hier::Box< DIM > &box)
void print (const hier::Box< DIM > &box, ostream &os=tbox::plog, int prec=-1) const
void print (const hier::Box< DIM > &box, const int d, ostream &os=tbox::plog, int prec=-1) const
void printAxisFace (const int axis, const int face, const hier::Box< DIM > &box, ostream &os=tbox::plog, int prec=-1) const
void printAxisFace (const int axis, const int face, const hier::Box< DIM > &box, const int d, ostream &os=tbox::plog, int prec=-1) const
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, const int depth)

Detailed Description

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

Class OuterfaceData<DIM> is a templated face-centered patch data structure derived from hier::PatchData<DIM>. It differs from the FaceData<DIM> class in that, given a box, an outerface data object represents face-centered data living only on the boundary of the box. It is templated on TYPE with a specified depth (that is, number of components for each spatial location). See the face geometry and patch data classes for more information about the translation between the AMR index space and face-centered data.

Outerface data is stored in 2*DIM arrays, containing the data for the patch boundary faces with each of the possible outward pointing normal directions. In each of these arrays, memory allocation is in column-major ordering (e.g., Fortran style) so that the leftmost index runs fastest in memory. In addition, the indices are permuted to match the face data storage. For example, a three-dimensional outerface data object instantiated with a box [l0:u0,l1:u1,l2:u2] allocates six data (i.e., three pairs) arrays dimensioned as:

     [ l1 : u1 ,
       l2 : u2 , d ]   ,

     [ l2 : u2 ,
       l0 : u0 , d ]   ,

     [ l0 : u0 ,
       l1 : u1 , d ]   ,

 * 
for the upper and lower x, y, and z (or 0, 1, 2) face directions, respectively, and where d is the depth index (i.e., number of values at each face index location). One- and two-dimensional face data arrays are managed similary.

IMPORTANT: The OutersideData class provides the same storage as this outerface data class, except that the individual arrays are not permuted in the outerside data type. Also, outerface and outerside data classes are intended to interact with their face-centered and side-centered data counterparts, respectively. Mixing types, while allowed, is discouraged to prevent undesirable behavior.

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::OuterfaceDataFactory

pdat::OuterfaceIndex

pdat::OuterfaceIterator

pdat::OuterfaceGeometry


Constructor & Destructor Documentation

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

The constructor for an outerface data object. The box describes the interior of the index space and the depth gives the number of components for each spatial location in the array. If the memory arena is not given, then the standard arena is used. Note that the ghost cell width is currently fixed at zero.

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

The virtual destructor for a outerface data object.


Member Function Documentation

template<int DIM, class TYPE>
void SAMRAI::pdat::OuterfaceData< DIM, TYPE >::copy const hier::PatchData< DIM > &  src  )  [virtual]
 

A fast copy between the source and destination (i.e., this) patch data objects. 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.

template<int DIM, class TYPE>
void SAMRAI::pdat::OuterfaceData< DIM, TYPE >::copy2 hier::PatchData< DIM > &  dst  )  const [virtual]
 

A fast copy between the source and destination. Member function copy2() is similar to copy() except that the location of source and destination are reversed and copy2() throws an exception (aka dumps core) if it does not understand the type of the argument. Currently, the destination data must be FaceData.

template<int DIM, class TYPE>
void SAMRAI::pdat::OuterfaceData< DIM, TYPE >::copy const hier::PatchData< DIM > &  src,
const hier::BoxOverlap< DIM > &  overlap
[virtual]
 

Not yet implemented! Copy data from the source into the destination using the designated overlap descriptor. The overlap description will have been computed using the appropriate box geometry objects. Currently, this function does nothing since copying to Outerface from Outerface is not defined on all box overlap configurations.

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 the source into the destination using the designated overlap descriptor. Member function copy2() is similar to the copy() member function except that the location of source and destination are reversed and copy2() throws an exception (aka dumps core) if it does not understand the type of the argument. Currently, the destination data must be FaceData.

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 between the source and destination at the specified depths.

Data is copied from the source into the destination 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).

template<int DIM, class TYPE>
bool SAMRAI::pdat::OuterfaceData< DIM, TYPE >::canEstimateStreamSizeFromBox  )  const [virtual]
 

Determines whether the patch data subclass can estinate the necessary stream size using only index space information. This routine is defined for the standard built-in types (bool, char, double, float, and int).

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

template<int DIM, class TYPE>
int SAMRAI::pdat::OuterfaceData< DIM, TYPE >::getDataStreamSize const hier::BoxOverlap< DIM > &  overlap  )  const [virtual]
 

Calculate the number of bytes needed to stream the data lying in the specified box domain. This routine is defined for the standard built-in types (bool, char, double, float, and int).

template<int DIM, class TYPE>
void SAMRAI::pdat::OuterfaceData< DIM, TYPE >::packStream tbox::AbstractStream stream,
const hier::BoxOverlap< DIM > &  overlap
const [virtual]
 

Pack data lying on the specified index set into the output stream.

template<int DIM, class TYPE>
void SAMRAI::pdat::OuterfaceData< DIM, TYPE >::unpackStream tbox::AbstractStream stream,
const hier::BoxOverlap< DIM > &  overlap
[virtual]
 

Unpack data from the message stream into the specified index set.

template<int DIM, class TYPE>
int SAMRAI::pdat::OuterfaceData< 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::OuterfaceData< DIM, TYPE >::getPointer const int  axis,
const int  face,
const int  d = 0
[inline]
 

Get a pointer to the beginning of a particular component of the outerface centered array. The axis gives the X=0, Y=1, or Z=2 axis and the face gives the lower=0 or upper=1 face.

template<int DIM, class TYPE>
const TYPE * SAMRAI::pdat::OuterfaceData< DIM, TYPE >::getPointer const int  axis,
const int  face,
const int  d = 0
const [inline]
 

Get a const pointer to the beginning of a particular component of the outerface centered array. The axis gives the X=0, Y=1, or Z=2 axis and the face gives the lower=0 or upper=1 face.

template<int DIM, class TYPE>
ArrayData< DIM, TYPE > & SAMRAI::pdat::OuterfaceData< DIM, TYPE >::getArrayData const int  axis,
const int  face
[inline]
 

Get a pointer to the array data object of a particular component of the outerface centered array. The axis gives the X=0, Y=1, or Z=2 axis and the face gives the lower=0 or upper=1 face.

template<int DIM, class TYPE>
const ArrayData< DIM, TYPE > & SAMRAI::pdat::OuterfaceData< DIM, TYPE >::getArrayData const int  axis,
const int  face
const [inline]
 

Get a const pointer to the array data object of a particular component of the outerface centered array. The axis gives the X=0, Y=1, or Z=2 axis and the face gives the lower=0 or upper=1 face.

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

hier::Index into the outerface data array using a face index.

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

hier::Index into the outerface data array (via a const reference) using a face index.

template<int DIM, class TYPE>
void SAMRAI::pdat::OuterfaceData< DIM, TYPE >::fill const TYPE &  t,
const int  d = 0
 

Fill all values of component 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,
const int  d = 0
 

Fill all values of component 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 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 components within the box with value t.

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

Calculate the amount of memory needed to represent the data in an outerface centered grid. 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.

template<int DIM, class TYPE>
void SAMRAI::pdat::OuterfaceData< DIM, TYPE >::print const hier::Box< DIM > &  box,
ostream &  os = tbox::plog,
int  prec = -1
const
 

Print all face centered data residing in the specified box. If the depth of the array is greater than one, all components are printed. Precision of floating point numbers (i.e., TYPE = float, double, or dcomplex) can be specified using the provided argument. 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 is ignored.

template<int DIM, class TYPE>
void SAMRAI::pdat::OuterfaceData< DIM, TYPE >::print const hier::Box< DIM > &  box,
const int  d,
ostream &  os = tbox::plog,
int  prec = -1
const
 

Print the specified component of the face centered data residing in the specified box. Precision of floating point numbers (i.e., TYPE = float, double, or dcomplex) can be specified using the provided argument. 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 is ignored.

template<int DIM, class TYPE>
void SAMRAI::pdat::OuterfaceData< DIM, TYPE >::printAxisFace const int  axis,
const int  face,
const hier::Box< DIM > &  box,
ostream &  os = tbox::plog,
int  prec = -1
const
 

Print all outerface centered data for specified axis index residing in the specified box, axis, and face. If the depth of the data is greater than one, then all components are printed. Precision of floating point numbers (i.e., TYPE = float, double, or dcomplex) can be specified using the provided argument. 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 is ignored.

template<int DIM, class TYPE>
void SAMRAI::pdat::OuterfaceData< DIM, TYPE >::printAxisFace const int  axis,
const int  face,
const hier::Box< DIM > &  box,
const int  d,
ostream &  os = tbox::plog,
int  prec = -1
const
 

Print specified component for all outerface centered data for the specified axis index, face index, and spatial component residing in the specified box. Precision of floating point numbers (i.e., TYPE = float, double, or dcomplex) can be specified using the provided argument. 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 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 Fri Dec 2 11:29:59 2005 for SAMRAI by  doxygen 1.4.2