FArrayBox Class Reference

: A Fortran Array of REALs More...

#include <FArrayBox.H>

Inheritance diagram for FArrayBox:

Collaboration diagram for FArrayBox:

List of all members.

Public Types

typedef T value_type

Public Member Functions

FArrayBox ()

Construct an invalid FAB with no memory.

FArrayBox (const Box &b, int ncomp=1)

Construct an initial FAB with the data space allocated but not inititialized.

FArrayBox (const FArrayBox &)

FArrayBox & operator= (const FArrayBox &)

FArrayBox & operator= (const Real &r)

~FArrayBox ()

The destructor.

void resize (const Box &b, int N=1)

This function resizes a `BaseFab' so it covers the `Box' B with N components.

Real norm (int p=2, int scomp=0, int ncomp=1) const

Compute the Lp-norm of this FAB using components (scomp : scomp+ncomp-1).

Real norm (const Box &subbox, int p=2, int scomp=0, int ncomp=1) const

Same as above except only on given subbox.

void writeOn (std::ostream &of) const

Writes out the FAB in whatever format you've set.

void writeOn (std::ostream &of, int comp, int num_comp=1) const

Write only selected range of components.

void readFrom (std::istream &is)

Read FAB from istream. Format is as it was written out.

int readFrom (std::istream &is, int compIndex)

Read FAB from istream.

void clear ()

The function returns the `BaseFab' to the invalid state.

int nComp () const

Returns the number of components.

const Box & box () const

Returns the domain (box) where the array is defined.

const int * length () const

Returns a pointer to an array of SPACEDIM integers giving the length of the domain in each direction.

const IntVect & smallEnd () const

Returns the lower corner of the domain.

const IntVect & bigEnd () const

Returns the upper corner of the domain.

const int * loVect () const

Returns the lower corner of the domain.

const int * hiVect () const

Returns the upper corner of the domain.

bool contains (const BaseFab< T > &fab) const

Returns true if the domain of fab is totally contained within the domain of this `BaseFab'.

bool contains (const Box &bx) const

Returns true if bx is totally contained within the domain of this `BaseFab'.

T * dataPtr (int N=0)

Returns a pointer to an object of type T that is the value of the Nth component associated with the cell at the low end of the domain.

const T * dataPtr (int N=0) const

Same as above except works on const FAB's.

bool isAllocated () const

Returns true if the data for the FAB has been allocated.

T & operator() (const IntVect &p, int N)

Returns a reference to the Nth component value defined at position p in the domain.

T & operator() (const IntVect &p)

Same as above, except returns component 0.

const T & operator() (const IntVect &p, int N) const

Same as above except works on const FAB's.

const T & operator() (const IntVect &p) const

Same as above, except returns component 0.

void getVal (T *data, const IntVect &pos, int N, int numcomp) const

This function puts numcomp component values, starting at component N, from position pos in the domain into array data, that must be allocated by the user.

void getVal (T *data, const IntVect &pos) const

Same as above, except that starts at component 0 and copies ALL comps.

void setVal (T x, const Box &bx, int nstart, int ncomp)

The setVal functions set subregions in the `BaseFab' to a constant value.

void setVal (T x, const Box &bx, int N)

Same as above, except the number of modified components is one.

void setVal (T x, int N)

Same as above, except the subbox defaults to the entire domain.

void setVal (T x)

Same as above, except ALL components are set.

void setComplement (T x, const Box &b, int ns, int num)

This function is analogous to the fourth form of setVal above, except that instead of setting values on the `Box' b, values are set on the complement of b in the domain.

BaseFab< T > & copy (const BaseFab< T > &src, const Box &srcbox, int srccomp, const Box &destbox, int destcomp, int numcomp)

The `copy' functions copy the contents of one `BaseFab' into another.

BaseFab< T > & copy (const BaseFab< T > &src, int srccomp, int destcomp, int numcomp=1)

As above, except the destination `Box' and the source `Box' are taken to be the entire domain of the destination.

BaseFab< T > & copy (const BaseFab< T > &src, const Box &destbox)

As above, except that the destination `Box' is specified, but the source `Box' is taken to the equal to the source `Box', and all components of the destination `BaseFab' are copied.

BaseFab< T > & copy (const BaseFab< T > &src)

As above, except that the destbox defaults to the entire domain of the destination BaseFab, and all components are copied.

BaseFab< T > & shift (const IntVect &v)

Perform shifts upon the domain of the `BaseFab'.

BaseFab< T > & shift (int idir, int n_cell)

Perform shifts upon the domain of the `BaseFab'.

BaseFab< T > & shiftHalf (int dir, int num_halfs)

Perform shifts upon the domain of the `BaseFab'.

BaseFab< T > & shiftHalf (const IntVect &num_halfs)

