SAMRAI::hier Namespace Reference

Classes
class	BasePatchHierarchy
class	BasePatchLevel
class	BinaryTree
class	BoundaryBox
class	BoundaryBoxUtils
	Perform shifts, extensions, etc on a BoundaryBox using the box's location index and type. More...
class	BoundaryLookupTable
class	Box
class	BoxArray
struct	BoxComm
class	BoxGeometry
class	BoxGraph
struct	BoxGraphUtilities
class	BoxIOUtility
class	BoxIterator
class	BoxList
class	BoxOverlap
class	BoxTop
class	BoxTree
class	BoxTreeNode
	Building block used by BoxTree<DIM>. More...
struct	BoxUtilities
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	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	GridGeometry
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...
struct	LevelNumber
class	LocallyActiveDataPatchLevelIterator
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	LocallyActiveVariableDatabase
	Class LocallyActiveVariableDatabase is a Singleton class that provides functionality for using the VariableDatabase to manage variables and data that live on different sets of patches in an AMR patch hierarchy, so-called "locally-active" data, can be managed. More...
class	MBUtilities
	Class MBUtilities contains utility functions related to multiblock functionality. More...
class	MultiblockDataTranslator
	Class MultiblockDataTranslator<DIM> More...
class	MultiblockGridGeometry
	Class MultiblockGridGeometry<DIM> More...
class	MultiblockPatchHierarchy
	Class MultiblockPatchHierarchy<DIM> manages an array of patch hierarchies that represent a multiblock domain, and describes the relationship between these hierarchies. More...
class	MultiblockPatchLevel
	Class MultiblockPatchLevel<DIM> contains an array of hier::PatchLevel<DIM> that contains all of the patch levels that have the same level of refinement in a multiblock domain. More...
class	Patch
class	PatchConfigurationUtilities
	Class PatchConfigurationUtilities contains routines that provide information about spatial relationships among patches on an AMR patch hierarchy. Such information is useful for building operations on patch data that must account for these relationships. Examples include knowing which patches are neighbors of a given patch on the same patch level and the positions of those neighbors with respect to the patch, and knowing which patches on a finer patch level overlap a given patch, etc. More...
class	PatchData
class	PatchDataFactory
struct	PatchDataId
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	PatchFactory
class	PatchGeometry
class	PatchHierarchy
class	PatchLevel
class	PatchLevelFactory
class	PatchLevelIterator
struct	PatchNumber
class	ProcessorMapping
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...