SAMRAI Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
arith_functions
KeyData
MDA_Access< MDA_TYPE, MDA_DIM, OrderType >Non-const multidimensional array access
MDA_AccessConst< MDA_TYPE, MDA_DIM, OrderType >Const data version of the multidimensional array access template class MDA_Access
MDA_IndexRange< MDA_DIM >Defines index ranges for multidimensional arrays
MDA_OrderColMajor< MDA_DIM >Performs computations based for column-major arrays
MDA_OrderRowMajor< MDA_DIM >Performs computations based for row-major arrays
SAMRAI::algs::HyperbolicLevelIntegrator< DIM >
SAMRAI::algs::HyperbolicPatchStrategy< DIM >
SAMRAI::algs::ImplicitEquationStrategy< DIM >Abstract base class defining the interface between ImplicitIntegrator<DIM> object and routines specific to the system of equations to be solved
SAMRAI::algs::ImplicitIntegrator< DIM >Manage implicit time integration over an AMR patch hierarchy
SAMRAI::algs::LocallyActiveDataOuteredgeSumTransactionFactory< DIM >Concrete subclass of the xfer::LocallyActiveDataRefineTransactionFactory<DIM> base class that allocates outeredge sum transaction objects for a xfer::LocallyActiveDataRefineSchedule<DIM> object
SAMRAI::algs::LocallyActiveDataOuternodeSumTransactionFactory< DIM >Concrete subclass of the xfer::LocallyActiveDataRefineTransactionFactory<DIM> base class that allocates transaction outernode sum objects for a xfer::LocallyActiveDataRefineSchedule<DIM> object
SAMRAI::algs::LocallyActiveDataPatchBoundaryEdgeSum< DIM >Class LocallyActiveDataPatchBoundaryEdgeSum provides operations summing locally-active edge data values at edges that are shared by multiple patches on a single level. Note that this utility only works on a SINGLE patch level, not on a multiple levels in an AMR patch hierarchy like the LocallyActiveDataPatchBoundaryNodeSum class. Unlike node data, edge data at coarse-fine boundaries are not co-located, so the sum operation across levels depends on application requirements
SAMRAI::algs::LocallyActiveDataPatchBoundaryNodeSum< DIM >Class LocallyActiveDataPatchBoundaryNodeSum provides operations for summing locally-active node data values at nodes shared by multiple patches on a single level or across multiple hierarchy levels
SAMRAI::algs::MblkPatchBoundaryNodeSum< DIM >Class MblkPatchBoundaryNodeSum provides operations for summing node data values at nodes that are shared by multiple patches on a single level or across multiple hierarchy levels
SAMRAI::algs::MethodOfLinesIntegrator< DIM >Class MethodOfLinesIntegrator<DIM> implements a spatially adaptive version of the Strong Stability Preserving (SSP) Runge-Kutta time integration algorithm
SAMRAI::algs::MethodOfLinesPatchStrategy< DIM >
SAMRAI::algs::OuteredgeSumTransaction< DIM >Class OuteredgeSumTransaction<DIM> represents a single outeredge data sum communication transaction between two processors or a local data sum for refine schedules. Note that to there is an implicit hand-shaking between objects of this class and the xfer::RefineSchedule<DIM> object that constructs them. Following the refine schedule implementation, the source patch data index for a transaction always refers to the source data and the destination patch data index for a transaction is always the scratch data, all as defined in the xfer::RefineClasses<DIM> class
SAMRAI::algs::OuteredgeSumTransactionFactory< DIM >Concrete subclass of the xfer::RefineTransactionFactory<DIM> base class that allocates outeredge sum transaction objects for a xfer::RefineSchedule<DIM> object
SAMRAI::algs::OuternodeSumTransaction< DIM >Class OuternodeSumTransaction<DIM> represents a single outernode data sum communication transaction between two processors or a local data sum for refine schedules. Note that to there is an implicit hand-shaking between objects of this class and the xfer::RefineSchedule<DIM> object that constructs them. Following the refine schedule implementation, the source patch data index for a transaction always refers to the source data and the destination patch data index for a transaction is always the scratch data, all as defined in the xfer::RefineClasses<DIM> class
SAMRAI::algs::OuternodeSumTransactionFactory< DIM >Concrete subclass of the xfer::RefineTransactionFactory<DIM> base class that allocates transaction outernode sum objects for a xfer::RefineSchedule<DIM> object
SAMRAI::algs::PatchBoundaryEdgeSum< DIM >Class PatchBoundaryEdgeSum provides operations summing edge data values at edges that are shared by multiple patches on a single level. Note that this utility only works on a SINGLE patch level, not on a multiple levels in an AMR patch hierarchy like the PatchBoundaryNodeSum class. Unlike node data, edge data at coarse-fine boundaries are not co-located, so the sum operation is not clearly defined
SAMRAI::algs::PatchBoundaryNodeSum< DIM >Class PatchBoundaryNodeSum provides operations for summing node data values at nodes that are shared by multiple patches on a single level or across multiple hierarchy levels
SAMRAI::algs::TimeRefinementIntegrator< DIM >
SAMRAI::algs::TimeRefinementLevelStrategy< DIM >
SAMRAI::appu::BoundaryNode< DIM >The BoundaryNode struct holds data and methods to define a boundary node (i.e. the first node inside the boundary) on an irregular boundary. An array of boundary nodes is maintained by each "CutCell" object, if the appropriate functions are called to enable boundary node storage. For more information, see the CutCell class documentation
SAMRAI::appu::BoundaryUtilityStrategyClass BoundaryUtilityStrategy is an abstract base class that declares an interface that allows application code to read problem-specific boundary data when using the SAMRAI boundary utilities. Currently, there are two virtual member functions defined. One allows users to read problem-specific DIRICHLET boundary values from an input database; the other does the same for NEUMANN boundary values. More virtual functions may be added in the future as additional boundary conditions are supported
SAMRAI::appu::CartesianBoundaryUtilities2Class CartesianBoundaryUtilities2 is a utility class that simplifies the implementation of simple physical boundary data in 2 spatial dimensions. It contains routines for reading boundary data information from input files, applying those boundary conditions, and error checking boundary data. These routines apply to the case of cell-centered double data only. One may use all of these capabilities, or use the input reading, boundary setting, and error checking routines independently
SAMRAI::appu::CartesianBoundaryUtilities3Class CartesianBoundaryUtilities2 is a utility class that simplifies the implementation of simple physical boundary data in 3 spatial dimensions. It contains routines for reading boundary data information from input files, applying those boundary conditions, and error checking boundary data. These routines apply to the case of cell-centered double data only. One may use all of these capabilities, or use the input reading, boundary setting, and error checking routines independently
SAMRAI::appu::CartesianVizamraiDataWriter< DIM >
SAMRAI::appu::CubesPatchInterface< DIM >
SAMRAI::appu::CutCell< DIM >The CutCell struct holds data and methods to define a cut-cell on an irregular boundary
SAMRAI::appu::ElevenPatchInterface< DIM >This class provides an interface to the Eleven geometry library by Kyle Chand in CASC. The shapes over which the embedded boundary is cut is defined through an XML database, the name of which is specified in the input file
SAMRAI::appu::EmbeddedBoundaryDefinesClass EmbeddedBoundaryDefines sets the enumerated types used to define cells and nodes on the embedded boundary level
SAMRAI::appu::EmbeddedBoundaryGeometry< DIM >Class EmbeddedBoundaryGeometry provides embedded boundary mesh construction, storage, and management on an AMR hierarchy
SAMRAI::appu::EmbeddedBoundaryShape< DIM >An abstract base class from which the different embedded boundary analytic shapes used in SAMRAI are derived. It specifies virtual implementations of several functions used to define an analytic embedded boundary shape
SAMRAI::appu::EmbeddedBoundaryShapePolygon< DIM >Provides an analytic description of a convex polygon. It inherets from the EmbeddedBoundaryShape base class and provides a concrete implementation of the "isInside()" method, which specifies whether a cell is INSIDE the convex poly
SAMRAI::appu::EmbeddedBoundaryShapeSphere< DIM >Provides an analytic description of a sphere. It inherets from the EmbeddedBoundaryShape base class and provides a concrete implementation of the "isInside()" method, which specifies whether a cell is INSIDE the sphere
SAMRAI::appu::VisDerivedDataStrategy< DIM >Class VisDerivedDataStrategy<DIM> is an abstract base class that defines an interface allowing an VisItDataWriter<DIM> object and/or an CartesianVizamraiDataWriter<DIM> object to generate plot files that contain "derived" quantities; that is, data that does not reside on the hierarchy, but which is derived from data that does reside on the hierarchy. The derived data may be scalar, vector, or tensor (VisIt only), and cell-centered or node-centered (VisIt only). A concrete object of this type must be registered with the data writer if any derived variable is registered with the data writer. The registration of the concrete strategy object may be done independently using the method setDerivedDataWriter() (Vizamrai only) or setDefaultDerivedDataWriter() (VisIt only) from the relevant DataWriter class, or the concrete strategy object may be registered concurrently with the derived variable using the method registerDerivedPlotScalar/Vector/Tensor()
SAMRAI::appu::VisItDataWriter< DIM >Class VisItDataWriter<DIM> is used by SAMRAI-based application codes to generate VisIt data files. VisIt provides a wide range of visualization and post-processing capabilities. This class supports both cell-centered and node-centered 2D and 3D AMR data where the underlying data type is either double, float, or int. Scalar, vector and 2nd-order tensor variables are supported. This class may be used when the mesh geometry is managed by a geom::CartesianGridGeometry<DIM> object, or when the mesh itself is stored in a state variable to allow moving deformed grids
SAMRAI::appu::VisMaterialsDataStrategy< DIM >Class VisMaterialsDataStrategy<DIM> is an abstract base class that defines an interface allowing an VisItDataWriter<DIM> object to generate plot files that contain material and species fractions, as well as state variables for individual materials. A concrete object of this type must be registered with the data writer in order to use materials or species with the data writer. The registration of the concrete object is done using the method setMaterialsDataWriter() from the VisItDataWriter class. VisIt requires that material fractions, species fractions, and material state variables be cell-centered. If they are not cell-centered in the simulation, it is the job of the relevant packing method to convert them to a cell-centered basis before packing them into the buffer
SAMRAI::geom::BlockGridGeometry< DIM >
SAMRAI::geom::BlockPatchGeometry< DIM >
SAMRAI::geom::CartesianCellComplexConservativeLinearRefine< DIM >
SAMRAI::geom::CartesianCellComplexLinearRefine< DIM >
SAMRAI::geom::CartesianCellComplexWeightedAverage< DIM >
SAMRAI::geom::CartesianCellDoubleConservativeLinearRefine< DIM >
SAMRAI::geom::CartesianCellDoubleLinearRefine< DIM >
SAMRAI::geom::CartesianCellDoubleWeightedAverage< DIM >
SAMRAI::geom::CartesianCellFloatConservativeLinearRefine< DIM >
SAMRAI::geom::CartesianCellFloatLinearRefine< DIM >
SAMRAI::geom::CartesianCellFloatWeightedAverage< DIM >
SAMRAI::geom::CartesianEdgeComplexWeightedAverage< DIM >
SAMRAI::geom::CartesianEdgeDoubleConservativeLinearRefine< DIM >
SAMRAI::geom::CartesianEdgeDoubleWeightedAverage< DIM >
SAMRAI::geom::CartesianEdgeFloatConservativeLinearRefine< DIM >
SAMRAI::geom::CartesianEdgeFloatWeightedAverage< DIM >
SAMRAI::geom::CartesianFaceComplexWeightedAverage< DIM >
SAMRAI::geom::CartesianFaceDoubleConservativeLinearRefine< DIM >
SAMRAI::geom::CartesianFaceDoubleWeightedAverage< DIM >
SAMRAI::geom::CartesianFaceFloatConservativeLinearRefine< DIM >
SAMRAI::geom::CartesianFaceFloatWeightedAverage< DIM >
SAMRAI::geom::CartesianGridGeometry< DIM >
SAMRAI::geom::CartesianNodeComplexLinearRefine< DIM >
SAMRAI::geom::CartesianNodeDoubleLinearRefine< DIM >
SAMRAI::geom::CartesianNodeFloatLinearRefine< DIM >
SAMRAI::geom::CartesianOuterfaceComplexWeightedAverage< DIM >
SAMRAI::geom::CartesianOuterfaceDoubleWeightedAverage< DIM >
SAMRAI::geom::CartesianOuterfaceFloatWeightedAverage< DIM >
SAMRAI::geom::CartesianOutersideDoubleWeightedAverage< DIM >
SAMRAI::geom::CartesianPatchGeometry< DIM >
SAMRAI::geom::CartesianSideComplexWeightedAverage< DIM >
SAMRAI::geom::CartesianSideDoubleConservativeLinearRefine< DIM >
SAMRAI::geom::CartesianSideDoubleWeightedAverage< DIM >
SAMRAI::geom::CartesianSideFloatConservativeLinearRefine< DIM >
SAMRAI::geom::CartesianSideFloatWeightedAverage< DIM >
SAMRAI::geom::SkeletonCoarsen< DIM >
SAMRAI::geom::SkeletonGridGeometry< DIM >
SAMRAI::geom::SkeletonPatchGeometry< DIM >
SAMRAI::geom::SkeletonRefine< DIM >
SAMRAI::hier::BasePatchHierarchy< DIM >
SAMRAI::hier::BasePatchLevel< DIM >
SAMRAI::hier::BinaryTree< DIM >
SAMRAI::hier::BoundaryBox< DIM >
SAMRAI::hier::BoundaryBoxUtils< DIM >Perform shifts, extensions, etc on a BoundaryBox using the box's location index and type
SAMRAI::hier::BoundaryLookupTable< DIM >
SAMRAI::hier::Box< DIM >
SAMRAI::hier::BoxArray< DIM >
SAMRAI::hier::BoxComm< DIM >
SAMRAI::hier::BoxGeometry< DIM >
SAMRAI::hier::BoxGraph< DIM >
SAMRAI::hier::BoxGraphUtilities< DIM >
SAMRAI::hier::BoxIOUtility< DIM >
SAMRAI::hier::BoxIterator< DIM >
SAMRAI::hier::BoxList< DIM >
SAMRAI::hier::BoxOverlap< DIM >
SAMRAI::hier::BoxTop< DIM >
SAMRAI::hier::BoxTree< DIM >
SAMRAI::hier::BoxTreeNode< DIM >Building block used by BoxTree<DIM>
SAMRAI::hier::BoxTreeNode< DIM >::Triple
SAMRAI::hier::BoxUtilities< DIM >
SAMRAI::hier::CoarseFineBoundary< DIM >Utility class to construct and maintain a description of the coarse-fine boundary between a patch level and some coarser level
SAMRAI::hier::ComponentSelectorClass 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
SAMRAI::hier::GridGeometry< DIM >
SAMRAI::hier::Index< DIM >
SAMRAI::hier::IntVector< DIM >
SAMRAI::hier::LayerEdgeSet< DIM >Encapsulates a set of DLBG edges that connect two LayerNodeSet objects
SAMRAI::hier::LayerEdgeSet< DIM >::CommunicationStructData sorted by a hash
SAMRAI::hier::LayerHierarchy< DIM >Distributed nested-level box graph for a patch hierarchy
SAMRAI::hier::LayerNode< DIM >Encapsulates the node on a DLBG
SAMRAI::hier::LayerNodeSet< DIM >Encapsulates a set of LayerNode objects on the same index space
SAMRAI::hier::LevelNumber
SAMRAI::hier::LocallyActiveDataPatchLevelIterator< DIM >
SAMRAI::hier::LocallyActiveDataPatchLevelManager< DIM >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
SAMRAI::hier::LocallyActiveVariableDatabase< DIM >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
SAMRAI::hier::MBUtilities< DIM >Class MBUtilities contains utility functions related to multiblock functionality
SAMRAI::hier::MultiblockDataTranslator< DIM >Class MultiblockDataTranslator<DIM>
SAMRAI::hier::MultiblockGridGeometry< DIM >Class MultiblockGridGeometry<DIM>
SAMRAI::hier::MultiblockPatchHierarchy< DIM >Class MultiblockPatchHierarchy<DIM> manages an array of patch hierarchies that represent a multiblock domain, and describes the relationship between these hierarchies
SAMRAI::hier::MultiblockPatchHierarchy< DIM >::NeighborStructure to represent the neighbor of a given block
SAMRAI::hier::MultiblockPatchLevel< DIM >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
SAMRAI::hier::Patch< DIM >
SAMRAI::hier::PatchConfigurationUtilities< DIM >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
SAMRAI::hier::PatchConfigurationUtilities< DIM >::NeighborPatchInfo
SAMRAI::hier::PatchData< DIM >
SAMRAI::hier::PatchDataFactory< DIM >
SAMRAI::hier::PatchDataId
SAMRAI::hier::PatchDescriptor< DIM >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
SAMRAI::hier::PatchFactory< DIM >
SAMRAI::hier::PatchGeometry< DIM >
SAMRAI::hier::PatchHierarchy< DIM >
SAMRAI::hier::PatchLevel< DIM >
SAMRAI::hier::PatchLevelFactory< DIM >
SAMRAI::hier::PatchLevelIterator< DIM >
SAMRAI::hier::PatchNumber
SAMRAI::hier::ProcessorMapping
SAMRAI::hier::Variable< DIM >
SAMRAI::hier::VariableContext
SAMRAI::hier::VariableDatabase< DIM >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
SAMRAI::math::ArrayDataBasicOps< DIM, TYPE >
SAMRAI::math::ArrayDataMiscellaneousOpsReal< DIM, TYPE >
SAMRAI::math::ArrayDataNormOpsComplex< DIM >
SAMRAI::math::ArrayDataNormOpsInteger< DIM >
SAMRAI::math::ArrayDataNormOpsReal< DIM, TYPE >
SAMRAI::math::HierarchyCellDataOpsComplex< DIM >
SAMRAI::math::HierarchyCellDataOpsInteger< DIM >
SAMRAI::math::HierarchyCellDataOpsReal< DIM, TYPE >
SAMRAI::math::HierarchyDataOpsComplex< DIM >
SAMRAI::math::HierarchyDataOpsInteger< DIM >
SAMRAI::math::HierarchyDataOpsManager< DIM >
SAMRAI::math::HierarchyDataOpsReal< DIM, TYPE >
SAMRAI::math::HierarchyEdgeDataOpsComplex< DIM >
SAMRAI::math::HierarchyEdgeDataOpsInteger< DIM >
SAMRAI::math::HierarchyEdgeDataOpsReal< DIM, TYPE >
SAMRAI::math::HierarchyFaceDataOpsComplex< DIM >
SAMRAI::math::HierarchyFaceDataOpsInteger< DIM >
SAMRAI::math::HierarchyFaceDataOpsReal< DIM, TYPE >
SAMRAI::math::HierarchyNodeDataOpsComplex< DIM >
SAMRAI::math::HierarchyNodeDataOpsInteger< DIM >
SAMRAI::math::HierarchyNodeDataOpsReal< DIM, TYPE >
SAMRAI::math::HierarchySideDataOpsComplex< DIM >
SAMRAI::math::HierarchySideDataOpsInteger< DIM >
SAMRAI::math::HierarchySideDataOpsReal< DIM, TYPE >
SAMRAI::math::PatchCellDataBasicOps< DIM, TYPE >
SAMRAI::math::PatchCellDataMiscellaneousOpsReal< DIM, TYPE >
SAMRAI::math::PatchCellDataNormOpsComplex< DIM >
SAMRAI::math::PatchCellDataNormOpsReal< DIM, TYPE >
SAMRAI::math::PatchCellDataOpsComplex< DIM >
SAMRAI::math::PatchCellDataOpsInteger< DIM >
SAMRAI::math::PatchCellDataOpsReal< DIM, TYPE >
SAMRAI::math::PatchEdgeDataBasicOps< DIM, TYPE >
SAMRAI::math::PatchEdgeDataMiscellaneousOpsReal< DIM, TYPE >
SAMRAI::math::PatchEdgeDataNormOpsComplex< DIM >
SAMRAI::math::PatchEdgeDataNormOpsReal< DIM, TYPE >
SAMRAI::math::PatchEdgeDataOpsComplex< DIM >
SAMRAI::math::PatchEdgeDataOpsInteger< DIM >
SAMRAI::math::PatchEdgeDataOpsReal< DIM, TYPE >
SAMRAI::math::PatchFaceDataBasicOps< DIM, TYPE >
SAMRAI::math::PatchFaceDataMiscellaneousOpsReal< DIM, TYPE >
SAMRAI::math::PatchFaceDataNormOpsComplex< DIM >
SAMRAI::math::PatchFaceDataNormOpsReal< DIM, TYPE >
SAMRAI::math::PatchFaceDataOpsComplex< DIM >
SAMRAI::math::PatchFaceDataOpsInteger< DIM >
SAMRAI::math::PatchFaceDataOpsReal< DIM, TYPE >
SAMRAI::math::PatchNodeDataBasicOps< DIM, TYPE >
SAMRAI::math::PatchNodeDataMiscellaneousOpsReal< DIM, TYPE >
SAMRAI::math::PatchNodeDataNormOpsComplex< DIM >
SAMRAI::math::PatchNodeDataNormOpsReal< DIM, TYPE >
SAMRAI::math::PatchNodeDataOpsComplex< DIM >
SAMRAI::math::PatchNodeDataOpsInteger< DIM >
SAMRAI::math::PatchNodeDataOpsReal< DIM, TYPE >
SAMRAI::math::PatchSideDataBasicOps< DIM, TYPE >
SAMRAI::math::PatchSideDataMiscellaneousOpsReal< DIM, TYPE >
SAMRAI::math::PatchSideDataNormOpsComplex< DIM >
SAMRAI::math::PatchSideDataNormOpsReal< DIM, TYPE >
SAMRAI::math::PatchSideDataOpsComplex< DIM >
SAMRAI::math::PatchSideDataOpsInteger< DIM >
SAMRAI::math::PatchSideDataOpsReal< DIM, TYPE >
SAMRAI::mesh::AsyncBergerRigoutsos< DIM >Asynchronous Berger-Rigoutsos implementation. This class is derived from the abstract base class mesh::BoxGeneratorStrategy<DIM>. Thus, it serves as a concrete implementation of the box generator Strategy pattern interface
SAMRAI::mesh::AsyncBergerRigoutsosNode< DIM >Node in the asynchronous Berger-Rigoutsos (BR) dendogram
SAMRAI::mesh::AsyncBergerRigoutsosNode< DIM >::CommonParamsParameters shared among all dendogram nodes in an dendogram and collectively managed by those nodes
SAMRAI::mesh::BalanceUtilities< DIM >Utility class BalanceUtilities<DIM> provides several functions useful in various load balancing operations. These utilities include bin packing operations, box chopping by recursive bisection, and computation of effective processor layouts for boxes
SAMRAI::mesh::BaseGriddingAlgorithm< DIM >Virtual base class providing interface for gridding algorithm
SAMRAI::mesh::BergerRigoutsos< DIM >BergerRigoutsos<DIM> provides operations that construct boxes to cover a collection of tagged cells on a single AMR hierarchy patch level. This class is derived from the abstract base class BoxGeneratorStrategy<DIM>. Thus, it serves as a concrete implementation of the box generator Strategy pattern interface
SAMRAI::mesh::BoxGeneratorStrategy< DIM >
SAMRAI::mesh::GriddingAlgorithm< DIM >Class GriddingAlgorithm<DIM> manages gridding operations in SAMRAI. Specifically, it provides AMR patch hierarchy generation and regridding routines that may be used with a variety of AMR solution algorithms and application-specific numerical routines
SAMRAI::mesh::HistogramBox< DIM >Class HistogramBox<DIM> manages the histogram signature array for a region of index space contained within a single box. It is used during the regridding process to gather information about the distribution of tagged cells across a portion of a patch level
SAMRAI::mesh::LoadBalancer< DIM >Class LoadBalancer<DIM> provides load balancing routines for AMR hierarchy levels based on either uniform or non-uniform workload estimates
SAMRAI::mesh::LoadBalanceStrategy< DIM >Class LoadBalanceStrategy<DIM> is an abstract base class that defines a Strategy pattern interface for operations that load balance patches on a single AMR patch hierarchy level. Typically, such operations are invoked after the domain of a new hierarchy level is determined (e.g., via some error estimation procedure) and is applied to the collection of boxes that describe the domain. The load balancing process produces a set of boxes from which patches on the new level are created and a processor mapping describing how the new patches are mapped to processors
SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >Class MultiblockGriddingAlgorithm<DIM> manages gridding operations in SAMRAI for problems on multiblock domains. Specifically, it provides AMR patch hierarchy generation and regridding routines that may be used with a variety of AMR solution algorithms and application-specific numerical routines
SAMRAI::mesh::MultiblockGriddingTagger< DIM >Class MultiblockGriddingTagger<DIM> is a concrete implementation of MultiblockRefinePatchStrategy<DIMI> that is used for boundary filling of patch data representing cells tagged for refinement
SAMRAI::mesh::SpatialKey
SAMRAI::mesh::StandardTagAndInitialize< DIM >
SAMRAI::mesh::StandardTagAndInitStrategy< DIM >
SAMRAI::mesh::TagAndInitializeStrategy< DIM >
SAMRAI::pdat::ArrayData< DIM, TYPE >Class ArrayData<DIM, TYPE> is a basic templated array structure defined over the index space of a box (with a specified depth) that provides the support for the various standard array-based patch data subclasses
SAMRAI::pdat::ArrayDataAccessUtility for wrapping data from ArrayData class in an MDA_Access or MDA_AccessConst object
SAMRAI::pdat::ArrayDataIterator< DIM >
SAMRAI::pdat::ArrayDataOperationUtilities< DIM, TYPE, OP >Struct ArrayDataOperationUtilities<DIM, TYPE, OP> provides generic looping operations for all array-based patch data types. The operations are templated on spatial dimension, data type, and the operation that will be performed on individual array elements in the innermost loop
SAMRAI::pdat::CellComplexConstantRefine< DIM >
SAMRAI::pdat::CellComplexLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::CellData< DIM, TYPE >Class CellData<DIM> provides an implementation for data defined at cell centers on AMR patches. It is derived from the hier::PatchData interface common to all SAMRAI patch data types. Given a CELL-centered AMR index space box, a cell data object represents data of some template TYPE and depth at the centers of the cells in the box. Here, depth indicates the number of data values at each cell index location. The CellGeometry class provides the translation between the standard SAMRAI cell-centered AMR index space and cell-centered data
SAMRAI::pdat::CellDataFactory< DIM, TYPE >
SAMRAI::pdat::CellDoubleConstantRefine< DIM >
SAMRAI::pdat::CellDoubleLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::CellFloatConstantRefine< DIM >
SAMRAI::pdat::CellFloatLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::CellGeometry< DIM >
SAMRAI::pdat::CellIndex< DIM >
SAMRAI::pdat::CellIntegerConstantRefine< DIM >
SAMRAI::pdat::CellIterator< DIM >
SAMRAI::pdat::CellOverlap< DIM >
SAMRAI::pdat::CellVariable< DIM, TYPE >
SAMRAI::pdat::CopyOperation< TYPE >Class CopyOperation<TYPE> encapsulates a copy operation into an object
SAMRAI::pdat::EdgeComplexConstantRefine< DIM >
SAMRAI::pdat::EdgeComplexLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::EdgeData< DIM, TYPE >Class EdgeData<DIM> provides an implementation for data defined at cell edges on AMR patches. It is derived from the hier::PatchData interface common to all SAMRAI patch data types. Given a CELL-centered AMR index space box, an edge data object represents data of some template TYPE and depth on the edges of the cells in the box. Here, depth indicates the number of data values at each edge index location. The EdgeGeometry class provides the translation between the standard SAMRAI cell-centered AMR index space and edge-centered data
SAMRAI::pdat::EdgeDataFactory< DIM, TYPE >
SAMRAI::pdat::EdgeDoubleConstantRefine< DIM >
SAMRAI::pdat::EdgeDoubleLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::EdgeFloatConstantRefine< DIM >
SAMRAI::pdat::EdgeFloatLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::EdgeGeometry< DIM >
SAMRAI::pdat::EdgeIndex< DIM >
SAMRAI::pdat::EdgeIntegerConstantRefine< DIM >
SAMRAI::pdat::EdgeIterator< DIM >
SAMRAI::pdat::EdgeOverlap< DIM >
SAMRAI::pdat::EdgeVariable< DIM, TYPE >
SAMRAI::pdat::FaceComplexConstantRefine< DIM >
SAMRAI::pdat::FaceComplexLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::FaceData< DIM, TYPE >Class FaceData<DIM> provides an implementation for data defined at cell faces on AMR patches. It is derived from the hier::PatchData interface common to all SAMRAI patch data types. Given a CELL-centered AMR index space box, a face data object represents data of some template TYPE and depth on the faces of the cells in the box. Here, depth indicates the number of data values at each face index location. The FaceGeometry class provides the translation between the standard SAMRAI cell-centered AMR index space and face-centered data
SAMRAI::pdat::FaceDataFactory< DIM, TYPE >
SAMRAI::pdat::FaceDoubleConstantRefine< DIM >
SAMRAI::pdat::FaceDoubleLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::FaceFloatConstantRefine< DIM >
SAMRAI::pdat::FaceFloatLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::FaceGeometry< DIM >
SAMRAI::pdat::FaceIndex< DIM >
SAMRAI::pdat::FaceIntegerConstantRefine< DIM >
SAMRAI::pdat::FaceIterator< DIM >
SAMRAI::pdat::FaceOverlap< DIM >
SAMRAI::pdat::FaceVariable< DIM, TYPE >
SAMRAI::pdat::FirstLayerCellFillPattern< DIM >
SAMRAI::pdat::FirstLayerCellNoCornersFillPattern< DIM >
SAMRAI::pdat::FirstLayerNodeFillPattern< DIM >
SAMRAI::pdat::IndexData< DIM, TYPE, BOX_GEOMETRY >
SAMRAI::pdat::IndexDataFactory< DIM, TYPE, BOX_GEOMETRY >
SAMRAI::pdat::IndexDataNode< DIM, TYPE, BOX_GEOMETRY >
SAMRAI::pdat::IndexIterator< DIM, TYPE, BOX_GEOMETRY >
SAMRAI::pdat::IndexVariable< DIM, TYPE, BOX_GEOMETRY >
SAMRAI::pdat::MBDataUtilities< DIM, TYPE >Class MBDataUtilities<DIM,TYPE> is a templated utilitiy class that contains a set of static member functions that can be used to copy patch data between index spaces that are not necessarily aligned on the same axes
SAMRAI::pdat::MultiblockCellDataTranslator< DIM, TYPE >
SAMRAI::pdat::MultiblockEdgeDataTranslator< DIM, TYPE >
SAMRAI::pdat::MultiblockFaceDataTranslator< DIM, TYPE >
SAMRAI::pdat::MultiblockNodeDataTranslator< DIM, TYPE >
SAMRAI::pdat::MultiblockSideDataTranslator< DIM, TYPE >
SAMRAI::pdat::NodeComplexInjection< DIM >
SAMRAI::pdat::NodeComplexLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::NodeData< DIM, TYPE >Class NodeData<DIM> provides an implementation for data defined at nodes on AMR patches. It is derived from the hier::PatchData interface common to all SAMRAI patch data types. Given a CELL-centered AMR index space box, a node data object represents data of some template TYPE and depth at the nodes of the cells in the box. Here, depth indicates the number of data values at each node index location. The NodeGeometry class provides the translation between the standard SAMRAI cell-centered AMR index space and node-centered data
SAMRAI::pdat::NodeDataFactory< DIM, TYPE >
SAMRAI::pdat::NodeDoubleInjection< DIM >
SAMRAI::pdat::NodeDoubleLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::NodeFloatInjection< DIM >
SAMRAI::pdat::NodeFloatLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::NodeGeometry< DIM >
SAMRAI::pdat::NodeIndex< DIM >
SAMRAI::pdat::NodeIntegerInjection< DIM >
SAMRAI::pdat::NodeIterator< DIM >
SAMRAI::pdat::NodeOverlap< DIM >
SAMRAI::pdat::NodeVariable< DIM, TYPE >
SAMRAI::pdat::OuteredgeData< DIM, TYPE >Class OuteredgeData<DIM> provides an implementation for data defined at cell edges on the boundaries of AMR patches. It is derived from the hier::PatchData interface common to all SAMRAI patch data types. Given a CELL-centered AMR index space box, an outeredge data object represents data of some template TYPE and depth on the cell edges on the boundary of the box. Here, depth indicates the number of data values at each edge index location. The OuteredgedgeGeometry class provides the translation between the standard SAMRAI cell-centered AMR index space and outeredge-centered data
SAMRAI::pdat::OuteredgeDataFactory< DIM, TYPE >Class OuteredgeDataFactory<DIM> is a factory class used to allocate new instances of OuteredgeData<DIM> objects. It is a subclass of the patch data factory class and outeredge data is a subclass of patch data. Both the factory and data classes are templated on the type of the contained object (e.g., double or int)
SAMRAI::pdat::OuteredgeGeometry< DIM >
SAMRAI::pdat::OuteredgeVariable< DIM, TYPE >Class OuteredgeVariable<DIM> is a templated variable class used to define edge-centered data quantities only on patch boundaries. It is a subclass of hier::Variable and is templated on the type of the underlying data (e.g., double, int, bool, etc.)
SAMRAI::pdat::OuterfaceComplexConstantRefine< DIM >
SAMRAI::pdat::OuterfaceComplexLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::OuterfaceData< DIM, TYPE >Class OuterfaceData<DIM> provides an implementation for data defined at cell faces on the boundaries of AMR patches. It is derived from the hier::PatchData interface common to all SAMRAI patch data types. Given a CELL-centered AMR index space box, an outerface data object represents data of some template TYPE and depth on the cell faces on the boundary of the box. Here, depth indicates the number of data values at each face index location. The OuteredgfaceGeometry class provides the translation between the standard SAMRAI cell-centered AMR index space and outerface-centered data
SAMRAI::pdat::OuterfaceDataFactory< DIM, TYPE >
SAMRAI::pdat::OuterfaceDoubleConstantRefine< DIM >
SAMRAI::pdat::OuterfaceDoubleLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::OuterfaceFloatConstantRefine< DIM >
SAMRAI::pdat::OuterfaceFloatLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::OuterfaceGeometry< DIM >
SAMRAI::pdat::OuterfaceIntegerConstantRefine< DIM >
SAMRAI::pdat::OuterfaceVariable< DIM, TYPE >Class OuterfaceVariable<DIM> is a templated variable class used to define face-centered data quantities only on patch boundaries. It is a subclass of hier::Variable and is templated on the type of the underlying data (e.g., double, int, bool, etc.)
SAMRAI::pdat::OuternodeData< DIM, TYPE >Class OuternodeData<DIM> provides an implementation for data defined at cell nodes on the boundaries of AMR patches. It is derived from the hier::PatchData interface common to all SAMRAI patch data types. Given a CELL-centered AMR index space box, an outernode data object represents data of some template TYPE and depth on the cell nodes on the boundary of the box. Here, depth indicates the number of data values at each node index location. The OuternodnodeGeometry class provides the translation between the standard SAMRAI cell-centered AMR index space and outernode-centered data
SAMRAI::pdat::OuternodeDataFactory< DIM, TYPE >Class OuternodeDataFactory is a factory class used to allocate new instances of OuternodeData objects. It is a subclass of the patch data factory class and outernode data is a subclass of patch data. Both the factory and data classes are templated on the type of the contained object (e.g., double or int)
SAMRAI::pdat::OuternodeDoubleConstantCoarsen< DIM >Class OuternodeDoubleConstantCoarsen implements constant averaging (i.e., injection) for outernode-centered double patch data defined over a mesh
SAMRAI::pdat::OuternodeGeometry< DIM >
SAMRAI::pdat::OuternodeVariable< DIM, TYPE >Class OuternodeVariable<DIM> is a templated variable class used to define node-centered data quantities only on patch boundaries. It is a subclass of hier::Variable and is templated on the type of the underlying data (e.g., double, int, bool, etc.)
SAMRAI::pdat::OutersideComplexLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::OutersideData< DIM, TYPE >Class OutersideData<DIM> provides an implementation for data defined at cell sides (faces) on the boundaries of AMR patches. It is derived from the hier::PatchData interface common to all SAMRAI patch data types. Given a CELL-centered AMR index space box, an outerside data object represents data of some template TYPE and depth on the cell sides (faces) on the boundary of the box. Here, depth indicates the number of data values at each face index location. The OuteredgsideGeometry class provides the translation between the standard SAMRAI cell-centered AMR index space and outerside-centered data
SAMRAI::pdat::OutersideDataFactory< DIM, TYPE >
SAMRAI::pdat::OutersideDoubleLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::OutersideFloatLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::OutersideGeometry< DIM >
SAMRAI::pdat::OutersideVariable< DIM, TYPE >Class OutersideVariable<DIM> is a templated variable class used to define side-centered data quantities only on patch boundaries. It is a subclass of hier::Variable and is templated on the type of the underlying data (e.g., double, int, bool, etc.)
SAMRAI::pdat::SecondLayerNodeFillPattern< DIM >
SAMRAI::pdat::SecondLayerNodeNoCornersFillPattern< DIM >
SAMRAI::pdat::SideComplexConstantRefine< DIM >
SAMRAI::pdat::SideComplexLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::SideData< DIM, TYPE >Class SideData<DIM> provides an implementation for data defined at cell sides (faces) on AMR patches. It is derived from the hier::PatchData interface common to all SAMRAI patch data types. Given a CELL-centered AMR index space box, a side data object represents data of some template TYPE and depth on the sides (faces) of the cells in the box. Here, depth indicates the number of data values at each side index location. The SideGeometry class provides the translation between the standard SAMRAI cell-centered AMR index space and side-centered data
SAMRAI::pdat::SideDataFactory< DIM, TYPE >
SAMRAI::pdat::SideDoubleConstantRefine< DIM >
SAMRAI::pdat::SideDoubleLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::SideFloatConstantRefine< DIM >
SAMRAI::pdat::SideFloatLinearTimeInterpolateOp< DIM >
SAMRAI::pdat::SideGeometry< DIM >
SAMRAI::pdat::SideIndex< DIM >
SAMRAI::pdat::SideIntegerConstantRefine< DIM >
SAMRAI::pdat::SideIterator< DIM >
SAMRAI::pdat::SideOverlap< DIM >
SAMRAI::pdat::SideVariable< DIM, TYPE >
SAMRAI::pdat::SumOperation< TYPE >Class SumOperation<TYPE> encapsulates a summation operation into an object
SAMRAI::solv::CartesianRobinBcHelper< DIM >Helper utility for setting Robin boundary conditions
SAMRAI::solv::CellPoissonFACOps< DIM >FAC operator class to solve Poisson's equation on a SAMR grid, using cell-centered, second-order finite-volume method, with Robin boundary conditions
SAMRAI::solv::CellPoissonFACSolver< DIM >Class for solving scalar Poisson's equation on SAMR grid, wrapping up lower-level components (FAC cycling, Poisson equation operations and boundary conditions) in a single high-level interface
SAMRAI::solv::CellPoissonHypreSolver< DIM >Use the HYPRE preconditioner library to solve (the cell-centered) Poisson's equation on a single level in a hierarchy
SAMRAI::solv::CVODEAbstractFunctions
SAMRAI::solv::CVODESolverClass CVODESolver serves as a C++ wrapper for the CVODE ordinary differential equation solver package
SAMRAI::solv::FACOperatorStrategy< DIM >Defines a Strategy pattern interface to problem-specific operations needed to implement the FAC preconditioner algorithm
SAMRAI::solv::FACPreconditioner< DIM >Implements the FAC iterative solution procedure for a linear system of equations, Au=f, defined on some subset of levels in an AMR patch hierarchy
SAMRAI::solv::GhostCellRobinBcCoefs< DIM >A prefabricated Robin boundary condition coefficients for the case where cell-centered data is fixed at the first ghost-cell centers
SAMRAI::solv::KINSOL_SAMRAIContext< DIM >Wraps the KINSOLSolver C++ wrapper class so that KINSOL may be used in applications that require a nonlinear solver
SAMRAI::solv::KINSOLAbstractFunctions
SAMRAI::solv::KINSOLSolver
SAMRAI::solv::LocationIndexRobinBcCoefs< DIM >A prefabricated Robin boundary condition coefficients for coefficients that are entirely specified by the boundary box location index
SAMRAI::solv::NonlinearSolverStrategy< DIM >Abstract base class defining interface between an algs::ImplicitIntegrator object and a nonlinear solver used to advance the solution in time
SAMRAI::solv::PETSc_SAMRAIVectorReal< DIM, TYPE >
SAMRAI::solv::PETScAbstractVectorReal< TYPE >
SAMRAI::solv::PoissonSpecificationsLight class holding specifications for cell-centered implementation of the scalar Poisson equation
SAMRAI::solv::RobinBcCoefStrategy< DIM >Interface for specifying Robin boundary conditions
SAMRAI::solv::SAMRAIVectorReal< DIM, TYPE >
SAMRAI::solv::SimpleCellRobinBcCoefs< DIM >A prefabricated Robin boundary condition coefficients with an interface like the old Poisson solvers
SAMRAI::solv::SNES_SAMRAIContext< DIM >
SAMRAI::solv::SNESAbstractFunctionsAbstract base class that declares the functions to be used with the PETSc SNES nonlinear solver package
SAMRAI::solv::Sundials_SAMRAIVector< DIM >
SAMRAI::solv::SundialsAbstractVector
SAMRAI::tbox::AbortAppender
SAMRAI::tbox::AbstractStream
SAMRAI::tbox::Arena
SAMRAI::tbox::ArenaManager
SAMRAI::tbox::Array< TYPE >
SAMRAI::tbox::AsyncCommGroupSupports many-to-one and one-to-many asynchronous communication operations within a given group of processes by sending messages along the branches of a conceptual tree
SAMRAI::tbox::AsyncCommStageStage multiple asynchronous group communications so that the collective can advance asynchronously (as individual underlying MPI requests are completed)
SAMRAI::tbox::Clock
SAMRAI::tbox::ConstPointer< TYPE >
SAMRAI::tbox::ConstPointerBase
SAMRAI::tbox::DatabaseClass Database is an abstract base class for the input, restart, and visualization databases
SAMRAI::tbox::DatabaseBox
SAMRAI::tbox::DatabaseBox_PODPOD data for class DatabaseBox
SAMRAI::tbox::DatabaseFactoryAbstract base class factory used to build Database objects
SAMRAI::tbox::DebugAppender
SAMRAI::tbox::FileStream
SAMRAI::tbox::FixedArena
SAMRAI::tbox::HDFDatabase
SAMRAI::tbox::HDFDatabaseFactoryHDFDatabase factory
SAMRAI::tbox::IEEE
SAMRAI::tbox::InputManager
SAMRAI::tbox::JobRelauncherManages an algorithm consisting of multiple relaunchable jobs
SAMRAI::tbox::List< TYPE >
SAMRAI::tbox::ListIterator< TYPE >
SAMRAI::tbox::ListNode< TYPE >
SAMRAI::tbox::Logger
SAMRAI::tbox::Logger::Appender
SAMRAI::tbox::MathUtilities< TYPE >
SAMRAI::tbox::MemoryDatabase
SAMRAI::tbox::MemoryDatabaseFactoryMemoryDatabase factory
SAMRAI::tbox::MemoryUtilitiesClass MemoryUtilities provides utility methods to access information about the memory characteristics of an application. Currently, there are only methods, one called "printMemoryInfo()" which does a simple dump of the current memory usage on a processor, and "recordMemoryInfo()" which records the memory for post-process analysis
SAMRAI::tbox::MessageStream
SAMRAI::tbox::NullDatabase
SAMRAI::tbox::ParallelBuffer
SAMRAI::tbox::Parser
SAMRAI::tbox::PIO
SAMRAI::tbox::Pointer< TYPE >
SAMRAI::tbox::PointerBase
SAMRAI::tbox::ReferenceCounter
SAMRAI::tbox::RelaunchableJobDefine interface for a relaunchable job managed by JobRelauncher
SAMRAI::tbox::RestartManager
SAMRAI::tbox::SAMRAI_MPIProvides C++ wrapper around MPI routines
SAMRAI::tbox::SAMRAIManagerClass SAMRAIManager is a utility for managing startup and shutdown for SAMRAI applications and for changing the maximum number of patch data components supported by SAMRAI patches. All applications should call SAMRAIManager::startup() (or SAMRAIManager::startup()) at the beginning of the program. Startup should be called after initializing MPI but before any SAMRAI objects are used. SAMRAIManager::shutdown() (or SAMRAIManager:shutdown()) should be called near the end of the program, but before shutting down MPI and calling exit(0). Note that the shutdown function does not exit the program; it merely shuts down certain packages and deallocates memory (mostly objects with static members)
SAMRAI::tbox::ScheduleClass Schedule is used to construct and execute a set of data communication transactions. Each transaction represents some data dependency and exchange between two processors, or locally involving a single processor. Once a communication schedule is constructed, transactions are provided to the schedule, using either the addTransaction() method or the appendTransaction() method. The schedule is then executed forcing the communication, either interprocessor or local to occur. The basic idea behind the schedule is that it enables the cost of assembling communication dependencies and data transfers over many communication phases
SAMRAI::tbox::Schedule::ScheduleMessageStream
SAMRAI::tbox::ScratchArena
SAMRAI::tbox::Serializable
SAMRAI::tbox::ShutdownRegistryClass ShutdownRegistry is a utility for managing callbacks at program completion
SAMRAI::tbox::ShutdownRegistryItem
SAMRAI::tbox::SiloDatabaseFactorySiloDatabase factory
SAMRAI::tbox::StandardArena
SAMRAI::tbox::Statistic
SAMRAI::tbox::Statistic::PatchStat
SAMRAI::tbox::Statistic::PatchStatRecord
SAMRAI::tbox::Statistic::ProcStat
SAMRAI::tbox::Statistician
SAMRAI::tbox::StatisticRestartDatabase
SAMRAI::tbox::StatTransaction
SAMRAI::tbox::Timer
SAMRAI::tbox::TimerManager
SAMRAI::tbox::Tracer
SAMRAI::tbox::Transaction
SAMRAI::tbox::Utilities
SAMRAI::tbox::WarningAppender
SAMRAI::tbox::XDRStream
SAMRAI::xfer::BoxGeometryFillPattern< DIM >
SAMRAI::xfer::CoarsenAlgorithm< DIM >Class CoarsenAlgorithm<DIM> encapsulates the AMR communication pattern to coarsen data from a finer level to any coarser level. Most often, data is coarsened from the interiors of source patch components on the source patch level into interiors of destination patch components on the destination level. See comments for the coarsen algorithm constructor for variations that are possible for (adventurous?) users. If the coarsening operators require ghost cells on a source component, then sufficient ghost cell storage must be provided by the source patch data component, and those ghost cells must be filled before calling the data coarsening routines
SAMRAI::xfer::CoarsenClasses< DIM >
SAMRAI::xfer::CoarsenClasses< DIM >::Data
SAMRAI::xfer::CoarsenCopyTransaction< DIM >Class CoarsenCopyTransaction<DIM> represents a single copy communication transaction between two processors or a local data copy for coaren schedules. Note that to there is an implicit hand-shaking between objects of this class and the CoarsenSchedule<DIM> object that constructs them. Following the coarsen schedule implementation, the source patch data index for a copy transaction always refers to the source data, and the destination patch data index for a copy transaction is always the destination data, all as defined in the CoarsenClasses<DIM> class
SAMRAI::xfer::CoarsenOperator< DIM >
SAMRAI::xfer::CoarsenPatchStrategy< DIM >Class CoarsenPatchStrategy<DIM> is an abstract base class that defines a Strategy pattern interface for operations that a user must supply for application-specific coarsening of data between two levels in an AMR patch hierarchy. A concrete subclass must define three member functions to perform the following tasks:
SAMRAI::xfer::CoarsenSchedule< DIM >Class CoarsenSchedule<DIM> performs the communication operations to coarsen data from a finer level to a coarser level
SAMRAI::xfer::CoarsenTransactionFactory< DIM >Abstract base class defining the interface for all concrete transaction factory objects that generate data transaction objects used with a CoarsenSchedule<DIM> object. A concrete subclass will allocate new transaction objects. This class is an example of the ``Abstract Factory'' method described in the Design Patterns book by Gamma, et al
SAMRAI::xfer::FillBoxSet< DIM >
SAMRAI::xfer::Geometry< DIM >
SAMRAI::xfer::LocallyActiveDataCoarsenAlgorithm< DIM >Class LocallyActiveDataCoarsenAlgorithm<DIM> encapsulates the AMR communication pattern to coarsen locally-active data from a finer level to a coarser level where the data exists on both the coarse and fine levels. Most often, data is coarsened from the interiors of source patch components on the source patch level into interiors of destination patch components on the destination level. See comments for the coarsen algorithm constructor for variations that are possible for (adventurous?) users. If the coarsening operators require ghost cells on a source component, then sufficient ghost cell storage must be provided by the source patch data component, and those ghost cells must be filled before calling the data coarsening routines
SAMRAI::xfer::LocallyActiveDataCoarsenPatchStrategy< DIM >Class LocallyActiveDataCoarsenPatchStrategy is an abstract base class that defines a Strategy pattern interface for operations that a user may supply for application-specific coarsening of locally-active data between two levels in an AMR patch hierarchy. This interface class is similar to the CoarsenPatchStrategy interface, except that it is used to treat locally-active patch data. A concrete subclass must define three member functions to perform the following tasks:
SAMRAI::xfer::LocallyActiveDataCoarsenSchedule< DIM >Class LocallyActiveDataCoarsenSchedule<DIM> performs the communication operations that coarsen locally-active data from a finer level to a coarser level
SAMRAI::xfer::LocallyActiveDataCoarsenTransactionFactory< DIM >Abstract base class defining the interface for all concrete transaction factory objects that generate data transaction objects used with a LocallyActiveDataCoarsenSchedule<DIM> object. A concrete subclass will allocate new transaction objects. This class is an example of the ``Abstract Factory'' method described in the Design Patterns book by Gamma, et al
SAMRAI::xfer::LocallyActiveDataFillBox< DIM >
SAMRAI::xfer::LocallyActiveDataFillBoxSet< DIM >
SAMRAI::xfer::LocallyActiveDataRefineAlgorithm< DIM >Class LocallyActiveDataRefineAlgorithm<DIM> encapsulates the AMR communication pattern to refine data to, copy data to, or fill physical boundary data on a destination patch level, where the data may be defined only on some patches (i.e., the patch data is "locally-active"). The basic procedure for moving data follows three steps:
  1. spatially interpolate data from coarser levels
  2. copy data from the same level of refinement
  3. fill physical boundary conditions regions