Perform shifts upon the domain of the `BaseFab'.

void abs ()

Compute absolute value for all components of this FAB.

void abs (int comp, int numcomp=1)

Same as above except only for components (comp: comp+numcomp-1).

void abs (const Box &subbox, int comp=0, int numcomp=1)

Calculate abs() on subbox for given component range.

T min (int comp=0) const

Minimum value of given component.

T min (const Box &subbox, int comp=0) const

Minimum value of given component in given subbox.

T max (int comp=0) const

Maximum value of given component.

T max (const Box &subbox, int comp=0) const

Maximum value of given component in given subbox.

IntVect minIndex (int comp=0) const

Find location of minimum value in given component.

IntVect minIndex (const Box &subbox, int comp=0) const

Find location of minimum value in given component in given subbox.

IntVect maxIndex (int comp=0) const

Find location of maximum value in given component.

IntVect maxIndex (const Box &subbox, int comp=0) const

Find location of maximum value in given component in given subbox.

int maskLT (BaseFab< int > &mask, T val, int comp=0) const

Compute mask array with value of 1 in cells where BaseFab has value less than val, 0 otherwise.

int maskLE (BaseFab< int > &mask, T val, int comp=0) const

Same as above except mark cells with value less than or equal to val.

int maskEQ (BaseFab< int > &mask, T val, int comp=0) const

Same as above except mark cells with value equal to val.

int maskGT (BaseFab< int > &mask, T val, int comp=0) const

Same as above except mark cells with value greater than val.

int maskGE (BaseFab< int > &mask, T val, int comp=0) const

Same as above except mark cells with value greater than or equal to val.

void patternFill (int mark=0)

Fill with a pattern of numbers.

void copyRev (const Box &destbox, const BaseFab< T > &src, const Box &srcbox, int reversal_index, T *multiplier)

Copies with index reversal from srcbox region of src into destbox region of this FAB.

T sum (int comp, int numcomp=1) const

Compute sum of given component of FAB state vector.

T sum (const Box &subbox, int comp, int numcomp=1) const

Compute sum of given component of FAB state vector in given subbox.

BaseFab< T > & invert (T v, const Box &subbox, int comp=0, int numcomp=1)

Most general version, specify subbox and which components.

BaseFab< T > & invert (T v, int comp, int numcomp=1)

As above except on entire domain.

BaseFab< T > & invert (T v)

As above except on entire domain, all components.

BaseFab< T > & negate (const Box &subbox, int comp=0, int numcomp=1)

Negate BaseFab, most general.

BaseFab< T > & negate (int comp, int numcomp=1)

As above, except on entire domain.

BaseFab< T > & negate ()

As above, except on entire domain and all components.

BaseFab< T > & plus (T r, const Box &b, int comp=0, int numcomp=1)

Scalar addition (a[i] <- a[i] + r), most general.

BaseFab< T > & plus (T r, int comp, int numcomp=1)

As above, except on entire domain.

BaseFab< T > & plus (T r)

As above, except on entire domain and all components.

BaseFab< T > & plus (const BaseFab< T > &src)

FAB addition (a[i] <- a[i] + b[i]). The same as += operator.

BaseFab< T > & plus (const BaseFab< T > &src, int srccomp, int destcomp, int numcomp=1)

Add src components (srccomp:srccomp+numcomp-1) to this FAB's components (destcomp:destcomp+numcomp-1) where the two FABs intersect.

BaseFab< T > & plus (const BaseFab< T > &src, const Box &subbox, int srccomp, int destcomp, int numcomp=1)

Same as above except addition is restricted to intersection of subbox and src FAB.

BaseFab< T > & plus (const BaseFab< T > &src, const Box &srcbox, const Box &destbox, int srccomp, int destcomp, int numcomp=1)

Add srcbox region of src FAB to destbox region of this FAB.

BaseFab< T > & operator+= (T r)

Addition in place.

BaseFab< T > & operator+= (const BaseFab< T > &f)

FAB addition (a[i] <- a[i] + b[i]) in place.

BaseFab< T > & operator-= (T r)

Scalar subtraction (a[i] <- a[i] - r).

BaseFab< T > & operator-= (const BaseFab< T > &f)

FAB subtraction (a[i] <- a[i] - b[i]), in place.

BaseFab< T > & minus (const BaseFab< T > &src)

FAB subtraction (a[i] <- a[i] - b[i]). The same as -= operator.

BaseFab< T > & minus (const BaseFab< T > &src, int srccomp, int destcomp, int numcomp=1)

Subtract src components (srccomp:srccomp+numcomp-1) to this FAB's components (destcomp:destcomp+numcomp-1) where the two FABs intersect.

BaseFab< T > & minus (const BaseFab< T > &src, const Box &subbox, int srccomp, int destcomp, int numcomp=1)

Same as above except subtraction is restricted to intersection of subbox and src FAB.

BaseFab< T > & minus (const BaseFab< T > &src, const Box &srcbox, const Box &destbox, int srccomp, int destcomp, int numcomp=1)

Subtract srcbox region of src FAB from destbox region of this FAB.

BaseFab< T > & operator*= (T r)

Scalar multiplication (a[i] <- a[i] * r), in place.

BaseFab< T > & operator*= (const BaseFab< T > &f)

FAB multiplication (a[i] <- a[i] * b[i]), in place.

BaseFab< T > & mult (T r)

Scalar multiplication (a[i] <- a[i] * r). The same as *=.

BaseFab< T > & mult (T r, int comp, int numcomp=1)

Scalar multiplication, except control which components are multiplied.

BaseFab< T > & mult (T r, const Box &b, int comp=0, int numcomp=1)

As above, except specify sub-box.

BaseFab< T > & mult (const BaseFab< T > &src)

As above.

BaseFab< T > & mult (const BaseFab< T > &src, int srccomp, int destcomp, int numcomp=1)

Multiply src components (srccomp:srccomp+numcomp-1) with this FAB's components (destcomp:destcomp+numcomp-1) where the two FABs intersect.

BaseFab< T > & mult (const BaseFab< T > &src, const Box &subbox, int srccomp, int destcomp, int numcomp=1)

Same as above except multiplication is restricted to intersection of subbox and src FAB.

BaseFab< T > & mult (const BaseFab< T > &src, const Box &srcbox, const Box &destbox, int srccomp, int destcomp, int numcomp=1)

Multiply srcbox region of src FAB with destbox region of this FAB.

BaseFab< T > & operator/= (T r)

Scalar division (a[i] <- a[i] / r), in place.

BaseFab< T > & operator/= (const BaseFab< T > &src)

FAB division, in place.

BaseFab< T > & divide (T r)

Scalar division (a[i] <- a[i] / r), in place.

BaseFab< T > & divide (T r, int comp, int numcomp=1)

As above except specify which components.

BaseFab< T > & divide (T r, const Box &b, int comp=0, int numcomp=1)

As above except specify sub-box.

BaseFab< T > & divide (const BaseFab< T > &src)

Same as above.

BaseFab< T > & divide (const BaseFab< T > &src, int srccomp, int destcomp, int numcomp=1)

This FAB is numerator, src FAB is denominator divide src components (srccomp:srccomp+numcomp-1) into this FAB's components (destcomp:destcomp+numcomp-1) where the two FABs intersect.

BaseFab< T > & divide (const BaseFab< T > &src, const Box &subbox, int srccomp, int destcomp, int numcomp=1)

Same as above except division is restricted to intersection of subbox and src FAB.

BaseFab< T > & divide (const BaseFab< T > &src, const Box &srcbox, const Box &destbox, int srccomp, int destcomp, int numcomp=1)

destbox region of this FAB is numerator.

BaseFab< T > & linInterp (const BaseFab< T > &f1, const Box &b1, int comp1, const BaseFab< T > &f2, const Box &b2, int comp2, Real t1, Real t2, Real t, const Box &b, int comp, int numcomp=1)

Linear interpolation / extrapolation.

BaseFab< T > & linComb (const BaseFab< T > &f1, const Box &b1, int comp1, const BaseFab< T > &f2, const Box &b2, int comp2, Real alpha, Real beta, const Box &b, int comp, int numcomp=1)

Linear combination.

Static Public Member Functions

static Box skipFAB (std::istream &is, int &num_comp)

Skip over the next FAB from the input stream.

static void skipFAB (std::istream &is)

Skip over the next FAB from the input stream.

static void setFormat (FABio::Format fmt)

Set the FABio::Format in the program.

static FABio::Format getFormat ()

Gets the FABio::Format set in the program.

static void setOrdering (FABio::Ordering ordering)

Set the FABio::Ordering for reading old FABs.

static FABio::Ordering getOrdering ()

Gets the FABio::Ordering set in the program.

static void setPrecision (FABio::Precision precision)

Set the FABio::Precision.

static FABio::Precision getPrecision ()

Returns the FABio::Precision.

static const FABio & getFABio ()

Returns reference to the FABio object used by the program.

static void setFABio (FABio *rd)

Sets the FABio object used by the program.

static bool set_do_initval (bool tf)

static bool get_do_initval ()

static Real set_initval (Real iv)

static Real get_initval ()

static void Initialize ()

static void Finalize ()

Protected Member Functions

void define ()

void undefine ()

void performCopy (const BaseFab< T > &src, const Box &srcbox, int srccomp, const Box &destbox, int destcomp, int numcomp)

void performSetVal (T x, const Box &bx, int nstart, int numcomp)

Protected Attributes

Box domain

int nvar

long numpts

long truesize

T * dptr

Static Protected Attributes

static FABio::Format format = FABio::FAB_NATIVE

static FABio::Ordering ordering = FABio::FAB_NORMAL_ORDER

static FABio * fabio = new FABio_binary(FPC::NativeRealDescriptor().clone())

static bool do_initval = true

static Real initval

Friends

class FABio

std::ostream & operator<< (std::ostream &os, const FArrayBox &fb)

Write FABs in ASCII form.

std::istream & operator>> (std::istream &is, FArrayBox &fb)

Read FABs in ASCII form.

Detailed Description

: A Fortran Array of REALs

Fortran Array Box's (generally called FAB's) are objects constructed to emulate the `FORTRAN' array. Useful operations can be performed upon FAB's in C++, and they provide a convenient interface to `FORTRAN' when it is necessary to retreat into that language.

FArrayBox is derived from BaseFab<Real>. FArrayBox adds additional useful capabilities which make sense for Real types, such as I/O and L**p norms.

FArrayBox's may be output in various format's with various precisions. Available formats are ascii, `IEEE 32', native, and 8bit. Ascii is self explanatory. IEEE 32 is the standard on most microprocessor based computers; it specifies that output should be in IEEE 32 bit floating point format in normal order. Native is the most efficient, but not necessarily most portable, I/O format for a given computer. 8bit is a 8 bit format, suitable for graphics output. In general, you probably want to use NATIVE, unless you need to write your data out with less precision than your computation in order to save space.

The format and precision may be set in a file read by the ParmParse class by the "fab.format" variable. Allowed values are NATIVE, ASCII, 8BIT and IEEE32.

FABs written using `operator<<' are always written in ASCII. FABS written using `writOn' use the FABio::Format specified with `setFormat' or the FABio::Format specified in the ParmParse file read by `init'. If the FABio::Format is not set explicitly by either of these two methods, then it defaults to NATIVE.

The C pre-processor macro `BL' must be defined to use this class. The internal precision of FARRAYBOX objects is set by defining either `BL' or `BL'

This is NOT a polymorphic class.

This class does NOT provide a copy constructor or assignment operator.

Member Typedef Documentation

template<class T>

typedef T BaseFab< T >::value_type [inherited]

Constructor & Destructor Documentation

FArrayBox::FArrayBox ( )

Construct an invalid FAB with no memory.

FArrayBox::FArrayBox	(	const Box &	b,
		int	ncomp = `1`
	)			`[explicit]`

Construct an initial FAB with the data space allocated but not inititialized.

ncomp is the number of components (variables) at each data point in the Box.

References do_initval, initval, and BaseFab< T >::setVal().

FArrayBox::FArrayBox ( const FArrayBox & fab )

FArrayBox::~FArrayBox ( )

The destructor.

Member Function Documentation

FArrayBox & FArrayBox::operator= ( const FArrayBox & fab )

References BaseFab< T >::operator=().

FArrayBox & FArrayBox::operator= ( const Real & r )

References BaseFab< T >::operator=().

void FArrayBox::resize	(	const Box &	b,
		int	N = `1`
	)

This function resizes a `BaseFab' so it covers the `Box' B with N components.

The default action is that under resize()ing, the memory allocated for the `BaseFab' only grows and never shrinks. This function is particularly useful when a `BaseFab' is used as a temporary space which must be a different size whenever it is used. Resize()ing a temp will often be faster than re-allocating a `BaseFab' because memory allocation can often be avoided.

Reimplemented from BaseFab< T >.

References do_initval, initval, BaseFab< T >::resize(), and BaseFab< T >::setVal().

Referenced by FABio::read_header().

Real FArrayBox::norm	(	int	p = `2`,
		int	scomp = `0`,
		int	ncomp = `1`
	)			const

Compute the Lp-norm of this FAB using components (scomp : scomp+ncomp-1).

p < 0 -> ERROR. p = 0 -> infinity norm (max norm). p = 1 -> sum of ABS(FAB) p > 1 -> Lp-norm

