SAMRAI::math::PatchEdgeDataMiscellaneousOpsReal

SAMRAI::math::PatchEdgeDataMiscellaneousOpsReal< DIM, TYPE > Class Template Reference

#include <source/mathops/edge/PatchEdgeDataMiscellaneousOpsReal.h>

Inheritance diagram for SAMRAI::math::PatchEdgeDataMiscellaneousOpsReal< DIM, TYPE >:

Inheritance graph
[legend]
List of all members.

Public Member Functions

 PatchEdgeDataMiscellaneousOpsReal ()
virtual ~PatchEdgeDataMiscellaneousOpsReal ()
int computeConstrProdPos (const tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &data1, const tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &data2, const hier::Box< DIM > &box, const tbox::Pointer< pdat::EdgeData< DIM, double > > cvol=((pdat::EdgeData< DIM, double > *)(0))) const
void compareToScalar (tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &dst, const tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &src, const TYPE &alpha, const hier::Box< DIM > &box, const tbox::Pointer< pdat::EdgeData< DIM, double > > cvol=((pdat::EdgeData< DIM, double > *)(0))) const
int testReciprocal (tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &dst, const tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &src, const hier::Box< DIM > &box, const tbox::Pointer< pdat::EdgeData< DIM, double > > cvol=((pdat::EdgeData< DIM, double > *)(0))) const
TYPE maxPointwiseDivide (const tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &numer, const tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &denom, const hier::Box< DIM > &box) const
 Compute max of "conditional" quotients of two arrays.
TYPE minPointwiseDivide (const tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &numer, const tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &denom, const hier::Box< DIM > &box) const
 Compute min of quotients of two arrays.

Detailed Description

template<int DIM, class TYPE>
class SAMRAI::math::PatchEdgeDataMiscellaneousOpsReal< DIM, TYPE >

Class PatchEdgeDataMiscellaneousOpsReal<DIM> provides access to a collection of operations that may be applied to numerical edge-centered patch data of type double and float. The primary intent of this class is to provide the interface to these operations for the class PatchEdgeDataOpsReal<DIM> which provides access to a more complete set of operations that may be used to manipulate edge-centered patch data. Each member function accepts a box argument indicating the region of index space on which the operation should be performed. The operation will be performed on the intersection of this box and those boxes corresponding to the patch data objects. Also, each operation allows an additional edge-centered patch data object to be used to represent a control volume that weights the contribution of each data entry in the given norm calculation. Note that the control volume patch data must be of type double and have edge-centered geometry (i.e., the same as the data itself). The use of control volumes is important when these operations are used in vector kernels where the data resides over multiple levels of spatial resolution in an AMR hierarchy. If the control volume is not given in the function call, it will be ignored in the calculation. Also, note that the depth of the control volume patch data object must be either 1 or be equal to the depth of the other data objects.

Since these operations are used only by the vector kernels for the KINSOL and CVODE solver packages at this time, they are intended to be instantiated for the standard built-in types double and float (since those solvers only treat double and float data). To extend this class to other data types or to include other operations, the member functions must be specialized or the new operations must be added.

See also:
math::ArrayDataMiscellaneousOpsReal

Constructor & Destructor Documentation

template<int DIM, class TYPE>
SAMRAI::math::PatchEdgeDataMiscellaneousOpsReal< DIM, TYPE >::PatchEdgeDataMiscellaneousOpsReal (  ) 

Empty constructor and destructor.

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

Member Function Documentation

template<int DIM, class TYPE>
int SAMRAI::math::PatchEdgeDataMiscellaneousOpsReal< DIM, TYPE >::computeConstrProdPos ( const tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &  data1,
const tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &  data2,
const hier::Box< DIM > &  box,
const tbox::Pointer< pdat::EdgeData< DIM, double > >  cvol = ((pdat::EdgeData< DIM, double > *)(0)) 
) const

Return 1 if $\|data2_i\| > 0$ and $data1_i * data2_i \leq 0$, for any $i$ in the index region, where $cvol_i > 0$. Otherwise return 0. If the control volume is NULL, all values in the index set are used.

template<int DIM, class TYPE>
void SAMRAI::math::PatchEdgeDataMiscellaneousOpsReal< DIM, TYPE >::compareToScalar ( tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &  dst,
const tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &  src,
const TYPE &  alpha,
const hier::Box< DIM > &  box,
const tbox::Pointer< pdat::EdgeData< DIM, double > >  cvol = ((pdat::EdgeData< DIM, double > *)(0)) 
) const

Wherever $cvol_i > 0$ in the index region, set $dst_i = 1$ if $\|src_i\| > \alpha$, and $dst_i = 0$ otherwise. If the control volume is NULL, all values in the index set are considered.

template<int DIM, class TYPE>
int SAMRAI::math::PatchEdgeDataMiscellaneousOpsReal< DIM, TYPE >::testReciprocal ( tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &  dst,
const tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &  src,
const hier::Box< DIM > &  box,
const tbox::Pointer< pdat::EdgeData< DIM, double > >  cvol = ((pdat::EdgeData< DIM, double > *)(0)) 
) const

Wherever $cvol_i > 0$ in the index region, set $dst_i = 1/src_i$ if $src_i \neq 0$, and $dst_i = 0$ otherwise. If $dst_i = 0$ anywhere, 0 is the return value. Otherwise 1 is returned. If the control volume all values in the index set are considered.

template<int DIM, class TYPE>
TYPE SAMRAI::math::PatchEdgeDataMiscellaneousOpsReal< DIM, TYPE >::maxPointwiseDivide ( const tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &  numer,
const tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &  denom,
const hier::Box< DIM > &  box 
) const

Compute max of "conditional" quotients of two arrays.

Return the maximum of pointwise "conditional" quotients of the numerator and denominator.

The "conditional" quotient is defined as |numerator/denominator| where the denominator is nonzero. Otherwise, it is defined as |numerator|.

Note: This method is currently intended to support the PETSc-2.1.6 vector wrapper only. Please do not use it!

template<int DIM, class TYPE>
TYPE SAMRAI::math::PatchEdgeDataMiscellaneousOpsReal< DIM, TYPE >::minPointwiseDivide ( const tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &  numer,
const tbox::Pointer< pdat::EdgeData< DIM, TYPE > > &  denom,
const hier::Box< DIM > &  box 
) const

Compute min of quotients of two arrays.

Return the minimum of pointwise quotients of the numerator and denominator.

The quotient is defined as (numerator/denominator) where the denominator is nonzero. When the denominator is zero, the entry is skipped. If the denominator is always zero, the value of tbox::IEEE::getFLT_MAX() is returned (see SAMRAI::tbox::IEEE).

Note: This method is currently intended to support the SUNDIALS vector wrapper only. Please do not use it!

The documentation for this class was generated from the following files:
Generated on Thu Jun 18 11:28:34 2009 for SAMRAI by  doxygen 1.5.1