| Camrex::AlgMG< T > | Algebraic multigrid solver for SpMatrix / AlgVector systems |
| Camrex::AlgPartition | |
| Camrex::AlgVector< T, Allocator > | Distributed dense vector that mirrors the layout of an AlgPartition |
| CAllocator | |
| Camrex::PODVector< T, Allocator > | |
| Camrex::PODVector< U, Allocator< U > > | |
| Camrex::PODVector< ParticleType, Allocator< ParticleType > > | |
| Camrex::PODVector< int, Allocator< int > > | |
| Camrex::PODVector< uint64_t, Allocator< uint64_t > > | |
| Camrex::PODVector< ParticleReal, Allocator< ParticleReal > > | |
| Cstd::allocator< T > | STL class |
| Camrex::PODVector< T, Allocator > | Dynamically allocated vector for trivially copyable data |
| CAllocT | |
| Camrex::PODVector< Real, AllocT > | |
| Camrex::PODVector< T, AllocT > | |
| Camrex::AmrAssignGrid< BinIteratorFactory > | |
| Camrex::AMRErrorTag | Flexible tagging rule that supports gradients, thresholds, boxes, and user functors |
| Camrex::AMRErrorTagInfo | Optional knobs that control AMRErrorTag behavior (time window, level limits, etc.) |
| Camrex::AMReX | Runtime context stored for each active amrex::Initialize() call |
| Camrex::AmrInfo | |
| Camrex::AmrMesh | |
| Camrex::AmrCore | Provide basic functionalities to set up an AMR hierarchy |
| Camrex::Amr | Manage hierarchy of levels for time-dependent AMR computations |
| Camrex::AmrLevel | Virtual base class for managing individual levels. AmrLevel functions both as a container for state data on a level and also manages the advancement of data in time |
| Camrex::AmrParticleLocator< Bins > | |
| Camrex::Any | Type-erased container similar to std::any, but supports move-only types |
| Camrex::Arena | Abstract base class for memory arenas |
| Camrex::BArena | Basic Arena that allocates aligned memory on the host heap |
| Camrex::CArena | Coalescing first-fit dynamic memory arena |
| Camrex::PArena | This arena uses CUDA stream-ordered memory allocator if available. If not, use The_Arena() |
| Camrex::SArena | A STREAM-ordered memory arena |
| Camrex::ArenaAllocatorBase< T, AR > | |
| Camrex::ArenaAllocatorBase< char, PolymorphicArenaWrapper > | |
| Camrex::PolymorphicArenaAllocator< char > | |
| Camrex::PODVector< char, amrex::PolymorphicArenaAllocator< char > > | |
| Camrex::ArenaAllocatorBase< int, PolymorphicArenaWrapper > | |
| Camrex::PolymorphicArenaAllocator< int > | |
| Camrex::PODVector< int, amrex::PolymorphicArenaAllocator< int > > | |
| Camrex::ArenaAllocatorBase< ParticleReal, PolymorphicArenaWrapper > | |
| Camrex::PolymorphicArenaAllocator< ParticleReal > | |
| Camrex::PODVector< ParticleReal, amrex::PolymorphicArenaAllocator< ParticleReal > > | |
| Camrex::ArenaAllocatorBase< T, ArenaWrapper > | |
| Camrex::ArenaAllocator< T > | |
| Camrex::PODVector< T, ArenaAllocator< T > > | |
| Camrex::PODVector< T, DefaultAllocator< T > > | |
| Camrex::PODVector< ParticleType, DefaultAllocator< ParticleType > > | |
| Camrex::PODVector< Real, DefaultAllocator< Real > > | |
| Camrex::PODVector< ParticleReal *, DefaultAllocator< ParticleReal * > > | |
| Camrex::PODVector< int *, DefaultAllocator< int * > > | |
| Camrex::PODVector< const ParticleReal *, DefaultAllocator< const ParticleReal * > > | |
| Camrex::PODVector< const int *, DefaultAllocator< const int * > > | |
| Camrex::PODVector< uint64_t, DefaultAllocator< uint64_t > > | |
| Camrex::PODVector< ParticleReal, DefaultAllocator< ParticleReal > > | |
| Camrex::PODVector< int, DefaultAllocator< int > > | |
| Camrex::ArenaAllocatorBase< T, AsyncArenaWrapper > | |
| Camrex::AsyncArenaAllocator< T > | |
| Camrex::PODVector< T, AsyncArenaAllocator< T > > | |
| Camrex::ArenaAllocatorBase< T, DeviceArenaWrapper > | |
| Camrex::DeviceArenaAllocator< T > | |
| Camrex::PODVector< T, DeviceArenaAllocator< T > > | |
| Camrex::ArenaAllocatorBase< T, ManagedArenaWrapper > | |
| Camrex::ManagedArenaAllocator< T > | |
| Camrex::PODVector< T, ManagedArenaAllocator< T > > | |
| Camrex::ArenaAllocatorBase< T, PinnedArenaWrapper > | |
| Camrex::PinnedArenaAllocator< T > | |
| Camrex::PODVector< T, PinnedArenaAllocator< T > > | |
| Camrex::ArenaAllocatorBase< T, PolymorphicArenaWrapper > | |
| Camrex::PolymorphicArenaAllocator< T > | |
| Camrex::ArenaAllocatorBase< uint64_t, PolymorphicArenaWrapper > | |
| Camrex::PolymorphicArenaAllocator< uint64_t > | |
| Camrex::PODVector< uint64_t, amrex::PolymorphicArenaAllocator< uint64_t > > | |
| Camrex::ArenaInfo | Configuration options for constructing an Arena |
| Camrex::ArenaWrapper | |
| Camrex::Array1D< T, XLO, XHI > | A GPU-compatible one-dimensional array |
| Camrex::Array2D< T, XLO, XHI, YLO, YHI, ORDER > | A GPU-compatible two-dimensional array |
| Camrex::Array3D< T, XLO, XHI, YLO, YHI, ZLO, ZHI, ORDER > | A GPU-compatible three-dimensional array |
| Camrex::Array4BoxOffsetTag< T > | |
| Camrex::Array4BoxOrientationTag< T > | |
| Camrex::Array4BoxTag< T > | |
| Camrex::Array4BoxValTag< T > | |
| Camrex::Array4CopyTag< T0, T1 > | |
| Camrex::Array4MaskCopyTag< T0, T1 > | |
| Camrex::Array4PairTag< T > | |
| Camrex::Array4Tag< T > | |
| Camrex::ArrayND< T, N, last_dim_component > | A multidimensional array accessor |
| Camrex::ArrayND< T, 4, true > | |
| Camrex::PolymorphicArray4< T > | Array4 subclass that provides uniform |
| Camrex::ArrayOfStructs< T_ParticleType, Allocator > | |
| Camrex::ArrayView< T > | |
| Camrex::AssignGrid< BinIteratorFactory > | |
| Camrex::AssignGridFilter | |
| Camrex::AsyncArenaWrapper | |
| Camrex::AsyncArray< T > | |
| Camrex::Gpu::AsyncArray< T > | |
| Camrex::Gpu::AtomicAdd< T > | |
| Camrex::Gpu::AtomicLogicalAnd< T > | |
| Camrex::Gpu::AtomicLogicalOr< T > | |
| Camrex::Gpu::AtomicMax< T > | |
| Camrex::Gpu::AtomicMin< T > | |
| Camrex::ParticleCopyPlan::AtomicScatterAlgorithm | |
| Camrex::AuxBoundaryData | |
| CB1 | |
| Camrex::Conjunction< B1 > | |
| Camrex::Disjunction< B1 > | |
| Camrex::BackgroundThread | Utility class running deferred work on a single background thread |
| Camrex::ParticleInterpolator::Base< Derived, WeightType > | A base class for doing general particle/mesh interpolation operations |
| Camrex::ParticleInterpolator::Base< Linear, amrex::ParticleMeshReal > | |
| Camrex::ParticleInterpolator::Linear | A class the implements linear (CIC) particle/mesh interpolation |
| Camrex::ParticleInterpolator::Base< Nearest, int > | |
| Camrex::ParticleInterpolator::Nearest | A class the implements nearest grid point particle/mesh interpolation |
| Camrex::BCRec | Boundary condition record storing low/high face types per coordinate |
| Camrex::MLTerrainPoisson::BCTag | |
| Camrex::FabArrayBase::BDKey | |
| Camrex::BiCGStab< V, M > | BiCGStab solver with right preconditioning |
| Camrex::BinIterator< T > | |
| Camrex::BinMapper | |
| Camrex::BLBackTrace | |
| Camrex::BLBTer | |
| Camrex::BLProfiler | |
| Camrex::StateDescriptor::BndryFunc | |
| Camrex::BndryFuncArray | This version calls function working on array |
| Camrex::BndryRegisterT< MF > | A BndryRegister organizes FabSets bounding each grid in a BoxArray. A FabSet is maintained for each boundary orientation, as well as the BoxArray domain of definition |
| Camrex::BndryDataT< MF > | A BndryData stores and manipulates boundary data information on each side of each box in a BoxArray |
| Camrex::InterpBndryDataT< MF > | An InterpBndryData object adds to a BndryData object the ability to manipulate and set the data stored in the boundary cells |
| Camrex::MLMGBndryT< MF > | Boundary helper for MLMG that manages coarse/fine and physical BC metadata |
| Camrex::BndryRegisterT< fMultiFab > | |
| Camrex::BndryDataT< fMultiFab > | |
| Camrex::InterpBndryDataT< fMultiFab > | |
| Camrex::BndryRegisterT< MultiFab > | |
| Camrex::BndryDataT< MultiFab > | |
| Camrex::InterpBndryDataT< MultiFab > | |
| Camrex::MLMGBndryT< MultiFab > | |
| Camrex::FluxRegister | Flux Register |
| Camrex::BoundCond | Maintain an identifier for boundary condition types |
| Camrex::BoxArray | Reference-counted collection of Boxes |
| Camrex::BoxConverter | |
| Camrex::InterpolaterBoxCoarsener | |
| Camrex::BoxIndexerND< dim > | Utility that maps flattened point indices back to IntVectND coordinates |
| Camrex::BoxIndexerND< 1 > | Specialization for the 1D case where no fast-division table is needed |
| Camrex::BoxIteratorND< dim > | Iterator over all IntVects in a Box |
| Camrex::BoxList | A list of Boxes sharing a common IndexType |
| Camrex::BoxDomain | A list of disjoint boxes built on top of BoxList |
| Camrex::BoxND< dim > | A Rectangular Domain on an Integer Lattice |
| Camrex::Gpu::Buffer< T > | |
| Camrex::ParticleCopyPlan::BuildWorkspace | |
| Camrex::EB2::Cell | Per-cell geometric information stored in EB graphs |
| Camrex::CellData< T > | Lightweight accessor for data associated with a single cell |
| Camrex::CellIndexEnum | Type for defining CellIndex so that all IndexTypeND with different dimensions have the same CellIndex type |
| Camrex::IndexTypeND< 3 > | |
| Camrex::IndexTypeND< dim > | Cell-Based or Node-Based Indices |
| Camrex::FabArrayBase::CFinfo | Coarse/fine boundary |
| Camrex::ChebyshevSmoother< T > | Chebyshev polynomial smoother for AlgVector/SpMatrix systems |
| Camrex::EB2::ChkptFile | Helper that serializes EB geometry to disk for restartability |
| Camrex::Cluster | A cluster of tagged cells |
| Camrex::ClusterList | A list of Cluster objects |
| Camrex::NonLocalBC::CommData | This class holds data buffers for either immediate MPI send or recv calls |
| Camrex::CommHandler | This class stores both recv and send buffers with an associated MPI tag |
| Camrex::NonLocalBC::CommHandler | This class stores both recv and send buffers with an associated MPI tag |
| Camrex::FabArrayBase::CommMetaData | |
| Camrex::FabArrayBase::CPC | Parallel copy or add |
| Camrex::FabArrayBase::FB | FillBoundary |
| Camrex::FabArrayBase::PolarB | Fill polar boundary in spherical coordinates |
| Camrex::FabArrayBase::RB180 | Rotate Boundary by 180 |
| Camrex::FabArrayBase::RB90 | Rotate Boundary by 90 |
| Camrex::NonLocalBC::MultiBlockCommMetaData | This is the index mapping based on the DTOS MultiBlockDestToSrc |
| Camrex::SpMatrix< T, Allocator >::CommMV | |
| Camrex::CommRecvBufTag< T > | |
| Camrex::CommSendBufTag< T > | |
| Camrex::SpMatrix< T, Allocator >::CommTR | |
| Camrex::CompileTimeOptions< ctr > | |
| Camrex::EB2::ComplementIF< F > | Implicit function wrapper that swaps interior/exterior |
| Camrex::ForkJoin::ComponentSet | If strategy == split, use this to specify how to split components across tasks |
| Cstd::conditional_t | |
| Camrex::Conjunction< B1, Bn... > | |
| Camrex::Disjunction< B1, Bn... > | |
| Camrex::Neighbors< ParticleType >::const_iterator | |
| Camrex::ConstParticleCPUWrapper | |
| Camrex::ConstParticleIDWrapper | |
| Camrex::ConstParticleTileData< T_ParticleType, NArrayReal, NArrayInt > | |
| Camrex::CoordSys | Coordinate system; provides mapping between physical space and index space |
| Camrex::Geometry | Rectangular problem domain geometry |
| Camrex::MPMD::Copier | Program ID |
| Camrex::FabArrayBase::CopyComTag | Used by a bunch of routines when communicating via MPI |
| Camrex::CpuBndryFuncFab | This cpu version calls function working on FArrayBox |
| Camrex::FFT::CrossProj< MF > | FFT-based projection of a cell-centered velocity field onto the space of fields that are divergence free with respect to the node-centered cross-stencil divergence |
| Camrex::CSR< T, V, Index > | Owning CSR container backed by AMReX resizable vectors |
| Camrex::CsrIndex< Index, V > | |
| Camrex::CsrSorted | Sorted CSR means for each row the column indices are sorted |
| Camrex::CsrValid | Valid CSR means all entries are valid. It may be sorted ro unsorted |
| Camrex::CsrView< T, Index > | Lightweight non-owning CSR view that can point to host or device buffers |
| Camrex::DataAllocator | Lightweight allocator/deallocator backed by an Arena |
| Camrex::BaseFab< Long > | |
| Camrex::BaseFab< EBCellFlag > | |
| Camrex::EBCellFlagFab | FAB storing EBCellFlag data per cell |
| Camrex::BaseFab< Real > | |
| Camrex::FArrayBox | A Fortran Array of REALs |
| Camrex::CutFab | FArrayBox specialization used to store cut-cell data (may skip allocation) |
| Camrex::EBFArrayBox | FArrayBox variant that can query accompanying EB geometric data |
| Camrex::BaseFab< int > | |
| Camrex::IArrayBox | A Fortran Array of ints |
| Camrex::Mask | |
| Camrex::BaseFab< char > | |
| Camrex::TagBox | Tagged cells in a Box |
| Camrex::BaseFab< GpuComplex< typename MultiFab::value_type > > | |
| Camrex::BaseFab< HYPRE_Int > | |
| Camrex::BaseFab< AtomicInt > | |
| Camrex::BaseFab< PetscInt > | |
| Camrex::BaseFab< T > | A FortranArrayBox(FAB)-like object |
| Camrex::TableData< T, N, ORDER > | Multi-dimensional array class |
| Camrex::DataDeleter | Custom deleter that returns memory to an Arena |
| Camrex::DataLayoutPolicy< ContainerType, ParticleType, DataLayoutTag > | |
| Camrex::DataLayoutPolicy< ContainerType, ParticleType< Types... >, DataLayout::AoS > | |
| Camrex::DataLayoutPolicy< ContainerType, ParticleType< Types... >, DataLayout::SoA > | |
| Camrex::DataLayoutPolicyRaw< ParticleType, DataLayoutTag > | |
| Camrex::DataLayoutPolicyRaw< ParticleType< Types... >, DataLayout::AoS > | |
| Camrex::DataLayoutPolicyRaw< ParticleType< Types... >, DataLayout::SoA > | |
| Camrex::DefaultAssignor | |
| Camrex::Gpu::Deleter | |
| Camrex::DenseBinIteratorFactory< T > | |
| Camrex::DenseBins< T > | A container for storing items in a set of bins |
| Camrex::DeriveList | A list of DeriveRecs |
| Camrex::DeriveRec | Derived Type Record |
| Camrex::DescriptorList | |
| Camrex::DestComp | Destination-component descriptor |
| Camrex::Gpu::Device | |
| Camrex::DeviceArenaWrapper | |
| Camrex::Gpu::DeviceScalar< T > | |
| Camrex::MFIter::DeviceSync | |
| Camrex::Gpu::DeviceToDevice | |
| Camrex::Gpu::DeviceToHost | |
| Camrex::EB2::DifferenceIF< F, G > | Implicit function that keeps points inside F but outside G |
| Camrex::Dim3 | A simple struct holding 3 int values for a 3D index |
| Camrex::distFcnElement2d | Abstract base for 2-D distance-function elements |
| Camrex::LineDistFcnElement2d | Distance function defined by a polyline |
| Camrex::SplineDistFcnElement2d | Distance function defined by a cubic spline |
| Camrex::DistributionMapping | Calculates the distribution of FABs to MPI processes |
| Camrex::Divides< T > | Function object that returns the quotient of two values |
| Camrex::NonLocalBC::DoLocalCopy | |
| Camrex::DynamicTiling | |
| Camrex::EBCellFlag | Bit-coded helper that classifies EB cells and neighbor connectivity |
| Camrex::EBData | Set of Array4 views to EB data for a single box (plus helpers) |
| Camrex::EBDataArrays | Views aggregating EBData for multiple boxes |
| Camrex::EBDataCollection | Aggregates the EB data required to build EB-aware MultiFabs/FabFactories |
| Camrex::EBToPVD | Helper that converts EB surfaces into polygonal PVD files |
| Camrex::EB2::Edge | Edge connecting a graph vertex to a face and downstream vertex id |
| Camrex::EdgeFluxRegister | |
| Camrex::Elixir | |
| Camrex::Gpu::Elixir | |
| Camrex::ErrorRec::ErrorFunc | |
| Camrex::ErrorRec::ErrorFunc2 | |
| Camrex::ErrorList | A List of ErrorRecs |
| Camrex::ErrorRec | Error Record |
| Cstd::exception | STL class |
| Cstd::bad_alloc | STL class |
| Camrex::OutOfMemoryError | |
| Cstd::runtime_error | STL class |
| Camrex::MLMGT< MF >::error | |
| Camrex::Scan::Type::Exclusive | |
| Camrex::Gpu::ExecConfig | |
| Camrex::Gpu::ExecutionConfig | |
| Camrex::expect | |
| Camrex::Gpu::ExternalGpuStreamRegion | |
| Camrex::EB2::ExtrusionIF< F > | Extrude a 2-D implicit function uniformly along a coordinate direction |
| Camrex::FabArrayBase | Base class for FabArray |
| Camrex::FabArray< BaseFab< GpuComplex< Real > > > | |
| Camrex::FabArray< BaseFab< float > > | |
| Camrex::FabArray< IdFab > | |
| Camrex::FabArray< BaseFab< GpuComplex< T > > > | |
| Camrex::FabArray< BaseFab< GpuComplex< typename MF::value_type > > > | |
| Camrex::FabArray< FArrayBox > | |
| Camrex::MultiFab | A collection (stored as an array) of FArrayBox objects |
| Camrex::FabArray< TagBox > | |
| Camrex::TagBoxArray | An array of TagBoxes |
| Camrex::FabArray< IArrayBox > | |
| Camrex::iMultiFab | A Collection of IArrayBoxes |
| Camrex::FabArray< amrex::EBCellFlagFab > | |
| Camrex::FabArray< BaseFab< GpuComplex< typename MultiFab::value_type > > > | |
| Camrex::FabArray< amrex::BaseFab< HYPRE_Int > > | |
| Camrex::FabArray< amrex::BaseFab< AtomicInt > > | |
| Camrex::FabArray< amrex::BaseFab< Long > > | |
| Camrex::FabArray< amrex::CutFab > | |
| Camrex::FabArray< amrex::Mask > | |
| Camrex::FabArray< amrex::BaseFab< PetscInt > > | |
| Camrex::LayoutData< GFab > | |
| Camrex::EB2::MultiGFab | LayoutData wrapper that allocates a GFab per FAB/Box |
| Camrex::LayoutData< amrex::Vector< amrex::Vector< amrex::BoundCond > > > | |
| Camrex::LayoutData< RealTuple > | |
| Camrex::LayoutData< int > | |
| Camrex::LayoutData< HYPRE_Int > | |
| Camrex::LayoutData< Int > | |
| Camrex::LayoutData< amrex::PODVector< T, ArenaAllocator< T > >< Int > > | |
| Camrex::LayoutData< amrex::PODVector< T, ArenaAllocator< T > >< HYPRE_Int > > | |
| Camrex::LayoutData< amrex::PODVector< T, ArenaAllocator< T > >< int > > | |
| Camrex::LayoutData< Long > | |
| Camrex::LayoutData< PetscInt > | |
| Camrex::FabArray< FAB > | An Array of FortranArrayBox(FAB)-like Objects |
| Camrex::LayoutData< T > | One-thingy-per-box distributed object |
| Camrex::FabArrayCopyDescriptor< FAB > | Manages multi-component copy operations out of one or more FabArrays |
| Camrex::FabArrayCopyDescriptor< FArrayBox > | |
| Camrex::MultiFabCopyDescriptor | |
| Camrex::FabArrayId | Lightweight handle returned when registering FabArrays with a descriptor |
| Camrex::FabArrayBase::FabArrayStats | |
| Camrex::FabArrayBase::FabComTag | Used for collecting information used in communicating FABs |
| Camrex::FabCopyDescriptor< FAB > | Describes a single copy request originating from a registered FabArray |
| Camrex::FabCopyTag< FAB > | Describes a source FAB region participating in a copy |
| Camrex::FabDataType< T > | Type trait specialized for MultiFab-like types and their containers |
| Camrex::FabDataType< T > | Extract the FAB and scalar types directly from a MultiFab-like type |
| Camrex::FabFactory< FAB > | Abstract factory interface for creating, aliasing, and destroying FAB objects |
| Camrex::DefaultFabFactory< FAB > | Default FabFactory that calls new / delete on the FAB type directly |
| Camrex::FabFactory< FArrayBox > | |
| Camrex::DefaultFabFactory< FArrayBox > | |
| Camrex::EBFArrayBoxFactory | |
| Camrex::FabFillNoOp | |
| Camrex::FabInfo | Construction hints passed to FabFactory::create |
| Camrex::FABio | A Class Facilitating I/O for Fabs |
| Camrex::FABio_8bit | |
| Camrex::FABio_ascii | |
| Camrex::FABio_binary | |
| Camrex::VisMF::FabOnDisk | A structure containing info regarding an on-disk FAB |
| Camrex::VisMF::FabReadLink | This structure is used to store the read order for each FabArray file |
| Camrex::FabSetT< MF > | A FabSet is a group of FArrayBox's. The grouping is designed specifically to represent regions along the boundary of Box's, and are used to implement boundary conditions to discretized partial differential equations |
| Camrex::FabArray< FAB >::FABType | |
| Camrex::EB2::Face | Metadata associated with an EB face |
| Cstd::false_type | |
| Camrex::Disjunction< B1 > | |
| Camrex::Disjunction< B1, Bn... > | |
| Camrex::EB2::IsGPUable< IntersectionIF< Tail... > > | |
| Camrex::EB2::IsGPUable< IntersectionIF< Head, Tail... > > | |
| Camrex::EB2::IsGPUable< UnionIF< Tail... > > | |
| Camrex::EB2::IsGPUable< UnionIF< Head, Tail... > > | |
| Camrex::EB2::IsGPUable< ComplementIF< F > > | |
| Camrex::EB2::IsGPUable< D > | |
| Camrex::EB2::IsGPUable< DifferenceIF< F, G > > | |
| Camrex::EB2::IsGPUable< ExtrusionIF< F > > | |
| Camrex::EB2::IsGPUable< IntersectionIF< F > > | |
| Camrex::EB2::IsGPUable< IntersectionIF< Head, Tail... > > | |
| Camrex::EB2::IsGPUable< LatheIF< F > > | |
| Camrex::EB2::IsGPUable< RotationIF< F > > | |
| Camrex::EB2::IsGPUable< ScaleIF< F > > | |
| Camrex::EB2::IsGPUable< TranslationIF< F > > | |
| Camrex::EB2::IsGPUable< UnionIF< F > > | |
| Camrex::EB2::IsGPUable< UnionIF< Head, Tail... > > | |
| Camrex::HasAtomicAdd< double > | |
| Camrex::HasAtomicAdd< float > | |
| Camrex::HasAtomicAdd< int > | |
| Camrex::HasAtomicAdd< long > | |
| Camrex::HasAtomicAdd< unsigned int > | |
| Camrex::HasAtomicAdd< unsigned long long > | |
| Camrex::IsAddAssignable< T, std::void_t< decltype(std::declval< T & >()+=std::declval< T >())> > | |
| Camrex::IsAlgVector< V > | |
| Camrex::IsArenaAllocator< T > | |
| Camrex::IsBaseFab< D > | |
| Camrex::IsFabArray< D > | |
| Camrex::IsMultiFabLike< M > | |
| Camrex::IsPolymorphicArenaAllocator< PolymorphicArenaAllocator< T > > | |
| Camrex::IsStoreAtomic< EBCellFlag > | |
| Camrex::IsStoreAtomic< T > | |
| Camrex::IsTypeList< TypeList< Ts... > > | |
| Camrex::RunOnGpu< ArenaAllocator< T > > | |
| Camrex::RunOnGpu< AsyncArenaAllocator< T > > | |
| Camrex::RunOnGpu< DeviceArenaAllocator< T > > | |
| Camrex::RunOnGpu< ManagedArenaAllocator< T > > | |
| Camrex::DefinitelyNotHostRunnable< T > | |
| Camrex::Disjunction<... > | |
| Camrex::EB2::IsGPUable< D > | Type trait that reports whether a functor derives from GPUable |
| Camrex::HasAtomicAdd< T, Enable > | |
| Camrex::IsAddAssignable< T, Enable > | |
| Camrex::IsAlgVector< V > | |
| Camrex::IsArenaAllocator< T, Enable > | |
| Camrex::IsBaseFab< A > | |
| Camrex::IsFabArray< A > | |
| Camrex::IsMultiFabLike< M > | |
| Camrex::IsPolymorphicArenaAllocator< T > | |
| Camrex::IsStoreAtomic< T > | |
| Camrex::IsTypeList< T > | |
| Camrex::RunOnGpu< T > | |
| Camrex::Math::FastDivmodU64 | |
| Camrex::FatPtr< T > | |
| Camrex::FBData< FAB > | |
| Camrex::EB2::Level::FCData | Face-centered EB data storage structure |
| Camrex::FillBoxId | Tracks metadata about a pending fill region (box and identifiers) |
| Camrex::FillPatcher< MF > | FillPatcher is for filling a fine level MultiFab/FabArray |
| Camrex::FillPatchIteratorHelper | |
| Camrex::FilterPositiveID | |
| Camrex::FilterVirt | |
| Camrex::ForkJoin | |
| Camrex::FPC | A Collection of Floating-Point Constants Supporting FAB I/O |
| Camrex::FabArrayBase::FPinfo | |
| Camrex::ParallelContext::Frame | |
| Camrex::GeometryData | GPU-safe snapshot of Geometry data suitable for capture in GPU kernels |
| Camrex::EB2::GeometryShop< F, R > | Samples an implicit function on boxes and fills EB data |
| Camrex::GetBucket | |
| Camrex::GetParticleBin | |
| Camrex::GetPID | |
| Camrex::GetSendBufferOffset | |
| Camrex::EB2::GFab | Object that stores level-set, face/edge types, and EB graph per box |
| Camrex::GMRES< V, M > | GMRES |
| Camrex::GMRESMLMGT< MF > | Solve using GMRES with multigrid as preconditioner |
| Cdetail::gpu_tuple_impl | |
| Camrex::GpuTuple< Ts... > | |
| Camrex::GpuTuple< Types *... > | |
| Camrex::GpuTuple< Fs... > | |
| Camrex::EB2::IntersectionIF< Fs > | Implicit function that evaluates the intersection of multiple objects |
| Camrex::EB2::UnionIF< Fs > | Implicit function representing the union of several objects |
| Camrex::GpuTuple< Ts > | GPU-compatible tuple |
| Camrex::GPUable | Marker base that denotes an implicit function callable on device kernels |
| Camrex::EB2::AllRegularIF | Trivial implicit function that always returns the "fluid" sign |
| Camrex::EB2::BoxIF | Signed implicit function for an axis-aligned box |
| Camrex::EB2::CylinderIF | Signed implicit function for cylinders along a coordinate axis |
| Camrex::EB2::DevicePtrIF< T > | Wrapper that forwards operator() calls to an implicit function pointer |
| Camrex::EB2::EllipsoidIF | Signed implicit function for ellipsoids centered at a_center |
| Camrex::EB2::ParserIF | Implicit surface defined by an amrex::Parser expression |
| Camrex::EB2::PlaneIF | |
| Camrex::EB2::PolyIF< N > | GPU-ready polynomial implicit function with a fixed number of terms |
| Camrex::EB2::SphereIF | |
| Camrex::EB2::TorusIF | |
| Camrex::GpuArray< T, N > | Fixed-size array that can be used on GPU |
| Camrex::BinPolicy::GPUBinPolicy | |
| Camrex::GpuBndryFuncFab< F > | |
| Camrex::GpuComplex< T > | A host / device complex number type, because std::complex doesn't work in device code with Cuda yet |
| Camrex::GpuTupleElement< Idx, T > | |
| Camrex::GpuTupleElement< 0, GpuTuple< Head, Tail... > > | |
| Camrex::GpuTupleElement< Idx-1, GpuTuple< Tail... > > | |
| Camrex::GpuTupleElement< Idx, GpuTuple< Head, Tail... > > | |
| Camrex::GpuTupleSize< T > | |
| Camrex::Gpu::GraphSafeGuard | |
| Camrex::ParticleHeader::GridEntry | One entry of the per-level grid table |
| Camrex::Gpu::Handler | |
| Camrex::CArena::Node::hash | |
| Camrex::VisMF::Header | An on-disk FabArray<FArrayBox> contains this info in a header file |
| Camrex::Gpu::HostToDevice | |
| Camrex::Hypre | Lightweight base class shared by HYPRE-backed linear solvers, HypreABecLap, HypreABecLap2, and HypreABecLap3 |
| Camrex::HypreABecLap | Struct-interface HYPRE solver for (a - b div beta grad) phi = rhs |
| Camrex::HypreABecLap2 | Semi-structured ABecLaplacian operator built on HYPRE's SStruct API |
| Camrex::HypreABecLap3 | HYPRE IJ solver for ABecLaplacian (optionally with overset masks) |
| Camrex::HypreIJIface | Convenience interface for configuring and invoking HYPRE IJ solvers |
| Camrex::HypreMLABecLap | Multilevel HYPRE solver that mirrors MLMG's ABecLaplacian structure |
| Camrex::HypreMLNodeLap | Composite multi-level solve of an MLNodeLaplacian with hypre |
| Camrex::HypreNodeLap | IJ-based nodal Laplacian that mirrors MLNodeLinOp's discretization |
| Camrex::HypreSolver< MSS > | Solve Ax = b using HYPRE's generic IJ matrix format where A is a sparse matrix specified using the compressed sparse row (CSR) format |
| Camrex::NonLocalBC::Identity | This class acts as a default no-op operator |
| Camrex::IFABio | |
| Camrex::MLAlgMG::Impl | |
| Camrex::Scan::Type::Inclusive | |
| Camrex::EB2::IndexSpace | |
| Camrex::EB2::IndexSpaceChkptFile | IndexSpace that reads EB levels from a checkpoint file on disk |
| Camrex::EB2::IndexSpaceImp< G > | |
| Camrex::EB2::IndexSpaceSTL | IndexSpace that samples implicit geometry from STL meshes |
| Camrex::FFT::Info | |
| Camrex::IntDescriptor | A Descriptor of the Long Integer type |
| Cstd::integral_constant | |
| Camrex::GpuTupleSize< GpuTuple< Ts... > > | |
| Camrex::is_soa_particle< T > | |
| Cstd::tuple_size< amrex::SmallMatrix< T, NRows, NCols, ORDER, StartIndex > > | |
| Camrex::IntegratorBase< T > | |
| Camrex::FEIntegrator< T > | |
| Camrex::RKIntegrator< T > | |
| Camrex::SundialsIntegrator< T > | IntegratorBase implementation powered by SUNDIALS ARKStep/MRIStep |
| Camrex::IntegratorOps< T > | |
| Camrex::IntegratorOps< T > | |
| Cdetail::InternalVectorized | |
| Camrex::simd::Vectorized< SIMD_WIDTH > | |
| Camrex::InterpBase | |
| Camrex::Interpolater | Virtual base class for interpolaters |
| Camrex::CellBilinear | Bilinear interpolation on cell centered data |
| Camrex::CellConservativeLinear | Linear conservative interpolation on cell centered data |
| Camrex::CellConservativeProtected | Lin. cons. interp. on cc data with protection against under/over-shoots |
| Camrex::EBCellConservativeLinear | CellConservativeLinear interpolater customized for EB volume fractions |
| Camrex::CellConservativeQuartic | Conservative quartic interpolation on cell averaged data |
| Camrex::CellQuadratic | Quadratic interpolation on cell centered data |
| Camrex::CellQuartic | Quartic interpolation on cell centered data |
| Camrex::FaceConservativeLinear | Bilinear tangential interpolation / linear normal interpolation of face data |
| Camrex::FaceDivFree | Divergence-preserving interpolation on face centered data |
| Camrex::FaceLinear | Piecewise constant tangential interpolation / linear normal interpolation of face data |
| Camrex::NodeBilinear | Bilinear interpolation on node centered data |
| Camrex::PCInterp | Piecewise Constant interpolation on cell centered data |
| Camrex::MFInterpolater | |
| Camrex::MFCellBilinear | [Bi|Tri]linear interpolation on cell centered data |
| Camrex::MFCellConsLinInterp | Linear conservative interpolation on cell centered data |
| Camrex::EBMFCellConsLinInterp | Cell-conservative MultiFab interpolater that honors EB geometry |
| Camrex::MFCellConsLinMinmaxLimitInterp | Linear conservative interpolation on cell centered data |
| Camrex::MFNodeBilinear | |
| Camrex::MFPCInterp | Piecewise constant interpolation on cell-centered data |
| Camrex::InterpFaceRegister | InterpFaceRegister is a coarse/fine boundary register for interpolation of face data at the coarse/fine boundary |
| Camrex::IntVectND< dim > | An Integer Vector in dim-Dimensional Space |
| Camrex::IOFormatSaver< CharT, Traits > | |
| Camrex::IParser | Integer-only variant of amrex::Parser |
| Camrex::IParserExecutor< N > | Callable wrapper around an integer parser expression with N variables |
| CIsDetected | |
| Camrex::IsCallable< T, Args > | Test if a given type T is callable with arguments of type Args.. |
| CIsDetectedExact | |
| Camrex::IsCallableR< FAB::value_type, P, Array4< const FAB::value_type >, Dim3, int > | |
| Camrex::NonLocalBC::IsFabProjection< P, FAB > | This type trait tests if a type P is a projection for FAB |
| Camrex::IsCallableR< R, T, Args > | Test if a given type T is callable with arguments of type Args.. |
| Camrex::NonLocalBC::HasInverseMemFn< T > | Type trait that tests if T has an InverseImage class member function |
| Camrex::BinIterator< T >::iterator | |
| Camrex::Neighbors< ParticleType >::iterator | |
| Camrex::JacobiSmoother< T > | Jacobi smoother for AlgVector/SpMatrix linear systems |
| Camrex::KeepValidFilter | |
| Camrex::Gpu::KernelInfo | |
| Camrex::KrylovMV< S, T > | Binds a Krylov solver to an SpMatrix |
| Camrex::L1GaussSeidelSmoother< T > | L1 hybrid Gauss-Seidel smoother for CPUs |
| Camrex::EB2::LatheIF< F > | Lathe an implicit curve around the z axis to build a surface of revolution |
| Camrex::Gpu::LaunchSafeGuard | |
| Camrex::EB2::Level | |
| Camrex::EB2::GShopLevel< ChkptFile > | |
| Camrex::EB2::ChkptFileLevel | EB level specialized for reading checkpoint EB data |
| Camrex::EB2::GShopLevel< STLtools > | |
| Camrex::EB2::STLLevel | EB2 level that samples geometry from STL files |
| Camrex::EB2::GShopLevel< G > | |
| Camrex::LevelBld | Builds problem-specific AmrLevels |
| Camrex::LinOpEnumType | |
| Camrex::FFT::LocalR2C< T, D, M > | Local Discrete Fourier Transform |
| Camrex::LogicalAnd< T > | Function object that returns the logical AND of two values |
| Camrex::LogicalOr< T > | Function object that returns the logical OR of two values |
| Camrex::MC::LookUpTable | Lookup tables used by the Lewiner marching-cubes variant |
| Camrex::LPInfo | Configuration knobs for multilevel linear operators (grid agglomeration, metrics, etc.) |
| Camrex::LUSolver< N, T > | |
| Camrex::make_particle< T_ParticleType > | |
| Camrex::make_particle< T_ParticleType > | |
| Camrex::Gpu::Managed | |
| Camrex::ManagedArenaWrapper | |
| Camrex::NonLocalBC::MapComponents< Base, Map > | This class takes a projection and a component map and combines them to form a new projection |
| Camrex::Maximum< T > | Function object that returns the larger of two values |
| Camrex::MC::MCFab | Minimal container holding marching-cubes output for one FAB |
| Camrex::MemProfiler::MemInfo | |
| Camrex::FabArrayBase::meminfo | |
| Camrex::sundials::MemoryHelper | A SUNDIALS SUNMemoryHelper interface to the amrex::Arena |
| Camrex::MemProfiler | |
| Camrex::MemStat | |
| Camrex::ParallelDescriptor::Message | Hold the description and status of communication data |
| Camrex::MFInfo | FabArray memory allocation information |
| Camrex::MFIter | Iterator for looping ever tiles and boxes of amrex::FabArray based containers |
| Camrex::ParIterBase_impl< is_const, Particle< T_NStructReal, T_NStructInt >, T_NArrayReal, T_NArrayInt, Allocator, CellAssignor > | |
| Camrex::ParIterBase_impl< is_const, SoAParticle< T_NArrayReal, T_NArrayInt >, T_NArrayReal, T_NArrayInt, Allocator, CellAssignor > | |
| Camrex::ParIterBase_impl< true, T_ParticleType, 0, 0, DefaultAllocator, DefaultAssignor > | |
| Camrex::ParConstIter_impl< T_ParticleType, NArrayReal, NArrayInt, Allocator, T_CellAssignor > | |
| Camrex::ParIterBase_impl< false, T_ParticleType, 0, 0, DefaultAllocator, DefaultAssignor > | |
| Camrex::ParIter_impl< T_ParticleType, NArrayReal, NArrayInt, Allocator, T_CellAssignor > | |
| Camrex::FabSetIter | Convenience iterator that reuses MFIter semantics for FabSet traversal |
| Camrex::FillPatchIterator | |
| Camrex::MultiMaskIter | Iterator adapter exposing MFIter semantics for MultiMask traversal |
| Camrex::ParIterBase_impl< is_const, T_ParticleType, NArrayReal, NArrayInt, Allocator, CellAssignor > | |
| Camrex::ParConstIter_impl< Particle< T_NStructReal, T_NStructInt >, T_NArrayReal, T_NArrayInt, Allocator, CellAssignor > | |
| Camrex::ParConstIter_impl< SoAParticle< T_NArrayReal, T_NArrayInt >, T_NArrayReal, T_NArrayInt, Allocator, CellAssignor > | |
| Camrex::ParConstIter_impl< RTSoAParticle< RType, IType >, 0, 0, PolymorphicArenaAllocator, CellAssignor > | |
| Camrex::ParConstIter_impl< ParticleType, NArrayReal, NArrayInt, Allocator, CellAssignor > | |
| Camrex::ParIter_impl< Particle< T_NStructReal, T_NStructInt >, T_NArrayReal, T_NArrayInt, Allocator, CellAssignor > | |
| Camrex::ParIter_impl< SoAParticle< T_NArrayReal, T_NArrayInt >, T_NArrayReal, T_NArrayInt, Allocator, CellAssignor > | |
| Camrex::ParIter_impl< RTSoAParticle< RType, IType >, 0, 0, PolymorphicArenaAllocator, CellAssignor > | |
| Camrex::ParIter_impl< ParticleType, NArrayReal, NArrayInt, Allocator, CellAssignor > | |
| Camrex::MFItInfo | |
| Camrex::Minimum< T > | Function object that returns the smaller of two values |
| Camrex::Minus< T > | Function object that returns the difference of two values |
| Camrex::MLAlgMG | Algebraic system of one MG level of AMR level 0 of an MLLinOp, solved with AlgMG |
| Camrex::MLCGSolverT< MF > | CG-family solvers (BiCGStab or CG) for use as the bottom solver in MLMG |
| Camrex::MLLinOpT< MF > | |
| Camrex::BCMode< MF > | |
| Camrex::StateMode< MF > | |
| Camrex::Location< MF > | |
| Camrex::MLCellLinOpT< MF > | |
| Camrex::MLCellABecLapT< MF > | Cell-centered operator that exposes ABec Laplacian helpers to derived classes |
| Camrex::MLABecLaplacianT< MF > | |
| Camrex::MLALaplacianT< MF > | Multi-component ALaplacian (a scalar plus optional spatial a coeffs) |
| Camrex::MLPoissonT< MF > | Cell-centered Laplacian operator \nabla^2 \phi |
| Camrex::MLLinOpT< Array< MultiFab, 3 > > | |
| Camrex::MLCurlCurl | Curl (alpha curl E) + beta E = rhs |
| Camrex::MLLinOpT< MultiFab > | |
| Camrex::MLCellLinOpT< MultiFab > | |
| Camrex::MLCellABecLapT< MultiFab > | |
| Camrex::MLABecLaplacianT< MultiFab > | |
| Camrex::MLTensorOp | Tensor solver with shear/bulk viscosity inputs for high-Reynolds flows |
| Camrex::MLALaplacianT< MultiFab > | |
| Camrex::MLPoissonT< MultiFab > | |
| Camrex::MLEBABecLap | Embedded-boundary ABec Laplacian (alpha a - beta div(b grad phi)) |
| Camrex::MLEBTensorOp | Embedded-boundary tensor solver mirroring MLTensorOp inside the domain |
| Camrex::MLTerrainPoisson | Cell-centered Poisson operator on a terrain-following mesh |
| Camrex::MLNodeLinOp | |
| Camrex::MLEBNodeFDLaplacian | Nodal finite-difference Laplacian with optional embedded boundaries |
| Camrex::MLNodeABecLaplacian | |
| Camrex::MLNodeLaplacian | |
| Camrex::MLNodeTensorLaplacian | |
| Camrex::MLMGABCEBTag< T > | |
| Camrex::MLMGABCTag< T > | |
| Camrex::MLMGT< MF > | |
| Camrex::mpidatatypes::MPI_Status | |
| Camrex::ParallelDescriptor::Mpi_typemap< T > | Communication datatype (note: this structure also works without MPI) |
| Camrex::ParallelDescriptor::Mpi_typemap< GpuComplex< T > > | |
| Camrex::ParallelDescriptor::Mpi_typemap< ValLocPair< TV, TI > > | |
| Camrex::MultiArray4< T > | |
| Camrex::MultiBlockIndexMapping | This struct describes an affine index transformation for two coordinate systems |
| Camrex::NonLocalBC::MultiBlockIndexMapping | This struct describes an affine index transformation for two coordinate systems |
| Camrex::MultiCutFab | FabArray façade that only allocates cut-cell Fabs (skipping regular cells) |
| Camrex::MultiMask | |
| Camrex::Multiplies< T > | Function object that returns the product of two values |
| Camrex::sundials::N_VectorContent_MultiFab_notptr | |
| Camrex::MemProfiler::NBuildsInfo | |
| Camrex::EB2::Neighbor | Packed neighbor structure that tracks the neighbor type in every direction |
| Camrex::NeighborCode | |
| Camrex::NeighborData< ParticleType > | |
| Camrex::NeighborList< ParticleType > | |
| Camrex::Neighbors< ParticleType > | |
| Camrex::NeighborParticleContainer_impl< T_ParticleType, T_NArrayReal, T_NArrayInt, Allocator, CellAssignor >::NeighborTask | |
| Camrex::NeighborUnpackPolicy | |
| Camrex::NextIDRTSoA | |
| Camrex::NFilesIter | This class encapsulates writing to nfiles |
| Camrex::CArena::Node | The nodes in our free list and block list |
| Camrex::NonLocalBC::NoLocalCopy | |
| Camrex::Gpu::NoSyncRegion | |
| Camrex::Gpu::SyncAtExitOnly | |
| Camrex::NullInterpHook< MFFAB > | |
| Camrex::EBCellFlagFab::NumCells | |
| Camrex::NumComps | Number-of-components descriptor |
| Camrex::FFT::OpenBCSolver< T > | Convolution-based solver for open boundary conditions using Green's functions |
| Camrex::OpenBCSolver | Open Boundary Poisson Solver |
| Camrex::BinPolicy::OpenMPBinPolicy | |
| Camrex::Orientation | Encapsulation of the Orientation of the Faces of a Box |
| Camrex::OrientationIter | An Iterator over the Orientation of Faces of a Box |
| Camrex::composite::OwnedCSR | Rows owned by this rank in CSR form, columns sorted within each row and duplicates summed |
| Camrex::NonLocalBC::PackComponents | Contains information about which components take part of the data transaction |
| Camrex::NonLocalBC::ApplyDtosAndProjectionOnReciever< DTOS, FabProj > | This class specializes behaviour on local copies and unpacking receive buffers |
| Camrex::ParCsr< T > | |
| Camrex::FabArrayBase::ParForInfo | For ParallelFor(FabArray) |
| Camrex::ParGDBBase | |
| Camrex::AmrParGDB | |
| Camrex::ParGDB | We use this for non-Amr particle code |
| Camrex::ParmParse | Parse Parameters From Command Line and Input Files |
| Camrex::Parser | Front-end for parsing scalar expressions into GPU/CPU executors |
| Camrex::ParserExecutor< N > | Callable wrapper around a compiled parser expression with N variables |
| Camrex::ParticleArray< ContainerType, ParticleType, DataLayoutTag > | |
| Camrex::ParticleArrayAccessor< ParticleType, DataLayoutTag > | |
| Camrex::ParticleBase< T, NReal, NInt > | |
| Camrex::Particle< NStructReal+NArrayReal, NStructInt+NArrayInt > | |
| Camrex::Particle< NStructReal+NAR, NStructInt+NAI > | |
| Camrex::ParticleBase< ParticleReal, T_NReal, 0 > | |
| Camrex::Particle< T_NReal, T_NInt > | The struct used to store particles |
| Camrex::ParticleBase< T, 0, 0 > | |
| Camrex::ParticleBase< T, 0, NInt > | |
| Camrex::ParticleBase< T, NReal, 0 > | |
| Camrex::ParticleBufferMap | |
| Camrex::ParticleCommData | A struct used for communicating particle data across processes during multi-level operations |
| Camrex::ParticleContainerBase | |
| Camrex::ParticleContainer_impl< T_ParticleType, T_NArrayReal, T_NArrayInt, Allocator, CellAssignor > | |
| Camrex::ParticleContainer_impl< Particle< T_NStructReal, T_NStructInt >, T_NArrayReal, T_NArrayInt, Allocator, CellAssignor > | |
| Camrex::TracerParticleContainer | |
| Camrex::AmrTracerParticleContainer | Simple tracer container that wires TracerParticleContainer to an AmrCore |
| Camrex::ParticleContainer_impl< T_ParticleType, NArrayReal, NArrayInt, Allocator, CellAssignor > | |
| Camrex::ParticleContainer_impl< ParticleType, NArrayReal, NArrayInt, Allocator, CellAssignor > | |
| Camrex::ParticleContainer_impl< ParticleType, NArrayReal, NArrayInt, NewAllocator > | |
| Camrex::ParticleContainer_impl< SoAParticle< T_NArrayReal, T_NArrayInt >, T_NArrayReal, T_NArrayInt, Allocator, CellAssignor > | |
| Camrex::NeighborParticleContainer_impl< SoAParticle< T_NArrayReal, T_NArrayInt >, T_NArrayReal, T_NArrayInt, Allocator, CellAssignor > | |
| Camrex::ParticleContainer_impl< RTSoAParticle< RType, IType >, 0, 0, PolymorphicArenaAllocator, CellAssignor > | |
| Camrex::ParticleContainer_impl< T_ParticleType, 0, 0, DefaultAllocator, DefaultAssignor > | |
| Camrex::AmrParticleContainer_impl< T_ParticleType, NArrayReal, NArrayInt, Allocator, CellAssignor > | Particle container that automatically pulls grid metadata from AmrCore when available |
| Camrex::NeighborParticleContainer_impl< T_ParticleType, T_NArrayReal, T_NArrayInt, Allocator, CellAssignor > | |
| Camrex::ParticleContainer_impl< T_ParticleType, T_NArrayReal, T_NArrayInt, Allocator, T_CellAssignor > | A distributed container for Particles sorted onto the levels, grids, and tiles of a block-structured AMR hierarchy |
| Camrex::AmrParticleContainer_impl< Particle< T_NStructReal, T_NStructInt >, T_NArrayReal, T_NArrayInt, Allocator, CellAssignor > | |
| Camrex::NeighborParticleContainer_impl< Particle< T_NStructReal, T_NStructInt >, T_NArrayReal, T_NArrayInt > | |
| Camrex::ParticleCopyOp | |
| Camrex::ParticleCopyPlan | |
| Camrex::ParticleCPUWrapper | |
| Camrex::ParticleHandshakeWindow | |
| Camrex::ParticleHeader | Metadata prefix of an AMReX particle "Header" file |
| Camrex::ParticleIDWrapper< T > | |
| Camrex::ParticleInitType< NStructReal, NStructInt, NArrayReal, NArrayInt > | A struct used to pass initial data into the various Init methods. This struct is used to pass initial data into the various Init methods of the particle container. That data should be initialized in the order real struct data, int struct data, real array data, int array data. If fewer components are specified than the template parameters specify for, a given component, then the extra values will be set to zero. If more components are specified, it is a compile-time error |
| Camrex::ParticleLocator< Bins > | |
| Camrex::ParticleLocData | A struct used for storing a particle's position in the AMR hierarchy |
| Camrex::ParticleTile< T_ParticleType, NArrayReal, NArrayInt, Allocator > | |
| Camrex::ParticleTileData< T_ParticleType, NArrayReal, NArrayInt > | |
| Camrex::ParticleTileDataRT< RType, IType > | |
| Camrex::ParticleTileRT< RType, IType > | |
| Camrex::PCData< FAB > | |
| Camrex::PCG< V, M > | Preconditioned conjugate gradient solver |
| Camrex::Periodicity | This provides length of period for periodic domains. 0 means it is not periodic in that direction. It is also assumed that the periodic domain starts with index 0 |
| Camrex::VisMF::PersistentIFStream | This structure is used to store file ifstreams that remain open |
| Camrex::PETScABecLap | PETSc wrapper that assembles/solves (a alpha - b div beta grad) phi = rhs |
| Camrex::PhysBCFunct< F > | |
| Camrex::PhysBCFunctNoOp | |
| Camrex::PhysBCFunctUseCoarseGhost | |
| Camrex::Gpu::Pinned | |
| Camrex::PinnedArenaWrapper | |
| Camrex::FFT::Plan< T > | |
| Camrex::PlotFileData | |
| Camrex::PlotFileDataImpl | |
| Camrex::Plus< T > | Function object that returns the sum of two values |
| Camrex::FFT::Poisson< MF > | Poisson solver for periodic, Dirichlet & Neumann boundaries using FFT |
| Camrex::FFT::PoissonHybrid< MF > | 3D Poisson solver for periodic, Dirichlet & Neumann boundaries in the first two dimensions, and Dirichlet & Neumann in the last dimension. The last dimension could have non-uniform mesh |
| Camrex::FFT::PoissonOpenBC< MF > | Poisson solve for Open BC using FFT |
| Camrex::PolymorphicArenaWrapper | |
| Camrex::EB2::PolynomialIF | Host-only dynamically-sized polynomial implicit function |
| Camrex::EB2::PolyTerm | Represents one monomial in a polynomial implicit function |
| Camrex::RungeKutta::PostStageNoOp | |
| Camrex::ParmParse::PP_entry | |
| Camrex::Print | This class provides the user with a few print options |
| Camrex::AllPrint | Print on all processors of the default communicator |
| Camrex::PrintToFile | This class prints to a file with a given base name |
| Camrex::AllPrintToFile | Print on all processors of the default communicator |
| Camrex::ParallelDescriptor::ProcessTeam | Provide functionalities needed to construct a team of processes to perform a particular job |
| Camrex::FFT::R2C< T, D, C > | Parallel Discrete Fourier Transform |
| Camrex::FFT::R2X< T > | Discrete Fourier Transform |
| Camrex::RandomEngine | |
| Camrex::RealBox | A Box with real dimensions |
| Camrex::RealDescriptor | A Descriptor of the Real Type |
| Camrex::RealVectND< dim > | A Real vector in dim-dimensional space |
| Camrex::FabArrayBase::ParForInfo::RedBlack | |
| Camrex::RedistributeUnpackPolicy | |
| Camrex::ReduceData< Ts > | |
| Camrex::ReduceOpLogicalAnd | |
| Camrex::ReduceOpLogicalOr | |
| Camrex::ReduceOpMax | |
| Camrex::ReduceOpMin | |
| Camrex::ReduceOps< Ps > | |
| Camrex::ReduceOpSum | |
| CReducerImpl | |
| Camrex::Reducer< Ops, Ts > | Class for local reductions (e.g., sum, min and max) |
| Camrex::DistributionMapping::Ref | |
| Camrex::ref_wrapper< T > | |
| Camrex::BoxArray::RefID | |
| Camrex::DistributionMapping::RefID | Lightweight identity handle wrapping a pointer to the underlying Ref |
| Camrex::FabArrayBase::RegionTag | |
| Camrex::SpMatrix< T, Allocator >::RemoteRowsMM | Rows of another matrix fetched for SpGEMM. Column indices are global |
| Camrex::Scan::RetSum | |
| Camrex::EB2::RotationIF< F > | Rotate an implicit surface around one of the coordinate axes |
| Camrex::RTSoAParticle< RType, IType > | |
| Camrex::RuntimePtrCacheDirtyFlag | |
| Camrex::Same< T, U1, Us > | |
| Camrex::Same< T, U > | |
| Camrex::EB2::ScaleIF< F > | Scale an implicit function by arbitrary per-axis factors |
| Camrex::BinPolicy::SerialBinPolicy | |
| Camrex::Gpu::SharedMemory< T > | |
| Camrex::Gpu::SharedMemory< bool > | |
| Camrex::Gpu::SharedMemory< char > | |
| Camrex::Gpu::SharedMemory< double > | |
| Camrex::Gpu::SharedMemory< float > | |
| Camrex::Gpu::SharedMemory< int > | |
| Camrex::Gpu::SharedMemory< long > | |
| Camrex::Gpu::SharedMemory< long long > | |
| Camrex::Gpu::SharedMemory< openbc::Moments::array_type > | |
| Camrex::Gpu::SharedMemory< short > | |
| Camrex::Gpu::SharedMemory< unsigned char > | |
| Camrex::Gpu::SharedMemory< unsigned int > | |
| Camrex::Gpu::SharedMemory< unsigned long > | |
| Camrex::Gpu::SharedMemory< unsigned long long > | |
| Camrex::Gpu::SharedMemory< unsigned short > | |
| Camrex::IntVectND< dim >::shift_hasher | Hash function for IntVectND |
| Camrex::FabArray< FAB >::ShMem | For shared memory |
| Camrex::SIMDindex< WIDTH, N > | |
| Camrex::Gpu::SingleStreamRegion | |
| Camrex::SmallMatrix< T, NRows, NCols, ORDER, StartIndex > | Matrix class with compile-time size |
| Camrex::SoAParticleBase | |
| Camrex::ConstSoAParticle< T_NArrayReal, T_NArrayInt > | |
| Camrex::SoAParticle< T_NArrayReal, T_NArrayInt > | |
| Camrex::SparseBinIteratorFactory< T > | |
| Camrex::SparseBins< T > | A container for storing items in a set of bins using "sparse" storage |
| Camrex::EB2::SplineIF | Implicit function that measures distance to a poly-spline curve in 2-D |
| Camrex::SpMatrix< T, Allocator > | Distributed CSR matrix that manages storage and GPU-friendly partitions |
| Camrex::SrcComp | Source-component descriptor |
| Camrex::ParticleCopyPlan::StableOrderedAlgorithm | |
| Camrex::Stack< T, N > | |
| Camrex::StateData | Current and previous level-time data |
| Camrex::StateDataPhysBCFunct | |
| Camrex::StateDescriptor | Attributes of StateData |
| Camrex::DeriveRec::StateRange | An element of a linked list to point to state quantities in AmrLevels |
| Camrex::STLtools | Utility class that loads STL meshes and samples them onto AMReX grids |
| Camrex::FFT::Stokes< MF > | Stokes solver for periodic domains using FFT |
| Camrex::Gpu::StreamIter | |
| Camrex::Gpu::StreamItInfo | |
| Camrex::Gpu::StreamManager | |
| Camrex::StreamRetry | |
| Camrex::StructOfArrays< NReal, NInt, Allocator, use64BitIdCpu > | |
| Camrex::SundialsUserData | User-supplied callbacks consumed by the AMReX/SUNDIALS bridge |
| Camrex::NonLocalBC::SwapComponents< CompI, CompJ > | This is a permutation where only two components are swapped |
| Camrex::NonLocalBC::SwapComponents< CompI, -1 > | |
| Camrex::NonLocalBC::SwapComponents<-1, -1 > | |
| Camrex::NonLocalBC::SwapComponents<-1, CompJ > | |
| Camrex::Table1D< T, IDX > | |
| Camrex::Table2D< T, ORDER > | |
| Camrex::Table3D< T, ORDER > | |
| Camrex::Table4D< T, ORDER > | |
| Camrex::TagVector< TagType > | |
| Camrex::TheFaArenaDeleter | |
| Camrex::ThisParticleTileHasNoAoS | |
| Camrex::ThisParticleTileHasNoParticleVector | |
| Camrex::FabArrayBase::TileArray | Tiling |
| Camrex::TileSize | |
| Camrex::TimeIntegrator< T > | |
| Camrex::TinyProfiler | A simple profiler that returns basic performance information (e.g. min, max, and average running time) |
| Camrex::TinyProfileRegion | |
| Camrex::ToTypeList< T > | Wrap non-TypeList into TypeList |
| Camrex::ToTypeList< TypeList< Ts... > > | |
| Camrex::Gpu::TrackedVector< T > | |
| Camrex::TransformerGhost | |
| Camrex::TransformerVirt | |
| Camrex::EB2::TranslationIF< F > | Translate an implicit surface by subtracting an offset vector |
| Camrex::MC::Triangle | Triangle index buffer referencing Vertex entries |
| Camrex::composite::Triplet | (row, column, value) of a matrix entry with global indices |
| Cstd::true_type | |
| Camrex::Conjunction< IsDetected< LocalCopy_t, DP &, FabArray< FAB > &, const FabArray< FAB > &, const FabArrayBase::CopyComTagsContainer & >, IsDetected< PrepareSendBuffers_t, DP &, FabArray< FAB > &, const FabArray< FAB > &, CommData &, const FabArrayBase::MapOfCopyComTagContainers & >, IsDetected< PrepareRecvBuffers_t, DP &, FabArray< FAB > &, const FabArray< FAB > &, CommData &, const FabArrayBase::MapOfCopyComTagContainers & >, IsDetected< PackSendBuffers_t, DP &, const FabArray< FAB > &, CommData & >, IsDetected< UnpackRecvBuffers_t, DP &, FabArray< FAB > &, CommData & > > | |
| Camrex::Conjunction< IsCallableR< Dim3, IndexMap &, const Dim3 & >, HasInverseMemFn< const IndexMap & > > | |
| Camrex::NonLocalBC::IsIndexMapping< IndexMap > | Tests if a given type IndexMap is usable as an index mapping between two index based coordinate systems |
| Camrex::Conjunction< B1 > | |
| Camrex::Conjunction< B1, Bn... > | |
| Camrex::detail::IsNarrowingConversionImp< From, To > | |
| Camrex::IsNarrowingConversion< From, To > | |
| Camrex::Conjunction<... > | Logical traits let us combine multiple type requirements |
| Camrex::NonLocalBC::IsDataPacking< DP, FAB > | This type trait tests if a given type DP satisfies the DataPacking concept for type FAB |
| Camrex::EB2::IsGPUable< ComplementIF< F > > | |
| Camrex::EB2::IsGPUable< D > | |
| Camrex::EB2::IsGPUable< DifferenceIF< F, G > > | |
| Camrex::EB2::IsGPUable< ExtrusionIF< F > > | |
| Camrex::EB2::IsGPUable< IntersectionIF< F > > | |
| Camrex::EB2::IsGPUable< LatheIF< F > > | |
| Camrex::EB2::IsGPUable< RotationIF< F > > | |
| Camrex::EB2::IsGPUable< ScaleIF< F > > | |
| Camrex::EB2::IsGPUable< TranslationIF< F > > | |
| Camrex::EB2::IsGPUable< UnionIF< F > > | |
| Camrex::HasAtomicAdd< double > | |
| Camrex::HasAtomicAdd< float > | |
| Camrex::HasAtomicAdd< int > | |
| Camrex::HasAtomicAdd< long > | |
| Camrex::HasAtomicAdd< unsigned int > | |
| Camrex::HasAtomicAdd< unsigned long long > | |
| Camrex::IsAddAssignable< T, std::void_t< decltype(std::declval< T & >()+=std::declval< T >())> > | |
| Camrex::IsAlgVector< V > | |
| Camrex::IsArenaAllocator< T > | |
| Camrex::IsBaseFab< D > | |
| Camrex::IsFabArray< D > | |
| Camrex::IsMultiFabLike< M > | |
| Camrex::IsPolymorphicArenaAllocator< PolymorphicArenaAllocator< T > > | |
| Camrex::IsStoreAtomic< EBCellFlag > | |
| Camrex::IsStoreAtomic< T > | |
| Camrex::IsTypeList< TypeList< Ts... > > | |
| Camrex::MaybeDeviceRunnable< T > | |
| Camrex::MaybeHostDeviceRunnable< T > | |
| Camrex::RunOnGpu< ArenaAllocator< T > > | |
| Camrex::RunOnGpu< AsyncArenaAllocator< T > > | |
| Camrex::RunOnGpu< DeviceArenaAllocator< T > > | |
| Camrex::RunOnGpu< ManagedArenaAllocator< T > > | |
| Cstd::tuple_element< N, amrex::SmallMatrix< T, NRows, NCols, ORDER, StartIndex > > | |
| Cstd::tuple_element< s, amrex::GpuTuple< T, Ts... > > | |
| Cstd::tuple_element< s, amrex::IndexTypeND< dim > > | |
| Cstd::tuple_element< s, amrex::IntVectND< dim > > | |
| Cstd::tuple_element< s, amrex::RealVectND< dim > > | |
| Cstd::tuple_element< std::size_t{0}, amrex::GpuTuple< T, Ts... > > | |
| Cstd::tuple_size< amrex::GpuTuple< Ts... > > | |
| Cstd::tuple_size< amrex::IndexTypeND< dim > > | |
| Cstd::tuple_size< amrex::IntVectND< dim > > | |
| Cstd::tuple_size< amrex::RealVectND< dim > > | |
| Camrex::ParticleCopyPlan::TwoPassHostAlgorithm | |
| Cstd::is_base_of::type | |
| Camrex::IsMultiFabIterator< T > | |
| Camrex::IsParticleContainer< T > | |
| Camrex::IsParticleIterator< T > | |
| Camrex::TypeArray< T, N > | |
| Camrex::TypeList< Ts > | Struct for holding types |
| Camrex::AMRErrorTag::UserFunc | |
| Camrex::ValLocPair< TV, TI > | |
| Cstd::vector< T > | STL class |
| Camrex::iterator< Box > | |
| Camrex::const_iterator< Box > | |
| Camrex::Vector< Setbuf_Char_Type > | |
| Camrex::Vector< MF > | |
| Camrex::Vector< int > | |
| Camrex::Vector< Long > | |
| Camrex::Vector< std::string > | |
| Camrex::Vector< ParticleLevel > | |
| Camrex::Vector< GFab > | |
| Camrex::Vector< char * > | |
| Camrex::Vector< std::size_t > | |
| Camrex::Vector< MPI_Request > | |
| Camrex::Vector< amrex::mpidatatypes::MPI_Status > | |
| Camrex::Vector< Real > | |
| Camrex::Vector< double > | |
| Camrex::Vector< amrex::SpMatrix< T > * > | |
| Camrex::Vector< std::unique_ptr< amrex::SpMatrix< T > > > | |
| Camrex::Vector< amrex::SpMatrix< T > > | |
| Camrex::Vector< amrex::AlgVector< T > > | |
| Camrex::Vector< std::unique_ptr< amrex::JacobiSmoother< T > > > | |
| Camrex::Vector< std::unique_ptr< amrex::ChebyshevSmoother< T > > > | |
| Camrex::Vector< std::unique_ptr< amrex::L1GaussSeidelSmoother< T > > > | |
| Camrex::Vector< amrex::BoxArray > | |
| Camrex::Vector< amrex::StateData > | |
| Camrex::Vector< amrex::Geometry > | |
| Camrex::Vector< amrex::DistributionMapping > | |
| Camrex::Vector< RealTuple > | |
| Camrex::Vector< amrex::MultiMask > | |
| Camrex::Vector< amrex::EB2::ChkptFileLevel > | |
| Camrex::Vector< amrex::EB2::STLLevel > | |
| Camrex::Vector< amrex::EB2::PolyTerm > | |
| Camrex::Vector< amrex::EB2::Edge > | |
| Camrex::Vector< std::unique_ptr< T > > | |
| Camrex::Vector< MFFork > | |
| Camrex::Vector< amrex::ForkJoin::ComponentSet > | |
| Camrex::Vector< amrex::MultiFab > | |
| Camrex::Vector< RT > | |
| Camrex::Vector< V > | |
| Camrex::Vector< amrex::Gpu::StreamManager > | |
| Camrex::Vector< ExternalStream > | |
| Camrex::Vector< HYPRE_Int > | |
| Camrex::Vector< amrex::iMultiFab > | |
| Camrex::Vector< Array< amrex::LayoutData< std::unique_ptr< amrex::PODVector< T, ArenaAllocator< T > >< Real > > >, 3 > > | |
| Camrex::Vector< amrex::PODVector< T, PinnedArenaAllocator< T > >< int > > | |
| Camrex::Vector< amrex::PODVector< T, PinnedArenaAllocator< T > >< amrex::IntVectND< 3 > > > | |
| Camrex::Vector< amrex::PODVector< T, PinnedArenaAllocator< T > >< std::size_t > > | |
| Camrex::Vector< amrex::PODVector< T, PinnedArenaAllocator< T > >< Real > > | |
| Camrex::Vector< amrex::LayoutData< amrex::PODVector< T, ArenaAllocator< T > >< HYPRE_BigInt > > > | |
| Camrex::Vector< amrex::PODVector< T, ArenaAllocator< T > >< HYPRE_BigInt > > | |
| Camrex::Vector< amrex::SpMatrix< Real > * > | |
| Camrex::Vector< VEC > | |
| Camrex::Vector< DirichletCoupling > | |
| Camrex::Vector< Int > | |
| Camrex::Vector< amrex::Vector< amrex::PODVector< T, ArenaAllocator< T > >< int > > > | |
| Camrex::Vector< NeighborCommTag > | |
| Camrex::Vector< char > | |
| Camrex::Vector< std::map< std::pair< int, int >, amrex::PODVector< T, ArenaAllocator< T > >< int > > > | |
| Camrex::Vector< const FabArrayBase::CopyComTagsContainer * > | |
| Camrex::Vector< PetscInt > | |
| Camrex::Vector< std::map< TileKey, amrex::PODVector< T, ArenaAllocator< T > >< int > > > | |
| Camrex::Vector< std::map< TileKey, amrex::PODVector< T, ArenaAllocator< T > >< amrex::IntVectND< 3 > > > > | |
| Camrex::Vector< amrex::BCRec > | |
| Camrex::Vector< amrex::Real > | |
| Camrex::Vector< amrex::InterpBase * > | |
| Camrex::Vector< amrex::VisMF::FabOnDisk > | |
| Camrex::Vector< T, Allocator > | This class is a thin wrapper around std::vector. Unlike vector, Vector::operator[] provides bound checking when compiled with DEBUG=TRUE |
| Cstd::vector< amrex::AlgVector< Real >, std::allocator< amrex::AlgVector< Real > > > | |
| Camrex::Vector< amrex::AlgVector< Real > > | |
| Cstd::vector< amrex::BoxND< 3 >, std::allocator< amrex::BoxND< 3 > > > | |
| Camrex::Vector< amrex::BoxND< 3 > > | |
| Cstd::vector< amrex::EB2::GShopLevel< G >, std::allocator< amrex::EB2::GShopLevel< G > > > | |
| Camrex::Vector< amrex::EB2::GShopLevel< G > > | |
| Cstd::vector< amrex::FabArray< amrex::BaseFab< HYPRE_Int > >, std::allocator< amrex::FabArray< amrex::BaseFab< HYPRE_Int > > > > | |
| Camrex::Vector< amrex::FabArray< amrex::BaseFab< HYPRE_Int > > > | |
| Cstd::vector< amrex::IndexTypeND< 3 >, std::allocator< amrex::IndexTypeND< 3 > > > | |
| Camrex::Vector< amrex::IndexTypeND< 3 > > | |
| Cstd::vector< amrex::IntVectND< 3 >, std::allocator< amrex::IntVectND< 3 > > > | |
| Camrex::Vector< amrex::IntVectND< 3 > > | |
| Cstd::vector< amrex::LayoutData< HYPRE_Int >, std::allocator< amrex::LayoutData< HYPRE_Int > > > | |
| Camrex::Vector< amrex::LayoutData< HYPRE_Int > > | |
| Cstd::vector< amrex::LayoutData< int >, std::allocator< amrex::LayoutData< int > > > | |
| Camrex::Vector< amrex::LayoutData< int > > | |
| Cstd::vector< amrex::ParticleLocator< amrex::DenseBins< amrex::BoxND< 3 > > >, std::allocator< amrex::ParticleLocator< amrex::DenseBins< amrex::BoxND< 3 > > > > > | |
| Camrex::Vector< amrex::ParticleLocator< amrex::DenseBins< amrex::BoxND< 3 > > > > | |
| Cstd::vector< amrex::ParticleLocator< Bins >, std::allocator< amrex::ParticleLocator< Bins > > > | |
| Camrex::Vector< amrex::ParticleLocator< Bins > > | |
| Cstd::vector< amrex::SpMatrix< Real >, std::allocator< amrex::SpMatrix< Real > > > | |
| Camrex::Vector< amrex::SpMatrix< Real > > | |
| Cstd::vector< amrex::TagVector< amrex::MLTerrainPoisson::BCTag >, std::allocator< amrex::TagVector< amrex::MLTerrainPoisson::BCTag > > > | |
| Camrex::Vector< amrex::TagVector< amrex::MLTerrainPoisson::BCTag > > | |
| Cstd::vector< amrex::Vector< amrex::BndryRegisterT< MF > >, std::allocator< amrex::Vector< amrex::BndryRegisterT< MF > > > > | |
| Camrex::Vector< amrex::Vector< amrex::BndryRegisterT< MF > > > | |
| Cstd::vector< amrex::Vector< amrex::BoxArray >, std::allocator< amrex::Vector< amrex::BoxArray > > > | |
| Camrex::Vector< amrex::Vector< amrex::BoxArray > > | |
| Cstd::vector< amrex::Vector< amrex::BoxND< 3 > >, std::allocator< amrex::Vector< amrex::BoxND< 3 > > > > | |
| Camrex::Vector< amrex::Vector< amrex::BoxND< 3 > > > | |
| Cstd::vector< amrex::Vector< amrex::DistributionMapping >, std::allocator< amrex::Vector< amrex::DistributionMapping > > > | |
| Camrex::Vector< amrex::Vector< amrex::DistributionMapping > > | |
| Cstd::vector< amrex::Vector< amrex::FabArrayId >, std::allocator< amrex::Vector< amrex::FabArrayId > > > | |
| Camrex::Vector< amrex::Vector< amrex::FabArrayId > > | |
| Cstd::vector< amrex::Vector< amrex::FArrayBox * >, std::allocator< amrex::Vector< amrex::FArrayBox * > > > | |
| Camrex::Vector< amrex::Vector< amrex::FArrayBox * > > | |
| Cstd::vector< amrex::Vector< amrex::Geometry >, std::allocator< amrex::Vector< amrex::Geometry > > > | |
| Camrex::Vector< amrex::Vector< amrex::Geometry > > | |
| Cstd::vector< amrex::Vector< amrex::iMultiFab >, std::allocator< amrex::Vector< amrex::iMultiFab > > > | |
| Camrex::Vector< amrex::Vector< amrex::iMultiFab > > | |
| Cstd::vector< amrex::Vector< amrex::LayoutData< int > >, std::allocator< amrex::Vector< amrex::LayoutData< int > > > > | |
| Camrex::Vector< amrex::Vector< amrex::LayoutData< int > > > | |
| Cstd::vector< amrex::Vector< amrex::MultiFab >, std::allocator< amrex::Vector< amrex::MultiFab > > > | |
| Camrex::Vector< amrex::Vector< amrex::MultiFab > > | |
| Cstd::vector< amrex::Vector< amrex::ParticleHeader::GridEntry >, std::allocator< amrex::Vector< amrex::ParticleHeader::GridEntry > > > | |
| Camrex::Vector< amrex::Vector< amrex::ParticleHeader::GridEntry > > | |
| Cstd::vector< amrex::Vector< amrex::Real >, std::allocator< amrex::Vector< amrex::Real > > > | |
| Camrex::Vector< amrex::Vector< amrex::Real > > | |
| Cstd::vector< amrex::Vector< amrex::TagVector< amrex::MLMGABCEBTag< RT > > >, std::allocator< amrex::Vector< amrex::TagVector< amrex::MLMGABCEBTag< RT > > > > > | |
| Camrex::Vector< amrex::Vector< amrex::TagVector< amrex::MLMGABCEBTag< RT > > > > | |
| Cstd::vector< amrex::Vector< amrex::TagVector< amrex::MLMGABCTag< RT > > >, std::allocator< amrex::Vector< amrex::TagVector< amrex::MLMGABCTag< RT > > > > > | |
| Camrex::Vector< amrex::Vector< amrex::TagVector< amrex::MLMGABCTag< RT > > > > | |
| Cstd::vector< amrex::Vector< amrex::Vector< amrex::BoundCond > >, std::allocator< amrex::Vector< amrex::Vector< amrex::BoundCond > > > > | |
| Camrex::Vector< amrex::Vector< amrex::Vector< amrex::BoundCond > > > | |
| Cstd::vector< amrex::Vector< amrex::Vector< amrex::FillBoxId > >, std::allocator< amrex::Vector< amrex::Vector< amrex::FillBoxId > > > > | |
| Camrex::Vector< amrex::Vector< amrex::Vector< amrex::FillBoxId > > > | |
| Cstd::vector< amrex::Vector< Array< amrex::MultiFab, 3 > >, std::allocator< amrex::Vector< Array< amrex::MultiFab, 3 > > > > | |
| Camrex::Vector< amrex::Vector< Array< amrex::MultiFab, 3 > > > | |
| Cstd::vector< amrex::Vector< Array< amrex::MultiMask, 2 *3 > >, std::allocator< amrex::Vector< Array< amrex::MultiMask, 2 *3 > > > > | |
| Camrex::Vector< amrex::Vector< Array< amrex::MultiMask, 2 *3 > > > | |
| Cstd::vector< amrex::Vector< Array< MF, 3 > >, std::allocator< amrex::Vector< Array< MF, 3 > > > > | |
| Camrex::Vector< amrex::Vector< Array< MF, 3 > > > | |
| Cstd::vector< amrex::Vector< Array< std::unique_ptr< amrex::iMultiFab >, 3 > >, std::allocator< amrex::Vector< Array< std::unique_ptr< amrex::iMultiFab >, 3 > > > > | |
| Camrex::Vector< amrex::Vector< Array< std::unique_ptr< amrex::iMultiFab >, 3 > > > | |
| Cstd::vector< amrex::Vector< Array< std::unique_ptr< amrex::MultiFab >, 3 > >, std::allocator< amrex::Vector< Array< std::unique_ptr< amrex::MultiFab >, 3 > > > > | |
| Camrex::Vector< amrex::Vector< Array< std::unique_ptr< amrex::MultiFab >, 3 > > > | |
| Cstd::vector< amrex::Vector< FAB * >, std::allocator< amrex::Vector< FAB * > > > | |
| Camrex::Vector< amrex::Vector< FAB * > > | |
| Cstd::vector< amrex::Vector< HYPRE_Int >, std::allocator< amrex::Vector< HYPRE_Int > > > | |
| Camrex::Vector< amrex::Vector< HYPRE_Int > > | |
| Cstd::vector< amrex::Vector< int >, std::allocator< amrex::Vector< int > > > | |
| Camrex::Vector< amrex::Vector< int > > | |
| Cstd::vector< amrex::Vector< Long >, std::allocator< amrex::Vector< Long > > > | |
| Camrex::Vector< amrex::Vector< Long > > | |
| Cstd::vector< amrex::Vector< MF >, std::allocator< amrex::Vector< MF > > > | |
| Camrex::Vector< amrex::Vector< MF > > | |
| Cstd::vector< amrex::Vector< Real >, std::allocator< amrex::Vector< Real > > > | |
| Camrex::Vector< amrex::Vector< Real > > | |
| Cstd::vector< amrex::Vector< RT >, std::allocator< amrex::Vector< RT > > > | |
| Camrex::Vector< amrex::Vector< RT > > | |
| Cstd::vector< amrex::Vector< std::unique_ptr< amrex::FabFactory< FAB > > >, std::allocator< amrex::Vector< std::unique_ptr< amrex::FabFactory< FAB > > > > > | |
| Camrex::Vector< amrex::Vector< std::unique_ptr< amrex::FabFactory< FAB > > > > | |
| Cstd::vector< amrex::Vector< std::unique_ptr< amrex::Gpu::DeviceScalar< amrex::LUSolver< 3 *2, RT > > > >, std::allocator< amrex::Vector< std::unique_ptr< amrex::Gpu::DeviceScalar< amrex::LUSolver< 3 *2, RT > > > > > > | |
| Camrex::Vector< amrex::Vector< std::unique_ptr< amrex::Gpu::DeviceScalar< amrex::LUSolver< 3 *2, RT > > > > > | |
| Cstd::vector< amrex::Vector< std::unique_ptr< amrex::iMultiFab > >, std::allocator< amrex::Vector< std::unique_ptr< amrex::iMultiFab > > > > | |
| Camrex::Vector< amrex::Vector< std::unique_ptr< amrex::iMultiFab > > > | |
| Cstd::vector< amrex::Vector< std::unique_ptr< amrex::MultiFab > >, std::allocator< amrex::Vector< std::unique_ptr< amrex::MultiFab > > > > | |
| Camrex::Vector< amrex::Vector< std::unique_ptr< amrex::MultiFab > > > | |
| Cstd::vector< amrex::Vector< std::unique_ptr< BndryCondLoc > >, std::allocator< amrex::Vector< std::unique_ptr< BndryCondLoc > > > > | |
| Camrex::Vector< amrex::Vector< std::unique_ptr< BndryCondLoc > > > | |
| Cstd::vector< amrex::YAFluxRegisterT< MF >, std::allocator< amrex::YAFluxRegisterT< MF > > > | |
| Camrex::Vector< amrex::YAFluxRegisterT< MF > > | |
| Cstd::vector< Array< amrex::iMultiFab, 3 >, std::allocator< Array< amrex::iMultiFab, 3 > > > | |
| Camrex::Vector< Array< amrex::iMultiFab, 3 > > | |
| Cstd::vector< Array< amrex::MultiFab, 3 >, std::allocator< Array< amrex::MultiFab, 3 > > > | |
| Camrex::Vector< Array< amrex::MultiFab, 3 > > | |
| Cstd::vector< Array< BCType, 3 >, std::allocator< Array< BCType, 3 > > > | |
| Camrex::Vector< Array< BCType, 3 > > | |
| Cstd::vector< Array< Real, 3 >, std::allocator< Array< Real, 3 > > > | |
| Camrex::Vector< Array< Real, 3 > > | |
| Cstd::vector< std::array< int, 2 >, std::allocator< std::array< int, 2 > > > | |
| Camrex::Vector< std::array< int, 2 > > | |
| Cstd::vector< std::array< Long, 4 >, std::allocator< std::array< Long, 4 > > > | |
| Camrex::Vector< std::array< Long, 4 > > | |
| Cstd::vector< std::map< amrex::BoxND< 3 >, Solver_t >, std::allocator< std::map< amrex::BoxND< 3 >, Solver_t > > > | |
| Camrex::Vector< std::map< amrex::BoxND< 3 >, Solver_t > > | |
| Cstd::vector< std::map< PairIndex, amrex::Vector< amrex::Vector< NeighborCopyTag > > >, std::allocator< std::map< PairIndex, amrex::Vector< amrex::Vector< NeighborCopyTag > > > > > | |
| Camrex::Vector< std::map< PairIndex, amrex::Vector< amrex::Vector< NeighborCopyTag > > > > | |
| Cstd::vector< std::map< PairIndex, amrex::Vector< InverseCopyTag > >, std::allocator< std::map< PairIndex, amrex::Vector< InverseCopyTag > > > > | |
| Camrex::Vector< std::map< PairIndex, amrex::Vector< InverseCopyTag > > > | |
| Cstd::vector< std::map< PairIndex, int >, std::allocator< std::map< PairIndex, int > > > | |
| Camrex::Vector< std::map< PairIndex, int > > | |
| Cstd::vector< std::map< PairIndex, IntVector >, std::allocator< std::map< PairIndex, IntVector > > > | |
| Camrex::Vector< std::map< PairIndex, IntVector > > | |
| Cstd::vector< std::map< PairIndex, ParticleTile >, std::allocator< std::map< PairIndex, ParticleTile > > > | |
| Camrex::Vector< std::map< PairIndex, ParticleTile > > | |
| Cstd::vector< std::map< std::pair< int, int >, amrex::NeighborList< ParticleType > >, std::allocator< std::map< std::pair< int, int >, amrex::NeighborList< ParticleType > > > > | |
| Camrex::Vector< std::map< std::pair< int, int >, amrex::NeighborList< ParticleType > > > | |
| Cstd::vector< std::pair< amrex::Arena *, void * >, std::allocator< std::pair< amrex::Arena *, void * > > > | |
| Camrex::Vector< std::pair< amrex::Arena *, void * > > | |
| Cstd::vector< std::pair< int, int >, std::allocator< std::pair< int, int > > > | |
| Camrex::Vector< std::pair< int, int > > | |
| Cstd::vector< std::pair< Real, std::unique_ptr< MultiFab > >, std::allocator< std::pair< Real, std::unique_ptr< MultiFab > > > > | |
| Camrex::Vector< std::pair< Real, std::unique_ptr< MultiFab > > > | |
| Cstd::vector< std::pair< void *, amrex::Arena * >, std::allocator< std::pair< void *, amrex::Arena * > > > | |
| Camrex::Vector< std::pair< void *, amrex::Arena * > > | |
| Cstd::vector< std::shared_ptr< amrex::distFcnElement2d >, std::allocator< std::shared_ptr< amrex::distFcnElement2d > > > | |
| Camrex::Vector< std::shared_ptr< amrex::distFcnElement2d > > | |
| Cstd::vector< std::unique_ptr< amrex::AmrLevel >, std::allocator< std::unique_ptr< amrex::AmrLevel > > > | |
| Camrex::Vector< std::unique_ptr< amrex::AmrLevel > > | |
| Cstd::vector< std::unique_ptr< amrex::BndryRegisterT< MF > >, std::allocator< std::unique_ptr< amrex::BndryRegisterT< MF > > > > | |
| Camrex::Vector< std::unique_ptr< amrex::BndryRegisterT< MF > > > | |
| Cstd::vector< std::unique_ptr< amrex::BndryRegisterT< MultiFab > >, std::allocator< std::unique_ptr< amrex::BndryRegisterT< MultiFab > > > > | |
| Camrex::Vector< std::unique_ptr< amrex::BndryRegisterT< MultiFab > > > | |
| Cstd::vector< std::unique_ptr< amrex::ChebyshevSmoother< Real > >, std::allocator< std::unique_ptr< amrex::ChebyshevSmoother< Real > > > > | |
| Camrex::Vector< std::unique_ptr< amrex::ChebyshevSmoother< Real > > > | |
| Cstd::vector< std::unique_ptr< amrex::DistributionMapping >, std::allocator< std::unique_ptr< amrex::DistributionMapping > > > | |
| Camrex::Vector< std::unique_ptr< amrex::DistributionMapping > > | |
| Cstd::vector< std::unique_ptr< amrex::EB2::IndexSpace >, std::allocator< std::unique_ptr< amrex::EB2::IndexSpace > > > | |
| Camrex::Vector< std::unique_ptr< amrex::EB2::IndexSpace > > | |
| Cstd::vector< std::unique_ptr< amrex::ErrorRec >, std::allocator< std::unique_ptr< amrex::ErrorRec > > > | |
| Camrex::Vector< std::unique_ptr< amrex::ErrorRec > > | |
| Cstd::vector< std::unique_ptr< amrex::FabArray< amrex::BaseFab< Long > > >, std::allocator< std::unique_ptr< amrex::FabArray< amrex::BaseFab< Long > > > > > | |
| Camrex::Vector< std::unique_ptr< amrex::FabArray< amrex::BaseFab< Long > > > > | |
| Cstd::vector< std::unique_ptr< amrex::FabArray< IdFab > >, std::allocator< std::unique_ptr< amrex::FabArray< IdFab > > > > | |
| Camrex::Vector< std::unique_ptr< amrex::FabArray< IdFab > > > | |
| Cstd::vector< std::unique_ptr< amrex::FillPatcher< amrex::MultiFab > >, std::allocator< std::unique_ptr< amrex::FillPatcher< amrex::MultiFab > > > > | |
| Camrex::Vector< std::unique_ptr< amrex::FillPatcher< amrex::MultiFab > > > | |
| Cstd::vector< std::unique_ptr< amrex::iMultiFab >, std::allocator< std::unique_ptr< amrex::iMultiFab > > > | |
| Camrex::Vector< std::unique_ptr< amrex::iMultiFab > > | |
| Cstd::vector< std::unique_ptr< amrex::JacobiSmoother< Real > >, std::allocator< std::unique_ptr< amrex::JacobiSmoother< Real > > > > | |
| Camrex::Vector< std::unique_ptr< amrex::JacobiSmoother< Real > > > | |
| Cstd::vector< std::unique_ptr< amrex::L1GaussSeidelSmoother< Real > >, std::allocator< std::unique_ptr< amrex::L1GaussSeidelSmoother< Real > > > > | |
| Camrex::Vector< std::unique_ptr< amrex::L1GaussSeidelSmoother< Real > > > | |
| Cstd::vector< std::unique_ptr< amrex::LayoutData< int > >, std::allocator< std::unique_ptr< amrex::LayoutData< int > > > > | |
| Camrex::Vector< std::unique_ptr< amrex::LayoutData< int > > > | |
| Cstd::vector< std::unique_ptr< amrex::MLMGBndryT< MF > >, std::allocator< std::unique_ptr< amrex::MLMGBndryT< MF > > > > | |
| Camrex::Vector< std::unique_ptr< amrex::MLMGBndryT< MF > > > | |
| Cstd::vector< std::unique_ptr< amrex::MLMGBndryT< MultiFab > >, std::allocator< std::unique_ptr< amrex::MLMGBndryT< MultiFab > > > > | |
| Camrex::Vector< std::unique_ptr< amrex::MLMGBndryT< MultiFab > > > | |
| Cstd::vector< std::unique_ptr< amrex::MultiFab >, std::allocator< std::unique_ptr< amrex::MultiFab > > > | |
| Camrex::Vector< std::unique_ptr< amrex::MultiFab > > | |
| Cstd::vector< std::unique_ptr< amrex::SpMatrix< Real > >, std::allocator< std::unique_ptr< amrex::SpMatrix< Real > > > > | |
| Camrex::Vector< std::unique_ptr< amrex::SpMatrix< Real > > > | |
| Cstd::vector< std::unique_ptr< amrex::StateDescriptor >, std::allocator< std::unique_ptr< amrex::StateDescriptor > > > | |
| Camrex::Vector< std::unique_ptr< amrex::StateDescriptor > > | |
| Cstd::vector< std::unique_ptr< amrex::StateDescriptor::BndryFunc >, std::allocator< std::unique_ptr< amrex::StateDescriptor::BndryFunc > > > | |
| Camrex::Vector< std::unique_ptr< amrex::StateDescriptor::BndryFunc > > | |
| Cstd::vector< std::unique_ptr< amrex::VisMF >, std::allocator< std::unique_ptr< amrex::VisMF > > > | |
| Camrex::Vector< std::unique_ptr< amrex::VisMF > > | |
| Cstd::vector< std::unique_ptr< Array< MultiFab, 3 > >, std::allocator< std::unique_ptr< Array< MultiFab, 3 > > > > | |
| Camrex::Vector< std::unique_ptr< Array< MultiFab, 3 > > > | |
| Cstd::vector< std::unique_ptr< MF >, std::allocator< std::unique_ptr< MF > > > | |
| Camrex::Vector< std::unique_ptr< MF > > | |
| Cstd::vector< std::unique_ptr< std::fstream >, std::allocator< std::unique_ptr< std::fstream > > > | |
| Camrex::Vector< std::unique_ptr< std::fstream > > | |
| Camrex::VectorTag< T > | |
| Camrex::EB2::Vertex | Vertex capturing one irregular cell plus its neighbor connectivity |
| Camrex::MC::Vertex | Vertex buffer storing coordinates and normals for extracted surfaces |
| Camrex::VisMFBuffer | |
| Camrex::VisMF | File I/O for FabArray<FArrayBox>. Wrapper class for reading/writing FabArray<FArrayBox> objects to disk in various "smart" ways |
| Camrex::VoidCopyTag | Lightweight tag describing raw pointer copies (used for pack/unpack) |
| Camrex::Gpu::warpReduce< warpSize, T, F > | |
| Camrex::AsyncOut::WriteInfo | Slot assignment metadata for ranks sharing an output file |
| Camrex::XDim3 | A simple struct holding 3 Real values for a 3D coordinate |
| Camrex::YAFluxRegisterT< MF > | |
| Camrex::YAFluxRegisterT< MultiFab > | |
| Camrex::EBFluxRegister | |
1.15.0