SAMRAI::hier Namespace Reference

Classes
class	BinaryTree
class	Box
class	BoxIterator
class	BoxArray
struct	BoxComm
class	BoxGraph
struct	BoxGraphUtilities
class	BoxIOUtility
class	BoxList
class	BoxTop
class	BoxTree
class	BoxTreeNode
	Building block used by BoxTree<DIM>. More...
struct	BoxUtilities
class	Index
class	IntVector
class	LayerEdgeSet
	Encapsulates a set of DLBG edges that connect two LayerNodeSet objects. More...
class	LayerHierarchy
	Distributed nested-level box graph for a patch hierarchy. More...
class	LayerNode
	Encapsulates the node on a DLBG. More...
class	LayerNodeSet
	Encapsulates a set of LayerNode objects on the same index space. More...
class	BasePatchHierarchy
class	BasePatchLevel
class	BoundaryBox
class	BoundaryLookupTable
class	CoarseFineBoundary
	Utility class to construct and maintain a description of the coarse-fine boundary between a patch level and some coarser level. More...
class	GridGeometry
class	Patch
class	PatchFactory
class	PatchGeometry
class	PatchHierarchy
class	PatchLevel
class	PatchLevelIterator
class	PatchLevelFactory
class	ProcessorMapping
class	BoxGeometry
class	BoxOverlap
class	ComponentSelector
	Class ComponentSelector implements a simple bit vector of a fixed length and is typically used to apply operations on subsets of entries in the patch data array owned by a patch (e.g., allocate/deallocate). All ComponentSelector objects have the same bit vector length that is established by the SAMRAIManager utility. See the documentation of the SAMRAIManager utility for information about changing this maximum value. More...
class	LocallyActiveDataPatchLevelManager
	Class LocallyActiveDataPatchLevelManager is a utility class for managing data on a patch level where each data item may be defined on a different set of patches; i.e., the data is "locally-active". A separate object of this class is needed for each patch level on which locally-active data is defined. Typical usage involves constructing an instance of this class with a patch level and then defining the active patches for each patch data integer identifier. Then, this class supports various patch level operations asscociated with the locally-active data, such as allocation and deallocation of data and iteration over patches for which a particular data id is active. More...
class	LocallyActiveDataPatchLevelIterator
class	LocallyActiveVariableDatabase
	Class LocallyActiveVariableDatabase is a Singleton class for managing variables and data that live on different sets of patches in an AMR patch hierarchy; i.e., they are "locally-active". Although this class is derived from the VariableDatabase class, this class does not extend the full range of functionality provided by the VariableDatabase base class. Instead, this class uses some of the functionality of the VariableDatabase base class so that it is not replicated here. For example, this class assumes that each variable is associated with only one patch data index and all variables registered with this class share the same variable context. However, the usage of this class is similar to the VariableDatabase class. To make usage of this class reasonably transparent all functions defined in the base class that make sense for this class are redeclared here. More...
class	PatchData
class	PatchDataFactory
class	PatchDescriptor
	Class PatchDescriptor<DIM> maintains a collection of patch data factories and associated names that describes how patch data entries are constructed on each patch in an AMR hierarchy. The factory mechanism is used to create new instances of concrete patch data objects without knowing their actual types. See the Design Patterns book by Gamma {et al.} for more details about the Abstract Factory pattern. Generally, a PatchDescriptor object is intended to be shared among all patches (which are distributed across processors) so that they store patch data objects in the same way. More...
class	Variable
class	VariableContext
class	VariableDatabase
	Class VariableDatabase<DIM> is a Singleton class that manages mapping information between variables and patch data objects in ways that are configurable to the needs of an application built using SAMRAI. In SAMRAI, a single patch descriptor object is shared by all patches in an SAMR hierarchy. This database generates and maintain mappings (for lookup) between integer patch data indices and either variable-context pairs or just variables when contexts are not used. Users define which variables are included in the database, which variable contexts are in the database, and which contexts are associated with which variables via registration operations described below. More...
Functions
template<int DIM>
istream &	operator>> (istream &s, Box< DIM > &box)
template<int DIM>
ostream &	operator<< (ostream &s, const Box< DIM > &box)
static void	buildTboxArrayFromList (tbox::Array< int > &array, const tbox::List< int > &list)
template<int DIM>
istream &	operator>> (istream &s, IntVector< DIM > &rhs)
template<int DIM>
ostream &	operator<< (ostream &s, const IntVector< DIM > &rhs)
template<int DIM>
ostream &	operator<< (ostream &co, const LayerNode< DIM > &r)
template<int DIM>
ostream &	operator<< (ostream &s, const Patch< DIM > &patch)

---

Function Documentation

template<int DIM> istream& SAMRAI::hier::operator>> (  istream &  s, Box< DIM > &  box )

template<int DIM> ostream& SAMRAI::hier::operator<< (  ostream &  s, const Box< DIM > &  box )

static void SAMRAI::hier::buildTboxArrayFromList (  tbox::Array< int > &  array, const tbox::List< int > &  list )  [static]

template<int DIM> istream& SAMRAI::hier::operator>> (  istream &  s, IntVector< DIM > &  rhs )

template<int DIM> ostream& SAMRAI::hier::operator<< (  ostream &  s, const IntVector< DIM > &  rhs )

template<int DIM> ostream& SAMRAI::hier::operator<< (  ostream &  co, const LayerNode< DIM > &  r )

template<int DIM> ostream& SAMRAI::hier::operator<< (  ostream &  s, const Patch< DIM > &  patch )

---