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

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

Class OuteredgeData<DIM> is a templated edge-centered patch data structure derived from hier::PatchData<DIM>. It differs from the EdgeData<DIM> class in that, given a box, an outeredge data object represents edge-centered data living only on the border of the patch. More...

#include <source/patchdata/outeredge/OuteredgeData.h>

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

Inheritance graph
[legend]
List of all members.

Public Member Functions

 OuteredgeData (const hier::Box< DIM > &box, const int depth, tbox::Pointer< tbox::Arena > pool=tbox::Pointer< tbox::Arena >(NULL))
 Constructor for an outeredge data object.
virtual ~OuteredgeData ()
 Virtual destructor for a outeredge data object.
virtual void copy (const hier::PatchData< DIM > &src)
 A fast copy between the source and destination (i.e., this) patch data objects.
virtual void copy2 (hier::PatchData< DIM > &dst) const
 A fast copy between the source and destination.
virtual void copy (const hier::PatchData< DIM > &src, const hier::BoxOverlap< DIM > &overlap)
 Copy data from the source into the destination using the designated overlap descriptor.
virtual void copy2 (hier::PatchData< DIM > &dst, const hier::BoxOverlap< DIM > &overlap) const
 Copy data from the source into the destination using the designated overlap descriptor.
void copyDepth (int dst_depth, const EdgeData< DIM, TYPE > &src, int src_depth)
 Fast copy between the source and destination at the specified depths.
virtual bool canEstimateStreamSizeFromBox () const
 Determines whether the patch data subclass can estinate the necessary stream size using only index space information.
virtual int getDataStreamSize (const hier::BoxOverlap< DIM > &overlap) const
 Calculate the number of bytes needed to stream the data lying in the specified box domain.
virtual void packStream (tbox::AbstractStream &stream, const hier::BoxOverlap< DIM > &overlap) const
 Pack data lying on the specified index set into the output stream.
virtual void unpackStream (tbox::AbstractStream &stream, const hier::BoxOverlap< DIM > &overlap)
 Unpack data from the message stream into the specified index set.
int getDepth () const
 Return the depth (e.g., the number of components in each spatial location) of the array.
bool dataExists (int axis, int face_nrml) const
 Returns whether outeredges exists for the face normal to a given axis.
TYPE * getPointer (const int axis, const int face_nrml, const int s, const int d=0)
 Get a pointer to the beginning of a particular component of the outeredge centered array.
const TYPE * getPointer (int axis, int face_nrml, int s, int d=0) const
 Get a const pointer to the beginning of a particular component of the outeredge centered array.
ArrayData< DIM, TYPE > & getArrayData (int axis, int face_nrml, int s)
 Get a pointer to the array data object of a particular component of the outeredge centered array.
const ArrayData< DIM, TYPE > & getArrayData (int axis, int face_nrml, int s) const
 Get a const pointer to the array data object of a particular component of the outeredge centered array.
TYPE & operator() (const EdgeIndex< DIM > &i, int axis, int depth=0)
 Index<DIM> into the outeredge data array using a edge index.
const TYPE & operator() (const EdgeIndex< DIM > &i, int axis, int depth=0) const
 Index<DIM> into the outeredge data array (via a const reference) using a edge index.
hier::Box< DIM > getDataBox (int axis, int face_nrml, int s)
void fill (const TYPE &t, const int d=0)
 Fill all values of component depth d with the value t.
void fill (const TYPE &t, const hier::Box< DIM > &box, const int d=0)
 Fill all values of component depth d within the box with the value t.
void fillAll (const TYPE &t)
 Fill all components with value t.
void fillAll (const TYPE &t, const hier::Box< DIM > &box)
 Fill all components within the box with value t.
void print (const hier::Box< DIM > &box, ostream &os=tbox::plog, int prec=-1) const
 Print all outeredge data residing in the specified box.
void print (const hier::Box< DIM > &box, int d, ostream &os=tbox::plog, int prec=-1) const
 Print the specified component of the outeredge data residing in the specified box.
void printAxisSide (int axis, int face_nrml, int s, const hier::Box< DIM > &box, ostream &os=tbox::plog, int prec=-1) const
 Print all outeredge centered data for specified (axis,face_nrml) index residing in the specified box and side.