Reimplemented from BaseFab< T >.

References BaseFab< T >::domain.

Real FArrayBox::norm	(	const Box &	subbox,
		int	p = `2`,
		int	scomp = `0`,
		int	ncomp = `1`
	)			const

Same as above except only on given subbox.

Reimplemented from BaseFab< T >.

References BL_ASSERT, BaseFab< T >::nComp(), and BaseFab< T >::norm().

void FArrayBox::writeOn ( std::ostream & of ) const

Writes out the FAB in whatever format you've set.

The default format is ASCII.

References BaseFab< T >::nComp().

void FArrayBox::writeOn	(	std::ostream &	of,
		int	comp,
		int	num_comp = `1`
	)			const

Write only selected range of components.

comp specifies from which component (starting at 0) to write at each point in space. num specifies how many data points to write out at each point is space -- it defaults to 1. It must be the case the comp >= 0 && num >= 1 && (comp+num) <= nComp(). The FAB is written out in whatever format you've set, with the default format being ASCII. The FAB that is written to disk will be an num component FAB.

References BL_ASSERT, fabio, BaseFab< T >::nComp(), FABio::write(), and FABio::write_header().

void FArrayBox::readFrom ( std::istream & is )

Read FAB from istream. Format is as it was written out.

References FABio::read(), and FABio::read_header().

int FArrayBox::readFrom	(	std::istream &	is,
		int	compIndex
	)

Read FAB from istream.

Format is as it was written out. This creates a single component FAB with data from compIndex of the FAB from the istream. Returns the number of components available in the fab.

References BL_ASSERT, FABio::read(), FABio::read_header(), and FABio::skip().

Box FArrayBox::skipFAB	(	std::istream &	is,
		int &	num_comp
	)			`[static]`

Skip over the next FAB from the input stream.

Return the Box defining the domain of the FAB and the number of components.

References BaseFab< T >::box(), BaseFab< T >::nComp(), FABio::read_header(), and FABio::skip().

Referenced by skipFAB().

void FArrayBox::skipFAB ( std::istream & is ) [static]

Skip over the next FAB from the input stream.

References skipFAB().

void FArrayBox::setFormat ( FABio::Format fmt ) [static]

Set the FABio::Format in the program.

This is the preferred way to set the output format in "new" FABs. When desiging new programs, this should be the only function that needs to be called in order to set the format.

References BoxLib::Abort(), RealDescriptor::clone(), FABio::FAB_8BIT, FABio::FAB_ASCII, FABio::FAB_IEEE, FABio::FAB_IEEE_32, FABio::FAB_NATIVE, format, FPC::Ieee32NormalRealDescriptor(), FPC::NativeRealDescriptor(), and setFABio().

FABio::Format FArrayBox::getFormat ( ) [static]

Gets the FABio::Format set in the program.

References format.

void FArrayBox::setOrdering ( FABio::Ordering ordering ) [static]

Set the FABio::Ordering for reading old FABs.

It does NOT set the ordering for output. This is deprecated. It exists only to facilitate reading old FABs. When you're reading in an "old" FAB, you must set the Ordering, before attempting to read it in. This is because FABs written out in the "old" format weren't self-describing; i.e. information such as the Ordering was lost when the "old" FAB was written out.

References ordering.

Referenced by Initialize().

FABio::Ordering FArrayBox::getOrdering ( ) [static]

Gets the FABio::Ordering set in the program.

This is deprecated. It does NOT do the right thing with the new FAB I/O format.

References ordering.

void FArrayBox::setPrecision ( FABio::Precision precision ) [static]

Set the FABio::Precision.

This is deprecated. It is not useful with the "new" FAB I/O format.

FABio::Precision FArrayBox::getPrecision ( ) [static]

Returns the FABio::Precision.

This is deprecated. It is not useful with the "new" FAB I/O format. Always returns FABio::Float.

References FABio::FAB_FLOAT.

const FABio & FArrayBox::getFABio ( ) [static]

Returns reference to the FABio object used by the program.

References fabio.

void FArrayBox::setFABio ( FABio * rd ) [static]

Sets the FABio object used by the program.

It is an error if the passed pointer `rd' is the null pointer.

References BL_ASSERT, and fabio.

Referenced by Initialize(), and setFormat().

bool FArrayBox::set_do_initval ( bool tf ) [static]

References do_initval.

bool FArrayBox::get_do_initval ( ) [static]

References do_initval.

Real FArrayBox::set_initval ( Real iv ) [static]

References initval.

Real FArrayBox::get_initval ( ) [static]

References initval.

void FArrayBox::Initialize ( ) [static]

References BoxLib::Abort(), RealDescriptor::clone(), do_initval, FABio::FAB_8BIT, FABio::FAB_ASCII, FABio::FAB_IEEE, FABio::FAB_IEEE_32, FABio::FAB_NATIVE, FABio::FAB_NORMAL_ORDER, FABio::FAB_REVERSE_ORDER, FABio::FAB_REVERSE_ORDER_2, format, FPC::Ieee32NormalRealDescriptor(), initval, FPC::NativeRealDescriptor(), ParmParse::query(), setFABio(), and setOrdering().

Referenced by BoxLib::Initialize().

void FArrayBox::Finalize ( ) [static]

Referenced by BoxLib::Finalize().

template<class T>

void BaseFab< T >::clear ( ) [inline, inherited]

The function returns the `BaseFab' to the invalid state.

(See comments for constructors above.) The memory is freed.

References BaseFab< T >::domain, BaseFab< T >::dptr, BaseFab< T >::numpts, BaseFab< T >::nvar, and BaseFab< T >::undefine().

template<class T>

int BaseFab< T >::nComp ( ) const [inline, inherited]

Returns the number of components.

References BaseFab< T >::nvar.

Referenced by BaseFab< T >::copy(), BaseFab< T >::copyRev(), BoxLib::linInterpFillFab(), norm(), BaseFab< T >::norm(), operator<<(), BaseFab< T >::operator=(), BaseFab< T >::performCopy(), skipFAB(), FABio::write_header(), and writeOn().

template<class T>

const Box & BaseFab< T >::box ( ) const [inline, inherited]

Returns the domain (box) where the array is defined.

References BaseFab< T >::domain.

Referenced by BaseFab< T >::contains(), BaseFab< T >::copy(), BoxLib::linInterpFillFab(), BaseFab< T >::operator=(), BaseFab< T >::performCopy(), BaseFab< T >::setVal(), skipFAB(), and FABio::write_header().

template<class T>

const int * BaseFab< T >::length ( ) const [inline, inherited]

Returns a pointer to an array of SPACEDIM integers giving the length of the domain in each direction.

References BaseFab< T >::domain, IntVect::getVect(), and Box::length().

Referenced by BaseFab< T >::performCopy().

template<class T>

const IntVect & BaseFab< T >::smallEnd ( ) const [inline, inherited]

Returns the lower corner of the domain.

See class `Box' for analogue.

References BaseFab< T >::domain, and Box::smallEnd().

template<class T>

const IntVect & BaseFab< T >::bigEnd ( ) const [inline, inherited]

Returns the upper corner of the domain.

See class `Box' for analogue.

References Box::bigEnd(), and BaseFab< T >::domain.

template<class T>

const int * BaseFab< T >::loVect ( ) const [inline, inherited]

Returns the lower corner of the domain.

Instead of returning them in the form of INTVECT's, as in smallEnd and bigEnd, it returns the values as a pointer to an array of constant integers. This is useful when interfacing to Fortran subroutines.

References BaseFab< T >::domain, and Box::loVect().

Referenced by BaseFab< T >::performCopy().

template<class T>

const int * BaseFab< T >::hiVect ( ) const [inline, inherited]

Returns the upper corner of the domain.

Instead of returning them in the form of INTVECT's, as in smallEnd and bigEnd, it returns the values as a pointer to an array of constant integers. This is useful when interfacing to Fortran subroutines.

References BaseFab< T >::domain, and Box::hiVect().

template<class T>

bool BaseFab< T >::contains ( const BaseFab< T > & fab ) const [inline, inherited]

Returns true if the domain of fab is totally contained within the domain of this `BaseFab'.

References BaseFab< T >::box(), Box::contains(), and BaseFab< T >::nvar.

template<class T>

bool BaseFab< T >::contains ( const Box & bx ) const [inline, inherited]

Returns true if bx is totally contained within the domain of this `BaseFab'.

References BaseFab< T >::box(), and Box::contains().

template<class T>

T * BaseFab< T >::dataPtr ( int N = 0 ) [inline, inherited]

Returns a pointer to an object of type T that is the value of the Nth component associated with the cell at the low end of the domain.

