| SAMRAI::tbox::AbstractStream | |
| SAMRAI::tbox::Arena | |
| SAMRAI::tbox::ArenaManager | |
| arith_functions | |
| SAMRAI::tbox::Array< TYPE > | |
| SAMRAI::pdat::ArrayData< DIM, TYPE > | |
| SAMRAI::math::ArrayDataBasicOps< DIM, TYPE > | |
| SAMRAI::pdat::ArrayDataIterator< DIM > | |
| SAMRAI::math::ArrayDataMiscellaneousOpsReal< DIM, TYPE > | |
| SAMRAI::math::ArrayDataNormOpsComplex< DIM > | |
| SAMRAI::math::ArrayDataNormOpsInteger< DIM > | |
| SAMRAI::math::ArrayDataNormOpsReal< 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::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::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::hier::BasePatchHierarchy< DIM > | |
| SAMRAI::hier::BasePatchLevel< DIM > | |
| 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::hier::BinaryTree< DIM > | |
| SAMRAI::hier::BoundaryBox< DIM > | |
| SAMRAI::hier::BoundaryLookupTable< 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::hier::Box< DIM > | |
| SAMRAI::hier::BoxArray< DIM > | |
| SAMRAI::hier::BoxComm< DIM > | |
| SAMRAI::mesh::BoxGeneratorStrategy< 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::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::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::solv::CartesianRobinBcHelper< DIM > | Helper utility for setting Robin boundary conditions |
| SAMRAI::geom::CartesianSideComplexWeightedAverage< DIM > | |
| SAMRAI::geom::CartesianSideDoubleConservativeLinearRefine< DIM > | |
| SAMRAI::geom::CartesianSideDoubleWeightedAverage< DIM > | |
| SAMRAI::geom::CartesianSideFloatConservativeLinearRefine< DIM > | |
| SAMRAI::geom::CartesianSideFloatWeightedAverage< DIM > | |
| SAMRAI::appu::CartesianVizamraiDataWriter< DIM > | |
| SAMRAI::pdat::CellComplexConstantRefine< DIM > | |
| SAMRAI::pdat::CellComplexLinearTimeInterpolateOp< DIM > | |
| SAMRAI::pdat::CellData< DIM, TYPE > | Class CellData<DIM> manages data defined on cell centers in patches. It is a templated cell-centered patch data structure derived from hier::PatchData<DIM>. Given a box, a cell data object represents cell-centered data of some template TYPE with a specified depth (that is, number of components for each spatial location). See the cell geometry class for more information about the translation between the 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::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::pdat::CellVariable< DIM, TYPE > | |
| SAMRAI::tbox::Clock | |
| 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::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::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::tbox::ConstPointer< TYPE > | |
| SAMRAI::tbox::ConstPointerBase | |
| SAMRAI::appu::CutCell< DIM > | The CutCell struct holds data and methods to define a cut-cell on an irregular boundary |
| 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 |
| DescribedClass | |
| DescribedClass | |
| DescribedClass | |
| DescribedClass | |
| SAMRAI::pdat::EdgeComplexConstantRefine< DIM > | |
| SAMRAI::pdat::EdgeComplexLinearTimeInterpolateOp< DIM > | |
| SAMRAI::pdat::EdgeData< DIM, TYPE > | Class EdgeData<DIM> manages data defined on edges of cells in patches. It is a templated edge-centered patch data structure derived from hier::PatchData<DIM>. Given a box, an edge data object represents edge-centered data of some template TYPE with a specified depth (that is, number of components for each spatial location). See the edge geometry class for more information about the translation between the 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::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::pdat::FaceComplexConstantRefine< DIM > | |
| SAMRAI::pdat::FaceComplexLinearTimeInterpolateOp< DIM > | |
| SAMRAI::pdat::FaceData< DIM, TYPE > | Class FaceData<DIM> manages data defined on faces of cells in patches. It is a templated face-centered patch data structure derived from hier::PatchData<DIM>. Given a box, a face data object represents face-centered data of some template TYPE with a specified depth (that is, number of components for each spatial location). See the face geometry class for more information about the translation between the 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::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::tbox::FileStream | |
| SAMRAI::xfer::FillBoxSet< DIM > | |
| SAMRAI::tbox::FixedArena | |
| SAMRAI::xfer::Geometry< DIM > | |
| 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::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::hier::GridGeometry< DIM > | |
| SAMRAI::tbox::HDFDatabase | |
| 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::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::algs::HyperbolicLevelIntegrator< DIM > | |
| SAMRAI::algs::HyperbolicPatchStrategy< DIM > | |
| SAMRAI::tbox::IEEE | |
| 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::hier::Index< DIM > | |
| SAMRAI::pdat::IndexData< DIM, TYPE > | |
| SAMRAI::pdat::IndexDataFactory< DIM, TYPE > | |
| SAMRAI::pdat::IndexDataNode< DIM, TYPE > | |
| SAMRAI::pdat::IndexIterator< DIM, TYPE > | |
| SAMRAI::pdat::IndexVariable< DIM, TYPE > | |
| SAMRAI::tbox::InputDatabase | |
| SAMRAI::tbox::InputManager | |
| SAMRAI::hier::IntVector< DIM > | |
| SAMRAI::tbox::JobRelauncher | Manages an algorithm consisting of multiple relaunchable jobs |
| KeyData | |
| 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::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::tbox::List< TYPE > | |
| SAMRAI::tbox::ListIterator< TYPE > | |
| SAMRAI::tbox::ListNode< TYPE > | |
| SAMRAI::mesh::LoadBalancer< DIM > | Class LoadBalancer<DIM> provides load balancing routines for AMR hierarchy levels based on either uniform or non-uniform workload estimates. This class is derived from the abstract base class LoadBalanceStrategy<DIM>; thus, it is a concrete implementation of the load balance Strategy pattern interface |
| 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::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::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 is not clearly defined |
| 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::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::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::hier::LocallyActiveVariableDatabase< DIM > | Class LocallyActiveVariableDatabase is a Singleton class for managing variables and data that live on different sets of patches in an AMR patch hierarchy; i.e., they are "locally-active". Although this class is derived from the VariableDatabase class, this class does not extend the full range of functionality provided by the VariableDatabase base class. Instead, this class uses some of the functionality of the VariableDatabase base class so that it is not replicated here. For example, this class assumes that each variable is associated with only one patch data index and all variables registered with this class share the same variable context. However, the usage of this class is similar to the VariableDatabase class. To make usage of this class reasonably transparent all functions defined in the base class that make sense for this class are redeclared here |
| SAMRAI::solv::LocationIndexRobinBcCoefs< DIM > | A prefabricated Robin boundary condition coefficients for coefficients that are entirely specified by the boundary box location index |
| SAMRAI::tbox::MathUtilities< TYPE > | |
| SAMRAI::mblk::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::mblk::MBUtilities< DIM > | Class MBUtilities is a utility class to hold static functions related to multiblock functionality |
| 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::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::tbox::MPI | |
| SAMRAI::mblk::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::mblk::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::mblk::MultiblockCoarsenSchedule< DIM > | Class MultiblockCoarsenSchedule<DIM> encapsulates the AMR communication pattern to coarsen data from a finer level to a coarser level |
| SAMRAI::mblk::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::mblk::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::mblk::MultiblockPatchHierarchy< DIM > | Class MultiblockPatchHierarchy<DIM> manages an array of patch hierarchies that represent a multiblock domain, and describes the relationship between these hierarchies |
| SAMRAI::mblk::MultiblockPatchHierarchy< DIM >::Neighbor | Structure to represent the neighbor of a given block |
| SAMRAI::mblk::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::mblk::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::mblk::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::mblk::MultiblockRefineSchedule< DIM > | |
| SAMRAI::mblk::MultiblockRefineSchedule< DIM >::SingularityPatch | Struct SingularityPatch allows a temporary patch that contains data near a singularity to be paired with a block id number |
| SAMRAI::pdat::NodeComplexConstantAverage< DIM > | |
| SAMRAI::pdat::NodeComplexLinearTimeInterpolateOp< DIM > | |
| SAMRAI::pdat::NodeData< DIM, TYPE > | Class NodeData<DIM> manages data defined on nodes of cells in patches. It is a templated node-centered patch data structure derived from hier::PatchData<DIM>. Given a box, a node data object represents node-centered data of some template TYPE with a specified depth (that is, number of components for each spatial location). See the node geometry class for more information about the translation between the AMR index space and node-centered data |
| SAMRAI::pdat::NodeDataFactory< DIM, TYPE > | |
| SAMRAI::pdat::NodeDoubleConstantAverage< DIM > | |
| SAMRAI::pdat::NodeDoubleLinearTimeInterpolateOp< DIM > | |
| SAMRAI::pdat::NodeFloatConstantAverage< DIM > | |
| SAMRAI::pdat::NodeFloatLinearTimeInterpolateOp< DIM > | |
| SAMRAI::pdat::NodeGeometry< DIM > | |
| SAMRAI::pdat::NodeIndex< DIM > | |
| SAMRAI::pdat::NodeIntegerConstantAverage< DIM > | |
| SAMRAI::pdat::NodeIterator< DIM > | |
| SAMRAI::pdat::NodeOverlap< DIM > | |
| SAMRAI::pdat::NodeVariable< DIM, TYPE > | |
| 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::tbox::NullDatabase | |
| SAMRAI::pdat::OuteredgeData< DIM, TYPE > | Class OuteredgeData<DIM> is a templated edge-centered patch data structure derived from hier::PatchData<DIM>. It differs from the EdgeData<DIM> class in that, given a box, an outeredge data object represents edge-centered data living only on the border of the patch |
| 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::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::pdat::OuteredgeVariable< DIM, TYPE > | Class OuteredgeVariable<DIM> is a templated variable class used to define edge-centered quantities on patch boundaries |
| SAMRAI::pdat::OuterfaceComplexConstantRefine< DIM > | |
| SAMRAI::pdat::OuterfaceComplexLinearTimeInterpolateOp< DIM > | |
| SAMRAI::pdat::OuterfaceData< DIM, TYPE > | |
| 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 > | |
| SAMRAI::pdat::OuternodeData< DIM, TYPE > | Class OuternodeData is a templated node-centered patch data structure derived from hier::PatchData. It differs from the NodeData<DIM> class in that, given a box, an outernode data object represents node-centered data living only on the border of the patch |
| 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 > | Manages the mapping between the AMR index space and the outernode-centered geometry index space |
| 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::pdat::OuternodeVariable< DIM, TYPE > | Class OuternodeVariable<DIM> is a templated variable class used to define node-centered quantities on patch boundaries |
| SAMRAI::pdat::OutersideComplexLinearTimeInterpolateOp< DIM > | |
| SAMRAI::pdat::OutersideData< DIM, TYPE > | |
| SAMRAI::pdat::OutersideDataFactory< DIM, TYPE > | |
| SAMRAI::pdat::OutersideDoubleLinearTimeInterpolateOp< DIM > | |
| SAMRAI::pdat::OutersideFloatLinearTimeInterpolateOp< DIM > | |
| SAMRAI::pdat::OutersideGeometry< DIM > | |
| SAMRAI::pdat::OutersideVariable< DIM, TYPE > | |
| SAMRAI::tbox::ParallelBuffer | |
| SAMRAI::tbox::Parser | |
| SAMRAI::hier::Patch< DIM > | |
| 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::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::hier::PatchData< DIM > | |
| SAMRAI::hier::PatchDataFactory< DIM > | |
| 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::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::hier::PatchFactory< DIM > | |
| SAMRAI::hier::PatchGeometry< DIM > | |
| SAMRAI::hier::PatchHierarchy< DIM > | |
| SAMRAI::hier::PatchLevel< DIM > | |
| SAMRAI::hier::PatchLevelFactory< DIM > | |
| SAMRAI::hier::PatchLevelIterator< DIM > | |
| 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::solv::PETSc_SAMRAIVectorReal< DIM, TYPE > | |
| SAMRAI::solv::PETScAbstractVectorReal< TYPE > | |
| SAMRAI::tbox::PIO | |
| SAMRAI::tbox::Pointer< TYPE > | |
| SAMRAI::tbox::PointerBase | |
| SAMRAI::solv::PoissonSpecifications | Light class holding specifications for cell-centered implementation of the scalar Poisson equation |
| SAMRAI::hier::ProcessorMapping | |
| SAMRAI::solv::PVODEAbstractFunctions | |
| SAMRAI::solv::PVODESolver | Class PVODESolver serves as a C++ wrapper for the PVODE ordinary differential equation solver package |
| SAMRAI::solv::PVodeTrio_SAMRAIVector< DIM > | |
| SAMRAI::solv::PVodeTrioAbstractVector | |
| SAMRAI::tbox::ReferenceCounter | |
| 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::tbox::RelaunchableJob | Define interface for a relaunchable job managed by JobRelauncher |
| SAMRAI::tbox::RestartManager | |
| SAMRAI::solv::RobinBcCoefStrategy< DIM > | Interface for specifying Robin boundary conditions |
| 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::solv::SAMRAIVectorReal< DIM, TYPE > | |
| 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::pdat::SideComplexConstantRefine< DIM > | |
| SAMRAI::pdat::SideComplexLinearTimeInterpolateOp< DIM > | |
| SAMRAI::pdat::SideData< DIM, TYPE > | Class SideData<DIM> manages data defined on sides of cells in patches. It is a templated side-centered patch data structure derived from hier::PatchData<DIM>. Given a box, a side data object represents side-centered data of some template TYPE with a specified depth (that is, number of components for each index location). See the side geometry class for more information about the translation between the 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::solv::SimpleCellRobinBcCoefs< DIM > | A prefabricated Robin boundary condition coefficients with an interface like the old Poisson solvers |
| SAMRAI::geom::SkeletonCoarsen< DIM > | |
| SAMRAI::geom::SkeletonGridGeometry< DIM > | |
| SAMRAI::geom::SkeletonPatchGeometry< DIM > | |
| SAMRAI::geom::SkeletonRefine< DIM > | |
| 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::mesh::SpatialKey | |
| SAMRAI::tbox::StandardArena | |
| 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::mesh::StandardTagAndInitialize< DIM > | |
| SAMRAI::mesh::StandardTagAndInitStrategy< DIM > | |
| 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::mesh::TagAndInitializeStrategy< DIM > | |
| SAMRAI::xfer::TimeInterpolateOperator< DIM > | |
| SAMRAI::tbox::Timer | |
| SAMRAI::algs::TimeRefinementIntegrator< DIM > | |
| SAMRAI::algs::TimeRefinementLevelStrategy< DIM > | |
| SAMRAI::tbox::TimerManager | |
| SAMRAI::tbox::Tracer | |
| SAMRAI::tbox::Transaction | |
| SAMRAI::tbox::Utilities | |
| 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::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 |
| XDR | |
| SAMRAI::tbox::XDRStream | |
| yy_buffer_state | |
| yyalloc | |
| YYSTYPE | |