void printAxisSide (int axis, int face_nrml, int s, const hier::Box< DIM > &box, int d, ostream &os=tbox::plog, int prec=-1) const
 Print all outeredge centered data for specified (axis,face_nrml) index residing in the specified box and side.
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, const int depth)
 Calculate the amount of memory needed to represent the data in an outeredge centered grid.

Detailed Description

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

Class OuteredgeData<DIM> is a templated edge-centered patch data structure derived from hier::PatchData<DIM>. It differs from the EdgeData<DIM> class in that, given a box, an outeredge data object represents edge-centered data living only on the border of the patch.

It is templated on TYPE with a specified depth (that is, number of components for each spatial location). See the edge geometry and patch data classes for more information about the translation between the AMR index space and edge-centered data.

Outeredge data is stored in DIM*DIM*2 arrays, containing the data for the patch boundary sides with each of the possible outward pointing normal directions. Where an outeredge falls on more than one side (patch edges and corners), the outeredge belongs to the array associated with the higher dimensional direction. 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.

The outeredge data is related to the edge data in the following way:

Outeredge box(axis,face_nrml,s) = EdgeData<DIM>.getBox(axis)

where "axis" corresponds to the box of the standard edge datatype, "face_nrml" is the normal face direction, and "s" indicates the upper or lower face. Note that when edge_dir = face_dir, there are no outside edges so the data is NULL.

A three-dimensional outeredge data object instantiated with a box [l0:u0,l1:u1,l2:u2] allocates 12 data (i.e., 3x2 pairs) arrays dimensioned as:

 *
 *    a = edge axis
 *    f = face normal dir
 *    s = lower/upper face
 *
 *        (a,f,s) 
 *    0:  (0,0,[0,1])  NULL
 *        (0,1,[0,1])  [l0:u0,l1:l1,l2+1:u2,d],  [l0:u0,u1:u1,l2+1:u2,d]
 *        (0,2,[0,1])  [l0:u0,l1:u1+1,l2:l2,d],  [l0:u0,l1:u1+1,u2:u2,d]
 *        note: trimmed in 2, not trimmed in 1
 *
 *    1:  (1,0,[0,1])  [l0:l0,l1:u1,l2+1:u2,d],  [u0:u0,l1:u1,l2+1:u2,d]
 *        (1,1,[0,1])  NULL
 *        (1,2,[0,1])  [l0:u0+1,l1:u1,l2:l2,d],  [l0:u0+1,l1:u1,u2:u2,d]
 *        note: trimmed in 2, not trimmed in 0
 *
 *    2:  (2,0,[0,1])  [l0:l0,l1+1:u1,l2:u2,d],  [u0:u0,l1+1:u1,l2:u2,d]
 *        (2,1,[0,1])  [l0:u0+1,l1:l1,l2:u2,d],  [l0:u0+1,u1:u1,l2:u2,d]
 *        (2,2,[0,1])  NULL
 *        note: trimmed in 1, not trimmed in 0
 *
 * 
where 0, 1, and 2 can be thought of as X, Y, Z respectively, and d is the depth of the data. One- and two-dimensional edge data arrays are managed similary. The "a" dimension corresponds with the "axis" of standard EdgeData<DIM>.

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

See also:
ArrayData<DIM>

hier::PatchData<DIM>

OuteredgeDataFactory<DIM>

OuteredgeIndex<DIM>

EdgeIterator<DIM>

OuteredgeGeometry<DIM>


Constructor & Destructor Documentation

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

Constructor for an outeredge data object.

Parameters:
box describes the interior of the index space Note that the ghost cell width is currently fixed at zero.
depth gives the number of components 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::OuteredgeData< DIM, TYPE >::~OuteredgeData  )  [virtual]
 

Virtual destructor for a outeredge data object.


Member Function Documentation

template<int DIM, class TYPE>
void SAMRAI::pdat::OuteredgeData< 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 EdgeData<DIM>. If copy() does not understand the source object type, then copy2() is called.

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

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

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. If copy() does not understand the source object type, then copy2() is called. Currently, this function does nothing since copying to Outeredge from Outeredge is not defined on all box overlap configurations.

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

template<int DIM, class TYPE>
void SAMRAI::pdat::OuteredgeData< DIM, TYPE >::copyDepth int  dst_depth,
const EdgeData< 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::OuteredgeData< 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::OuteredgeData< 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::OuteredgeData< 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::OuteredgeData< 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::OuteredgeData< 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>
bool SAMRAI::pdat::OuteredgeData< DIM, TYPE >::dataExists int  axis,
int  face_nrml
const [inline]
 