This is commonly used to get a pointer to data in the array which is then handed off to a Fortran subroutine. Remember that data is stored in Fortran array order, with the component index coming last. In other words, `dataPtr' returns a pointer to all the Nth components.

References BL_ASSERT, BaseFab< T >::dptr, and BaseFab< T >::numpts.

Referenced by BaseFab< T >::maskEQ(), BaseFab< T >::maskGE(), BaseFab< T >::maskGT(), BaseFab< T >::maskLE(), BaseFab< T >::maskLT(), and BaseFab< T >::performCopy().

template<class T>

const T * BaseFab< T >::dataPtr ( int N = 0 ) const [inline, inherited]

Same as above except works on const FAB's.

References BL_ASSERT, BaseFab< T >::dptr, and BaseFab< T >::numpts.

template<class T>

bool BaseFab< T >::isAllocated ( ) const [inline, inherited]

Returns true if the data for the FAB has been allocated.

References BaseFab< T >::dptr.

template<class T>

T & BaseFab< T >::operator()	(	const IntVect &	p,
		int	N
	)			`[inline, inherited]`

Returns a reference to the Nth component value defined at position p in the domain.

This operator may be inefficient if the C++ compiler is unable to optimize the C++ code.

References BL_ASSERT, Box::contains(), BaseFab< T >::domain, BaseFab< T >::dptr, Box::index(), BaseFab< T >::numpts, and BaseFab< T >::nvar.

template<class T>

T & BaseFab< T >::operator() ( const IntVect & p ) [inline, inherited]

Same as above, except returns component 0.

References BL_ASSERT, Box::contains(), BaseFab< T >::domain, BaseFab< T >::dptr, and Box::index().

template<class T>

const T & BaseFab< T >::operator()	(	const IntVect &	p,
		int	N
	)			const `[inline, inherited]`

Same as above except works on const FAB's.

References BL_ASSERT, Box::contains(), BaseFab< T >::domain, BaseFab< T >::dptr, Box::index(), BaseFab< T >::numpts, and BaseFab< T >::nvar.

template<class T>

const T & BaseFab< T >::operator() ( const IntVect & p ) const [inline, inherited]

Same as above, except returns component 0.

References BL_ASSERT, Box::contains(), BaseFab< T >::domain, BaseFab< T >::dptr, and Box::index().

template<class T>

void BaseFab< T >::getVal	(	T *	data,
		const IntVect &	pos,
		int	N,
		int	numcomp
	)			const `[inline, inherited]`

This function puts numcomp component values, starting at component N, from position pos in the domain into array data, that must be allocated by the user.

References BL_ASSERT, BaseFab< T >::domain, BaseFab< T >::dptr, Box::index(), Box::numPts(), and BaseFab< T >::nvar.

Referenced by BaseFab< T >::getVal().

template<class T>

void BaseFab< T >::getVal	(	T *	data,
		const IntVect &	pos
	)			const `[inline, inherited]`

Same as above, except that starts at component 0 and copies ALL comps.

References BaseFab< T >::getVal(), and BaseFab< T >::nvar.

template<class T>

void BaseFab< T >::setVal	(	T	x,
		const Box &	bx,
		int	nstart,
		int	ncomp
	)			`[inline, inherited]`

The setVal functions set subregions in the `BaseFab' to a constant value.

This most general form specifies the sub-box, the starting component number, and the number of components to be set.

References BaseFab< T >::performSetVal().

Referenced by FArrayBox(), BaseFab< T >::maskEQ(), BaseFab< T >::maskGE(), BaseFab< T >::maskGT(), BaseFab< T >::maskLE(), BaseFab< T >::maskLT(), BaseFab< T >::operator=(), and resize().

template<class T>

void BaseFab< T >::setVal	(	T	x,
		const Box &	bx,
		int	N
	)			`[inline, inherited]`

Same as above, except the number of modified components is one.

N is the component to be modified.

References BaseFab< T >::performSetVal().

template<class T>

void BaseFab< T >::setVal	(	T	x,
		int	N
	)			`[inline, inherited]`

Same as above, except the subbox defaults to the entire domain.

References BaseFab< T >::domain, and BaseFab< T >::performSetVal().

template<class T>

void BaseFab< T >::setVal ( T x ) [inline, inherited]

Same as above, except ALL components are set.

References BaseFab< T >::box(), BaseFab< T >::nvar, and BaseFab< T >::performSetVal().

template<class T>

void BaseFab< T >::setComplement	(	T	x,
		const Box &	b,
		int	ns,
		int	num
	)			`[inline, inherited]`

This function is analogous to the fourth form of setVal above, except that instead of setting values on the `Box' b, values are set on the complement of b in the domain.

References BoxList::begin(), BoxLib::boxDiff(), BaseFab< T >::domain, BoxList::end(), and BaseFab< T >::performSetVal().

Referenced by VisMF::Write().

template<class T>

BaseFab< T > & BaseFab< T >::copy	(	const BaseFab< T > &	src,
		const Box &	srcbox,
		int	srccomp,
		const Box &	destbox,
		int	destcomp,
		int	numcomp
	)			`[inline, inherited]`

The `copy' functions copy the contents of one `BaseFab' into another.

The destination `BaseFab' is always the object which invokes the function. This, the most general form of copy, specifies the contents of any sub-box srcbox in `BaseFab' src may be copied into a (possibly different) destbox in the destination `BaseFab'. Note that although the srcbox and the destbox may be disjoint, they must be the same size and shape. If the sizes differ, the copy is undefined and a runtime error results. This copy function is the only one of the copy functions to allow a copy between differing boxes. The user also specifies how many components are copied, starting at component srccomp in src and stored starting at component destcomp. Note that the actual copy is made by the function `performCopy' of this class. The results are UNDEFINED if the src and dest are the same and the srcbox and destbox overlap.

References BL_ASSERT, BaseFab< T >::box(), Box::contains(), BaseFab< T >::domain, BoxLib::Error(), BaseFab< T >::nComp(), BaseFab< T >::nvar, BaseFab< T >::performCopy(), and Box::sameSize().

template<class T>

BaseFab< T > & BaseFab< T >::copy	(	const BaseFab< T > &	src,
		int	srccomp,
		int	destcomp,
		int	numcomp = `1`
	)			`[inline, inherited]`

As above, except the destination `Box' and the source `Box' are taken to be the entire domain of the destination.

A copy of the intersecting region is performed. Note that the actual copy is made by the function `performCopy' of this class.

References BL_ASSERT, BaseFab< T >::domain, BaseFab< T >::nvar, Box::ok(), and BaseFab< T >::performCopy().

template<class T>

BaseFab< T > & BaseFab< T >::copy	(	const BaseFab< T > &	src,
		const Box &	destbox
	)			`[inline, inherited]`

As above, except that the destination `Box' is specified, but the source `Box' is taken to the equal to the source `Box', and all components of the destination `BaseFab' are copied.

Note that the actual copy is made by the function `performCopy' of this class.

References BL_ASSERT, Box::contains(), BaseFab< T >::domain, BaseFab< T >::nvar, and BaseFab< T >::performCopy().

template<class T>

BaseFab< T > & BaseFab< T >::copy ( const BaseFab< T > & src ) [inline, inherited]

As above, except that the destbox defaults to the entire domain of the destination BaseFab, and all components are copied.

Note that the actual copy is made by the function `performCopy' of this class.

References BL_ASSERT, BaseFab< T >::domain, BaseFab< T >::nvar, BaseFab< T >::performCopy(), and Box::sameType().

template<class T>

BaseFab< T > & BaseFab< T >::shift ( const IntVect & v ) [inline, inherited]

Perform shifts upon the domain of the `BaseFab'.

They are completely analogous to the corresponding `Box' functions. There is no effect upon the array memory.

References BaseFab< T >::domain.

template<class T>

BaseFab< T > & BaseFab< T >::shift	(	int	idir,
		int	n_cell
	)			`[inline, inherited]`

Perform shifts upon the domain of the `BaseFab'.

They are completely analogous to the corresponding `Box' functions. There is no effect upon the array memory.

References BaseFab< T >::domain, and Box::shift().

template<class T>

BaseFab< T > & BaseFab< T >::shiftHalf	(	int	dir,
		int	num_halfs
	)			`[inline, inherited]`

Perform shifts upon the domain of the `BaseFab'.

They are completely analogous to the corresponding `Box' functions. There is no effect upon the array memory.

References BaseFab< T >::domain, and Box::shiftHalf().

template<class T>

BaseFab< T > & BaseFab< T >::shiftHalf ( const IntVect & num_halfs ) [inline, inherited]

Perform shifts upon the domain of the `BaseFab'.

They are completely analogous to the corresponding `Box' functions. There is no effect upon the array memory.

References BaseFab< T >::domain, and Box::shiftHalf().

template<class T>

void BaseFab< T >::abs ( ) [inline, inherited]

Compute absolute value for all components of this FAB.

References ForAllThis.

template<class T>

void BaseFab< T >::abs	(	int	comp,
		int	numcomp = `1`
	)			`[inline, inherited]`

Same as above except only for components (comp: comp+numcomp-1).

References ForAllThisNN.

template<class T>

void BaseFab< T >::abs	(	const Box &	subbox,
		int	comp = `0`,
		int	numcomp = `1`
	)			`[inline, inherited]`

Calculate abs() on subbox for given component range.

template<class T>

T BaseFab< T >::min ( int comp = 0 ) const [inline, inherited]

Minimum value of given component.

References BaseFab< T >::domain, and BoxLib::min().

