| 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::BoundaryUtilityStrategy | Class 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::CartesianBoundaryUtilities2 | Class 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::CartesianBoundaryUtilities3 | Class 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::EmbeddedBoundaryDefines | Class 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::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 |
| 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 >::CommunicationStruct | Data 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 >::Neighbor | Structure 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 >::CommonParams | Parameters 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::ArrayDataAccess | Utility 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::CVODESolver | Class 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::PoissonSpecifications | Light 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::SNESAbstractFunctions | Abstract 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::AsyncCommGroup | Supports 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::AsyncCommStage | Stage 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::Database | Class Database is an abstract base class for the input, restart, and visualization databases |
| SAMRAI::tbox::DatabaseBox | |
| SAMRAI::tbox::DatabaseBox_POD | POD data for class DatabaseBox |
| SAMRAI::tbox::DatabaseFactory | Abstract base class factory used to build Database objects |
| SAMRAI::tbox::DebugAppender | |
| SAMRAI::tbox::FileStream | |
| SAMRAI::tbox::FixedArena | |
| SAMRAI::tbox::HDFDatabase | |
| SAMRAI::tbox::HDFDatabaseFactory | HDFDatabase factory |
| SAMRAI::tbox::IEEE | |
| SAMRAI::tbox::InputManager | |
| SAMRAI::tbox::JobRelauncher | Manages 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::MemoryDatabaseFactory | MemoryDatabase factory |
| SAMRAI::tbox::MemoryUtilities | Class 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::RelaunchableJob | Define interface for a relaunchable job managed by JobRelauncher |
| SAMRAI::tbox::RestartManager | |
| SAMRAI::tbox::SAMRAI_MPI | Provides C++ wrapper around MPI routines |
| SAMRAI::tbox::SAMRAIManager | Class 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::Schedule | Class 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::ShutdownRegistry | Class ShutdownRegistry is a utility for managing callbacks at program completion |
| SAMRAI::tbox::ShutdownRegistryItem | |
| SAMRAI::tbox::SiloDatabaseFactory | SiloDatabase 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:
- spatially interpolate data from coarser levels
- copy data from the same level of refinement
- 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 >::SingularityPatch | Struct 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:
- interpolate data (spatial and possibly temporal) from coarser levels
- copy data from the same level of refinement
- 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 | |
