| Nexprtk | |
| Cexpression | |
| Csymbol_table | |
| NOpenMesh | |
| NPython | |
| CMeshTraits | |
| NParallelPlates | |
| CChannelType | |
| Nstd | STL namespace |
| Chash< walberla::Cell > | |
| Chash< walberla::Vector2< T > > | |
| Chash< walberla::Vector3< T > > | |
| Nwalberla | Storage for detected contacts which can be used to perform actions for all contacts, e.g |
| Nsweepgen | |
| Ndetail | |
| CFreeSlipLinksFromFlagField | |
| Nsweep_parts | |
| CShadowBufferCache | Manages a single shadow buffer for a field to facilitate data swapping |
| CFreeSlipLinkInfo | |
| CIrregularFreeSlipFactoryImplTraits | |
| CFreeSlipFactory | |
| CPotentialBoundaryLink | Represents a potential boundary link |
| CGenericBoundaryFactory | |
| Nv8 | |
| Ndomain | |
| CCellGrid | Geometric properties of a cell grid |
| CBlockGeometry | Container for geometric properties of a simulation block |
| Nhalo_exchange | |
| Nfields | |
| CGenericFieldPackInfo | |
| CGenericStreamPullPackInfo | |
| Ndetail | |
| C_StreamPullSyncFactory | |
| Nlegacy_cpu | |
| CLegacyHostPackInfoWrapper | |
| CLegacyCpuScheme | |
| CLegacyCpuSchemeTraits | |
| CAbstractCommScheme | |
| CCommSchemeOptions | Options controlling construction of the underlying comm scheme |
| CCommSchemeTraits | |
| CCommSchemeTraits< TCommStencil, memtag::stdmem > | |
| CCommSchemeTraits< TCommStencil, memtag::host > | |
| CHaloExchangeTraits< TField, memtag::stdmem > | |
| CHaloExchangeTraits< TField, memtag::host > | |
| CHaloExchangeTraits< TField, memtag::unified > | |
| CHaloExchangeTraits | |
| CHaloExchangeBuilder | Builder for the HaloExchange class |
| CHaloExchange | Primary facilitator for exchange of halo-layer data between adjacent blocks |
| Nmemory | |
| Nallocator_backends | |
| CHostMemory | Allocator backend for pageable host memory |
| Nbuffer_system | |
| CLinearBuffer | |
| CLinearBufferDataHandling | |
| CBufferIndexing | |
| CBufferView | |
| CBufferSystemBuilder | |
| CBufferSystem | |
| Ninitializers | |
| CBufferInitializer | |
| CSerialBufferInitializer | |
| CBufferInitializer< memtag::stdmem, T > | |
| CBufferInitializer< memtag::host, T > | |
| CBufferInitializer< memtag::unified, T > | |
| CBufferInitializer< memtag::device, T > | |
| CBufferInitializer< memtag::pinned, T > | |
| Nmemtag | |
| C_mem_tag | Common base class for all memory tags |
| Cstdmem | Standard pageable host memory |
| Chost | Aligned pageable host memory |
| Cunified | Managed GPU memory with unified memory semantics |
| Cdevice | Memory tag indicating GPU device memory |
| Cpinned | Memory tag indicating pinned (page-locked) host memory |
| CAllocator | Aligned memory allocator with offset |
| Crebind | |
| CFieldSlices | Iteration slices and cell intervals over a field |
| CField | Primary distributed 3D numerical field data structure |
| CFieldView | View into a field's block-local portion |
| CFieldVtkWriter | |
| CMemoryTraits | Memory traits for a given memory tag |
| CMemoryTraits< memtag::stdmem, T > | |
| CMemoryTraits< memtag::host, T > | |
| CMemoryTraits< memtag::unified, T > | |
| CMemoryTraits< memtag::device, T > | |
| CMemoryTraits< memtag::pinned, T > | |
| CBufferSystem | |
| CBufferView | |
| Nstencil_ranges | |
| CVelocities | |
| CStencilRange | |
| CSubdirections | |
| CSubdirectionsMatrix | |
| CSubdirectionsRange | |
| Nsweep | |
| Ndetail | |
| CBorderSweepSlice | |
| Nexectag | |
| C_exec_tag | |
| CSerial | Serial execution on a single CPU thread |
| COpenMP | Thread-parallel execution using OpenMP |
| CGPU | Accelerated execution on GPU |
| Ninternal | |
| CIndexListBuffer | Index vectors for sparse sweeps |
| CBorderSweep | Sweep restriction to a domain border |
| CFusedSweep | Fusion of two sweeps |
| CCommHidingSweep | |
| CSweepFactory | Factory for derived and wrapper sweeps |
| CCellIdx | |
| CSparseIndexList | |
| CSerialSweeper | |
| Ntesting | |
| CAssertionError | |
| CTestsRunner | Primary test orchestrator |
| Cwith_tolerance | Floating-point near-equality assertions with given tolerances |
| CHaloExchange | Primary facilitator for exchange of halo-layer data between adjacent blocks |
| CField | Primary distributed 3D numerical field data structure |
| CFieldView | View into a field's block-local portion |
| Nblockforest | |
| Ninternal | |
| CBlockDataHandlingWrapper | |
| CBlockDataHandlingHelper | |
| CBlockDataHandlingAdder | |
| CBlockIDSorter | |
| CBlockIDSorter< PhantomData_T, Value_T, false > | |
| CNode | |
| CUniformBufferedSchemeWrapper | Purpose of this class could also be solved by adding return_internal_reference to "createUniformDirectScheme" however this is not easily possible since it returns not a reference but an py::object |
| CUniformBufferedSchemeExporter | |
| CUniformBufferedSchemeCreator | |
| CUniformDirectSchemeWrapper | |
| CUniformDirectSchemeExporter | |
| CUniformDirectSchemeCreator | |
| Ncommunication | |
| CNonUniformBufferedScheme | |
| CNonUniformPackInfo | |
| CUniformBufferedScheme | Communication scheme for buffered communication in uniform block grids |
| CUniformDirectScheme | Communication for a single field using MPI datatypes ( no intermediate buffers ) |
| CCommInfo | |
| CUniformToNonUniformPackInfoAdapter | Adapter to use a communication::UniformPackInfo in a NonUniformBufferedScheme |
| CAABBRefinementSelection | |
| CBlock | |
| CNeighborBlock | |
| CBlockDataHandling | |
| CAlwaysInitializeBlockDataHandling | |
| CAlwaysCreateBlockDataHandling | |
| CBlockForest | |
| CRefreshFunctor | |
| CRefreshCallbackWrappper | |
| CSnapshotCreationFunctor | |
| CBlockInformation | |
| CNode | |
| CMinTargetLevelDeterminationFunctions | |
| CCombinedMinTargetLevelDeterminationFunctions | |
| CBlockForestEvaluation | |
| CBlockStatistics | |
| CBlockID | |
| CBlockReconstruction | |
| CAABBReconstruction | |
| CNeighborhoodReconstructionBlock | |
| CNeighborhoodReconstruction | |
| CNeighborhoodSectionReconstruction | |
| CDirectionBasedReduceScheme | Communication Scheme class for ghost layer based communication with the direction neighbors |
| CGlobalLoadBalancing | |
| CMetisConfiguration | |
| CFixedRefinementLevelSelector | |
| CBlockInfo | |
| CCartesianDistribution | |
| CDynamicCurveBalance | This class implements Hilber and Morton space filling curves for load balancing |
| CDynamicDiffusionBalance | This class implements a diffusive algorithm for load balancing |
| CDynamicParMetis | |
| CDynamicParMetisBlockInfo | |
| CDynamicParMetisBlockInfoPackUnpack | |
| CMinMaxLevelDetermination | |
| CNoPhantomData | |
| CPODPhantomWeight | |
| CPODPhantomWeightPackUnpack | |
| CStaticLevelwiseCurveBalance | |
| CStaticLevelwiseCurveBalanceWeighted | |
| CStaticLevelwiseParMetis | |
| CMetisAssignmentFunctor | Assignment functor for ParMetis based load balancing |
| CWeightAssignmentFunctor | General assignment functor for load balancing |
| CPhantomBlock | |
| CNeighborBlock | |
| CPhantomBlockForest | |
| CSetupBlock | |
| CSetSorter | |
| CBlockSorter | |
| CSetupBlockForest | |
| CRootBlockAABB | |
| Citerator | |
| Cconst_iterator | |
| CRefinementSelectionFunctions | |
| CStructuredBlockForest | |
| CCellBoundingBoxHandling | |
| CSimpleCommunication | |
| CUpdateSecondGhostLayer | |
| CUniformBufferedScheme | Communication scheme for buffered communication in uniform block grids |
| Ndomain_decomposition | |
| Ninternal | |
| CBlockDataHandlingFunctionAdaptor | |
| CBlockDataHandlingWrapper | |
| CBlockDataHandlingHelper | |
| CBlockDataHandlingAdder | |
| CBlockDataItem | |
| CBlockData | Wrapper class for any kind of block data (used only internally, never to be seen in the interface of public member functions) see: http://www.drdobbs.com/cpp/twisting-the-rtti-system-for-safe-dynami/229401004# |
| CDataBase | |
| CData | |
| CSharedSweep | |
| CBlockCounter | Class/functor for counting the blocks stored in parallel on all processes in a structured block storage |
| CBlockDataHandling | |
| CAlwaysInitializeBlockDataHandling | |
| CBlockDataCreator | |
| CBlockDataID | |
| CConstBlockDataID | |
| CBlockStorage | Base class for block storage data structures (the entire simulation space is partitioned into blocks [see class 'IBlock'], and block storage data structures manage these blocks) |
| Citerator | |
| Cconst_iterator | |
| CBlockSweepWrapper | Takes an existing block 'sweep' functor and wrapps it into a void-void functor |
| CIBlock | Base class for blocks (blocks are used to partition the simulation space: blocks are rectangular parts of the simulation space that manage all the data that is assigned to their part of the simulation space) |
| CIBlockID | Interface/base class for block IDs (unique identifiers for blocks) |
| CStructuredBlockDataCreator | |
| CStructuredBlockStorage | Base class for structured block storages (the entire simulation space is partitioned into blocks [see class 'IBlock'], the blocks are partitioned into cells, and structured block storages manage those blocks) |
| CStructuredBlockDataAdder | Helper class for adding multiple block data initialization functions |
| CCellBoundingBoxHandling | |
| Nmpi | |
| Ninternal | |
| CAbstractCommunication | |
| CReceiveInfo | |
| CKnownSizeCommunication | |
| CUnknownSizeCommunication | |
| CUnknownSizeCommunicationIProbe | |
| CNoMPICommunication | |
| CBufferSizeTrait< blockforest::BlockID > | |
| CBufferSizeTrait< Cell > | |
| CBufferSizeTrait< CellInterval > | |
| CBufferSizeTrait< walberla::math::GenericAABB< T > > | |
| CBufferSizeTrait< walberla::math::Matrix3< VT > > | |
| CBufferSizeTrait< walberla::math::Quaternion< VT > > | |
| CBufferSizeTrait< math::Rot3< V > > | |
| CBufferSizeTrait< walberla::math::Vector2< VT > > | |
| CBufferSizeTrait< walberla::math::Vector3< VT > > | |
| CBufferSizeTrait< std::pair< T1, T2 > > | |
| CBufferSizeTrait< std::array< T, N > > | |
| CBufferSizeTrait< std::vector< T, A > > | |
| CBufferSizeTrait< std::basic_string< T > > | |
| CBufferSizeTrait< std::deque< T, A > > | |
| CBufferSizeTrait< std::list< T, A > > | |
| CBufferSizeTrait< std::set< T, C, A > > | |
| CBufferSizeTrait< std::unordered_set< T, C, A > > | |
| CBufferSizeTrait< std::multiset< T, C, A > > | |
| CBufferSizeTrait< std::map< K, T, C, A > > | |
| CBufferSizeTrait< std::unordered_map< K, T, C, A > > | |
| CBufferSizeTrait< std::multimap< K, T, C, A > > | |
| CBufferSizeTrait< RandomUUID > | |
| CBufferSizeTrait | |
| CBufferSizeTrait< bool > | |
| CBufferSizeTrait< char > | |
| CBufferSizeTrait< short > | |
| CBufferSizeTrait< int > | |
| CBufferSizeTrait< long > | |
| CBufferSizeTrait< long long > | |
| CBufferSizeTrait< signed char > | |
| CBufferSizeTrait< unsigned char > | |
| CBufferSizeTrait< unsigned short > | |
| CBufferSizeTrait< unsigned int > | |
| CBufferSizeTrait< unsigned long > | |
| CBufferSizeTrait< unsigned long long > | |
| CBufferSizeTrait< float > | |
| CBufferSizeTrait< double > | |
| CBufferSizeTrait< T > | |
| CGenericOpenMPBufferSystem | Wrapper around BufferSystem for OpenMP parallel MPI communication |
| CGenericBufferSystem | Manages MPI Communication with a set of known communication partners |
| Citerator | |
| CSendInfo | |
| CDatatype | RAII class for MPI data types that commits and frees them |
| CEnvironment | RAII Object to initialize and finalize MPI |
| CMPIManager | Encapsulates MPI Rank/Communicator information |
| CMPIOperation | RAII class for MPI operators that commits and frees them |
| CGenericRecvBuffer | Implementation of a MPI receive buffer |
| CGenericSendBuffer | Implementation of a MPI send buffer |
| CPtr | |
| CTokenizing | MPI tokenizing ensures that not more than N processes execute the same code portion simultaneously |
| CTokenizedScope | Object that starts tokenizing in constructor and ends tokenizing when going out of scope |
| CBufferSizeTrait< walberla::Set< T > > | |
| CBufferSizeTrait< walberla::uid::UID< GE > > | |
| CBufferSizeTrait< BlockDataID > | |
| CBufferSizeTrait< ConstBlockDataID > | |
| CBufferSizeTrait< free_surface::bubble_model::Bubble > | |
| CBufferSizeTrait< free_surface::bubble_model::DistanceInfo > | |
| CBufferSizeTrait< walberla::lbm::LatticeModelBase< CM, CO, FM, EQU > > | |
| CBufferSizeTrait< walberla::mesa_pd::data::particle_flags::FlagT > | |
| CBufferSizeTrait< mesa_pd::ElectrostaticForceNotification > | |
| CBufferSizeTrait< mesa_pd::ForceTorqueNotification > | |
| CBufferSizeTrait< mesa_pd::HeatFluxNotification > | |
| CBufferSizeTrait< mesa_pd::HydrodynamicForceTorqueNotification > | |
| CBufferSizeTrait< mesa_pd::NumContactNotification > | |
| CBufferSizeTrait< mesa_pd::ParticleMigrationNotification > | |
| CBufferSizeTrait< mesa_pd::ParticleRemoteMigrationNotification > | |
| CBufferSizeTrait< mesa_pd::ParticleRemovalNotification > | |
| CBufferSizeTrait< mesa_pd::VelocityCorrectionNotification > | |
| CBufferSizeTrait< mesa_pd::VelocityUpdateNotification > | |
| CBufferSizeTrait< OpenMesh::VertexHandle > | |
| CBufferSizeTrait< OpenMesh::FaceHandle > | |
| CBufferSizeTrait< OpenMesh::HalfedgeHandle > | |
| CBufferSizeTrait< OpenMesh::EdgeHandle > | |
| CBufferSizeTrait< OpenMesh::VectorT< Scalar, DIM > > | |
| Nboundary | |
| CBoundaryConfiguration | Base class for all boundary configuration parameters |
| CBoundary | Base class for all boundary classes |
| CisThreadSafe | |
| CisThreadSafe< Boundary_T > | |
| CBHUIDGenerator | |
| CBoundaryHandling | |
| CBlockSweep | |
| CBHCUIDGenerator | |
| CBoundaryHandlingCollection | |
| CBlockSweep | |
| CBUIDGenerator | |
| CHandlingPackInfo | |
| CShiftedPeriodicityBase | A periodicity boundary condition that adds a user-defined spatial shift to the field when applied |
| Csecond_t | |
| CShiftedPeriodicity | A periodicity boundary condition that adds a user-defined spatial shift to the field when applied |
| Ncommunication | |
| CReducePackInfo | Data packing/unpacking for reduce operations This class can be used, when multiple data sets from different senders should be reduced at the receiver |
| CUniformMPIDatatypeInfo | Interface for direction MPI datatype based communication using blockforest::UniformDirectScheme |
| CUniformPackInfo | Data packing/unpacking for ghost layer based communication of a field |
| Ncell | |
| CCell | A representation of a Cell's coordinates (in 3D) |
| CCellInterval | |
| CCellIntervalIterator | |
| CCellSet | A set of cells |
| CCellVector | A vector of cells |
| Nconfig | |
| CCaseInsensitiveCompare | |
| CConfig | Configuration handler & parameter file parser |
| CParameter | |
| CBlock | Parameter block |
| CBlockHandle | Handle for a Block object |
| CSingleConfigGenerator | |
| CMultipleConfigGenerator | |
| CConfigGenerator | |
| CIterator | |
| Ngrid_generator | |
| CHCPIterator | Helper class to generate points in a hexagonal close packing structure within a certain domain |
| CHCPGrid | Convenience class to enable range based for loops over grid points |
| CSCIterator | Helper class to generate points in a simple cubic structure within a certain domain |
| CSCGrid | Convenience class to enable range based for loops over grid points |
| Nlogging | |
| Ninternal | |
| CLoggingMacroDispatcher | |
| CLogging | |
| CCustomStamp | |
| CTracer | Tracer printing a log message upon creation and destruction |
| Nmath | |
| CGenericAABB | GenericAABB represents an axis-aligned bounding box |
| CMinMaxCornerGivenT | |
| CDistributedSample | Class describing a distributed statistical sample |
| CDoubleAndLongLong | |
| CFloatAndLong | |
| CKahanAccumulator | |
| CLimits | Numerical limits of built-in data types |
| CMathTrait | Base template for the MathTrait class |
| CMathTrait< T, T > | |
| CMatrix2 | Efficient, generic implementation of a 2x2 matrix |
| CMatrix3 | Efficient, generic implementation of a 3x3 matrix |
| CMatrixMxN | Efficient implementation of a \( M \times N \) matrix |
| CFunctionParser | Function parser, for parsing and evaluating functions |
| CFunctionParserOMP | |
| CPlane | |
| CVector3 | Efficient, generic implementation of a 3-dimensional vector |
| CQuaternion | Efficient implementation of a quaternion |
| CIntRandom | |
| CRealRandom | |
| CBoolRandom | |
| CRot3 | Rotation class which merges quaternion and matrix representation |
| CSample | Class describing a statistical sample |
| CSqrtTrait | Base template for the SqrtTrait class |
| CuintFromBitWidth | |
| CuintFromBitWidth< 8 > | |
| CuintFromBitWidth< 16 > | |
| CuintFromBitWidth< 32 > | |
| CuintFromBitWidth< 64 > | |
| CleastUnsignedInteger | Provides the smallest unsigned integer type that has at least minSize bits |
| CVector2 | Efficient, generic implementation of a 2-dimensional vector |
| CVector2LexicographicalyLess | Functor providing a lexicographical ordering for Vector2 |
| CVector3LexicographicalyLess | Functor providing a lexicographical ordering for Vector3 |
| Nselectable | |
| CAllSetSelectableObject | Implementation of SelectableObject using sets (see "AllSet.h") as selection attributes |
| CCompare | |
| CSelectableObject | Abstract base class for storing and selecting objects of type T which are attached with selection attributes of type A |
| Citerator | |
| Cconst_iterator | |
| CSetSelectableObject | Implementation of SelectableObject using objects of type SetSelectionPair (see "SetSelectionPair.h") as selection attributes, and objects of type Set (see "Set.h") as selector |
| CCompare | |
| CSetSelectionPair | Class for storing two sets: one marked as "included" and one marked as "excluded" |
| Ntiming | |
| CCpuPolicy | Timing policy for the measurement of the CPU time |
| CRemainingTimeLogger | |
| CStaticPolicy | Timing policy for fake measurement with a static settable clock |
| CTimer | Progress timer for time and performance measurements |
| CTimingNode | |
| CScopeTimer | |
| CTimingPool | |
| CTimingTree | |
| CWcPolicy | Timing policy for the measurement of the wall clock time |
| CDeviceSynchronizePolicy | Timing policy for the measurement of the GPU time |
| Nuid | |
| Nsuidgenerator | |
| CS | Generator class for unified state/selection UIDs |
| CUID | Class for creating, storing, and managing unique identifiers |
| CIndexGenerator | Generates UIDs (unique IDs) per class T starting from 0 |
| CStandardGenerator | Generates UIDs (unique IDs) per class T starting from 1 |
| CBitGenerator | Generates UIDs (unique IDs) per class T starting from 1 |
| CSingletonGenerator | Generates UIDs (unique IDs) per class T starting from 1 |
| Cindex_generated_tag | |
| Cstandard_generated_tag | |
| Cbit_generated_tag | |
| Csingleton_generated_tag | |
| Nexecutiontree | |
| Ninternal | |
| CCaller | |
| CCaller< shared_ptr< T > > | |
| CLoggingStamp | |
| CLoggingStampManager | |
| CFunctor | |
| CSharedFunctor | |
| CSweep | |
| CSharedSweep | |
| CIFunctionNode | |
| CEveryNth | |
| CSequence | |
| CLoop | |
| CITimeloop | |
| Nfft | |
| CFourierTransform | |
| Nfield | |
| Ninternal | |
| CAccuracyEvaluationPlotData | |
| CAccuracyEvaluationPlotDataSorter | |
| CAddToStorage | |
| CAddToStorage< GhostLayerField_T, BlockStorage_T > | |
| CFieldWriter | |
| CPythonFormatString | |
| CPythonFormatString< double > | |
| CPythonFormatString< float > | |
| CPythonFormatString< unsigned short > | |
| CPythonFormatString< int > | |
| CPythonFormatString< unsigned int > | |
| CPythonFormatString< long > | |
| CPythonFormatString< unsigned long > | |
| CPythonFormatString< long long > | |
| CPythonFormatString< unsigned long long > | |
| CPythonFormatString< int8_t > | |
| CPythonFormatString< int16_t > | |
| CPythonFormatString< uint8_t > | |
| CGhostLayerFieldDataHandling | |
| CFieldExporter | |
| CFieldAllocatorExporter | |
| CAddToStorageExporter | |
| CCreateFieldExporter | |
| CCreateVTKWriterExporter | |
| CCreateBinarizationVTKWriterExporter | |
| CGatherExporter | |
| Ncommunication | |
| CPackInfo | Data packing/unpacking for ghost layer based communication of a single walberla::field::FieldTemplate parameters are equivalent of the parameters of GhostLayerField that is communicated |
| CReducePackInfo | Data packing/unpacking for reduce operations This class can be used, when multiple data sets from different senders should be reduced at the receiver |
| CStencilRestrictedMPIDatatypeInfo | |
| CStencilRestrictedPackInfo | PackInfo that packs only the components that point to the neighbor |
| CUniformMPIDatatypeInfo | |
| CUniformPullReductionPackInfo | Data packing/unpacking for ghost layer based communication of a single walberla::field::Field |
| Nrefinement | |
| CPackInfo | |
| CAccuracyEvaluation | Class for evaluating the accuracy of a simulation |
| CAccuracyEvaluationLinePlot | Class for plotting simulation (and solution) values along a line through the domain |
| CAccuracyEvaluationLinePlotter | Class for plotting simulation (and solution) values along a line through the domain |
| CAdaptorHandling | |
| CAdaptorIterator | Iterator class for Adaptors |
| CComponentExtractionFunction | |
| CComponentExtractionAdaptor | |
| CGhostLayerFieldAdaptor | Adaptor for walberla::field::GhostLayerField |
| CVectorFieldAccessor | Provides an abstraction between Field<real_t,3> and Field<Vector3<real_t>, 1 > |
| CVectorFieldAccessor< VectorField_T > | |
| CCreator | BlockDataCreator for fields |
| CCreator< GhostLayerField_T > | |
| CCreator< FlagField< T > > | |
| CFieldAllocatorBase | |
| CFieldAllocator | Allocation Strategy base class for fields |
| CAllocateAligned | Aligned Allocation strategy for Fields |
| CStdFieldAlloc | Allocator without alignment using new and delete[] |
| CBlockDataHandling | |
| CMerge | |
| CMerge< Vector2< T > > | |
| CMerge< Vector3< T > > | |
| CDefaultBlockDataHandling | |
| CAlwaysInitializeBlockDataHandling | |
| CCloneBlockDataHandling | |
| CFlattenedShallowCopyBlockDataHandling | |
| CGradientRefinement | |
| CCellCounter | Class/functor for counting cells of a specific type that are stored in parallel on all processes in a structured block storage |
| CDistributorHandling | DistributorCreators |
| CKernelDistributor | Distributor for walberla::field::GhostLayerField with kernel strategy |
| CNearestNeighborDistributor | Distributor for walberla::field::Field with nearest neighbor strategy |
| CDefaultEvaluationFilter | |
| CFlagFieldEvaluationFilter | |
| CField | A four dimensional field/lattice |
| CFieldClone | Helper class for the common scenario where a 'scratch field' is needed |
| CFlagField | GhostLayerField that stores bit masks |
| CRegistrationData | |
| CGhostLayerField | Extends the Field with ghost-layer information |
| CInterpolatorHandling | FieldInterpolatorCreators |
| CKernelFieldInterpolator | Interpolator for walberla::field::GhostLayerField with kernel strategy |
| CNearestNeighborFieldInterpolator | Interpolator for walberla::field::Field with nearest neighbor strategy |
| CNearestNeighborInterpolator | Nearest Neighbor interpolation for GhostLayerFields |
| CTrilinearFieldInterpolator | Interpolator for walberla::field::GhostLayerField with trilinear strategy |
| CTrilinearInterpolator | Trilinear interpolation for GhostLayerFields |
| CFieldIterator | Iterator over a 4D array, stored linearized in memory |
| CForwardFieldIterator | |
| CReverseFieldIterator | |
| CFieldNeighborPointer | Class representing one Field coordinate with access only to neighbor values |
| CFieldPointer | Class representing on Field coordinate |
| CMassEvaluation | Class for evaluating the evolution of the mass of a simulation |
| CStabilityChecker | Class/functor for checking a running simulation for non-finite values in a specific field |
| CVTKCellFilter | This cell filter selects only those cells in which at least one non-finite value (= infinite or NaN) was detected |
| CFValueVTKWriter | For each value of a cell, either '0' or '1' is stored in the VTK file |
| CLocalCoordVTKWriter | For each cell, the corresponding block local cell coordinates are stored in the VTK file |
| CGlobalCoordVTKWriter | For each cell, the corresponding global cell coordinates are stored in the VTK file |
| CSwapableCompare | A comparison functor based on field size / field layout |
| CVolumetricFlowRateEvaluation | Class for evaluating the volumetric flow rate of a simulation |
| CFlagFieldCellFilter | |
| CFlagFieldMapping | |
| CBinarizationFieldWriter | |
| CVTKWriter | |
| CQCriterionCellFilter | |
| CVelocityCellFilter | |
| Ngather | |
| CCellGatherPackInfo | Packs data in cells given by a CellContainter ( CellInterval, CellVector..) |
| CSamples | |
| CCompare | Helper class for sorting the receivedData array according to t-value |
| CCurveGatherPackInfo | Packs data of a field along a curve |
| CSamples | |
| CCompare | Helper class for sorting the receivedData array according to t-value |
| CDataProcessor | Interface for classes that operate on "Graph" like data Can be implemented in classes that do output (print a GnuPlot file) or for post-processing classes (calculation of mean value, std deviation..) |
| CFileGatherScheme | Collects / Gathers data from multiple blocks to a single block, using temporary files |
| CGatherPackInfo | Interface for packing & unpacking of data to be gathered |
| CGnuPlotGraphWriter | |
| CMPIGatherScheme | Collects / Gathers data from multiple blocks to a single process |
| Ngeometry | |
| Ncontainment_octree | |
| CBranchNode | |
| CIndeterminateLeafNode | |
| CInsideLeafNode | |
| CLeafNode | |
| CNode | |
| COutsideLeafNode | |
| Ninitializer | |
| CBoundaryFromBody | Initializes a boundary handler using a Body (works for both boundary handlings and boundary handling collections) |
| CBoundaryFromCellInterval | Initializes a boundary handler using a CellInterval (works for both boundary handlings and boundary handling collections) |
| CBoundaryFromDomainBorder | Sets a boundary condition at a certain border of the domain (borders are specified by directions) |
| CBoundaryFromImage | Sets boundary conditions according to a gray scale image |
| CIBlockIDPtrCompare | |
| CBoundaryFromVoxelFile | Sets boundary conditions using information obtained from a voxel file |
| CBoundarySetter | |
| CBoundarySetter< FlagField< Flag_T > > | |
| CInitializationManager | Manages domain initialization from configuration file |
| CInitializerUIDGenerator | |
| CInitializer | Abstract base class for all Initializers |
| COverlapFieldFromBody | Initializes a scalar field from a geometric body |
| CScalarFieldFromBody | Initializes a scalar field from a geometric body |
| CScalarFieldFromCellInterval | Initializes a scalar field using a CellInterval |
| CScalarFieldFromGrayScaleImage | Initializes a scalar field, using the pixel values from a gray scale image The real_t field is initialized with values between 0 and 1 |
| CBodyLogicalOperationBinary | Class representing a union, difference, etc |
| CBodyLogicalAND | |
| CBodyLogicalOR | |
| CBodyLogicalXOR | |
| CBodyLogicalNOT | |
| CCylinder | Class representing a Cylinder |
| CAbstractBody | |
| CDynamicBody | |
| CEllipsoid | Class representing an Ellipsoid in 3D |
| CSphere | Class representing a Sphere |
| CTorus | Class representing a Torus |
| CContainmentOctree | |
| CLessThan | Helper class, used in TriangleMesh::removeDuplicateVertices |
| CTriangleMeshNode | Used only internally in function "TriangleMesh::split( vector<TriangleMesh>& meshes )" |
| CTriangleMesh | Class for storing a triangle mesh |
| CBasicVoxelFileReader | Provides a low level reader for waLBerla geometry files |
| CCellAABB | Helper class to provide a cell based axis-aligned bounding box |
| CBinaryRawFile | |
| CBinaryRawFileInterpolator | |
| CGrayScaleImage | A gray scale image |
| CRGBAImage | A gray scale image |
| CRGBAColor | |
| Cpixel_t | |
| CVoxelFileReader | Provides a reader for waLBerla geometry files |
| Cset | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| Cvector | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| Cmap | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| Ngpu | |
| Ninternal | |
| CGpuFieldExporter | |
| CAddToStorageExporter | |
| CPackInfoExporter | |
| CUniformMPIDatatypeInfoExporter | |
| CcopyFieldToGpuDispatchExporter | |
| Ncommunication | |
| CCustomMemoryBuffer | Simple buffer class that supports memory allocators, e.g |
| CHostMemoryAllocator | |
| CDeviceMemoryAllocator | |
| CGPUPackInfo | Data packing/unpacking for ghost layer based communication of a GPUField |
| CMemcpyPackInfo | Data packing/unpacking for ghost layer based communication of a GPUField |
| CNonUniformGPUScheme | |
| CHeader | |
| CUniformGPUScheme | Communication scheme for buffered communication in uniform block grids |
| CHeader | |
| CGeneratedGPUPackInfo | Data packing/unpacking for ghost layer based communication of a GPUField |
| CGeneratedNonUniformGPUPackInfo | |
| CFieldAccessor | Handle to the underlying device data of a GPUField |
| CFieldAccessor3D | |
| CFieldAccessorXYZ | |
| CGPUField | GhostLayerField stored on a CUDA/HIP GPU |
| CFieldIndexing | Utility class to generate handles to the underlying device data of a GPUField |
| CFieldIndexing3DBase | |
| CFieldIndexing3D | |
| CFieldIndexingXYZ | |
| CStreamRAII | RAII wrapper for GPU streams |
| CEventRAII | |
| CHostFieldAllocator | Allocator that allocates a CPU! |
| CKernel | Wrapper class around a GPU kernel, to call kernels also from code not compiled with the device compiler |
| CNvtxRange | |
| CParallelSection | |
| CParallelStreams | Helper class to run CUDA/HIP operations on parallel streams |
| CShiftedPeriodicityGPU | A periodicity boundary condition that adds a user-defined spatial shift to the field when applied |
| CGPUSweepBase | |
| Nlbm | |
| Ninternal | |
| CPdfFieldHandling | |
| CAdaptVelocityToForce | |
| CAdaptVelocityToForce< LatticeModel_T > | |
| CVelocityCallbackCorrection | |
| CVelocityCallbackCorrection< LatticeModel_T > | |
| CMacroscopicForceCorrection | |
| CMacroscopicForceCorrection< LatticeModel_T > | |
| CEquilibriumForceCorrection | |
| CEquilibriumForceCorrection< LatticeModel_T > | |
| CShearRelaxationParameter | |
| CShearRelaxationParameter< CollisionModel_T > | |
| CVelocityFieldWriterHelper | |
| CVelocityFieldWriterHelper< PdfField_T, VelocityField_T, Vector3< real_t > > | |
| Nevaluations | |
| CPermeability | |
| Ninitializer | |
| CExprSystemInitFunction | |
| CPdfFieldInitializer | |
| CPoiseuille | Initializes the complete domain with a Poiseuille (Channel) Flow |
| Ncollision_model | |
| CSRT_tag | |
| CTRT_tag | |
| CMRT_tag | |
| CCumulant_tag | |
| CSRT | Implementation of LB collision model SRT [6] |
| CSRTField | |
| CTRT | Implementation of LB collision model TRT [10] |
| CD3Q19MRT | Implementation of LB collision model MRT [7] |
| CD3Q27Cumulant | Implementation of Cumulant LB collision operator [8] |
| Nforce_model | |
| CNone_tag | |
| CSimple_tag | |
| CEDM_tag | |
| CLuo_tag | |
| CGuo_tag | |
| CCorrection_tag | |
| CNoDirectionIndependentTerms | Used as return type if there are no common, direction-independent terms for the force density term |
| CNone | |
| CSimpleConstant | For the incompressible LBM, in lattice units, the body force density is equal to the acceleration, since bodyForceDensity_lattice = density_lattice * acceleration_lattice and density_lattice is implicitly set to 1 |
| CEDMField | [16], [17] |
| CDirectionIndependentTerm | |
| CDirectionIndependentTerm< LatticeModel_T > | |
| CShiftedVelocity | |
| CShiftedVelocity< LatticeModel_T > | |
| CLuoConstant | For the incompressible LBM, in lattice units, the body force is equal to the acceleration, since bodyForceDensity_lattice = density_lattice * acceleration_lattice and density_lattice is implicitly set to 1 |
| CLuoField | |
| CGuoConstant | For the incompressible LBM, in lattice units, the body force is equal to the acceleration, since bodyForceDensity_lattice = density_lattice * acceleration_lattice and density_lattice is implicitly set to 1 |
| CGuoField | |
| CCorrection | [18] |
| Nrefinement | |
| Ninternal | |
| CEdgeCornerStencil | |
| CEdgeCornerStencil< LatticeModel_T > | |
| CCurlBasedLevelDetermination | Level determination for refinement check based on local curl |
| CEqualLevelBorderStreamCorrection | |
| CLinearExplosion | |
| CPdfFieldPackInfo | |
| CPdfFieldSyncPackInfo | |
| CFunctorWrapper | |
| CSweepAsFunctorWrapper | |
| CTimeStep | |
| CVoidFunctionWrappper | |
| CBlockFunctionWrappper | |
| CSharedVoidFunctor | |
| CSharedBlockFunctor | |
| CTimeStepPdfPackInfo | |
| CVorticityBasedLevelDetermination | Level determination for refinement check based on (scaled) vorticity values |
| CCombinedInPlaceGpuPackInfo | |
| CPostProcessing | |
| CMarkerFieldGenerator | |
| CMarkerData | |
| CBlockForestEvaluationBase | Class for evaluating the BlockForest data structure of an LBM simulation |
| CBlockStatistics | |
| CBlockForestEvaluation | |
| CCurved | |
| CConfiguration | |
| CDiffusionDirichlet | |
| CScalarConfiguration | |
| CSingleScalarConfiguration | |
| CDynamicUBB | |
| CDefaultBoundaryHandlingFactory | Creates a default boundary handling for LBM simulations |
| CDefaultBoundaryHandlingCollectionFactory | |
| CDefaultDiffusionBoundaryHandlingFactory | |
| CExtendedBoundaryHandlingFactory | Creates a default boundary handling for LBM simulations |
| CFreeDiffusion | |
| CFreeSlip | |
| CNoDiffusion | |
| CNoSlip | |
| COutlet | |
| CParserUBB | |
| CParser | |
| CVelocity | |
| CPressure | |
| CLatticeDensity | |
| CSimpleDiffusionDirichlet | |
| CScalarConfiguration | |
| CSimplePAB | |
| CSimplePressure | |
| CSimpleUBB | |
| CSimpleVelocityBoundary | |
| CUBB | |
| CVelocity | |
| CVelocityBoundary | |
| CConfiguration | |
| CCombinedInPlaceCpuPackInfo | |
| CSparsePdfFieldPackInfo | Optimized PackInfo for sparse PDF fields |
| CDensityAdaptionFunction | |
| CVelocityVectorAdaptionFunction | |
| CMomentumDensityVectorAdaptionFunction | |
| CVelocityAdaptionFunction | |
| CMomentumDensityAdaptionFunction | |
| CShearRateAdaptionFunction | |
| CAdaptor | |
| CPdfFieldCreator | |
| CDensity | |
| CDensity< LatticeModel_T > | |
| CDensityAndMomentumDensity | |
| CDensityAndMomentumDensity< LatticeModel_T > | |
| CDensityAndVelocity | |
| CDensityAndVelocityRange | |
| CDensityAndVelocityRange< LatticeModel_T, FieldIteratorXYZ > | |
| CDefaultDensityEquilibriumVelocityCalculation | |
| CAdvectionDiffusionDensityEquilibriumVelocityCalculation | |
| CDefaultDensityVelocityCallback | |
| CVelocityCallback | |
| CVelocityCallback< VelocityField_T > | |
| CDensityCallback | |
| CDensityVelocityCallback | |
| CEquilibrium | |
| CEquilibrium< LatticeModel_T > | |
| CEquilibriumRange | |
| CEquilibriumRange< LatticeModel_T, FieldIteratorXYZ > | |
| CMomentumDensity | |
| CMomentumDensity< LatticeModel_T > | |
| CPdfField | Specialized field class for PDF fields (fields containing multiple particle distribution functions per cell) |
| CPressureTensor | |
| CQCriterion | |
| CQCriterionFieldWriter | |
| CShearRate | |
| CVelocityFieldWriter | |
| CVorticity | |
| CD2Q9 | |
| CD3Q15 | |
| CD3Q19 | |
| CD3Q27 | |
| CEquilibriumDistribution | |
| CEquilibriumDistribution< LatticeModel_T > | |
| CLatticeModelBase | Base class that is supposed (but not required) to be used for defining specific lattice models |
| CNeighborsStencil | |
| CNeighborsStencil< LatticeModel_T > | |
| CSmagorinskyLES | Can be used together with the collision model "SRTField" |
| CPerformanceEvaluationBase | Class for evaluating the performance of LBM simulations |
| CPerformanceEvaluation | Class for evaluating the performance of LBM simulations using fields |
| CPerformanceLogger | Class for using the PerformanceEvaluation in a timeloop |
| CTimeTracker | Keeps track of the simulation time (One step on the coarsest level counts as '1', one step on the next finer level counts as '0.5', one step on the next level as '0.25' etc.) |
| CAdvectionDiffusionSweep | |
| CAdvectionDiffusionSweep< LM_AdvDiff, VelocityAdapter_T, FlagField_T, VectorField_T > | |
| CAdvectionDiffusionCellOperation< LM_AdvDiff, LM_Hydro > | |
| CDefaultCellOperation< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > &&LatticeModel_T::CollisionModel::constant &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > > | |
| CDefaultCellOperation< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > &&LatticeModel_T::CollisionModel::constant &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::Guo_tag > > > | |
| CDefaultCellOperation< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > &&LatticeModel_T::CollisionModel::constant &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&! LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > > | |
| CDefaultCellOperation< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > &&LatticeModel_T::CollisionModel::constant &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > > | |
| CSplitPureSweep< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > &&LatticeModel_T::CollisionModel::constant &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&! LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > > | |
| CSplitPureSweep< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > &&LatticeModel_T::CollisionModel::constant &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > > | |
| CSplitSweep< LatticeModel_T, FlagField_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > &&LatticeModel_T::CollisionModel::constant &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&! LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > > | |
| CSplitSweep< LatticeModel_T, FlagField_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > &&LatticeModel_T::CollisionModel::constant &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > > | |
| CActiveCellSweep | |
| CAdvectionDiffusionCellOperation | |
| CDefaultCellOperation | |
| CCellwiseSweep | Class for performing the streaming and collision step of the LBM |
| CFlagFieldSweepBase | |
| CSplitPureSweep | |
| CSplitSweep | |
| CStream | |
| CStreamEverything | |
| CStreamPullEverything | |
| CStreamPull | |
| CSweepBase | |
| CStreamSweep | |
| CCollideSweep | |
| CDefaultCellOperation< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::TRT_tag > &&! std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > > | |
| CDefaultCellOperation< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::TRT_tag > &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&! LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > > | |
| CDefaultCellOperation< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::TRT_tag > &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > > | |
| CSplitPureSweep< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::TRT_tag > &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&! LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > > | |
| CSplitPureSweep< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::TRT_tag > &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > > | |
| CSplitSweep< LatticeModel_T, FlagField_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::TRT_tag > &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&! LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > > | |
| CSplitSweep< LatticeModel_T, FlagField_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::TRT_tag > &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > > | |
| CCurlMagnitudeVTKWriter | LengthScaleWeight is only used to be able to derive quantities for the adaptive mesh refinement criterium of curl |
| CDensityVTKWriter | |
| CDensitySIVTKWriter | |
| CNonEqulibriumVTKWriter | |
| CPressureTensorVTKWriter | |
| CQCriterionVTKWriter | |
| CVelocityVTKWriter | |
| CVelocityMagnitudeVTKWriter | |
| CVelocitySIVTKWriter | |
| CVelocitySIMagnitudeVTKWriter | |
| CVorticityComponentVTKWriter | |
| CVTKOutput | Default setup for VTK in LBM simulations |
| CD3Q19BoundaryCollection | |
| CD3Q27BoundaryCollection | |
| CFixedDensityD3Q19 | |
| CIndexInfo | |
| CIndexVectors | |
| CFixedDensityD3Q27 | |
| CIndexInfo | |
| CIndexVectors | |
| CFreeSlipD3Q19 | |
| CIndexInfo | |
| CIndexVectors | |
| CFreeSlipD3Q27 | |
| CIndexInfo | |
| CIndexVectors | |
| CNoSlipD3Q19 | |
| CIndexInfo | |
| CIndexVectors | |
| CNoSlipD3Q27 | |
| CIndexInfo | |
| CIndexVectors | |
| COutflowD3Q19 | |
| CIndexInfo | |
| CIndexVectors | |
| COutflowD3Q27 | |
| CIndexInfo | |
| CIndexVectors | |
| CUBBD3Q19 | |
| CIndexInfo | |
| CIndexVectors | |
| CUBBD3Q27 | |
| CIndexInfo | |
| CIndexVectors | |
| CD3Q19StorageSpecification | |
| CAccessorEVEN | |
| CAccessorODD | |
| CPackKernels | |
| CD3Q27StorageSpecification | |
| CAccessorEVEN | |
| CAccessorODD | |
| CPackKernels | |
| CD3Q19SRT | |
| CD3Q27SRT | |
| Nfree_surface | |
| Ninternal | |
| CBoundaryBlockDataHandling | |
| Nbubble_model | |
| CBubbleModel | |
| CBubbleInfo | |
| CSplitHint | |
| CBubble | |
| CBubbleDistanceAdaptionFunction | |
| CBubbleIDFieldPackInfo | |
| CBubbleModelBase | |
| CBubbleModelConstantPressure | |
| CDisjoiningPressureBubbleModel | |
| CDistanceInfo | |
| CFloodFillInterface | |
| CFloodFillUsingFillLevel | |
| CFloodFillUsingFlagField | |
| CMergeInformation | |
| CCommunicatedNewBubbles | |
| CNewBubbleCommunication | |
| CRegionalFloodFill | |
| Ncurvature_model | |
| CFiniteDifferenceMethod | |
| CLocalTriangulation | |
| CSimpleFiniteDifferenceMethod | |
| CemptySweep | |
| CBlockStateDetectorSweep | |
| CFreeSurfaceBoundaryHandling | |
| CExecuteBoundaryHandling | |
| CSimplePressureWithFreeSurface | |
| CCellConversionSweep | |
| CConversionFlagsResetSweep | |
| CExcessMassDistributionModel | |
| CExcessMassDistributionSweepBase | |
| CExcessMassDistributionSweepInterfaceEvenly | |
| CExcessMassDistributionSweepInterfaceWeighted | |
| CExcessMassDistributionSweepInterfaceAndLiquid | |
| CForceDensitySweep | |
| CForceDensityCodegenSweep | |
| CPdfReconstructionModel | |
| CPdfRefillingModel | |
| CRefillingSweepBase | |
| CExtrapolationRefillingSweepBase | |
| CEquilibriumRefillingSweep | |
| CAverageRefillingSweep | |
| CEquilibriumAndNonEquilibriumRefillingSweep | |
| CExtrapolationRefillingSweep | |
| CGradsMomentsRefillingSweep | |
| CStreamReconstructAdvectSweep | |
| CSurfaceDynamicsHandler | |
| CFlagInfo | |
| CProcessLoadEvaluator | |
| CLoadBalancer | |
| CPhantomWeight | |
| CMaxVelocityComputer | |
| CContactAngle | |
| CSurfaceGeometryHandler | |
| CCurvatureSweepFiniteDifferences | |
| CCurvatureSweepLocalTriangulation | |
| CCurvatureSweepSimpleFiniteDifferences | |
| CDetectWettingSweep | |
| CExtrapolateNormalsSweep | |
| CNormalSweep | |
| CObstacleFillLevelSweep | |
| CObstacleNormalSweep | |
| CKernelK8 | |
| CSmoothingSweep | |
| CSurfaceMeshWriter | |
| CTotalMassComputer | |
| Nlbm_generated | |
| Ninternal | |
| CNonuniformPackingKernelsWrapper | |
| CNonuniformPackingKernelsWrapper< PdfField_T, false > | |
| CNonuniformPackingKernelsWrapper< PdfField_T, true > | |
| CUniformPackingKernelsWrapper | |
| CUniformPackingKernelsWrapper< PdfField_T, false > | |
| CUniformPackingKernelsWrapper< PdfField_T, true > | |
| CPdfFieldHandling | |
| CNonuniformGPUPackingKernelsWrapper | |
| CNonuniformGPUPackingKernelsWrapper< PdfField_T, false > | |
| CNonuniformGPUPackingKernelsWrapper< PdfField_T, true > | |
| CUniformPackingGPUKernelsWrapper | |
| CUniformPackingGPUKernelsWrapper< PdfField_T, false > | |
| CUniformPackingGPUKernelsWrapper< PdfField_T, true > | |
| CCombinedInPlaceCpuPackInfo | |
| CNonuniformCommData | |
| CNonuniformCommDataHandling | |
| CNonuniformGeneratedPdfPackInfo | |
| CUniformGeneratedPdfPackInfo | Pack Info class template for lattice Boltzmann PDF fields |
| CPerformanceEvaluationBase | Class for evaluating the performance of LBM simulations |
| CPerformanceEvaluation | Class for evaluating the performance of LBM simulations using fields |
| CPdfField | |
| CBasicRecursiveTimeStepGPU | |
| CGPUPdfField | |
| CNonuniformGeneratedGPUPdfPackInfo | |
| CNonuniformGPUCommData | |
| CNonuniformGPUCommDataHandling | |
| CUniformGeneratedGPUPdfPackInfo | Pack Info class template for lattice Boltzmann PDF fields |
| CBasicRecursiveTimeStep | |
| Nlbm_mesapd_coupling | |
| Namr | |
| CBlockInfo | |
| CWeightEvaluationFunctor | |
| CParticlePresenceLevelDetermination | |
| CMetisAssignmentFunctor | |
| CWeightAssignmentFunctor | |
| Npsm | |
| Ngpu | |
| CParticleAndVolumeFractionSoA_T | |
| CSphereFractionMappingSweep | |
| CBoxFractionMappingSweep | |
| CPSMSweepCollection | |
| CSetParticleVelocitiesSweep | |
| CReduceParticleForcesSweep | |
| COverlapFractionFunctor | |
| CBoxWithOverlap | |
| CCylindricalBoundaryWithOverlap | |
| CEllipsoidWithOverlap | |
| CHalfSpaceWithOverlap | |
| CSphereWithOverlap | |
| CParticleAndVolumeFractionMapping | |
| CPSMSweep | LBM sweep for the partially saturated cells method |
| CParticleMappingKernel | |
| CCurvedLinear | Linear boundary handling for moving particles |
| CSimpleBB | Bounce back boundary handling for moving particles |
| CMovingParticleMapping | Maps the moving particles into the simulation domain and updates the mapping |
| CMovingParticleMappingKernel | Kernel that maps all particles onto all blocks to the "moving obstacle" boundary condition, that requires the additional particleField |
| CFlagFieldNormalExtrapolationDirectionFinder | |
| CSphereNormalExtrapolationDirectionFinder | |
| CPdfReconstructionManager | Class to manage the reconstruction of PDFs that is needed when cells are becoming uncovered by moving obstacles |
| CEquilibriumReconstructor | |
| CEquilibriumAndNonEquilibriumReconstructor | |
| CExtrapolationReconstructor | |
| CGradsMomentApproximationReconstructor | |
| CAddAccelerationOnParticlesKernel | |
| CAddForceOnParticlesKernel | |
| CAddHydrodynamicInteractionKernel | |
| CAverageHydrodynamicForceTorqueKernel | |
| CInitializeHydrodynamicForceTorqueForAveragingKernel | |
| CInspectionProbe | |
| CLubricationCorrectionKernel | Applies a correction for the unresolved lubrication forces and torques on the the interacting particles |
| COmegaBulkAdapter | |
| CRegularParticlesSelector | |
| CFixedParticlesSelector | |
| CGlobalParticlesSelector | |
| CStokesNumberBasedSphereSelector | |
| CResetHydrodynamicForceTorqueKernel | |
| CSubCyclingManager | Handles the execution of subcycles in a timeloop to allow for finer grained time steps than the LBM ones |
| CAddVirtualForceTorqueKernel | Kernel that sets a virtual force and torque on particles |
| CInitializeVirtualMassKernel | This kernel calculates virtual mass and inertia and sets them as attributes on a particle |
| CParticleAccessorWithShapeVirtualMassWrapper | ! |
| Nmesa_pd | |
| Ncollision_detection | |
| CAnalyticContactDetection | Collision detection functor which uses analytic functions |
| CEpsilonRelEPA | |
| CEpsilonRelEPA< float > | |
| CEpsilonRelEPA< double > | |
| CEpsilonRelEPA< long double > | |
| CEPA | The Expanding-Polytope Algorithm |
| CEPA_Triangle | Class storing Information about a triangular facette (Triangle) of the EPA-Polytope |
| CEPA_Edge | Class storing Information about an Edge of the EPA-Polytope |
| CEPA_TriangleComp | Compare Triangles by their closest points to sort the triangle heap |
| CGeneralContactDetection | Collision detection functor which uses recommended collision functions |
| CGJK | Implementation of the Gilbert-Johnson-Keerthi Algorithm |
| CSupport | |
| Ndata | |
| Nparticle_flags | |
| CFlagT | |
| CContactAccessor | Basic ContactAccessor for the ContactStorage |
| CSingleContactAccessor | Basic ContactAccessor which emulates a single Contact in a ContactStorage without actually needing a ContactStorage |
| CContactHistory | |
| CContactStorage | |
| CContact | |
| Citerator | |
| CSelectContactUid | Predicate that selects a certain property from a Contact |
| CSelectContactId1 | Predicate that selects a certain property from a Contact |
| CSelectContactId2 | Predicate that selects a certain property from a Contact |
| CSelectContactDistance | Predicate that selects a certain property from a Contact |
| CSelectContactNormal | Predicate that selects a certain property from a Contact |
| CSelectContactPosition | Predicate that selects a certain property from a Contact |
| CSelectContactT | Predicate that selects a certain property from a Contact |
| CSelectContactO | Predicate that selects a certain property from a Contact |
| CSelectContactR1 | Predicate that selects a certain property from a Contact |
| CSelectContactR2 | Predicate that selects a certain property from a Contact |
| CSelectContactMu | Predicate that selects a certain property from a Contact |
| CSelectContactP | Predicate that selects a certain property from a Contact |
| CSelectContactDiag_nto | Predicate that selects a certain property from a Contact |
| CSelectContactDiag_nto_inv | Predicate that selects a certain property from a Contact |
| CSelectContactDiag_to_inv | Predicate that selects a certain property from a Contact |
| CSelectContactDiag_n_inv | Predicate that selects a certain property from a Contact |
| CHashGrids | Implementation of the 'Hierarchical Hash Grids' coarse collision detection algorithm |
| CHashGrid | Implementation of the hash grid data structure |
| CCell | Data structure for representing a cell in the hash grid (used by the 'Hierarchical Hash Grids' coarse collision detection algorithm) |
| CIAccessor | Add this as a base class to identify your class as a accessor |
| CIContactAccessor | Add this as a base class to identify your class as an accessor for contact objects |
| CLinkedCells | |
| CParticleAccessor | Basic ParticleAccessor for the ParticleStorage |
| CSingleParticleAccessor | Basic ParticleAccessor which emulates a single particle in a ParticleStorage without actually needing a ParticleStorage |
| CParticleAccessorWithBaseShape | |
| CParticleAccessorWithShape | |
| CParticleStorage | |
| CParticle | |
| Citerator | |
| CSelectParticleUid | Predicate that selects a certain property from a Particle |
| CSelectParticlePosition | Predicate that selects a certain property from a Particle |
| CSelectParticleInteractionRadius | Predicate that selects a certain property from a Particle |
| CSelectParticleFlags | Predicate that selects a certain property from a Particle |
| CSelectParticleOwner | Predicate that selects a certain property from a Particle |
| CSelectParticleGhostOwners | Predicate that selects a certain property from a Particle |
| CSelectParticleLinearVelocity | Predicate that selects a certain property from a Particle |
| CSelectParticleInvMass | Predicate that selects a certain property from a Particle |
| CSelectParticleForce | Predicate that selects a certain property from a Particle |
| CSelectParticleOldForce | Predicate that selects a certain property from a Particle |
| CSelectParticleCharge | Predicate that selects a certain property from a Particle |
| CSelectParticleShapeID | Predicate that selects a certain property from a Particle |
| CSelectParticleBaseShape | Predicate that selects a certain property from a Particle |
| CSelectParticleRotation | Predicate that selects a certain property from a Particle |
| CSelectParticleAngularVelocity | Predicate that selects a certain property from a Particle |
| CSelectParticleTorque | Predicate that selects a certain property from a Particle |
| CSelectParticleOldTorque | Predicate that selects a certain property from a Particle |
| CSelectParticleRadiusAtTemperature | Predicate that selects a certain property from a Particle |
| CSelectParticleCurrentBlock | Predicate that selects a certain property from a Particle |
| CSelectParticleType | Predicate that selects a certain property from a Particle |
| CSelectParticleNextParticle | Predicate that selects a certain property from a Particle |
| CSelectParticleOldContactHistory | Predicate that selects a certain property from a Particle |
| CSelectParticleNewContactHistory | Predicate that selects a certain property from a Particle |
| CSelectParticleTemperature | Predicate that selects a certain property from a Particle |
| CSelectParticleHeatFlux | Predicate that selects a certain property from a Particle |
| CSelectParticleNumContacts | Predicate that selects a certain property from a Particle |
| CSelectParticleDv | Predicate that selects a certain property from a Particle |
| CSelectParticleDw | Predicate that selects a certain property from a Particle |
| CSelectParticleHydrodynamicForce | Predicate that selects a certain property from a Particle |
| CSelectParticleHydrodynamicTorque | Predicate that selects a certain property from a Particle |
| CSelectParticleOldHydrodynamicForce | Predicate that selects a certain property from a Particle |
| CSelectParticleOldHydrodynamicTorque | Predicate that selects a certain property from a Particle |
| CSelectParticleElectrostaticForce | Predicate that selects a certain property from a Particle |
| CSelectParticleTotalDisplacement | Predicate that selects a certain property from a Particle |
| CSelectParticleCollisionForceNorm | Predicate that selects a certain property from a Particle |
| CSelectParticleVirtualMass | Predicate that selects a certain property from a Particle |
| CSelectParticleInvMassIncludingVirtual | Predicate that selects a certain property from a Particle |
| CSelectParticleOldLinearAcceleration | Predicate that selects a certain property from a Particle |
| CSelectParticleInvInertiaBF | Predicate that selects a certain property from a Particle |
| CSelectParticleVirtualInertiaBF | Predicate that selects a certain property from a Particle |
| CSelectParticleInvInertiaBFIncludingVirtual | Predicate that selects a certain property from a Particle |
| CSelectParticleOldAngularAcceleration | Predicate that selects a certain property from a Particle |
| CSelectParticleClusterID | Predicate that selects a certain property from a Particle |
| CSelectParticleSegmentID | Predicate that selects a certain property from a Particle |
| CSelectParticleNeighborState | Predicate that selects a certain property from a Particle |
| CBaseShape | Base class of all shape types |
| CBox | |
| CConvexPolyhedron | |
| CCylindricalBoundary | |
| CEllipsoid | |
| CHalfSpace | Half space shape class |
| CSphere | |
| CShapeStorage | |
| CSparseLinkedCells | |
| Ndomain | |
| Ninternal | |
| CParticleDeleter | Class which gets initialized by BlockForestDataHandling |
| CBlockForestDataHandling | |
| CBlockForestDomain | |
| CSubdomain | |
| CIDomain | Abstract base class for the local subdomain |
| CInfiniteDomain | Every process assumes the whole simulation space belongs to its subdomain |
| Nkernel | |
| Ncnt | |
| CAnisotropicVDWContact | Anisotropic vdW contact |
| CIntegratedVDWContact | VdW Contact with integration |
| CIsotropicVDWContact | Isotropic vdW contact model |
| CVBondContact | VBond interaction model |
| CViscousDamping | |
| CWallContact | Repulsive wall interaction kernel |
| CAssocToBlock | Kernel which updates the currentBlock property of all local properties |
| CDetectAndStoreContacts | Kernel which performs collision detection on a pair of two particles and inserts the contact (if existent) into the contact storage passed in the constructor |
| CDoubleCast | This kernel requires the following particle accessor interface |
| CExplicitEuler | Explicit Euler integration |
| CForceLJ | Kernel which calculates the Lennard Jones force between two particles |
| CHCSITSRelaxationStep | Apply a HCSITS (Hard-contact semi-implicit timestepping solver) relaxation to all contacts |
| CHeatConduction | Heat conduction interaction kernel |
| CInitContactsForHCSITS | Init the datastructures for a contact for later use of the HCSITS-Solver |
| CInitParticlesForHCSITS | Init the datastructures for the particles for later use of the HCSITS-Solver |
| CInsertParticleIntoLinkedCells | Inserts a particle into the data::LinkedCells data structure |
| CInsertParticleIntoSparseLinkedCells | Inserts a particle into the data::SparseLinkedCells data structure |
| CIntegrateParticlesHCSITS | Kernel performing integration of the particles after the HCSITS iteration is done |
| CLinearSpringDashpot | Advanced DEM kernel |
| CNonLinearSpringDashpot | Advanced DEM kernel |
| CSelectAll | |
| CSelectMaster | |
| CSelectGhost | |
| CExcludeInfiniteInfinite | |
| CPFCDamping | PFC style damping |
| CSemiImplicitEuler | Semi-implicit Euler integration for position and velocity |
| CSingleCast | This kernel requires the following particle accessor interface |
| CSpringDashpot | Basic DEM kernel |
| CSpringDashpotSpring | Basic DEM kernel |
| CTemperatureIntegration | Kernel which explicitly integrates a particle in time |
| CVelocityVerletPreForceUpdate | Velocity verlet integration for all particles |
| CVelocityVerletPostForceUpdate | |
| Nmpi | |
| CBroadcastProperty | Broadcast a property from the master particle to all corresponding ghost particles |
| CClearGhostOwnerSync | Clear all ghost particles and reset ghost owner information |
| CClearNextNeighborSync | Clear all ghost particles and reset ghost owner information |
| CContactFilter | Contact filter for parallel execution of collision detection |
| CReduceContactHistory | Reduces all contact history from ghost particles to the master particle |
| CReduceProperty | Reduce a property from all ghost particles to the corresponding master particle |
| CSyncGhostOwners | Kernel which updates all ghost particles |
| CSyncNextNeighbors | Kernel which updates all ghost particles |
| CSyncNextNeighborsBlockForest | Kernel which updates all ghost particles |
| CSyncNextNeighborsNoGhosts | Next neighbor synchronization kernel without ghost particles |
| Nsorting | |
| CHilbertCompareFunctor | Compare functor which sorts particles according to the hilbert space filling curve |
| CLinearizedCompareFunctor | Compare functor which sorts particles along the x, y and z axes |
| Ninternal | |
| CVertexDataSourceAdapter | Adapts a vertex data source for the MESAPD mesh output to the generic vertex data source class |
| CFaceDataSourceAdapter | Adapts a face data source for the MESAPD mesh output to the generic face data source class |
| Nvtk | |
| CIOutputSelector | |
| COutputSelector | |
| CParticleVtkOutput | |
| CContainsPointFunctor | |
| CRayParticleIntersectionRatioFunctor | |
| CContactHistoryNotification | Transmits the contact history |
| CParameters | |
| CElectrostaticForceNotification | Transmits force and torque information |
| CParameters | |
| CForceTorqueNotification | Transmits force and torque information |
| CParameters | |
| CHeatFluxNotification | Transmits force and torque information |
| CParameters | |
| CHydrodynamicForceTorqueNotification | Transmits force and torque information |
| CParameters | |
| CNewGhostParticleNotification | This notification is send to the owner of a particle to signal that a new ghost particle exists and the ghost particle list should be updated |
| CParameters | |
| CNotificationTrait< NewGhostParticleNotification > | |
| CNotificationTrait | Returns the notification type of the template parameter |
| CNumContactNotification | Transmits force and torque information |
| CParameters | |
| CParseMessage | |
| CParticleCopyNotification | A complete particle copy |
| CParameters | |
| CNotificationTrait< ParticleCopyNotification > | |
| CParticleGhostCopyNotification | A complete particle copy for a new ghost particle |
| CParameters | |
| CNotificationTrait< ParticleGhostCopyNotification > | |
| CParticleMigrationNotification | Migrate the particle to this process |
| CParameters | |
| CNotificationTrait< ParticleMigrationNotification > | |
| CParticleRemoteMigrationNotification | The ownership for one of the ghost particles has changed |
| CParameters | |
| CNotificationTrait< ParticleRemoteMigrationNotification > | |
| CParticleRemovalInformationNotification | Used to signal other processes that a shadow copy was destroyed |
| CParameters | |
| CNotificationTrait< ParticleRemovalInformationNotification > | |
| CParticleRemovalNotification | The specified particle should be removed from the process |
| CParameters | |
| CNotificationTrait< ParticleRemovalNotification > | |
| CParticleUpdateNotification | Updates a ghost particle |
| CParameters | |
| CNotificationTrait< ParticleUpdateNotification > | |
| CVelocityCorrectionNotification | Transmits corrections of the linear and angular velocity (dv / dw) that were generated by the impulses acting on the ghost particles during application of the Hard-Contact-Solvers (HCSITS) to the main particle and adds them up |
| CParameters | |
| CVelocityUpdateNotification | Adds up LinearVelocity + Parameters::relaxationParam * velocity_correction in a particle and transmits the result to all its ghost particles |
| CParameters | |
| CFaceDataSource | |
| COutputSelectorFaceDataSource | Generic data source to pick data for a face using a particle selector |
| COutputSelectorFaceDataSource< MeshType, Selector, Vector3< Type > > | Data Source for particle selectors specialized for Vec3 |
| COutputSelectorVertexDataSource | |
| COutputSelectorVertexDataSource< MeshType, Selector, Vector3< Type > > | Data Source specialized for Vec3 |
| CSurfaceVelocityVertexDataSource | |
| CVertexDataSource | |
| CMeshParticleVTKOutput | |
| Nmesh | |
| Ndistance_octree | |
| CBranchNode | |
| CChildInfo | |
| CChildInfoIntersects | |
| CDistanceOctree | |
| CLeafNode | |
| CNode | |
| CExcludeMeshExterior | |
| CExcludeMeshInteriorRefinement | |
| CExcludeMeshInterior | |
| CComplexGeometryBlockforestCreator | |
| CComplexGeometryStructuredBlockforestCreator | |
| CMeshWorkloadMemory | |
| CRefinementSelection | |
| CBoundaryInfo | |
| CBoundaryLocation | |
| CBoundarySetup | |
| CBoundaryUIDFaceDataSource | |
| CColorToBoundaryMapper | |
| CRay | |
| CDistanceProperties | |
| CTriangleDistance | Adds information required to compute signed distances from a point to a triangle |
| CMeshBodyWallDistance | Class which computes the minimum wall distance between a fluid cell and a mesh object using the Möller-Trumbore Fast Minimum Storage Ray/Triangle Intersection Algorithm |
| CQHullFaceSorter | |
| CQHullPointDataSource | |
| CQHull | |
| CRealTraits | |
| CFloatTraits | |
| CNormalsVertexDataSource | |
| CNormalsFaceDataSource | |
| CAreaFaceDataSource | |
| CStatusBitFaceDataSource | |
| CStatusBitVertexDataSource | |
| CColorFaceDataSource | |
| CColorVertexDataSource | |
| CIndexFaceDataSource | |
| CIndexVertexDataSource | |
| CRankFaceDataSource | |
| CRankVertexDataSource | |
| CSubsetFaceFilter | |
| CAABBFaceFilter | |
| CStatusFaceFilter | |
| CDistributedVTKMeshWriter | |
| CVTKMeshWriter | |
| CDataSource | |
| CVertexDataSource | |
| CFaceDataSource | |
| CDistanceOctree | |
| Npde | |
| CDirichlet | Dirichlet boundary handling for PDEs |
| CDirichletBC | |
| CNeumannDomainBoundary | Class for setting Neumann domain boundaries for 1st and 2nd derivatives |
| CNeumann | Neumann boundary handling for PDEs |
| CNeumannBC | |
| CConditionalResidualNorm | |
| CCGFixedStencilIteration | |
| CCGIteration | |
| CJacobiIteration | |
| CRBGSIteration | |
| CVCycles | Class for multigrid V-cycle |
| CResidualNorm | |
| CResidualNormStencilField | |
| CJacobi | |
| CJacobiFixedStencil | |
| CRestrict | Restriction sweep for multigrid |
| CProlongateAndCorrect | Prolongation and correction sweep for multigrid |
| CComputeResidual | Residual calculation sweep for multigrid with stencil field |
| CComputeResidualFixedStencil | Residual calculation sweep for multigrid with fixed stencil weights |
| CZeroize | Sweep that sets all values in a field to zero |
| CCoarsenStencilFieldsDCA | Direct Coarsening Approach for the stencil field |
| CCoarsenStencilFieldsGCA | Galerkin Coarsening Approach for the stencil field |
| CRBGS | |
| CRBGSFixedStencil | |
| CSOR | |
| CSORFixedStencil | |
| CStencilFieldSweepBase | |
| CStencilSweepBase | |
| CSweepBase | |
| Npostprocessing | |
| CTriangleMesh | Class for storing a triangle mesh |
| Npython_coupling | |
| Ndetail | |
| Cowning_iterator_state | |
| CDictWrapper | |
| CNoSuchBlockData | |
| CBlockDataNotConvertible | |
| CNonCopyableWrap | |
| CDispatcher | |
| CBlockDataToObjectTester | |
| CManager | |
| CPythonCallback | Run a Python function from C++ code |
| Nsimd | |
| Nscalar | |
| Cdouble4_t | |
| Caligned_allocator | STL-compliant allocator that allocates aligned memory |
| Crebind | Defines an aligned allocator suitable for allocating elements of type U |
| Cis_vector4_type | |
| Cis_vector4_type< scalar::double4_t > | |
| Nsqlite | |
| CSQLiteDB | |
| Cstring | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| Cmap | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| Nstencil | |
| CIterator | Iterator over all directions contained in a stencil |
| C$name | Defines a D-dimensional stencil info with Q directions |
| Ntimeloop | |
| CITimeloop | |
| CPerformanceMeter | |
| CMeasurement | This struct holds a measurement definition |
| CFuncCreator | |
| CSelectableFunction | |
| CBeforeFunction | |
| CAfterFunction | |
| CSweepOnBlock | |
| CSweepAdder | |
| CSweepTimeloop | Timeloop that runs a collection of sweeps |
| CTimeloop | Abstract base class for time loops |
| CLoggingStamp | |
| CLoggingStampManager | |
| Nvtk | |
| Ninternal | |
| CBlockCellDataWriter | Interface that is used by VTKOutput in order to write data to VTK files |
| CAABBCellFilter | Implementation of a cell filter based on an axis-aligned bounding box |
| CBase64Writer | Class for encoding VTK compatible base64 data streams |
| CBlockCellDataWriter | Interface that is used by VTKOutput in order to write data to VTK files |
| CBlockCellDataWriterScalingAdapter | |
| CCellBBCellFilter | Implementation of a cell filter based on a cell bounding box |
| CChainedFilter | |
| CDumpBlockStructureLevel | |
| CDumpBlockStructureProcess | |
| CCaseInsensitiveCompare | |
| CPointDataSource | |
| CAttributes | |
| CPolylineDataSource | |
| CAttributes | |
| CVTKOutput | |
| CVTKGEN | |
| CVertexCompare | |
| CSamplingCell | |
| CWrite | |
| CWriteCollectors | |
| CVTKTrait | |
| CVTKTrait< int8_t > | |
| CVTKTrait< int16_t > | |
| CVTKTrait< int32_t > | |
| CVTKTrait< int64_t > | |
| CVTKTrait< uint8_t > | |
| CVTKTrait< uint16_t > | |
| CVTKTrait< uint32_t > | |
| CVTKTrait< uint64_t > | |
| CVTKTrait< float > | |
| CVTKTrait< double > | |
| CVTKTrait< math::Vector3< T > > | |
| CVTKTrait< math::Rot3< T > > | |
| CVTKTrait< std::array< T, N > > | |
| CGeneratedNonUniformFieldPackInfo | |
| CAbort | |
| CAllSet | A class for managing sets that supports the ability to define a set that represents all possible elements |
| CConcatIterator | |
| Cnever_true | Workaround to implement static_assert(false) (CWG 2518 / P2593R1) |
| CEnvironment | RAII Object to initialize waLBerla using command line parameters |
| CFunctionTraits | Gives a function's return type as well as the number and type of arguments accepted by a function |
| CFunctionTraits< R(Args...) > | |
| Cargument | |
| CTimestepTracker | |
| CVectorTrait< Matrix2< T > > | |
| CVectorTrait< Matrix3< T > > | |
| CMPITrait< Matrix3< T > > | |
| CVectorTrait< Quaternion< T > > | |
| CMPITrait< Vector2< T > > | |
| CVectorTrait< Vector2< T > > | |
| CMPITrait< Vector3< T > > | |
| CVectorTrait< Vector3< T > > | |
| CRandomUUID | Replacement for boost::uuids::uuid and boost::uuids::random_generator |
| CSet | Wrapper class for managing sets that store elements of type T |
| CSharedFunctor | |
| CParameterList | |
| CContainerStreamReader | RAII Object to read an STL container (e.g |
| CUniqueID | Generation of unique IDs in MPI environments |
| CVectorTrait | Provides information on how to serialize (=extract components) from a compound data type |
| CVectorTrait< T > | |
| CGeneratedNonUniformGPUFieldPackInfo | |
| CBoundaryLocationFunction | |
| CMeshDistanceFunction | |
| CSimpleSweep | |
| CGameOfLifeSweep | |
| CShearFlowInit | Shear Flow Initialization Functor /// |
| CBoundarySetup | |
| CDirectionHandler | |
| CGameOfLifeSweepCUDA | |
| CVelDensLogger | Class for determining (and logging) the minimum and maximum velocity as well as the minimum and maximum density |
| CForceLogger | Class for calculating (and logging) the force exerted by the fluid on an obstacle inside the domain |
| CSRTStream | LBGK/SRT algorithm of the lattice Boltzmann method extended by an additional, simple force term (by Luo) |
| CSRTCollideForce | |
| CMyBoundaryHandling | Functor that is used to add a boundary handling object to each block |
| CReattachmentLengthFinder | Class for determining (and logging) the normalized reattachment length after the backward-facing step |
| CSetup | [variableDefines] |
| CVelocityFunctor | [setupStruct] |
| CJacobiSweep | |
| CJacobiSweepStencil | |
| CJacobiIteration | |
| CReinitialize | |
| CJacobiIterationResidual | |
| CVelocityGradientRefinement | Adaptive refinement criterion |
| CAABBRefinement | |
| CBlockForest | |
| CRefreshFunctor | |
| CRefreshCallbackWrappper | |
| CSnapshotCreationFunctor | |
| CBlockInformation | |
| CNode | |
| CSetupBlock | |
| CSetupBlockForest | |
| CRootBlockAABB | |
| Citerator | |
| Cconst_iterator | |
| CStructuredBlockForest | |
| CCellBoundingBoxHandling | |
| CBoundaryConfiguration | Base class for all boundary configuration parameters |
| CBoundary | Base class for all boundary classes |
| CBoundaryHandling | |
| CBlockSweep | |
| CBoundaryHandlingCollection | |
| CBlockSweep | |
| CCell | A representation of a Cell's coordinates (in 3D) |
| CCellInterval | |
| CCellSet | A set of cells |
| CCellVector | A vector of cells |
| CConfig | Configuration handler & parameter file parser |
| CParameter | |
| CBlock | Parameter block |
| CBlockHandle | Handle for a Block object |
| Cshared_ptr | STL class |
| Cweak_ptr | STL class |
| CMatrix2 | Efficient, generic implementation of a 2x2 matrix |
| CMatrix3 | Efficient, generic implementation of a 3x3 matrix |
| CQuaternion | Efficient implementation of a quaternion |
| CVector2 | Efficient, generic implementation of a 2-dimensional vector |
| CVector3 | Efficient, generic implementation of a 3-dimensional vector |
| CMPIManager | Encapsulates MPI Rank/Communicator information |
| CRemainingTimeLogger | |
| CUID | Class for creating, storing, and managing unique identifiers |
| CBlockDataID | |
| CConstBlockDataID | |
| CBlockDataCreator | |
| CBlockStorage | Base class for block storage data structures (the entire simulation space is partitioned into blocks [see class 'IBlock'], and block storage data structures manage these blocks) |
| Citerator | |
| Cconst_iterator | |
| CBlockSweepWrapper | Takes an existing block 'sweep' functor and wrapps it into a void-void functor |
| CIBlock | Base class for blocks (blocks are used to partition the simulation space: blocks are rectangular parts of the simulation space that manage all the data that is assigned to their part of the simulation space) |
| CIBlockID | Interface/base class for block IDs (unique identifiers for blocks) |
| CStructuredBlockDataCreator | |
| CStructuredBlockStorage | Base class for structured block storages (the entire simulation space is partitioned into blocks [see class 'IBlock'], the blocks are partitioned into cells, and structured block storages manage those blocks) |
| CStructuredBlockDataAdder | Helper class for adding multiple block data initialization functions |
| CCellBoundingBoxHandling | |
| CField | A four dimensional field/lattice |
| CFlagField | GhostLayerField that stores bit masks |
| CRegistrationData | |
| CGhostLayerField | Extends the Field with ghost-layer information |
| CUniformPackInfo | Data packing/unpacking for ghost layer based communication of a field |
| CNonUniformGPUScheme | |
| CHeader | |
| CGeneratedGPUPackInfo | Data packing/unpacking for ghost layer based communication of a GPUField |
| CNonUniformBufferedScheme | |
| CSweepOnBlock | |
| CBeforeFunction | |
| CAfterFunction | |
| CUniformBufferedScheme | Communication scheme for buffered communication in uniform block grids |
| CBubbleModelBase | |