template<class T>

T BaseFab< T >::min	(	const Box &	subbox,
		int	comp = `0`
	)			const `[inline, inherited]`

Minimum value of given component in given subbox.

References BoxLib::min().

template<class T>

T BaseFab< T >::max ( int comp = 0 ) const [inline, inherited]

Maximum value of given component.

References BaseFab< T >::domain, and BoxLib::max().

template<class T>

T BaseFab< T >::max	(	const Box &	subbox,
		int	comp = `0`
	)			const `[inline, inherited]`

Maximum value of given component in given subbox.

References BoxLib::max().

template<class T>

IntVect BaseFab< T >::minIndex ( int comp = 0 ) const [inline, inherited]

Find location of minimum value in given component.

References BaseFab< T >::domain, and Box::smallEnd().

template<class T>

IntVect BaseFab< T >::minIndex	(	const Box &	subbox,
		int	comp = `0`
	)			const `[inline, inherited]`

Find location of minimum value in given component in given subbox.

References Box::smallEnd().

template<class T>

IntVect BaseFab< T >::maxIndex ( int comp = 0 ) const [inline, inherited]

Find location of maximum value in given component.

References BaseFab< T >::domain, and Box::smallEnd().

template<class T>

IntVect BaseFab< T >::maxIndex	(	const Box &	subbox,
		int	comp = `0`
	)			const `[inline, inherited]`

Find location of maximum value in given component in given subbox.

References Box::smallEnd().

template<class T>

int BaseFab< T >::maskLT	(	BaseFab< int > &	mask,
		T	val,
		int	comp = `0`
	)			const `[inline, inherited]`

Compute mask array with value of 1 in cells where BaseFab has value less than val, 0 otherwise.

mask is resized by this function. The number of cells marked with 1 returned.

References BaseFab< T >::dataPtr(), BaseFab< T >::domain, BaseFab< T >::resize(), and BaseFab< T >::setVal().

template<class T>

int BaseFab< T >::maskLE	(	BaseFab< int > &	mask,
		T	val,
		int	comp = `0`
	)			const `[inline, inherited]`

Same as above except mark cells with value less than or equal to val.

References BaseFab< T >::dataPtr(), BaseFab< T >::domain, BaseFab< T >::resize(), and BaseFab< T >::setVal().

template<class T>

int BaseFab< T >::maskEQ	(	BaseFab< int > &	mask,
		T	val,
		int	comp = `0`
	)			const `[inline, inherited]`

Same as above except mark cells with value equal to val.

References BaseFab< T >::dataPtr(), BaseFab< T >::domain, BaseFab< T >::resize(), and BaseFab< T >::setVal().

template<class T>

int BaseFab< T >::maskGT	(	BaseFab< int > &	mask,
		T	val,
		int	comp = `0`
	)			const `[inline, inherited]`

Same as above except mark cells with value greater than val.

References BaseFab< T >::dataPtr(), BaseFab< T >::domain, BaseFab< T >::resize(), and BaseFab< T >::setVal().

template<class T>

int BaseFab< T >::maskGE	(	BaseFab< int > &	mask,
		T	val,
		int	comp = `0`
	)			const `[inline, inherited]`

Same as above except mark cells with value greater than or equal to val.

References BaseFab< T >::dataPtr(), BaseFab< T >::domain, BaseFab< T >::resize(), and BaseFab< T >::setVal().

template<class T>

void BaseFab< T >::patternFill ( int mark = 0 ) [inline, inherited]

Fill with a pattern of numbers.

References ForAllThis.

template<class T>

void BaseFab< T >::copyRev	(	const Box &	destbox,
		const BaseFab< T > &	src,
		const Box &	srcbox,
		int	reversal_index,
		T *	multiplier
	)			`[inline, inherited]`

Copies with index reversal from srcbox region of src into destbox region of this FAB.

All components are copied and multiplied by corresponding multiplier.

References BaseFab< T >::nComp().

template<class T>

T BaseFab< T >::sum	(	int	comp,
		int	numcomp = `1`
	)			const `[inline, inherited]`

Compute sum of given component of FAB state vector.

References BaseFab< T >::domain.

template<class T>

T BaseFab< T >::sum	(	const Box &	subbox,
		int	comp,
		int	numcomp = `1`
	)			const `[inline, inherited]`

Compute sum of given component of FAB state vector in given subbox.

template<class T>

BaseFab< T > & BaseFab< T >::invert	(	T	v,
		const Box &	subbox,
		int	comp = `0`,
		int	numcomp = `1`
	)			`[inline, inherited]`

Most general version, specify subbox and which components.

template<class T>

BaseFab< T > & BaseFab< T >::invert	(	T	v,
		int	comp,
		int	numcomp = `1`
	)			`[inline, inherited]`

As above except on entire domain.

References ForAllThisNN.

template<class T>

BaseFab< T > & BaseFab< T >::invert ( T v ) [inline, inherited]

As above except on entire domain, all components.

References ForAllThis.

template<class T>

BaseFab< T > & BaseFab< T >::negate	(	const Box &	subbox,
		int	comp = `0`,
		int	numcomp = `1`
	)			`[inline, inherited]`

Negate BaseFab, most general.

template<class T>

BaseFab< T > & BaseFab< T >::negate	(	int	comp,
		int	numcomp = `1`
	)			`[inline, inherited]`

As above, except on entire domain.

References ForAllThisNN.

template<class T>

BaseFab< T > & BaseFab< T >::negate ( ) [inline, inherited]

As above, except on entire domain and all components.

References ForAllThis.

template<class T>

BaseFab< T > & BaseFab< T >::plus	(	T	r,
		const Box &	b,
		int	comp = `0`,
		int	numcomp = `1`
	)			`[inline, inherited]`

Scalar addition (a[i] <- a[i] + r), most general.

template<class T>

BaseFab< T > & BaseFab< T >::plus	(	T	r,
		int	comp,
		int	numcomp = `1`
	)			`[inline, inherited]`

As above, except on entire domain.

References ForAllThisNN.

template<class T>

BaseFab< T > & BaseFab< T >::plus ( T r ) [inline, inherited]

As above, except on entire domain and all components.

References BaseFab< T >::operator+=().

template<class T>

BaseFab< T > & BaseFab< T >::plus ( const BaseFab< T > & src ) [inline, inherited]

FAB addition (a[i] <- a[i] + b[i]). The same as += operator.

References BaseFab< T >::operator+=().

template<class T>

BaseFab< T > & BaseFab< T >::plus	(	const BaseFab< T > &	src,
		int	srccomp,
		int	destcomp,
		int	numcomp = `1`
	)			`[inline, inherited]`

Add src components (srccomp:srccomp+numcomp-1) to this FAB's components (destcomp:destcomp+numcomp-1) where the two FABs intersect.

References BaseFab< T >::domain.

template<class T>

BaseFab< T > & BaseFab< T >::plus	(	const BaseFab< T > &	src,
		const Box &	subbox,
		int	srccomp,
		int	destcomp,
		int	numcomp = `1`
	)			`[inline, inherited]`

Same as above except addition is restricted to intersection of subbox and src FAB.

NOTE: subbox must be contained in this FAB.

template<class T>

BaseFab< T > & BaseFab< T >::plus	(	const BaseFab< T > &	src,
		const Box &	srcbox,
		const Box &	destbox,
		int	srccomp,
		int	destcomp,
		int	numcomp = `1`
	)			`[inline, inherited]`

Add srcbox region of src FAB to destbox region of this FAB.

The srcbox and destbox must be same size.

template<class T>

BaseFab< T > & BaseFab< T >::operator+= ( T r ) [inline, inherited]

Addition in place.

This will often be more efficient than making new BaseFab for result.

References ForAllThis.

Referenced by BaseFab< T >::operator-=(), and BaseFab< T >::plus().

template<class T>

BaseFab< T > & BaseFab< T >::operator+= ( const BaseFab< T > & f ) [inline, inherited]

FAB addition (a[i] <- a[i] + b[i]) in place.

References ForAllThisXC.

template<class T>

BaseFab< T > & BaseFab< T >::operator-= ( T r ) [inline, inherited]

Scalar subtraction (a[i] <- a[i] - r).

Note: use plus(-r) for more general operations.

References BaseFab< T >::operator+=().

Referenced by BaseFab< T >::minus().

template<class T>

BaseFab< T > & BaseFab< T >::operator-= ( const BaseFab< T > & f ) [inline, inherited]

FAB subtraction (a[i] <- a[i] - b[i]), in place.

References ForAllThisXC.

template<class T>

BaseFab< T > & BaseFab< T >::minus ( const BaseFab< T > & src ) [inline, inherited]

FAB subtraction (a[i] <- a[i] - b[i]). The same as -= operator.

References BaseFab< T >::operator-=().

template<class T>

BaseFab< T > & BaseFab< T >::minus	(	const BaseFab< T > &	src,
		int	srccomp,
		int	destcomp,
		int	numcomp = `1`
	)			`[inline, inherited]`

