Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

►Nbitpit
►Nadaption	The namespace 'adaption' contains the routines and the data structures for handling patch adaption
CInfo	The Info struct defines the infomation associated to an adaption
CInfoCollection	Container that holds one or more adaption info items
►Nlog	The namespace 'log' contains routines for interacting with the message logger
CLoggerManipulator
►Nmapping	The namespace 'mapping' contains structures for working with the MapperVolOctree class
CInfo	The Info is the structure to store info about mapping between elements
►Npod	The namespace 'pod' contains structures for working with the POD class
CPODField	The PODfield structure is used to store the fields inside POD classes
CPODMode	The PODMode structure is used to store the modes inside pod classes
CSnapshotFile	The SnapFile structure is used to store the file names inside POD classes
►Nutils	Namespace for generic utility functions
►Nhashing	Functions for generating the hash of data types
Chash
Chash< std::pair< T, U > >
Chash< std::tuple< TT... > >
CDoubleFloatingComparison
CDoubleFloatingEqual
CDoubleFloatingGreater
CDoubleFloatingGreaterEqual
CDoubleFloatingLess
CDoubleFloatingLessEqual
CBasePiercedKernel	Base class for the pierced kernel
CBasePiercedStorage	Base class for the pierced storages
CBasePiercedVector	Base class for pierced vectors
CBasePiercedVectorKernel	Base class for pierced vector kernels
CBasePiercedVectorStorage	Base class for pierced vector kernels
CBinaryArchive	Base class for binary archives
CBinaryStream	Base class for defining input and output binary streams
CCell	Defines the cells
CCellFlatMapping	Allows to generate a cell mapping between an id-base numeration to a continuous-index numeration
CCommunicationBuffer	Buffer to be used for data communications
CCommunicationTags	The CommunicationTags oversee the handling of the communication tags
CConfig	Configuration storage
CConfigParser	Configuration file parser
CDataCommInterface	Base class for data communications
CDataCommunicator	Infrastructure needed to exchange data among processes
CDataLBInterface	Base class for data communications
CDGFData	Structure holding meta-information
CDGFObj	Interface to DGF I/O function
►CDiscreteStencil	Metafunction for generating a discretization stencil
Citem_type
CDiscreteStencilWeightManager
CDiscreteStencilWeightPool
CDiscreteStencilWeightValueInfo
CDiscreteStencilWeightValueInfo< weight_t, std::void_t< typename weight_t::value_type > >
CDiscretizationStencilProxyBaseStorage	The DiscretizationStencilProxyBaseStorage class defines a proxy for stencil storage
CDiscretizationStencilProxyStorage
CDiscretizationStencilProxyStorage< stencil_t, PiercedStorage< stencil_t > >
CDiscretizationStencilSolver
CDiscretizationStencilSolverAssembler	The DiscretizationStencilSolverAssembler class defines an assembler for building the stencil solver
CDiscretizationStencilStorageInterface	The DiscretizationStencilStorageInterface class defines the interface for stencil storage
CDummyDataLBImpl	Dummy class for data communications
►CElement	Interface for defining elements
CIdHasher
CElementCacheCollection	The class ElementCacheCollection allows to store a collection of caches for the elements of a mesh
CElementHalfEdge	The ElementHalfEdge class defines element half-edge items
CElementHalfFace	The ElementHalfFace class defines element half-faces
►CElementHalfItem	The ElementHalfItem class is the base calss for defining element half-edge and half-faces
CHasher	The ElementHalfItem::Hasher class allows to create hashes for the half-items
CFileHandler	Creates file names and checks status
CFlatMapping	Allows to generate a mapping between an id-base numeration to a continuous-index numeration
CFlatVector2D	Metafunction for generation of a flattened vector of vectors
CGlobalConfigParser	Global configuration file parser
CIBinaryArchive	Input binary archive
CIBinaryStream	Output binary stream
CIndexGenerator	The IndexGenerator class allows to generate unique ids
CInterface	Defines the interfaces among cells
CIntersection	Intersection class definition
CKdNode	Class for kd-tree node
CKdTree	Class for kd-tree data structure
CKSPOptions
CKSPStatus
CLevelSet	Level Set driver class
CLevelSetBooleanBaseObject	Base class which deals with boolean operation between two LevelSetObjects
CLevelSetBooleanObject	Class which deals with boolean operation between two LevelSetObjects
CLevelSetBooleanObject< LevelSetSegmentationBaseObject >
CLevelSetBooleanResult	Allow to evaluate the result of a boolean operation between two LevelSetObjects
CLevelSetCache	The class LevelSetCache is the base class for defining caches
►CLevelSetCacheCollection	The class LevelSetCacheCollection allows to store a collection of caches
CItem	The class LevelSetCacheCollection::Item defines the items stored in a cache collection. Each item stores the cache and the factory that will be used to create the cache
CLevelSetCachedKernel	Base class for defining kernels that need to cache data
CLevelSetCacheFactory	The class LevelSetCacheFactory provides basic functionalities for cache factories
CLevelSetCartesianKernel	Implements LevelSetKernel for cartesian meshes
CLevelSetComplementBaseObject	Base class that allows to evaluate the complement of a LevelSetObjects
CLevelSetComplementObject	Class that allows to evaluate the complement of a LevelSetObjects
CLevelSetComplementObject< LevelSetObject >
CLevelSetComplementObject< LevelSetSegmentationBaseObject >
CLevelSetContainerBaseCache	The class LevelSetContainerBaseCache is the base class for defining caches that stores the values inside a container owned by them
CLevelSetContainerBaseCacheFactory	The class LevelSetContainerBaseCacheFactory provides basic functionalities for cache factories
CLevelSetContainerCache	The class LevelSetContainerCache is the class for defining caches that stores the values inside a container owned by them
CLevelSetContainerCache< key_t, PiercedStorage< value_t, key_t > >
CLevelSetContainerCache< key_t, PiercedVector< value_t, key_t > >
CLevelSetContainerCache< key_t, std::unordered_map< key_t, value_t > >
CLevelSetContainerCache< key_t, std::vector< value_t > >
CLevelSetContainerCacheFactory	The class LevelSetContainerCacheFactory provides basic functionalities for cache factories
CLevelSetContainerCacheFactory< key_t, PiercedStorage< value_t, key_t > >
CLevelSetContainerCacheFactory< key_t, PiercedVector< value_t, key_t > >
CLevelSetContainerCacheFactory< key_t, std::unordered_map< key_t, value_t > >
CLevelSetContainerCacheFactory< key_t, std::vector< value_t > >
CLevelSetFieldHasher
CLevelSetInfo	A public container which includes all information provided by LevelSet
CLevelSetKernel	Mesh specific implementation to calculate the levelset function
CLevelSetMaskObject	Implements the levelset around a set of cells or interfaces of the kernel
CLevelSetObject	Interface class for all objects with respect to whom the levelset function may be computed
CLevelSetOctreeKernel	Implements LevelSetKernel for octree meshes
CLevelSetProxyBaseObject
CLevelSetProxyObject	Interface class for all objects, which depend on other LevelSetObjects
CLevelSetSegmentationBaseObject	Implements visitor pattern fo segmentated geometries
CLevelSetSegmentationObject	Implements visitor pattern fo segmentated geometries
CLevelSetSegmentationSurfaceInfo	Segmentation kernel
CLevelSetUnstructuredKernel	Implements LevelSetKernel for unstructured meshes
CLevelSetValueCache	The class LevelSetCache is the base class for defining caches that store values
CLevelSetValueCacheBaseEntry
CLevelSetValueCacheEntry	The class LevelSetValueCacheEntry allows to get read-only access to a value stored in the cache
CLevelSetValueCacheEntry< bool >
CLevelSetValueCacheFactory	The class LevelSetValueCacheFactory provides basic functionalities for cache factories
CLIFOStack	Class for Last In First Out stack
CLineBuffer	LineBuffer defines a buffer for reading lines
CLineKernel
CLineStream	LineStream defines a stream for reading lines
CLineUnstructured	Defines an unstructured line tasselation
CLocalTree	Local octree portion for each process
CLogger	Message logger
►CLoggerBuffer	Stream buffer for the message logger
CSettings
CLoggerManager	Manager for the loggers
CMap	Transformation Mapper
CMaxPQueue	Class for max priority queue
CMinPQueue	Class for min priority queue
CMPDiscreteStencil	Metafunction for generating a discretization stencil with a memory pool (MP)
CNaturalSystemMatrixOrdering	Defines allows to use a matrix natural ordering
COBinaryArchive	Output binary archive
COBinaryStream	Output binary stream
COctant	Octant class definition
CPabloUniform	PABLO Uniform is an example of user class derived from ParaTree to map ParaTree in a uniform (square/cubic) domain. Pablo Uniform takes as input in constructor the coordinates of the origin (X,Y,Z) and the length of the side L
►CParaTree	Para Tree is the user interface class
CLoadBalanceRanges
CPatchInfo	Interface for defining patch info
►CPatchKernel	Interface for defining patches
CCellFuzzyPositionGreater
CCellFuzzyPositionLess
CCellPositionGreater
CCellPositionLess
CPointPositionLess
CVertexPositionGreater
CVertexPositionLess
CPatchManager	The PatchManager oversee the handling of the patches
CPatchNumberingInfo	Numbering information about the patch
CPatchSkdTree	PatchSkdTree is the class that implements a spatial kd-tree (skd-tree) a bitpit patch
CPetscManager	Handles the interaction with PETSc library
►CPiercedKernel	Metafunction for generating a pierced kernel
CClearAction
CEraseAction
CFillAction
CMoveAction
CpositionGreater
CpositionLess
CReserveAction
CResizeAction
CShrinkToFitAction
CSortAction
CSqueezeAction
CSwapAction
CPiercedKernelIterator	Iterator for the class PiercedKernel
CPiercedKernelRange	The PiercedKernelRange allow to iterate using range-based loops over a PiercedStorage
CPiercedStorage	Metafunction for generating a pierced storage
CPiercedStorageIterator	Iterator for the class PiercedStorage
CPiercedStorageRange	The PiercedStorageRange allow to iterate using range-based loops over a PiercedStorage
CPiercedStorageSyncSlave	Base class for defining storages that acts like a slave in pierced synchronization
CPiercedSyncAction	Action for pierced synchronization
►CPiercedSyncMaster	Base class for defining an object that acts like a master in pierced synchronization
CSyncModeHasher
CPiercedSyncSlave	Base class for defining an object that acts like a slave in pierced synchronization
CPiercedVector	Metafunction for generating a pierced vector
CPiercedVectorKernel	Kernel of the pierced vector
CPiercedVectorStorage	Kernel of the pierced vector
CPOD	The POD (Proper Orthogonal Decomposition) class provides an interface for defining POD object
CPODKernel	Interface to manage the mesh dependent members and functions of a POD object
CPODVolOctree	The PODVolOctree is the specialized class of PODKernel for VolOctree meshes
CPointCloud	Defines a point cloud
CPointKernel
CProxySystemMatrixOrdering	The ProxySystemMatrixOrdering class defines allows to use a matrix ordering defined in some external storage
CProxyVector	Metafunction for generating a list of elements that can be either stored in an external vectror or, if the elements are constant, inside the container itself
CProxyVectorDummyStorage	Metafunction for generating ProxyVector dummy storages
CProxyVectorIterator	Iterator for the class ProxyVector
CProxyVectorStorage	Metafunction for generating ProxyVector storages
CProxyVectorStorageInterface	Interface for ProxyVector storages
CQualifiedCellHalfEdge
CQualifiedCellHalfFace	The QualifiedCellHalfFace class defines cell half-faces
CQualifiedInterfaceHalfEdge	The QualifiedInterfaceHalfEdge class defines interface half-edges
CRBF	Class to handle Radial Basis Function with a large set of 3D points as nodes
CRBFKernel	Base class to handle Radial Basis Function with a large set of nodes
CReconstruction	Allows to build and apply a polynomial reconstructions
CReconstructionAssembler	Allows to define reconstruction polynomial
CReconstructionKernel	Allows to evaluate the weight of a reconstruction polynomial previously assembled
CReconstructionPolynomial	Allows to apply a reconstruction polynomial previously assembled
CRecvBuffer	Buffer to be used for receive communications
CReference0DElementInfo	Allows to define information about reference zero-dimensional elements
CReference1DElementInfo	Allows to define information about reference one-dimensional elements
CReference2DElementInfo	Allows to define information about reference two-dimensional elements
CReference3DElementInfo	Allows to define information about reference three-dimensional elements
CReferenceElementInfo	Allows to define information about reference elements
CReferenceHexahedronInfo	Defines the information about the reference hexahedron
CReferenceLineInfo	Defines the information about the reference line
CReferencePixelInfo	Defines the information about the reference pixel
CReferencePyramidInfo	Defines the information about the reference pyramid
CReferenceQuadInfo	Defines the information about the reference quadrangle
CReferenceTetraInfo	Defines the information about the reference tetrahedron
CReferenceTriangleInfo	Defines the information about the reference triangle
CReferenceVertexInfo	Defines the information about the reference vertex
CReferenceVoxelInfo	Defines the information about the reference voxel
CReferenceWedgeInfo	Defines the information about the reference wedge
CSendBuffer	Buffer to be used for send communications
CSkdBox	Defines a box
CSkdGlobalCellDistance	Allows to define a distance between a point and a cell
CSkdNode	The SkdPatchInfo class defines a node of the skd-tree
CSkdPatchInfo	Allows to store patch information needed for the construction and the utilization of a skd-tree
CSparseMatrix	Sparse matrix
CSplitSystemMatrixAssembler	Base class for defining assemblers for split system solvers
CSplitSystemSolver	Allows to solve a split linear system
CSplitSystemSparseMatrixAssembler	Allows to assembly a split system solver from a sparse matrix
CSTLBase	Base class for the STL writer and the STL reader
►CSTLReader	Class for reading ASCII and binary STL files
CInspectionInfo	Structure holding inspection information
CSTLWriter	Class for writing ASCII and binary STL files
CSurfaceKernel	Interface for defining surface patches
CSurfaceSkdTree	The SurfaceSkdTree implements a Bounding Volume Hierarchy tree for surface patches
CSurfUnstructured	Defines an unstructured surface triangulation
►CSystemMatrixAssembler	Interface for defining system matrix assemblers
CAssemblyOptions
CSystemMatrixOrdering	Interface for defining classes that allows to reorder the system matrix
CSystemSolver	Methods for building and solving large linear systems
CSystemSparseMatrixAssembler	Defines an assembler for building the system matrix form a sparse matrix
CTreeConstants	Global constants associated to a PABLO tree
►CVertex	Defines the vertexs
CLess
CVolCartesian	The VolCartesian defines a Cartesian patch
►CVolOctree	The VolOctree defines a Octree patch
COctantInfo
COctantInfoHasher
CVolOctreeMapper	The VolOctreeMapper is the class to map two meshes of class VolOctree
CVolumeKernel	Interface for defining volume patches
CVolumeMapper	The VolumeMapper is the class to map two meshes
CVolumeSkdTree	The VolumeSkdTree implements a Bounding Volume Hierarchy tree for volume patches
CVolUnstructured	Defines a dummy unstructured volume patch
CVTK	A base class for VTK input output
CVTKBaseContainer	An interface class to all containers that are batively supported by VTK
CVTKBaseStreamer	The base class to be used to derive VTK streamers form
CVTKField	VTKField handles geometry and data field information for the VTK format
CVTKNativeStreamer	In VTKNativeStreamer all instances of classes derived from VTKBaseConatiner are stored. Right now only std::vector is supported
CVTKRectilinearGrid	VTK input output for Rectilinear Meshes
CVTKTypes	VTK data types handling
►CVTKUnstructuredGrid	VTK input output for Unstructured Meshes
CHomogeneousInfoStreamer
CVTKVectorContainer	Implementation of VTKBaseContainer in order to support natively std::vector in VTK
CAMGSplitSystemSolver	The class AMGSplitSystemSolver is derived form SplitSystemSolver and it allows to solve the linear system using PETSc GAMG preconditioner. Only non-block matrices can be solved using GAMG
CAMGSystemSolver	The class AMGSystemSolver is derived form SystemSolver and it allows to solve the linear system using PETSc GAMG preconditioner. Only non-block matrices can be solved using GAMG
CCellHalfEdge	Defines cell half-edges
CData
CFieldStreamer
CInfoBitpodPP	Database of essential information absorbed from the custom arguments
CTesselation	Allows to tessalete polygons and polyhedrons
CVTKUnstructuredGridStreamer	Streamer for VTKUnstructuredGrid if the grid is made of homogeneous types