SAMRAI::xfer::LocallyActiveDataRefinePatchStrategy< DIM >Class LocallyActiveDataRefinePatchStrategy is an abstract base class that defines a Strategy pattern interface for operations that a user may supply for application-specific refining of locally-active data between levels in an AMR patch hierarchy and filling of physical boundary values. A concrete subclass must define four member functions to perform the following tasks:
SAMRAI::xfer::LocallyActiveDataRefineSchedule< DIM >Class LocallyActiveDataRefineSchedule<DIM> performs the communication operations that refine data to, copy data to, or fill physical boundary data on a destination patch level, where the data may be defined only on some patches (i.e., the patch data is "locally-active"). This class is based on the RefineSchedule<DIM> class. However, it has a reduced set of functionality since it treats locally-active data. For example, this class does not support time interpolation, and there is only one version of the constructor (vs. three for RefineSchedule<DIM>), the schedule cannot be reset, etc
SAMRAI::xfer::LocallyActiveDataRefineTransactionFactory< DIM >Abstract base class defining the interface for all concrete transaction factory objects that generate data transaction objects used with a LocallyActiveDataRefineSchedule<DIM> object. A concrete subclass will allocate new transaction objects. This class is an example of the ``Abstract Factory'' method described in the Design Patterns book by Gamma, et al
SAMRAI::xfer::MultiblockCoarsenAlgorithm< DIM >Class MultiblockCoarsenAlgorithm<DIM> encapsulates the AMR communication pattern to coarsen data from a finer level to any coarser level in a multiblock domain. Most often, data is coarsened from the interiors of source patch components on the source patch level into interiors of patch components on the destination level. If the coarsening operators require ghost cells on a source component, then sufficient ghost cell storage must be provided by the source patch data component, and those ghost cells must be filled before calling the data coarsening routines
SAMRAI::xfer::MultiblockCoarsenPatchStrategy< DIM >Class MultiblockCoarsenPatchStrategy is an abstract base class that provides interfaces between coarsen operations in the multiblock classes and user's problem specific routines. In general, it mimics the standard CoarsenPatchStrategy class but implements some additional methods that supply information about the blocks
SAMRAI::xfer::MultiblockCoarsenSchedule< DIM >Class MultiblockCoarsenSchedule<DIM> encapsulates the AMR communication pattern to coarsen data from a finer level to a coarser level
SAMRAI::xfer::MultiblockRefineAlgorithm< DIM >Class MultiblockRefineAlgorithm<DIM> is an extension of the concept of xfer::RefineAlgorithm<DIM> to be used in applications that require a multiblock domain
SAMRAI::xfer::MultiblockRefinePatchStrategy< DIM >Class MultiblockRefinePatchStrategy is a virtual base class that provides interfaces for users to problem-specific routines related to issues that arise in multiblock domains, particularly the filling of boundary conditions around a singularity
SAMRAI::xfer::MultiblockRefineSchedule< DIM >
SAMRAI::xfer::MultiblockRefineSchedule< DIM >::SingularityPatchStruct SingularityPatch allows a temporary patch that contains data near a singularity to be paired with a block id number
SAMRAI::xfer::RefineAlgorithm< DIM >Class RefineAlgorithm<DIM> encapsulates the AMR communication pattern to refine data to, copy data to, or fill physical boundary data on any destination patch level. The basic procedure for moving data follows three steps:
  1. interpolate data (spatial and possibly temporal) from coarser levels
  2. copy data from the same level of refinement
  3. fill physical boundary conditions regions