Subtract src components (srccomp:srccomp+numcomp-1) to this FAB's components (destcomp:destcomp+numcomp-1) where the two FABs intersect.

References BaseFab< T >::domain.

template<class T>

BaseFab< T > & BaseFab< T >::minus	(	const BaseFab< T > &	src,
		const Box &	subbox,
		int	srccomp,
		int	destcomp,
		int	numcomp = `1`
	)			`[inline, inherited]`

Same as above except subtraction is restricted to intersection of subbox and src FAB.

NOTE: subbox must be contained in this FAB.

template<class T>

BaseFab< T > & BaseFab< T >::minus	(	const BaseFab< T > &	src,
		const Box &	srcbox,
		const Box &	destbox,
		int	srccomp,
		int	destcomp,
		int	numcomp = `1`
	)			`[inline, inherited]`

Subtract srcbox region of src FAB from destbox region of this FAB.

srcbox and destbox must be same size.

template<class T>

BaseFab< T > & BaseFab< T >::operator*= ( T r ) [inline, inherited]

Scalar multiplication (a[i] <- a[i] * r), in place.

References ForAllThis.

Referenced by BaseFab< T >::mult().

template<class T>

BaseFab< T > & BaseFab< T >::operator*= ( const BaseFab< T > & f ) [inline, inherited]

FAB multiplication (a[i] <- a[i] * b[i]), in place.

References ForAllThisXC.

template<class T>

BaseFab< T > & BaseFab< T >::mult ( T r ) [inline, inherited]

Scalar multiplication (a[i] <- a[i] * r). The same as *=.

References BaseFab< T >::operator*=().

template<class T>

BaseFab< T > & BaseFab< T >::mult	(	T	r,
		int	comp,
		int	numcomp = `1`
	)			`[inline, inherited]`

Scalar multiplication, except control which components are multiplied.

References ForAllThisNN.

template<class T>

BaseFab< T > & BaseFab< T >::mult	(	T	r,
		const Box &	b,
		int	comp = `0`,
		int	numcomp = `1`
	)			`[inline, inherited]`

As above, except specify sub-box.

template<class T>

BaseFab< T > & BaseFab< T >::mult ( const BaseFab< T > & src ) [inline, inherited]

As above.

References BaseFab< T >::operator*=().

template<class T>

BaseFab< T > & BaseFab< T >::mult	(	const BaseFab< T > &	src,
		int	srccomp,
		int	destcomp,
		int	numcomp = `1`
	)			`[inline, inherited]`

Multiply src components (srccomp:srccomp+numcomp-1) with this FAB's components (destcomp:destcomp+numcomp-1) where the two FABs intersect.

References BaseFab< T >::domain.

template<class T>

BaseFab< T > & BaseFab< T >::mult	(	const BaseFab< T > &	src,
		const Box &	subbox,
		int	srccomp,
		int	destcomp,
		int	numcomp = `1`
	)			`[inline, inherited]`

Same as above except multiplication is restricted to intersection of subbox and src FAB.

NOTE: subbox must be contained in this FAB.

template<class T>

BaseFab< T > & BaseFab< T >::mult	(	const BaseFab< T > &	src,
		const Box &	srcbox,
		const Box &	destbox,
		int	srccomp,
		int	destcomp,
		int	numcomp = `1`
	)			`[inline, inherited]`

Multiply srcbox region of src FAB with destbox region of this FAB.

The srcbox and destbox must be same size.

template<class T>

BaseFab< T > & BaseFab< T >::operator/= ( T r ) [inline, inherited]

Scalar division (a[i] <- a[i] / r), in place.

References ForAllThis.

Referenced by BaseFab< T >::divide().

template<class T>

BaseFab< T > & BaseFab< T >::operator/= ( const BaseFab< T > & src ) [inline, inherited]

FAB division, in place.

References ForAllThisXC.

template<class T>

BaseFab< T > & BaseFab< T >::divide ( T r ) [inline, inherited]

Scalar division (a[i] <- a[i] / r), in place.

References BaseFab< T >::operator/=().

template<class T>

BaseFab< T > & BaseFab< T >::divide	(	T	r,
		int	comp,
		int	numcomp = `1`
	)			`[inline, inherited]`

As above except specify which components.

References ForAllThisNN.

template<class T>

BaseFab< T > & BaseFab< T >::divide	(	T	r,
		const Box &	b,
		int	comp = `0`,
		int	numcomp = `1`
	)			`[inline, inherited]`

As above except specify sub-box.

template<class T>

BaseFab< T > & BaseFab< T >::divide ( const BaseFab< T > & src ) [inline, inherited]

Same as above.

References BaseFab< T >::operator/=().

template<class T>

BaseFab< T > & BaseFab< T >::divide	(	const BaseFab< T > &	src,
		int	srccomp,
		int	destcomp,
		int	numcomp = `1`
	)			`[inline, inherited]`

This FAB is numerator, src FAB is denominator divide src components (srccomp:srccomp+numcomp-1) into this FAB's components (destcomp:destcomp+numcomp-1) where the two FABs intersect.

References BaseFab< T >::domain.

template<class T>

BaseFab< T > & BaseFab< T >::divide	(	const BaseFab< T > &	src,
		const Box &	subbox,
		int	srccomp,
		int	destcomp,
		int	numcomp = `1`
	)			`[inline, inherited]`

Same as above except division is restricted to intersection of subbox and src FAB.

NOTE: subbox must be contained in this FAB.

template<class T>

BaseFab< T > & BaseFab< T >::divide	(	const BaseFab< T > &	src,
		const Box &	srcbox,
		const Box &	destbox,
		int	srccomp,
		int	destcomp,
		int	numcomp = `1`
	)			`[inline, inherited]`

destbox region of this FAB is numerator.

srcbox regions of src FAB is denominator. srcbox and destbox must be same size.

template<class T>

BaseFab< T > & BaseFab< T >::linInterp	(	const BaseFab< T > &	f1,
		const Box &	b1,
		int	comp1,
		const BaseFab< T > &	f2,
		const Box &	b2,
		int	comp2,
		Real	t1,
		Real	t2,
		Real	t,
		const Box &	b,
		int	comp,
		int	numcomp = `1`
	)			`[inline, inherited]`

Linear interpolation / extrapolation.

Result is (t2-t)/(t2-t1)*f1 + (t-t1)/(t2-t1)*f2 Data is taken from b1 region of f1, b2 region of f2 and stored in b region of this FAB. Boxes b, b1 and b2 must be the same size. Data is taken from component comp1 of f1, comp2 of f2, and stored in component comp of this FAB. This FAB is returned as a reference for chaining.

Referenced by BoxLib::linInterpFillFab().

template<class T>

BaseFab< T > & BaseFab< T >::linComb	(	const BaseFab< T > &	f1,
		const Box &	b1,
		int	comp1,
		const BaseFab< T > &	f2,
		const Box &	b2,
		int	comp2,
		Real	alpha,
		Real	beta,
		const Box &	b,
		int	comp,
		int	numcomp = `1`
	)			`[inline, inherited]`

Linear combination.

Result is alpha*f1 + beta*f2. Data is taken from b1 region of f1, b2 region of f2 and stored in b region of this FAB. Boxes b, b1 and b2 must be the same size. Data is taken from component comp1 of f1, comp2 of f2, and stored in component comp of this FAB. This FAB is returned as a reference for chaining.

template<class T>

void BaseFab< T >::define ( ) [inline, protected, inherited]

References Arena::alloc(), BL_ASSERT, BaseFab< T >::dptr, BaseFab< T >::numpts, BaseFab< T >::nvar, BoxLib::The_Arena(), and BaseFab< T >::truesize.

Referenced by BaseFab< T >::BaseFab(), BaseFab< T >::operator=(), and BaseFab< T >::resize().

template<class T>

void BaseFab< T >::undefine ( ) [inline, protected, inherited]

References BaseFab< T >::dptr, Arena::free(), BoxLib::The_Arena(), and BaseFab< T >::truesize.

Referenced by BaseFab< T >::clear(), BaseFab< T >::resize(), and BaseFab< T >::~BaseFab().

template<class T>

void BaseFab< T >::performCopy	(	const BaseFab< T > &	src,
		const Box &	srcbox,
		int	srccomp,
		const Box &	destbox,
		int	destcomp,
		int	numcomp
	)			`[inline, protected, inherited]`

References BL_ASSERT, BaseFab< T >::box(), Box::contains(), BaseFab< T >::dataPtr(), BoxLib::Error(), IntVect::getVect(), Box::length(), BaseFab< T >::length(), Box::loVect(), BaseFab< T >::loVect(), BaseFab< T >::nComp(), Box::ok(), and Box::sameSize().

Referenced by BaseFab< T >::copy().

template<class T>

void BaseFab< T >::performSetVal	(	T	x,
		const Box &	bx,
		int	nstart,
		int	numcomp
	)			`[inline, protected, inherited]`

References BL_ASSERT, Box::contains(), BaseFab< T >::domain, BaseFab< T >::dptr, BaseFab< T >::numpts, and BaseFab< T >::nvar.

Referenced by BaseFab< T >::setComplement(), and BaseFab< T >::setVal().