Returns whether outeredges exists for the face normal to a given axis.

The "axis" and "face_nrml" arguments correspond to the edge axis and face normal, as discussed above.

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

Get a pointer to the beginning of a particular component of the outeredge centered array.

The "axis" and "face_nrml" arguments specify the X=0, Y=1, or Z=2 axis and "s" specifies the lower=0 or upper=1 side. See class description for the size of the array returned.

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

Get a const pointer to the beginning of a particular component of the outeredge centered array.

The "axis" and "face_nrml" arguments specify the X=0, Y=1, or Z=2 axis and "s" specifies the lower=0 or upper=1 side. See class description for the size of the array returned.

template<int DIM, class TYPE>
ArrayData< DIM, TYPE > & SAMRAI::pdat::OuteredgeData< DIM, TYPE >::getArrayData int  axis,
int  face_nrml,
int  s
[inline]
 

Get a pointer to the array data object of a particular component of the outeredge centered array.

The "axis" and "face_nrml" arguments specify the X=0, Y=1, or Z=2 axis and "s" specifies the lower=0 or upper=1 side.

template<int DIM, class TYPE>
const ArrayData< DIM, TYPE > & SAMRAI::pdat::OuteredgeData< DIM, TYPE >::getArrayData int  axis,
int  face_nrml,
int  s
const [inline]
 

Get a const pointer to the array data object of a particular component of the outeredge centered array.

The "axis" and "face_nrml" arguments specify the X=0, Y=1, or Z=2 axis and "s" specifies the lower=0 or upper=1 side.

template<int DIM, class TYPE>
TYPE & SAMRAI::pdat::OuteredgeData< DIM, TYPE >::operator() const EdgeIndex< DIM > &  i,
int  axis,
int  depth = 0
[inline]
 

Index<DIM> into the outeredge data array using a edge index.

The index MUST be an index on the outeredge of the box.

template<int DIM, class TYPE>
const TYPE & SAMRAI::pdat::OuteredgeData< DIM, TYPE >::operator() const EdgeIndex< DIM > &  i,
int  axis,
int  depth = 0
const [inline]
 

Index<DIM> into the outeredge data array (via a const reference) using a edge index.

The index MUST be an index on the outeredge of the box.

template<int DIM, class TYPE>
hier::Box< DIM > SAMRAI::pdat::OuteredgeData< DIM, TYPE >::getDataBox int  axis,
int  face_nrml,
int  s
 

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

Fill all values of component depth d with the value t.

template<int DIM, class TYPE>
void SAMRAI::pdat::OuteredgeData< DIM, TYPE >::fill const TYPE &  t,
const hier::Box< DIM > &  box,
const int  d = 0
 

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

template<int DIM, class TYPE>
void SAMRAI::pdat::OuteredgeData< DIM, TYPE >::fillAll const TYPE &  t  ) 
 

Fill all components with value t.

template<int DIM, class TYPE>
void SAMRAI::pdat::OuteredgeData< 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::OuteredgeData< DIM, TYPE >::getSizeOfData const hier::Box< DIM > &  box,
const int  depth
[static]
 

Calculate the amount of memory needed to represent the data in an outeredge 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::OuteredgeData< DIM, TYPE >::print const hier::Box< DIM > &  box,
ostream &  os = tbox::plog,
int  prec = -1
const
 

Print all outeredge 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::OuteredgeData< DIM, TYPE >::print const hier::Box< DIM > &  box,
int  d,
ostream &  os = tbox::plog,
int  prec = -1
const
 

Print the specified component of the outeredge 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::OuteredgeData< DIM, TYPE >::printAxisSide int  axis,
int  face_nrml,
int  s,
const hier::Box< DIM > &  box,
ostream &  os = tbox::plog,
int  prec = -1
const
 

Print all outeredge centered data for specified (axis,face_nrml) index residing in the specified box and side.

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::OuteredgeData< DIM, TYPE >::printAxisSide int  axis,
int  face_nrml,
int  s,
const hier::Box< DIM > &  box,
int  d,
ostream &  os = tbox::plog,
int  prec = -1
const
 

Print all outeredge centered data for specified (axis,face_nrml) index residing in the specified box and side.

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::OuteredgeData< 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::OuteredgeData< 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:58 2005 for SAMRAI by  doxygen 1.4.2