SAMRAI::xfer::RefineClasses< DIM >
SAMRAI::xfer::RefineClasses< DIM >::Data
SAMRAI::xfer::RefineCopyTransaction< DIM >Class RefineCopyTransaction<DIM> represents a single copy communication transaction between two processors or a local data copy for refine schedules. Note that to there is an implicit hand-shaking between objects of this class and the RefineSchedule<DIM> object that constructs them. Following the refine schedule implementation, the source patch data index for a copy transaction always refers to the source data and the destination patch data index for a copy transaction is always the scratch data, all as defined in the RefineClasses<DIM> class
SAMRAI::xfer::RefineOperator< DIM >
SAMRAI::xfer::RefinePatchStrategy< DIM >Class RefinePatchStrategy<DIM> is an abstract base class that defines a Strategy pattern interface for operations that a user must supply for application-specific refining of data between levels in an AMR patch hierarchy and filling of physical boundary values. A concrete subclass must define four member functions to perform the following tasks:
SAMRAI::xfer::RefineSchedule< DIM >Class RefineSchedule<DIM> performs the communication operations that refine data to, copy data to, or fill physical boundary data on a destination patch level
SAMRAI::xfer::RefineTimeTransaction< DIM >Class RefineTimeTransaction<DIM> represents a single time interpolation communication transaction between two processors or a local data copy or refine schedules. Note that to there is an implicit hand-shaking between objects of this class and the RefineSchedule<DIM> object that constructs them. Following the refine schedule implementation, the source patch data indices for a time transaction are always refer to the old and new source data and the destination patch data index for a time transaction is always the scratch data, all as defined in the RefineClasses<DIM> class. This transaction is used by the refine schedule
SAMRAI::xfer::RefineTransactionFactory< DIM >Abstract base class defining the interface for all concrete transaction factory objects that generate data transaction objects used with a RefineSchedule<DIM> object. A concrete subclass will allocate new transaction objects. This class is an example of the ``Abstract Factory'' method described in the Design Patterns book by Gamma, et al
SAMRAI::xfer::StandardCoarsenTransactionFactory< DIM >Concrete subclass of CoarsenTransactionFactory<DIM> base class that allocates CoarsenCopyTransaction<DIM> objects for a CoarsenSchedule<DIM> object
SAMRAI::xfer::StandardLocallyActiveDataCoarsenTransactionFactory< DIM >Concrete subclass of LocallyActiveDataCoarsenTransactionFactory<DIM> base class that allocates CoarsenCopyTransaction<DIM> objects for a LocallyActiveDataCoarsenSchedule<DIM> object
SAMRAI::xfer::StandardLocallyActiveDataRefineTransactionFactory< DIM >Concrete subclass of LocallyActiveDataRefineTransactionFactory<DIM> base class that allocates RefineCopyTransaction<DIM> and RefineTimeTransaction<DIM> objects for a LocallyActiveDataRefineSchedule<DIM> object
SAMRAI::xfer::StandardRefineTransactionFactory< DIM >Concrete subclass of RefineTransactionFactory<DIM> base class that allocates RefineCopyTransaction<DIM> and RefineTimeTransaction<DIM> objects for a RefineSchedule<DIM> object
SAMRAI::xfer::TimeInterpolateOperator< DIM >
SAMRAI::xfer::VariableFillPattern< DIM >
DescribedClass
XDR
yy_buffer_state
yyalloc
YYSTYPE

Generated on Thu Jun 18 11:28:17 2009 for SAMRAI by  doxygen 1.5.1