Friends And Related Function Documentation

friend class FABio [friend]

std::ostream& operator<<	(	std::ostream &	os,
		const FArrayBox &	fb
	)			`[friend]`

Write FABs in ASCII form.

std::istream& operator>>	(	std::istream &	is,
		FArrayBox &	fb
	)			`[friend]`

Read FABs in ASCII form.

Member Data Documentation

FABio::Format FArrayBox::format = FABio::FAB_NATIVE [static, protected]

Referenced by getFormat(), Initialize(), and setFormat().

FABio::Ordering FArrayBox::ordering = FABio::FAB_NORMAL_ORDER [static, protected]

Referenced by getOrdering(), FABio::read_header(), and setOrdering().

FABio * FArrayBox::fabio = new FABio_binary(FPC::NativeRealDescriptor().clone()) [static, protected]

Referenced by getFABio(), setFABio(), and writeOn().

bool FArrayBox::do_initval = true [static, protected]

Referenced by FArrayBox(), get_do_initval(), Initialize(), resize(), and set_do_initval().

Real FArrayBox::initval [static, protected]

Initial value:

    std::numeric_limits<Real>::has_quiet_NaN
  ? std::numeric_limits<Real>::quiet_NaN()
  : std::numeric_limits<Real>::max()

Referenced by FArrayBox(), get_initval(), Initialize(), resize(), and set_initval().

template<class T>

Box BaseFab< T >::domain [protected, inherited]

template<class T>

int BaseFab< T >::nvar [protected, inherited]

Referenced by BaseFab< T >::BaseFab(), BaseFab< T >::clear(), BaseFab< T >::contains(), BaseFab< T >::copy(), BaseFab< T >::define(), BaseFab< T >::getVal(), BaseFab< T >::nComp(), BaseFab< T >::operator()(), BaseFab< T >::operator=(), BaseFab< T >::performSetVal(), BaseFab< T >::resize(), and BaseFab< T >::setVal().

template<class T>

long BaseFab< T >::numpts [protected, inherited]

Referenced by BaseFab< T >::BaseFab(), BaseFab< T >::clear(), BaseFab< T >::dataPtr(), BaseFab< T >::define(), BaseFab< T >::operator()(), BaseFab< T >::operator=(), BaseFab< T >::performSetVal(), and BaseFab< T >::resize().

template<class T>

long BaseFab< T >::truesize [protected, inherited]

Referenced by BaseFab< T >::define(), BaseFab< T >::resize(), and BaseFab< T >::undefine().

template<class T>

T* BaseFab< T >::dptr [protected, inherited]

Referenced by BaseFab< T >::BaseFab(), BaseFab< T >::clear(), BaseFab< T >::dataPtr(), BaseFab< T >::define(), BaseFab< T >::getVal(), BaseFab< T >::isAllocated(), BaseFab< T >::operator()(), BaseFab< T >::operator=(), BaseFab< T >::performSetVal(), BaseFab< T >::resize(), and BaseFab< T >::undefine().

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


Public Types
typedef T	value_type
Public Member Functions
	FArrayBox ()
	Construct an invalid FAB with no memory.
	FArrayBox (const Box &b, int ncomp=1)
	Construct an initial FAB with the data space allocated but not inititialized.
	FArrayBox (const FArrayBox &)
FArrayBox &	operator= (const FArrayBox &)
FArrayBox &	operator= (const Real &r)
	~FArrayBox ()
	The destructor.
void	resize (const Box &b, int N=1)
	This function resizes a `BaseFab' so it covers the `Box' B with N components.
Real	norm (int p=2, int scomp=0, int ncomp=1) const
	Compute the Lp-norm of this FAB using components (scomp : scomp+ncomp-1).
Real	norm (const Box &subbox, int p=2, int scomp=0, int ncomp=1) const
	Same as above except only on given subbox.
void	writeOn (std::ostream &of) const
	Writes out the FAB in whatever format you've set.
void	writeOn (std::ostream &of, int comp, int num_comp=1) const
	Write only selected range of components.
void	readFrom (std::istream &is)
	Read FAB from istream. Format is as it was written out.
int	readFrom (std::istream &is, int compIndex)
	Read FAB from istream.
void	clear ()
	The function returns the `BaseFab' to the invalid state.
int	nComp () const
	Returns the number of components.
const Box &	box () const
	Returns the domain (box) where the array is defined.
const int *	length () const
	Returns a pointer to an array of SPACEDIM integers giving the length of the domain in each direction.
const IntVect &	smallEnd () const
	Returns the lower corner of the domain.
const IntVect &	bigEnd () const
	Returns the upper corner of the domain.
const int *	loVect () const
	Returns the lower corner of the domain.
const int *	hiVect () const
	Returns the upper corner of the domain.
bool	contains (const BaseFab< T > &fab) const
	Returns true if the domain of fab is totally contained within the domain of this `BaseFab'.
bool	contains (const Box &bx) const
	Returns true if bx is totally contained within the domain of this `BaseFab'.
T *	dataPtr (int N=0)
	Returns a pointer to an object of type T that is the value of the Nth component associated with the cell at the low end of the domain.
const T *	dataPtr (int N=0) const
	Same as above except works on const FAB's.
bool	isAllocated () const
	Returns true if the data for the FAB has been allocated.
T &	operator() (const IntVect &p, int N)
	Returns a reference to the Nth component value defined at position p in the domain.
T &	operator() (const IntVect &p)
	Same as above, except returns component 0.
const T &	operator() (const IntVect &p, int N) const
	Same as above except works on const FAB's.
const T &	operator() (const IntVect &p) const
	Same as above, except returns component 0.
void	getVal (T *data, const IntVect &pos, int N, int numcomp) const
	This function puts numcomp component values, starting at component N, from position pos in the domain into array data, that must be allocated by the user.
void	getVal (T *data, const IntVect &pos) const
	Same as above, except that starts at component 0 and copies ALL comps.
void	setVal (T x, const Box &bx, int nstart, int ncomp)
	The setVal functions set subregions in the `BaseFab' to a constant value.
void	setVal (T x, const Box &bx, int N)
	Same as above, except the number of modified components is one.
void	setVal (T x, int N)
	Same as above, except the subbox defaults to the entire domain.
void	setVal (T x)
	Same as above, except ALL components are set.
void	setComplement (T x, const Box &b, int ns, int num)
	This function is analogous to the fourth form of setVal above, except that instead of setting values on the `Box' b, values are set on the complement of b in the domain.
BaseFab< T > &	copy (const BaseFab< T > &src, const Box &srcbox, int srccomp, const Box &destbox, int destcomp, int numcomp)
	The `copy' functions copy the contents of one `BaseFab' into another.
BaseFab< T > &	copy (const BaseFab< T > &src, int srccomp, int destcomp, int numcomp=1)
	As above, except the destination `Box' and the source `Box' are taken to be the entire domain of the destination.
BaseFab< T > &	copy (const BaseFab< T > &src, const Box &destbox)
	As above, except that the destination `Box' is specified, but the source `Box' is taken to the equal to the source `Box', and all components of the destination `BaseFab' are copied.
BaseFab< T > &	copy (const BaseFab< T > &src)
	As above, except that the destbox defaults to the entire domain of the destination BaseFab, and all components are copied.
BaseFab< T > &	shift (const IntVect &v)
	Perform shifts upon the domain of the `BaseFab'.
BaseFab< T > &	shift (int idir, int n_cell)
	Perform shifts upon the domain of the `BaseFab'.
BaseFab< T > &	shiftHalf (int dir, int num_halfs)
	Perform shifts upon the domain of the `BaseFab'.
