| Namrex | |
| NAsyncOut | |
| CWriteInfo | Slot assignment metadata for ranks sharing an output file |
| NGpu | |
| CAsyncArray | |
| CAtomicAdd | |
| CAtomicMin | |
| CAtomicMax | |
| CAtomicLogicalAnd | |
| CAtomicLogicalOr | |
| CBuffer | |
| CHostToDevice | |
| CDeviceToHost | |
| CDeviceToDevice | |
| CLaunchSafeGuard | |
| CGraphSafeGuard | |
| CSingleStreamRegion | |
| CNoSyncRegion | |
| CStreamManager | |
| CDevice | |
| CExternalGpuStreamRegion | |
| CSyncAtExitOnly | |
| CElixir | |
| CKernelInfo | |
| CExecutionConfig | |
| CExecConfig | |
| CManaged | |
| CPinned | |
| CDeleter | |
| CDeviceScalar | |
| CSharedMemory | |
| CSharedMemory< double > | |
| CSharedMemory< float > | |
| CSharedMemory< long > | |
| CSharedMemory< long long > | |
| CSharedMemory< int > | |
| CSharedMemory< short > | |
| CSharedMemory< char > | |
| CSharedMemory< unsigned long > | |
| CSharedMemory< unsigned long long > | |
| CSharedMemory< unsigned int > | |
| CSharedMemory< unsigned short > | |
| CSharedMemory< unsigned char > | |
| CSharedMemory< bool > | |
| CwarpReduce | |
| CHandler | |
| CStreamItInfo | |
| CStreamIter | |
| CTrackedVector | |
| CSharedMemory< openbc::Moments::array_type > | |
| Nmpidatatypes | |
| CMPI_Status | |
| NParallelDescriptor | Parallel frontend that abstracts functionalities needed to spawn processes and handle communication |
| CMpi_typemap | Communication datatype (note: this structure also works without MPI) |
| CMessage | Hold the description and status of communication data |
| CProcessTeam | Provide functionalities needed to construct a team of processes to perform a particular job |
| CMpi_typemap< GpuComplex< T > > | |
| CMpi_typemap< ValLocPair< TV, TI > > | |
| NEB2 | |
| CIndexSpace | |
| CIndexSpaceImp | |
| CGeometryShop | Samples an implicit function on boxes and fills EB data |
| CCell | Per-cell geometric information stored in EB graphs |
| CFace | Metadata associated with an EB face |
| CEdge | Edge connecting a graph vertex to a face and downstream vertex id |
| CNeighbor | Packed neighbor structure that tracks the neighbor type in every direction |
| CVertex | Vertex capturing one irregular cell plus its neighbor connectivity |
| CAllRegularIF | Trivial implicit function that always returns the "fluid" sign |
| CIsGPUable | Type trait that reports whether a functor derives from GPUable |
| CIsGPUable< D > | |
| CBoxIF | Signed implicit function for an axis-aligned box |
| CComplementIF | Implicit function wrapper that swaps interior/exterior |
| CIsGPUable< ComplementIF< F > > | |
| CCylinderIF | Signed implicit function for cylinders along a coordinate axis |
| CDevicePtrIF | Wrapper that forwards operator() calls to an implicit function pointer |
| CDifferenceIF | Implicit function that keeps points inside F but outside G |
| CIsGPUable< DifferenceIF< F, G > > | |
| CEllipsoidIF | Signed implicit function for ellipsoids centered at a_center |
| CExtrusionIF | Extrude a 2-D implicit function uniformly along a coordinate direction |
| CIsGPUable< ExtrusionIF< F > > | |
| CIntersectionIF | Implicit function that evaluates the intersection of multiple objects |
| CIsGPUable< IntersectionIF< Head, Tail... > > | |
| CIsGPUable< IntersectionIF< F > > | |
| CLatheIF | Lathe an implicit curve around the z axis to build a surface of revolution |
| CIsGPUable< LatheIF< F > > | |
| CParserIF | Implicit surface defined by an amrex::Parser expression |
| CPlaneIF | |
| CPolyTerm | Represents one monomial in a polynomial implicit function |
| CPolyIF | GPU-ready polynomial implicit function with a fixed number of terms |
| CPolynomialIF | Host-only dynamically-sized polynomial implicit function |
| CRotationIF | Rotate an implicit surface around one of the coordinate axes |
| CIsGPUable< RotationIF< F > > | |
| CScaleIF | Scale an implicit function by arbitrary per-axis factors |
| CIsGPUable< ScaleIF< F > > | |
| CSphereIF | |
| CSplineIF | Implicit function that measures distance to a poly-spline curve in 2-D |
| CTorusIF | |
| CTranslationIF | Translate an implicit surface by subtracting an offset vector |
| CIsGPUable< TranslationIF< F > > | |
| CUnionIF | Implicit function representing the union of several objects |
| CIsGPUable< UnionIF< Head, Tail... > > | |
| CIsGPUable< UnionIF< F > > | |
| CIndexSpaceChkptFile | IndexSpace that reads EB levels from a checkpoint file on disk |
| CIndexSpaceSTL | IndexSpace that samples implicit geometry from STL meshes |
| CGShopLevel | |
| CLevel | |
| CFCData | Face-centered EB data storage structure |
| CChkptFileLevel | EB level specialized for reading checkpoint EB data |
| CSTLLevel | EB2 level that samples geometry from STL files |
| CGFab | Object that stores level-set, face/edge types, and EB graph per box |
| CMultiGFab | LayoutData wrapper that allocates a GFab per FAB/Box |
| CChkptFile | Helper that serializes EB geometry to disk for restartability |
| NMath | |
| CFastDivmodU64 | |
| NMPMD | |
| CCopier | Program ID |
| NNonLocalBC | |
| CHasInverseMemFn | Type trait that tests if T has an InverseImage class member function |
| CIsIndexMapping | Tests if a given type IndexMap is usable as an index mapping between two index based coordinate systems |
| CMultiBlockIndexMapping | This struct describes an affine index transformation for two coordinate systems |
| CMultiBlockCommMetaData | This is the index mapping based on the DTOS MultiBlockDestToSrc |
| CIsFabProjection | This type trait tests if a type P is a projection for FAB |
| CIdentity | This class acts as a default no-op operator |
| CMapComponents | This class takes a projection and a component map and combines them to form a new projection |
| CSwapComponents | This is a permutation where only two components are swapped |
| CSwapComponents< CompI, -1 > | |
| CSwapComponents<-1, CompJ > | |
| CSwapComponents<-1, -1 > | |
| CCommData | This class holds data buffers for either immediate MPI send or recv calls |
| CCommHandler | This class stores both recv and send buffers with an associated MPI tag |
| CIsDataPacking | This type trait tests if a given type DP satisfies the DataPacking concept for type FAB |
| CPackComponents | Contains information about which components take part of the data transaction |
| CApplyDtosAndProjectionOnReciever | This class specializes behaviour on local copies and unpacking receive buffers |
| CNoLocalCopy | |
| CDoLocalCopy | |
| NParallelContext | |
| CFrame | |
| NRungeKutta | Functions for Runge-Kutta methods |
| CPostStageNoOp | |
| NScan | |
| NType | |
| CInclusive | |
| CExclusive | |
| CRetSum | |
| Nsimd | |
| CVectorized | |
| NMC | |
| CVertex | Vertex buffer storing coordinates and normals for extracted surfaces |
| CTriangle | Triangle index buffer referencing Vertex entries |
| CMCFab | Minimal container holding marching-cubes output for one FAB |
| CLookUpTable | Lookup tables used by the Lewiner marching-cubes variant |
| Ncomposite | |
| CTriplet | (row, column, value) of a matrix entry with global indices |
| COwnedCSR | Rows owned by this rank in CSR form, columns sorted within each row and duplicates summed |
| Nsundials | |
| CN_VectorContent_MultiFab_notptr | |
| CMemoryHelper | A SUNDIALS SUNMemoryHelper interface to the amrex::Arena |
| NFFT | |
| CCrossProj | 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 |
| CInfo | |
| CPlan | |
| CLocalR2C | Local Discrete Fourier Transform |
| COpenBCSolver | Convolution-based solver for open boundary conditions using Green's functions |
| CPoisson | Poisson solver for periodic, Dirichlet & Neumann boundaries using FFT |
| CPoissonOpenBC | Poisson solve for Open BC using FFT |
| CPoissonHybrid | 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 |
| CR2C | Parallel Discrete Fourier Transform |
| CR2X | Discrete Fourier Transform |
| CStokes | Stokes solver for periodic domains using FFT |
| NBinPolicy | |
| CGPUBinPolicy | |
| COpenMPBinPolicy | |
| CSerialBinPolicy | |
| NParticleInterpolator | |
| CBase | A base class for doing general particle/mesh interpolation operations |
| CNearest | A class the implements nearest grid point particle/mesh interpolation |
| CLinear | A class the implements linear (CIC) particle/mesh interpolation |
| CAmr | Manage hierarchy of levels for time-dependent AMR computations |
| CAmrLevel | 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 |
| CFillPatchIterator | |
| CFillPatchIteratorHelper | |
| CAuxBoundaryData | |
| CDeriveRec | Derived Type Record |
| CStateRange | An element of a linked list to point to state quantities in AmrLevels |
| CDeriveList | A list of DeriveRecs |
| CLevelBld | Builds problem-specific AmrLevels |
| CStateData | Current and previous level-time data |
| CStateDataPhysBCFunct | |
| CStateDescriptor | Attributes of StateData |
| CBndryFunc | |
| CDescriptorList | |
| CAmrCore | Provide basic functionalities to set up an AMR hierarchy |
| CAmrInfo | |
| CAmrMesh | |
| CAmrParGDB | |
| CAmrParticleContainer_impl | Particle container that automatically pulls grid metadata from AmrCore when available |
| CAmrTracerParticleContainer | Simple tracer container that wires TracerParticleContainer to an AmrCore |
| CCluster | A cluster of tagged cells |
| CClusterList | A list of Cluster objects |
| CErrorRec | Error Record |
| CErrorFunc | |
| CErrorFunc2 | |
| CErrorList | A List of ErrorRecs |
| CAMRErrorTagInfo | Optional knobs that control AMRErrorTag behavior (time window, level limits, etc.) |
| CAMRErrorTag | Flexible tagging rule that supports gradients, thresholds, boxes, and user functors |
| CUserFunc | |
| CFillPatcher | FillPatcher is for filling a fine level MultiFab/FabArray |
| CNullInterpHook | |
| CFluxRegister | Flux Register |
| CInterpolaterBoxCoarsener | |
| CInterpBase | |
| CInterpFaceRegister | InterpFaceRegister is a coarse/fine boundary register for interpolation of face data at the coarse/fine boundary |
| CInterpolater | Virtual base class for interpolaters |
| CNodeBilinear | Bilinear interpolation on node centered data |
| CCellBilinear | Bilinear interpolation on cell centered data |
| CCellConservativeLinear | Linear conservative interpolation on cell centered data |
| CCellConservativeProtected | Lin. cons. interp. on cc data with protection against under/over-shoots |
| CCellQuadratic | Quadratic interpolation on cell centered data |
| CPCInterp | Piecewise Constant interpolation on cell centered data |
| CCellConservativeQuartic | Conservative quartic interpolation on cell averaged data |
| CFaceDivFree | Divergence-preserving interpolation on face centered data |
| CFaceLinear | Piecewise constant tangential interpolation / linear normal interpolation of face data |
| CFaceConservativeLinear | Bilinear tangential interpolation / linear normal interpolation of face data |
| CCellQuartic | Quartic interpolation on cell centered data |
| CMFInterpolater | |
| CMFPCInterp | Piecewise constant interpolation on cell-centered data |
| CMFCellConsLinInterp | Linear conservative interpolation on cell centered data |
| CMFCellConsLinMinmaxLimitInterp | Linear conservative interpolation on cell centered data |
| CMFCellBilinear | [Bi|Tri]linear interpolation on cell centered data |
| CMFNodeBilinear | |
| CTagBox | Tagged cells in a Box |
| CTagBoxArray | An array of TagBoxes |
| CAMReX | Runtime context stored for each active amrex::Initialize() call |
| CAny | Type-erased container similar to std::any, but supports move-only types |
| CMemStat | |
| CArenaInfo | Configuration options for constructing an Arena |
| CArena | Abstract base class for memory arenas |
| CGpuArray | Fixed-size array that can be used on GPU |
| CArray1D | A GPU-compatible one-dimensional array |
| CArray2D | A GPU-compatible two-dimensional array |
| CArray3D | A GPU-compatible three-dimensional array |
| CBoxND | A Rectangular Domain on an Integer Lattice |
| CCellData | Lightweight accessor for data associated with a single cell |
| CArrayND | A multidimensional array accessor |
| CPolymorphicArray4 | Array4 subclass that provides uniform |
| CBackgroundThread | Utility class running deferred work on a single background thread |
| CBArena | Basic Arena that allocates aligned memory on the host heap |
| CSrcComp | Source-component descriptor |
| CDestComp | Destination-component descriptor |
| CNumComps | Number-of-components descriptor |
| CBaseFab | A FortranArrayBox(FAB)-like object |
| CFabArray | An Array of FortranArrayBox(FAB)-like Objects |
| CFABType | |
| CShMem | For shared memory |
| CLayoutData | One-thingy-per-box distributed object |
| CIntVectND | An Integer Vector in dim-Dimensional Space |
| Cshift_hasher | Hash function for IntVectND |
| CIndexTypeND | Cell-Based or Node-Based Indices |
| CFabFactory | Abstract factory interface for creating, aliasing, and destroying FAB objects |
| CParserExecutor | Callable wrapper around a compiled parser expression with N variables |
| CBCRec | Boundary condition record storing low/high face types per coordinate |
| CBLBackTrace | |
| CBLBTer | |
| CBLProfiler | |
| CTinyProfiler | A simple profiler that returns basic performance information (e.g. min, max, and average running time) |
| CBoxIteratorND | Iterator over all IntVects in a Box |
| CBoxConverter | |
| CBoxIndexerND | Utility that maps flattened point indices back to IntVectND coordinates |
| CBoxIndexerND< 1 > | Specialization for the 1D case where no fast-division table is needed |
| CBoxArray | Reference-counted collection of Boxes |
| CRefID | |
| CBoxDomain | A list of disjoint boxes built on top of BoxList |
| CBoxList | A list of Boxes sharing a common IndexType |
| CCArena | Coalescing first-fit dynamic memory arena |
| CNode | The nodes in our free list and block list |
| Chash | |
| CCoordSys | Coordinate system; provides mapping between physical space and index space |
| CCompileTimeOptions | |
| CDataAllocator | Lightweight allocator/deallocator backed by an Arena |
| CDataDeleter | Custom deleter that returns memory to an Arena |
| CDim3 | A simple struct holding 3 int values for a 3D index |
| CXDim3 | A simple struct holding 3 Real values for a 3D coordinate |
| CDistributionMapping | Calculates the distribution of FABs to MPI processes |
| CRef | |
| CRefID | Lightweight identity handle wrapping a pointer to the underlying Ref |
| COutOfMemoryError | |
| CMFInfo | FabArray memory allocation information |
| CTheFaArenaDeleter | |
| CFBData | |
| CPCData | |
| CMultiArray4 | |
| CFabArrayBase | Base class for FabArray |
| CCopyComTag | Used by a bunch of routines when communicating via MPI |
| CBDKey | |
| CTileArray | Tiling |
| CFabComTag | Used for collecting information used in communicating FABs |
| CFPinfo | |
| CCFinfo | Coarse/fine boundary |
| Cmeminfo | |
| CRegionTag | |
| CCommMetaData | |
| CFB | FillBoundary |
| CCPC | Parallel copy or add |
| CRB90 | Rotate Boundary by 90 |
| CRB180 | Rotate Boundary by 180 |
| CPolarB | Fill polar boundary in spherical coordinates |
| CParForInfo | For ParallelFor(FabArray) |
| CRedBlack | |
| CFabArrayStats | |
| CIntDescriptor | A Descriptor of the Long Integer type |
| CRealDescriptor | A Descriptor of the Real Type |
| CFabDataType | Type trait specialized for MultiFab-like types and their containers |
| CFabDataType< T > | Extract the FAB and scalar types directly from a MultiFab-like type |
| CFabInfo | Construction hints passed to FabFactory::create |
| CDefaultFabFactory | Default FabFactory that calls new / delete on the FAB type directly |
| CFillBoxId | Tracks metadata about a pending fill region (box and identifiers) |
| CFabArrayId | Lightweight handle returned when registering FabArrays with a descriptor |
| CFabCopyDescriptor | Describes a single copy request originating from a registered FabArray |
| CFabArrayCopyDescriptor | Manages multi-component copy operations out of one or more FabArrays |
| CFABio_8bit | |
| CFABio_ascii | |
| CFABio | A Class Facilitating I/O for Fabs |
| CFABio_binary | |
| CFArrayBox | A Fortran Array of REALs |
| CFabCopyTag | Describes a source FAB region participating in a copy |
| CVoidCopyTag | Lightweight tag describing raw pointer copies (used for pack/unpack) |
| CFEIntegrator | |
| CForkJoin | |
| CComponentSet | If strategy == split, use this to specify how to split components across tasks |
| CFPC | A Collection of Floating-Point Constants Supporting FAB I/O |
| CPlus | Function object that returns the sum of two values |
| CMinus | Function object that returns the difference of two values |
| CMinimum | Function object that returns the smaller of two values |
| CMaximum | Function object that returns the larger of two values |
| CLogicalAnd | Function object that returns the logical AND of two values |
| CLogicalOr | Function object that returns the logical OR of two values |
| CMultiplies | Function object that returns the product of two values |
| CDivides | Function object that returns the quotient of two values |
| CGeometryData | GPU-safe snapshot of Geometry data suitable for capture in GPU kernels |
| CGeometry | Rectangular problem domain geometry |
| CFatPtr | |
| CArenaAllocatorBase | |
| CArenaWrapper | |
| CDeviceArenaWrapper | |
| CPinnedArenaWrapper | |
| CManagedArenaWrapper | |
| CAsyncArenaWrapper | |
| CPolymorphicArenaWrapper | |
| CArenaAllocator | |
| CDeviceArenaAllocator | |
| CPinnedArenaAllocator | |
| CManagedArenaAllocator | |
| CAsyncArenaAllocator | |
| CPolymorphicArenaAllocator | |
| CRunOnGpu | |
| CIsArenaAllocator | |
| CIsArenaAllocator< T > | |
| CIsPolymorphicArenaAllocator | |
| CIsPolymorphicArenaAllocator< PolymorphicArenaAllocator< T > > | |
| CRunOnGpu< ArenaAllocator< T > > | |
| CRunOnGpu< DeviceArenaAllocator< T > > | |
| CRunOnGpu< ManagedArenaAllocator< T > > | |
| CRunOnGpu< AsyncArenaAllocator< T > > | |
| CGpuComplex | A host / device complex number type, because std::complex doesn't work in device code with Cuda yet |
| CSIMDindex | |
| CIFABio | |
| CIArrayBox | A Fortran Array of ints |
| CiMultiFab | A Collection of IArrayBoxes |
| CCellIndexEnum | Type for defining CellIndex so that all IndexTypeND with different dimensions have the same CellIndex type |
| CIntegratorOps | |
| CIntegratorOps< T > | |
| CIntegratorBase | |
| CIOFormatSaver | |
| CLUSolver | |
| CMemProfiler | |
| CMemInfo | |
| CNBuildsInfo | |
| CMultiFabCopyDescriptor | |
| CMFItInfo | |
| CMFIter | Iterator for looping ever tiles and boxes of amrex::FabArray based containers |
| CDeviceSync | |
| CTileSize | |
| CDynamicTiling | |
| CMultiFab | A collection (stored as an array) of FArrayBox objects |
| CNFilesIter | This class encapsulates writing to nfiles |
| COrientation | Encapsulation of the Orientation of the Faces of a Box |
| COrientationIter | An Iterator over the Orientation of Faces of a Box |
| CPArena | This arena uses CUDA stream-ordered memory allocator if available. If not, use The_Arena() |
| CRealVectND | A Real vector in dim-dimensional space |
| CParmParse | Parse Parameters From Command Line and Input Files |
| CPP_entry | |
| CPeriodicity | 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 |
| CBndryFuncArray | This version calls function working on array |
| CGpuBndryFuncFab | |
| CFabFillNoOp | |
| CCpuBndryFuncFab | This cpu version calls function working on FArrayBox |
| CPhysBCFunctNoOp | |
| CPhysBCFunctUseCoarseGhost | |
| CPhysBCFunct | |
| CPlotFileDataImpl | |
| CPlotFileData | |
| CPODVector | Dynamically allocated vector for trivially copyable data |
| CPrint | This class provides the user with a few print options |
| CAllPrint | Print on all processors of the default communicator |
| CPrintToFile | This class prints to a file with a given base name |
| CAllPrintToFile | Print on all processors of the default communicator |
| CRandomEngine | |
| CRealBox | A Box with real dimensions |
| CReduceOpSum | |
| CReduceOpMin | |
| CReduceOpMax | |
| CReduceOpLogicalAnd | |
| CReduceOpLogicalOr | |
| CReduceOps | |
| CReduceData | |
| CReducer | Class for local reductions (e.g., sum, min and max) |
| CRKIntegrator | |
| CSArena | A STREAM-ordered memory arena |
| CSmallMatrix | Matrix class with compile-time size |
| CStack | |
| CTable1D | |
| CTable2D | |
| CTable3D | |
| CTable4D | |
| CTableData | Multi-dimensional array class |
| CArray4PairTag | |
| CArray4CopyTag | |
| CArray4MaskCopyTag | |
| CArray4Tag | |
| CArray4BoxTag | |
| CArray4BoxValTag | |
| CArray4BoxOrientationTag | |
| CArray4BoxOffsetTag | |
| CVectorTag | |
| CCommRecvBufTag | |
| CCommSendBufTag | |
| CTagVector | |
| CTimeIntegrator | |
| CTinyProfileRegion | |
| CGpuTuple | GPU-compatible tuple |
| CGpuTupleSize | |
| CGpuTupleSize< GpuTuple< Ts... > > | |
| CGpuTupleElement | |
| CGpuTupleElement< Idx, GpuTuple< Head, Tail... > > | |
| CGpuTupleElement< 0, GpuTuple< Head, Tail... > > | |
| CTypeList | Struct for holding types |
| CTypeArray | |
| CToTypeList | Wrap non-TypeList into TypeList |
| CToTypeList< TypeList< Ts... > > | |
| CIsTypeList | |
| CIsTypeList< TypeList< Ts... > > | |
| CIsBaseFab | |
| CIsBaseFab< D > | |
| CIsFabArray | |
| CIsFabArray< D > | |
| CIsMultiFabLike | |
| CIsMultiFabLike< M > | |
| CHasAtomicAdd | |
| CHasAtomicAdd< int > | |
| CHasAtomicAdd< long > | |
| CHasAtomicAdd< unsigned int > | |
| CHasAtomicAdd< unsigned long long > | |
| CHasAtomicAdd< float > | |
| CHasAtomicAdd< double > | |
| CIsAddAssignable | |
| CIsAddAssignable< T, std::void_t< decltype(std::declval< T & >()+=std::declval< T >())> > | |
| CIsMultiFabIterator | |
| CIsParticleIterator | |
| CIsParticleContainer | |
| CDefinitelyNotHostRunnable | |
| CMaybeDeviceRunnable | |
| CMaybeHostDeviceRunnable | |
| CSame | |
| CSame< T, U > | |
| CIsCallable | Test if a given type T is callable with arguments of type Args.. |
| CIsCallableR | Test if a given type T is callable with arguments of type Args.. |
| CConjunction | Logical traits let us combine multiple type requirements |
| CConjunction< B1 > | |
| CConjunction< B1, Bn... > | |
| CDisjunction | |
| CDisjunction< B1 > | |
| CDisjunction< B1, Bn... > | |
| CIsNarrowingConversion | |
| CIsStoreAtomic | |
| CIsStoreAtomic< T > | |
| Cexpect | |
| CStreamRetry | |
| CValLocPair | |
| CVector | This class is a thin wrapper around std::vector. Unlike vector, Vector::operator[] provides bound checking when compiled with DEBUG=TRUE |
| CVisMF | File I/O for FabArray<FArrayBox>. Wrapper class for reading/writing FabArray<FArrayBox> objects to disk in various "smart" ways |
| CFabOnDisk | A structure containing info regarding an on-disk FAB |
| CHeader | An on-disk FabArray<FArrayBox> contains this info in a header file |
| CFabReadLink | This structure is used to store the read order for each FabArray file |
| CPersistentIFStream | This structure is used to store file ifstreams that remain open |
| CVisMFBuffer | |
| CIParserExecutor | Callable wrapper around an integer parser expression with N variables |
| CIParser | Integer-only variant of amrex::Parser |
| CParser | Front-end for parsing scalar expressions into GPU/CPU executors |
| CBndryDataT | A BndryData stores and manipulates boundary data information on each side of each box in a BoxArray |
| CBndryRegisterT | 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 |
| CFabSetT | 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 |
| CInterpBndryDataT | An InterpBndryData object adds to a BndryData object the ability to manipulate and set the data stored in the boundary cells |
| CYAFluxRegisterT | |
| CBoundCond | Maintain an identifier for boundary condition types |
| CEdgeFluxRegister | |
| CFabSetIter | Convenience iterator that reuses MFIter semantics for FabSet traversal |
| CMask | |
| CMultiMask | |
| CMultiMaskIter | Iterator adapter exposing MFIter semantics for MultiMask traversal |
| CdistFcnElement2d | Abstract base for 2-D distance-function elements |
| CLineDistFcnElement2d | Distance function defined by a polyline |
| CSplineDistFcnElement2d | Distance function defined by a cubic spline |
| CGPUable | Marker base that denotes an implicit function callable on device kernels |
| CSTLtools | Utility class that loads STL meshes and samples them onto AMReX grids |
| CEBCellFlag | Bit-coded helper that classifies EB cells and neighbor connectivity |
| CIsStoreAtomic< EBCellFlag > | |
| CEBCellFlagFab | FAB storing EBCellFlag data per cell |
| CNumCells | |
| CEBData | Set of Array4 views to EB data for a single box (plus helpers) |
| CEBDataArrays | Views aggregating EBData for multiple boxes |
| CEBDataCollection | Aggregates the EB data required to build EB-aware MultiFabs/FabFactories |
| CEBFArrayBoxFactory | |
| CEBFArrayBox | FArrayBox variant that can query accompanying EB geometric data |
| CEBFluxRegister | |
| CEBCellConservativeLinear | CellConservativeLinear interpolater customized for EB volume fractions |
| CEBMFCellConsLinInterp | Cell-conservative MultiFab interpolater that honors EB geometry |
| CEBToPVD | Helper that converts EB surfaces into polygonal PVD files |
| CCutFab | FArrayBox specialization used to store cut-cell data (may skip allocation) |
| CMultiCutFab | FabArray façade that only allocates cut-cell Fabs (skipping regular cells) |
| CHypre | Lightweight base class shared by HYPRE-backed linear solvers, HypreABecLap, HypreABecLap2, and HypreABecLap3 |
| CHypreABecLap | Struct-interface HYPRE solver for (a - b div beta grad) phi = rhs |
| CHypreABecLap2 | Semi-structured ABecLaplacian operator built on HYPRE's SStruct API |
| CHypreABecLap3 | HYPRE IJ solver for ABecLaplacian (optionally with overset masks) |
| CHypreIJIface | Convenience interface for configuring and invoking HYPRE IJ solvers |
| CHypreMLABecLap | Multilevel HYPRE solver that mirrors MLMG's ABecLaplacian structure |
| CHypreMLNodeLap | Composite multi-level solve of an MLNodeLaplacian with hypre |
| CHypreNodeLap | IJ-based nodal Laplacian that mirrors MLNodeLinOp's discretization |
| CHypreSolver | Solve Ax = b using HYPRE's generic IJ matrix format where A is a sparse matrix specified using the compressed sparse row (CSR) format |
| CPETScABecLap | PETSc wrapper that assembles/solves (a alpha - b div beta grad) phi = rhs |
| CSundialsUserData | User-supplied callbacks consumed by the AMReX/SUNDIALS bridge |
| CSundialsIntegrator | IntegratorBase implementation powered by SUNDIALS ARKStep/MRIStep |
| CAlgMG | Algebraic multigrid solver for SpMatrix / AlgVector systems |
| CAlgPartition | |
| CAlgVector | Distributed dense vector that mirrors the layout of an AlgPartition |
| CIsAlgVector | |
| CIsAlgVector< V > | |
| CBiCGStab | BiCGStab solver with right preconditioning |
| CCsrView | Lightweight non-owning CSR view that can point to host or device buffers |
| CCSR | Owning CSR container backed by AMReX resizable vectors |
| CCsrIndex | |
| CGMRES | GMRES |
| CGMRESMLMGT | Solve using GMRES with multigrid as preconditioner |
| CKrylovMV | Binds a Krylov solver to an SpMatrix |
| CPCG | Preconditioned conjugate gradient solver |
| CJacobiSmoother | Jacobi smoother for AlgVector/SpMatrix linear systems |
| CChebyshevSmoother | Chebyshev polynomial smoother for AlgVector/SpMatrix systems |
| CL1GaussSeidelSmoother | L1 hybrid Gauss-Seidel smoother for CPUs |
| CParCsr | |
| CCsrSorted | Sorted CSR means for each row the column indices are sorted |
| CCsrValid | Valid CSR means all entries are valid. It may be sorted ro unsorted |
| CSpMatrix | Distributed CSR matrix that manages storage and GPU-friendly partitions |
| CCommMV | |
| CCommTR | |
| CRemoteRowsMM | Rows of another matrix fetched for SpGEMM. Column indices are global |
| CMLABecLaplacianT | |
| CMLALaplacianT | Multi-component ALaplacian (a scalar plus optional spatial a coeffs) |
| CMLAlgMG | Algebraic system of one MG level of AMR level 0 of an MLLinOp, solved with AlgMG |
| CImpl | |
| CMLCellABecLapT | Cell-centered operator that exposes ABec Laplacian helpers to derived classes |
| CMLMGABCTag | |
| CMLCellLinOpT | |
| CMLCGSolverT | CG-family solvers (BiCGStab or CG) for use as the bottom solver in MLMG |
| CMLCurlCurl | Curl (alpha curl E) + beta E = rhs |
| CMLMGABCEBTag | |
| CMLEBABecLap | Embedded-boundary ABec Laplacian (alpha a - beta div(b grad phi)) |
| CMLEBNodeFDLaplacian | Nodal finite-difference Laplacian with optional embedded boundaries |
| CMLEBTensorOp | Embedded-boundary tensor solver mirroring MLTensorOp inside the domain |
| CLPInfo | Configuration knobs for multilevel linear operators (grid agglomeration, metrics, etc.) |
| CLinOpEnumType | |
| CMLMGT | |
| Cerror | |
| CMLPoissonT | Cell-centered Laplacian operator \nabla^2 \phi |
| CMLLinOpT | |
| CMLMGBndryT | Boundary helper for MLMG that manages coarse/fine and physical BC metadata |
| CMLNodeABecLaplacian | |
| CMLNodeLaplacian | |
| CMLNodeLinOp | |
| CMLNodeTensorLaplacian | |
| CMLTensorOp | Tensor solver with shear/bulk viscosity inputs for high-Reynolds flows |
| CMLTerrainPoisson | Cell-centered Poisson operator on a terrain-following mesh |
| CBCTag | |
| COpenBCSolver | Open Boundary Poisson Solver |
| CArrayOfStructs | |
| CBinIterator | |
| Citerator | |
| CDenseBinIteratorFactory | |
| CDenseBins | A container for storing items in a set of bins |
| Cis_soa_particle | |
| Cmake_particle | |
| Cmake_particle< T_ParticleType > | |
| CNeighbors | |
| Citerator | |
| Cconst_iterator | |
| CNeighborData | |
| CNeighborList | |
| CNeighborCode | |
| CNeighborParticleContainer_impl | |
| CNeighborTask | |
| CParGDBBase | |
| CParGDB | We use this for non-Amr particle code |
| CParticleContainer_impl | A distributed container for Particles sorted onto the levels, grids, and tiles of a block-structured AMR hierarchy |
| CParticle | The struct used to store particles |
| CSoAParticle | |
| CRTSoAParticle | |
| CParIterBase_impl | |
| CParIter_impl | |
| CParConstIter_impl | |
| CParticleIDWrapper | |
| CParticleCPUWrapper | |
| CConstParticleIDWrapper | |
| CConstParticleCPUWrapper | |
| CParticleBase | |
| CParticleBase< T, 0, NInt > | |
| CParticleBase< T, NReal, 0 > | |
| CParticleBase< T, 0, 0 > | |
| CSoAParticleBase | |
| CDataLayoutPolicy | |
| CDataLayoutPolicyRaw | |
| CParticleArrayAccessor | |
| Cref_wrapper | |
| CDataLayoutPolicy< ContainerType, ParticleType< Types... >, DataLayout::AoS > | |
| CDataLayoutPolicyRaw< ParticleType< Types... >, DataLayout::AoS > | |
| CDataLayoutPolicy< ContainerType, ParticleType< Types... >, DataLayout::SoA > | |
| CDataLayoutPolicyRaw< ParticleType< Types... >, DataLayout::SoA > | |
| CParticleArray | |
| CGetPID | |
| CGetBucket | |
| CParticleBufferMap | |
| CNeighborUnpackPolicy | |
| CRedistributeUnpackPolicy | |
| CParticleCopyOp | |
| CParticleCopyPlan | |
| CStableOrderedAlgorithm | |
| CTwoPassHostAlgorithm | |
| CAtomicScatterAlgorithm | |
| CBuildWorkspace | |
| CGetSendBufferOffset | |
| CParticleCommData | A struct used for communicating particle data across processes during multi-level operations |
| CParticleLocData | A struct used for storing a particle's position in the AMR hierarchy |
| CParticleInitType | 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 |
| CParticleHandshakeWindow | |
| CParticleContainerBase | |
| CFilterVirt | |
| CTransformerVirt | |
| CAssignGridFilter | |
| CTransformerGhost | |
| CParticleHeader | Metadata prefix of an AMReX particle "Header" file |
| CGridEntry | One entry of the per-level grid table |
| CFilterPositiveID | |
| CAssignGrid | |
| CParticleLocator | |
| CAmrAssignGrid | |
| CAmrParticleLocator | |
| CConstSoAParticle | |
| CConstParticleTileData | |
| CParticleTileData | |
| CThisParticleTileHasNoParticleVector | |
| CThisParticleTileHasNoAoS | |
| CRuntimePtrCacheDirtyFlag | |
| CParticleTile | |
| CArrayView | |
| CParticleTileDataRT | |
| CNextIDRTSoA | |
| CParticleTileRT | |
| CBinMapper | |
| CGetParticleBin | |
| CDefaultAssignor | |
| CSparseBinIteratorFactory | |
| CSparseBins | A container for storing items in a set of bins using "sparse" storage |
| CStructOfArrays | |
| CTracerParticleContainer | |
| CKeepValidFilter | |
| CAsyncArray | |
| CElixir | |
| CMultiBlockIndexMapping | This struct describes an affine index transformation for two coordinate systems |
| CMultiBlockCommMetaData | This is the index mapping based on the DTOS MultiBlockDestToSrc |
| CCommHandler | This class stores both recv and send buffers with an associated MPI tag |
| Nstd | STL namespace |
| Ctuple_size< amrex::IndexTypeND< dim > > | |
| Ctuple_element< s, amrex::IndexTypeND< dim > > | |
| Ctuple_size< amrex::IntVectND< dim > > | |
| Ctuple_element< s, amrex::IntVectND< dim > > | |
| Ctuple_size< amrex::RealVectND< dim > > | |
| Ctuple_element< s, amrex::RealVectND< dim > > | |
| Ctuple_size< amrex::SmallMatrix< T, NRows, NCols, ORDER, StartIndex > > | |
| Ctuple_element< N, amrex::SmallMatrix< T, NRows, NCols, ORDER, StartIndex > > | |
| Ctuple_size< amrex::GpuTuple< Ts... > > | |
| Ctuple_element< std::size_t{0}, amrex::GpuTuple< T, Ts... > > | |
| Ctuple_element< s, amrex::GpuTuple< T, Ts... > > | |
1.15.0