BaseFab< T > &	shiftHalf (const IntVect &num_halfs)
	Perform shifts upon the domain of the `BaseFab'.
void	abs ()
	Compute absolute value for all components of this FAB.
void	abs (int comp, int numcomp=1)
	Same as above except only for components (comp: comp+numcomp-1).
void	abs (const Box &subbox, int comp=0, int numcomp=1)
	Calculate abs() on subbox for given component range.
T	min (int comp=0) const
	Minimum value of given component.
T	min (const Box &subbox, int comp=0) const
	Minimum value of given component in given subbox.
T	max (int comp=0) const
	Maximum value of given component.
T	max (const Box &subbox, int comp=0) const
	Maximum value of given component in given subbox.
IntVect	minIndex (int comp=0) const
	Find location of minimum value in given component.
IntVect	minIndex (const Box &subbox, int comp=0) const
	Find location of minimum value in given component in given subbox.
IntVect	maxIndex (int comp=0) const
	Find location of maximum value in given component.
IntVect	maxIndex (const Box &subbox, int comp=0) const
	Find location of maximum value in given component in given subbox.
int	maskLT (BaseFab< int > &mask, T val, int comp=0) const
	Compute mask array with value of 1 in cells where BaseFab has value less than val, 0 otherwise.
int	maskLE (BaseFab< int > &mask, T val, int comp=0) const
	Same as above except mark cells with value less than or equal to val.
int	maskEQ (BaseFab< int > &mask, T val, int comp=0) const
	Same as above except mark cells with value equal to val.
int	maskGT (BaseFab< int > &mask, T val, int comp=0) const
	Same as above except mark cells with value greater than val.
int	maskGE (BaseFab< int > &mask, T val, int comp=0) const
	Same as above except mark cells with value greater than or equal to val.
void	patternFill (int mark=0)
	Fill with a pattern of numbers.
void	copyRev (const Box &destbox, const BaseFab< T > &src, const Box &srcbox, int reversal_index, T *multiplier)
	Copies with index reversal from srcbox region of src into destbox region of this FAB.
T	sum (int comp, int numcomp=1) const
	Compute sum of given component of FAB state vector.
T	sum (const Box &subbox, int comp, int numcomp=1) const
	Compute sum of given component of FAB state vector in given subbox.
BaseFab< T > &	invert (T v, const Box &subbox, int comp=0, int numcomp=1)
	Most general version, specify subbox and which components.
BaseFab< T > &	invert (T v, int comp, int numcomp=1)
	As above except on entire domain.
BaseFab< T > &	invert (T v)
	As above except on entire domain, all components.
BaseFab< T > &	negate (const Box &subbox, int comp=0, int numcomp=1)
	Negate BaseFab, most general.
BaseFab< T > &	negate (int comp, int numcomp=1)
	As above, except on entire domain.
BaseFab< T > &	negate ()
	As above, except on entire domain and all components.
BaseFab< T > &	plus (T r, const Box &b, int comp=0, int numcomp=1)
	Scalar addition (a[i] <- a[i] + r), most general.
BaseFab< T > &	plus (T r, int comp, int numcomp=1)
	As above, except on entire domain.
BaseFab< T > &	plus (T r)
	As above, except on entire domain and all components.
BaseFab< T > &	plus (const BaseFab< T > &src)
	FAB addition (a[i] <- a[i] + b[i]). The same as += operator.
BaseFab< T > &	plus (const BaseFab< T > &src, int srccomp, int destcomp, int numcomp=1)
	Add src components (srccomp:srccomp+numcomp-1) to this FAB's components (destcomp:destcomp+numcomp-1) where the two FABs intersect.
BaseFab< T > &	plus (const BaseFab< T > &src, const Box &subbox, int srccomp, int destcomp, int numcomp=1)
	Same as above except addition is restricted to intersection of subbox and src FAB.
BaseFab< T > &	plus (const BaseFab< T > &src, const Box &srcbox, const Box &destbox, int srccomp, int destcomp, int numcomp=1)
	Add srcbox region of src FAB to destbox region of this FAB.
BaseFab< T > &	operator+= (T r)
	Addition in place.
BaseFab< T > &	operator+= (const BaseFab< T > &f)
	FAB addition (a[i] <- a[i] + b[i]) in place.
BaseFab< T > &	operator-= (T r)
	Scalar subtraction (a[i] <- a[i] - r).
BaseFab< T > &	operator-= (const BaseFab< T > &f)
	FAB subtraction (a[i] <- a[i] - b[i]), in place.
BaseFab< T > &	minus (const BaseFab< T > &src)
	FAB subtraction (a[i] <- a[i] - b[i]). The same as -= operator.
BaseFab< T > &	minus (const BaseFab< T > &src, int srccomp, int destcomp, int numcomp=1)
	Subtract src components (srccomp:srccomp+numcomp-1) to this FAB's components (destcomp:destcomp+numcomp-1) where the two FABs intersect.
BaseFab< T > &	minus (const BaseFab< T > &src, const Box &subbox, int srccomp, int destcomp, int numcomp=1)
	Same as above except subtraction is restricted to intersection of subbox and src FAB.
BaseFab< T > &	minus (const BaseFab< T > &src, const Box &srcbox, const Box &destbox, int srccomp, int destcomp, int numcomp=1)
	Subtract srcbox region of src FAB from destbox region of this FAB.
BaseFab< T > &	operator*= (T r)
	Scalar multiplication (a[i] <- a[i] * r), in place.
BaseFab< T > &	operator*= (const BaseFab< T > &f)
	FAB multiplication (a[i] <- a[i] * b[i]), in place.
BaseFab< T > &	mult (T r)
	Scalar multiplication (a[i] <- a[i] * r). The same as *=.
BaseFab< T > &	mult (T r, int comp, int numcomp=1)
	Scalar multiplication, except control which components are multiplied.
BaseFab< T > &	mult (T r, const Box &b, int comp=0, int numcomp=1)
	As above, except specify sub-box.
BaseFab< T > &	mult (const BaseFab< T > &src)
	As above.
BaseFab< T > &	mult (const BaseFab< T > &src, int srccomp, int destcomp, int numcomp=1)
	Multiply src components (srccomp:srccomp+numcomp-1) with this FAB's components (destcomp:destcomp+numcomp-1) where the two FABs intersect.
BaseFab< T > &	mult (const BaseFab< T > &src, const Box &subbox, int srccomp, int destcomp, int numcomp=1)
	Same as above except multiplication is restricted to intersection of subbox and src FAB.
BaseFab< T > &	mult (const BaseFab< T > &src, const Box &srcbox, const Box &destbox, int srccomp, int destcomp, int numcomp=1)
	Multiply srcbox region of src FAB with destbox region of this FAB.
BaseFab< T > &	operator/= (T r)
	Scalar division (a[i] <- a[i] / r), in place.
BaseFab< T > &	operator/= (const BaseFab< T > &src)
	FAB division, in place.
BaseFab< T > &	divide (T r)
	Scalar division (a[i] <- a[i] / r), in place.
BaseFab< T > &	divide (T r, int comp, int numcomp=1)
	As above except specify which components.
BaseFab< T > &	divide (T r, const Box &b, int comp=0, int numcomp=1)
	As above except specify sub-box.
BaseFab< T > &	divide (const BaseFab< T > &src)
	Same as above.
BaseFab< T > &	divide (const BaseFab< T > &src, int srccomp, int destcomp, int numcomp=1)
	This FAB is numerator, src FAB is denominator divide src components (srccomp:srccomp+numcomp-1) into this FAB's components (destcomp:destcomp+numcomp-1) where the two FABs intersect.
BaseFab< T > &	divide (const BaseFab< T > &src, const Box &subbox, int srccomp, int destcomp, int numcomp=1)
	Same as above except division is restricted to intersection of subbox and src FAB.
BaseFab< T > &	divide (const BaseFab< T > &src, const Box &srcbox, const Box &destbox, int srccomp, int destcomp, int numcomp=1)
	destbox region of this FAB is numerator.
BaseFab< T > &	linInterp (const BaseFab< T > &f1, const Box &b1, int comp1, const BaseFab< T > &f2, const Box &b2, int comp2, Real t1, Real t2, Real t, const Box &b, int comp, int numcomp=1)
	Linear interpolation / extrapolation.
BaseFab< T > &	linComb (const BaseFab< T > &f1, const Box &b1, int comp1, const BaseFab< T > &f2, const Box &b2, int comp2, Real alpha, Real beta, const Box &b, int comp, int numcomp=1)
	Linear combination.
Static Public Member Functions
static Box	skipFAB (std::istream &is, int &num_comp)
	Skip over the next FAB from the input stream.
static void	skipFAB (std::istream &is)
	Skip over the next FAB from the input stream.
static void	setFormat (FABio::Format fmt)
	Set the FABio::Format in the program.
static FABio::Format	getFormat ()
	Gets the FABio::Format set in the program.
static void	setOrdering (FABio::Ordering ordering)
	Set the FABio::Ordering for reading old FABs.
static FABio::Ordering	getOrdering ()
	Gets the FABio::Ordering set in the program.
static void	setPrecision (FABio::Precision precision)
	Set the FABio::Precision.
static FABio::Precision	getPrecision ()
	Returns the FABio::Precision.
static const FABio &	getFABio ()
	Returns reference to the FABio object used by the program.
static void	setFABio (FABio *rd)
	Sets the FABio object used by the program.
static bool	set_do_initval (bool tf)
static bool	get_do_initval ()
static Real	set_initval (Real iv)
static Real	get_initval ()
static void	Initialize ()
static void	Finalize ()
Protected Member Functions
void	define ()
void	undefine ()
void	performCopy (const BaseFab< T > &src, const Box &srcbox, int srccomp, const Box &destbox, int destcomp, int numcomp)
void	performSetVal (T x, const Box &bx, int nstart, int numcomp)
Protected Attributes
Box	domain
int	nvar
long	numpts
long	truesize
T *	dptr
Static Protected Attributes
static FABio::Format	format = FABio::FAB_NATIVE
static FABio::Ordering	ordering = FABio::FAB_NORMAL_ORDER
static FABio *	fabio = new FABio_binary(FPC::NativeRealDescriptor().clone())
static bool	do_initval = true
static Real	initval
Friends
class	FABio
std::ostream &	operator<< (std::ostream &os, const FArrayBox &fb)
	Write FABs in ASCII form.
std::istream &	operator>> (std::istream &is, FArrayBox &fb)
	Read FABs in ASCII form.