Namespace List

Here is a list of all namespaces with brief descriptions:

[detail level 12345]

►NCGAL
NindexedCellOps	Operations for indexed cell types
NindexedVertexOps	Operations for indexed vertex types
►CindexedCell	An indexed form of CGAL::Triangulation_cell_base_3<K> used to keep track of the Delaunay cells (tets) in the tessellation
CRebind_TDS
►CindexedFace	An indexed form of CGAL::Triangulation_face_base_2<K> used to keep track of the vertices in the triangulation
CRebind_TDS
►CindexedVertex	An indexed form of CGAL::Triangulation_vertex_base_3<K> used to keep track of the Delaunay vertices in the tessellation
CRebind_TDS
Nfac	Calculate the second temporal derivative
Nfam	Calculate the matrix for the second temporal derivative
►NFoam	Namespace for OpenFOAM
►NaspectRatioModels
CconstantAspectRatio	Constant value aspect ratio model
CTomiyamaAspectRatio	Aspect ratio model of Tomiyama
CVakhrushevEfremov	Aspect ratio model of Vakhrushev and Efremov
CWellek	Aspect ratio model of Wellek et al
►NAveragingMethods
CBasic	Basic lagrangian averaging procedure
CDual	Dual-mesh lagrangian averaging procedure
CMoment	Moment lagrangian averaging procedure
►NbinModels
CsingleDirectionUniformBin	Calculates binned data in a specified direction
CuniformBin	Calculates binned data in multiple segments according to a specified Cartesian or cylindrical coordinate system
►NBitOps	Various bit-wise operations and adaptor methods for containers that are somewhat similar to bitSet (eg, boolList, labelHashSet)
CbitInfo	An (unsigned) integral type adapter, for output of bit values
NBitSetOps	Factory and other methods for bitSet. Adaptor methods for other containers that are somewhat similar to bitSet (eg, boolList, labelHashSet)
►NblendingMethods
Chyperbolic
Clinear
CnoBlending
►NblockEdges	A namespace for various blockEdge types
CarcEdge	A blockEdge defined as an arc of a circle
Cbezier	Nth order bezier curve edge. Only interior control points should be specified. The outer points are taken as start and end. Note that the calculation of each point takes 0(N^2) time, where N is the number of control points. This edge type shouldn't therefore be used for finely discretised line data; polyLine or similar will be more appropriate for such cases. Beziers are useful for simple curved shapes such as aerofoils, or when you want an edge to match a specific direction at one, or both, or its endpoints. In comparison with BSplines, the grading of bezier edges should be smoother, and the code is much simpler. The algorithmic order is worse, however, and the edge will not follow the control points as closely
CBSplineEdge	A blockEdge interface for B-splines
ClineEdge	A straight edge between the start point and the end point
CpolyLineEdge	A blockEdge defined in terms of a series of straight line segments
CprojectCurveEdge	Defines the edge from the projection onto a surface (single surface) or intersection of two surfaces
CprojectEdge	Defines the edge from the projection onto a surface (single surface) or intersection of two surfaces
CsplineEdge	A blockEdge interface for Catmull-Rom splines
►NblockFaces
CprojectFace	Projects the given set of face points onto the selected surface of the geometry provided as a searchableSurfaces object
NblockMeshTools	Tools for parsing label(List) with dictionary lookup
►Nblocks
CnamedBlock	Gives name to a block
►NblockVertices
CnamedVertex	Gives name to a vertex
CpointVertex
CprojectVertex	Projects the vertex onto the selected surfacees of the geometry provided as a searchableSurfaces object
Nbounds	Namespace for bounding specifications. At the moment, mostly for tables
►Nccm
Cbase	Base functionality common to reader and writer classes
CfieldEntry	A ccm field entry with short name, name, maxId and type
CfieldTable	A list of the available fields
CinterfaceDefinitions	A list of available interface definitions
CinterfaceEntry	A STARCCM interface definition is a pair of boundary ids
CnamesList	A linked-list that is searchable by the 'name()' of the items
►Creader	Reads CCM files as written by PROSTAR/STARCCM
Coptions
CsolutionEntry	A ccm solution entry with name, iteration and time
Cwriter	Write OpenFOAM meshes and/or results to CCM format
►NcellCellStencils
CcellVolumeWeight	Volume-weighted interpolation stencil
CinverseDistance	Inverse-distance-weighted interpolation stencil
CleastSquares	Least-squares-weighted interpolation stencil
CtrackingInverseDistance	Inverse-distance-weighted interpolation stencil
►NchemistryReductionMethods
CDAC	The Dynamic Adaptive Chemistry (DAC) method [1] simplifies the chemistry using the matrix rAB defined by (DRGEP algorithm [2])
CDRG	Implementation of the Directed Relation Graph (DRG) method
CDRGEP	The DRGEP algorithm [1] is based on
CEFA
Cnone
CPFA	Path flux analysis
►NchemistryTabulationMethods
CISAT	Implementation of the ISAT (In-situ adaptive tabulation), for chemistry calculation
Cnone
NcolourTools	Utility methods for colours and colour spaces
►NcombustionModels
Cdiffusion	Simple diffusion-based combustion model based on the principle mixed is burnt. Additional parameter C is used to distribute the heat release rate in time
CdiffusionMulticomponent	Diffusion based turbulent combustion model for multicomponent species
CEDC	Eddy Dissipation Concept (EDC) turbulent combustion model
CeddyDissipationDiffusionModel	Eddy dissipation model based on the principle of mixed is burnt
CeddyDissipationModelBase	Standard Eddy Dissipation Model based on the assumption that the reaction rates are controlled by the turbulece time length scale. The chemical reaction rate is governed by the large-eddy mixing scale, (ie k/epsilon). Combustion takes place whenever the turbulence is present
CFSD	Flame Surface Dennsity (FDS) combustion model
CinfinitelyFastChemistry	Simple infinitely fast chemistry combustion model based on the principle mixed is burnt. Additional parameter C is used to distribute the heat release rate.in time
Claminar	Laminar combustion model
CnoCombustion	Dummy combustion model for 'no combustion'
CPaSR	Partially stirred reactor turbulent combustion model
CsingleStepCombustion	Base class for combustion models using singleStepReactingMixture
CzoneCombustion	Zone-filtered combustion model
►NcompressibilityModels	Namespace for compressibility models
CChung	Chung compressibility model
Clinear	Linear compressibility model
CWallis	Wallis compressibility model
►Ncompressible
►NRASModels
CalphatFilmWallFunctionFvPatchScalarField	This boundary condition provides a turbulent thermal diffusivity condition when using wall functions, for use with surface film models. This condition varies from the standard wall function by taking into account any mass released from the film model
CnutkFilmWallFunctionFvPatchScalarField	This boundary condition provides a turbulent viscosity condition when using wall functions, based on turbulence kinetic energy, for use with surface film models
CPDRkEpsilon	Standard k-epsilon turbulence model with additional source terms corresponding to PDR basic drag model (basic.H)
CalphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField	A simple alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField with a fixed volumetric phase-change mass flux
CalphatJayatillekeWallFunctionFvPatchScalarField	This boundary condition provides a thermal wall function for turbulent thermal diffusivity (usuallyalphat) based on the Jayatilleke model
CalphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField	This boundary condition provides a thermal wall function for turbulent thermal diffusivity (usuallyalphat) based on the Jayatilleke model for the Eulerian multiphase solvers
CalphatPhaseChangeWallFunctionFvPatchScalarField	Abstract base-class for all alphatWallFunctions supporting phase-change
CalphatWallBoilingWallFunctionFvPatchScalarField	A thermal wall function for simulation of boiling wall
CalphatWallFunctionFvPatchScalarField	This boundary condition provides a turbulent thermal diffusivity condition when using wall functions
CconvectiveHeatTransferFvPatchScalarField	This boundary condition provides a convective heat transfer coefficient condition
CthermalBaffle1DFvPatchScalarField	This BC solves a steady 1D thermal baffle
CthermalBaffleFvPatchScalarField	This boundary condition provides a coupled temperature condition between multiple mesh regions
CthermalShellFvPatchScalarField	This boundary condition provides a coupled temperature condition between a primary region (3D mesh) and a thermal shell model (2D mesh)
CturbulentTemperatureCoupledBaffleMixedFvPatchScalarField	Mixed boundary condition for temperature, to be used for heat-transfer on back-to-back baffles. Optional thin thermal layer resistances can be specified through thicknessLayers and kappaLayers entries
CturbulentTemperatureRadCoupledMixedFvPatchScalarField	Mixed boundary condition for temperature and radiation heat transfer to be used for in multiregion cases. Optional thin thermal layer resistances can be specified through thicknessLayers and kappaLayers entries
CturbulentTemperatureTwoPhaseRadCoupledMixedFvPatchScalarField	Mixed boundary condition for temperature and radiation heat transfer to be used for in multiregion cases with two phase Euler system
►Nconstant	Different types of constants
Natomic	Atomic constants
Nelectromagnetic	Electromagnetic constants
Nmathematical	Mathematical constants
NphysicoChemical	Physico-chemical constants
Nstandard	Standard values
Nthermodynamic	Thermodynamic scalar constants
Nuniversal	Universal constants
►NcoordinateRotations	Namespace for coordinate system rotations
Caxes	A coordinateRotation specified using global axes
CaxisAngle	A coordinateRotation specified by a rotation axis and a rotation angle about that axis
Ccylindrical	A special purpose coordinateRotation that is generally for use in combination with a cylindricalCS when only the orientation of the local Z-axis is relevant
Ceuler	A coordinateRotation defined in the z-x-z (intrinsic) Euler convention
Cidentity	An identity coordinateRotation
Cspecified	An user-specified coordinateRotation, primarily to be used internally within coding when the rotation matrix is already known but needs to be wrapped as a coordinateRotation for use in a coordinate system
Cstarcd	A coordinateRotation defined by the STAR-CD convention
►NcoordSetWriters
CcsvWriter	Write coordSet(s) in csv format
CensightWriter
CgltfWriter	A coordSet(s) writer in glTF v2 format, which is particularly useful for writing track data
CgnuplotWriter	A coordSet(s) writer in gnuplot format
CnastranWriter	Write coordSet(s) as Nastran plot lines. Does not do field data
CnullWriter	A coordSet(s) writer with suppressed output
CrawWriter	A coordSet(s) in raw format
CvtkWriter
CxmgraceWriter	Write coordSet(s) in xmgrace format
►NcoordSystem	Namespace for coordinate systems
Ccartesian	A Cartesian coordinate system
Ccylindrical	A cylindrical coordinate system (r-theta-z). The coordinate system angle theta is always in radians
Cindirect	A coordinate system forward to a global coordinate system that is normally provided by the constant/coordinateSystems file
►NCorrectionLimitingMethods
Cabsolute	Correction limiting method based on the absolute particle velocity
CnoCorrectionLimiting	Place holder for the 'none' option
Crelative	Correction limiting method based on the relative particle velocity
►Ncut
CappendOp
CareaIntegrateOp
CareaOp
►ClistOp
Cresult	Result class
CnoOp
CopAddResult	Trait to determine the result of the addition of two operations
CopAddResult< noOp, noOp >
CopAddResult< noOp, Op >
CopAddResult< Op, noOp >
CopAddResult< Op, Op >
CuniformOp
CvolumeIntegrateOp
CvolumeOp
►NDampingModels
CNoDamping	Place holder for the 'none' option
CRelaxation	Relaxation collisional damping model
Ndebug	Namespace for handling debugging switches
►NdecompositionConstraints
Cgeometric	Keep faces together based on geometric considerations from a list of topoSetFaceSource. The faces selected (inside) of each source are to be kept together during the decomposition
CpreserveBaffles	Detects baffles and keeps owner and neighbour on same processor
CpreserveFaceZones	Constraint to keep/move owner and neighbour of faceZone onto same processor
CpreservePatches	Constraint to keep owner and neighbour of (cyclic) patch on same processor
CrefinementHistory	Constraint to keep all cells originating from refining the same cell onto the same processor. Reads polyMesh/refinementHistory
CsingleProcessorFaceSets	Constraint to keep all cells connected to face or point of faceSet on a single processor
NDelaunayMeshTools	Collection of functions for operating on a Delaunay mesh
►NDetail	Implementation details for various OpenFOAM classes
►NListPolicy	Additional compile-time controls of List behaviour
Cno_linebreak
Cno_linebreak< keyType >	Suppress line-breaks for keyType
Cno_linebreak< word >	Suppress line-breaks for word
Cno_linebreak< wordRe >	Suppress line-breaks for wordRe
Cshort_length	Number of items before requiring line-breaks in the list output
CHashTablePair	Internal storage type for HashTable entries
CHashTableSingle	Internal storage type for HashSet entries
CIListStreamAllocator	An stream/stream-buffer input allocator with List storage
CisPointerLike	Pointer-like behaviour
CisPointerLike< autoPtr< T > >	Pointer-like behaviour for autoPtr
CisPointerLike< std::unique_ptr< T > >	Pointer-like behaviour for std::unique_ptr
CMeshedSurfaceIOAllocator	A helper class for storing points and faces with IO capabilities
COCountStreamAllocator	An stream/stream-buffer allocator for counting
COListStreamAllocator	An stream/stream-buffer output allocator with DynamicList-like storage
COSHA1streamAllocator	Allocator for an osha1stream
CPackedListCore	Template-invariant parts for PackedList
CparcelSelection	Selection of parcels based on their objectRegistry entries. Normally accessed via a dictionary entry
CPtrListDetail	A rudimentary list of pointers used for PtrList, UPtrList, etc. This class is considered implementation detail and should not normally be used other than by OpenFOAM container classes
CSTLAsciiParse	Internal class used when parsing STL ASCII format
CSTLAsciiParseManual	A lexer for parsing STL ASCII files
CStringStreamAllocator	Allocator for variants of a std stringstream
CUIListStreamAllocator	An stream/stream-buffer input allocator for a externally allocated list
CUOListStreamAllocator	An stream/stream-buffer allocator for external buffers
CzoneSubSet
►NdiameterModels
►NbinaryBreakupModels
CLehrMilliesMewes	Model of Lehr et al. (2002). The breakup rate is calculated by
CLuoSvendsen	Model of Luo and Svendsen (1996). The breakup rate is calculated by
CpowerLawUniformBinary	Powerlaw kernel with a uniform daughter size distribution. Used for verification and validation of the binary breakup formulation implemented in the populationBalanceModel class
►NbreakupModels
Cexponential	Exponential kernel. Used for verification and validation of the breakup formulation implemented in the populationBalanceModel class
CLaakkonenAlopaeusAittamaa	Model of Laakkonen et al. (2006). The total breakup rate is calculated by
CpowerLaw	Powerlaw kernel. Used for verification and validation of the breakup formulation implemented in the populationBalanceModel class
►NcoalescenceModels
CconstantCoalescence	Constant coalescence kernel. Used for verification and validation of the coalescence formulation implemented in the populationBalanceModel class
CCoulaloglouTavlaridesCoalescence	Model of Coulaloglou and Tavlarides (1977). The coalescence rate is calculated by
Chydrodynamic	Hydrodynamic kernel. Used for verification and validation of the coalescence formulation implemented in the populationBalanceModel class
CLehrMilliesMewesCoalescence	Model of Lehr et al. (2002). The coalescence rate is calculated by
CLuo	Model of Luo (1993). The coalescence rate is calculated by
CPrinceBlanch	Model of Prince and Blanch (1990). The coalescence rate is calculated by
►NdaughterSizeDistributionModels
CLaakkonenAlopaeusAittamaaDsd	Daughter size distribution model used by Laakkonen et al. (2006). Note that it must be multiplied by the number of daughter particles (2). Also, the coefficient C4 needs to be set to the value of 2 as to ensure number and mass conservation following Kumar and Ramkrishna (1996). Also the internal coordinate was changed to particle volume, which gives
CuniformBinary	Uniform binary daughter size distribution. Used for verification and validation of the breakup formulation implemented in the populationBalanceModel class
►NdriftModels
CconstantDrift	Constant drift rate within all classes. Used for verification and validation of the drift formulation implemented in the populationBalanceModel class. Rate is calculated from fvOptions mass source
CdensityChangeDrift	Drift rate induced by changes in density
CphaseChange	Drift induced by interfacial phase change. By default phase change mass flux is distributed between sizeGroups of each velocityGroup with phase change based on interfacial area of each size group
►NIATEsources
Cdummy
CphaseChange	Phase-change IATE source
CrandomCoalescence	Random coalescence IATE source as defined in paper:
CturbulentBreakUp	Turbulence-induced break-up IATE source as defined in paper:
CwakeEntrainmentCoalescence	Bubble coalescence due to wake entrainment IATE source as defined in paper:
CwallBoiling	Wall-boiling IATE source
►NnucleationModels
CconstantNucleation	Constant nucleation rate within all classes. Used for verification and validation of the nucleation formulation implemented in the populationBalanceModel class. Rate is calculated from fvOptions mass source
CwallBoiling	Wall-boiling model which requires a velocityGroup (i.e. phase) to be specified in which the nucleation occurs. This setting must be consistent with the specifications in the alphatWallBoilingWallFunction. If the departure-diameter lies outside the diameter-range given by the sizeGroups of the corresponding velocityGroup, the solver will give a warning and the nucleation rate will be set to zero
►CbinaryBreakupModel	Base class for binary breakup models which give the breakup rate between a sizeGroup pair directly, without an explicit expression for the daughter size distribution
CiNew	Class used for the read-construction of
►CbreakupModel	Base class for breakup models which give a total breakup rate and a separate daughter size distribution function
CiNew	Class used for the read-construction of
►CcoalescenceModel	Base class for coalescence models
CiNew	Class used for the read-construction of
Cconstant	Constant dispersed-phase particle diameter model
CdaughterSizeDistributionModel	Base class for daughter size distribution models
►CdriftModel	Base class for drift models
CiNew	Class used for the read-construction of
CIATE	IATE (Interfacial Area Transport Equation) bubble diameter model
►CIATEsource	IATE (Interfacial Area Transport Equation) bubble diameter model run-time selectable sources
CiNew	Class used for the read-construction of
Cisothermal	Isothermal dispersed-phase particle diameter model
ClinearTsub
►CnucleationModel	Base class for nucleation models
CiNew	Class used for the read-construction of
►CpopulationBalanceModel	Class that solves the univariate population balance equation by means of a class method (also called sectional or discrete method). The internal coordinate is set to the particle volume, so the equation is based on a transport equation of the volume-based number density function. The discretization is done using the fixed pivot technique of Kumar and Ramkrishna (1996). The source terms are written in a way that particle number and mass are preserved. Coalescence (aggregation), breakup, drift (growth and surface loss) as well as nucleation are supported. For the discrete breakup term two recipes are available, depending on the model choice. For models which state a total breakup rate and a separate daughter size distribution function, the formulation of Kumar and Ramkrishna (1996) is applied which is applicable for binary and multiple breakup events. The second formulation is given by Liao et al. (2018). It is useful for binary breakup models which give the breakup rate between a sizeGroup pair directly, without an explicit expression for the daughter size distribution. The drift term is implemented using a finite difference upwind scheme. Although it is diffusive, it ensures a stable and number-conservative solution
CiNew	Return a pointer to a new populationBalanceModel object created on
►CsizeGroup	This class represents a single sizeGroup belonging to a velocityGroup. The main property of a sizeGroup is its representative diameter. The corresponding volScalarField f<number>.<phaseName>.<populationBalanceName> gives the volume fraction of the sizeGroup such that all sizeGroup fractions over a velocityGroup must sum to unity. The field is either read from the startTime directory if present or constructed from a reference field called f.<phaseName>.<populationBalanceName> where the boundary condition types must be specified. All field and boundary condition values are reset to match the "value" given in the sizeGroup subdictionary
CiNew	Return a pointer to a new sizeGroup created on freestore
CvelocityGroup	This diameterModel is intended for use with a populationBalanceModel in order to simulate polydispersed bubbly or particulate flows. It can hold any number of sizeGroups from which the Sauter mean diameter is calculated. It can also be used as a diameterModel without a populationBalance and would then behave like a constantDiameter model. In this case, some arbitrary name must be entered for the populationBalance keyword
►NdistributionModels	A namespace for various probability distribution model implementations
Cbinned	Particle-size distribution model wherein random samples are drawn from a given discrete set of (bin, probability) pairs, where in terms of its meaning, bins correspond to particle sizes and probabilities correspond to (relative) probability of occurrences
Cexponential	Particle-size distribution model wherein random samples are drawn from the doubly-truncated exponential probability density function:
CfixedValue	Particle-size distribution model wherein samples are given fixed values
Cgeneral	Particle-size distribution model wherein random samples are drawn from a given arbitrary probability density function or cumulative distribution function. Input distributions are specified as pairs of (size, probability) (i.e. (point, value) )
CmassRosinRammler	Particle-size distribution model wherein random samples are drawn from the two-parameter Rosin-Rammler (Weibull) probability density function corrected to take into account varying number of particles per parcels for fixed-mass parcels
CmultiNormal	Particle-size distribution model wherein random samples are drawn from a mixture of a finite set of doubly-truncated univariate normal probability density functions:
Cnormal	Particle-size distribution model wherein random samples are drawn from the doubly-truncated univariate normal probability density function:
CRosinRammler	Particle-size distribution model wherein random samples are drawn from the doubly-truncated two-parameter Rosin-Rammler (Weibull) probability density function:
Cuniform	Particle-size distribution model wherein random samples are drawn from the doubly-truncated uniform probability density function:
►NDMDModels	A namespace for various dynamic mode decomposition (DMD) model implementations
CSTDMD	Streaming Total Dynamic Mode Decomposition (i.e. STDMD) is a variant of dynamic mode decomposition
►NdragModels
CAttouFerschneider	Attou and Ferschneider's Drag model for film flow through packed beds. The implementation follows the description of Gunjal and Ranade, who, in the reference below, formulate the model in more convenient terms
CBeetstra	Drag model of Beetstra et al. for monodisperse gas-particle flows obtained with direct numerical simulations with the Lattice-Boltzmann method and accounting for the effect of particle ensembles
CErgun	Reference:
CGibilaro	Reference:
CGidaspowErgunWenYu	Gidaspow, Ergun, Wen and Yu drag model
CGidaspowSchillerNaumann	Gidaspow, Schiller and Naumann drag model
CIshiiZuber	Ishii and Zuber (1979) drag model for dense dispersed bubbly flows
CLain	Drag model of Lain et al
CSchillerNaumann	Schiller and Naumann drag model for dispersed bubbly flows
Csegregated	Segregated drag model for use in regions with no obvious dispersed phase
CSyamlalOBrien	Reference:
CTenneti	Drag model of Tenneti et al. for monodisperse gas-particle flows obtained with particle-resolved direct numerical simulations and accounting for the effect of particle ensembles
CTomiyamaAnalytic	Analytical drag model of Tomiyama et al
CTomiyamaCorrelated	Correlation of Tomiyama et al
CTomiyamaKataokaZunSakaguchi	Drag model for gas-liquid system of Tomiyama et al
CWenYu	Wen and Yu drag model
NedgeMeshTools	Collection of static functions related to edgeMesh features
NElliptic
►NenergyScalingFunctions
CdoubleSigmoid
CnoScaling
Cshifted
CshiftedForce
Csigmoid
►Nensight
CFileName	Specification of a valid Ensight file-name
CVarName	Specification of a valid Ensight variable-name
►NensightOutput	A collection of functions for writing ensight file content
NDetail	Implementation details and output backends that would not normally be called directly by a user
CwriterCaching	State information for writers with collated times
►Nexpressions
►NexprDriverOps	Miscellaneous operations used in combination with the expressions::exprDriver
CswakModuloOp	A modulo operation similar to that used in swak4foam
NexprString	A variant of Foam::string with expansion of dictionary variables into a comma-separated form
►NfieldExpr	Namespace for primitive field expressions parsing and evaluation
CparseDriver	Driver for generic primitive field expressions
Cparser	Lemon parser interface for field expressions grammar
Cscanner	Ragel lexer/scanner interface for patch expressions
►NpatchExpr	Namespace for patch expressions parsing and evaluation
CparseDriver	Driver for patch expressions
Cparser	Lemon parser interface for patch expressions grammar
Cscanner	Ragel lexer/scanner interface for patch expressions
►NvolumeExpr	Namespace for volume field expressions parsing and evaluation
CparseDriver	Driver for volume, surface, point field expressions
Cparser	Lemon parser interface for volume expressions grammar
Cscanner	Ragel lexer/scanner interface for volume expressions
CboolAndOp	Logical 'and', possibly with scalars as (false, true) values
CboolNotOp	Inverse of boolOp()
CboolNotOp< bool >	Inverse of boolOp, no conversion required for bool
CboolOp	Convert [0-1] values (usually scalars) as false/true
CboolOp< bool >	Convert to bool, pass-through for bool
CboolOrOp	Logical 'or', possibly with scalars as (false, true) values
CboolXorOp	Logical 'xor', possibly with scalars as (false, true) values
CexprDriver	Base driver for parsing (field) values
CexprResult	A polymorphic field/result from evaluating an expression
CexprResultDelayed	An exprResult with an additional delay before evaluation
►CexprResultGlobals	A globally available registry of expression results. These are currently registered on Time (may change in the future)
CTable	The table of results
CexprResultStack	A stack of polymorphic fields. Can be used to build a list of results one at a time
CexprResultStored	An exprResult with persistence
CexprResultStoredStack	An exprResultStack with persistence
CexprString
CfvExprDriver	Base driver for parsing value expressions associated with an fvMesh
CfvExprDriverWriter	Registered input/output for an expressions::fvExprDriver
CpatchExprFieldBase	Base class for managing patches with expressions. The expected input supports value, gradient and mixed conditions
CscanToken	A low-level input/scan token content. No defined constructors/destructors. All memory management is manual!
►NexprTools	Helper methods for creating expressions
CboolEntry	Expression representation of a bool : (false/true)
CdimensionedScalarEntry	Create an expression string from a dimensionedScalar as its value
CdimensionedSphericalTensorEntry	Create an expression string from a dimensionedSphericalTensor as its value
CdimensionedSymmTensorEntry	Create an expression string from a dimensionedSymmTensor as its value
CdimensionedTensorEntry	Create an expression string from a dimensionedTensor as its value
CdimensionedVectorEntry	Create an expression string from a dimensionedVector as its value
CexpressionEntry	Convert dictionary entry to a stringified expression
CsphericalTensorEntry	Create an expression string from a sphericalTensor
CstringEntry	Creates an expression from a string (removing surrounding quotes)
CsymmTensorEntry	Create an expression string from a symmTensor
CtensorEntry	Create an expression string from a tensor
CvectorEntry	Create an expression string from a vector
►NextrudeModels
CcyclicSector	Extrudes a sector
ClinearDirection	Extrudes by transforming points in a specified direction by the given distance
ClinearNormal	Extrudes by transforming points normal to the surface by a given distance
ClinearRadial	Extrudes by transforming radially from the surface
CoffsetSurface	Extrudes by interpolating points from one surface to the other. Surfaces have to be topologically identical i.e. one has to be an offsetted version of the other
Cplane	Extrudes by transforming points normal to the surface by 1 layer over a given distance
Cpolyline	Extrudes by transforming points along a polyline provided as a series of points and edge segments. Supports all blockMesh edge types, e.g. line, arc, spline. The surface points are rotated to follow the path
Cradial	Extrudes radially according to the Function1 description
Csector	Extrudes by rotating a surface around an axis
CsigmaRadial	Extrudes into sphere with grading according to pressure (atmospherics)
Cwedge	Extrudes by rotating a surface symmetrically around axis by 1 layer
►Nfa	Namespace for finite-area
CbackwardFaDdtScheme	Second-order backward-differencing implicit ddt using the current and two previous time-step values
CboundedBackwardFaDdtScheme
CcontactHeatFluxSource	Applies contact heat flux between specified faMesh and fvMesh within a specified region for compressible flows
CconvectionScheme	Abstract base class for finite area calculus convection schemes
CcorrectedLnGrad	Simple central-difference lnGrad scheme with non-orthogonal correction
CdivScheme	Abstract base class for finite area calculus div schemes
CedgeLimitedGrad	EdgeLimitedGrad gradient scheme applied to a runTime selected base gradient scheme
CEulerFaD2dt2Scheme	First-order Euler implicit d2dt2 using the current and two previous time-step values
CEulerFaDdtScheme
CexternalFileSource	Applies sources on a specified field within a specified region by using an external table file for compressible flows
CexternalHeatFluxSource	Applies a heat flux condition for a specified faMesh region to temperature on an external wall for compressible flows in one of three modes:
CfaceLimitedGrad	FaceLimitedGrad gradient scheme applied to a runTime selected base gradient scheme
CfaceSetOption	Intermediate abstract class for handling face-set options for the derived faOptions
CfaD2dt2Scheme	Abstract base class for d2dt2 schemes
CfaDdtScheme
CfourthLnGrad	Fourth-order snGrad scheme with non-orthogonal correction
CgaussConvectionScheme	Basic second-order convection using face-gradients and Gauss' theorem
CgaussDivScheme	Basic second-order div using face-gradients and Gauss' theorem
CgaussGrad	Basic second-order gradient scheme using face-interpolation and Gauss' theorem
CgaussLaplacianScheme	Basic second-order laplacian using face-gradients and Gauss' theorem
CgradScheme	Abstract base class for finite area calculus gradient schemes
CjouleHeatingSource	Evolves an electrical potential equation
ClaplacianScheme	Abstract base class for finite area calculus laplacian schemes
CleastSquaresFaGrad	Second-order gradient scheme using least-squares
ClimitedLnGrad	Central-difference lnGrad scheme with limited non-orthogonal correction
ClimitVelocity	Limits the maximum velocity magnitude to the specified max value
ClnGradScheme	Abstract base class for lnGrad schemes
►Coption	Base abstract class for handling finite area options (i.e. faOption)
CiNew
CoptionList	List of finite volume options
Coptions	Finite-area options
CsteadyStateFaDdtScheme
Nfac
►NfaceSelections
CfaceZoneSelection	Select faces from faceZone
CsearchableSurfaceSelection	Selects all (internal or coupled) faces intersecting the searchableSurface
Nfam
NFieldOps	Various utility functions to work on Fields
NfieldTypes	Collection of common field types
►NfileFormats
►CABAQUSCore	Core routines used when reading/writing ABAQUS files
CreadHelper	Raw reader structure
CABAQUSsurfaceFormat	Abaqus surface reader
CABAQUSsurfaceFormatCore	Internal class used by the ABAQUSsurfaceFormat
CAC3DsurfaceFormat	Read/write AC3D format
CAC3DsurfaceFormatCore	Internal class used by the AC3DsurfaceFormat
CedgeMeshFormat	Provide a means of reading/writing the single-file OpenFOAM edge format
CedgeMeshFormatsCore	A collection of helper functions for reading/writing edge formats
CextendedEdgeMeshFormat	Provide a means of reading/writing the single-file OpenFOAM extendedEdgeMesh format
CextendedFeatureEdgeMeshFormat	Provide a means of reading extendedFeatureEdgeMesh as featureEdgeMesh
CFIRECore	Core routines used when reading/writing AVL/FIRE files
CFIREMeshReader	Read AVL/FIRE fpma, fpmb files
CFIREMeshWriter	Writes polyMesh in AVL/FIRE polyhedra format (fpma, fpmb)
CFLMAsurfaceFormat	Provide a means of writing AVL/FIRE FLMA format
CFLMAZsurfaceFormat
CGTSsurfaceFormat	Read/write GTS format
CNASCore	Core routines used when reading/writing NASTRAN files
CNASedgeFormat	Nastran edge reader
CNASsurfaceFormat	Nastran surface reader/writer
COBJedgeFormat	Provide a means of reading/writing Alias/Wavefront OBJ format
COBJsurfaceFormat	Read/write Alias/Wavefront OBJ format
COFFsurfaceFormat	Read/write Geomview OFF polyList format
CSMESHsurfaceFormat	Write tetgen SMESH format (Tetgen http://tetgen.berlios.de)
CSTARCDCore	Core routines used when reading/writing PROSTAR vrt/cel/bnd files
CSTARCDedgeFormat	Read/write the lines from PROSTAR vrt/cel files
CSTARCDMeshReader	Read PROSTAR vrt/cel/bnd files. The protected data in meshReader are filled
CSTARCDMeshWriter	Writes polyMesh in PROSTAR (v4) bnd/cel/vrt format
CSTARCDsurfaceFormat	Read/write the surface shells from PROSTAR vrt/cel files
CSTARCDsurfaceFormatCore	Internal class used by the STARCDsurfaceFormat
CSTLCore	Core routines used when reading/writing STL files
CSTLReader	Internal class used by the STLsurfaceFormat and triSurface
CSTLsurfaceFormat	Provide a means of reading/writing STL files (ASCII and BINARY)
CsurfaceFormatsCore	A collection of helper functions for reading/writing surface formats
CTRIReader	TRI (triangle) file reader
CTRIsurfaceFormat	Provide a means of reading/writing .tri format
CVTKedgeFormat	Provide a means of writing VTK legacy format
CVTKsurfaceFormat	Read/write VTK legacy format (ASCII) for surfaces
CVTKsurfaceFormatCore	Internal class used by the VTKsurfaceFormat Format is LEGACY_ASCII
CVTPsurfaceFormat	Write surfaces in VTP (xml) format. The default format is INLINE_BASE64
CVTPsurfaceFormatCore	Internal class used by the VTPsurfaceFormat. The default format is INLINE_BASE64
CX3DsurfaceFormat	Provide a means of writing x3d format
CX3DsurfaceFormatCore	Internal class used by the X3DsurfaceFormat
►NfileOperations	Namespace for implementations of a fileOperation
CcollatedFileOperation	Version of masterUncollatedFileOperation that collates regIOobjects into a container in the processors/ subdirectory
CcollatedFileOperationInitialise
CfileOperationInitialise
ChostCollatedFileOperation	Version of collatedFileOperation with multiple read/write ranks
ChostCollatedFileOperationInitialise
►CmasterUncollatedFileOperation	FileOperations that performs all file operations on the master processor. Requires the calls to be parallel synchronised!
CchModOp
CcpOp
CexistsOp
CfileOrNullOp
CfileSizeOp
ChighResLastModifiedOp
CisDirOp
CisFileOp
ClastModifiedOp
ClnOp
CmkDirOp
CmodeOp
CmvBakOp
CmvOp
CreadDirOp
CrmDirOp
CrmOp
CtypeOp
CmasterUncollatedFileOperationInitialise
CuncollatedFileOperation	FileOperation that assumes file operations are local
CunthreadedInitialise
►NFlatOutput	Various output adaptors, principally to output a list of items on a single line
CBareComma	Surround with '\0' and '\0' separate with ','
CBareSpace	Surround with '\0' and '\0' separate with ' '
CBraceComma	Surround with '{' and '}' separate with ','
CBraceSpace	Surround with '{' and '}' separate with ' '
CDecorators	List decorators with open, close and separator characters
COutputAdaptor	An output adaptor with a write method and an Ostream operator
CParenComma	Surround with '(' and ')' separate with ','
CParenSpace	Surround with '(' and ')' separate with ' '
CPointyComma	Surround with '<' and '>' separate with ','
CPointySpace	Surround with '<' and '>' separate with ' '
CSquareComma	Surround with '[' and ']' separate with ','
CSquareSpace	Surround with '[' and ']' separate with ' '
NfoamVersion	Namespace for OpenFOAM version information
NfoamyHexMeshChecks	Collection of checks for foamyHexMesh
►NFunction1Types
CCodedFunction1	Function1 with the code supplied by an on-the-fly compiled C++ expression
CConstant	Templated function that returns a constant value
CCosine	A templated cosine function, with support for offset etc
CCSV	Templated CSV function
CFunction1Expression	Function1 with values supplied by a parsed expression
CFunctionObjectTrigger	Returns a 0/1 value corresponding to function object trigger levels
CFunctionObjectValue	Returns a value retrieved from a function object result
ChalfCosineRamp	Half-cosine ramp function starting from 0 and increasing to 1 from start over the duration and remaining at 1 thereafter
CInputValueMapper	Function1 wrapper that maps the input value prior to it being used by another Function1
ClinearRamp	Linear ramp function starting from 0 and increasing linearly to 1 from start over the duration and remaining at 1 thereafter
CNone	Templated placeholder function that returns an error message if called
COneConstant	Templated function that returns the corresponding 1 (one)
CPolynomial
CquadraticRamp	Quadratic ramp function starting from 0 and increasing quadratically to 1 from start over the duration and remaining at 1 thereafter
CquarterCosineRamp	Quarter-cosine ramp function starting from 0 and increasing to 1 from start over the duration and remaining at 1 thereafter
CquarterSineRamp	Quarter-sine ramp function starting from 0 and increasing to 1 from start over the duration and remaining at 1 thereafter
Cramp	Ramp function base class for the set of scalar functions starting from 0 and increasing monotonically to 1 from start over the duration and remaining at 1 thereafter
CSample
CScale	Function1 which scales a given 'value' function by a scalar 'scale' function
CSine	A templated sine function, with support for offset etc
CSquare	A templated square-wave function with support for offset, etc
CstepFunction	A step function that is 0 before start changing to 1 for the duration and returning to 0 thereafter
CTable	Templated table container function
CTableBase	Base class for table with bounds handling, interpolation and integration
CTableFile	Templated table container function where data are read from file
CUniform	Templated function that returns a constant value
CZeroConstant	Templated function that returns the corresponding 0 (zero)
►NfunctionEntries	Namespace for containing a functionEntry
CcalcEntry	Uses dynamic compilation to provide calculating functionality for entering dictionary entries
CcodeStream	Dictionary entry that contains C++ OpenFOAM code that is compiled to generate the entry itself. So
CevalEntry	Uses expressions::fieldExprDriver to evaluate mathematical expressions with scalars, vectors etc
CifEntry	Conditional parsing of dictionary entries
CifeqEntry	Conditional parsing of dictionary entries
CincludeEntry	A dictionary directive for including a file, expects a single string to follow
CincludeEtcEntry	A dictionary directive for including a file found using the Foam::findEtcFile() mechanism
CincludeFuncEntry	Specify a functionObject dictionary file to include, expects the functionObject name to follow with option arguments (without quotes)
CinputMode	Specify the global input mode when reading further dictionaries, expects a single word to follow
CinputModeDefault	Temporarily change inputMode to protect for the following entry
CinputModeError	Temporarily change inputMode to error for the following entry
CinputModeMerge	Temporarily change inputMode to merge for the following entry
CinputModeOverwrite	Temporarily change inputMode to overwrite for the following entry
CinputModeWarn	Temporarily change inputMode to warn for the following entry
CmessageDirective	Expands string content and reports as a message on stderr
CremoveEntry	Remove a dictionary entry
CsincludeEntry
CsincludeEtcEntry
CwordDirective	Converts/expands string content to a word. This can be useful for composition of names
►NfunctionObjects	Function objects are OpenFOAM utilities to ease workflow configurations and enhance workflows by producing additional user-requested data both during runtime and postprocessing calculations, typically in the form of additional logging to the screen, or generating text, image and field files
►NfieldValues
CmultiFieldValue	Computes a selected operation between multiple function objects
CsurfaceFieldValue	A face regionType variant of the fieldValues function object
CvolFieldValue	Provides a 'volRegion' specialization of the fieldValue function object
►NrunTimeControls
CaverageCondition	Average run time condition - satisfied when average does not change by more than a given value
CequationInitialResidualCondition	Minimum or maximum initial residual run time condition
CequationMaxIterCondition	Maximum number of equation iterations run time condition
CmaxDurationCondition	Activated after a user-specified duration
CminMaxCondition
CminTimeStepCondition	Minimum time step condition
CnoneCondition
CrunTimeCondition	Base class for run time conditions
CrunTimeControl
Cabort	Watches for presence of the named trigger file in the case directory and signals a simulation stop (or other) event if found
Cadd	Sums a given list of (at least two or more) fields and outputs the result into a new field, where the fields possess the same sizes and dimensions:
Cage	Calculates and writes out the time taken for a particle to travel from an inlet to the location. Solves the following equation when incompressible:
CAMIWeights	Computes the min/max/average weights of arbitrary mesh interface (AMI) patches, and optionally reports to a text file or writes VTK surfaces of the sum of the weights and mask fields for arbitrarily coupled mesh interface (ACMI) patches
CBilgerMixtureFraction	Calculates the Bilger mixture-fraction field (i.e. \(f_{\mathrm{Bilger}}\)) based on the elemental composition of the mixture. Elements C, H, S and O are considered
CbinField	Calculates binned data, where specified patches are divided into segments according to various input bin characteristics, so that spatially-localised information can be output for each segment
CblendingFactor	Computes blending factor as an indicator about which of the schemes is active across the domain
CcloudInfo	Outputs Lagrangian cloud information to a file
CcodedFunctionObject	Provides a general interface to enable dynamic code compilation
CcolumnAverage	Computes the arithmetic average of given quantities along columns of cells in a given direction for structured-like layered meshes. It is, for example, useful for channel-like cases where spanwise average of a field is desired. However, the columnAverage function object does not operate on arbitrary unstructured meshes
Ccomfort	Calculates the thermal comfort quantities predicted mean vote (PMV), predicted percentage of dissatisfaction (PPD) and the draught rate (DR) based on DIN ISO EN 7730:2005
Ccomponents	Extracts the components of elements of a field and outputs the result into new fields, where the fields possess the same sizes and dimensions
CcontinuityError	Computes local, global and cumulative continuity errors for a flux field
CCourantNo	Computes the Courant number field for time-variant simulations
CCurle	Computes the acoustic pressure based on Curle's analogy
CdataCloud	This functionObject writes a cloud position and in ASCII
Cddt	Computes the Eulerian time derivative of an input volume field for time-variant simulations (not appropriate to steady-state simulations)
Cddt2	Computes the magnitude or magnitude squared of the Eulerian time derivative of an input volume field for time-variant simulations (not appropriate to steady-state simulations)
CderivedFields	Computes two predefined derived fields, i.e. rhoU, and pTotal, where the defined fields are hard-coded as follows:
CDESModelRegions	Computes an indicator field for detached eddy simulation (DES) turbulence calculations, where the values of the indicator mean:
Cdiv	Computes the divergence of an input field
CDMD	Computes a dynamic mode decomposition model on a specified field
CdsmcFields	This function object calculates and outputs the intensive fields:
CelectricPotential	Computes the steady-state equation of charge conservation to obtain the electric potential by strictly assuming a quasi-static electrostatic field for single-phase and multiphase applications
CenergySpectrum	Calculates the energy spectrum for a structured IJK mesh
CenergyTransport	Evolves a simplified energy transport equation for incompressible flows. It takes into account the inertia, conduction and convection terms plus a source
CensightWrite	Writes fields in ensight format
Censtrophy	Computes the enstrophy of an input volVectorField
CeulerianParticle
CexternalCoupled	Provides a simple file-based communication interface for explicit coupling with an external application, so that data is transferred to- and from OpenFOAM. The data exchange employs specialised boundary conditions to provide either one-way or two-way coupling models
CextractEulerianParticles	Generates particle size information from Eulerian calculations, e.g. VoF
CfieldAverage	Computes ensemble- and/or time-based field averages, with optional windowing, for a user-specified selection of volumetric and/or surface fields
CfieldAverageItem	Helper class to describe what form of averaging to apply. A set will be applied to each base field in Foam::fieldAverage, of the following form
CfieldExpression	Intermediate class for handling field expression function objects (e.g. blendingFactor etc.) whereinto a single field is input
CfieldExtents	Computes the spatial minimum and maximum extents of an input field
CfieldInfo	Helper class to store a wordRe and label used by Foam::functionObjects::fieldSelection
CfieldMinMax	Computes the values and locations of field minima and maxima. These are good indicators of calculation performance, e.g. to confirm that predicted results are within expected bounds, or how well a case is converging
CfieldSelection	Helper class to manage field selections
CfieldsExpression	Intermediate class for handling field expression function objects (e.g. add, subtract etc.) whereinto more than one fields are input
CfieldValue	Intermediate class for handling field value-based function objects
CfileFieldSelection	Helper class to manage file-based field selections
CfilmFlux	Calculates the mass flux for surface film models
CflowType	Computes the flow type indicator of an input velocity field
Cflux	Computes the flux of an input vector field
CfluxSummary	Computes the volumetric- or mass-flux information across selections of face zones
►CforceCoeffs	Computes force and moment coefficients over a given list of patches, and optionally over given porous zones. The following coefficients can be selected and output:
CcoeffDesc
CforceComponents
Cforces	Computes forces and moments over a given list of patches by integrating pressure and viscous forces and moments, and optionally resistance forces and moments from porous zones
CfvExpressionField	Function object that generates or modifies a field based on expressions
CfvMeshFunctionObject	Specialization of Foam::functionObject for an Foam::fvMesh, providing a reference to the Foam::fvMesh
Cgrad	Computes the gradient of an input field
CheatTransferCoeff	Computes the heat transfer coefficient [W/(m2 K)] as a volScalarField for a given set of patches
Chistogram	Computes the volume-weighted histogram of an input volScalarField
ChydrostaticPressure	Calculates and outputs the pressure fields p_rgh and ph_rgh
CicoUncoupledKinematicCloud	This functionObject tracks a uncoupled kinematic particle cloud in the specified velocity field of an incompressible flow (laminar, RANS or LES)
CinterfaceHeight	This function object reports the height of the interface above a set of locations
CLambda2	Computes the second largest eigenvalue of the sum of the square of the symmetrical and anti-symmetrical parts of the velocity gradient tensor
CLambVector	Computes Lamb vector, i.e. the cross product of vorticity and velocity. Calculation of the divergence of the Lamb vector can be performed by using div function object on this LambVector function object
ClimitFields	Limits input fields to user-specified min and max bounds
Clog	Computes the natural logarithm of an input volScalarField
ClogFiles	FunctionObject base class for creating, maintaining and writing log files e.g. integrated or averaged field data vs time
CMachNo	Computes the Mach number as a volScalarField
Cmag	Computes the magnitude of an input field
CmagSqr	Computes the magnitude of the square of an input field
CmapFields	Maps input fields from local mesh to secondary mesh at runtime
Cmomentum	Computes linear/angular momentum, reporting integral values and optionally writing the fields
CmomentumError	Computes balance terms for the steady momentum equation
CmultiphaseInterHtcModel	A heat transfer coefficient for multiphase inter solvers (i.e. icoReactingMultiphaseFoam)
Cmultiply	Multiplies a given list of (at least two or more) fields and outputs the result into a new field
CmultiRegion	Wrapper that clones the supplied function object for each region
CnearWallFields	Samples near-patch volume fields within an input distance range
Cnorm	Normalises an input field with a chosen norm, and outputs a new normalised field
CObukhovLength	Computes the Obukhov length field and associated friction velocity field
CparProfiling	Simple (simplistic) mpi-profiling
CparticleDistribution	Generates a particle distribution for lagrangian data at a given time
CPecletNo	Computes the Peclet number as a surfaceScalarField
CphaseForces	This function object calculates and outputs the blended interfacial forces acting on a given phase, i.e. drag, virtual mass, lift, wall-lubrication and turbulent dispersion. Note that it works only in run-time processing mode and in combination with the reactingEulerFoam solvers
Cpow	Computes the power of an input volScalarField
Cpressure	Provides several methods to convert an input pressure field into derived forms, including:
CprocessorField	Writes a scalar field whose value is the local processor ID. The output field name is processorID
CpropellerInfo	Calculates propeller performance and wake field properties
Cproperties	Storage for function object properties, derived from IOdictionary. Provides functionality to read/write state information (data required for smooth restart behaviour) and results to/from the state dictionary
CproudmanAcousticPower	Computes the acoustic power due to the volume of isotropic turbulence using Proudman's formula
CQ	Computes the second invariant of the velocity gradient tensor \([s^{-2}]\)
Crandomise	Adds a random component to an input field, with a specified perturbation magnitude
CreactingEulerHtcModel	A heat transfer coefficient for reactingEuler solvers
CreactionsSensitivityAnalysis	Computes indicators for reaction rates of creation or destruction of species in each reaction
CreadFields	Reads fields from the time directories and adds them to the mesh database for further post-processing
Creference	Computes a field whose values are offset to a reference value obtained by from a Function1
CregionFunctionObject	Specialization of Foam::functionObject for a region and providing a reference to the region Foam::objectRegistry
CregionSizeDistribution	Creates a droplet size distribution via interrogating a continuous phase fraction field
CremoveRegisteredObject	Removes registered objects if present in the database
CscalarTransport	Evolves a passive scalar transport equation
CsetFlow	Provides options to set the velocity and flux fields as a function of time
CsetTimeStepFaRegionsFunctionObject	This function object controls the time step for classes of the type regionFaModel. It reads regionFaMaxCo entry from controlDict and evaluate the time step based on the finite area Courant Number
CsetTimeStepFunctionObject	This function object overrides the calculation time step
CsixDoFRigidBodyState	Writes the 6-DoF motion state
CsizeDistribution	This function object calculates and outputs information about the size distribution of the dispersed phase, such as the number density function or its moments. It is designed to be used exclusively with the population balance modeling functionality of the reactingEulerFoam solvers. It can be applied to a specific cellZone or the entire domain
CsolverFieldSelection
CsolverInfo	Writes solver information for a list of user-specified fields
CspecieReactionRates	Writes the domain averaged reaction rates for each specie for each reaction into the file <timeDir>/specieReactionRates.dat
CstabilityBlendingFactor	Computes the stabilityBlendingFactor to be used by the local blended convection scheme. The output is a surface field weight between 0-1
CstateFunctionObject	Base class for function objects, adding functionality to read/write state information (data required for smooth restart behaviour) and results to/from the state dictionary
CstreamFunction	Computes the stream function (i.e. https://w.wiki/Ncm)
CstreamLine	Generates streamline data by sampling a set of user-specified fields along a particle track, transported by a user-specified velocity field
CstreamLineBase
Csubtract	Subtracts a given list of (at least one or more) fields from a field and produces a new field, where the fields possess the same sizes and dimensions
CsumParticleOp
CsurfaceDistance	Computes the distance to the nearest surface from a given geometry
CsurfaceInterpolate	Linearly interpolates volume fields to generate surface fields
CsyncObjects	Copies content of local objectRegistry to all processors
CsystemCall	Executes system calls, entered in the form of string lists
CthermoCoupleProbes	Sample probe for temperature using a thermocouple
CtimeActivatedFileUpdate	Performs a file copy/replacement once a specified time has been reached
CtimeControl	Wrapper around functionObjects to add time control
CtimeFunctionObject	Virtual base class for function objects with a reference to Time
CtimeInfo	Writes the run time (time-step), cpuTime and clockTime - optionally with cpuTime and clockTime change for each time step
CturbulenceFields	Computes various turbulence-related quantities that are not typically output during calculations, and stores/writes them on the mesh database for further manipulation
CvalueAverage	Computes the ensemble- or time-based singular-value average values, with optional windowing, from the output of function objects that generate non-field type values (e.g. Cd of forceCoeffs or momentum_x in momentum function objects)
CvalueAverageBase	Base class that computes the ensemble- or time-based singular-value average values, with optional windowing, from the output of function objects that generate non-field type values, e.g. Cd of forceCoeffs or momentum_x in momentum function objects
CvolFieldSelection	Helper class to manage solver field selections
CvolRegion	Volume (cell) region selection class
Cvorticity	Computes the vorticity, the curl of the velocity
CvtkCloud	This functionObject writes cloud(s) in VTK PolyData format (.vtp extension) with the time information saved in a '.series' file
CvtkWrite	Writes fields in VTK (xml or legacy) format. Writes cell-values or point-interpolated values for volFields
CwallBoundedStreamLine	Generates streamline data by sampling a set of user-specified fields along a particle track, transported by a user-specified velocity field, constrained to a patch
CwallHeatFlux	Computes the wall-heat flux at selected wall patches
CwallShearStress	Computes the wall-shear stress at selected wall patches
CwriteCellCentres	Writes the cell-centres volVectorField and the three component fields as volScalarFields
CwriteCellVolumes	Writes the cell-volumes volScalarField
CwriteDictionary	Reports dictionary contents on change
CwriteFile	Base class for writing single files from the function objects
CwriteObjects	Allows specification of different writing frequency of objects registered to the database
CXiReactionRate	Writes the turbulent flame-speed and reaction-rate volScalarFields for the Xi-based combustion models
CyPlus	Computes the near wall \(y_1^+\) for turbulence models
CzeroGradient	Creates a volume field with zero-gradient boundary conditions from another volume field
►Nfv	Namespace for finite-volume
►NgradientLimiters
Ccubic	Cubic gradient limiter
Cminmod	Minmod gradient limiter
CVenkatakrishnan	Venkatakrishnan gradient limiter
CacousticDampingSource	Applies sources on velocity (i.e. U) within a specified region to enable acoustic damping
CactuationDiskSource	Applies sources on velocity (i.e. U) within a specified region to enable actuator disk models for aero/hydro thrust loading of horizontal axis turbines on surrounding flow field in terms of energy conversion processes
CatmAmbientTurbSource	Applies sources on k and either epsilon or omega to prevent them droping below a specified ambient value for atmospheric boundary layer modelling. Such adjustment reportedly increases numerical stability for very stable atmospheric stability conditions, and prevents nonphysical oscillations in regions of low shear at higher altitudes
CatmBuoyancyTurbSource	Applies sources on k and either epsilon or omega to incorporate effects of buoyancy for atmospheric boundary layer modelling
CatmCoriolisUSource	Applies corrections to incorporate the horizontal and vertical components of the Coriolis force for which the rotating frame is Earth
CatmLengthScaleTurbSource	Applies sources on either epsilon or omega to correct mixing-length scale estimations for atmospheric boundary layer modelling
CatmNutSource	Adds/subtracts a given artificial turbulent viscosity field to/from nut for atmospheric boundary layer modelling
CatmPlantCanopyTSource	Applies sources on temperature, i.e. T, to incorporate effects of plant canopy for atmospheric boundary layer modelling
CatmPlantCanopyTurbSource	Applies sources on either epsilon or omega to incorporate effects of plant canopy for atmospheric boundary layer modelling
CatmPlantCanopyUSource	Applies sources on velocity, i.e. U, to incorporate effects of plant canopy for atmospheric boundary layer modelling
CbackwardDdtScheme	Second-order backward-differencing ddt using the current and two previous time-step values
CboundedConvectionScheme	Bounded form of the selected convection scheme
CboundedDdtScheme	Bounded form of the selected ddt scheme
CbuoyancyEnergy	Applies buoyancy energy sources (i.e. Sb) to the energy equation for compressible flows
CbuoyancyForce	Applies buoyancy force sources (i.e. Sf) to the momentum equation for incompressible and compressible flows
CbuoyancyTurbSource	Applies sources on turbulent kinetic energy (i.e. k) and either turbulent kinetic energy dissipation rate (i.e. epsilon) or specific dissipation rate (i.e. omega) to incorporate effects of buoyancy on turbulence in incompressible and compressible flows
CcellLimitedGrad	CellLimitedGrad gradient scheme applied to a runTime selected base gradient scheme
CcellMDLimitedGrad	CellMDLimitedGrad gradient scheme applied to a runTime selected base gradient scheme
CcellSetOption	Intermediate abstract class for handling cell-set options for the derived fvOptions
CCentredFitSnGradScheme
CCodedSource
CCoEulerDdtScheme	Courant number limited first-order Euler implicit/explicit ddt
CconstantHeatTransfer	Applies a constant heat transfer model for inter-region heat exchanges
CconvectionScheme	Abstract base class for convection schemes
CcorrectedSnGrad	Surface gradient scheme with full explicit non-orthogonal correction
CCrankNicolsonDdtScheme	Second-oder Crank-Nicolson implicit ddt using the current and previous time-step fields as well as the previous time-step ddt
Cd2dt2Scheme	Abstract base class for finite volume d2dt2 schemes
CddtScheme	Abstract base class for ddt schemes
CddtSchemeBase	Non-templated base class for ddt schemes
CdirectionalPressureGradientExplicitSource	Applies an explicit pressure gradient source in such a way to deflect the flow towards an specific direction (flowDir). Alternatively add an extra pressure drop in the flowDir direction using a model
CdivScheme	Abstract base class for div schemes
CeffectivenessHeatExchangerSource	Heat exchanger source model for compressible flows, where the heat exchanger is modelled as an energy source using a selection of cells
CEulerD2dt2Scheme	First-order Euler implicit d2dt2 using the current and two previous time-step values
CEulerDdtScheme	Basic first-order Euler implicit/explicit ddt using only the current and previous time-step values
CexplicitPorositySource	Applies an explicit porosity source to the momentum equation within a specified region
CfaceCorrectedSnGrad	Surface gradient scheme with full explicit non-orthogonal correction
CfaceLimitedGrad	FaceLimitedGrad gradient scheme applied to a runTime selected base gradient scheme
CfaceMDLimitedGrad	FaceMDLimitedGrad gradient scheme applied to a runTime selected base gradient scheme
CfixedTemperatureConstraint	Constrain temperature equation (i.e. T) with a given set of fixed values within a specified region
CFixedValueConstraint	Constrain values of given fields of Type with a given maximum value within a specified region, where <Type>=Scalar/Vector/SphericalTensor/SymmTensor/Tensor
CfourthGrad	Second-order gradient scheme using least-squares
CgaussConvectionScheme	Basic second-order convection using face-gradients and Gauss' theorem
CgaussDivScheme	Basic second-order div using face-gradients and Gauss' theorem
CgaussGrad	Basic second-order gradient scheme using face-interpolation and Gauss' theorem
CgaussLaplacianScheme	Basic second-order laplacian using face-gradients and Gauss' theorem
CgradScheme	Abstract base class for gradient schemes
CinterRegionExplicitPorositySource	Applies inter-region explicit porosity source
CinterRegionHeatTransferModel	Intermediate class for handling inter-region heat exchanges
CinterRegionOption	Intermediate class for handling inter-region exchanges
CiterativeGaussGrad	A second-order gradient scheme using face-interpolation, Gauss' theorem and iterative skew correction
CjouleHeatingSource	Evolves an electrical potential equation
ClaplacianScheme	Abstract base class for laplacian schemes
CLeastSquaresGrad	Gradient calculated using weighted least-squares on an arbitrary stencil. The stencil type is provided via a template argument and any cell-based stencil is supported:
CleastSquaresGrad	Second-order gradient scheme using least-squares
CLeastSquaresVectors	Least-squares gradient scheme vectors
ClimitedSnGrad	Surface gradient scheme with limited explicit non-orthogonal correction
ClimitTemperature	Corrects temperature field (i.e. T) within a specified region by applying limits between a given minimum and maximum
ClimitVelocity	Corrects velocity field (i.e. T) within a specified region by applying a given maximum velocity magnitude limit
ClocalEulerDdt
ClocalEulerDdtScheme	Local time-step first-order Euler implicit/explicit ddt
CmeanVelocityForce	Applies the force within a specified region to maintain the specified mean velocity for incompressible flows
CmultiphaseMangrovesSource
CmultiphaseMangrovesTurbulenceModel
CmultiphaseStabilizedTurbulence	Applies corrections to the turbulent kinetic energy equation (i.e. k) and turbulent viscosity field (i.e. nut) for incompressible multiphase flow cases
CmultivariateGaussConvectionScheme	Basic second-order convection using face-gradients and Gauss' theorem
►Coption	Base abstract class for handling finite volume options (i.e. fvOption)
CiNew	Return pointer to new fvOption object created
CoptionList	List of finite volume options
Coptions	Finite-volume options
CorthogonalSnGrad	Surface gradient scheme with no non-orthogonal correction
CpatchCellsSource	Source defined by a boundary condition applied to cells next to patches. This fvOption needs to be used with a boundarySourcePatch type of boundary condition (e.g. speciesSorption and enthalpySorption.)
CpatchMeanVelocityForce	Applies the force over the specified patch to maintain the specified mean velocity for incompressible flows
CPhaseLimitStabilization	Stabilization source for phase transport equations of Type, where <Type>=Scalar/Vector/SphericalTensor/SymmTensor/Tensor
CradialActuationDiskSource	Applies sources on velocity field (i.e. U) within a specified region to enable actuator disk models with radial thrust distribution for aero/hydro thrust loading of horizontal axis turbines on surrounding flow field in terms of energy conversion processes
Cradiation	Applies radiation sources (i.e. Sh) to the energy equation for compressible flows
CrelaxedNonOrthoGaussLaplacianScheme	Basic second-order laplacian using face-gradients and Gauss' theorem
CrelaxedSnGrad	Surface gradient scheme with under-/over-relaxed full or limited explicit non-orthogonal correction
►CrotorDiskSource	Applies cell-based momentum sources on velocity (i.e. U) within a specified cylindrical region to approximate the mean effects of rotor forces
CflapData
CSemiImplicitSource	Applies semi-implicit source within a specified region for Type, where <Type>=Scalar/Vector/SphericalTensor/SymmTensor/Tensor. The source rate coefficients are specified as pairs of Su-Sp coefficients, i.e.:
CskewCorrectedSnGrad	Surface gradient scheme with skewness and full explicit non-orthogonal corrections
CSLTSDdtScheme	Stabilised local time-step first-order Euler implicit/explicit ddt. The time-step is adjusted locally so that an advective equations remains diagonally dominant
CsnGradScheme	Abstract base class for runtime selected snGrad surface normal gradient schemes
CsolidificationMeltingSource	This source is designed to model the effect of solidification and melting processes, e.g. windhield defrosting, within a specified region. The phase change occurs at the melting temperature, Tmelt
CsteadyStateD2dt2Scheme	SteadyState d2dt2 which returns 0
CsteadyStateDdtScheme	SteadyState implicit/explicit ddt which returns 0
CtabulatedAccelerationSource	Solid-body 6-DoF acceleration source
CtabulatedHeatTransfer	Applies a tabulated heat transfer model for inter-region heat exchanges
CtabulatedNTUHeatTransfer	Applies a tabulated heat transfer model for inter-region heat exchanges. The heat flux is calculated based on the Number of Thermal Units (NTU)
CuncorrectedSnGrad	Surface gradient scheme with no non-orthogonal correction
CvariableHeatTransfer	Applies a variable heat transfer model depending on local values for inter-region heat exchanges
CvelocityDampingConstraint	Constrain given velocity fields to dampen velocity fluctuations exceeding a given value within a specified region
CviscousDissipation	Applies a viscous dissipation energy source to the energy equation
CVoFSolidificationMeltingSource	Solidification and melting model for VoF simulations
Nfvc	Namespace of functions to calculate explicit derivatives
Nfvm	Namespace of functions to calculate implicit derivatives returning a matrix
►NglTF	Namespace for handling glTF creation. https://www.khronos.org/registry/glTF/
Caccessor	GlTF accessor
►Canimation	GlTF animation
CglTFChannel
CglTFSampler
CglTFTarget
Cbase	Base class for glTF entities
CbufferView	GlTF buffer view - provides a view/slice of the glTF buffer
CList	Container for glTF entities
Cmesh	GlTF mesh
Cobject	GlTF binary object
Cscene	Main class to assemble glTF components into a scene
CsceneWriter	Wrapper for glTF scene for file output
►NgraphWriters
CgnuplotWriter	Output in gnuplot (http://www.gnuplot.info) format
CrawWriter	A raw xy graph output
CxmgraceWriter	Output and agr file for xmgrace (http://plasma-gate.weizmann.ac.il/Grace/)
►NHashSetOps	Various operations for HashSet
CplusEqOp	Combine HashSet operation. Equivalent to 'a |= b'
►NHashTableOps	Various operations for HashTable
CplusEqOp	Combine HashTable operation. Equivalent to 'a += b'
►NheatTransferCoeffModels	A namespace for various heat transfer coefficient model implementations
CfixedReferenceTemperature	Heat transfer coefficient calculation that employs a fixed reference temperature
ClocalReferenceTemperature	Heat transfer coefficient calculation that employs the patch internal field as the reference temperature
CReynoldsAnalogy	Heat transfer coefficient calculation based on Reynolds Analogy, which is used to relate turbulent momentum and heat transfer
►NheatTransferModels
CconstantNuHeatTransfer	Model which applies a user provided constant Nusselt number for interfacial heat transfer
CRanzMarshall	Ranz-Marshall correlation for turbulent heat transfer from the surface of a sphere to the surrounding fluid
CsphericalHeatTransfer	Model which applies an analytical solution for heat transfer from the surface of a sphere to the fluid within the sphere
►NhelpTypes
ChelpBoundary
ChelpFunctionObject
ChelpSolver
►NimplicitFunctions
CcomposedFunctionImplicitFunction	Handles multiple implicit functions and offers multiple ways to combine them
CcylinderImplicitFunction	Creates a infintite long cylinderImplicitFunction
CellipsoidImplicitFunction	Creates an ellipsoidImplicitFunction
CparaboloidImplicitFunction	Creates a paraboloid
CplaneImplicitFunction	Creates a plane
CsinImplicitFunction	Original code supplied by Henning Scheufler, DLR (2019)
CsphereImplicitFunction	Creates a sphere
►Nincompressible
NadjointRASModels	Namespace for incompressible adjointRAS turbulence models
►NRASModels
CkkLOmega	Low Reynolds-number k-kl-omega turbulence model for incompressible flows
CLamBremhorstKE	Lam and Bremhorst low-Reynolds number k-epsilon turbulence model for incompressible flows
CLienCubicKE	Lien cubic non-linear low-Reynolds k-epsilon turbulence models for incompressible flows
CLienLeschziner	Lien and Leschziner low-Reynolds number k-epsilon turbulence model for incompressible flows
CqZeta	Gibson and Dafa'Alla's q-zeta two-equation low-Re turbulence model for incompressible flows
CShihQuadraticKE	Shih's quadratic algebraic Reynolds stress k-epsilon turbulence model for incompressible flows
►NRASVariables
CkEpsilon
CkOmegaSST
Claminar
CLaunderSharmaKE
CSpalartAllmaras
CadjointEikonalSolver	Solver of the adjoint to the eikonal PDE
CadjointMeshMovementSolver	Solver of the adjoint to the Laplace grid displacement equation
CadjointSensitivity	Abstract base class for adjoint-based sensitivities in incompressible flows
CalphatJayatillekeWallFunctionFvPatchScalarField	This boundary condition provides a kinematic turbulent thermal conductivity for using wall functions, using the Jayatilleke 'P' function
CFIBase	Base class for Field Integral-based sensitivity derivatives
CoptimisationType	Abstract base class for optimisation methods
CRASModelVariables	Abstract base class for objective functions. No point in making this runTime selectable since its children will have different constructors
CsensitivityBezier	Calculation of adjoint based sensitivities for Bezier control points
CsensitivityBezierFI	Calculation of adjoint based sensitivities for Bezier control points using the FI appoach
CsensitivityMultiple	Calculation of adjoint based sensitivities of multiple types
CsensitivitySurface	Calculation of adjoint based sensitivities at wall faces
CsensitivitySurfacePoints	Calculation of adjoint based sensitivities at wall points
CsensitivityVolBSplines	Calculation of adjoint based sensitivities at vol B-Splines control points using the SI or e-SI approach (determined by surface sensitivities)
CsensitivityVolBSplinesFI	Calculation of adjoint based sensitivities at vol B-Splines control points using the FI approach
CshapeOptimisation	Calculates shape sensitivities using the adjoint approach, computes boundaryMesh movement and propagates it to the volume mesh
CshapeSensitivities
CSIBase	Base class for Surface Integral-based sensitivity derivatives
►NincompressibleAdjoint	Namespace for incompressible adjoint turbulence models
►NadjointRASModels
CadjointkOmegaSST	Continuous adjoint to the kOmegaSST turbulence model for incompressible flows
CadjointLaminar	Dummy turbulence model for a laminar incompressible flow. Can also be used when the "frozen turbulence" assumption is employed
CadjointSpalartAllmaras	Continuous adjoint to the Spalart-Allmaras one-eqn mixing-length model for incompressible flows
CadjointRASModel	Abstract base class for incompressible turbulence models
CadjointTurbulenceModel	Abstract base class for incompressible adjoint turbulence models (RAS, LES and laminar)
►NintegrationSchemes
Canalytical	Analytical integration scheme
CEuler
►NinterfaceCompositionModels
CHenry	Henry's law for gas solubility in liquid. The concentration of a dissolved species in the liquid is proportional to its partial pressure in the gas. A dimensionless solubility, \(k\), is given for each species. This is the ratio of the concentration of the species in the liquid to the corresponding concentration in the gas; i.e., \(k = c_{i,liq}/c_{i,gas}\). Mixing in the gas is assumed to be ideal
CNonRandomTwoLiquid	Non ideal law for the mixing of two species. A separate composition model is given for each species. The composition of a species is equal to the value given by the model, scaled by the species fraction in the bulk of the other phase, and multiplied by the activity coefficient for that species. The gas behaviour is assumed ideal; i.e. the fugacity coefficient is taken as equal to 1
CRaoult	Raoult's law of ideal mixing. A separate composition model is given for each species. The composition of a species is equal to the value given by the model scaled by the species fraction in the bulk of the other phase
CSaturated	Model which uses a saturation pressure model for a single species to calculate the interface composition
►NIsotropyModels
CNoIsotropy	Place holder for the 'none' option
CStochastic	Stochastic return-to-isotropy model
►NkineticTheoryModels
►NconductivityModels
CGidaspow
CHrenyaSinclair
CSyamlal
►NfrictionalStressModels
CJohnsonJackson
CJohnsonJacksonSchaeffer
CSchaeffer
►NgranularPressureModels
CLun
CSyamlalRogersOBrien
►NradialModels
CCarnahanStarling
CLunSavage
CSinclairJackson
►NviscosityModels
CGidaspow
CHrenyaSinclair
CSyamlal
CconductivityModel
CfrictionalStressModel
CgranularPressureModel
CnoneViscosity
CradialModel
CviscosityModel
►NlaminarFlameSpeedModels	Namespace for laminar flame speed models
Cconstant	Constant laminar flame speed model
CGulders	Laminar flame speed obtained from Gulder's correlation
CGuldersEGR	Laminar flame speed obtained from Gulder's correlation with EGR modelling
CRaviPetersen	Laminar flame speed obtained from Ravi and Petersen's correlation
CSCOPE	Laminar flame speed obtained from the SCOPE correlation
►NlaminarModels
►NgeneralizedNewtonianViscosityModels	A namespace for various generalized Newtonian viscosity model implementations
CBirdCarreau	An incompressible Bird-Carreau non-Newtonian viscosity model
CCasson	Casson generalized Newtonian viscosity model
CCrossPowerLaw	Cross-Power law generalized Newtonian viscosity model
CHerschelBulkley	Herschel-Bulkley generalized Newtonian viscosity model
CpowerLaw	Standard power-law generalized Newtonian viscosity model
CstrainRateFunction	Run-time selected strain-rate function generalized Newtonian viscosity model
CgeneralizedNewtonian	Turbulence model for shear-dependent Non-Newtonian flow
CgeneralizedNewtonianViscosityModel	An abstract base class for generalized Newtonian viscosity models
CMaxwell	Maxwell model for viscoelasticity using the upper-convected time derivative of the stress tensor. See http://en.wikipedia.org/wiki/Upper-convected_Maxwell_model
CStokes	Turbulence model for Stokes flow
►NLESModels	Namespace for LES SGS models
CcontinuousGasKEqn	One-equation SGS model for the gas-phase in a two-phase system supporting phase-inversion
CcubeRootVolDelta
CDeardorffDiffStress	Differential SGS Stress Equation Model for incompressible and compressible flows
CDESModel	Templated abstract base class for DES models
CdynamicKEqn	Dynamic one equation eddy-viscosity model
CdynamicLagrangian	Dynamic SGS model with Lagrangian averaging
CIDDESDelta
CkEqn	One equation eddy-viscosity model
CkOmegaSSTDDES	K-omega-SST DDES turbulence model for incompressible and compressible flows
CkOmegaSSTDES	K-omega-SST DES turbulence model for incompressible and compressible flows
CkOmegaSSTIDDES	K-omega-SST IDDES turbulence model for incompressible and compressible flows
CLESeddyViscosity	Eddy viscosity LES SGS model base class
CmaxDeltaxyz
CmaxDeltaxyzCubeRootLESDelta
CNicenoKEqn	One-equation SGS model for the continuous phase in a two-phase system including bubble-generated turbulence
CPrandtlDelta
CSmagorinsky	The Smagorinsky SGS model
CSmagorinskyZhang	The Smagorinsky SGS model including bubble-generated turbulence
►CsmoothDelta
CdeltaData	Public class used by mesh-wave to propagate the delta-ratio
CSpalartAllmarasDDES	SpalartAllmaras DDES turbulence model for incompressible and compressible flows
CSpalartAllmarasDES	SpalartAllmarasDES DES turbulence model for incompressible and compressible flows
CSpalartAllmarasIDDES	SpalartAllmaras IDDES turbulence model for incompressible and compressible flows
CvanDriestDelta
CWALE	The Wall-adapting local eddy-viscosity (WALE) SGS model
►NliftModels
CconstantLiftCoefficient	Constant coefficient lift model
CLegendreMagnaudet	Lift model of Legendre and Magnaudet
CMoraga	Lift model of Moraga et al
CnoLift
CTomiyamaLift	Lift model of Tomiyama et al
CwallDamped
►NlimitFuncs	Namespace for limiting functions
CmagSqr
Cnull
CrhoMagSqr
NListListOps	Various utility functions to work on Lists of Lists (usually resulting from 'gather'ing and combining information from individual processors)
►NListOps	Various utility functions to work on Lists
CappendEqOp	List helper to append y elements onto the end of x
Cgreater	A list compare binary predicate for reverse sort
Cless	A list compare binary predicate for normal sort
CunionEqOp	List helper to add y unique elements to x
CuniqueEqOp	List helper to append y unique elements onto the end of x
NlumpedPointTools	A collection of utility functions for handling IO related to the lumped-mass movement
►NmassTransferModels
CFrossling	Frossling correlation for turbulent mass transfer from the surface of a sphere to the surrounding fluid
CsphericalMassTransfer	Model which applies an analytical solution for mass transfer from the surface of a sphere to the fluid within the sphere
NMath	A namespace for various mathematical functions
NMatrixTools	Collection of functions for matrix-related verifications
►NmeltingEvaporationModels
CdiffusionGasEvaporation	Gas diffusion based evaporation/condensation mass transfer model
CinterfaceHeatResistance	Interface Heat Resistance type of condensation/saturation model using spread source distribution following:
CinterfaceOxideRate	The interfaceOxideRate is a simple model to calculate the formation rate of oxide inclusions (mDotOxide), which is a local function of the volume fraction of reducing agent (alpha), temperature (T) and oxide-inclusion density (chi)
CkineticGasEvaporation	Considering the Hertz Knudsen formula, which gives the evaporation-condensation flux based on the kinetic theory for flat interface:
CLee	Mass transfer Lee model. Simple model driven by field value difference as:
►NmeshObjects
Cgravity	Gravitational acceleration vector Although termed a MeshObject it is registered on Time only and thus identical for all regions
NmeshTools	Collection of static functions to do various simple mesh related things
►NmixtureViscosityModels	A namespace for incompressible mixtureViscosityModel implementations
CBinghamPlastic	Viscosity correction model for Bingham plastics
Cplastic	Viscosity correction model for a generic power-law plastic
Cslurry	Thomas' viscosity correction for slurry
NModule	Additional OpenFOAM modules
►NMSwindows	OS-specific functions implemented for MS-windows
CdirectoryIterator	A simple directory contents iterator
NMULES
►NmultiphaseEuler
►NdiameterModels
Cconstant	Constant dispersed-phase particle diameter model
Cisothermal	Isothermal dispersed-phase particle diameter model
►NdragModels
Cblended	Blends two drag models based on the phase fractions to handle phase-inversion
CErgun	H, Enwald, E. Peirano, A-E Almstedt 'Eulerian Two-Phase Flow Theory Applied to Fluidization' Int. J. Multiphase Flow, Vol. 22, Suppl, pp. 21-66 (1996) Eq. 104, p. 42
CGibilaro	H, Enwald, E. Peirano, A-E Almstedt 'Eulerian Two-Phase Flow Theory Applied to Fluidization' Int. J. Multiphase Flow, Vol. 22, Suppl, pp. 21-66 (1996) Eq. 106, p. 43
CGidaspowErgunWenYu	D. Gidaspow, Multiphase flow and fluidization, Academic Press, New York, 1994
CGidaspowSchillerNaumann	H, Enwald, E. Peirano, A-E Almstedt 'Eulerian Two-Phase Flow Theory Applied to Fluidization' Int. J. Multiphase Flow, Vol. 22, Suppl, pp. 21-66 (1996) Eq. 86-87, p. 40
Cinterface	Drag between phase separated by a VoF resolved interface
CSchillerNaumann
CSyamlalOBrien	Syamlal, M., Rogers, W. and O'Brien, T. J. (1993) MFIX documentation, Theory Guide. Technical Note DOE/METC-94/1004. Morgantown, West Virginia, USA
CWenYu	H, Enwald, E. Peirano, A-E Almstedt 'Eulerian Two-Phase Flow Theory Applied to Fluidization' Int. J. Multiphase Flow, Vol. 22, Suppl, pp. 21-66 (1996) Eq. 86-87, p. 40
►NheatTransferModels
CRanzMarshall
►CalphaContactAngleFvPatchScalarField
CinterfaceThetaProps
CdiameterModel	Abstract base-class for dispersed-phase particle diameter models
CdragModel
CheatTransferModel
►NmultiphaseInter
►NsurfaceTensionModels
CconstantSurfaceTensionCoefficient
CinterfaceCompositionModel
CmultiphaseSystem
CphaseModel
CsurfaceTensionModel
►NnoiseModels
CpointNoise	Perform noise analysis on point-based pressure data
CsurfaceNoise	Perform noise analysis on surface-based pressure data
►Nobjectives
CobjectiveForce
CobjectiveMoment
CobjectiveNutSqr	Objective qualitatively quantifying noise through the integral of the squared turbulent viscosity over specified cellZones. Requires the adjoint to the turbulence model to be incorporated into the optimisation loop
CobjectivePartialVolume
CobjectivePtLosses
►NPackingModels
CExplicit	Explicit model for applying an inter-particle stress to the particles
CImplicit	Implicit model for applying an inter-particle stress to the particles
CNoPacking
►NpairPotentials
CazizChen	Reference:
Ccoulomb
CdampedCoulomb
CexponentialRepulsion
ClennardJones
CmaitlandSmith	Reference:
CnoInteraction
►Nparsing	Collection of static functions and data related to parsing and an isolated namespace for lexers, parsers, scanners
CgenericRagelLemonDriver	Generic interface code for Ragel/Lemon combination Subclasses should implement one or more process() methods
►NParticleStressModels
Cexponential	Exponential inter-particle stress model of the same form as used in twoPhaseEulerFoam
CHarrisCrighton	Inter-particle stress model of Harris and Crighton
CLun	Inter-particle stress model of Lun et al
►NpatchDistMethods
CadvectionDiffusion	Calculation of approximate distance to nearest patch for all cells and boundary by solving the Eikonal equation in advection form with diffusion smoothing
CdirectionalMeshWave	Variant of meshWave distance-to-patch method
Cexact	Calculation of exact distance to nearest patch for all cells and boundary by constructing a search tree for all patch faces
CmeshWave	Fast topological mesh-wave method for calculating the distance to nearest patch for all cells and boundary
CPoisson	Calculation of approximate distance to nearest patch for all cells and boundary by solving Poisson's equation
►NPatchFunction1Types
CCodedField	PatchFunction1 with the code supplied by an on-the-fly compiled C++ expression
CConstantField	Templated function that returns a constant value
CMappedFile	Patch value mapping from a set of values stored in a file and a set of unstructured points using the following directory structure:
CPatchExprField	PatchFunction1 with values supplied by a parsed expression
CSampled	PatchFunction1 to sample an existing field
CUniformValueField	Templated function that returns a uniform field based on a run-time selectable Function1 entry
►NPDRDragModels
Cbasic	Basic sub-grid obstacle drag model. Details supplied by J Puttock 2/7/06
►NPDRlegacy	Legacy and transitional routines
CobstacleGrouping	Locations for each instance of an obstacle group
►NPDRobstacles	Reader classes for concrete PDRsetFields obstacle types
Ccuboid	A cuboid, selectable as box
Ccylinder	A cylinder, selectable as cyl or cylinder
Cdiagbeam	A diagonal beam, which is cylinder-like, selectable as diag or diagbeam
Cgrating	A grating, selectable as grate or grating
Clouver	Louver blowoff, selectable as louver or louvre
Cpatch	Rectangular patch, selectable as patch
Cwallbeam	A wallbeam, selectable as wallbeam which is currently identical to a box (PDRobstacles::cuboid)
NPDRutils	Utilities for PDR (eg, for setFields)
►NphaseChangeTwoPhaseMixtures
CKunz	Kunz cavitation model slightly modified so that the condensation term is switched off when the pressure is less than the saturation vapour pressure. This change allows the condensation term to be formulated as a coefficient multiplying (p - p_sat) so that it can be included as an implicit term in the pressure equation
CMerkle	Merkle cavitation model
CSchnerrSauer	SchnerrSauer cavitation model
►NphaseTransferModels
Cdeposition	Phase transfer model representing change from a dispersed phase to a film as a result of deposition onto a third phase
►NporosityModels
CDarcyForchheimer	Darcy-Forchheimer law porosity model, given by:
CfixedCoeff	Fixed coefficient form of porosity model
CpowerLaw	Power law porosity model, given by:
CpowerLawLopesdaCosta	Variant of the power law porosity model with spatially varying drag coefficient
CpowerLawLopesdaCostaZone
Csolidification	Simple solidification porosity model
►NporousModels
CVollerPrakash	Porous model to apply a porous media on a solid phase
►NPOSIX	OS-specific functions implemented in POSIX
CdirectoryIterator	A simple directory contents iterator
►Npredicates	Constant predicate types
Calways	Unary and binary predicates that always return true, useful for templating
Cnever	Unary and binary predicates that never return true, useful for templating
Cscalars	A list of unary predicates (tests) on scalars. Includes a number of standard comparison predicates (eg, "less", "greater", ...)
►NprocessorLODs
Cbox	Creates the parallel distribution map by describing the source and target objects using box shapes
CcellBox	Creates the parallel distribution map by describing the source and target objects using box shapes
CfaceBox	Creates the parallel distribution map by describing the source and target objects using box shapes
NPstreamDetail	Some implementation details for Pstream and/or MPI
NPstreamGlobals	Global functions and variables for working with parallel streams, but principally for mpi
NPtrListOps	Various utility functions to operate on Pointer Lists
►Nradiation	Namespace for radiation modelling
CabsorptionCoeffs
CabsorptionEmissionModel	Model to supply absorption and emission coefficients for radiation modelling
CbinaryAbsorptionEmission	Radiation coefficient based on two absorption models
CblackBodyEmission	Class black body emission
CboundaryRadiationProperties	Boundary radiation properties holder
CboundaryRadiationPropertiesPatch
CcloudAbsorptionEmission	Retrieves absorption/emission data from a cloud object
CcloudScatter	Cloud radiation scatter model
CconstantAbsorption	Constant radiation transmissivity coefficient
CconstantAbsorptionEmission	Constant radiation absorption and emission coefficients for continuous phase
CconstantScatter	Constant radiation scatter coefficient
CconstantTransmissivity	Constant radiation transmissivity coefficient
CfixedIncidentRadiationFvPatchScalarField	Boundary condition for thermal coupling for solid regions. Used to emulate a fixed incident radiative heat flux on a wall
CFresnel	General Fresnel reflection model bewtween a dialectric and an absorbing medium
CFresnelLaser	Modified Fresnel reflection model
CfvDOM	Finite Volume Discrete Ordinates Method. Solves the RTE equation for n directions in a participating media, not including scatter and reflective walls
CgreyDiffusiveRadiationMixedFvPatchScalarField	This boundary condition provides a grey-diffuse condition for radiation intensity, I, for use with the finite-volume discrete-ordinates model (fvDOM), in which the radiation temperature is retrieved from the temperature field boundary condition
CgreyDiffusiveViewFactorFixedValueFvPatchScalarField	This boundary condition provides a grey-diffuse condition for radiative heat flux, qr, for use with the view factor model
CgreyMeanAbsorptionEmission	GreyMeanAbsorptionEmission radiation absorption and emission coefficients for continuous phase
CgreyMeanSolidAbsorptionEmission	GreyMeanSolidAbsorptionEmission radiation absorption and emission coefficients for solid mixture
ClaserDTRM	Discrete Tray Radiation Method for collimated radiation flux. At the moment the particles are injected on a 2D disk in polar coordinates providing starting and finish locations
ClocalDensityAbsorptionEmission	Constant radiation absorption and emission coefficients for continuous phase
Clookup	Lookup type of boundary radiation properties
CMarshakRadiationFixedTemperatureFvPatchScalarField
CMarshakRadiationFvPatchScalarField
CmixtureFractionSoot	This soot model is purely an state model. The amount of soot produced is determined by a single step chemistry as :
CmultiBandAbsorption	MultiBandAbsorption radiation transmissivity for solids
CmultiBandAbsorptionEmission	MultiBandAbsorptionEmission radiation absorption/emission for solids
CmultiBandTransmissivity	MultiBandTransmissivity radiation transmissivity for solids
CmultiBandZoneAbsorptionEmission	MultiBandZoneAbsorptionEmission radiation absorption/emission for solids
CnoAbsorptionEmission	Dummy absorption-emission model for 'none'
CnoRadiation	No radiation - does nothing to energy equation source terms (returns zeros)
CnoReflection	Dummy scatter model for 'none'
CnoScatter	Dummy scatter model for 'none'
CnoSoot	NoSoot
CopaqueDiffusive	Radiation boundary model for opaque diffusive walls. It requires to specify a wallAbsorptionEmissionModel in boundaryRadiationProperties file
CopaqueReflective	Radiation boundary model for opaque reflective walls. It requires to specify a wallAbsorptionEmissionModel and the reflected fraction in boundaryRadiationProperties file fd is the diffusive reflected fraction. 0 all the incoming flux is specularly reflected and 1 all is diffusive reflected. fd is used in the calculation of the specular reflection (rSpec) and the diffusive reflection (rDiff). Absorptivity and emissivity are independent of fd
CopaqueSolid	Radiation for solid opaque solids - does nothing to energy equation source terms (returns zeros) but creates absorptionEmissionModel and scatterModel
CP1	Works well for combustion applications where optical thickness, tau is large, i.e. tau = a*L > 3 (L = distance between objects)
CradiationModel	Top level model for radiation modelling
CradiativeIntensityRay	Radiation intensity for a ray in a given direction
CreflectionModel	Base class for radiation scattering
CscatterModel	Base class for radiation scattering
CsolarLoad	The solarLoad radiation model includes Sun primary hits, their reflective fluxes and diffusive sky radiative fluxes
CsolidAbsorption	Radiation absorptivity-emissivity model to be used on walls on inter-region patches when the solid opaque radiation model is used in the solid and the wall emissivity and absorptivity are taken from the solid radiation properties
CsootModel	Base class for soor models
Ctransparent	Radiation boundary model for transparent walls. It requires to specify a wallAbsorptionEmissionModel in boundaryRadiationProperties file
CviewFactor	View factor radiation model. The system solved is: C q = b where: Cij = deltaij/Ej - (1/Ej - 1)Fij q = heat flux b = A eb - Ho and: eb = sigma*T^4 Ej = emissivity Aij = deltaij - Fij Fij = view factor matrix
CwallAbsorptionEmissionModel	Based class for wall absorption emission models
CwallTransmissivityModel	Base class for wall transmissivity models
CwideBandAbsorptionEmission	WideBandAbsorptionEmission radiation absorption and emission coefficients for continuous phase
CwideBandDiffusiveRadiationMixedFvPatchScalarField	This boundary condition provides a wide-band, diffusive radiation condition, where the patch temperature is specified
►NRASModels
CbuoyantKEpsilon	Additional buoyancy generation/dissipation term applied to the k and epsilon equations of the standard k-epsilon model
CcontinuousGasKEpsilon	K-epsilon model for the gas-phase in a two-phase system supporting phase-inversion
CEBRSM	Manceau (2015)'s elliptic-blending Reynolds-stress turbulence model for incompressible and compressible flows
CkEpsilon	Standard k-epsilon turbulence model for incompressible and compressible flows including rapid distortion theory (RDT) based compression term
CkEpsilonLopesdaCosta	Variant of the standard k-epsilon turbulence model with additional source terms to handle the changes in turbulence in porous regions represented by the powerLawLopesdaCosta porosity model
CkEpsilonPhitF	The k-epsilon-phit-f turbulence closure model for incompressible and compressible flows
CkineticTheoryModel	Kinetic theory particle phase RAS model
CkL	A one-equation (turbulent kinetic energy k) turbulence closure model for incompressible and compressible geophysical applications
CkOmega	Standard high Reynolds-number k-omega turbulence model for incompressible and compressible flows
CkOmegaSST	Implementation of the k-omega-SST turbulence model for incompressible and compressible flows
CkOmegaSSTLM	Langtry-Menter 4-equation transitional SST model based on the k-omega-SST RAS model
CkOmegaSSTSAS	Scale-adaptive URAS model based on the k-omega-SST RAS model
CkOmegaSSTSato	Implementation of the k-omega-SST turbulence model for dispersed bubbly flows with Sato (1981) bubble induced turbulent viscosity model
CLaheyKEpsilon	Continuous-phase k-epsilon model including bubble-generated turbulence
CLaunderSharmaKE	Launder and Sharma low-Reynolds k-epsilon turbulence model for incompressible and compressible and combusting flows including rapid distortion theory (RDT) based compression term
CLRR	Launder, Reece and Rodi Reynolds-stress turbulence model for incompressible and compressible flows
CmixtureKEpsilon	Mixture k-epsilon turbulence model for two-phase gas-liquid systems
CphasePressureModel	Particle-particle phase-pressure RAS model
CrealizableKE	Realizable k-epsilon turbulence model for incompressible and compressible flows
CRNGkEpsilon	Renormalization group k-epsilon turbulence model for incompressible and compressible flows
CSpalartAllmaras	Spalart-Allmaras one-transport-equation linear-eddy-viscosity turbulence closure model for incompressible and compressible external flows
CSSG	Speziale, Sarkar and Gatski Reynolds-stress turbulence model for incompressible and compressible flows
►NRBD
►Njoints	Namespace for rigid-body joints
Ccomposite	Prismatic joint for translation along the specified arbitrary axis
Cfloating	Prismatic joint for translation along the specified arbitrary axis
Cnull	Null joint for the root-body
CPa	Prismatic joint for translation along the specified arbitrary axis
CPx	Prismatic joint for translation along the x-axis
CPxyz	Prismatic joint for translation in the x/y/z directions
CPy	Prismatic joint for translation along the y-axis
CPz	Prismatic joint for translation along the x-axis
CRa	Revolute joint for rotation about the specified arbitrary axis
CRs	Spherical joint for rotation about the x/y/z-axes using a quaternion (Euler parameters) to avoid gimble-lock
CRx	Revolute joint for rotation about the x-axis
CRxyz	Spherical joint for rotation about the x/y/z-axes using Euler-angles in the order x, y, z
CRy	Revolute joint for rotation about the y-axis
CRyxz	Spherical joint for rotation about the x/y/z-axes using Euler-angles in the order y, x, z
CRz	Revolute joint for rotation about the z-axis
CRzyx	Spherical joint for rotation about the x/y/z-axes using Euler-angles in the order z, y, x
►Nrestraints	Namespace for rigid-body dynamics restraints
CexternalForce	Time-dependent external force restraint using Function1
ClinearAxialAngularSpring	Linear axial angular spring restraint
ClinearDamper	Linear damper restraint. Operates in the local frame of the body
ClinearSpring	Linear spring restraint
CprescribedRotation	Restraint setting angular velocity of the rigid body. Developed from the linear axial angular spring restraint
CsoftWall	Soft wall is a Damper-Linear spring restraint. Acts as a "soft" wall when the distance between 'anchor' and 'refAttachmentPt' in the wallNormal direction becomes negative
CsphericalAngularDamper	Spherical angular damper restraint. Operates in the local frame of the body
►NrigidBodySolvers
CCrankNicolson	Crank-Nicolson 2nd-order time-integrator for 6DoF solid-body motion
CNewmark	Newmark 2nd-order time-integrator for 6DoF solid-body motion
Csymplectic	Symplectic 2nd-order explicit time-integrator for rigid-body motion
CcompositeBody
Ccuboid
►Cjoint	Abstract base-class for all rigid-body joints
CiNew
CXSvc	Joint state returned by jcalc
CjointBody
CmasslessBody
Crestraint	Base class for defining restraints for rigid-body dynamics
CrigidBody
CrigidBodyInertia
CrigidBodyModel	Basic rigid-body model representing a system of rigid-bodies connected by 1-6 DoF joints
CrigidBodyModelState	Holds the motion state of rigid-body model
CrigidBodyMotion	Six degree of freedom motion for a rigid body
CrigidBodySolver
Csphere
CsubBody
►NreactingMultiphaseEuler
►NsurfaceTensionModels
CconstantSurfaceTensionCoefficient
►CalphaContactAngleFvPatchScalarField
CinterfaceThetaProps
CsurfaceTensionModel
►NreactionRateFlameAreaModels
Crelaxation	Consumption rate per unit of flame area obtained from a relaxation equation
►Nreconstruction
CgradAlpha	Reconstructs an interface (centre and normal vector) consisting of planes to match the internal fluid distribution in cells. The interface normals are estimated by least square gradient scheme on the VoF Field (alpha). Also known as Young method
CisoAlpha	Reconstructs an interface (centre and normal vectors) consisting of isosurfaces to match the internal fluid distribution in cells. The point values (ap_) are estimated by inverse distance interpolation of the VoF (alpha) field
CplicRDF	Reconstructs an interface (centre and normal vector) consisting of planes to match the internal fluid distribution in cells. The interface normals are estimated by least square gradient scheme on the RDF function (height). Uses the normal from the previous times step as intial guess
►NregionModels
►NareaSurfaceFilmModels
CcontactAngleForce	Base-class for film contact angle force models
CcurvatureSeparation	Curvature film separation model
CfilmSubModelBase
CfilmTurbulenceModel	Base class for film turbulence models
Cforce	Base class for film (stress-based) force models
CforceList
CinjectionModel	Base class for film injection models, handling mass transfer from the film
CinjectionModelList
CkinematicThinFilm
Claminar	Film laminar turbulence model
CliquidFilmBase
CliquidFilmModel
CperturbedTemperatureDependentContactAngleForce	Temperature dependent contact angle force with a stochastic perturbation
►NpyrolysisModels
CnoPyrolysis	Dummy surface pyrolysis model for 'none'
CpyrolysisModel	Base class for pyrolysis models
CpyrolysisModelCollection	A centralized pyrolysis collection
CreactingOneDim	Reacting, 1-D pyrolysis model NOTE: The moveMesh option can only be applied to solid reaction such as: PMMA -> gas at the moment
Cthermo	Pyrolysis model which solves only the energy equation in the region
►NsurfaceFilmModels
CArrheniusViscosity	The Arrhenius temperature-dependent viscosity model multiplies the viscosity of a base model by an Arrhenius-type temperature function:
CBrunDrippingInjection	Film Dripping mass transfer model
►CconstantFilmThermo	Constant thermo model
CthermoData
CconstantHeatTransfer	Constant heat transfer model
CconstantRadiation	Film constant radiation model. The constant radiative flux is specified by the user, and operated over a time interval defined by a start time and duration. In addition, a mask can be applied to shield the film from the radiation
CconstantViscosity	Constant viscosity model
CcontactAngleForce	Base-class for film contact angle force models
CcurvatureSeparation	Curvature film separation model
CdistributionContactAngleForce	PDF distribution based film contact angle force
CdrippingInjection	Film dripping mass transfer model
CfilmRadiationModel	Base class for film radiation models
CfilmSubModelBase	Base class for surface film sub-models
CfilmThermoModel	Base class for film thermo models
CfilmTurbulenceModel	Base class for film turbulence models
CfilmViscosityModel	Base class for surface film viscosity models
Cforce	Base class for film (stress-based) force models
CforceList	List container for film sources
Cfunction1Viscosity	The Foam::Function1 temperature-dependent viscosity model multiplies the viscosity of a base model by a Function1 temperature function
CheatTransferModel	Base class for film heat transfer models
CinjectionModel	Base class for film injection models, handling mass transfer from the film
CinjectionModelList	List container for film injection models
CkinematicSingleLayer	Kinematic form of single-cell layer surface film model
Claminar	Film laminar turbulence model
CliquidFilmThermo	Liquid thermo model
CliquidViscosity	LiquidViscosity viscosity model
CmappedConvectiveHeatTransfer	Convective heat transfer model based on a re-working of a Nusselt number correlation
CnoFilm	Dummy surfaceFilmModel to allow solvers supporting film simulations to be run without a film region
CnoPhaseChange	Dummy phase change model for 'none'
CnoRadiation	Dummy radiation model for 'none' option
CpatchInjection	Remove and inject the mass in the film as it passes over the selected patches
CperturbedTemperatureDependentContactAngleForce	Temperature dependent contact angle force with a stochastic perturbation
CphaseChangeModel	Base class for surface film phase change models
CprimaryRadiation	Radiation model whereby the radiative heat flux is mapped from the primary region
Csolidification	Solidification phase change model where all film mass is converted when the local temperature > activation temperature. The latent heat is assumed to be removed by heat-transfer to the wall
CstandardPhaseChange	Standard phase change model with modification for boiling
CstandardRadiation	Standard radiation model
CsurfaceFilmRegionModel	Base class for surface film models
CtemperatureDependentContactAngleForce	Temperature dependent contact angle force
CthermocapillaryForce	Thermocapillary force
CthermoSingleLayer	Thermodynamic form of single-cell layer surface film model
CthixotropicViscosity	Thixotropic viscosity model based on the evolution of the structural parameter \( \lambda \):
CtransferModel	Base class for film transfer models, handling mass transfer between the film and the continuous phase
CtransferModelList
CVoFPatchTransfer	Transfer mass between the film and the VoF in the continuous phase
CwaxSolventEvaporation
CwaxSolventViscosity	Wax solvent mixture viscosity model
►NthermalBaffleModels
CnoThermo	Dummy surface pyrolysis model for 'none'
CthermalBaffle	2D thermal baffle
CthermalBaffleModel
CKirchhoffShell
CregionFaModel	Base class for area region models
CregionModel	Base class for region models
CregionModel1D	Base class for 1-D region models
CregionModelFunctionObject	Region model function object base class
CregionModelFunctionObjectList	List of cloud function objects
CsingleLayerRegion	Base class for single layer region models
CsurfaceFilmModel	Base class for surface film models
CthermalShell
CthermalShellModel
CvibrationShellModel
►NrelativeVelocityModels
Cgeneral
Csimple
Nroots
►NsaturationModels
CAntoine	Antoine equation for the vapour pressure
CAntoineExtended	Extended Antoine equation for the vapour pressure
CArdenBuck	ArdenBuck equation for the vapour pressure of moist air
CconstantSaturationConditions	Constant saturation pressure and temperature
Cfunction1	Saturation vapour temperature in terms of the vapour pressure (in Pa). The saturation temperature in Kelvins is specified as a Foam::Function1 type, to enable use of, e.g. constant, polynomial, table values
Cpolynomial	Polynomial equation for the saturation vapour temperature in terms of the vapour pressure (in Pa)
►NsearchableSurfaceModifiers
CautoPatch
Ccut
►NsimplifiedMeshes
CcolumnFvMesh	Generates a 1D column representation of a mesh based on an existing mesh and/or fields
CcolumnFvMeshInfo
ChexCellFvMesh	Generates a single hex cell representation of a mesh
CSimplifiedDynamicFvMesh
CsimplifiedDynamicFvMeshBase
►NsixDoFRigidBodyMotionConstraints	Namespace for six DoF motion constraints
Caxis	Orientation constraint: may only rotate around a fixed axis
Cline	Translation constraint on the centre of rotation: may only move along a line
Corientation	Orientation constraint: fixed in global space
Cplane	Translation constraint on the centre of rotation: may only move on a plane
Cpoint	Translation constraint on the centre of rotation: fixed in space
►NsixDoFRigidBodyMotionRestraints	Namespace for six DoF motion restraints
ClinearAxialAngularSpring	SixDoFRigidBodyMotionRestraints model. Linear axial angular spring
ClinearDamper	SixDoFRigidBodyMotionRestraints model. Linear spring
ClinearSpring	SixDoFRigidBodyMotionRestraints model. Linear spring
ClinearSpringDamper	SixDoFRigidBodyMotionRestraints model. Linear Spring-Damper system
CsoftWall	SixDoFRigidBodyMotionRestraints model. Soft wall
CsphericalAngularDamper	SixDoFRigidBodyMotionRestraints model. Spherical angular damper
CsphericalAngularSpring	SixDoFRigidBodyMotionRestraints model. Spherical angular spring
CtabulatedAxialAngularSpring	SixDoFRigidBodyMotionRestraints model. Axial angular spring with moment values drawn from an interpolation table. Linear damping
►NsixDoFSolvers
CCrankNicolson	Crank-Nicolson 2nd-order time-integrator for 6DoF solid-body motion
CNewmark	Newmark 2nd-order time-integrator for 6DoF solid-body motion
Csymplectic	Symplectic 2nd-order explicit time-integrator for 6DoF solid-body motion
►NsolidBodyMotionFunctions	Namespace for solid-body motions
CaxisRotationMotion	Constant velocity rotation around CoG. Similar to rotatingMotion but motion specified as rotation vector
CdrivenLinearMotion	Variable velocity displacement. The velocity is read from a uniformVectorField from the time registry with the name CofGvelocity
ClinearMotion	SolidBodyMotionFvMesh 6DoF motion function. Constant velocity displacement
CmultiMotion	Combination of SolidBodyMotionFvMesh 6DoF motion functions
CoscillatingLinearMotion	SolidBodyMotionFvMesh 6DoF motion function. Oscillating displacement
CoscillatingRotatingMotion	SolidBodyMotionFvMesh 6DoF motion function. Oscillating rotation
CrotatingMotion	SolidBodyMotionFvMesh 6DoF motion function
CSDA	Ship design analysis (SDA) 3DoF motion function
Ctabulated6DoFMotion	Tabulated 6DoF motion function
►Nspecies
Cthermo
►NSRF	Namespace for single rotating frame (SRF) models
Crpm	Basic SRF model whereby angular velocity is specified in terms of a (global) axis and revolutions-per-minute [rpm]
CSRFModel	Top level model for single rotating frame
►NstringListOps	Various utility functions to work on lists of strings
CfoundOp	Functor to determine if a string is exists in a list of strings
►NstringOps	Collection of static functions for various string-related operations
►Cnatural_sort	Encapsulation of natural order sorting for algorithms
Cgreater	A list compare binary predicate for reverse natural sort
Cless	A list compare binary predicate for natural sort
Creverse	Reverse natural sorting
►NsurfaceFeaturesExtraction	Namespace for run-time selectable surface feature extraction methods
CextractFromFile	Run-time selectable surface feature extraction
CextractFromNone	Run-time selectable surface feature extraction - no extraction. Primarily useful with self-intersection methods
CextractFromSurface	Run-time selectable surface feature extraction - extract from surface
Cmethod	Abstract base for run-time selectable surface feature extraction methods
►NsurfaceTensionModels
Cconstant	Uniform constant surface tension model
CliquidProperties	Temperature-dependent surface tension model in which the surface tension function provided by the phase Foam::liquidProperties class is used
CtemperatureDependent	Temperature-dependent surface tension model
►NsurfaceWriters	Namespace for surface writers
CabaqusWriter	A surface writer for the ABAQUS file format - both surface mesh and fields
CboundaryDataWriter	A surfaceWriter for outputting to a form usable for the timeVaryingMapped boundary condition. This reads the data from constant/boundaryData/<patch> directory
CensightWriter	A surfaceWriter for Ensight format
CfoamWriter	A surfaceWriter for OpenFOAM surfaces
CnastranWriter	A surface writer for the Nastran file format - both surface mesh and fields
CnullWriter	Suppresses output of geometry and fields
CproxyWriter	A surfaceWriter that writes the geometry via the MeshedSurfaceProxy, but which does not support any fields
CrawWriter	A surfaceWriter for raw output
CstarcdWriter	A surfaceWriter for STARCD files
CvtkWriter	A surfaceWriter for VTK legacy (.vtk) or XML (.vtp) format
Cx3dWriter	A surfaceWriter for X3D files
►NswarmCorrections
CnoSwarm
CTomiyamaSwarm	Swarm correction of Tomiyama et al
►NtabulatedWallFunctions
Cgeneral	Computes U+ as a function of Reynolds number by inverting table of y+ vs U+
CSpaldingsLaw	Computes U+ as a function of Reynolds number by inverting Spaldings law
CtabulatedWallFunction	Base class for models that generate tabulated wall function data
►NtemperaturePhaseChangeTwoPhaseMixtures
Cconstant
CinterfaceHeatResistance
►NtetherPotentials
CharmonicSpring
CpitchForkRing
CrestrainedHarmonicSpring
NthermophysicalFunctions
►NTimeScaleModels
Cequilibrium	Equlibrium model for the time scale over which properties of a dispersed phase tend towards the mean value
Cisotropic	Model for the time scale over which the velocity field of a dispersed phase tends towards an isotropic distribution
CnonEquilibrium	Non-Equlibrium model for the time scale over which properties of a dispersed phase tend towards the mean value
►Nturbulence
CIntegralScaleBox	Class to describe the integral-scale container being used in the turbulentDigitalFilterInletFvPatchField boundary condition
►NturbulentDispersionModels
CBurns	Turbulent dispersion model of Burns et al
CconstantTurbulentDispersionCoefficient	Constant coefficient turbulent dispersion model
CGosman	Turbulent dispersion model of Gosman et al
CLopezDeBertodano	Lopez de Bertodano (1992) turbulent dispersion model
CnoTurbulentDispersion
►NupdateablePatchTypes
CupdateableSnGrad
NvectorTools	Collection of functions for testing relationships between two vectors
►NvirtualMassModels
CconstantVirtualMassCoefficient	Constant coefficient virtual mass model
CLamb	Virtual mass model of Lamb
CnoVirtualMass
►NviscosityModels	A namespace for various incompressible viscosityModel implementations
CArrhenius	Arrhenius type of dependency on a given scalar field name. Most likely temperature. The expression is as follow:
CBirdCarreau	An incompressible Bird-Carreau non-Newtonian viscosity model
CCasson	An incompressible Casson non-Newtonian viscosity model
CCrossPowerLaw	An incompressible Cross-Power law non-Newtonian viscosity model
CHerschelBulkley	Herschel-Bulkley non-Newtonian viscosity model
CNewtonian	An incompressible Newtonian viscosity model
CpowerLaw	Standard power-law non-Newtonian viscosity model
CstrainRateFunction	Run-time selected strain-rate function non-Newtonian viscosity model
►Nvtk	Namespace for handling VTK input/output
Nlegacy	Namespace for legacy VTK output constants and functions
►NTools	A collection of static methods to assist converting OpenFOAM data structures into VTK internal data structures
CPatch	Convert OpenFOAM patch to vtkPolyData
CappendBase64Formatter	Appended base-64 encoded binary output. Uses an output filter layer to write base-64 encoded content
CappendRawFormatter	Appended raw binary output
CasciiFormatter	Inline ASCII output. Adds spaces between entries and a newline every 9 items (for consistency with what VTK itself outputs)
Cbase64Formatter	Inline base-64 encoded binary output. Uses an output filter layer to write base-64 encoded content
CCaching	Bookkeeping for internal caching
CcoordSetWriter	Write as points/lines, optionally with fields, as a vtp file or a legacy vtk file
CfileWriter	Base class for VTK output writers that handle geometry and fields (eg, vtp, vtu data). These output formats are structured as DECLARED, FIELD_DATA, PIECE followed by any CELL_DATA or POINT_DATA
CfoamVtkBase64Layer	Base-64 encoded output layer - normally only used indirectly by formatters
Cformatter	Abstract class for a VTK output stream formatter
CGenericPatchGeoFieldsWriter	A Foam::vtk::GenericPatchWriter with support for geometric fields
CGenericPatchWriter	Write concrete PrimitivePatch faces/points (optionally with fields) as a vtp file or a legacy vtk file. The patch type is limited to representations of polygon faces and 3D points and must support the following methods:
CinternalMeshWriter	Write an OpenFOAM volume (internal) geometry and internal fields as a vtu file or a legacy vtk file
CinternalWriter	Write an OpenFOAM volume (internal) geometry and internal fields as a vtu file or a legacy vtk file
ClagrangianWriter	Write lagrangian (cloud) positions and fields (as PointData) in VTP format. Legacy VTK format is intentionally not supported since the VTP format provides much better field selection in ParaView, and for consistency with the Foam::functionObjects::vtkCloud function object
ClegacyAsciiFormatter	Formatting as per Foam::vtk::asciiFormatter, but with naming for legacy output
ClegacyRawFormatter	Binary output for the VTK legacy format, always written as big-endian and with 32-bit integers
ClineWriter	Write edge/points (optionally with fields) as a vtp file or a legacy vtk file
CoutputOptions	Encapsulated combinations of output format options. This is primarily useful when defining the output type based on some command-line arguments or dictionary contents. However, it can also be a useful alternative to using the underlying enumeration directly, since this class provides additional methods not possible with an enum
CpatchMeshWriter	Write OpenFOAM patches and patch fields in VTP or legacy vtk format
CpatchWriter	Write OpenFOAM patches and patch fields in VTP or legacy vtk format
CpolyWriter	Write faces/points (optionally with fields) as a vtp file or a legacy vtk file
CseriesWriter	Provides a means of accumulating and generating VTK file series
CsurfaceFieldWriter	Write surfaces fields (as PointData) in VTP format. Legacy VTK format is intentionally not supported
CsurfaceWriter	Write faces/points (optionally with fields) as a vtp file or a legacy vtk file
CvtmWriter	Provides a means of accumulating file entries for generating a vtkMultiBlockDataSet (.vtm) file
CvtuAdaptor	Bookkeeping for vtkUnstructuredGrid
CvtuCells	A deep-copy description of an OpenFOAM volume mesh in data structures suitable for VTK UnstructuredGrid, including the possibility of decomposing polyhedral cells into primitive cell types
CvtuSizing	Sizing descriptions and routines for transcribing an OpenFOAM volume mesh into a VTK unstructured grid, with possible decomposition of polyhedral cells into primitive cell types
►NwallBoilingModels
►NCHFModels
CHuaXu	A critical heat flux (CHF) sub-cooling correlation model based on Hua-Xu (2000) for boiling flows
CJeschar
CTatsumoto	A critical heat flux (CHF) sub-cooling correlation model
CZuber	A critical heat flux (CHF) correlation model based on Zuber (1958) for boiling flows
►NdepartureDiameterModels
CKocamustafaogullariIshii	A correlation for bubble departure diameter modelling based on Kocamustafaogullari-Ishii (1983) for boiling flows
CTolubinskiKostanchuk	A correlation for bubble departure diameter modelling based on Tolubinski-Kostanchuk (1970) for boiling flows
►NdepartureFrequencyModels
CCole	A correlation for bubble departure frequency modelling based on Cole (1960) for boiling flows
►NfilmBoilingModels
CBreenWestwater	Boiling film correlation. A correlation for boiling film modelling based on Breen & Westwater (1965) for boiling flows
CBromley	A correlation for boiling film modelling based on Bromley (1950) for boiling flows
►NLeidenfrostModels
CSpiegler	A model for Leidenfrost effects based on Spiegler et al. (1963) for boiling flows
►NnucleateFluxModels
Cexponential	Nucleate flux sub-cooling correlation
CKutadeladze	Nucleate flux sub-cooling correlation
►NnucleationSiteModels
CLemmertChawla	A model for nucleation site density based on Lemmert-Chawla (1977) function and Egorov-Menter (2004) correlation for boiling flows
►NpartitioningModels
Ccosine	A cosine model for wall heat flux partitioning based on Tentner et al. (2006) for boiling flows
CLavieville	A model for wall heat flux partitioning based on Lavieville et al. (2006) for boiling flows
Clinear	A linear model for wall heat flux partitioning based on Ioilev et al. (2007) for boiling flows
CphaseFraction	Wall heat-flux partitioned according to the phase volume fraction
►NTDNBModels
CSchroeder	A model for departure from nucleation boiling based on Schroeder-Richter and Bartsch (1994) for boiling flows
CShirai	Temperature of departure from nulceate boiling correlation
CCHFModel	Base class for critical heat flux (CHF) correlation models for boiling flows
CCHFSubCoolModel
CdepartureDiameterModel	Base class for bubble departure diameter models for boiling flows
CdepartureFrequencyModel	Base class for bubble departure frequency models for boiling flows
CfilmBoilingModel
CLeidenfrostModel	Base class for Leidenfrost-effect models
CMHFModel
CnucleateFluxModel	Base class for nucleation flux models
CnucleationSiteModel	Base class for nucleation site density models
CpartitioningModel	Base class for wall heat flux partitioning models
CTDNBModel	Base class for departure from nucleation boiling models
►NwallDampingModels
Ccosine
Cinterpolated
Clinear
CnoWallDamping
Csine
►NwallLubricationModels
CAntal	Wall lubrication model of Antal et al
CFrank	Wall lubrication model of Frank
CnoWallLubrication
CTomiyamaWallLubrication	Wall lubrication model of Tomiyama
►NwaveModels
CBoussinesq	Boussinesq wave model
Ccnoidal	Cnoidal wave model
CGrimshaw	Grimshaw wave model
CirregularMultiDirectional	Multi-directional irregular wave model
CirregularWaveModel
CMcCowan	McCowan wave model
CregularWaveModel
CshallowWaterAbsorption
CsolitaryWaveModel
CStokesI	Stokes I wave model
CStokesII	Stokes II wave model
CStokesV	Stokes V wave model
CstreamFunction	StreamFunction wave model
CwaveAbsorptionModel
CwaveGenerationModel
►NwindowModels
CHanning	Hanning window
Cuniform	A window that applies uniform scaling
►NXiEqModels
CbasicSubGrid	Basic sub-grid obstacle flame-wrinkling enhancement factor model. Details supplied by J Puttock 2/7/06
CGulder	Simple Gulder model for XiEq based on Gulders correlation with a linear correction function to give a plausible profile for XiEq
Cinstability	This is the equilibrium level of the flame wrinkling generated by instability. It is a constant (default 2.5). It is used in XiModel.H
CSCOPEBlend	Simple SCOPEBlendXiEq model for XiEq based on SCOPEXiEqs correlation with a linear correction function to give a plausible profile for XiEq. See SCOPELaminarFlameSpeed.H for details on the SCOPE laminar flame speed model
CSCOPEXiEq	Simple SCOPEXiEq model for XiEq based on SCOPEXiEqs correlation with a linear correction function to give a plausible profile for XiEq. See SCOPELaminarFlameSpeed.H for details on the SCOPE laminar flame speed model
►NXiGModels
CbasicSubGrid	Basic sub-grid obstacle flame-wrinkling generation rate coefficient model. Details supplied by J Puttock 2/7/06
CinstabilityG	Flame-surface instabilityG flame-wrinkling generation rate coefficient model used in XiModel.H
CKTS	Simple Kolmogorov time-scale (KTS) model for the flame-wrinling generation rate
►NXiModels
Calgebraic	Simple algebraic model for Xi based on Gulders correlation with a linear correction function to give a plausible profile for Xi. See report TR/HGW/10 for details on the Weller two equations model. See XiModel.H for more details on flame wrinkling modelling
Cfixed	Fixed value model for Xi. See XiModel.H for more details on flame wrinkling modelling
Ctransport	Simple transport model for Xi based on Gulders correlation with a linear correction function to give a plausible profile for Xi. See report TR/HGW/10 for details on the Weller two equations model. See XiModel.H for more details on flame wrinkling modelling
CAABBTree	Templated tree of axis-aligned bounding boxes (AABB)
CabsoluteEnthalpy	Thermodynamics mapping class to expose the absolute enthalpy functions
CabsoluteInternalEnergy	Thermodynamics mapping class to expose the absolute internal energy functions
CaC10H7CH3	AlphaMethylNaphthalene
CaccessOp
CacousticWaveTransmissiveFvPatchField	This boundary condition provides a wave transmissive outflow condition, based on solving DDt(W, field) = 0 at the boundary W is the wave velocity and field is the field to which this boundary condition is applied. The wave speed is input in the BC
CactiveBaffleVelocityFvPatchVectorField	This velocity boundary condition simulates the opening of a baffle due to local flow conditions, by merging the behaviours of wall and cyclic conditions. The baffle joins two mesh regions, where the open fraction determines the interpolation weights applied to each cyclic- and neighbour-patch contribution
CactivePressureForceBaffleVelocityFvPatchVectorField	This boundary condition is applied to the flow velocity, to simulate the opening or closure of a baffle due to area averaged pressure or force delta, between both sides of the baffle. This is achieved by merging the behaviours of wall and cyclic baffles
CadaptiveLinear	Produces a linear ramp which adapts its gradient to changes in endTime and deltaT to always arrive at the relaxationEnd value at the end of the run
CadaptiveSolver
CaddcommsTypeToOpt
CaddPatchCellLayer	Adds layers of cells to outside of polyPatch. Can optionally create stand-alone extruded mesh (addToMesh=false)
CaddstopAtWriteNowSignalToOpt
CaddwriteNowSignalToOpt
CadiabaticPerfectFluid	Adiabatic perfect fluid equation of state
CadjointBoundaryCondition	Base class for solution control classes
CadjointFarFieldNuaTildaFvPatchScalarField
CadjointFarFieldPressureFvPatchScalarField
CadjointFarFieldTMVar1FvPatchScalarField
CadjointFarFieldTMVar2FvPatchScalarField
CadjointFarFieldVelocityFvPatchVectorField
CadjointInletNuaTildaFvPatchScalarField	Inlet boundary for adjoint nuaTilda
CadjointInletVelocityFvPatchVectorField
CadjointOutletFluxFvPatchField
CadjointOutletFluxFvPatchScalarField
CadjointOutletKaFvPatchScalarField
CadjointOutletNuaTildaFluxFvPatchScalarField
CadjointOutletNuaTildaFvPatchScalarField
CadjointOutletPressureFvPatchScalarField
CadjointOutletVelocityFluxFvPatchVectorField	An outlet boundary condition for patches in which the primal flow exhibits recirculation. Adds the contribution of the objective as an adjoint momentum flux directly to the PDEs, without the need to first compute an adjoint outlet velocity, circumventing thus the division with (almost) zero that manifests in case of primal flow recirculation
CadjointOutletVelocityFvPatchVectorField	Provides the adjoint outlet velocity values (i.e. adjoint velocity in case of a zeroGradient U boundary condition). Can have stability issues in cases of backflow of the primal velocity. The adjointOutletVelocityFlux should preferably be used
CadjointOutletWaFvPatchScalarField
CadjointRotatingWallVelocityFvPatchVectorField	The same as adjointWallVelocity but additionally computes the sensitivity contribution emerging from the change in the positions of the face centres, in case rotatingWallVelocity is used for the flow simulation
CadjointSimple	Solution of the adjoint PDEs for incompressible, steady-state flows
CadjointSolver	Base class for adjoint solvers
CadjointSolverManager	Class for managing adjoint solvers, which may be more than one per operating point
CadjointWallVelocityFvPatchVectorField	Adjoint wall velocity boundary condition. If nutUSpaldingWallFunction is employed in the flow solution, the corresponding adjoint wall function is used. Otherwise, the typical low-Re boundary condition is applied
CadjointWallVelocityLowReFvPatchVectorField
CadjointZeroInletFvPatchField
CadvancingFrontAMI	Base class for Arbitrary Mesh Interface (AMI) methods
CadvectiveFvPatchField	This boundary condition provides an advective outflow condition, based on solving DDt(W, field) = 0 at the boundary where W is the wave velocity and field is the field to which this boundary condition is applied
CalgebraicPairGAMGAgglomeration	Agglomerate using the pair algorithm
►CalphaContactAngleFvPatchScalarField	Contact-angle boundary condition for multi-phase interface-capturing simulations. Used in conjunction with multiphaseSystem
CinterfaceThetaProps
CalphaContactAngleTwoPhaseFvPatchScalarField	Abstract base class for two-phase alphaContactAngle boundary conditions
CalphaFixedPressureFvPatchScalarField	A fixed-pressure alphaContactAngle boundary
CAMIInterpolation	Interpolation class dealing with transfer of data between two primitive patches with an arbitrary mesh interface (AMI)
CAmultiplier
CandEqOp
CandEqOp2
CandOp
CandOp2
CangularOscillatingDisplacementPointPatchVectorField	Foam::angularOscillatingDisplacementPointPatchVectorField
CangularOscillatingVelocityPointPatchVectorField	Foam::angularOscillatingVelocityPointPatchVectorField
CAnisothermalPhaseModel	Class which represents a phase for which the temperature (strictly energy) varies. Returns the energy equation and corrects the thermodynamic model
CanisotropicFilter	Anisotropic filter
CAPIdiffCoefFunc	API function for vapour mass diffusivity
CAr	Liquid Ar
CareaMesh	Mesh data needed to do the Finite Area discretisation
CareaWrite	Write finite area mesh/fields to standard output formats
CargList	Extract command arguments and options from the supplied argc and argv parameters
CArmijoConditions	Class satisfying the Armijo line search conditions
CarraySet	Specifies an x,y,z array of uniformly distributed sampling points
CArrheniusReactionRate	Arrhenius reaction rate given by:
Cash	Coal ash solid properties
CaspectRatioModel
CassemblyFaceAreaPairGAMGAgglomeration	Agglomerate using the pair algorithm
CAssemblyFvPatch	An assembly of lduMatrix that is specific inter-region coupling through mapped patches
CATCModel	Base class for selecting the adjoint transpose convection model. Inherits from regIOobject to add lookup functionality
CATCstandard	The ATC formualtion resulting by differentiating the Non-conservative form of the momentum equations
CATCUaGradU	The ATC formualtion resulting by differentiating the Conservative form of the Momentum equations
CatmAlphatkWallFunctionFvPatchScalarField	This boundary condition provides a wall constraint on the kinematic turbulent thermal conductivity (i.e. alphat) for atmospheric boundary layer modelling. It assumes a logarithmic distribution of the potential temperature within the first cell
CatmBoundaryLayer	Base class to set log-law type ground-normal inlet boundary conditions for wind velocity and turbulence quantities for homogeneous, two-dimensional, dry-air, equilibrium and neutral atmospheric boundary layer (ABL) modelling
CatmBoundaryLayerInletEpsilonFvPatchScalarField	This boundary condition provides a log-law type ground-normal inlet boundary condition for the turbulent kinetic energy dissipation rate (i.e. epsilon) for homogeneous, two-dimensional, dry-air, equilibrium and neutral atmospheric boundary layer modelling
CatmBoundaryLayerInletKFvPatchScalarField	This boundary condition provides a log-law type ground-normal inlet boundary condition for the turbulent kinetic energy (i.e. k) for homogeneous, two-dimensional, dry-air, equilibrium and neutral atmospheric boundary layer modelling
CatmBoundaryLayerInletOmegaFvPatchScalarField
CatmBoundaryLayerInletVelocityFvPatchVectorField	This boundary condition provides a log-law type ground-normal inlet boundary condition for the streamwise component of wind velocity (i.e. u) for homogeneous, two-dimensional, dry-air, equilibrium and neutral atmospheric boundary layer modelling
CatmEpsilonWallFunctionFvPatchScalarField	This boundary condition provides a wall constraint on the turbulent kinetic energy dissipation rate (i.e. epsilon) and the turbulent kinetic energy production contribution (i.e. G) for atmospheric boundary layer modelling
CatmNutkWallFunctionFvPatchScalarField	This boundary condition provides a wall constraint on the turbulent viscosity (i.e. nut) based on the turbulent kinetic energy (i.e. k) for atmospheric boundary layer modelling. It is designed to be used in conjunction with the atmBoundaryLayerInletVelocity boundary condition
CatmNutUWallFunctionFvPatchScalarField	This boundary condition provides a wall constraint on the turbulent viscosity (i.e. nut) based on velocity (i.e. U) for atmospheric boundary layer modelling. It is designed to be used in conjunction with the atmBoundaryLayerInletVelocity boundary condition
CatmNutWallFunctionFvPatchScalarField	This boundary condition provides a wall constraint on the turbulent viscosity (i.e. nut) based on the turbulent kinetic energy (i.e. k) and velocity (i.e. U) for atmospheric boundary layer modelling
CatmOmegaWallFunctionFvPatchScalarField	This boundary condition provides a wall constraint on the specific dissipation rate (i.e. omega) and the turbulent kinetic energy production contribution (i.e. G) for atmospheric boundary layer modelling
CatmTurbulentHeatFluxTemperatureFvPatchScalarField	This boundary condition provides a fixed heat constraint on temperature (i.e. T) to specify temperature gradient through an input heat source which can either be specified as absolute power [W], or as flux [W/m2]
►CatomicWeightTable	A table of atomic weights for all the elements
CatomicWeight	Structure to hold the element name and atomic weight pair
CAtomizationModel	Templated atomization model class
CattachDetach	Attach/detach boundary mesh modifier. This modifier takes a set of internal faces and converts them into boundary faces and vice versa based on the given activation switch
CattachPolyTopoChanger	This class is derived from polyMesh and serves as a tool for statically connecting pieces of a mesh by executing the mesh modifiers and cleaning the mesh
CautoDensity	Choose random points inside the domain and place them with a probability proportional to the target density of points
Cautomatic
CautoPtr	Pointer management similar to std::unique_ptr, with some additional methods and type checking
CaverageNeighbourFvGeometryScheme	Geometry calculation scheme to minimise non-orthogonality/
CAveragingMethod	Base class for lagrangian averaging methods
CaxisAligned	Defines control points aligned with coordinate system
CbackgroundMeshDecomposition	Store a background polyMesh to use for the decomposition of space and queries for parallel conformalVoronoiMesh
CbadQualityToCell	Selects bad quality cells (using snappyHexMesh/cvMesh mesh quality selector)
CbadQualityToFace	Selects bad quality faces (using snappyHexMesh/cvMesh mesh quality selector)
CbarotropicCompressibilityModel	Abstract class for barotropic compressibility models
CBarycentric	Templated 3D Barycentric derived from VectorSpace. Has 4 components, one of which is redundant
CBarycentric2D	Templated 2D Barycentric derived from VectorSpace. Has 3 components, one of which is redundant
CBarycentricTensor	Templated 4x3 tensor derived from VectorSpace. Has 12 components. Can represent a barycentric transformation as a matrix-barycentric inner- product. Can alternatively represent an inverse barycentric transformation as a vector-matrix inner-product
Cbase64Layer	An output filter layer to write base-64 encoded content
CbaseIOdictionary	BaseIOdictionary is derived from dictionary and IOobject to give the dictionary automatic IO functionality via the objectRegistry
CBasicChemistryModel	Basic chemistry model templated on thermodynamics
CbasicChemistryModel	Base class for chemistry models
CbasicCombustionMixture	Specialization of the basicSpecieMixture for combustion
CbasicFvGeometryScheme	Default geometry calculation scheme. Slight stabilisation for bad meshes
CbasicMixture	Foam::basicMixture
CbasicMultiComponentMixture	Multi-component mixture
CbasicSolidChemistryModel	Chemistry model for solid thermodynamics
CbasicSpecieMixture	Specialization of basicMultiComponentMixture for a mixture consisting of a number for molecular species
CbasicSymmetryFaPatchField	A symmetry patch
CbasicSymmetryFvPatchField	A symmetry patch
CbasicSymmetryPointPatchField	A Symmetry boundary condition for pointField
CbasicThermo	Abstract base-class for fluid and solid thermodynamic properties
CbC10H7CH3	BetaMethylNaphthalene
CBezier	Calculation of adjoint based sensitivities for Bezier control points
CBFGS	The quasi-Newton BFGS formula
CBiIndirectList	Indexes into negList (negative index) or posList (zero or positive index)
CbiLinearFitPolynomial	BiLinear polynomial for interpolation fitting
CBinaryCollisionModel	Templated DSMC particle collision class
CbinaryNode	Node of the binary tree
CbinaryTree	Data storage of the chemistryOnLineLibrary according to a binary tree structure
CbinModel	Base class for bin models to handle general bin characteristics
CBinSum	Sums into bins
Cbisection	Reduces step by a given ratio
CbitAndEqOp
CbitAndEqOp2
CbitAndOp
CbitAndOp2
CbitAndOp3
CbitOrEqOp
CbitOrEqOp2
CbitOrOp
CbitOrOp2
CbitOrOp3
►CbitSet	A bitSet stores bits (elements with only two states) in packed internal format and supports a variety of bit-set operations. Its behaviour is largely list-like, with some HashSet features
Cconst_iterator	A const_iterator for iterating across on values
Creference	A reference supporting read/write access to an entry
CbitXorEqOp
CbitXorEqOp2
CbitXorOp
CbitXorOp2
CbitXorOp3
CbladeModel	Blade model class calculates:
Cblended	Linear/upwind blended differencing scheme
CblendedEdgeInterpolation	Linear/upwind blended differencing scheme
CblendedInterfacialModel
CBlendedInterfacialModel
CblendedSchemeBase	Base class for blended schemes to provide access to the blending factor surface field
CblendingMethod
CBlobsSheetAtomization	Primary Breakup Model for pressure swirl atomizers
►Cblock	Creates a single block of cells from point coordinates, numbers of cells in each direction and an expansion ratio
CiNew	Class used for the read-construction of
CblockDescriptor	Takes the description of the block and the list of curved edges and creates a list of points on edges together with the weighting factors
►CblockEdge	Define a curved edge that is parameterized for 0<lambda<1 between the start/end points
CiNew	Class used for the read-construction of
►CblockFace	Define a curved face
CiNew	Class used for the read-construction of
CblockMesh	A multi-block mesh generator
►CblockVertex	Define a block vertex
CiNew	Class used for the read-construction of
CbodyCentredCubic	Generate a BCC lattice of points inside the surfaces to be conformed to of the conformalVoronoiMesh
CbooleanSurface	Surface-surface intersection. Given two surfaces construct combined surface
CboolVector	Specialized bundling of boolean values as a vector of 3 components, element access using x(), y() and z() member functions. It also has some methods similar to bitSet
CboundaryAdjointContribution	Abstract base class for computing contributions of the objective functions to the adjoint boundary conditions
CboundaryAdjointContributionIncompressible	Contributions of objective function differentiation to adjoint boundary conditions for incompressible flows
CboundaryCutter	Does modifications to boundary faces
CboundaryInfo	Class to interrogate the polyMesh/boundary file to provide mesh patching information, without the need to read the mesh
CboundaryMesh	Addressing for all faces on surface of mesh. Can either be read from polyMesh or from triSurface. Used for repatching existing meshes
CboundaryPatch	Like polyPatch but without reference to mesh. Used in boundaryMesh to hold data on patches. The patchIdentifier::index is set, but not used
CboundaryRegion	The boundaryRegion persistent data saved as a Map<dictionary>
CboundarySourcePatch	Pure virtual class for sources on cells next to patches
CboundaryTemplates	Class to store boundary template specifications
CboundaryToCell	A topoSetCellSource to select all cells possessing at least a single face on all external boundaries
CboundaryToFace	A topoSetFaceSource to select faces on all external boundaries
CboundBox	A bounding box defined in terms of min/max extrema points
CBoussinesq	Incompressible gas equation of state using the Boussinesq approximation for the density as a function of temperature only:
CboxToCell	A topoSetCellSource to select all cells whose cell centre inside given bounding box(es)
CboxToFace	A topoSetFaceSource to select all faces whose face centre inside given bounding box(es)
CboxToPoint	A topoSetPointSource to select all points based on whether they are inside given bounding box(es)
CBreakupModel	Templated break-up model class
CBrownianMotionForce	Calculates particle Brownian motion force
CBSpline	An implementation of B-splines
CbufferedAccumulator
CC	Graphite solid properties
CC10H22	NDecane
CC12H26	NDodecane
CC13H28	NTriDecane
CC14H30	NTetraDecane
CC16H34	NHexaDecane
CC2H5OH	Ethanol
CC2H6	Ethane
CC2H6O	DiMethylEther
CC3H6O	Acetone
CC3H8	Propane
CC4H10O	DiEthylEther
CC6H14	NHexane
CC6H6	Benzene
CC7H16	NHeptane
CC7H8	Toluene
CC8H10	EthylBenzene
CC8H18	NOctane
CC9H20	NNonane
CCaCO3	Calcium carbonate (limestone)
CcalculatedFaePatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CcalculatedFaPatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CcalculatedFvPatchField	This boundary condition is not designed to be evaluated; it is assmued that the value is assigned via field assignment, and not via a call to e.g. updateCoeffs or evaluate
CcalculatedFvsPatchField	Foam::calculatedFvsPatchField
CcalculatedPointPatchField	A calculated boundary condition for pointField
CcalculatedProcessorFvPatchField	A processorFvPatchField type bypassing fvPatch
CcalculatedProcessorGAMGInterface	GAMG agglomerated processor interface
CcalculatedProcessorGAMGInterfaceField	GAMG agglomerated processor interface field
CCallback	Abstract class to handle automatic call-back registration with the CallbackRegistry. Derive from this class and extend by adding the appropriate callback functions
CCallbackRegistry	Base class with which callbacks are registered
CcancelATC	Return a zero ATC field. Seriously influences computed sensitivities
CcaseInfo	Class to hold information related to the simaulation case
CCatmullRomSpline	An implementation of Catmull-Rom splines (sometimes known as Overhauser splines)
CCECCellToCellStencil
CCECCellToFaceStencil	Combined corresponding cellToCellStencil of owner and neighbour
CceilOp
CceilOp< Scalar >	Round scalar upwards - functor version of std::ceil
Ccell	A cell is defined as a list of faces with extra functionality
CcellAspectRatio	(Rough approximation of) cell aspect ratio
CcellAspectRatioControl
CcellBitSet	A special purpose topoSet with the cell labels stored as a bitSet. It does not correspond to a cellSet either (no associated IOobject)
CcellCellStencil	Calculation of interpolation stencils
CcellCellStencilObject
CcellCentreSet	A sampleSet based on cell centres
CcellClassification	'Cuts' a mesh with a surface
CcellCoBlended	Two-scheme cell-based Courant number based blending differencing scheme
CcellCuts	Description of cuts across cells
CcellDistFuncs	Collection of functions used in wall distance calculation
CcellFeatures	Cell analysis class
CcellInfo	Holds information regarding type of cell. Used in inside/outside determination in cellClassification
CcellLooper	Abstract base class. Concrete implementations know how to cut a cell (i.e. determine a loop around the circumference)
CcellMapper	This object provides mapping and fill-in information for cell data between the two meshes after the topological change. It is constructed from mapPolyMesh
CcellMatcher	Base class for cellshape matchers (hexMatch, prismMatch, etc.). These are classes which given a mesh and cell number find out the orientation of the cellShape and construct cell-vertex to mesh-vertex mapping and cell-face to mesh-face mapping
CcellModel	Maps a geometry to a set of cell primitives
CcellModeller
CcellMotionFvPatchField	Foam::cellMotionFvPatchField
CcellPointWeight	Foam::cellPointWeight
CcellPointWeightWallModified	Foam::cellPointWeightWallModified
CcellQuality	Class calculates cell quality measures
CcellSet	A collection of cell labels
CcellShape	An analytical geometric cellShape
CcellShapeControl
CcellShapeControlMesh
CcellSizeAndAlignmentControl
CcellSizeAndAlignmentControls
CcellSizeCalculationType	Abstract base class for specifying target cell sizes
CcellSizeFunction	Abstract base class for specifying target cell sizes
CcellSplitter	Does pyramidal decomposition of selected cells. So all faces will become base of pyramid with as top a user-supplied point (usually the cell centre)
CcellTable	The cellTable persistent data saved as a Map<dictionary>
CcellToCell	A topoSetCellSource to select all the cells from given cellSet(s)
CcellToCellStencil	Baseclass for extended cell centred addressing. Contains per cell a list of neighbouring cells and/or boundaryfaces in global addressing
CcellToFace	A topoSetFaceSource to select all the faces from given cellSet(s)
CcellToFaceStencil	Base class for extended cell-to-face stencils (face values from neighbouring cells)
CcellToPoint	A topoSetPointSource to select all the points from given cellSet(s)
CcellVolumeWeightMethod	Cell-volume-weighted mesh-to-mesh interpolation class
CcellZone	A subset of mesh cells
CCellZoneInjection	Injection positions specified by a particle number density within a cell set
CcellZoneSet	Like cellSet but -reads data from cellZone -updates cellZone when writing
CcentredCECCellToCellStencilObject
CcentredCECCellToFaceStencilObject
CcentredCFCCellToCellStencilObject
CcentredCFCCellToFaceStencilObject
CcentredCFCFaceToCellStencilObject
CcentredCPCCellToCellStencilObject
CcentredCPCCellToFaceStencilObject
CcentredFECCellToFaceStencilObject
CCentredFitData	Data for the quadratic fit correction interpolation scheme
CCentredFitScheme	Centred fit surface interpolation scheme which applies an explicit correction to linear
CCentredFitSnGradData	Data for centred fit snGrad schemes
CCFCCellToCellStencil
CCFCCellToFaceStencil	Combined corresponding cellToCellStencil of owner and neighbour
CCFCFaceToCellStencil
CCH3OH	Methanol
CCH4N2O	Urea, note that some of the properties are unavailable in the literature and have been copied from water
CchannelIndex	Does averaging of fields over layers of cells. Assumes layered mesh
CChemicallyActivatedReactionRate	General class for handling chemically-activated bimolecular reactions
CChemistryCombustion	Chemistry model wrapper for combustion models
CchemistryReader	Abstract class for reading chemistry
CchemistryReductionMethod	An abstract class for methods of chemical mechanism reduction
CchemistrySolver	An abstract base class for solving chemistry
CchemistryTabulationMethod	An abstract class for chemistry tabulation
CchemkinReader	Foam::chemkinReader
CchemPointISAT	Leaf of the binary tree. The chemPoint stores the composition 'phi', the mapping of this composition Rphi, the mapping gradient matrix A and the matrix describing the Ellipsoid Of Accuracy (EOA)
CcircleSet	Samples along a circular path
►CCircularBuffer	A simple list of objects of type <T> that is intended to be used as a circular buffer (eg, a FIFO) when the alloc/free overhead associated with a linked-list approach is to be avoided
Cconst_iterator	A simple forward const iterator for a circular buffer
CCirculator	Walks over a container as if it were circular. The container must have the following members defined:
CCirculatorBase	Template-invariant parts for circulators
CCirculatorIters	A pair of begin/end iterators used for implementing circular iteration
CclampedPlateFaPatchField	This BC provides a clamped BC. It sets zero fixe value and zeroGradient
CclipEqOp	Clip value and assign inplace
CclipOp	Return the value after clipping by the min/max limiter
CclippedLinear	Central-differencing interpolation scheme using clipped-weights to improve stability on meshes with very rapid variations in cell size
Cclock	Read access to the system clock with formatting
CclockTime	Starts timing and returns elapsed time from start. Uses std::chrono::high_resolution_clock for better resolution (2uSec instead of ~20mSec) than cpuTime
CclockValue	Access to high-resolution clock value with some basic operations. Used to calculate time durations, elapsed times etc
CclosedTriSurfaceMesh	A triSurfaceMesh where it is forced to check volumeTypes, used for surfaces that are topologically non-manifold (small holes or multiple parts) but are geometrically essentially closed
Ccloud	A cloud is a registry collection of lagrangian particles
CCloud	Base cloud calls templated on particle type
CCloudFunctionObject	Templated cloud function object base class
CCloudFunctionObjectList	List of cloud function objects
CcloudSet	Samples at arbitrary locations with a volume mesh
CcloudSolution	Stores all relevant solution info for cloud
CCloudSubModelBase	Base class for cloud sub-models
CcmptDivideOp
CcmptDivideOp2
CcmptDivideOp3
CcmptMultiplyOp
CcmptMultiplyOp2
CcmptMultiplyOp3
CcmptPowOp
CcmptPowOp2
CcmptPowOp3
CcoalCloudList
CCoBlended	Two-scheme Courant number based blending differencing scheme
CcodedBase	Base class for function objects and boundary conditions using dynamic code that provides methods for managing loading/unloading/updating of a dynamic library. For these purposes, it uses a dynamicCodeContext object to maintain information about the state
CcodedFixedValueFvPatchField	Constructs on-the-fly a new boundary condition (derived from fixedValueFvPatchField) which is then used to evaluate
CcodedFixedValuePointPatchField	Constructs on-the-fly a new boundary condition (derived from fixedValuePointPatchField) which is then used to evaluate
CcodedMixedFvPatchField	Constructs on-the-fly a new boundary condition (derived from mixedFvPatchField) which is then used to evaluate
CcodedPoints0MotionSolver	Provides a general interface to enable dynamic code compilation of mesh motion solvers
CCollidingCloud	Adds coolisions to kinematic clouds
►CCollidingParcel	Wrapper around kinematic parcel types to add collision modelling
CconstantProperties	Class to hold thermo particle constant properties
CiNew	Factory class to read-construct particles used for
CCollisionModel	Templated collision model class
CCollisionRecordList
CcolourTable	Base class for generating a colour table from node points
Ccombine
CcombineConstraintsEqOp	Reduce operator
CcombineEqOp	Reduction class. If x and y are not equal assign value
CcombineFaces	Combines boundary faces into single face. The faces get the patch of the first face ('the master')
CcombineReduceFileStates	Combine operator for PackedList of fileState
CcombustionModel	Base class for combustion models
CCombustionModel	Combustion models for templated thermodynamics
CcommSchedule	Determines the order in which a set of processors should communicate with one another
CCompactIOField	A Field of objects of type <T> with automated input and output using a compact storage. Behaves like IOField except when binary output in case it writes a CompactListList
CCompactIOList	A List of objects of type <T> with automated input and output using a compact storage. Behaves like IOList except when binary output in case it writes a CompactListList
CCompactListList	A packed storage unstructured matrix of objects of type <T> using an offset table for access
CCompactSpatialTensor	Templated 3D compact spatial tensor derived from MatrixSpace used to represent transformations of spatial vectors and the angular and linear inertia of rigid bodies
CCompactSpatialTensorT	Templated 3D transposed compact spatial tensor derived from MatrixSpace used to represent transformations of spatial vectors of rigid bodies
CcompareOp	Three-way comparison operation of two parameters,
CcompareOp< Scalar >	Compare scalar values
Ccomplex	A complex number, similar to the C++ complex type
CcomponentDisplacementMotionSolver	Virtual base class for displacement motion solver
CcomponentVelocityMotionSolver	Virtual base class for velocity motion solver
CCompositionModel	Templated reacting parcel composition model class Consists of carrier species (via thermo package), and additional liquids and solids
CcompressibleInterPhaseTransportModel	Transport model selection class for the compressibleInterFoam family of solvers
CcompressibleTransportModel	Base-class for all transport models used by the compressible turbulence models
CCompressibleTurbulenceModel	Templated abstract base class for single-phase compressible turbulence models
CcompressibleTurbulenceModel	Abstract base class for turbulence models (RAS, LES and laminar)
CConeInjection	Multi-point cone injection model
CConeNozzleInjection	Cone injection
CconformalVoronoiMesh
CconformationSurfaces
CconjugateGradient	The Conjugate Gradient formula
CconstAnIsoSolidTransport	Constant properties Transport package. Templated into a given Thermodynamics package (needed for thermal conductivity)
CconstantAlphaContactAngleFvPatchScalarField	A constant alphaContactAngle scalar boundary condition
CConstantRateDevolatilisation	Constant rate devolatisation model
CConstCirculator	Like Foam::Circulator, but with const-access iterators
CconstIsoSolidTransport	Constant properties Transport package. Templated into a given thermodynamics package (needed for thermal conductivity)
CConstMatrixBlock
CConstPrecisionAdaptor	A const Field/List wrapper with possible data conversion
CconstrainedOptimisationMethod	Abstract base class for optimisation methods supporting constraints. Does not add functionality to updateMethod but act as a means to categorize constrained optimisation methods for performing sanity checks
CconstraintProjection	Update design variables using Rosen's projection method
CconstTransport	Constant properties Transport package. Templated into a given thermodynamics package (needed for thermal conductivity)
CconsumptionSpeed
CcontrolMeshRefinement
CcontrolPointsDefinition	Abstract base for selecting how to construct the control points of a volumetric B-Splines morpher
CcoordinateRotation	User specification of a coordinate rotation
CcoordinateScaling	Helper class to wrap coordinate system and component-wise scaling
►CcoordinateSystem	Base class for coordinate system specification, the default coordinate system type is cartesian
CiNew	Helper for construction of coordinateSystem PtrList
CcoordinateSystems	A centralized collection of named coordinate systems
CcoordSet	Holds list of sampling positions
CcoordSetWriter	Base class for writing coordSet(s) and tracks with fields
CcopiedFixedValueFvPatchScalarField	Copies the boundary values from a user specified field
CcorrectedCellVolumeWeightMethod	Cell-volume-weighted mesh-to-mesh interpolation class
CCorrectionLimitingMethod	Base class for correction limiting methods
CcorrelationFunction
Ccountstreambuf	A streambuf class for determining byte counts
CcoupledFacePointPatch	Coupled patch for post-processing. Used as the base class for processor and cyclic pointPatches
CcoupledFaePatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CcoupledFaPatch	CoupledFaPatch is an abstract base class for patches that couple regions of the computational domain e.g. cyclic, arbitrary interfaces, sliding interfaces and processor-processor links
CcoupledFaPatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CcoupledFvPatch	An abstract base class for patches that couple regions of the computational domain e.g. cyclic and processor-processor links
CcoupledFvPatchField	Abstract base class for coupled patches
CcoupledFvsPatchField	Foam::coupledFvsPatchField
CcoupledPointPatch	Coupled patch for post-processing. Used as the base class for processor and cyclic pointPatches
CcoupledPointPatchField	A Coupled boundary condition for pointField
CcoupledPolyPatch	The coupledPolyPatch is an abstract base class for patches that couple regions of the computational domain e.g. cyclic and processor-processor links
CcoupleGroupIdentifier	Encapsulates using "patchGroups" to specify coupled patch
CCOxidationDiffusionLimitedRate	Diffusion limited rate surface reaction model for coal parcels. Limited to:
CCOxidationHurtMitchell	Char oxidation model given by Hurt and Mitchell:
CCOxidationIntrinsicRate	Intrinsic char surface reaction mndel
CCOxidationKineticDiffusionLimitedRate	Kinetic/diffusion limited rate surface reaction model for coal parcels. Limited to:
CCOxidationMurphyShaddix	Limited to C(s) + O2 -> CO2
CCPCCellToCellStencil
CCPCCellToFaceStencil	Combined corresponding cellToCellStencil of owner and neighbour
CcpuInfo	General CPU characteristics
CcpuTimeCxx	Starts timing CPU usage and return elapsed time from start
CcpuTimePosix	Starts timing CPU usage and return elapsed time from start
CcrankConRod	Manage time in terms of engine RPM and crank-angle
CcreateShellMesh	Creates mesh by extruding a patch
CcrossProduct
CCStringList	An adapter for copying a list of C++ strings into a list of C-style strings for passing to C code that expects argc/argv parameters
CcsvTableReader	Reads an interpolation table from a file - CSV-format
Ccubic	Cubic interpolation scheme class derived from linear and returns linear weighting factors but also applies an explicit correction
CcubicEqn	Container to encapsulate various operations for cubic equation of the forms with real coefficients:
CcubicUpwindFitPolynomial	Cubic polynomial for upwind biased interpolation fitting
►Ccurve	A single curve in a graph
CcurveStyle	The style (line, symbol, etc) of a curve
CcutCell	Service routines for cutting a cell, celli, of an fvMesh, mesh_, at its intersection with a surface
CcutCellIso	Class for cutting a cell, celli, of an fvMesh, mesh_, at its intersection with an isosurface defined by the mesh point values f_ and the cutValue, isoValue_
CcutCellPLIC	Class for cutting a cell, cellI, of an fvMesh, mesh_, at its intersection with an surface defined by a normal and cutValue_ (defined as distance to the cell centre)
CcutFace	Base class for cutting a face, faceI, of an fvMesh, mesh_, at its intersections
CcutFaceAdvect	Calculates the face fluxes
CcutFaceIso	Class for cutting a face, faceI, of an fvMesh, mesh_, at its intersection with an isosurface defined by the mesh point values f_ and the isovalue, cutValue
CcutFacePLIC	Class for cutting a face, faceI, of an fvMesh, mesh_, at its intersection with an plane defined by normal and a base point
CCuthillMcKeeRenumber	Cuthill-McKee renumbering
CcuttingPlane	Constructs cutting plane through a mesh
CcuttingSurface	Constructs a cutting surface through a mesh
CcuttingSurfaceBase	Base for creating a MeshedSurface by performing some type of cell cutting/intersection
CCV2D	Conformal-Voronoi 2D automatic mesher with grid or read initial points and point position relaxation with optional "squarification"
Ccv2DControls	Controls for the 2D CV mesh generator
CcvControls	Controls for the conformalVoronoiMesh mesh generator
CcyclicACMIFvPatch	Cyclic patch for Arbitrarily Coupled Mesh Interface (ACMI)
CcyclicACMIFvPatchField	This boundary condition enforces a cyclic condition between a pair of boundaries, whereby communication between the patches is performed using an arbitrarily coupled mesh interface (ACMI) interpolation
CcyclicACMIFvsPatchField	Foam::cyclicACMIFvsPatchField
CcyclicACMIGAMGInterface	GAMG agglomerated cyclic ACMI interface
CcyclicACMIGAMGInterfaceField	GAMG agglomerated cyclic interface for Arbitrarily Coupled Mesh Interface (ACMI) fields
CcyclicACMILduInterface	An abstract base class for cyclic ACMI coupled interfaces
CcyclicACMILduInterfaceField	Abstract base class for cyclic ACMI coupled interfaces
CcyclicACMIPointPatch	Cyclic AMI point patch - place holder only
CcyclicACMIPointPatchField	Cyclic ACMI front and back plane patch field
CcyclicACMIPolyPatch	Cyclic patch for Arbitrarily Coupled Mesh Interface (ACMI)
CcyclicAMIFvPatch	Cyclic patch for Arbitrary Mesh Interface (AMI)
CcyclicAMIFvPatchField	This boundary condition enforces a cyclic condition between a pair of boundaries, whereby communication between the patches is performed using an arbitrary mesh interface (AMI) interpolation
CcyclicAMIFvsPatchField	Foam::cyclicAMIFvsPatchField
CcyclicAMIGAMGInterface	GAMG agglomerated cyclic AMI interface
CcyclicAMIGAMGInterfaceField	GAMG agglomerated cyclic interface field
CcyclicAMILduInterface	An abstract base class for cyclic AMI coupled interfaces
CcyclicAMILduInterfaceField	Abstract base class for cyclic AMI coupled interfaces
CcyclicAMIPointPatch	Cyclic AMI point patch - place holder only
CcyclicAMIPointPatchField	Cyclic AMI front and back plane patch field
CcyclicAMIPolyPatch	Cyclic patch for Arbitrary Mesh Interface (AMI)
CcyclicFaePatchField	Foam::cyclicFaePatchField
CcyclicFaPatch	Cyclic-plane patch
CcyclicFaPatchField	Foam::cyclicFaPatchField
CcyclicFvPatch	Cyclic-plane patch
CcyclicFvPatchField	This boundary condition enforces a cyclic condition between a pair of boundaries
CcyclicFvsPatchField	Foam::cyclicFvsPatchField
CcyclicGAMGInterface	GAMG agglomerated cyclic interface
CcyclicGAMGInterfaceField	GAMG agglomerated cyclic interface field
CcyclicLduInterface	An abstract base class for cyclic coupled interfaces
CcyclicLduInterfaceField	Abstract base class for cyclic coupled interfaces
CcyclicPeriodicAMIPolyPatch	Cyclic patch for periodic Arbitrary Mesh Interface (AMI)
CcyclicPointPatch	Cyclic patch for post-processing
CcyclicPointPatchField	Cyclic front and back plane patch field
CcyclicPolyPatch	Cyclic plane patch
CcyclicSlipFvPatch	Cyclic-plane patch
CcyclicSlipFvPatchField	This boundary condition is a light wrapper around the cyclicFvPatchField condition, providing no new functionality
CcyclicSlipFvsPatchField	Foam::cyclicSlipFvsPatchField
CcyclicSlipPointPatch	Cyclic patch with slip constraint
CcyclicSlipPointPatchField	Cyclic + slip constraints
CcyclicSlipPolyPatch	Copy of cyclicSlip - used to be able to instantiate cyclicSlip pointPatch which is cyclicSlip with slip constraints
CcylinderAnnulusToCell	A topoSetCellSource to select all cells with centres inside a given bounding cylinder annulus
CcylinderAnnulusToFace	A topoSetFaceSource to select all faces with centres inside a given bounding cylinder annulus
CcylinderToCell	A topoSetCellSource to select all cells whose cell centre inside a given bounding cylinder or cylinder annulus
CcylinderToFace	A topoSetFaceSource to select all faces whose face centre inside a given bounding cylinder or cylinder annulus
CcylinderToPoint	A topoSetPointSource to select all points which are inside a given bounding cylinder or cylinder annulus
CcylindricalInletVelocityFvPatchVectorField	This boundary condition describes an inlet vector boundary condition in cylindrical coordinates given a central axis, central point, rpm, axial and radial velocity
CDampingModel	Base class for collisional damping models
Cdata	Database for solution data, solver performance and other reduced data
CDBFGS	The quasi-Newton BFGS formula with the dampening proposed by Powell
CdecomposedBlockData	The decomposedBlockData comprise a List<char> for each output processor, typically with IO on the master processor only
CdecompositionConstraint	Abstract class for handling decomposition constraints
CdecompositionInformation	Abstract base class for decomposition
CdecompositionMethod	Abstract base class for domain decomposition
CdecompositionModel	MeshObject wrapper of decompositionMethod
CdeferredCorrection	Deferred correction interpolation scheme wrapper around a run-time selectable base scheme
CdegenerateMatcher	Collection of all hex degenerate matchers (hex, wedge, prism etc.)
CDelaunayMesh	The vertex and cell classes must have an index defined
CdeltaBoundary	Differentiation of the mesh data structure
CdemandDrivenEntry	Class for demand-driven dictionary entries
CDEShybrid	Hybrid convection scheme of Travin et al. for hybrid RAS/LES calculations
CDESModelBase	Base class for DES models providing an interfaces to the LESRegion function
CDevolatilisationModel	Templated devolatilisation model class
CDiagonalMatrix	A templated (N x N) diagonal matrix of objects of <Type>, effectively containing N elements, derived from List
CDiagonalPreconditioner	Diagonal preconditioner for both symmetric and asymmetric matrices
CdiagonalPreconditioner	Diagonal preconditioner for both symmetric and asymmetric matrices
CDiagonalSolver	Foam::DiagonalSolver
CdiagonalSolver	Foam::diagonalSolver
CDiagTensor	A templated (3 x 3) diagonal tensor of objects of <T>, effectively containing 3 elements, derived from VectorSpace
CdiameterModel	Abstract base-class for dispersed-phase particle diameter models
CDICGaussSeidelSmoother	Combined DIC/GaussSeidel smoother for symmetric matrices in which DIC smoothing is followed by GaussSeidel to ensure that any "spikes" created by the DIC sweeps are smoothed-out
CDICPreconditioner	Simplified diagonal-based incomplete Cholesky preconditioner for symmetric matrices (symmetric equivalent of DILU). The reciprocal of the preconditioned diagonal is calculated and stored
CDICSmoother	Simplified diagonal-based incomplete Cholesky smoother for symmetric matrices
►Cdictionary	A list of keyword definitions, which are a keyword followed by a number of values (eg, words and numbers) or by a sub-dictionary. Since the dictionary format is used extensively throughout OpenFOAM for input/output files, there are many examples of its use
CSearcher	Generic const/non-const dictionary entry searcher
CDictionary	General purpose template dictionary class that manages the storage associated with it
CDictionaryBase	Base dictionary class templated on both the form of doubly-linked list it uses as well as the type it holds
CdictionaryContent	A wrapper for dictionary content, without operators that could affect inheritance patterns
CdictionaryEntry	A keyword and a list of tokens is a 'dictionaryEntry'
CdictionaryListEntry	Read/write List of dictionaries
CDILUGaussSeidelSmoother	Combined DILU/GaussSeidel smoother for asymmetric matrices in which DILU smoothing is followed by GaussSeidel to ensure that any "spikes" created by the DILU sweeps are smoothed-out
CDILUPreconditioner	Simplified diagonal-based incomplete LU preconditioner for asymmetric matrices. The reciprocal of the preconditioned diagonal is calculated and stored
CDILUSmoother	Simplified diagonal-based incomplete LU smoother for asymmetric matrices
Cdimensioned	Generic dimensioned Type class
CDimensionedField	Field with dimensions and associated with geometry type GeoMesh which is used to size the field and a reference to it is maintained
CdimensionSet	Dimension set for the base types, which can be used to implement rigorous dimension checking for algebraic manipulation
CdimensionSets	Construction of unit sets
CdimFieldDecomposer	Dimensioned field decomposer
CDirectFieldMapper	A templated direct mapper for the given FieldMapper type
CdirectionalDiffusivity	Directional finite volume mesh motion diffusivity
CdirectionalWallPointData	Holds information (coordinate and normal) regarding the nearest wall point
CdirectionInfo	Holds direction in which to split cell (in fact a local coordinate axes). Information is a label and a direction
CdirectionMixedFvPatchField	Base class for direction-mixed boundary conditions
Cdirections	Set of directions for each cell in the mesh. Either uniform and size=1 or one set of directions per cell
CdirectMethod	Direct (one-to-one cell correspondence) mesh-to-mesh interpolation class
CDispersionModel	Base class for dispersion modelling
CDispersionRASModel	Base class for particle dispersion models based on RAS turbulence
CdisplacementComponentLaplacianFvMotionSolver	Mesh motion solver for an fvMesh. Based on solving the cell-centre Laplacian for the given component of the motion displacement
CdisplacementInterpolationMotionSolver	Mesh motion solver for an fvMesh
CdisplacementLaplacianFvMotionSolver	Mesh motion solver for an fvMesh. Based on solving the cell-centre Laplacian for the motion displacement
CdisplacementLayeredMotionMotionSolver	Mesh motion solver for an (multi-block) extruded fvMesh. Gets given the structure of the mesh blocks and boundary conditions on these blocks
CdisplacementMeshMoverMotionSolver	Mesh motion solver for an fvMesh. Uses externalDisplacementMeshMover to do the mesh motion
CdisplacementMethod	Abstract base class for displacement methods, which are a set or wrapper classes allowing to change the driving force of mesh motion solvers
CdisplacementMethoddisplacementLaplacian	Wrapper class for the displacementLaplacian motion solver
CdisplacementMethodelasticityMotionSolver	Wrapper class for the elasticityMotionSolver motion solver
CdisplacementMethodlaplacianMotionSolver	Wrapper class for the velocityLaplacian motion solver
CdisplacementMethodvelocityLaplacian	Wrapper class for the velocityLaplacian motion solver
CdisplacementMethodvolumetricBSplinesMotionSolver	Wrapper class for the volumetricBSplinesMotionSolver motion solver
CdisplacementMotionSolver	Virtual base class for displacement motion solver
CdisplacementMotionSolverMeshMover	Quality-based under-relaxation wrapped around generic displacementMotionSolver
CdisplacementSBRStressFvMotionSolver	Mesh motion solver for an fvMesh. Based on solving the cell-centre solid-body rotation stress equations for the motion displacement
CdistanceSurface	A surface defined by a distance from an input searchable surface. Uses an iso-surface algorithm (cell, topo, point) for constructing the distance surface
CDistortedSphereDragForce	Particle-drag model wherein drag forces (per unit carrier-fluid velocity) are dynamically computed by using sphereDrag model; however, are corrected for particle distortion by linearly varying the drag between of a sphere (i.e. sphereDrag) and a value of 1.54 corresponding to a disk
CDistributedDelaunayMesh
CDistributedFieldMapper	A templated field mapper with direct mapping from local or remote quantities
CdistributedTriSurfaceMesh	IOoject and searching on distributed triSurface. All processor hold (possibly overlapping) part of the overall surface. All queries are distributed to the processor that can answer it and the result sent back
CdistributedWeightedFvPatchFieldMapper	FieldMapper with weighted mapping from (optionally remote) quantities
Cdistribution	Accumulating histogram of values. Specified bin resolution automatic generation of bins
CDistribution	Accumulating histogram of component values. Specified bin resolution, automatic generation of bins
CdistributionModel	A library of runtime-selectable doubly-truncated probability distribution models. Returns random samples based on given distribution parameters
CdivideEqOp
CdivideEqOp2
CdivideOp
CdivideOp2
CdivideOp3
CdlLibraryTable	A table of dynamically loaded libraries
►CDLListBase	Base for doubly-linked lists
Cconst_iterator	A primitive const node iterator (bidirectional)
Citerator	A primitive non-const node iterator
Clink	The structure for a doubly-linked storage node
CDMDModel	Abstract base class for DMD models to handle DMD characteristics for the DMD function object
CdomainDecomposition	Automatic domain decomposition class for finite-volume meshes
CdomainDecompositionDryRun	Testing of domain decomposition for finite-volume meshes
Cdownwind	Downwind differencing scheme class
CdoxygenXmlParser	Parser for doxygen XML
CDPMIncompressibleTurbulenceModel	Templated abstract base class for volumen occupancy incompressible turbulence models
CdragModel
CDSMCBaseCloud	Virtual abstract base class for templated DSMCCloud
CDSMCCloud	Templated base class for dsmc cloud
►CDSMCParcel	DSMC parcel class
CconstantProperties	Class to hold DSMC particle constant properties
CiNew	Factory class to read-construct particles used for
►CDTRMParticle	Discrete Transfer Radiation Model (DTRM) particle
CiNew	Factory class to read-construct particles used for
CtrackingData	Class used to pass tracking data to the trackToFace function
CdummyAgglomeration	Agglomerate without combining cells. Used for testing
CdummyISstream	Dummy input stream, which can be used as a placeholder for interfaces taking an Istream or ISstream. Aborts at any attempt to read from it
CdummyTransform
CduplicatePoints	Duplicate points
CdynamicAlphaContactAngleFvPatchScalarField	A dynamic alphaContactAngle scalar boundary condition (alphaContactAngleTwoPhaseFvPatchScalarField)
CdynamicCode	Tools for handling dynamic code compilation
CdynamicCodeContext	Encapsulation of dynamic code dictionaries
CDynamicField	Dynamically sized Field
CdynamicFvMesh	Abstract base class for geometry and/or topology changing fvMesh
CDynamicID	A class that holds the data needed to identify things (zones, patches) in a dynamic mesh
►CdynamicIndexedOctree	Non-pointer based hierarchical recursive searching. Storage is dynamic, so elements can be deleted
Cnode	Tree node. Has up pointer and down pointers
CdynamicInkJetFvMesh	Mesh motion specifically for the "pumping" system of an ink-jet injector
CDynamicList	A 1D vector of objects of type <T> that resizes itself as necessary to accept the new objects
CdynamicMotionSolverFvMesh	The dynamicMotionSolverFvMesh
CdynamicMotionSolverFvMeshAMI	The dynamicMotionSolverFvMeshAMI
CdynamicMotionSolverListFvMesh	Dynamic mesh able to handle multiple motion solvers. NOTE: If the word entry "solvers" is not found it falls back to a single motion solver behavior
CdynamicMotionSolverTopoFvMesh	Sample topoChangerFvMesh that moves an object using a motion solver
CdynamicMultiMotionSolverFvMesh	Mesh motion described per cellZone. Individual motion solvers solve over whole domain but are only applied per cellZone
CdynamicOversetFvMesh	DynamicFvMesh with support for overset meshes
CdynamicRefineFvMesh	A fvMesh with built-in refinement
CdynamicTreeDataPoint	Holds (reference to) pointField. Encapsulation of data needed for octree searches. Used for searching for nearest point. No bounding boxes around points. Only overlaps and calcNearest are implemented, rest makes little sense
CeagerGAMGProcAgglomeration	'Eager' processor agglomeration of GAMGAgglomerations: at every level agglomerates 'mergeLevels' number of processors onto the minimum processor number
CeConstThermo	Constant properties thermodynamics package templated on an equation of state
Ceddy	Class to describe eddies for the turbulentDFSEMInletFvPatchVectorField boundary condition
CEddyDiffusivity	Templated abstract base class for single-phase compressible turbulence models
CeddyViscosity	Eddy viscosity turbulence model base class
►Cedge	An edge is a list of two point labels. The functionality it provides supports the discretisation on a 2-D flat mesh
CHash	Deprecated(2021-04) hashing functor. Use hasher()
Chasher	Hashing functor for edge (commutative)
CedgeCollapser	Does polyTopoChanges to remove edges. Can remove faces due to edge collapse but can not remove cells due to face removal! Also removes unused points
CedgeFaceCirculator	Walks from starting face around edge
CedgeInterpolation	Face to edge interpolation scheme. Included in faMesh
CedgeInterpolationScheme	Abstract base class for edge interpolation schemes
CedgeIntersections	Holder of intersections of edges of a surface with another surface. Optionally shuffles around points on surface to resolve any 'conflicts' (edge hitting triangle edge, edge hitting point etc.)
CEdgeMap	Map from edge (expressed as its endpoints) to value. For easier forward declaration it is currently implemented as a separate class rather than a template alias
CedgeMesh	Mesh data needed to do the Finite Area discretisation
CedgeNormalFixedValueFaPatchVectorField	Edge normal fixed value vector field finite area boundary condition
CedgeStats	Helper class to calculate minimum edge length on mesh
CedgeSurface	Description of surface in form of 'cloud of edges'
CedgeTopoDistanceData	For use with PatchEdgeFaceWave. Determines topological distance to starting edges. Templated on passive transported data
CedgeVertex	Combines edge or vertex in single label. Used to specify cuts across cell circumference
CegrMixture	The egr mixture contains species ("ft", "b", "egr")
CEigenMatrix	EigenMatrix (i.e. eigendecomposition or spectral decomposition) decomposes a diagonalisable nonsymmetric real square matrix into its canonical form, whereby the matrix is represented in terms of its eigenvalues and eigenvectors
CelasticityMotionSolver	Mesh deformation based on the linear elasticity equations. The boundary displacement is set as a boundary condition on the pointMotionU field
CelectrostaticDepositionFvPatchScalarField	The electrostaticDeposition is a boundary condition to calculate electric potential (V) on a given boundary based on film thickness (h) and film resistance (R) fields which are updated based on a given patch-normal current density field (jn), Coulombic efficiency and film resistivity
CelectrostaticPotential
CemptyFaePatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CemptyFaPatch	A patch which will not exist in the faMesh. Typical example is a front and back plane of a 2-D geometry
CemptyFaPatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CemptyFvPatch	A patch which will not exist in the fvMesh. Typical example is a front and back plane of a 2-D geometry
CemptyFvPatchField	This boundary condition provides an 'empty' condition for reduced dimensions cases, i.e. 1- and 2-D geometries. Apply this condition to patches whose normal is aligned to geometric directions that do not constitue solution directions
CemptyFvsPatchField	Foam::emptyFvsPatchField
CemptyOp	Test if object is empty, typically using its empty() method
CemptyPointPatch	Empty plane patch
CemptyPointPatchField	An empty boundary condition for pointField
CemptyPolyPatch	Empty front and back plane patch. Used for 2-D geometries
Cendian
CenergyJumpAMIFvPatchScalarField	This boundary condition provides an energy jump condition across a pair of coupled patches with an arbitrary mesh interface (AMI). It is not applied directly, but is employed on-the-fly when converting temperature boundary conditions into energy
CenergyJumpFvPatchScalarField	This boundary condition provides an energy jump condition across a pair of coupled patches. It is not applied directly, but is employed on-the-fly when converting temperature boundary conditions into energy
CenergyScalingFunction
CengineMesh	Foam::engineMesh
CenginePiston	Foam::enginePiston
CengineTime	An abstract class for the time description of the piston motion
CengineValve	Foam::engineValve
CenrichedPatch	The enriched patch contains a double set of faces from the two sides of the sliding interface before the cutting
►CensightCase	Supports writing of ensight cases as well as providing common factory methods to open new files
Coptions	Configuration options for the ensightCase
CensightCells	Sorting/classification of cells (3D) into corresponding ensight element types
CensightFaces	Sorting/classification of faces (2D) into corresponding ensight types
CensightFaMesh	Encapsulation of area meshes for writing in ensight format
CensightFile	Ensight output with specialized write() for strings, integers and floats. Correctly handles binary write as well
CensightGeoFile	Specialized Ensight output with extra geometry file header
►CensightMesh	Encapsulation of volume meshes for writing in ensight format. It manages cellZones, facesZone, patches
Coptions	Configuration options for the ensightMesh
CensightOutputSurface	A variant of ensightFaces that holds references to contiguous points/faces with its own encapsulated write methods. The surface is assumed to have been merged prior, thus the output is serial-only
CensightPart	Base class for ensightCells, ensightFaces, ensightOutputSurfaces
CensightPTraits	Ensight names and component order for base types
CensightReadFile	Ensight output with specialized read() for strings, integers and floats. Correctly handles binary read as well
CensightSurfaceReader	Ensight format surface reader
CenthalpySorptionFvPatchScalarField	This is a temperature boundary condition which works in conjunction with the speciesSorption condition for species
Centry	A keyword and a list of tokens is an 'entry'
►CEnum	Enum is a wrapper around a list of names/values that represent particular enumeration (or int) values. All dictionary searches use a literal (not regex)
Cconst_iterator	A const_iterator for iterating an Enum list
CepsilonWallFunctionFvPatchScalarField	This boundary condition provides wall functions for the turbulent kinetic energy dissipation rate (i.e. epsilon) and the turbulent kinetic energy production contribution (i.e. G) for low- and high-Reynolds number simulations
CeqMagOp
CeqMagOp2
CeqMagSqrOp
CeqMagSqrOp2
CeqMinusOp
CeqMinusOp2
CeqOp
CeqOp2
CeqSqrOp
CeqSqrOp2
CequalOp
CequalOp1
CequalOp2
CequalOp< Scalar >	Compare scalar values for equality
CErgunWenYuDragForce	Particle-drag model wherein drag forces (per unit carrier-fluid velocity) are dynamically computed based on the Gidaspow drag model which is a switch-like combination of the Wen-Yu and Ergun drag models
Cerror	Class to handle errors and exceptions in a simple, consistent stream-based manner
CerrorManip	Error stream manipulators for exit and abort which may terminate the program or throw an exception depending if the exception handling has been switched on (off by default)
CerrorManipArg	Error stream manipulators for functions with an argument
CETAB	The Enhanced TAB model
CEuler	Euler-implicit integration scheme
CEulerImplicit	An Euler implicit solver for chemistry
CEulerSI	Semi-implicit Euler ODE solver of order (0)1
CexponentialDiffusivity	Mesh motion diffusivity maipulator which returns the exp(-alpha/D) of the given diffusivity D
CexponentialSolidTransport	Exponential properties for solid heat transport Templated into a given thermodynamics package
CexprFixedValueFvPatchField	A fixed value boundary condition with expressions
CexprMixedFvPatchField	A mixed boundary condition with expressions
CexprTypeTraits	Simple type identifiers for polymorphic expression values
CexprTypeTraits< ::Foam::label >
CexprTypeTraits< ::Foam::scalar >
CexprTypeTraits< ::Foam::sphericalTensor >
CexprTypeTraits< ::Foam::symmTensor >
CexprTypeTraits< ::Foam::tensor >
CexprTypeTraits< ::Foam::vector >
CexprTypeTraits< bool >
CexprValuePointPatchField	A fixed value point boundary condition with expressions
CextendedCellToCellStencil	Baseclass for cell-to-cell stencils
CextendedCellToFaceStencil	Calculates/constains the extended cell-to-face stencil
CextendedCentredCellToCellStencil
CextendedCentredCellToFaceStencil
CextendedCentredFaceToCellStencil
CextendedEdgeMesh	Description of feature edges and points
CextendedFaceToCellStencil	Note: transformations on coupled patches not supported. Problem is the positions of cells reachable through these patches
CextendedFeatureEdgeMesh	ExtendedEdgeMesh + IO
CextendedUpwindCellToFaceStencil	Creates upwind stencil by shifting a centred stencil to upwind and downwind faces and optionally removing all non-(up/down)wind faces ('pureUpwind')
CexternalCoupledMixedFvPatchField	Extends the mixed boundary condition with serialisation functions
CexternalCoupledTemperatureMixedFvPatchScalarField	This boundary condition provides a temperatue interface to an external application
CexternalDisplacementMeshMover	Virtual base class for mesh movers with externally provided displacement field giving the boundary conditions. Move the mesh from the current location to a new location (so modify the mesh; v.s. motionSolver that only returns the new location)
CexternalFileCoupler	Encapsulates the logic for coordinating between OpenFOAM and an external application
►CexternalPointEdgePoint	Holds information regarding nearest wall point. Used in PointEdgeWave. (so not standard FaceCellWave) To be used in wall distance calculation
CtrackingData	Class used to pass data into container
CexternalWallHeatFluxTemperatureFvPatchScalarField	This boundary condition applies a heat flux condition to temperature on an external wall in one of three modes:
CextrapolatedCalculatedFvPatchField	This boundary condition applies a zero-gradient condition from the patch internal field onto the patch faces when evaluated but may also be assigned. snGrad returns the patch gradient evaluated from the current internal and patch field values rather than returning zero
Cextrude2DMesh	Given a 2D mesh insert all the topology changes to extrude. Does not work in parallel
CextrudedMesh
CextrudeModel	Top level extrusion model class
CextrudePatchMesh	Mesh at a patch created on the fly. The following entry should be used on the field boundary dictionary:
CfaAreaMapper	FA area mapper
CfaBoundaryMesh	Finite area boundary mesh
CfaBoundaryMeshEntries	Read and store dictionary entries for finite-area boundary patches
CfaBoundaryMeshMapper	Foam::faBoundaryMeshMapper
►Cface	A face is a list of labels corresponding to mesh vertices
Chasher	Hashing functor for face
CsymmHasher	Symmetric hashing functor for face
CfaceAreaIntersect	Face intersection class
CfaceAreaPairGAMGAgglomeration	Agglomerate using the pair algorithm
CfaceAreaWeightAMI	Face area weighted Arbitrary Mesh Interface (AMI) method
CfaceAreaWeightAMI2D	Face area weighted Arbitrary Mesh Interface (AMI) method that performs the intersection of src and tgt face area in 2D
CfaceAreaWeightModel	Abstract base class for providing faceAreaWeight values to the cell motion controller based on an argument faceAreaFraction value, typically the ratio of the area of the face in question to the area of a square face with a side length of the local target cell size
CfaceBitSet	A special purpose topoSet with the face labels stored as a bitSet. It does not correspond to a faceSet either (no associated IOobject)
CfaceBoolSet	A special purpose topoSet with the face labels stored as a boolList. It does not correspond to a faceSet either (no associated IOobject)
CfaceCells	Smooth ATC in cells next to a set of patches supplied by type
CFaceCellWave	Wave propagation of information through grid. Every iteration information goes through one layer of cells. Templated on information that is transferred
CfaceCentredCubic	Generate an FCC lattice of points inside the surfaces to be conformed to of the conformalVoronoiMesh
CfaceCollapser	Collapses faces into edges. Used to remove sliver faces (faces with small area but non-zero span)
CfaceCoupleInfo	Container for information needed to couple to meshes. When constructed from two meshes and a geometric tolerance finds the corresponding boundary faces
CfaceEqOp
CFaceInteraction	Face zone-based particle interactions
CfaceMapper	This object provides mapping and fill-in information for face data between the two meshes after the topological change. It is constructed from mapPolyMesh
CfaceOnlySet	Sample on faces along a specified path
CfacePointPatch	A pointPatch based on a polyPatch
CFacePostProcessing	Records particle face quantities on used-specified face zone
CfaceReflecting	Calculates the reflecting faces from specular surfaces. It only takes into account the first reflection coming from a surface hit by the primary Sun hit faces
CfaceSelection	Face selection method for createBaffles
CfaceSet	A list of face labels
CfaceShading	FaceShading uses the transmissivity value in the boundaryRadiationProperties in order to evaluate which faces are "hit" by the "direction" vector. NOTE: Only transmissivity values of zero are considered for opaque walls
CfaceToCell	A topoSetCellSource to select all cells based on usage in given faceSet(s), e.g. select cells that are the owner/neighbour/any of the faces in a given faceSet
CfaceToCellStencil	Baseclass for extended cell centred addressing. Contains per cell a list of neighbouring faces in global addressing
CfaceToFace	A topoSetFaceSource to select faces based on usage in another faceSet
CfaceToPoint	A topoSetPointSource to select all points based on usage in given faceSet(s)
CfaceTraits	Traits class for faces
CfaceTriangulation	Triangulation of faces. Handles concave polygons as well (inefficiently)
CfaceZone	A subset of mesh faces organised as a primitive patch
CfaceZoneSet	Like faceSet but -reads data from faceZone -updates faceZone when writing
CfaceZoneToCell	A topoSetCellSource to select cells based on master or slave side of given faceZone(s)
CfaceZoneToFaceZone	A topoSetSource to select faces of a given faceZone
CfaEdgeMapper	FA edge mapper. Currently, edge-based finite area data is not mapped, but only resized, since edge-based mapping data is not available
CfaePatchField	FaePatchField<Type> abstract base class. This class gives a fat-interface to all derived classes covering all possible ways in which they might be used. The first level of derivation is to basic patchFields which cover zero-gradient, fixed-gradient, fixed-value and mixed conditions. The next level of derivation covers all the specialised typed with specific evaluation procedures, particularly with respect to specific fields
►CfaFieldDecomposer	Finite Area area and edge field decomposer
►CfieldsCache
CprivateCache
CpatchFieldDecomposer	Patch field decomposer class
CprocessorAreaPatchFieldDecomposer	Processor patch field decomposer class
CprocessorEdgePatchFieldDecomposer	Processor patch field decomposer class
►CfaFieldReconstructor	Finite Area area and edge fields reconstruction
CfaPatchFieldReconstructor
CfaGlobalMeshData	Various mesh related information for a parallel run
CFallOffReactionRate	General class for handling unimolecular/recombination fall-off reactions
►CfaMatrix	A special matrix type and solver, designed for finite area solutions of scalar equations. Face addressing is used to make all matrix assembly and solution loops vectorise
CfaSolver
CfaMesh	Finite area mesh (used for 2-D non-Euclidian finite area method) defined using a patch of faces on a polyMesh (ie, uindirectPrimitivePatch)
CfaMeshBoundaryHalo	Class for obtaining halo face data for the boundary edges. The ordering follows that natural edge ordering of the underlying primitive patch
CfaMeshDecomposition	Automatic faMesh decomposition class
CfaMeshDistributor	Holds a reference to the original mesh (the baseMesh) and optionally to a subset of that mesh (the subMesh) with mapping lists for points, faces, and cells
CfaMeshLduAddressing	LduAddressing wrapper for faMesh
CfaMeshMapper	Class holds all the necessary information for mapping fields associated with faMesh
CfaMeshReconstructor	A bare-bones reconstructor for finiteArea meshes when processor meshes are available (in parallel) but an equivalent serial faMesh is needed for reconstruction or decomposition. In these situations, a serial version of the faMesh is needed, but preferably without reconstructing the entire volume mesh
CfaMeshSubset	Holds a reference to the original mesh (the baseMesh) and optionally to a subset of that mesh (the subMesh) with mapping lists for points, faces, and cells
CfaMeshTools	A collection of tools for operating on an faMesh
CfanFvPatchField	This boundary condition provides a jump condition, using the cyclic condition as a base
CfanPressureFvPatchScalarField	This boundary condition can be applied to assign either a pressure inlet or outlet total pressure condition for a fan
CfaNVDscheme	Class to create the weighting-factors based on the NVD (Normalised Variable Diagram)
CfaPatch	Finite area patch class. Used for 2-D non-Euclidian finite area method
CfaPatchData	Helper class for holding data during faPatch construction. Most data members are exposed at the moment
CfaPatchField	FaPatchField<Type> abstract base class. This class gives a fat-interface to all derived classes covering all possible ways in which they might be used. The first level of derivation is to basic patchFields which cover zero-gradient, fixed-gradient, fixed-value and mixed conditions. The next level of derivation covers all the specialised typed with specific evaluation procedures, particularly with respect to specific fields
CfaPatchFieldMapper	A FieldMapper for finite-area patch fields
CfaPatchFieldMapperPatchRef
CfaPatchMapper	Mapping class for a faPatchField. Edge mapping is calculated based on faceCells comparison of old and new patch
CfaSchemes	Selector class for finite area differencing schemes. faMesh is derived from faSchemes so that all fields have access to the faSchemes from the mesh reference they hold
CfaSolution	Selector class for finite area solution. faMesh is derived from faSolution so that all fields have access to the faSolution from the mesh reference they hold
CFDICPreconditioner	Faster version of the DICPreconditioner diagonal-based incomplete Cholesky preconditioner for symmetric matrices (symmetric equivalent of DILU) in which the reciprocal of the preconditioned diagonal and the upper coefficients divided by the diagonal are calculated and stored
CFDICSmoother	Simplified diagonal-based incomplete Cholesky smoother for symmetric matrices
CfeatureEdgeMesh	EdgeMesh + IO
CfeaturePointConformer	The Delaunay vertices required to conform to a feature point can be determined upon initialisation because the feature points are fixed and do not change throughout the meshing process
CFECCellToFaceStencil	All cells connected via edge to face
Cfft	Fast fourier transform using the fftw library
CField	Generic templated field type
CFieldActivatedInjection	Conditional injection at specified positions
CFieldBase	Template invariant parts for Field and SubField
CfieldDictionary	Read field as dictionary (without mesh)
CFieldField	A field of fields is a PtrList of fields with reference counting
CfieldFromFile
CFieldFunction1
CFieldMapper	Abstract base class to hold the Field mapping addressing and weights
CfieldsDistributor
CfieldSmoother	Utility functions for mesh motion solvers
CfieldToCell	A topoSetCellSource to select cells based on volScalarField values, i.e. select cells with given field value of >= min and <= max
CFIFOStack	A FIFO stack based on a singly-linked list
CfileControl
CfileDiffusivity	Motion diffusivity read from given file name
CfileMonitor	Checking for changes to files
CfileMonitorWatcher	Internal tracking via stat(3p) or inotify(7)
CfileName	A class for handling file names
CfileOperation	An encapsulation of filesystem-related operations
CfileStat	Wrapper for stat() and lstat() system calls
CfilmHeightInletVelocityFvPatchVectorField	This boundary condition is designed to be used in conjunction with surface film modelling. It provides a velocity inlet boundary condition for patches where the film height is specified. The inflow velocity is obtained from the flux with a direction normal to the patch faces using:
CfilmPyrolysisRadiativeCoupledMixedFvPatchScalarField	Mixed boundary condition for temperature, to be used in the flow and pyrolysis regions when a film region model is used
CfilmPyrolysisTemperatureCoupledFvPatchScalarField	This boundary condition is designed to be used in conjunction with surface film and pyrolysis modelling. It provides a temperature boundary condition for patches on the primary region based on whether the patch is seen to be 'wet', retrieved from the film alpha field
CfilmPyrolysisVelocityCoupledFvPatchVectorField	This boundary condition is designed to be used in conjunction with surface film and pyrolysis modelling
CfilteredLinear2Limiter	Class to generate weighting factors for the filteredLinear2 differencing scheme
CfilteredLinear2VLimiter	Class to generate weighting factors for the filteredLinear2V differencing scheme
CfilteredLinear3Limiter	Class to generate weighting factors for the filteredLinear differencing scheme
CfilteredLinear3VLimiter	Class to generate weighting factors for the filteredLinear3V differencing scheme
CfilteredLinearLimiter	Class to generate weighting factors for the filteredLinear differencing scheme
►CfindCellParticle	Particle class that finds cells by tracking
CiNew	Factory class to read-construct particles used for
CtrackingData	Class used to pass tracking data to the trackToFace function
CfindNearestMaskedOp
CfindUniqueIntersectOp
CFitData	Data for the upwinded and centred polynomial fit interpolation schemes. The linearCorrection_ determines whether the fit is for a corrected linear scheme (first two coefficients are corrections for owner and neighbour) or a pure upwind scheme (first coefficient is correction for owner; weight on face taken as 1)
CfixedBlended	Two-scheme fixed-blending differencing scheme
CfixedEnergyFvPatchScalarField	This boundary condition provides a fixed condition for internal energy
CfixedFluxExtrapolatedPressureFvPatchScalarField	This boundary condition sets the pressure gradient to the provided value such that the flux on the boundary is that specified by the velocity boundary condition
CfixedFluxPressureFvPatchScalarField	This boundary condition sets the pressure gradient to the provided value such that the flux on the boundary is that specified by the velocity boundary condition
CfixedGradientFaPatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CfixedGradientFvPatchField	This boundary condition supplies a fixed gradient condition, such that the patch values are calculated using:
CfixedInternalValueFvPatchField	This boundary condition provides a mechanism to set boundary (cell) values directly into a matrix, i.e. to set a constraint condition. Default behaviour is to act as a zero gradient condition
CfixedJumpAMIFvPatchField	This boundary condition provides a jump condition, across non-conformal cyclic path-pairs, employing an arbitraryMeshInterface (AMI)
CfixedJumpFvPatchField	This boundary condition provides a jump condition, using the cyclic condition as a base
►CFixedList	A 1D vector of objects of type <T> with a fixed length <N>
CHash	Deprecated(2021-04) hashing functor. Use hasher()
Chasher	Hashing functor for FixedList
CfixedMeanFvPatchField	This boundary condition extrapolates field to the patch using the near-cell values and adjusts the distribution to match the specified, optionally time-varying, mean value
CfixedMeanOutletInletFvPatchField	This boundary condition extrapolates field to the patch using the near-cell values and adjusts the distribution to match the specified, optionally time-varying, mean value. This extrapolated field is applied as a fixedValue for outflow faces but zeroGradient is applied to inflow faces
CfixedMultiPhaseHeatFluxFvPatchScalarField	Calculates a wall temperature that produces the specified overall wall heat flux across all the phases in an Eulerian multi-phase simulation
CfixedNormalInletOutletVelocityFvPatchVectorField	This velocity inlet/outlet boundary condition combines a fixed normal component obtained from the "normalVelocity" patchField supplied with a fixed or zero-gradiented tangential component
CfixedNormalSlipFvPatchField	This boundary condition sets the patch-normal component to the field (vector or tensor) to the patch-normal component of a user specified field. The tangential component is treated as slip, i.e. copied from the internal field
CfixedNormalSlipPointPatchField	Slip with user-specified normal
CfixedPressureCompressibleDensityFvPatchScalarField	This boundary condition calculates a (liquid) compressible density as a function of pressure and fluid properties:
CfixedProfileFvPatchField	This boundary condition provides a fixed value profile condition
CfixedRhoFvPatchScalarField	Foam::fixedRhoFvPatchScalarField
CfixedShearStressFvPatchVectorField	This boundary condition sets a user-defined shear stress constant and uniform across a given patch by using the expression:
CfixedTrim	Trim model where the operating characteristics of rotor (e.g. blade pitch angle) are fixed, hence the possibility of varying thrust and torque
CfixedUnburntEnthalpyFvPatchScalarField	Fixed boundary condition for unburnt
CfixedValueFaePatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CfixedValueFaPatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CfixedValueFvPatchField	This boundary condition supplies a fixed value constraint, and is the base class for a number of other boundary conditions
CfixedValueFvsPatchField	Foam::fixedValueFvsPatchField
CfixedValueOutflowFaPatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CfixedValuePointPatchField	A FixedValue boundary condition for pointField
CflipBoolOp	Invert boolean value
CflipLabelOp	Negate integer values
CflipOp	Functor to negate primitives. Dummy for most other types
CfloorOp
CfloorOp< Scalar >	Round scalar downwards - functor version of std::floor
CflowRateInletVelocityFvPatchVectorField	Velocity inlet boundary condition either correcting the extrapolated velocity or creating a uniform velocity field normal to the patch adjusted to match the specified flow rate
CflowRateOutletVelocityFvPatchVectorField	Velocity outlet boundary condition which corrects the extrapolated velocity to match the specified flow rate
CfluentFvMesh
CfluidThermo	Fundamental fluid thermodynamic properties
Cflux
Cflux< scalar >
CfluxCorrectedVelocityFvPatchVectorField	This boundary condition provides a velocity outlet boundary condition for patches where the pressure is specified. The outflow velocity is obtained by "zeroGradient" and then corrected from the flux:
CfoamChemistryReader	Chemistry reader for OpenFOAM format
CfoamToVtkReportFields	Collection of simple static methods for reporting field names by category, which is used by foamToVTK
CfoamVtkMeshMaps	Bookkeeping for mesh subsetting and/or polyhedral cell decomposition. Although the main use case is for handling vtk meshes, it is not specific to VTK alone
CforceSuSp	Helper container for force Su and Sp terms
CfreePiston	In case of free pistons, the piston position is determined by a user-defined position according to time
CFreeStream	Inserting new particles across the faces of a all patched of type "patch" for a free stream. Uniform values number density, temperature and velocity sourced face-by-face from the boundaryT and boundaryU fields of the cloud
CfreestreamFvPatchField	This boundary condition provides a free-stream condition. It is a 'mixed' condition derived from the inletOutlet condition, whereby the mode of operation switches between fixed (free stream) value and zero gradient based on the sign of the flux
CfreestreamPressureFvPatchScalarField	This boundary condition provides a free-stream condition for pressure
CfreestreamVelocityFvPatchVectorField	This boundary condition provides a free-stream condition for velocity
CfreeSurfacePressureFvPatchScalarField	This boundary condition provides static pressure condition for p_rgh, calculated as:
CfreeSurfaceVelocityFvPatchVectorField	This boundary condition provides a velocity outlet boundary condition for free surface patches
CfromFile	Reads control points from constant/controlPoints
CFunction1	Top level data entry class for use in dictionaries. Provides a mechanism to specify a variable as a certain type, e.g. constant or table, and provide functions to return the (interpolated) value, and integral between limits
Cfunction1Base	Base class for template-invariant parts of Function1
CfunctionEntry	A functionEntry causes entries to be added/manipulated on the specified dictionary given an input stream
►CfunctionObject	Abstract base-class for Time/database function objects
CunavailableFunctionObject	Abstract functionObject to report when a real version is unavailable
CfunctionObjectList	List of function objects with start(), execute() and end() functions that is called for each object
CfvBoundaryMesh	Foam::fvBoundaryMesh
CfvBoundaryMeshMapper	Foam::fvBoundaryMeshMapper
►CfvFieldDecomposer	Finite Volume volume and surface field decomposer
►CfieldsCache
CprivateCache
CpatchFieldDecomposer	Patch field decomposer class
CprocessorSurfacePatchFieldDecomposer	Processor patch field decomposer class. Surface field is assumed
CprocessorVolPatchFieldDecomposer	Processor patch field decomposer class. Maps either owner or
►CfvFieldReconstructor	Finite volume reconstructor for volume and surface fields
CfvPatchFieldReconstructor	Mapper for sizing only - does not do any actual mapping
CfvGeometryScheme	Abstract base class for geometry calculation schemes
►CfvMatrix	A special matrix type and solver, designed for finite volume solutions of scalar equations. Face addressing is used to make all matrix assembly and solution loops vectorise
CfvSolver
CfvMesh	Mesh data needed to do the Finite Volume discretisation
CfvMeshAdder	Adds two fvMeshes without using any polyMesh morphing. Uses polyMeshAdder
CfvMeshDistribute	Sends/receives parts of mesh+fvfields to neighbouring processors. Used in load balancing
CfvMeshLduAddressing	Foam::fvMeshLduAddressing
CfvMeshMapper	Class holds all the necessary information for mapping fields associated with fvMesh
CfvMeshPrimitiveLduAddressing	Variant of fvMeshLduAddressing that contains addressing instead of slices
CfvMeshSubset	Holds a reference to the original mesh (the baseMesh) and optionally to a subset of that mesh (the subMesh) with mapping lists for points, faces, and cells
CfvMeshSubsetProxy	Simple proxy for holding a mesh, or mesh-subset. The subMeshes are currently limited to cellSet or cellZone definitions
CfvMeshSubsetter	Extends Foam::fvMeshSubset with two-step subsetting (uses polyTopoChange modification)
CfvMeshTools	A collection of tools for operating on an fvMesh
CfvMotionSolver	Base class for fvMesh based motionSolvers
CfvMotionSolverEngineMesh	Foam::fvMotionSolverEngineMesh
CfvPatch	A finiteVolume patch using a polyPatch and a fvBoundaryMesh
CfvPatchField	Abstract base class with a fat-interface to all derived classes covering all possible ways in which they might be used
CfvPatchFieldMapper	A FieldMapper for finite-volume patch fields
CfvPatchMapper	Mapping class for a fvPatchField
CfvSchemes	Selector class for finite volume differencing schemes. fvMesh is derived from fvSchemes so that all fields have access to the fvSchemes from the mesh reference they hold
CfvSolution	Selector class for finite volume solution solution. fvMesh is derived from fvSolution so that all fields have access to the fvSolution from the mesh reference they hold
CfvsPatchField	An abstract base class with a fat-interface to all derived classes covering all possible ways in which they might be used
CfvSurfaceMapper	FV surface mapper
CGAMGAgglomeration	Geometric agglomerated algebraic multigrid agglomeration class
CGAMGInterface	Abstract base class for GAMG agglomerated interfaces
CGAMGInterfaceField	Abstract base class for GAMG agglomerated interface fields
CGAMGPreconditioner	Geometric agglomerated algebraic multigrid preconditioner
CGAMGProcAgglomeration	Processor agglomeration of GAMGAgglomerations
CGAMGSolver	Geometric agglomerated algebraic multigrid solver
CGammaLimiter	Class with limiter function which returns the limiter for the Gamma differencing scheme based on phict obtained from the LimiterFunc class
CGammaWeight	Class with operator() which returns the weighting factors for the Gamma differencing scheme. Used in conjunction with the template class NVDscheme
CGaussSeidelSmoother	A lduMatrix::smoother for Gauss-Seidel
CgenericFaPatchField	This boundary condition provides a generic version of the calculated condition, useful as a fallback for handling unknown patch types. Not generally applicable as a user-specified condition
CgenericFvPatch	FV variant of the genericPolyPatch
CgenericFvPatchField	This boundary condition provides a generic version of the calculated condition, useful as a fallback for handling unknown patch types. Not generally applicable as a user-specified condition
CgenericFvsPatchField	This boundary condition provides a generic version of the calculated condition, useful as a fallback for handling unknown patch types. Not generally applicable as a user-specified condition
CgenericPatchFieldBase	Generic infrastructure for reading/writing unknown patch types
CgenericPointPatch	Substitute for unknown patches. Used for postprocessing when only basic polyPatch info is needed
CgenericPointPatchField	A generic version of calculatedPointPatchField, useful as a fallback for handling unknown patch types
CgenericPolyPatch	Substitute for unknown patches. Used for postprocessing when only basic polyPatch info is needed or if the real patch type is unavailable
CgeomCellLooper	Implementation of cellLooper. Does pure geometric cut through cell
CgeomDecomp	Base for geometrical domain decomposition methods
CGeoMesh	Generic mesh wrapper used by volMesh, surfaceMesh, pointMesh etc
CGeometricBoundaryField	Generic GeometricBoundaryField class
CGeometricField	Generic GeometricField class
CGeometricMeshObject
CgeometricOneField	A class representing the concept of a GeometricField of 1 used to avoid unnecessary manipulations for objects which are known to be one at compile-time
►CgeometricSurfacePatch	Identifies a surface patch/zone by name and index, with geometric type
CfromIdentifier	Helper to convert identifier types as an operation
CgeometricZeroField	A class representing the concept of a GeometricField of 0 used to avoid unnecessary manipulations for objects which are known to be zero at compile-time
CgetNameOp	Deprecated(2020-11) use nameOp (word.H)
CgetTypeOp	Deprecated(2020-11) use typeOp (word.H)
►CglobalIndex	Calculates a unique integer (label so might not have enough room - 2G max) for processor + local index. E.g
CgatherNone	Dispatch tag
CgatherOnly	Dispatch tag
►CglobalIndexAndTransform	Determination and storage of the possible independent transforms introduced by coupledPolyPatches, as well as all of the possible permutations of these transforms generated by the presence of multiple coupledPolyPatches, i.e. more than one cyclic boundary. Note that any given point can be on maximum 3 transforms only (and these transforms have to be perpendicular)
Cless	Less function class used in sorting encoded transforms and indices
CGlobalIOField	IOField with global data (so optionally read from master)
CGlobalIOList	IOList with global data (so optionally read from master)
►CglobalMeshData	Various mesh related information for a parallel run. Upon construction, constructs all info using parallel communication
CListPlusEqOp	Deprecated(2020-09) use ListOps::appendEqOp
CglobalPoints	Calculates points shared by more than two processor patches or cyclic patches
CGradientDispersionRAS	The velocity is perturbed in the direction of -grad(k), with a Gaussian random number distribution with variance sigma. where sigma is defined below
CgradientEnergyFvPatchScalarField	This boundary condition provides a gradient condition for internal energy, where the gradient is calculated using:
CgradientUnburntEnthalpyFvPatchScalarField	Gradient boundary condition for unburnt
CgradingDescriptor	Handles the specification for grading within a section of a block
CgradingDescriptors	List of gradingDescriptor for the sections of a block with additional IO functionality
►Cgraph	Class to create, store and output qgraph files
Cwriter	Abstract base class for a graph writer
CGravityForce	Calculates particle gravity force
CgreaterEqOp
CgreaterEqOp2
CgreaterEqualOp
CgreaterEqualOp1
CgreaterEqualOp2
CgreaterOp
CgreaterOp1
CgreaterOp2
CH2O	Water
ChaloToCell	A topoSetCellSource to select cells attached to the outside of this cellSet, and add into/remove from this cellSet
Charmonic	Harmonic-mean differencing scheme class
CHash	Hash function class. The default definition is for primitives. Non-primitives used to hash entries on hash tables will need a specialized version
CHash< bitSet >	Hashing for bitSet data
CHash< bool >	Hashing of integral type: bool
CHash< char >	Hashing of integral type: char
CHash< DynamicList< T, SizeMin > >	Hashing for List data
CHash< edge >	Hashing for edge uses commutative (incremental) hash
CHash< ensight::FileName >	Hashing for FileName is the same as string
CHash< ensight::VarName >	Hashing for VarName is the same as string
CHash< expressions::exprString >	Hashing for exprString is the same as string
CHash< face >	Hash face as contiguous (non-commutative) list data
CHash< fileName >	Hashing for fileName
CHash< FixedList< T, N > >	Hashing for FixedList data
CHash< int32_t >	Hashing of integral type: int32_t
CHash< int64_t >	Hashing of integral type: int64_t
CHash< keyType >	Hashing for keyType
CHash< List< T > >	Hashing for List data
CHash< PackedList< Width > >	Hashing for PackedList data
CHash< Pair< T > >	Hashing for Pair of data
CHash< phasePairKey >	Hashing for phasePairKey
CHash< std::nullptr_t >	Hashing of nullptr, always 0
CHash< std::pair< T1, T2 > >	Hashing for std::pair data
CHash< std::string >	Hashing for std:::string
CHash< string >	Hashing for Foam::string
CHash< triFace >	Hashing for triFace uses commutative (incremental) hash
CHash< Tuple2< T1, T2 > >	Hashing for Tuple2 data
CHash< uint32_t >	Hashing of integral type: uint32_t
CHash< UList< T > >	Hashing for List data
CHash< void * >	Hashing of pointers, treat as unsigned integer
CHash< word >	Hashing for word
CHash< wordRe >	Hashing for wordRe
ChashedWordList	A wordList with hashed named lookup, which can be faster in some situations than using the normal list find/found methods
CHashPtrTable	A HashTable of pointers to objects of type <T>, with deallocation management of the pointers
CHashSet	A HashTable with keys but without contents that is similar to std::unordered_set
►CHashTable	A HashTable similar to std::unordered_map
Cconst_iterator	Forward iterator with const access
CIterator	Internally used base for iterator and const_iterator
Citerator	Forward iterator with non-const access
Ckey_iterator_base	An iterator wrapper for returning a reference to the key
►CHashTableCore	Bits that are independent of HashTable template parameters
Cconst_iterator_pair	Factory class for creating a begin/end pair for any const iterator
ChConstThermo	Constant properties thermodynamics package templated into the EquationOfState
CHeatTransferCoeff	Calculates and writes particle heat transfer coefficient field on the cloud
CheatTransferCoeffModel	An abstract base class for heat transfer coeffcient models
CheatTransferModel
CHeatTransferModel	Templated class to calculate the fluid-particle heat transfer coefficients based on a specified Nusselt-number model
CheheuPsiThermo
ChelpType	Base class for foam help classes
ChePsiThermo	Energy for a mixture based on compressibility
CheRhoThermo	Energy for a mixture based on density
CheSolidThermo	Energy for a solid mixture
CHeterogeneousReactingModel	Base class for heterogeneous reacting models
CheThermo	Enthalpy/Internal energy for a mixture
ChexBlock	Hex block definition used in the cfx converter
ChexCell	A hexahedral cell primitive
ChexCellLooper	Implementation of cellLooper
ChexMatcher	A cellMatcher for hex cells (cellModel::HEX)
ChexRef8	Refinement of (split) hexes using polyTopoChange
ChexRef8Data	Various for reading/decomposing/reconstructing/distributing refinement data
ChierarchGeomDecomp	Does hierarchical decomposition of points, selectable as hierarchical
ChighAspectRatioFvGeometryScheme	Geometry calculation scheme with automatic stabilisation for high-aspect ratio cells
CHistogram	Calculates the counts per bin of a list
CholeToFace	A topoSetFaceSource to select a set of faces that closes a hole i.e. disconnects zones (specified by locations) from one another
ChomogeneousMixture	The homogeneous mixture contains species ("b")
ChPolynomialThermo	Thermodynamics package templated on the equation of state, using polynomial functions for cp, h and s
ChPowerThermo	Power-function based thermodynamics package templated on EquationOfState
ChTabulatedThermo	Enthalpy based thermodynamics package using non-uniform tabulated data for heat capacity vs temperature
ChumidityTemperatureCoupledMixedFvPatchScalarField
ChypotOp	Hypot operation (scalar only)
CiC3H8O	Iso-propanol
CIC8H18	Iso-Octane
CicoPolynomial	Incompressible, polynomial form of equation of state, using a polynomial function for density
CicoTabulated	Incompressible of equation of state using non-uniform tabulated density vs temperature
CIDEA	The IDEA fuel is constructed by adding 30% alphaMethylNaphthalene with 70% n-decane
►CIdentity	Templated identity and dual space identity tensors derived from SphericalTensor
Cdual	The identity type in the dual space
CidentityOp
CifEqEqOp	Reduction class. If x and y are not equal assign value
CIFstream	Input from file stream, using an ISstream
CifstreamPointer	A wrapped std::ifstream with possible compression handling (igzstream) that behaves much like a std::unique_ptr
Cignition	Foam::ignition
►CignitionSite	Foam::ignitionSite
CiNew	Read-construction of PtrLists of ignitionSite
CijkAddressing	A simple i-j-k (row-major order) to linear addressing
CIjkField	Generic templated field type with i-j-k addressing
CijkMesh	A simple i-j-k (row-major order) to linear addressing for a rectilinear mesh. Since the underlying mesh is rectilinear, some mesh-related sizing information can be derived directly from the addressing information
CIListStream	An ISstream with internal List storage. Always UNCOMPRESSED
CILList	Template class for intrusive linked lists
CImanip	An Istream manipulator taking arguments
CimmiscibleIncompressibleThreePhaseMixture	An immiscible incompressible two-phase mixture transport model
CimmiscibleIncompressibleTwoPhaseMixture	An immiscible incompressible two-phase mixture transport model
CimplicitFunction	Base class for implicit functions
CinclinedFilmNusseltHeightFvPatchScalarField	Film height boundary condition for inclined films that imposes a sinusoidal perturbation on top of a mean flow rate, where the height is calculated using the Nusselt solution
CinclinedFilmNusseltInletVelocityFvPatchVectorField	Film velocity boundary condition for inclined films that imposes a sinusoidal perturbation on top of a mean flow rate, where the velocity is calculated using the Nusselt solution
CincompressibleAdjointMeanFlowVars	Manages the adjoint mean flow fields and their mean values
CincompressibleAdjointSolver	Base class for incompressibleAdjoint solvers
CincompressibleAdjointVars	Class including all adjoint fields for incompressible flows
CincompressibleInterPhaseTransportModel	Transport model selection class for the incompressibleInterFoam family of solvers
CincompressiblePerfectGas	Incompressible gas equation of state using a constant reference pressure in the perfect gas equation of state rather than the local pressure so that the density only varies with temperature and composition
CincompressiblePrimalSolver	Base class for primal incompressible solvers
CincompressibleRhoTurbulenceModel	Abstract base class for turbulence models (RAS, LES and laminar)
CincompressibleThreePhaseMixture
CincompressibleTurbulenceModel	Abstract base class for turbulence models (RAS, LES and laminar)
CIncompressibleTurbulenceModel	Templated abstract base class for single-phase incompressible turbulence models
CincompressibleTwoPhaseInteractingMixture	A two-phase incompressible transportModel for interacting phases requiring the direct evaluation of the mixture viscosity, e.g. activated sludge or slurry
CincompressibleTwoPhaseMixture	A two-phase incompressible transportModel
CincompressibleVars	Base class for solution control classes
CindexedCellEnum
►CindexedOctree	Non-pointer based hierarchical recursive searching
Cnode	Tree node. Has up pointer and down pointers
CindexedParticle	Adds label index to base particle
CindexedParticleCloud	A Cloud of particles carrying an additional index
CindexedVertexEnum
CIndirectList	A List with indirect addressing
CIndirectListAddressing	A class for storing list addressing (labels, slices etc), which are normally to used by IndirectList. Private inheritance is often used by any inheriting classes
►CIndirectListBase	Base for lists with indirect addressing, templated on the list contents type and the addressing type. Storage for both values and addressing is held outside of the class
Cconst_iterator	A const iterator for an indirect list
Citerator	A non-const iterator for an indirect list
CIndirectSubList	Indirect access to a sub-section of a list
CInertPhaseModel	Class which represents an inert phase, with no reactions. Returns zero reaction rate and heat
CINew	A helper class when constructing from an Istream or dictionary
CinfiniteReactionRate	Infinite reaction rate
CInflationInjection	Inflation injection - creates new particles by splitting existing particles within in a set of generation cells, then inflating them to a target diameter within the generation cells and an additional set of inflation cells
CInflowBoundaryModel	Templated inflow boundary model class
CInfoProxy	A helper class for outputting values to Ostream
CinhomogeneousMixture	The inhomogeneous mixture contains species ("ft", "b")
CinitialPointsMethod	Abstract base class for generating initial points for a conformalVoronoiMesh
►CinjectedParticle	Primarily stores particle properties so that it can be injected at a later time. Note that this stores its own local position as opposed to the base particle class barycentric coordinates since the particle is not (usually) attached to a mesh, and instead used for post-processing
CiNew	Factory class to read-construct particles used for
CinjectedParticleCloud
CInjectedParticleDistributionInjection	Interrogates an injectedParticleCloud to convert the raw particle data into a set of 'binned' injectors
CInjectedParticleInjection	Replays an set of particle data based on an injectedParticleCloud, using the assumption of one particle per parcel
CInjectionModel	Templated injection model class
CInjectionModelList	List of injection models
CinletOutletFaPatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CinletOutletFvPatchField	This boundary condition provides a generic outflow condition, with specified inflow for the case of return flow
CinletOutletTotalTemperatureFvPatchScalarField	This boundary condition provides an outflow condition for total temperature for use with supersonic cases, where a user-specified value is applied in the case of reverse flow
CinnerProduct
CinnerProduct< one, arg2 >
CinnerProduct< SphericalTensor2D< Cmpt >, SphericalTensor2D< Cmpt > >
CinnerProduct< SphericalTensor2D< Cmpt >, SymmTensor2D< Cmpt > >
CinnerProduct< SphericalTensor2D< Cmpt >, Tensor2D< Cmpt > >
CinnerProduct< SphericalTensor2D< Cmpt >, Vector2D< Cmpt > >
CinnerProduct< SphericalTensor< Cmpt >, SphericalTensor< Cmpt > >
CinnerProduct< SphericalTensor< Cmpt >, SymmTensor< Cmpt > >
CinnerProduct< SphericalTensor< Cmpt >, Tensor< Cmpt > >
CinnerProduct< SphericalTensor< Cmpt >, Vector< Cmpt > >
CinnerProduct< SymmTensor2D< Cmpt >, SphericalTensor2D< Cmpt > >
CinnerProduct< SymmTensor2D< Cmpt >, SymmTensor2D< Cmpt > >
CinnerProduct< SymmTensor2D< Cmpt >, Vector2D< Cmpt > >
CinnerProduct< SymmTensor< Cmpt >, SphericalTensor< Cmpt > >
CinnerProduct< SymmTensor< Cmpt >, SymmTensor< Cmpt > >
CinnerProduct< SymmTensor< Cmpt >, Tensor< Cmpt > >
CinnerProduct< SymmTensor< Cmpt >, Vector< Cmpt > >
CinnerProduct< Tensor2D< Cmpt >, SphericalTensor2D< Cmpt > >
CinnerProduct< Tensor2D< Cmpt >, Tensor2D< Cmpt > >
CinnerProduct< Tensor2D< Cmpt >, Vector2D< Cmpt > >
CinnerProduct< Tensor< Cmpt >, SphericalTensor< Cmpt > >
CinnerProduct< Tensor< Cmpt >, SymmTensor< Cmpt > >
CinnerProduct< Vector2D< Cmpt >, SphericalTensor2D< Cmpt > >
CinnerProduct< Vector2D< Cmpt >, SymmTensor2D< Cmpt > >
CinnerProduct< Vector2D< Cmpt >, Tensor2D< Cmpt > >
CinnerProduct< Vector< Cmpt >, scalar >	Dummy innerProduct for scalar to allow the construction of vtables for
CinnerProduct< Vector< Cmpt >, SphericalTensor< Cmpt > >
CinnerProduct< Vector< Cmpt >, SymmTensor< Cmpt > >
►CInstant	A tuple of scalar value and key. The value often corresponds to a time value, thus the naming of the class. The key will usually be a time name or a file name etc
Cless	Less function for sorting
Cinstant	An instant of time. Contains the time value and name. Uses Foam::Time when formatting the name
CintegrationScheme	Base for a set of schemes which integrate simple ODEs which arise from semi-implcit rate expressions
CInteractionLists	Builds direct interaction list, specifying which local (real) cells are potentially in range of each other
CinterfaceCompositionModel	Generic base class for interface models. Mass transfer models are interface models between two thermos. Abstract class for mass transfer functions
CInterfaceCompositionModel	Base class for interface composition models, templated on the two thermodynamic models either side of the interface
CInterfaceCompositionPhaseChangePhaseSystem	Class to provide interfacial heat and mass transfer between a number of phases according to a interface composition model
CinterfaceCompressionFvPatchScalarField	Applies interface-compression to the phase-fraction distribution at the patch by setting the phase-fraction to 0 if it is below 0.5, otherwise to 1
CinterfaceCompressionLimiter	Interface compression scheme currently based on the generic limited scheme although it does not use the NVD/TVD functions
CInterfaceForce	Vector force apply to particles to avoid the crossing of particles from one phase to the other. The magnitude is calculated as C*mass*grad(alpha)
CinterfaceProperties	Contains the interface properties
CinterfaceTrackingFvMesh	The interfaceTrackingFvMesh
Cinterpolation	Abstract base class for volume field interpolation
Cinterpolation2DTable	2D table interpolation. The data must be in ascending order in both dimensions x and y
CinterpolationCell	Uses the cell value for any location within the cell
CinterpolationCellPatchConstrained	Uses the cell value for any point in the cell apart from a boundary face where it uses the boundary value directly. Note: will not work on an empty patch
CinterpolationCellPoint	Given cell centre values and point (vertex) values decompose into tetrahedra and linear interpolate within them
CinterpolationCellPointFace	Foam::interpolationCellPointFace
CinterpolationCellPointWallModified	Same as interpolationCellPoint, but if interpolating a wall face, uses cell centre value instead
CinterpolationLookUpTable	A list of lists. Interpolates based on the first dimension. The values must be positive and monotonically increasing in each dimension
CinterpolationPointMVC	Given cell centre values interpolates to vertices and uses these to do a Mean Value Coordinates interpolation
CinterpolationTable	An interpolation/look-up table of scalar vs <Type> values. The reference scalar values must be monotonically increasing
CinterpolationWeights	Abstract base class for interpolating in 1D
CintersectedSurface	Given triSurface and intersection creates the intersected (properly triangulated) surface. (note: intersection is the list of points and edges 'shared' by two surfaces)
Cintersection	Foam::intersection
CinterstitialInletVelocityFvPatchVectorField	Inlet velocity in which the actual interstitial velocity is calculated by dividing the specified inletVelocity field with the local phase-fraction
►CIntRange	An interval of (signed) integers defined by a start and a size
Cconst_iterator	Random-access input iterator with const access
Cconst_reverse_iterator	Random-access reverse input iterator with const access
Cge0	Unary predicate for greater-equal 0 (int values)
Cgt0	Unary predicate for greater than 0 (int values)
Cle0	Unary predicate for less-equal 0 (int values)
Clt0	Unary predicate for less than 0 (int values)
CinverseDistanceDiffusivity	Inverse distance to the given patches motion diffusivity
CinverseFaceDistanceDiffusivity	Inverse distance to the given patches motion diffusivity
CinversePointDistanceDiffusivity	Inverse distance to the given patches motion diffusivity
CinverseVolumeDiffusivity	Inverse cell-volume motion diffusivity
CIOdictionary	IOdictionary is derived from dictionary and IOobject to give the dictionary automatic IO functionality via the objectRegistry. To facilitate IO, IOdictionary is provided with a constructor from IOobject and with readData/writeData functions
CIOerror	Report an I/O error
CIOField	A primitive field of type <T> with automated input and output
CIOFieldRef	A IOField wrapper for writing external data
CIOList	A List of objects of type <T> with automated input and output
CIOListRef	A IOList wrapper for writing external data
CIOMap	A Map of objects of type <T> with automated input and output. Is a global object; i.e. can be read from undecomposed case
CIOmapDistribute	IOmapDistribute is derived from mapDistribute and IOobject to give the mapDistribute automatic IO functionality via the objectRegistry
CIOmapDistributePolyMesh	IOmapDistributePolyMesh is derived from mapDistributePolyMesh and IOobject to give the mapDistributePolyMesh automatic IO functionality via the objectRegistry
CIOmapDistributePolyMeshRef	A IOmapDistributePolyMesh wrapper for using referenced external data
CIOMRFZoneList	List of MRF zones with IO functionality. MRF zones are specified by a list of dictionary entries, e.g
CIOobject	Defines the attributes of an object for which implicit objectRegistry management is supported, and provides the infrastructure for performing stream I/O
CIOobjectList	List of IOobjects with searching and retrieving facilities
CIOporosityModelList	List of porosity models with IO functionality
CIOPosition	Helper IO class to read and write particle coordinates (positions)
CIOPtrList	A PtrList of objects of type <T> with automated input and output
CIOstream	An IOstream is an abstract base class for all input/output systems; be they streams, files, token lists etc
►CIOstreamOption	The IOstreamOption is a simple container for options an IOstream can normally have
CversionNumber	Representation of a major/minor version number
CIPBstream
CIPstream	Input inter-processor communications stream
CIrreversibleReaction	Simple extension of Reaction to handle reversible reactions using equilibrium thermodynamics
Cis_contiguous	A template class to specify that a data type can be considered as being contiguous in memory
Cis_contiguous< Barycentric2D< Cmpt > >	Data are contiguous if component type is contiguous
Cis_contiguous< Barycentric< Cmpt > >	Data are contiguous if component type is contiguous
Cis_contiguous< BarycentricTensor< Cmpt > >	Data are contiguous if component type is contiguous
Cis_contiguous< basicHeterogeneousReactingParcel >	Non-contiguous data for basicHeterogeneousReactingParcel
Cis_contiguous< basicKinematicMPPICParcel >	Contiguous data for basicKinematicMPPICParcel
Cis_contiguous< basicKinematicParcel >	Contiguous data for basicKinematicParcel
Cis_contiguous< basicReactingMultiphaseParcel >	Non-contiguous data for basicReactingMultiphaseParcel
Cis_contiguous< basicReactingParcel >	Non-contiguous data for basicReactingParcel
Cis_contiguous< basicSprayParcel >	Non-contiguous data for basicSprayParcel
Cis_contiguous< basicThermoParcel >	Contiguous data for basicThermoParcel
Cis_contiguous< boolVector >	A boolVector is contiguous (FixedList of bool)
Cis_contiguous< boundBox >	Contiguous data for boundBox
Cis_contiguous< cellInfo >	Contiguous data for cellInfo
Cis_contiguous< coalParcel >	Non-contiguous data for coalParcel
Cis_contiguous< CompactSpatialTensor< Cmpt > >	Data are contiguous if component type is contiguous
Cis_contiguous< CompactSpatialTensorT< Cmpt > >	Data are contiguous if component type is contiguous
Cis_contiguous< complex >	Contiguous data for complex
Cis_contiguous< DiagTensor< Cmpt > >	Data are contiguous if component type is contiguous
Cis_contiguous< directionalWallPointData< bool > >
Cis_contiguous< directionalWallPointData< label > >
Cis_contiguous< directionalWallPointData< scalar > >
Cis_contiguous< directionInfo >	Contiguous data for directionInfo
Cis_contiguous< edge >	Contiguous data for edge (a pair of labels)
Cis_contiguous< edgeTopoDistanceData< Type, PrimitivePatchType > >	Data are contiguous if data type is contiguous
Cis_contiguous< externalPointEdgePoint >	Contiguous data for externalPointEdgePoint
Cis_contiguous< findCellParticle >	Contiguous data for findCellParticle
Cis_contiguous< FixedList< T, N > >	FixedList is contiguous if the type is contiguous
Cis_contiguous< hexCell >	Contiguous data for hexCell
Cis_contiguous< indexedCellEnum >	Contiguous data for indexedCellEnum
Cis_contiguous< indexedVertexEnum >	Contiguous data for indexedVertexEnum
Cis_contiguous< labelledTri >	Contiguous data for labelledTri
Cis_contiguous< LESModels::smoothDelta::deltaData >	Contiguous data for deltaData
Cis_contiguous< meshToMeshData >	Contiguous data for meshToMeshData
Cis_contiguous< minData >	Contiguous data for minData
Cis_contiguous< Pair< T > >	Pair is contiguous if the type is contiguous
Cis_contiguous< patchEdgeFaceInfo >	Contiguous data for patchEdgeFaceInfo
Cis_contiguous< patchEdgeFaceRegion >	Contiguous data for patchEdgeFaceRegion
Cis_contiguous< patchFaceOrientation >	Contiguous data for patchFaceOrientation
Cis_contiguous< pointConstraint >	Contiguous data for pointConstraint
Cis_contiguous< PointData< DataType > >	Data are contiguous if data type is contiguous
Cis_contiguous< pointEdgeCollapse >	Contiguous data for pointEdgeCollapse
Cis_contiguous< pointEdgePoint >	Contiguous data for pointEdgePoint
Cis_contiguous< pointEdgeStructuredWalk >	Contiguous data for pointEdgeStructuredWalk
Cis_contiguous< pointIndexHit >	Contiguous data for pointIndexHit
Cis_contiguous< PointIntegrateData< DataType > >	Data are contiguous if the data type is contiguous
Cis_contiguous< pointTopoDistanceData< Type > >	Data are contiguous if data type is contiguous
Cis_contiguous< quaternion >	Contiguous data for quaternion
Cis_contiguous< refinementData >	Contiguous data for refinementData
Cis_contiguous< refinementDistanceData >	Contiguous data for refinementDistanceData
Cis_contiguous< septernion >	Contiguous data for septernion
Cis_contiguous< smoothData >	Contiguous data for smoothData
Cis_contiguous< solidParticle >	Contiguous data for solidParticle
Cis_contiguous< SpatialTensor< Cmpt > >	Data are contiguous if component type is contiguous
Cis_contiguous< SpatialVector< Cmpt > >	Data are contiguous if component type is contiguous
Cis_contiguous< SphericalTensor2D< Cmpt > >	Data are contiguous if component type is contiguous
Cis_contiguous< SphericalTensor< Cmpt > >	Data are contiguous if component type is contiguous
Cis_contiguous< sweepData >	Contiguous data for sweepData
Cis_contiguous< SymmTensor2D< Cmpt > >	Data are contiguous if component type is contiguous
Cis_contiguous< SymmTensor< Cmpt > >	Data are contiguous if component type is contiguous
Cis_contiguous< Tensor2D< Cmpt > >	Data are contiguous if component type is contiguous
Cis_contiguous< Tensor< Cmpt > >	Data are contiguous if component type is contiguous
Cis_contiguous< tetCell >	Contiguous data for tetCell
Cis_contiguous< tetIndices >	Contiguous data for tetIndices
Cis_contiguous< topoDistanceData< Type > >	Data are contiguous if data type is contiguous
Cis_contiguous< trackedParticle >	Contiguous data for trackedParticle
Cis_contiguous< transportData >	Contiguous data for transportData
Cis_contiguous< treeBoundBox >	Contiguous data for treeBoundBox
Cis_contiguous< triad >	Contiguous data for triad
Cis_contiguous< triFace >	Contiguous data for triFace
Cis_contiguous< Vector2D< Cmpt > >	Data are contiguous if component type is contiguous
Cis_contiguous< Vector< Cmpt > >	Data are contiguous if component type is contiguous
Cis_contiguous< vectorTensorTransform >	Contiguous data for vectorTensorTransform
Cis_contiguous< volumeType >	Contiguous data for volumeType
Cis_contiguous< wallNormalInfo >	Contiguous data for wallNormalInfo
Cis_contiguous< wallPoint >	Contiguous data for wallPoint
Cis_contiguous< wallPointData< Type > >	Data are contiguous if data type is contiguous
Cis_contiguous< wallPointYPlus >	Contiguous data for wallPointYPlus
Cis_contiguous_label	A template class to specify if a data type is composed solely of Foam::label elements
Cis_contiguous_label< Barycentric2D< Cmpt > >	Data are contiguous label if component type is label
Cis_contiguous_label< Barycentric< Cmpt > >	Data are contiguous label if component type is label
Cis_contiguous_label< BarycentricTensor< Cmpt > >	Data are contiguous label if component type is label
Cis_contiguous_label< cellInfo >	Contiguous label data for cellInfo
Cis_contiguous_label< CompactSpatialTensor< Cmpt > >	Data are contiguous label if component type is label
Cis_contiguous_label< CompactSpatialTensorT< Cmpt > >	Data are contiguous label if component type is label
Cis_contiguous_label< DiagTensor< Cmpt > >	Data are contiguous label if component type is label
Cis_contiguous_label< edge >	Contiguous label data for edge (a pair of labels)
Cis_contiguous_label< edgeTopoDistanceData< Type, PrimitivePatchType > >	Data are contiguous label if data type is label
Cis_contiguous_label< FixedList< T, N > >	Check for FixedList of labels
Cis_contiguous_label< hexCell >	Contiguous label data for hexCell
Cis_contiguous_label< labelledTri >	Contiguous label data for labelledTri
Cis_contiguous_label< meshToMeshData >	Contiguous label data for meshToMeshData
Cis_contiguous_label< minData >	Contiguous label data for minData
Cis_contiguous_label< Pair< T > >	Check for Pair of labels
Cis_contiguous_label< patchEdgeFaceRegion >	Contiguous label data for patchEdgeFaceRegion
Cis_contiguous_label< patchFaceOrientation >	Contiguous label data for patchFaceOrientation
Cis_contiguous_label< pointTopoDistanceData< Type > >	Data are contiguous label if data type is label
Cis_contiguous_label< refinementData >	Contiguous label data for refinementData
Cis_contiguous_label< SpatialTensor< Cmpt > >	Data are contiguous label if component type is label
Cis_contiguous_label< SpatialVector< Cmpt > >	Data are contiguous label if component type is label
Cis_contiguous_label< SphericalTensor2D< Cmpt > >	Data are contiguous label if component type is label
Cis_contiguous_label< SphericalTensor< Cmpt > >	Data are contiguous label if component type is label
Cis_contiguous_label< SymmTensor2D< Cmpt > >	Data are contiguous label if component type is label
Cis_contiguous_label< SymmTensor< Cmpt > >	Data are contiguous label if component type is label
Cis_contiguous_label< Tensor2D< Cmpt > >	Data are contiguous label if component type is label
Cis_contiguous_label< Tensor< Cmpt > >	Data are contiguous label if component type is label
Cis_contiguous_label< tetCell >	Contiguous label data for tetCell
Cis_contiguous_label< tetIndices >	Contiguous label data for tetIndices
Cis_contiguous_label< topoDistanceData< Type > >	Data are contiguous label if data type is label
Cis_contiguous_label< triFace >	Contiguous label data for triFace
Cis_contiguous_label< Vector2D< Cmpt > >	Data are contiguous label if component type is label
Cis_contiguous_label< Vector< Cmpt > >	Data are contiguous label if component type is label
Cis_contiguous_label< wallPointData< Type > >	Data are contiguous label if data type is label
Cis_contiguous_scalar	A template class to specify if a data type is composed solely of Foam::scalar elements
Cis_contiguous_scalar< Barycentric2D< Cmpt > >	Data are contiguous scalar if component type is scalar
Cis_contiguous_scalar< Barycentric< Cmpt > >	Data are contiguous scalar if component type is scalar
Cis_contiguous_scalar< BarycentricTensor< Cmpt > >	Data are contiguous scalar if component type is scalar
Cis_contiguous_scalar< boundBox >	Contiguous scalar data for boundBox
Cis_contiguous_scalar< CompactSpatialTensor< Cmpt > >	Data are contiguous scalar if component type is scalar
Cis_contiguous_scalar< CompactSpatialTensorT< Cmpt > >	Data are contiguous scalar if component type is scalar
Cis_contiguous_scalar< complex >	Contiguous scalar data for complex
Cis_contiguous_scalar< DiagTensor< Cmpt > >	Data are contiguous scalar if component type is scalar
Cis_contiguous_scalar< edgeTopoDistanceData< Type, PrimitivePatchType > >	Data are contiguous scalar if data type is scalar
Cis_contiguous_scalar< FixedList< T, N > >	Check for FixedList of scalars
Cis_contiguous_scalar< Pair< T > >	Check for Pair of scalars
Cis_contiguous_scalar< patchEdgeFaceInfo >	Contiguous scalar data for patchEdgeFaceInfo
Cis_contiguous_scalar< PointData< DataType > >	Contiguous scalar only when data type is also scalar
Cis_contiguous_scalar< pointEdgePoint >	Contiguous scalar data for pointEdgePoint
Cis_contiguous_scalar< pointTopoDistanceData< Type > >	Data are contiguous scalar if data type is scalar
Cis_contiguous_scalar< quaternion >	Contiguous scalar data for quaternion
Cis_contiguous_scalar< septernion >	Contiguous scalar data for septernion
Cis_contiguous_scalar< SpatialTensor< Cmpt > >	Data are contiguous scalar if component type is scalar
Cis_contiguous_scalar< SpatialVector< Cmpt > >	Data are contiguous scalar if component type is scalar
Cis_contiguous_scalar< SphericalTensor2D< Cmpt > >	Data are contiguous scalar if component type is scalar
Cis_contiguous_scalar< SphericalTensor< Cmpt > >	Data are contiguous scalar if component type is scalar
Cis_contiguous_scalar< SymmTensor2D< Cmpt > >	Data are contiguous scalar if component type is scalar
Cis_contiguous_scalar< SymmTensor< Cmpt > >	Data are contiguous scalar if component type is scalar
Cis_contiguous_scalar< Tensor2D< Cmpt > >	Data are contiguous scalar if component type is scalar
Cis_contiguous_scalar< Tensor< Cmpt > >	Data are contiguous scalar if component type is scalar
Cis_contiguous_scalar< topoDistanceData< Type > >	Data are contiguous scalar if data type is scalar
Cis_contiguous_scalar< treeBoundBox >	Contiguous scalar data for treeBoundBox
Cis_contiguous_scalar< triad >	Contiguous 'scalar' data for triad
Cis_contiguous_scalar< Vector2D< Cmpt > >	Data are contiguous scalar if component type is scalar
Cis_contiguous_scalar< Vector< Cmpt > >	Data are contiguous scalar if component type is scalar
Cis_contiguous_scalar< wallPoint >	Contiguous scalar data for wallPoint
Cis_contiguous_scalar< wallPointData< Type > >	Data are contiguous scalar if data type is scalar
CisAOp	Check if dynamic_cast to TargetType is possible, as a functor
CisNotEqOp
CisoAdvection	An implementation of the isoAdvector geometric Volume-of-Fluid method advancing the provided volume fraction field (alpha1) in time using the given velocity field, U, and corresponding face fluxes, phi
CisoSurfaceBase	Low-level components common to various iso-surface algorithms
CisoSurfaceCell	A surface formed by the iso value. After "Polygonising A Scalar Field Using Tetrahedrons", Paul Bourke (http://paulbourke.net/geometry/polygonise) and "Regularised Marching Tetrahedra: improved iso-surface extraction", G.M. Treece, R.W. Prager and A.H. Gee
CisoSurfaceParams	Preferences for controlling iso-surface algorithms
CisoSurfacePoint	A surface formed by the iso value. After "Regularised Marching Tetrahedra: improved iso-surface extraction", G.M. Treece, R.W. Prager and A.H. Gee
CisoSurfaceTopo	Marching tet iso surface algorithm with optional filtering to keep only points originating from mesh edges
CIsothermalPhaseModel	Class which represents a phase for which the temperature (strictly energy) remains constant. Returns an empty energy equation and does nothing when correctThermo is called
CIsotropyModel	Base class for collisional return-to-isotropy models
CISstream	Generic input stream using a standard (STL) stream
CIstream	An Istream is an abstract base class for all input systems (streams, files, token lists etc). The basic operations are construct, close, read token, read primitive and read binary block
CIStringStream	Input from string buffer, using a ISstream. Always UNCOMPRESSED
CisTypeOp	Check is typeid is identical to the TargetType, as a functor
CisVolMesh	Template argument for type volMesh
CisVolMesh< volMesh >
CITstream	An input stream of tokens
CjanafThermo	JANAF tables based thermodynamics package templated into the equation of state
CJanevReactionRate	Janev, Langer, Evans and Post reaction rate
CJobInfo	Helper class for recording information about run/finished jobs, acts like global singleton
CJohnsonJacksonParticleSlipFvPatchVectorField	Partial slip boundary condition for the particulate velocity
CJohnsonJacksonParticleThetaFvPatchScalarField	Robin condition for the particulate granular temperature
CjumpCyclicAMIFvPatchField	This boundary condition provides a base class that enforces a cyclic condition with a specified 'jump' (or offset) between a pair of boundaries, whereby communication between the patches is performed using an arbitrary mesh interface (AMI) interpolation
CjumpCyclicFvPatchField	This boundary condition provides a base class for coupled-cyclic conditions with a specified 'jump' (or offset) between the values
CkahipDecomp	Domain decomposition using KaHIP http://algo2.iti.kit.edu/documents/kahip/
CkaqRWallFunctionFvPatchScalarField
CkeyType	A class for handling keywords in dictionaries
CKinematicCloud	Templated base class for kinematic cloud
CkinematicCloud	Virtual abstract base class for templated KinematicCloud
CKinematicLookupTableInjection	Particle injection sources read from look-up table. Each row corresponds to an injection site
►CKinematicParcel	Kinematic parcel class with rotational motion (as spherical particles only) and one/two-way coupling with the continuous phase
CconstantProperties	Class to hold kinematic particle constant properties
CiNew	Factory class to read-construct particles used for
CtrackingData
CkinematicParcelInjectionData	Container class to provide injection data for kinematic parcels
CKinematicReynoldsNumber	Calculates and writes particle Reynolds number field on the cloud. The normalisation factors are calculated without thermal effects
CKinematicSurfaceFilm	Kinematic parcel surface film model
CkLowReWallFunctionFvPatchScalarField	This boundary condition provides a wall function for the turbulent kinetic energy (i.e. k) for low- and high-Reynolds number simulations
CKmesh	Calculate the wavenumber vector field corresponding to the space vector field of a finite volume mesh;
CkOmegaSSTBase	Base class implementation of the k-omega-SST turbulence model for incompressible and compressible flows
CkqRWallFunctionFvPatchField	This boundary condition provides a simple wrapper around the zero-gradient condition, which can be used for the turbulent kinetic energy (i.e. k), square-root of turbulent kinetic energy (i.e. q) and Reynolds stress symmetric-tensor fields (i.e. R) for the cases of high Reynolds number flow using wall functions. It is not a wall-function condition
ClabelBits	A 29bits label and 3bits direction packed into single label
CLabelledItem	A container with an integer index that can be attached to any item. The index may be useful for sorting or storing additional information
ClabelledTri	A triFace with additional (region) index
ClabelOp	Conversion/extraction to label operation
ClabelOp< int32_t >	Convert (likely promote) from int32_t to label
ClabelOp< int64_t >	Convert (possibly truncate) from int64_t to label
ClabelRange	A range or interval of labels defined by a start and a size
ClabelRangeOp	Conversion/extraction to labelRange operation (functor)
ClabelRangeOp< polyPatch >	The labelRange of a polyPatch
ClabelRangeOp< surfZone >	The labelRange of a surfZone
►ClabelRanges	A list of labelRange
Cconst_iterator	Forward input iterator with const access
ClabelToCell	A topoSetCellSource to select cells based on explicitly given cell labels
ClabelToFace	A topoSetFaceSource to select faces based on explicitly given face labels
ClabelToPoint	A topoSetPointSource to select points based on explicitly given point labels
►ClagrangianFieldDecomposer	Lagrangian field decomposer
►CfieldsCache
CprivateCache
ClagrangianReconstructor	Reconstructor for lagrangian positions and fields
ClaminarFlameSpeed	Abstract class for laminar flame speed
ClaminarModel	Templated abstract base class for laminar transport models
CLandauTellerReactionRate	Landau-Teller reaction rate
CLangmuirHinshelwoodReactionRate	Power series reaction rate
ClaplaceFilter	Laplace filter for LES
ClaplacianMotionSolver	Similar to velocityLaplacian but iteratively solves the mesh displacement PDEs to account for non-orthogonality. The boundary displacement is set as a boundary condition on pointMotionU; the latter is generated automatically if not found. Assumes uniform diffusivity
CLarsenBorgnakkeVariableHardSphere	Variable Hard Sphere BinaryCollision Model with Larsen Borgnakke internal energy redistribution. Based on the INELRS subroutine in Bird's DSMC0R.FOR
ClayerAdditionRemoval	Cell layer addition mesh modifier
ClayeredEngineMesh	Foam::layeredEngineMesh
ClayerParameters	Simple container to keep together layer specific information
CLBFGS	The quasi-Newton Limited-memory BFGS formula. Keeps nPrevSteps_ of the y and s vectors and approximates the inverse areas through them. Values of 3 < nPrevSteps_ < 20 are suggested
ClduAddressing	The class contains the addressing required by the lduMatrix: upper, lower and losort
ClduCalculatedProcessorField	A lduProcessorField type bypassing coupledFvPatchField and holding a reference to the Field<Type>
ClduInterface	An abstract base class for implicitly-coupled interfaces e.g. processor and cyclic patches
CLduInterfaceField	An abstract base class for implicitly-coupled interface fields e.g. processor and cyclic patch fields
ClduInterfaceField	An abstract base class for implicitly-coupled interface fields e.g. processor and cyclic patch fields
►CLduMatrix	LduMatrix is a general matrix class in which the coefficients are stored as three arrays, one for the upper triangle, one for the lower triangle and a third for the diagonal
Cpreconditioner	Abstract base-class for LduMatrix preconditioners
Csmoother	Abstract base-class for LduMatrix smoothers
Csolver	Abstract base-class for LduMatrix solvers
►ClduMatrix	LduMatrix is a general matrix class in which the coefficients are stored as three arrays, one for the upper triangle, one for the lower triangle and a third for the diagonal
Cpreconditioner	Abstract base-class for lduMatrix preconditioners
Csmoother	Abstract base-class for lduMatrix smoothers
Csolver	Abstract base-class for lduMatrix solvers
ClduMesh	Abstract base class for meshes which provide LDU addressing for the construction of lduMatrix and LDU-solvers
ClduPrimitiveMesh	Simplest concrete lduMesh that stores the addressing needed by lduMatrix
ClduPrimitiveMeshAssembly	An assembly of lduMatrix that is specific inter-region coupling through mapped patches
ClduPrimitiveProcessorInterface	Concrete implementation of processor interface. Used to temporarily store settings
ClduScheduleEntry	Struct to hold the patch index and the initialisation flag for the patch schedule
CleastSquareGrad	Estimates the gradient with a least square scheme in a cell
CleastSquaresFaVectors	Least-squares gradient scheme vectors for the Finite Area method
CleastSquaresVectors	Least-squares gradient scheme vectors
CLESdelta	Abstract base class for LES deltas
CLESfilter	Abstract class for LES filters
CLESModel	Templated abstract base class for LES SGS models
ClessEqOp
ClessEqOp2
ClessEqualOp
ClessEqualOp1
ClessEqualOp2
ClessOp
ClessOp1
ClessOp2
ClessProcPatches	Less function class that can be used for sorting processor patches
CLIFOStack	A LIFO stack based on a singly-linked list
CLiftForce	Base class for particle lift force models
CliftModel
CLimited01Limiter	A LimitedLimiter with the range 0-1
ClimitedCubicLimiter	Class with limiter function which returns the limiter for the TVD limited centred-cubic differencing scheme based on r obtained from the LimiterFunc class
ClimitedCubicVLimiter	Class with limiter function which returns the limiter for the limitedCubicV differencing scheme based on r obtained from the LimiterFunc class
CLimitedLimiter	Foam::LimitedLimiter
ClimitedLinearLimiter	Class with limiter function which returns the limiter for the TVD limited linear differencing scheme based on r obtained from the LimiterFunc class
CLimitedScheme	Class to create NVD/TVD limited weighting-factors
ClimitedSurfaceInterpolationScheme	Abstract base class for limited surface interpolation schemes
ClimiterBlended	Blends two specified schemes using the limiter function provided by a limitedSurfaceInterpolationScheme
ClimitWith	LimitWith differencing scheme limits the specified scheme with the specified limiter
CLindemannFallOffFunction	Lindemann fall-off function
Cline	A line primitive
Clinear	Central-differencing interpolation scheme class
ClinearDistance
ClinearEdgeInterpolation	Central-differencing interpolation scheme class
ClinearEqn	Container to encapsulate various operations for linear equation of the forms with real coefficients:
ClinearFitPolynomial	Linear polynomial for interpolation fitting
ClinearInterpolationWeights
ClinearSpatial
ClinearUpwind	LinearUpwind interpolation scheme class derived from upwind and returns upwind weighting factors and also applies a gradient-based explicit correction
ClinearUpwindNormal	LinearUpwindNormal interpolation scheme class derived from upwind and returns upwind weighting factors and also applies a gradient-based explicit correction. The magnitude of the correcting gradient is equal to 1
ClinearUpwindV	LinearUpwindV interpolation scheme class derived from upwind and returns upwind weighting factors but also applies an explicit correction
ClinearUpwindWeight	Class with operator() which returns the weighting factors for the linear-upwind differencing scheme. Note that the weighting factors are not bounded between upwind and central-differencing, some downwind contribution is possible although the interpolate is limited to be between the upwind and downwind cell values
ClinearValveFvMesh	A sliding linear valve
ClinearValveLayersFvMesh	A sliding linear valve with layers
ClinearViscousStress	Linear viscous stress turbulence model base class
ClineDivide	Divides a line into segments
ClineSearch	Abstract base class for line search methods
Cliquid	Generic thermophysical properties class for a liquid in which the functions and coefficients for each property are run-time selected
CLiquidEvapFuchsKnudsen	Liquid evaporation/condensation model for solution of liquid and solid
CLiquidEvaporation	Liquid evaporation model
CLiquidEvaporationBoil	Liquid evaporation model
CliquidMixtureProperties	A mixture of liquids
CliquidProperties	The thermophysical properties of a liquid
CLISAAtomization	Primary Breakup Model for pressure swirl atomizers
CList	A 1D array of objects of type <T>, where the size of the vector is known and used for subscript bounds checking, etc
ClistPlusEqOp
ClistUpdateOp	List update operation
►CLList	Template class for non-intrusive linked lists
Cconst_iterator	An STL-conforming const_iterator
Cconst_reverse_iterator
Citerator	An STL-conforming iterator
Clink	The storage of T with linked nodes
Creverse_iterator
CLLTMatrix	Templated class to perform the Cholesky decomposition on a symmetric positive-definite matrix
ClocalBlended	Two-scheme localBlended differencing scheme
CLocalInteraction	Patch interaction specified on a patch-by-patch basis
ClocalIOdictionary	LocalIOdictionary is derived from IOdictionary but excludes parallel master reading
ClocalMax	LocalMax-mean differencing scheme class
ClocalMin	LocalMin-mean differencing scheme class
ClocalPointRegion	Takes mesh with 'baffles' (= boundary faces sharing points). Determines for selected points on boundary faces the 'point region' it is connected to. Each region can be visited by a cell-face-cell walk. Used in duplicating points after splitting baffles
ClogPolynomialTransport	Transport package using polynomial functions of ln(T) for mu and kappa:
ClookupProfile	Profile model where polar lift and drag coefficients are linearly interpolated from a polar table by using an input angle of attack
CloopControl	A class for managing arbitrary loops with the ability to invoke function object execution
►CLPtrList	Template class for non-intrusive linked PtrLists
Cconst_iterator	An STL-conforming const_iterator
Cconst_reverse_iterator
Citerator	An STL-conforming iterator
Creverse_iterator
ClumpedMassWallTemperatureFvPatchScalarField	Employs a lumped mass model for temperature
ClumpedPointController	Simple connectivity of point labels to specify a controller for lumped point movement
ClumpedPointDisplacementPointPatchVectorField	This is the point-patch responsible for managing the force integration on a 'lumped-point' basis, waiting for the external application, reading back the response from the external program and updating the locations of the associated patch points accordingly
ClumpedPointInterpolator	A simple linear interpolator between two locations, which are referenced by index
ClumpedPointIOMovement	IO-registered version of lumpedPointMovement
ClumpedPointMovement	The movement driver that describes initial point locations, the current state of the points/rotations, and forwarding to the externalFileCoupler communication coordinator
ClumpedPointState	The state of lumped points corresponds to positions and rotations
CLUscalarMatrix	Class to perform the LU decomposition on a symmetric matrix
CLUST	LUST: Linear-upwind stabilised transport
Cmagnet	Class to hold the defining data for a permanent magnet, in particular the name, relative permeability and remanence
CmanifoldCellsMeshObject	Provides cell-to-faces ('cells()') with duplicate faces removed
CmanualDecomp	Decompose based on cell-to-processor association in a file
CmanualGAMGProcAgglomeration	Manual processor agglomeration of GAMGAgglomerations
CManualInjection	Manual injection
CmanualRenumber	Renumber given a ordered-to-original cell association in a file
CMap	A HashTable to objects of type <T> with a label key
CmapAddedPolyMesh	Class containing mesh-to-mesh mapping information after a mesh addition where we add a mesh ('added mesh') to an old mesh, creating a new mesh
►CmapDistribute	Class containing processor-to-processor mapping information
Ctransform	Default transformation behaviour
CtransformPosition	Default transformation behaviour for position
CmapDistributeBase	Class containing processor-to-processor mapping information
CmapDistributeLagrangian	Mesh-to-mesh mapping information for particles
CmapDistributePolyMesh	Class containing mesh-to-mesh mapping information after a mesh distribution where we send parts of meshes (using subsetting) to other processors and receive and reconstruct mesh
CMapInternalField	Generic internal field mapper. For "real" mapping, add template specialisations for mapping of internal fields depending on mesh type
CMapInternalField< Type, MeshMapper, areaMesh >
CMapInternalField< Type, MeshMapper, edgeMesh >
CMapInternalField< Type, MeshMapper, pointMesh >
CMapInternalField< Type, MeshMapper, surfaceMesh >
CMapInternalField< Type, MeshMapper, volMesh >
CmapNearestMethod	Map nearest mesh-to-mesh interpolation class
CmapPatchChange	Class containing mesh-to-mesh mapping information after a patch change operation
CmappedFieldFvPatchField	This boundary condition provides a self-contained version of the mapped condition. It does not use information on the patch; instead it holds the data locally
CmappedFixedInternalValueFvPatchField	This boundary condition maps the boundary and internal values of a neighbour patch field to the boundary and internal values of *this
CmappedFixedPushedInternalValueFvPatchField	This boundary condition maps the boundary values of a neighbour patch field to the boundary and internal cell values of *this
CmappedFixedValueFvPatchField	This boundary condition maps the value at a set of cells or patch faces back to *this
CmappedFlowRateFvPatchVectorField	Describes a volumetric/mass flow normal vector boundary condition by its magnitude as an integral over its area
CmappedFvPatch	Foam::mappedFvPatch
CmappedMixedFieldFvPatchField	This boundary condition provides a self-contained version of e.g. mapped boundary conditions
CmappedMixedFvPatchField	This boundary condition maps the value at a set of cells or patch faces back to *this
►CmappedPatchBase	Determines a mapping between patch face centres and mesh cell or face centres and processors they're on
CmaxProcEqOp
CnearestEqOp
CnearestWorldEqOp
CmappedPatchFieldBase	Functionality for sampling fields using mappedPatchBase. Every call to mappedField() returns a sampled field, optionally scaled to maintain an area-weighted average
CmappedPointPatch	MappedPointPatch patch
CmappedPolyPatch	Determines a mapping between patch face centres and mesh cell or face centres and processors they're on
CmappedVariableThicknessWallFvPatch	Take thickness field and number of layers and returns deltaCoeffs as 2.0/thickness/nLayers. To be used with 1D thermo baffle
CmappedVariableThicknessWallPolyPatch	Foam::mappedVariableThicknessWallPolyPatch
CmappedVelocityFluxFixedValueFvPatchField	This boundary condition maps the velocity and flux from a neighbour patch to this patch
CmappedWallFvPatch	Foam::mappedWallFvPatch
CmappedWallPointPatch	MappedWallPointPatch patch
CmappedWallPolyPatch	Determines a mapping between patch face centres and mesh cell or face centres and processors they're on
CmapPolyMesh	Class containing mesh-to-mesh mapping information after a change in polyMesh topology
CmapSubsetMesh	Class containing mesh-to-mesh mapping information after a subset operation
CmassTransferModel
CMassTransferPhaseSystem	Class for mass transfer between phases
CmasterCoarsestGAMGProcAgglomeration	Processor agglomeration of GAMGAgglomerations
CmasterOFstream	Master-only drop-in replacement for OFstream
CmatchedFlowRateOutletVelocityFvPatchVectorField	Velocity outlet boundary condition which corrects the extrapolated velocity to match the flow rate of the specified corresponding inlet patch
CMatrix	A templated (m x n) matrix of objects of <T>. The layout is (mRows x nCols) - row-major order:
CMatrixBlock	A templated block of an (m x n) matrix of type <MatrixType>
►CMatrixSpace	Templated matrix space
CBlock	Sub-block type
CConstBlock	Const sub-block type
CmaxEqOp
CmaxEqOp2
CmaxFirstEqOp	Assign tuple-like container to use the one with the larger value of first
CmaxFirstOp	Compare tuple-like containers
CmaxMagSqrEqOp
CmaxMagSqrEqOp2
CmaxMagSqrOp
CmaxMagSqrOp2
CmaxMagSqrOp3
CmaxOp
CmaxOp2
CmaxOp3
CMaxwellianThermal	Wall interaction setting microscopic velocity to a random one drawn from a Maxwellian distribution corresponding to a specified temperature
CmaxwellSlipUFvPatchVectorField	Maxwell slip boundary condition including thermal creep and surface curvature terms that can be optionally switched off
CMB	Liquid nC3H7COOCH3 or (MB) methyl butyrate (used for biodiesel surrogate)
CmedialAxisMeshMover	Mesh motion solver that uses a medial axis algorithm to work out a fraction between the (nearest point on a) moving surface and the (nearest point on a) fixed surface
CmemInfo	Memory usage information for the current process, and the system memory that is free
►Cmemorybuf	A streambuf for memory
Cin	An input streambuf for memory access
Cout	An output streambuf for memory access
CmergedSurf	Simple class to manage surface merging information
CmergePolyMesh	Add a given mesh to the original mesh to create a single new mesh
CmeshCutAndRemove	Like meshCutter but also removes non-anchor side of cell
CmeshCutter	Cuts (splits) cells
CmeshDualiser	Creates dual of polyMesh. Every point becomes a cell (or multiple cells for feature points), a walk around every edge creates faces between them
►CmeshedSurf	Abstract definition of a meshed surface defined by faces and points
CemptySurface	A concrete meshedSurf class without faces, points, etc
CMeshedSurface	A surface geometry mesh with zone information, not to be confused with the similarly named surfaceMesh, which actually refers to the cell faces of a volume mesh
CMeshedSurfaceProxy	A proxy for writing MeshedSurface, UnsortedMeshedSurface and surfMesh to various file formats
CmeshedSurfRef	Implements a meshed surface by referencing another meshed surface or faces/points components
CmeshObject
CMeshObject	Templated abstract base-class for optional mesh objects used to automate their allocation to the mesh database and the mesh-modifier event-loop
►CmeshReader	This class supports creating polyMeshes with baffles
CcellFaceIdentifier	Identify cell faces in terms of cell Id and face Id
CmeshRefinement	Helper class which maintains intersections of (changing) mesh with (static) surfaces
CmeshSearch	Various (local, not parallel) searches on polyMesh; uses (demand driven) octree to search
CmeshSearchFACE_CENTRE_TRISMeshObject	MeshObject wrapper around meshSearch(mesh, polyMesh::FACE_CENTRE_TRIS)
CmeshSearchMeshObject	MeshObject wrapper around meshSearch(mesh)
CmeshStructure	Detect extruded mesh structure given a set of faces (uindirectPrimitivePatch)
CmeshToMesh	Class to calculate the cell-addressing between two overlapping meshes
►CmeshToMesh0	Serial mesh to mesh interpolation class
CpatchFieldInterpolator	Patch-field interpolation class
►CmeshToMeshData	Transfers refinement levels such that slow transition between levels is maintained. Used in FaceCellWave
CtrackData	Class used to pass non-cell data to the update function
CmeshToMeshMethod	Base class for mesh-to-mesh calculation methods
CMeshWave	FaceCellWave plus data
CmeshWriter	Write OpenFOAM meshes and/or results to another CFD format
CmessageStream	Handle output messages in a simple, consistent stream-based manner
CmetisDecomp	Metis domain decomposition
CmetisLikeDecomp	Domain decomposition using METIS-like data structures
CMGridGenGAMGAgglomeration	Agglomerate using the MGridGen algorithm
CmidPoint	Mid-point interpolation (weighting factors = 0.5) scheme class
CmidPointAndFaceSet
CmidPointSet
CminData	For use with FaceCellWave. Transports minimum passive data
CminEqOp
CminEqOp2
CminEqOp< labelPair >
CminEqOpFace
CminFirstEqOp	Assign tuple-like container to use the one with the smaller value of first
CminFirstOp	Compare tuple-like containers
CminMagSqrEqOp
CminMagSqrEqOp2
CminMagSqrOp
CminMagSqrOp2
CminMagSqrOp3
CMinMax	A min/max value pair with additional methods. In addition to conveniently storing values, it can be used for logic operations or to modify data. A few global functions and functors are also provided
CminMaxEqOp	Combine assignment for MinMax range
CminMaxMagEqOp	Combine assignment for MinMax range
CminMaxMagOp	Scalar combine the magitude of a value
CminMaxOp	Combine values and/or MinMax ranges
CMinmodLimiter	Class with limiter function which returns the limiter for the Minmod differencing scheme
CminModOp
CminModOp2
CminModOp3
CminOp
CminOp2
CminOp3
CminusEqOp
CminusEqOp2
CminusOp
CminusOp2
CminusOp3
CmirrorFvMesh
CMixedDiffuseSpecular	Wall interaction setting microscopic velocity to a random one drawn from a Maxwellian distribution corresponding to a specified temperature for a specified fraction of collisions, and reversing the wall-normal component of the particle velocity for the remainder
CmixedEnergyFvPatchScalarField	This boundary condition provides a mixed condition for internal energy
CmixedFaPatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CmixedFvPatchField	This boundary condition provides a base class for 'mixed' type boundary conditions, i.e. conditions that mix fixed value and patch-normal gradient conditions
CmixedUnburntEnthalpyFvPatchScalarField	Mixed boundary condition for unburnt
CmixerFvMesh	A rotating slider mesh
Cmixture
CmixtureViscosityModel	An abstract base class for incompressible mixtureViscosityModels
CModifiableMeshedSurface	A special purpose MeshedSurface that exposes the stored values for direct modification
►Cmolecule	Foam::molecule
CconstantProperties	Class to hold molecule constant properties
CiNew	Factory class to read-construct particles used for
CtrackingData	Class used to pass tracking data to the trackToFace function
CmoleculeCloud
CmoleFractions	Calculates mole-fraction fields from the mass-fraction fields of the psi/rhoReactionThermo and caches them for output and further post-processing
CmomentOfInertia	Calculates the inertia tensor and principal axes and moments of a polyhedra/cells/triSurfaces. Inertia can either be of the solid body or of a thin shell
CMomentumTransferPhaseSystem	Class which models interfacial momenum transfer between a number of phases. Drag, virtual mass, lift, wall lubrication and turbulent dispersion are all modelled. The explicit contribution from the drag is omitted from the transfer matrices, as this forms part of the solution of the pressure equation
CmorphFieldMapper	Abstract base class to hold the Field mapping for mesh morphs
CmotionDiffusivity	Abstract base class for cell-centre mesh motion diffusivity
CmotionDirectionalDiffusivity	MotionDirectional finite volume mesh motion diffusivity
CmotionInterpolation	Base class for interpolation of cell displacement fields, generated by fvMotionSolvers, to the points. This base class implements the default method which applies volPointInterpolation only
CmotionSmoother	Given a displacement moves the mesh by scaling the displacement back until there are no more mesh errors
CmotionSmootherAlgo	Given a displacement moves the mesh by scaling the displacement back until there are no more mesh errors
CmotionSmootherData
►CmotionSolver	Virtual base class for mesh motion solver
CiNew	Class used for the construction of PtrLists of motionSolvers
CMoveableMeshObject
CmovingConeTopoFvMesh	Sample topoChangerFvMesh that moves an object in x direction and introduces/removes layers
CMovingPhaseModel	Class which represents a moving fluid phase. Holds the velocity, fluxes and turbulence model. Provides access to the turbulent quantities
CmovingWallVelocityFvPatchVectorField	This boundary condition provides a velocity condition for cases with moving walls
CMPPICCloud	Adds MPPIC modelling to kinematic clouds
►CMPPICParcel	Wrapper around kinematic parcel types to add MPPIC modelling
CiNew	Factory class to read-construct particles used for
CtrackingData
CMRFZone	MRF zone definition based on cell zone and parameters obtained from a control dictionary constructed from the given stream
CMRFZoneList	List container for MRF zomes
CMUCSheterogeneousRate	Heteregeneous noncatalytic reaction MUCS approach. Reference: D. Papanastassiou and G. Bitsianes, Modelling of Heterogeneous Gas-Solid Reactions, Metallurgical Transsactions, 480. Volume 4. 1973
CmultiComponentMixture	Foam::multiComponentMixture
CMultiComponentPhaseModel	Class which represents a phase with multiple species. Returns the species' mass fractions, and their governing equations
CmultiDimPolyFitter	Fit a polynominal function with the help of multiDimPolyFunction
CmultiDimPolyFunctions	Base class for polynomial functions
CmultiDirRefinement	Does multiple pass refinement to refine cells in multiple directions
CMultiInteraction	Runs multiple patch interaction models in turn. Takes dictionary where all the subdictionaries are the interaction models
CmultiLevelDecomp	Decompose given using consecutive application of decomposers
CmultiphaseInterSystem
►CmultiphaseMixture	Incompressible multi-phase mixture with built in solution for the phase fractions with interface compression for interface-capturing
CinterfacePair	Symmetric pair of interface names
►CmultiphaseMixtureThermo
CinterfacePair	Symmetric pair of interface names
►CmultiphaseSystem	Incompressible multi-phase mixture with built in solution for the phase fractions with interface compression for interface-capturing
CinterfacePair	Name pair for the interface
CmultiplyEqOp
CmultiplyEqOp2
CmultiplyOp
CmultiplyOp2
CmultiplyOp3
CmultiplyWeightedOp
CmultiSolidBodyMotionSolver	Solid-body motion of the mesh specified by a run-time selectable motion function
CmultivariateIndependentScheme	Generic multi-variate discretisation scheme class for which any of the NVD, CNVD or NVDV schemes may be selected for each variable and applied independently
►CmultivariateScheme	Generic multi-variate discretisation scheme class which may be instantiated for any of the NVD, CNVD or NVDV schemes
CfieldScheme	SurfaceInterpolationScheme sub-class returned by operator(field)
►CmultivariateSelectionScheme	Generic multi-variate discretisation scheme class for which any of the NVD, CNVD or NVDV schemes may be selected for each variable
CfieldScheme	SurfaceInterpolationScheme sub-class returned by operator(field)
►CmultivariateSurfaceInterpolationScheme	Abstract base class for multi-variate surface interpolation schemes
CfieldScheme	SurfaceInterpolationScheme sub-class returned by operator(field)
CfieldTable	FieldTable
►CmultivariateUpwind	Upwind-difference form of the multivariate surfaceInterpolationScheme
CfieldScheme	SurfaceInterpolationScheme sub-class returned by operator(field)
CmultiWorldConnections	Centralized handling of multi-world MPI connections
CMUSCLLimiter	Class with limiter function which returns the limiter for the van Leer's MUSCL differencing scheme
CN2	Liquid N2
CnamedDictionary	A tuple of keyType and dictionary, which can be used when reading named or unnamed dictionary entries or simply a name
CNamedEnum	A NamedEnum is a wrapper around a list of names that represent particular enumeration values
CnameOp	Extract name (as a word) from an object, typically using its name() method
CnameOp< expressions::valueTypeCode >	A word representation of a valueTypeCode. Empty for INVALID
CnameOp< int16_t >	A word representation of int16 value
CnameOp< int32_t >	A word representation of int32 value
CnameOp< int64_t >	A word representation of int64 value
CnameOp< Scalar >	A word representation of a floating-point value
CnameOp< uint16_t >	A word representation of uint16 value
CnameOp< uint32_t >	A word representation of uint32 value
CnameOp< uint64_t >	A word representation of uint64 value
CnameOp< uint8_t >	A word representation of uint8 value
CnbrToCell	A topoSetCellSource to select cells with N or less number of neighbouring cells (i.e. number of internal or coupled faces)
CnC3H8O	Propanol
CnearestEqOp
►CnearestFaceAMI	Nearest-face Arbitrary Mesh Interface (AMI) method
CnearestEqOp	Helper class for finding nearest
CnearestToCell	A topoSetCellSource to select cells whose cell centre nearest to given points
CnearestToPoint	A topoSetPointSource to select points nearest to given points
CnearWallDist	Distance calculation for cells with face on a wall. Searches pointNeighbours to find closest
CnearWallDistNoSearch	Distance calculation for cells with face on a wall. Does not search anything, just takes normal component of distance
CNoAtomization	Dummy phase change model for 'none'
CNoBinaryCollision	No collison BinaryCollision Model
CNoBreakup	Dummy breakup model for 'none'
CnoChemistrySolver	Dummy chemistry solver for 'none' option
CNoCollision	Place holder for 'none' option
CNoComposition	Dummy class for 'none' option - will raise an error if any functions are called that require return values
CnoDecomp	A dummy decomposition method, selected as none
CNoDevolatilisation	Dummy devolatilisation model for 'none'
CNoDispersion	Place holder for 'none' option
CNoHeatTransfer	Nusselt-number model providing an interface to the properties of HeatTransferModel without any active model
CNoheterogeneousReacting	Dummy surface reaction model for 'none'
CNoInflow	Not inserting any particles
CNoInjection	Place holder for 'none' option
CNoInteraction	Dummy class for 'none' option - will raise an error if any functions are called that require return values
CnoiseFFT	Performs FFT of pressure field to generate noise data
►CnoiseModel	Base class for noise models
CoctaveBandInfo	Octave band information
CplanInfo	FFTW planner information
CnonBlockingGaussSeidelSmoother	Variant of gaussSeidelSmoother that expects processor boundary cells to be sorted last and so can block later. Only when the cells are actually visited does it need the results to be present. It is expected that there is little benefit to be gained from doing this on a patch by patch basis since the number of processor interfaces is quite small and the overhead of checking whether a processor interface is finished might be quite high (call into mpi). Also this would require a dynamic memory allocation to store the state of the outstanding requests
CnoneGAMGProcAgglomeration	Processor agglomeration of GAMGAgglomerations
CNonEquilibriumReversibleReaction	Simple extension of Reaction to handle reversible reactions using equilibrium thermodynamics
CNonInertialFrameForce	Calculates particle non-inertial reference frame force. Variable names as from Landau and Lifshitz, Mechanics, 3rd Ed, p126-129
CnonlinearEddyViscosity	Eddy viscosity turbulence model with non-linear correction base class
CNonSphereDragForce	Particle-drag model wherein drag forces (per unit carrier-fluid velocity) are dynamically computed based on empirical expressions using a four-parameter general drag correlation for non-spherical particles
CnonUniformField
CnonuniformTransformCyclicFvPatch	Cyclic-plane patch
CnonuniformTransformCyclicFvPatchField	This boundary condition enforces a cyclic condition between a pair of boundaries, incorporating a non-uniform transformation
CnonuniformTransformCyclicFvsPatchField	Foam::nonuniformTransformCyclicFvsPatchField
CnonuniformTransformCyclicPointPatch	Cyclic patch with slip constraint
CnonuniformTransformCyclicPointPatchField	Cyclic + slip constraints
CnonuniformTransformCyclicPolyPatch	Transform boundary used in extruded regions. Allows non-uniform transforms. Wip
CnoOp	Same as Foam::identityOp. Should never be specialized
CNoPair	Placeholder for 'none' option
CnopEqOp
CnopEqOp2
CNoPhaseChange	Dummy phase change model for 'none'
CnoPreconditioner	Null preconditioner for both symmetric and asymmetric matrices
CNoPreconditioner	Null preconditioner for both symmetric and asymmetric matrices
CnormalLess	To compare normals
CnormalToFace	A topoSetFaceSource to select faces whose surface normal aligned with a given direction
CnoSlipFvPatchVectorField	This boundary condition fixes the velocity to zero at walls
CNoStochasticCollision	Dummy collision model for 'none'
CNoSurfaceFilm	Place holder for 'none' option
CNoSurfaceReaction	Dummy surface reaction model for 'none'
CnotEqualOp
CnotEqualOp1
CnotEqualOp2
CnotEqualOp< Scalar >	Compare scalar values for inequality
CNSRDSfunc0	NSRDS function number 100
CNSRDSfunc1	NSRDS function number 101
CNSRDSfunc14	NSRDS function number 114
CNSRDSfunc2	NSRDS function number 102
CNSRDSfunc3	NSRDS function number 103
CNSRDSfunc4	NSRDS function number 104
CNSRDSfunc5	NSRDS function number 105
CNSRDSfunc6	NSRDS function number 106
CNSRDSfunc7	NSRDS-AICHE function number 107
CNullMRF
CNullObject	Singleton null-object class and instance
CNURBS3DCurve	A NURBS 3D curve
CNURBS3DSurface	A NURBS 3D surface
CNURBS3DVolume	NURBS3DVolume morpher. Includes support functions for gradient computations Base class providing support for different coordinate systems
CNURBS3DVolumeCartesian	Calculation of adjoint based sensitivities at wall faces
CNURBS3DVolumeCylindrical	Calculation of adjoint based sensitivities at wall faces
CNURBSbasis	NURBSbasis function. Used to construct NURBS curves, surfaces and volumes
CNusseltNumber	Calculates and writes particle Nusselt number field on the cloud
CnutkRoughWallFunctionFvPatchScalarField	This boundary condition provides a wall-function for the turbulent viscosity (i.e. nut) when using wall functions for rough walls, based on the turbulent kinetic energy (i.e. k). The condition manipulates the wall roughness parameter (i.e. E) to account for roughness effects
CnutkWallFunctionFvPatchScalarField	This boundary condition provides a wall function for the turbulent viscosity (i.e. nut) based on the turbulent kinetic energy, (i.e. k) for for low- and high-Reynolds number applications
CnutLowReWallFunctionFvPatchScalarField	This boundary condition provides a simple wrapper around a zero fixed-value condition for the turbulent viscosity (i.e. nut) for low-Reynolds number applications. It sets nut to zero, and provides an access function to calculate y+
CnutUBlendedWallFunctionFvPatchScalarField	This boundary condition provides a wall function for the turbulent viscosity (i.e. nut) based on velocity (i.e. U) using a binomial-function wall-function blending method between the viscous and inertial sublayer predictions of nut for low- and high-Reynolds number applications
CnutURoughWallFunctionFvPatchScalarField	This boundary condition provides a wall function on the turbulent viscosity (i.e. nut) based on velocity (i.e. U) for low- and high-Reynolds number applications for rough walls
CnutUSpaldingWallFunctionFvPatchScalarField	This boundary condition provides a wall function for the turbulent viscosity (i.e. nut) based on velocity (i.e. U). Using Spalding's law gives a continuous nut profile to the wall
CnutUTabulatedWallFunctionFvPatchScalarField	This boundary condition provides a wall constraint on the turbulent viscosity (i.e. nut) based on velocity (i.e. U), for low- and high-Reynolds number applications
CnutUWallFunctionFvPatchScalarField	This boundary condition provides a wall function for the turbulent viscosity (i.e. nut) based on velocity (i.e. U) for low- and high-Reynolds number applications
CnutWallFunctionFvPatchScalarField	The class nutWallFunction is an abstract base class that hosts \(y^+\) calculation methods and common functions for nut wall-function boundary conditions
CNVDTVD	Foam::NVDTVD
CNVDVTVDV	Foam::NVDVTVDV
CobjectHit	This class describes a combination of target object index and success flag. Behaves somewhat like std::optional
Cobjective	Abstract base class for objective functions. No point in making this runTime selectable since its children will have different constructors
CobjectiveIncompressible	Abstract base class for objective functions in incompressible flows
CobjectiveManager	Class for managing incompressible objective functions
CobjectiveManagerIncompressible	Class for managing incompressible objective functions
CobjectMap	An objectMap is a pair of labels defining the mapping of an object from another object, e.g. a cell mapped from a point
CobjectRegistry	Registry of regIOobjects
COBJstream	OFstream that keeps track of vertices
COCountStream	An output stream for calculating byte counts
Cocountstream	Trivial output stream for calculating byte counts
Code	An ODE solver for chemistry
►CODESolver	Abstract base-class for ODE system solvers
CstepState
CODESystem	Abstract base class for the systems of ordinary differential equations
CoffsetOp	Offset operator for ListListOps::combineOffset()
CoffsetOp< face >	Specialization to offset faces, used in ListListOps::combineOffset
CoffsetOp< labelledTri >	Specialization to offset faces, used in ListListOps::combineOffset
CoffsetOp< triFace >	Specialization to offset faces, used in ListListOps::combineOffset
COFstream	Output to file stream, using an OSstream
COFstreamCollator	Threaded file writer
CofstreamPointer	A wrapped std::ofstream with possible compression handling (ogzstream) that behaves much like a std::unique_ptr
ColdCyclicPolyPatch	'old' style cyclic polyPatch with all faces in single patch. Does ordering but cannot be used to run. Writes 'type cyclic' so foamUpgradeCyclics can be run afterwards. Used to get cyclics from mesh converters that assume cyclics in single patch (e.g. fluent3DMeshToFoam)
COListStream	An OSstream attached to a List
COmanip	An Ostream manipulator taking arguments
ComegaWallFunctionFvPatchScalarField	This boundary condition provides a wall function for the specific dissipation rate (i.e. omega) and the turbulent kinetic energy production contribution (i.e. G) for low- and high-Reynolds number applications
►Cone	A class representing the concept of 1 (one) that can be used to avoid manipulating objects known to be one at compile-time. It is also used for tagged dispatch
Cminus	A class representing the concept of -1
Cnull	A Foam::one class with a null output adapter
ConeField	A class representing the concept of a field of 1 used to avoid unnecessary manipulations for objects which are known to be one at compile-time
ConeFieldField	A class representing the concept of a field of oneFields used to avoid unnecessary manipulations for objects which are known to be one at compile-time
COneResistanceHeatTransferPhaseSystem	Class which models interfacial heat transfer between a number of phases. A single heat transfer model is used for each interface
COPBstream
CopenFoamTableReader	Reads an interpolation table from a file - OpenFOAM-format
CoppositeFace	Class containing opposite face for a prismatic cell with addressing and a possibility of failure
COppositeFaceCellWave	Version of FaceCellWave that walks through prismatic cells only
COPstream	Output inter-processor communications stream
CoptimisationManager	Abstract base class for optimisation methods
CoptionalData	A simplified version of std::optional (c++17), with much simpler construction semantics
CoptMeshMovement	Abstract base class for translating an update of the design variables into mesh movement
CoptMeshMovementBezier	Converts NURBS control points update to actual mesh movement
CoptMeshMovementNULL	A dummy optMeshMovement object
CoptMeshMovementVolumetricBSplines	Converts NURBS volume control points update to actual mesh movement. Internal points are also moved based on the movement of the control points
CoptMeshMovementVolumetricBSplinesExternalMotionSolver	Converts NURBS volume control points update to actual mesh movement. Internal points are moved based on a motionSolver other than volumetricBSplinesExternalMotionSolver
CorderedPhasePair
CorEqOp
CorEqOp2
CorientedSurface	Given point flip all faces such that normals point in same direction
CorientedType	Class to determine the 'oriented' status of surface fields
CorOp
CorOp2
CORourkeCollision	Collision model by P.J. O'Rourke
CoscillatingDisplacementPointPatchVectorField	Foam::oscillatingDisplacementPointPatchVectorField
CoscillatingVelocityPointPatchVectorField	Foam::oscillatingVelocityPointPatchVectorField
Cosha1stream	A basic output stream for calculating SHA1 digests
COSHA1stream	The output stream for calculating SHA1 digests
COSPRELimiter	Class with limiter function which returns the limiter for the OSPRE differencing scheme based on r obtained from the LimiterFunc class
COSstream	Generic output stream using a standard (STL) stream
COstream	An Ostream is an abstract base class for all output systems (streams, files, token lists, etc)
COStringStream	Output to string buffer, using a OSstream. Always UNCOMPRESSED
COTstream	A simple output token stream that can be used to build token lists. Always UNCOMPRESSED
CouterProduct
CouterProduct1	Outer-product of identical types
CouterProduct< Cmpt, SphericalTensor2D< Cmpt > >
CouterProduct< Cmpt, SphericalTensor< Cmpt > >
CouterProduct< Cmpt, SymmTensor2D< Cmpt > >
CouterProduct< Cmpt, SymmTensor< Cmpt > >
CouterProduct< SphericalTensor2D< Cmpt >, Cmpt >
CouterProduct< SphericalTensor< Cmpt >, Cmpt >
CouterProduct< SymmTensor2D< Cmpt >, Cmpt >
CouterProduct< SymmTensor< Cmpt >, Cmpt >
CouterProduct< Vector2D< Cmpt >, Vector2D< Cmpt > >
CoutletInletFvPatchField	This boundary condition provides a generic inflow condition, with specified outflow for the case of reverse flow
CoutletMachNumberPressureFvPatchScalarField	This boundary condition maintains a certain subsonic Mach number at an outlet patch by dynamically adjusting the static outlet pressure. It makes it possible, for example, to simulate the flow in a preturbine engine exhaust manifold, without resolving details of the flow inside the turbine. In general, the flow in a choked nozzle can be non-trivial and expensive to simulate
CoutletMappedUniformInletFvPatchField	The outletMappedUniformInlet is an inlet boundary condition that
CoutletMappedUniformInletHeatAdditionFvPatchField	This temperature boundary condition averages the temperature over the "outlet" patch specified by name "outletPatchName" and applies an extra heat source. This is set as a uniform temperature value on this patch. Additionally TMin/TMax limits can be applied
CoutletPhaseMeanVelocityFvPatchVectorField	This boundary condition adjusts the velocity for the given phase to achieve the specified mean thus causing the phase-fraction to adjust according to the mass flow rate
CoutletStabilised	Outlet-stabilised interpolation scheme which applies upwind differencing to the faces of the cells adjacent to outlets
CoversetFvPatch	Patch for indicating interpolated boundaries (in overset meshes)
CoversetFvPatchField	Boundary condition for use on overset patches. To be run in combination with special dynamicFvMesh type that inserts interpolation into the matrix
CoversetPolyPatch	Patch for indicating interpolated boundaries (in overset meshes)
►CPackedList	A dynamic list of packed unsigned integers, with the number of bits per item specified by the <Width> template parameter
Chasher	Hashing functor for PackedList
Creference	A reference supporting read/write access to an entry
CPackingModel	Base class for packing models
►CPair	An ordered pair of two objects of type <T> with first() and second() elements
CsymmHasher	Symmetric hashing functor for Pair, hashes lower value first
CPairCollision
CPairCollisionRecord	Record of a collision between the particle holding the record and the particle with the stored id
CpairGAMGAgglomeration	Agglomerate using the pair algorithm
CPairModel	Templated pair interaction class
CpairPatchAgglomeration	Primitive patch pair agglomerate method
CpairPotential
CpairPotentialList
CPairSpringSliderDashpot	Pair forces between particles colliding with a spring, slider, damper model
CParamagneticForce	Calculates particle paramagnetic (magnetic field) force
CparFaFieldDistributorCache	Simple container to manage read/write, redistribute finiteArea fields
CparFvFieldDistributor	Finite volume reconstructor for volume and surface fields
CparLagrangianDistributor	Lagrangian field redistributor
CparPointFieldDistributor	Distributor/redistributor for point fields, uses a two (or three) stage construction
CParRunControl	Helper class for initializing parallel jobs from the command arguments, storing 'dry-run' state etc. Also handles cleanup of parallel (or serial) jobs
CParSortableList	Implementation of PSRS parallel sorting routine
CpartialSlipFvPatchField	This boundary condition provides a partial slip condition. The amount of slip is controlled by a user-supplied field
►Cparticle	Base particle class
CiNew	Factory class to read-construct particles (for parallel transfer)
CpositionsCompat1706	Old particle positions content for OpenFOAM-1706 and earlier
CtrackingData
CParticleCollector	Function object to collect the parcel mass- and mass flow rate over a set of polygons. The polygons can either be specified by sets of user- supplied points, or in a concentric circles arrangement. If a parcel is 'collected', it can be flagged to be removed from the domain using the removeCollected entry
CParticleDose	Calculate the doses absorbed by a particle as the time integral of the particle track along the radiation field G [w/m2]
CParticleErosion	Creates particle erosion field, Q
CParticleForce	Abstract base class for particle forces
CParticleForceList	List of particle forces
CparticleInfo
CparticleInfoCombineOp
CParticleStressModel	Base class for inter-particle stress models
CParticleTracks	Records particle state (all variables) on each call to postFace
CparticleTracksSampler	Helper class when generating particle tracks. The interface is fairly rudimentary
CParticleTrap	Traps particles within a given phase fraction for multi-phase cases
CParticleZoneInfo	Reports cloud information for particles passing through a specified cell zone
►CpassiveParticle	Copy of base particle
CiNew	Factory class to read-construct particles (for parallel transfer)
CpassiveParticleCloud	A Cloud of passive particles
►CpassivePositionParticle	Copy of base particle but without particle locating and preserving read location
CiNew	Factory class to read-construct particles (for parallel transfer)
CpassivePositionParticleCloud	A Cloud of passive particles
CpatchCloudSet	Like Foam::cloudSet but samples nearest patch face
CPatchCollisionDensity	Function object which generates fields of the number and rate of collisions per unit area on all patches. Can optionally take a minimum speed below which a collision is not counted
CpatchCorrectedInterpolation	Interpolation of cell-based displacements to the points with additional correction for interpolation inconsistency on patches
CpatchDataWave	Takes a set of patches to start MeshWave from
CpatchDistMethod	Specialisation of patchDist for wall distance calculation
CpatchEdgeFaceInfo
CpatchEdgeFaceRegion	Transport of region for use in PatchEdgeFaceWave
CpatchEdgeFaceRegions	Transport of regions for use in PatchEdgeFaceWave
CPatchEdgeFaceWave	Wave propagation of information along patch. Every iteration information goes through one layer of faces. Templated on information that is transferred
CpatchEdgeSet	Like Foam::uniformSet but samples patch edges
CpatchFaceOrientation	Transport of orientation for use in PatchEdgeFaceWave
CPatchFlowRateInjection	Patch injection, by using patch flow rate to determine concentration and velocity
CPatchFunction1	Top level data entry class for use in dictionaries. Provides a mechanism to specify a variable as a certain type, e.g. constant or time varying, and provide functions to return the (interpolated) value, and integral between limits
CpatchFunction1Base	Top level data entry class for use in dictionaries. Provides a mechanism to specify a variable as a certain type, e.g. constant or time varying, and provide functions to return the (interpolated) value, and integral between limits
CpatchIdentifier	Identifies a patch by name and index, with optional physical type and group information
CPatchInjection	Patch injection
CpatchInjectionBase
CpatchInteractionData	Helper class for the LocalInteraction patch interaction model
CpatchInteractionDataList	List container for patchInteractionData class
CPatchInteractionFields	Creates volume fields whose boundaries are used to store patch interaction statistics
CPatchInteractionModel	Templated patch interaction model class
CPatchParticleHistogram	Computes a histogram for the distribution of particle diameters and corresponding number of particles hitting on a given list of patches
CpatchPatchDist	Like wallDist but calculates on a patch the distance to nearest neighbouring patches. Uses PatchEdgeFaceWave to do actual calculation
CPatchPostProcessing	Standard post-processing
CpatchProbes	Set of locations to sample at patches
CpatchSeedSet	Initialises points on or just off patch
CpatchToCell	A topoSetCellSource to select cells associated with given patch(es)
CpatchToFace	A topoSetFaceSource to select cells associated with given patch(es)
CPatchTools	A collection of tools for searching, sorting PrimitivePatch information
CPatchToPatchInterpolation	Interpolation class dealing with transfer of data between two primitivePatches
CpatchToPoly2DMesh	Convert a primitivePatch into a 2D polyMesh
CpatchTransformedInterpolation	Interpolation of cell-based displacements to the points with additional correction of patch-adjacent cells
CpatchWave	Takes a set of patches to start MeshWave from. After construction holds distance at cells and distance at patches. Is e.g. used by wallDist to construct volScalarField with correct distance to wall
CpatchZones	Calculates zone number for every face of patch
CPBiCCCG	Preconditioned bi-conjugate gradient solver for asymmetric lduMatrices using a run-time selectable preconditioner
CPBiCG	Preconditioned bi-conjugate gradient solver for asymmetric lduMatrices using a run-time selectable preconditioner
CPBiCGStab	Preconditioned bi-conjugate gradient stabilized solver for asymmetric lduMatrices using a run-time selectable preconditioner
CPBiCICG	Preconditioned bi-conjugate gradient solver for asymmetric lduMatrices using a run-time selectable preconditioner
CPCG	Preconditioned conjugate gradient solver for symmetric lduMatrices using a run-time selectable preconditioner
CPCICG	Preconditioned conjugate gradient solver for symmetric lduMatrices using a run-time selectable preconditioner
CPDRarrays	Work array definitions for PDR fields
►CPDRblock	A single block x-y-z rectilinear mesh addressable as i,j,k with simplified creation. Some of the input is similar to blockMeshDict, but since this specialization is for a single-block that is aligned with the x-y-z directions, it provides a different means of specifying the mesh
CgridControl
Clocation	Grid locations in an axis direction
CPDRDragModel	Base-class for sub-grid obstacle drag models. The available drag model is at basic.H
CPDRmeshArrays	OpenFOAM/PDRblock addressing information
CPDRobstacle	Obstacle definitions for PDR
CPDRparams	Parameters for PDRsetFields
CPDRpatchDef	Bookkeeping for patch definitions
CPengRobinsonGas	PengRobinsonGas gas equation of state
CperfectFluid	Perfect gas equation of state
CperfectGas	Perfect gas equation of state
CperfectInterface	Hack of attachDetach to couple patches when they perfectly align. Does not decouple. Used by stitchMesh app. Does geometric matching
►Cphase	Single incompressible phase derived from the phase-fraction. Used as part of the multiPhaseMixture for interface-capturing multi-phase simulations
CiNew	Return a pointer to a new phase created on freestore
CPhaseChangeModel	Templated phase change model class
CphaseChangeTwoPhaseMixture
CPhaseCompressibleTurbulenceModel	Templated abstract base class for multiphase compressible turbulence models
CphaseHydrostaticPressureFvPatchScalarField	This boundary condition provides a phase-based hydrostatic pressure condition, calculated as:
CPhaseIncompressibleTurbulenceModel	Templated abstract base class for multiphase incompressible turbulence models
►CphaseModel	Single incompressible phase derived from the phase-fraction. Used as part of the multiPhaseMixture for interface-capturing multi-phase simulations
CiNew	Return a pointer to a new phase created on freestore
►CphasePair	Description for mass transfer between a pair of phases. The direction of the mass transfer is from the phase 'from' to the phasse 'to'
Cconst_iterator	STL const_iterator
►CphasePairKey	An ordered or unorder pair of phase names. Typically specified as follows
Chasher	Hashing functor for phasePairKey
CphaseProperties	Helper class to manage multi-specie phase properties
CphasePropertiesList	Simple container for a list of phase properties
CphaseSystem	Class to represent a system of phases and model interfacial transfers between them
CphaseTransferModel
CPhaseTransferPhaseSystem	Class which models non-thermally-coupled mass transfers; i.e., representation changes, rather than phase changes
CPhiLimiter	Class with limiter function which returns the limiter for the Phi differencing scheme
CPhiScheme	Class to create the weighting-factors based on the face-flux
CpiecewiseLinearRamp	A linear ramp between 0 and 1 with definable start and end points
CPilchErdman	Particle secondary breakup model based on Pilch-Erdman total droplet breakup model
CpimpleControl	PIMPLE control class to supply convergence information/checks for the PIMPLE loop
CpisoControl	Specialization of the pimpleControl class for PISO control
►Cplane	Geometric class that creates a 3D plane and can return the intersection point between a line and the plane
Cray	A reference point and direction
CplaneToFaceZone	A topoSetSource to select faces based on the adjacent cell centres spanning a given plane. The plane is defined by a point and normal vector
CplenumPressureFvPatchScalarField	This boundary condition provides a plenum pressure inlet condition. This condition creates a zero-dimensional model of an enclosed volume of gas upstream of the inlet. The pressure that the boundary condition exerts on the inlet boundary is dependent on the thermodynamic state of the upstream volume. The upstream plenum density and temperature are time-stepped along with the rest of the simulation, and momentum is neglected. The plenum is supplied with a user specified mass flow and temperature
CPlessisMasliyahDragForce	Particle-drag model wherein drag forces (per unit carrier-fluid velocity) are dynamically computed based on the Du Plessis-Masliyah drag model
CplusEqMagSqrOp
CplusEqMagSqrOp2
CplusEqOp
CplusEqOp2
CplusOp
CplusOp2
CplusOp3
CpointBitSet	A special purpose topoSet with the point labels stored as a bitSet. It does not correspond to a pointSet either (no associated IOobject)
CpointBoundaryMesh	Foam::pointBoundaryMesh
CpointBoundaryMeshMapper	Foam::pointBoundaryMeshMapper
CpointCells	Smooth ATC in cells having a point to a set of patches supplied by type
CpointConstraint	Accumulates point constraints through successive applications of the applyConstraint function
CpointConstraints	Application of (multi-)patch point constraints
CPointData	Variant of pointEdgePoint with some transported additional data. Templated on the transported data type
CpointEdgeCollapse	Determines length of string of edges walked to point
CpointEdgePoint	Holds information regarding nearest wall point. Used in PointEdgeWave. (so not standard FaceCellWave) To be used in wall distance calculation
CpointEdgeStructuredWalk	Determines length of string of edges walked to point
CPointEdgeWave	Wave propagation of information through grid. Every iteration information goes through one layer of edges
CpointFeatureEdgesTypes	Hold the types of feature edges attached to the point
►CpointFieldDecomposer	Point field decomposer
►CfieldsCache
CprivateCache
CpatchFieldDecomposer	Point patch field decomposer class
►CpointFieldReconstructor	Point field reconstructor
CpointPatchFieldReconstructor
CpointFile	Inserts points at locations specified in a pointFile into the surfaces to be conformed to of the conformalVoronoiMesh
CpointHistory
CPointHit	Describes the interaction of a face and a point. It carries the info of a successful hit and (if successful) the interaction point
CPointIndexHit	This class describes the interaction of (usually) a face and a point. It carries the info of a successful hit and (if successful), returns the interaction point
►CPointIntegrateData	Integrate along selected edges using PointEdgeWave
CtrackingData	Class used to pass extra data
CpointLinear	Face-point interpolation scheme class derived from linear and returns linear weighting factors but also applies an explicit correction
CpointMapper	This object provides mapping and fill-in information for point data between the two meshes after the topological change. It is constructed from mapPolyMesh
CpointMesh	Mesh representing a set of points created from polyMesh
CpointMeshMapper	Class holds all the necessary information for mapping fields associated with pointMesh
CpointMVCWeight	Container to calculate weights for interpolating directly from vertices of cell using Mean Value Coordinates
CpointPairs	HashSet of unique edges. The edges are stored as a pair of pairs:
CpointPatch	Basic pointPatch represents a set of points from the mesh
CpointPatchDist	Calculation of distance to nearest patch for all points
CpointPatchField	Abstract base class for point-mesh patch fields
CpointPatchFieldMapper	Foam::pointPatchFieldMapper
CpointPatchFieldMapperPatchRef	Foam::pointPatchFieldMapperPatchRef
CpointPatchMapper	Mapping class for a pointPatchField
Cpoints0MotionSolver	Virtual base class for displacement motion solvers, where the point motion is relative to a set of fixed points (points0)
CpointSet	A set of point labels
CpointToCell	A topoSetCellSource to select cells with any point or any edge within a given pointSet(s)
CpointToFace	A topoSetFaceSource to select faces with any point or any edge within a given pointSet(s)
CpointTopoDistanceData	For use with PointEdgeWave. Determines topological distance to starting points. Templated on passive transported data
CpointToPoint	A topoSetPointSource to select all points from given pointSet(s)
CpointToPointPlanarInterpolation	Interpolates between two sets of unstructured points using 2D Delaunay triangulation. Used in e.g. timeVaryingMapped bcs
CpointVolInterpolation
CpointZone	A subset of mesh points
CpointZoneSet	Like pointSet but -reads data from pointZone -updates pointZone when writing
CpolyAddCell	Class containing data for cell addition
CpolyAddFace	A face addition data class. A face can be inflated either from a point or from another face and can either be in internal or a boundary face
CpolyAddPoint	Class containing data for point addition
CpolyBoundaryMesh	A polyBoundaryMesh is a polyPatch list with additional search methods and registered IO
CpolyBoundaryMeshEntries	Read and store dictionary entries for boundary patches
CpolyDegree1	First degree polynominal function
CpolyDualMesh	Creates dual of polyMesh
CpolyGeoMesh	The polyMesh GeoMesh for holding internal fields without an fvMesh
CPolyhedronReader
CpolyLine	A series of straight line segments, which can also be interpreted as a series of control points for splines, etc
CpolyLineSet	Sample along poly line defined by a list of points (knots)
CpolyMesh	Mesh consisting of general polyhedral cells
CpolyMeshAdder	Adds two meshes without using any polyMesh morphing
CpolyMeshFilter	Remove the edges and faces of a polyMesh whilst satisfying the given mesh quality criteria
CpolyMeshFilterSettings	Class to store the settings for the polyMeshFilter class
CpolyMeshGeometry	Updateable mesh geometry and checking routines
CpolyMeshModifier	Virtual base class for mesh modifiers
CpolyMeshTetDecomposition	Tools for performing the minimum decomposition of faces of the mesh into triangles so that the cells may be tet decomposed. Includes functions for finding variable face starting (base) points on each face to avoid the decomposition of cells into tets that have negative or zero volume
CpolyMeshTools	Collection of static functions operating on polyMesh (mainly checks) so that need access to patch information
CpolyModifyCell	Class describing modification of a cell
CpolyModifyFace	Class describing modification of a face
CpolyModifyPoint	Class describing modification of a point
CPolynomial	Polynomial templated on size (order):
CpolynomialFunction	Polynomial function representation
CpolynomialSolidTransport	Transport package using polynomial functions for solid kappa
CpolynomialTransport	Transport package using polynomial functions for mu and kappa
CpolyPatch	A patch is a list of labels that address the faces in the global face list
CpolyRemoveCell	Class containing data for cell removal
CpolyRemoveFace	Class containing data for face removal
CpolyRemovePoint	Class containing data for point removal
CpolySurface	A surface mesh consisting of general polygon faces and capable of holding fields
CpolySurfaceGeoMesh	The polySurface GeoMesh (for holding fields)
CpolySurfacePointGeoMesh	The polySurface GeoMesh (for holding point fields)
CpolyTopoChange	Direct mesh changes based on v1.3 polyTopoChange syntax
CpolyTopoChanger	List of mesh modifiers defining the mesh dynamics
CPopulationBalancePhaseSystem	Class which provides population balance functionality
►CporosityModel	Top level model for porosity models
CiNew	Return pointer to new porosityModel object created on the freestore
CporosityModelList	List container for porosity models
CporousBafflePressureFvPatchField	This boundary condition provides a jump condition, using the cyclic condition as a base
CporousModel
Cpotential
CpowerSeriesReactionRate	Power series reaction rate
CpowProduct
CPPCG	Preconditioned pipelined conjugate gradient solver for symmetric lduMatrices using a run-time selectable preconditioner
CPPCR	Preconditioned pipelined conjugate residuals solver for symmetric lduMatrices using a run-time selectable preconditioner
CPrecisionAdaptor	A non-const Field/List wrapper with possible data conversion
CprefixOSstream	Version of OSstream that prints a prefix on each line
CpressureControl	Provides controls for the pressure reference is closed-volume simulations and a general method for limiting the pressure during the startup of steady-state simulations
CpressureDirectedInletOutletVelocityFvPatchVectorField	This velocity inlet/outlet boundary condition is applied to velocity boundaries where the pressure is specified. A zero-gradient condition is applied for outflow (as defined by the flux); for inflow, the velocity is obtained from the flux with the specified inlet direction
CpressureDirectedInletVelocityFvPatchVectorField	This velocity inlet boundary condition is applied to patches where the pressure is specified. The inflow velocity is obtained from the flux with the specified inlet direction" direction
CPressureGradientForce	Calculates particle pressure gradient force
CpressureInletOutletParSlipVelocityFvPatchVectorField	This velocity inlet/outlet boundary condition for pressure boundary where the pressure is specified. A zero-gradient is applied for outflow (as defined by the flux); for inflow, the velocity is obtained from the flux with the specified inlet direction
CpressureInletOutletVelocityFvPatchVectorField	This velocity inlet/outlet boundary condition is applied to velocity boundaries where the pressure is specified. A zero-gradient condition is applied for outflow (as defined by the flux); for inflow, the velocity is obtained from the patch-face normal component of the internal-cell value
CpressureInletUniformVelocityFvPatchVectorField	This velocity inlet boundary condition is applied to patches where the pressure is specified. The uniform inflow velocity is obtained by averaging the flux over the patch, and then applying it in the direction normal to the patch faces
CpressureInletVelocityFvPatchVectorField	This velocity inlet boundary condition is applied to patches where the pressure is specified. The inflow velocity is obtained from the flux with a direction normal to the patch faces
CpressureNormalInletOutletVelocityFvPatchVectorField	This velocity inlet/outlet boundary condition is applied to patches where the pressure is specified. A zero-gradient condition is applied for outflow (as defined by the flux); for inflow, the velocity is obtained from the flux with a direction normal to the patch faces
CpressurePermeableAlphaInletOutletVelocityFvPatchVectorField	The pressurePermeableAlphaInletOutletVelocity is a velocity inlet-outlet boundary condition which can be applied to velocity boundaries for multiphase flows when the pressure boundary condition is specified
CpressurePIDControlInletVelocityFvPatchVectorField	This boundary condition tries to generate an inlet velocity that maintains a specified pressure drop between two face zones downstream. The zones should fully span a duct through which all the inlet flow passes
CprghPermeableAlphaTotalPressureFvPatchScalarField	The prghPermeableAlphaTotalPressure is a mixed boundary condition for the p_rgh variable in multiphase flows
CprghPressureFvPatchScalarField	This boundary condition provides static pressure condition for p_rgh, calculated as:
CprghTotalHydrostaticPressureFvPatchScalarField	This boundary condition provides static pressure condition for p_rgh, calculated as:
CprghTotalPressureFvPatchScalarField	This boundary condition provides static pressure condition for p_rgh, calculated as:
CprimalSolver	Base class for primal solvers
CprimitiveEntry	A keyword and a list of tokens comprise a primitiveEntry. A primitiveEntry can be read, written and printed, and the types and values of its tokens analysed
CprimitiveMesh	Cell-face mesh analysis engine
CprimitiveMeshGeometry	Updateable mesh geometry + checking routines
CprimitiveMeshTools	Collection of static functions operating on primitiveMesh (mainly checks)
CPrimitivePatch	A list of faces which address into the list of points
CPrimitivePatchBase	Non-templated base elements for PrimitivePatch
CPrimitivePatchInterpolation	Interpolation class within a primitive patch. Allows interpolation from points to faces and vice versa
CPrintTable	Print a table in parallel, e.g.;
CprismMatcher	A cellMatcher for prism cells (cellModel::PRISM)
►Cprobes	Set of locations to sample
CfieldGroup	Grouping of field names by GeometricField type
CprocessorCyclicFvPatch	Processor patch
CprocessorCyclicFvPatchField	This boundary condition enables processor communication across cyclic patches
CprocessorCyclicFvsPatchField	Foam::processorCyclicFvsPatchField
CprocessorCyclicGAMGInterface	GAMG agglomerated processor interface
CprocessorCyclicGAMGInterfaceField	GAMG agglomerated processor interface field
CprocessorCyclicPointPatch	Processor patch boundary needs to be such that the ordering of points in the patch is the same on both sides
CprocessorCyclicPointPatchField	Foam::processorCyclicPointPatchField
CprocessorCyclicPolyPatch	Neighbour processor patch
CprocessorFaePatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CprocessorFaMeshes	Container for finite-area processor mesh addressing
CprocessorFaPatch	Processor patch
CprocessorFaPatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CprocessorFvPatch	Processor patch
CprocessorFvPatchField	This boundary condition enables processor communication across patches
CprocessorFvsPatchField	Foam::processorFvsPatchField
CprocessorGAMGInterface	GAMG agglomerated processor interface
CprocessorGAMGInterfaceField	GAMG agglomerated processor interface field
CprocessorLduInterface	An abstract base class for processor coupled interfaces
CprocessorLduInterfaceField	Abstract base class for processor coupled interfaces
CprocessorLOD	Base class to generate a parallel distribution map for sending sufficient target objects to cover a description of the source object, based on processor Level Of Detail (LOD) shapes
CprocessorMeshes	Container for processor mesh addressing
CprocessorPointPatch	Processor patch boundary needs to be such that the ordering of points in the patch is the same on both sides
CprocessorPointPatchField	Foam::processorPointPatchField
CprocessorPolyPatch	Neighbour processor patch
CprocessorTopology	Determines/represents processor-processor connection. After instantiation contains the processor-processor connection table (globally synchronized on all processors)
CprocFacesGAMGProcAgglomeration	Processor agglomeration of GAMGAgglomerations. Needs nAgglomeratingCells which is when to start agglomerating processors. Processors get agglomerated by constructing a single cell mesh for each processor with each processor interface a face. This then gets agglomerated using the pairGAMGAgglomeration algorithm with the number of faces on the original processor interface as face weight
CprocLduInterface	IO interface for processorLduInterface
CprocLduMatrix	I/O for lduMatrix and interface values
CprocLess	Less operator for pairs of <processor><index>
CprofileModel	Base class for profile models for handling aerofoil lift and drag polar diagrams
CprofileModelList	Base class for profile models
Cprofiling	Code profiling
CprofilingInformation	Code profiling information in terms of time spent, number of calls etc
CprofilingPstream	Timers and values for simple (simplistic) mpi-profiling. The entire class behaves as a singleton
CprofilingSysInfo	General system information useful for profiling
CprofilingTrigger	Triggers for starting/stopping code profiling
CpsiReactionThermo	Foam::psiReactionThermo
CpsiThermo	Basic thermodynamic properties based on compressibility
CpsiuReactionThermo	Foam::psiuReactionThermo
CPstream	Inter-processor communications stream
CPstreamBuffers	Buffers for inter-processor communications streams (UOPstream, UIPstream)
CpTraits	A traits class, which is primarily used for primitives
CpTraits< bool >
CpTraits< char >	Template specialisation for pTraits<char>
CpTraits< complex >
CpTraits< edge >	Template specialization for pTraits<edge> so we can use syncTools
CpTraits< face >
CpTraits< Field< T > >
CpTraits< int32_t >	Template specialization for pTraits<int32_t>
CpTraits< int64_t >	Template specialization for pTraits<int64_t>
CpTraits< labelList >	Template specialization for pTraits<labelList> so we can have fields
CpTraits< List< T > >
CpTraits< Scalar >
CpTraits< uint32_t >	Template specialization for pTraits<uint32_t>
CpTraits< uint64_t >	Template specialization for pTraits<uint64_t>
CpTraits< uint8_t >	Template specialization for pTraits<uint8_t>
CpTraits< UList< T > >
CpTraits< vectorList >	Template specialization for pTraits<labelList> so we can have fields
CpTraits< weightedPosition >	PTraits
CPtrDictionary	Template dictionary class which manages the storage associated with it
CPtrDynList	A dynamically resizable PtrList with allocation management
CPtrList	A list of pointers to objects of type <T>, with allocation/deallocation management of the pointers. The operator[] returns a reference to the object, not the pointer
CPtrListDictionary	Template dictionary class which manages the storage associated with it
CPtrMap	A HashTable of pointers to objects of type <T> with a label key
CptscotchDecomp	PTScotch domain decomposition
CpureMixture	Foam::pureMixture
CPurePhaseModel	Class which represents pure phases, i.e. without any species. Returns an empty list of mass fractions
CpureUpwindCFCCellToFaceStencilObject
CPureUpwindFitScheme	Upwind biased fit surface interpolation scheme that applies an explicit correction to upwind
Cpyramid	A geometric pyramid primitive with a base of 'n' sides: i.e. a parametric pyramid. A pyramid is constructed from a base polygon and an apex point
CpyrMatcher	A cellMatcher for pyr cells (cellModel::PYR)
CpyrolysisChemistryModel	Pyrolysis chemistry model. It includes gas phase in the solid reaction
CQRMatrix	QRMatrix computes QR decomposition of a given scalar/complex matrix A into the following:
Cquadratic	Fits a quadratic polynomial of the merit function as a function of step and finds the "optimal" value
CquadraticDiffusivity	Mesh motion diffusivity maipulator which returns the sqr of the given diffusivity
CquadraticEqn	Container to encapsulate various operations for quadratic equation of the forms with real coefficients:
CquadraticFitPolynomial	Quadratic polynomial for centred interpolation fitting
CquadraticLinearFitPolynomial	Quadratic/linear polynomial for interpolation fitting: quadratic normal to the face, linear in the plane of the face for consistency with 2nd-order Gauss
CquadraticLinearUpwindFitPolynomial	Quadratic polynomial for upwind biased interpolation fitting
CquadraticUpwindFitPolynomial	Quadratic polynomial for upwind biased interpolation fitting
Cquaternion	Quaternion class used to perform rotations in 3D space
CQUICKLimiter	Class with limiter function which returns the limiter for the quadratic-upwind differencing scheme
CQUICKVLimiter	Class with limiter function which returns the limiter for the quadratic-upwind differencing scheme
CrampHoldFall	Piecewise linear function with a ramp from a start value to a plateaux value, holding at this, then a linear fall to an end value
CRand48	A pseudo random number generator using the linear congruential algorithm with the following parameters:
►CRandom	Random number generator
CgaussianGeneratorOp	A generator class returning a gaussian distributed random number
CuniformGeneratorOp
CrandomDecomp	Decomposition according to pseudo-random number generator, which is useful for development and stress testing implementations but obviously sub-optimal for normal uses. Can optionally specify the number of consecutive cells to assign to the same processor (agglomeration)
CrandomRenumber	Random renumber. Just to see effect of renumbering
CRanzMarshall	Nusselt-number model using the empirical Ranz-Marshall correlation to be used in modelling of the fluid-particle heat transfer coefficient:
CRASModel	Templated abstract base class for RAS turbulence models
CRASTurbulenceModel	Solves for a RAS turbulence model, with constant U and phi values
CrawIOField	Like IOField but falls back to raw IFstream if no header found. Optionally reads average value. For use in MappedFile container
CrawTopoChangerFvMesh	TopoChangerFvMesh without any added functionality
CrayShooting
CreactingCloud	Virtual abstract base class for templated ReactingCloud
CReactingCloud	Templated base class for reacting cloud
CreactingHeterogeneousCloud	Virtual abstract base class for templated ReactingCloud
CReactingHeterogeneousCloud	Templated base class for reacting heterogeneous cloud
►CReactingHeterogeneousParcel	Reacting heterogeneous Parcel
CconstantProperties	Class to hold reacting particle constant properties
CiNew	Factory class to read-construct particles used for
CReactingLookupTableInjection	Particle injection sources read from look-up table. Each row corresponds to an injection site
CreactingMixture	Foam::reactingMixture
CreactingMultiphaseCloud	Virtual abstract base class for templated reactingMultiphaseCloud
CReactingMultiphaseCloud	Templated base class for multiphase reacting cloud
CReactingMultiphaseLookupTableInjection	Particle injection sources read from look-up table. Each row corresponds to an injection site
►CReactingMultiphaseParcel	Multiphase variant of the reacting parcel class with one/two-way coupling with the continuous phase
CconstantProperties	Class to hold reacting multiphase particle constant properties
CiNew	Factory class to read-construct particles used for
CreactingMultiphaseParcelInjectionData	Container class to provide injection data for reacting multiphase parcels
►CReactingParcel	Reacting parcel class with one/two-way coupling with the continuous phase
CconstantProperties	Class to hold reacting parcel constant properties
CiNew	Factory class to read-construct particles used for
CtrackingData
CreactingParcelInjectionData	Container class to provide injection data for reacting parcels
CReactingPhaseModel	Class which represents phases with volumetric reactions. Returns the reaction rate and heat
►CReaction	Simple extension of ReactionThermo to handle reaction kinetics in addition to the equilibrium thermodynamics already handled
CspecieCoeffs
CReactionList	List of templated reactions
CreactionRateFlameArea	Abstract class for reaction rate per flame area unit
CreadFieldsHandler	A simple field-loader, as per the readFields function object
CRebound	Simple rebound patch interaction model
CreconstructedDistanceFunction	Calculates a reconstructed distance function
►CreconstructionSchemes	Original code supplied by Henning Scheufler, DLR (2019)
Cinterface
CRectangularMatrix	A templated (M x N) rectangular matrix of objects of <Type>, containing M*N elements, derived from Matrix
CRecycleInteraction	Patch interaction model to perform parcel transfer and recycle from one patch to another
CreducedUnits
CreduceFileStates	Reduction operator for PackedList of fileState
►CrefCount	Reference counter for various OpenFOAM components
Czero	A non-counting (dummy) refCount
CreferredWallFace	Storage for referred wall faces. Stores patch index, face and associated points
CrefineCell	Container with cells to refine. Refinement given as single direction
CrefinementData	Transfers refinement levels such that slow transition between levels is maintained. Used in FaceCellWave
CrefinementDistanceData	Transfers refinement levels such that slow transition between levels is maintained. Used in FaceCellWave
CrefinementFeatures	Encapsulates queries for features
►CrefinementHistory	All refinement history. Used in unrefinement
CsplitCell8
CrefinementIterator	Utility class to do iterating meshCutter until all requests satisfied
CrefinementParameters	Simple container to keep together refinement specific information
CrefinementSurfaces	Container for data on surfaces used for surface-driven refinement. Contains all the data about the level of refinement needed per surface
CrefPtr	A class for managing references or pointers (no reference counting)
►CregExpCxx	Wrapper around C++11 regular expressions with some additional prefix-handling. The prefix-handling is loosely oriented on PCRE regular expressions and provides a simple means of tuning the expressions
Cmeta	Functor wrapper for testing meta-characters
CregExpPosix	Wrapper around POSIX extended regular expressions with some additional prefix-handling. The prefix-handling is loosely oriented on PCRE regular expressions and provides a simple means of tuning the expressions
CregionProperties	Simple class to hold region information for coupled region simulations
CregionSide	Determines the 'side' for every face and connected to a singly-connected (through edges) region of faces. Gets set of faces and a list of mesh edges ('fenceEdges') which should not be crossed. Used in splitting a mesh region
CregionSplit	This class separates the mesh into distinct unconnected regions, each of which is then given a label according to globalNumbering()
CregionSplit2D	Splits a patch into regions based on a mask field. Result is a globally consistent label list of region index per patch face
CregionsToCell	TopoSetSource. Select cells belonging to topological connected region (that contains given points)
CregionToCell	A topoSetCellSource to select cells belonging to a topologically connected region (that contains given points). If started inside a given subCellSet keeps to it; if started outside stays outside
CregionToFace	A topoSetFaceSource to select cells belonging to a topologically connected region (that contains given points)
CregIOobject	RegIOobject is an abstract class derived from IOobject to handle automatic object registration with the objectRegistry
CRegisterDebugSwitch	Define the debug information, lookup as name
CRegisterSwitch	Class and registration macros for InfoSwitches and OptimisationSwitches to support reading from system/controlDict and dynamic update
CReitzDiwakar	Secondary breakup model
CReitzKHRT	Secondary breakup model which uses the Kelvin-Helmholtz instability theory to predict the 'stripped' droplets... and the Raleigh-Taylor instability as well
CrelativeVelocityModel
CrelaxationModel	Abstract base class for providing relaxation values to the cell motion controller
CremoveCells	Given list of cells to remove, insert all the topology changes
CremoveFaces	Given list of faces to remove insert all the topology changes. Contains helper function to get consistent set of faces to remove
CRemoveParcels	Removes parcels that hit user-specified face zone faces
CremovePoints	Removes selected points from mesh and updates faces using these points
CrenumberMethod	Abstract base class for renumbering
CrepatchPolyTopoChanger	A mesh which allows changes in the patch distribution of the boundary faces. The change in patching is set using changePatchID. For a boundary face, a new patch ID is given
CreuseTmp
CreuseTmp< TypeR, TypeR >
CreuseTmpDimensionedField
CreuseTmpDimensionedField< TypeR, TypeR, GeoMesh >
CreuseTmpFieldField
CreuseTmpFieldField< Field, TypeR, TypeR >
CreuseTmpGeometricField
CreuseTmpGeometricField< TypeR, TypeR, PatchField, GeoMesh >
CreuseTmpTmp
CreuseTmpTmp< TypeR, Type1, Type12, TypeR >
CreuseTmpTmp< TypeR, TypeR, TypeR, Type2 >
CreuseTmpTmp< TypeR, TypeR, TypeR, TypeR >
CreuseTmpTmpDimensionedField
CreuseTmpTmpDimensionedField< TypeR, Type1, Type12, TypeR, GeoMesh >
CreuseTmpTmpDimensionedField< TypeR, TypeR, TypeR, Type2, GeoMesh >
CreuseTmpTmpDimensionedField< TypeR, TypeR, TypeR, TypeR, GeoMesh >
CreuseTmpTmpFieldField
CreuseTmpTmpFieldField< Field, TypeR, Type1, Type12, TypeR >
CreuseTmpTmpFieldField< Field, TypeR, TypeR, TypeR, Type2 >
CreuseTmpTmpFieldField< Field, TypeR, TypeR, TypeR, TypeR >
CreuseTmpTmpGeometricField
CreuseTmpTmpGeometricField< TypeR, Type1, Type12, TypeR, PatchField, GeoMesh >
CreuseTmpTmpGeometricField< TypeR, TypeR, TypeR, Type2, PatchField, GeoMesh >
CreuseTmpTmpGeometricField< TypeR, TypeR, TypeR, TypeR, PatchField, GeoMesh >
CreverseLinear	Inversed weight central-differencing interpolation scheme class
CReversibleReaction	Simple extension of Reaction to handle reversible reactions using equilibrium thermodynamics
CReynoldsStress	Reynolds-stress turbulence model base class
CrhoConst	RhoConst (rho = const) of state
CrhoReactionThermo	Foam::rhoReactionThermo
CrhoThermo	Basic thermodynamic properties based on density
CrigidBodyMeshMotion	Rigid-body mesh motion solver for fvMesh
CrigidBodyMeshMotionSolver	Rigid-body mesh motion solver for fvMesh
CRKCK45	4/5th Order Cash-Karp Runge-Kutta ODE solver
CRKDP45	4/5th Order Dormand-Prince Runge-Kutta ODE solver
CRKF45	4/5th Order Runge-Kutta-Fehlberg ODE solver
Crodas23	L-stable, stiffly-accurate embedded Rosenbrock ODE solver of order (2)3
Crodas34	L-stable, stiffly-accurate embedded Rosenbrock ODE solver of order (3)4
CRoots	Templated storage for the roots of polynomial equations, plus flags to indicate the nature of the roots
CRosenbrock12	L-stable embedded Rosenbrock ODE solver of order (1)2
CRosenbrock23	L-stable embedded Rosenbrock ODE solver of order (2)3
CRosenbrock34	L-stable embedded Rosenbrock ODE solver of order (3)4
CrotatedBoxToCell	A topoSetCellSource to select cells based on cell centres inside a given parallopiped (i.e. rotated/skewed box)
CrotatingPressureInletOutletVelocityFvPatchVectorField	This velocity inlet/outlet boundary condition is applied to patches in a rotating frame where the pressure is specified. A zero-gradient is applied for outflow (as defined by the flux); for inflow, the velocity is obtained from the flux with a direction normal to the patch faces
CrotatingTotalPressureFvPatchScalarField	This boundary condition provides a total pressure condition for patches in a rotating frame
CrotatingWallVelocityFvPatchVectorField	This boundary condition provides a rotational velocity condition
CroundOp
CroundOp< Scalar >	Round scalar - functor version of std::round
CRowVector	Templated 3D row-vector derived from MatrixSpace adding construction from 3 components and element access using x(), y() and z()
CrPolynomial	Reciprocal polynomial equation of state for liquids and solids
CSaffmanMeiLiftForce	Saffman-Mei particle lift force model applicable to spherical particles
CsampledCuttingPlane	A sampledSurface defined by a plane using an iso-surface algorithm to cut the mesh
CsampledCuttingSurface	A surface define by using an input surface to cut the mesh cells
CsampledDistanceSurface	A sampledSurface defined by a distance to a surface - resolved using an iso-surface (algorithm: cell, point, topo)
CsampledFaceZone	A sampledSurface defined by a faceZone or faceZones
CsampledInterface	A sampledSurface that calculates the PLIC interface in VoF simulations Only works in combination with isoAdvector and a reconstruction scheme
CsampledIsoSurface	A sampledSurface defined by a surface of iso value. It only recalculates the iso-surface if time changes. To be used in sampleSurfaces / functionObjects
CsampledIsoSurfaceCell	A sampledSurface defined by a surface of iso value using a cell algorithm. It only recalculates the iso-surface if time changes. To be used in sampleSurfaces / functionObjects
CsampledIsoSurfacePoint	A sampledSurface defined by a surface of iso value using a point algorithm (always triangulated!). It only recalculates the iso-surface if time changes. To be used in sampleSurfaces / functionObjects
CsampledIsoSurfaceTopo	A sampledSurface defined by a surface of iso value using a topo algorithm. It only recalculates the iso-surface if time changes. To be used in sampleSurfaces / functionObjects
CsampledMeshedSurface	A sampledSurface from a meshed surface. It samples on the points/faces of the meshed surface
CsampledMeshedSurfaceNormal	Variant of sampledMeshedSurface that samples the surface-normal component of a vector field
CsampledNone	A no operation sampledSurface that can be used when a sampler is expected but is not desired. For example, to temporarily disable a sampling definition, or to provide a boilerplate definition that is overwritten at a later stage in a dictionary
CsampledPatch	A sampledSurface on patches. Non-triangulated by default
CsampledPatchInternalField	Variation of sampledPatch that samples the internalField (at a given normal distance from the patch) instead of the patchField. Note:
CsampledPlane	A sampledSurface defined by a plane which cuts the mesh using the cuttingPlane alorithm. The surface is triangulated by default
►CsampledSet	Holds list of sampling points which is filled at construction time. Various implementations of this base class to e.g. get sampling points at uniform distance along a line (uniformSet) or directly specified (cloudSet)
CiNew	Class used for the read-construction of
CiNewCapture
CsampledSets	Set of sets to sample
►CsampledSurface	An abstract class for surfaces with sampling
CiNew	PtrList read-construction helper
CiNewCapture
CsampledSurfaces	Set of surfaces to sample
CsampledThresholdCellFaces	A sampledSurface defined by the cell faces corresponding to a threshold value
CsaturationModel
CscalarDivideOp	Scalar division with divide-by-zero protection
CscalarModuloOp	Floating point modulo operation with divide-by-zero protection
CscalarProduct
CscalarRange	Scalar bounds to be used as a unary predicate
CscalarRanges	A collection of scalar bounds to be used as a unary predicate
CscaledFixedValueFvPatchField	This condition applies a scalar multiplier to the value of another boundary condition
CschemesLookup	Selector class for finite area/finite volume differencing schemes
CscotchDecomp	Scotch domain decomposition
CsearchableBox	Searching on bounding box
CsearchableBoxFeatures
CsearchableCone	Searching on (optionally hollow) cone
CsearchableCylinder	Searching on a cylinder
CsearchableDisk	Searching on circular disk given as origin, normal (gets normalised) and radius. Optionally it can be an annular ring
CsearchableExtrudedCircle	Searching on edgeMesh with constant radius
CsearchablePlane	Searching on (infinite) plane. The dictionary specifications are identical to the Foam::plane requirements
CsearchablePlate	Searching on finite plate. Plate has to be aligned with coordinate axes. Plate defined as origin and span. One of the components of span has to be 0 which defines the normal direction. E.g
CsearchablePlateFeatures
CsearchableRotatedBox	Searching on a rotated box
CsearchableSphere	Searching on general spheroid
►CsearchableSurface	Base class of (analytical or triangulated) surface. Encapsulates all the search routines. WIP
CiNew	Class used for the read-construction of
CsearchableSurfaceCollection	Set of transformed searchableSurfaces. Does not do boolean operations so when meshing might find parts 'inside'
CsearchableSurfaceControl
CsearchableSurfaceFeatures	Decorator that returns the features of a searchable surface
CsearchableSurfaceModifier	Changing a surface
CsearchableSurfaces	Container for searchableSurfaces. The collection is specified as a dictionary. For example,
CsearchableSurfacesQueries	A collection of tools for searchableSurfaces
CsearchableSurfaceToCell	A topoSetCellSource to select cells whose cell centre enclosed by a given searchableSurface
CsearchableSurfaceToFace	A topoSetFaceSource to select faces whose face centre enclosed by a given searchableSurface
CsearchableSurfaceToFaceZone	A topoSetSource to select all faces whose cell-cell centre vector intersects with a given searchableSurface
CsearchableSurfaceToPoint	A topoSetPointSource to select points which are centre enclosed by a given searchableSurface
CsearchableSurfaceWithGaps	SearchableSurface using multiple slightly shifted underlying surfaces to make sure pierces don't go through gaps:
CsemiPermeableBaffleMassFractionFvPatchScalarField	This is a mass-fraction boundary condition for a semi-permeable baffle
CsemiPermeableBaffleVelocityFvPatchVectorField	This is a velocity boundary condition for a semi-permeable baffle
CsensibleEnthalpy	Thermodynamics mapping class to expose the sensible enthalpy functions
CsensibleInternalEnergy	Thermodynamics mapping class to expose the sensible internal energy functions
Csensitivity	Abstract base class for adjoint sensitivities
Csepternion	Septernion class used to perform translations and rotations in 3D space
CseriesLess
CseriesProfile	Profile model where polar lift and drag coefficients are computed as sum of trigonometric series by using an input angle of attack
CsetAndNormalToFaceZone	A topoSetSource to select faces based on usage in a faceSet, where the normal vector is used to orient the faces
CsetsToFaceZone	A topoSetSource to select all faces in a given faceSet, which are oriented in slave cells of a given cellSet
CsetToCellZone	A topoSetSource to convert a cellSet to a cellZone (and associated cellSet)
CsetToFaceZone	A topoSetSource to convert a faceSet to a faceZone (and associated faceSet)
CsetToPointZone	A topoSetSource to convert a pointSet to a pointZone (and associated pointSet)
CsetUpdater	Keeps cell/face/vertex sets uptodate. Both the ones loaded and the ones on disk
Cseulex	An extrapolation-algorithm, based on the linearly implicit Euler method with step size control and order selection
CSFCDLimiter	Class with limiter function which returns the limiter for the SFCD differencing scheme based on phict obtained from the LimiterFunc class
CSHA1	Functions to compute SHA1 message digest according to the NIST specification FIPS-180-1
CSHA1Digest	The SHA1 message digest
CshapeSensitivitiesBase
CshapeToCell	A topoSetCellSource to select cells based on the type of their cell shapes
CshellSurfaces	Encapsulates queries for volume refinement ('refine all cells within shell')
CSHF	Secondary Breakup Model to take account of the different breakup regimes, bag, molutimode, shear...
CshortEdgeFilter2D	This class filters short edges generated by the CV2D mesher
CshortestPathSet	Finds shortest path (in terms of cell centres) to walk on mesh from any point in insidePoints to any point in outsidePoints
CSIBS	A semi-implicit mid-point solver for stiff systems of ordinary differential equations
►CsigFpe	Set up trapping for floating point exceptions (signal FPE)
Cignore	Helper to locally ignore SIGFPE handling
CsigInt	Signal handler for INT interrupt
CsigQuit	Signal handler for QUIT interrupt
CsigSegv	Signal handler for SEGV interrupt
CsigStopAtWriteNow	Signal handler to write and stop the job. The interrupt is defined by OptimisationSwitches::stopAtWriteNowSignal
CsigWriteNow	Signal handler to write once and continue. The interrupt is defined by OptimisationSwitches::writeNowSignal
Csimple	Base class for solution control classes
CsimpleControl	SIMPLE control class to supply convergence information/checks for the SIMPLE loop
CSIMPLEControl	SIMPLE control class to supply convergence information/checks for the SIMPLE loop
CSIMPLEControlOpt	SIMPLE control class for optimisation runs. Each time is sub-cycled and corresponds to one optimisation cycle
CSIMPLEControlSingleRun	SIMPLE control class for single runs (i.e. not optimisation). Time acts as in simpleFoam, with all solver control read through optimisationDict
CsimpleFilter	Simple top-hat filter used in dynamic LES models
CsimpleGeomDecomp	Simple geometric decomposition, selectable as simple
CsimpleMatrix	A simple square matrix solver with scalar coefficients
CsimpleObjectRegistry	Object registry for simpleRegIOobject. Maintains ordering
CsimpleObjectRegistryEntry
CsimpleRegIOobject	Abstract base class for registered object with I/O. Used in debug symbol registration
CsimplifiedFvMesh	Functions to generate simplified finite volume meshes
►CsingleCellFvMesh	FvMesh as subset of other mesh. Consists of one cell and all original bounday faces. Useful when manipulating boundary data. Single internal cell only needed to be able to manipulate in a standard way
CagglomPatchFieldMapper	Patch field mapper class for agglomerated meshes
CsingleComponentMixture	Single component mixture
CSingleKineticRateDevolatilisation	Single kinetic rate devolatisation model
CSingleMixtureFraction	Templated parcel multi-phase, multi-component class
CSinglePhaseMixture	Templated parcel single phase, multi-component class
CsinglePhaseTransportModel	A simple single-phase transport model based on viscosityModel
CsingleRun	Update design variables using steepest descent
CsingleStepReactingMixture	Single step reacting mixture
CsixDoFRigidBodyDisplacementPointPatchVectorField	Foam::sixDoFRigidBodyDisplacementPointPatchVectorField
CsixDoFRigidBodyMotion	Six degree of freedom motion for a rigid body
CsixDoFRigidBodyMotionConstraint	Base class for defining constraints for sixDoF motions
CsixDoFRigidBodyMotionRestraint	Base class for defining restraints for sixDoF motions
CsixDoFRigidBodyMotionSolver	6-DoF solid-body mesh motion solver for an fvMesh
CsixDoFRigidBodyMotionState	Holds the motion state of sixDoF object. Wrapped up together to allow rapid scatter to other processors. The processors must all maintain exactly the same state data to avoid any drift or inconsistency
CsixDoFSolver
CsizeOp	Extract size (as label) from an object, typically using its size() method
CskewCorrected	Skewness-corrected interpolation scheme that applies an explicit correction to given scheme
CskewCorrectedEdgeInterpolation	Linear/upwind blended differencing scheme
CskewCorrectionVectors	Skew-correction vectors for the skewness-corrected interpolation scheme
CSLGThermo	Thermo package for (S)olids (L)iquids and (G)ases Takes reference to thermo package, and provides:
CSlicedDimensionedField	Specialisation of DimensionedField that holds a slice of a given field so that it acts as a DimensionedField
CslicedFvPatchField	Specialization of fvPatchField which creates the underlying fvPatchField as a slice of the given complete field
CslicedFvsPatchField	Specialization of fvsPatchField which creates the underlying fvsPatchField as a slice of the given complete field
CSlicedGeometricField	Specialization of GeometricField which holds slices of given complete fields in a form that they act as a GeometricField
CSliceList	A List with indirect slice addressing
►CsliceRange	A set of labels defined by a start, a length and a stride
Cconst_iterator	Bidirectional input iterator with const access
Cconst_reverse_iterator	Bidirectional reverse input iterator with const access
Cindexer	A value indexer, for iteration or generation
CslidingInterface	Sliding interface mesh modifier. Given two face zones, couple the master and slave side using a cutting procedure
CslipFaPatchField	Foam::slipFaPatchField
CslipFvPatchField	This boundary condition provides a slip constraint
CslipPointPatchField	Foam::slipPointPatchField
►CSLListBase	Base for singly-linked lists
Cconst_iterator	A primitive const node iterator
Citerator	A primitive non-const node iterator
Clink	The structure for a singly-linked storage node
CSloanRenumber	Sloan renumbering algorithm
CSmanip	An IOstream manipulator taking arguments
CsmoluchowskiJumpTFvPatchScalarField	Smoluchowski temperature jump boundary condition
CsmoothAlignmentSolver
►CsmoothData	Helper class used by the fvc::smooth and fvc::spread functions
CtrackData	Class used to pass additional data in
CSmoothSolver	Iterative solver for symmetric and asymmetric matrices which uses a run-time selected smoother e.g. GaussSeidel to converge the solution to the required tolerance. To improve efficiency, the residual is evaluated after every nSweeps smoothing iterations
CsmoothSolver	Iterative solver for symmetric and asymmetric matrices which uses a run-time selected smoother e.g. GaussSeidel to converge the solution to the required tolerance
CsnapParameters	Simple container to keep together snap specific information
CsnappyLayerDriver	All to do with adding layers
CsnappyRefineDriver
CsnappySnapDriver	All to do with snapping to surface
CsnappyVoxelMeshDriver	Equivalent of snappyRefineDriver but operating on a voxel mesh
CsolarCalculator	A solar calculator model providing models for the solar direction and solar loads
CsolidArrheniusReactionRate	Arrhenius reaction rate for solids
CsolidBodyDisplacementLaplacianFvMotionSolver	Applies Laplacian displacement solving on top of a transformation of the initial points using a solid-body motion
CsolidBodyFvGeometryScheme	Geometry calculation scheme that performs geometry updates only in regions where the mesh has changed
CsolidBodyMotionDisplacementPointPatchVectorField	Enables the specification of a fixed value boundary condition using the solid body motion functions
CsolidBodyMotionFunction	Base class for defining solid-body motions
CsolidBodyMotionSolver	Solid-body motion of the mesh specified by a run-time selectable motion function
CsolidChemistryModel	Extends base solid chemistry model by adding a thermo package, and ODE functions
CsolidMixtureProperties	A mixture of solids
►CsolidParticle	Simple solid spherical particle class with one-way coupling with the continuous phase
CiNew	Factory class to read-construct particles (for parallel transfer)
CtrackingData	Class used to pass tracking data to the trackToFace function
CsolidParticleCloud	A Cloud of solid particles
CsolidProperties	The thermophysical properties of a solid
CsolidReaction	Read solid reactions of the type S1 = S2 + G1
CsolidReactionThermo	Foam::solidReactionThermo
CsolidThermo	Fundamental solid thermodynamic properties
Csolution	Selector class for relaxation factors, solver type and solution
►CsolutionControl	Base class for solution control classes
CfieldData	Simple convenient storage of field residuals
Csolver	Base class for solution control classes
CsolverControl	Base class for solver control classes
CSolverPerformance	SolverPerformance is the class returned by the LduMatrix solver containing performance statistics
CsolverTemplate	Class to store solver template specifications
CSortableList	A list that is sorted upon construction or when explicitly requested with the sort() method
►CSortableListDRGEP	A list that is sorted upon construction or when explicitly requested with the sort() method
Cless	Less function class used by the sort function
►CSortableListEFA	A list that is sorted upon construction or when explicitly requested with the sort() method
Cmore	Less function class used by the sort function
CSortList	An indirect list with addressing based on sorting. The list is sorted upon construction or when explicitly requested
CSpatialTensor	Templated 3D spatial tensor derived from MatrixSpace used to represent transformations of spatial vectors and the angular and linear inertia of rigid bodies
►CspatialTransform	Compact representation of the Plücker spatial transformation tensor in terms of the rotation tensor E and translation vector r
Cdual	Wrapper-class to provide dual functions and operators
Ctranspose	Wrapper-class to provide transpose functions and operators
►CSpatialVector	Templated 3D spatial vector derived from VectorSpace used to represent the anglular and linear components of position, velocity and acceleration of rigid bodies
Cdual	Class to represent the dual spatial vector
Cspecie	Base class of the thermophysical property types
CspecieElement
CSpecieMixture	Foam::SpecieMixture
CspeciesSorptionFvPatchScalarField	This boundary condition provides a first-order zero-gradient condition for a given scalar field to model time-dependent adsorption-desorption processes
CSpecularReflection	Reversing the wall-normal component of the particle velocity
CSphereDragForce	Particle-drag model wherein drag forces (per unit carrier-fluid velocity) are dynamically computed based on empirical expressions
CsphereToCell	A topoSetCellSource to select cells based on cell centres inside a given bounding sphere
CsphereToFace	A topoSetFaceSource to select faces based on face centres inside a given bounding sphere
CsphereToPoint	A topoSetPointSource to select points which are inside a given bounding sphere
CSphericalTensor	A templated (3 x 3) diagonal tensor of objects of <T>, effectively containing 1 element, derived from VectorSpace
CSphericalTensor2D	A templated (2 x 2) diagonal tensor of objects of <T>, effectively containing 1 element, derived from VectorSpace
CsplineInterpolationWeights	Catmull-Rom spline interpolation
CsplitCell	Description of cell after splitting. Contains cellLabel and pointers to cells it it split in. See directedRefinement
CsprayCloud	Virtual abstract base class for templated SprayCloud
CSprayCloud	Templated base class for spray cloud
►CSprayParcel	Reacting spray parcel, with added functionality for atomization and breakup
CconstantProperties	Class to hold reacting particle constant properties
CiNew	Factory class to read-construct particles used for
CspringRenumber	Use spring analogy - attract neighbouring cells according to the distance of their cell indices
CSQP	The quasi-Newton SQP formula for constrained optimisation
CSquareMatrix	A templated (N x N) square matrix of objects of <Type>, containing N*N elements, derived from Matrix
CSR1	The quasi-Newton Symmetric Rank One formula
CSRFForce	Calculates particle SRF reference frame force
CSRFFreestreamVelocityFvPatchVectorField	Freestream velocity condition to be used in conjunction with the single rotating frame (SRF) model (see: SRFModel class)
CSRFVelocityFvPatchVectorField	Velocity condition to be used in conjunction with the single rotating frame (SRF) model (see: SRFModel class)
CSRFWallVelocityFvPatchVectorField	Wall-velocity condition to be used in conjunction with the single rotating frame (SRF) model (see: FOAM::SRFModel)
CSRIFallOffFunction	The SRI fall-off function
CstabilisedFvGeometryScheme	Geometry calculation scheme that implements face geometry calculation using normal-component-of-area weighted triangle contributions
CstabiliseOp
CstabiliseOp2
CstabiliseOp3
CStandardChemistryModel	Extends base chemistry model by adding a thermo package, and ODE functions. Introduces chemistry equation system and evaluation of chemical source terms
CStandardWallInteraction	Wall interaction model
CstaticEngineMesh	Foam::staticEngineMesh
CstaticFvMesh	Foam::staticFvMesh
CStaticPhaseModel	Class which represents a static fluid phase
CStationaryPhaseModel	Class which represents a stationary (and therefore probably solid) phase. Generates, but does not store, zero velocity and flux field and turbulent qauantities. Throws an error when non-const access is requested to the motion fields or when the momentum equation is requested. Usage must must protect against such calls
CsteadyOptimisation	Iterate the optimisation cycles. For steady state opt, this coinsides with evolving Time
CsteepestDescent	Update design variables using steepest descent
CstepUpdate	Abstract base class for step update methods used in line search
CSTLpoint	A vertex point or facet normal representation for STL files
CSTLtriangle	A triangle representation for STL files
CStochasticCollisionModel	Templated stochastic collision model class
CStochasticDispersionRAS	The velocity is perturbed in random direction, with a Gaussian random number distribution with variance sigma. where sigma is defined below
CstoreOp
►CstreamLineParticle	Particle class that samples fields as it passes through. Used in streamline calculation
CiNew	Factory class to read-construct particles used for parallel transfer
CtrackingData
CstreamLineParticleCloud	A Cloud of streamLine particles
►Cstring	A class for handling character strings derived from std::string
Chash	Deprecated hashing functor - use hasher
Chasher	Hashing functor for string and derived string classes
CstructuredDecomp	Walk out decomposition of patch cells mesh - selectable as structured
►CstructuredRenumber	Renumbering according to mesh layers. depthFirst = true: first column gets ids 0..nLayer-1, second nLayers..2*nLayers-1 etc. depthFirst = false: first layer gets ids 0,1,2 etc
ClayerLess	Less function class that can be used for sorting according to
CsubCycle	Perform a subCycleTime on a field
CsubCycleField
CsubCycleTime	A class for managing sub-cycling times
CSubDimensionedField	SubDimensionedField is a DimensionedField obtained as a section of another DimensionedField
CSubField	SubField is a Field obtained as a section of another Field, without its own allocation. SubField is derived from a SubList rather than a List
CSubList	A List obtained as a section of another List
CsubLoopTime	A class for managing sub-loops referencing Time
CsubModelBase	Base class for generic sub-models requiring to be read from dictionary. Provides a mechanism to read and write properties from a dictionary to enable clean re-starts. Used by, e.g. clou dsub-models
Csubstance
CSubStrings	Sub-ranges of a string with a structure similar to std::match_results, but without the underlying regular expression matching
CsubTriSurfaceMesh	On-the-fly subset of triSurfaceMesh (based on selected patches)
CsumOp
CsumOp2
CsumOp3
CSuperBeeLimiter	Class with limiter function which returns the limiter for the SuperBee differencing scheme based on r obtained from the LimiterFunc class
CsupersonicFreestreamFvPatchVectorField	This boundary condition provides a supersonic free-stream condition
CSuppressionCollision	Inter-cloud collision model, whereby the canReact flag can be used to inhibit devolatilisation and surface reactions
CsurfaceAlignedSBRStressFvMotionSolver	Mesh motion solver for an fvMesh. Based on solving the cell-centre solid-body rotation stress equations for the motion displacement. The model calculates the necessary rotation to align the stl surface with the closest mesh face normals and it calculates the respective source term for the SBRStress equation
CsurfaceCellSizeFunction	Abstract base class for specifying target cell sizes
CsurfaceDisplacementPointPatchVectorField	Displacement fixed by projection onto triSurface. Use in a displacementMotionSolver as a bc on the pointDisplacement field
CsurfaceFeatures	Holds feature edges/points of surface
CSurfaceFilmModel	Templated wall surface film model class
CsurfaceInterpolation	Cell to surface interpolation scheme. Included in fvMesh
CsurfaceInterpolationScheme	Abstract base class for surface interpolation schemes
CsurfaceIntersection	Basic surface-surface intersection description. Constructed from two surfaces it creates a description of the intersection
CsurfaceIteratorIso	Finds the isovalue that matches the volume fraction
CsurfaceIteratorPLIC	Finds the cutValue that matches the volume fraction
CsurfaceLocation	Contains information about location on a triSurface
CsurfaceMesh	Mesh data needed to do the Finite Volume discretisation
CsurfaceNormalFixedValueFvPatchVectorField	This boundary condition provides a surface-normal vector boundary condition by its magnitude
CsurfaceOffsetLinearDistance
CsurfacePatch	A 'patch' on surface as subset of triSurface
CSurfaceReactionModel	Templated surface reaction model class
CsurfaceReader	Base class for surface readers
CsurfaceRegistry	Wraps the normal objectRegistry with a local instance for surfaces
CsurfaceSets	Various utilities to handle sets relating mesh to surface. Note: work in progress. Used in meshing tools
CsurfaceSlipDisplacementFvPatchField	FvPatchField corresponding to surfaceSlipDisplacementPointPatchField. Is just a slip type since all hard work (projection) is done in the pointPatch field
CsurfaceSlipDisplacementPointPatchVectorField	Displacement follows a triSurface. Use in a displacementMotionSolver as a bc on the pointDisplacement field. Following is done by calculating the projection onto the surface according to the projectMode
CsurfaceTensionModel	Abstract base-class for surface tension models which return the surface tension coefficient field
CsurfaceToCell	A topoSetCellSource to select cells based on relation to a surface given by an external file
CsurfaceToPoint	A topoSetPointSource to select points based on relation to a surface given by an external file
CsurfaceWriter	Base class for surface writers
CsurfaceZonesInfo
CsurfactantProperties
CsurfGeoMesh	The surfMesh GeoMesh (for holding fields)
CsurfMesh	A surface mesh consisting of general polygon faces that has IO capabilities and a registry for storing fields
CsurfPointGeoMesh	The surfMesh GeoMesh (for holding fields)
CsurfZone	A surface zone on a MeshedSurface
CsurfZoneIdentifier	Identifies a surface patch/zone by name and index, with optional geometric type
CsurfZoneIOList	IOobject for a surfZoneList
CsutherlandTransport	Transport package using Sutherland's formula
CSVD	Singular value decomposition of a rectangular matrix
CswarmCorrection
CsweepData	Helper class used by fvc::sweep function
CswirlFanVelocityFvPatchField	This boundary condition provides a jump condition for U across a cyclic pressure jump condition and applies a transformation to U
CswirlFlowRateInletVelocityFvPatchVectorField	This boundary condition provides a volumetric- OR mass-flow normal vector boundary condition by its magnitude as an integral over its area with a swirl component determined by the angular speed, given in revolutions per minute (RPM)
CswirlInletVelocityFvPatchVectorField	This boundary condition describes an inlet vector boundary condition in swirl coordinates given a central axis, central point, axial, radial and tangential velocity profiles
CSwitch	A simple wrapper around bool so that it can be read as a word: true/false, on/off, yes/no, any/none. Also accepts 0/1 as a string and shortcuts t/f, y/n
CsymGaussSeidelSmoother	A lduMatrix::smoother for symmetric Gauss-Seidel
CSymmetricSquareMatrix	A templated (N x N) square matrix of objects of <Type>, containing N*N elements, derived from Matrix
CsymmetryFaePatchField	Foam::symmetryFaePatchField
CsymmetryFaPatch	Symmetry-plane patch
CsymmetryFaPatchField	Foam::symmetryFaPatchField
CsymmetryFvPatch	Symmetry patch for non-planar or multi-plane patches
CsymmetryFvPatchField	This boundary condition enforces a symmetry constraint
CsymmetryFvsPatchField	Foam::symmetryFvsPatchField
CsymmetryPlaneFvPatch	Symmetry-plane patch
CsymmetryPlaneFvPatchField	This boundary condition enforces a symmetryPlane constraint
CsymmetryPlaneFvsPatchField	Foam::symmetryPlaneFvsPatchField
CsymmetryPlanePointPatch	Symmetry-plane patch
CsymmetryPlanePointPatchField	A symmetry-plane boundary condition for pointField
CsymmetryPlanePolyPatch	Symmetry-plane patch
CsymmetryPointPatch	Symmetry patch for non-planar or multi-plane patches
CsymmetryPointPatchField	A Symmetry boundary condition for pointField
CsymmetryPolyPatch	Symmetry patch for non-planar or multi-plane patches
CSymmTensor	A templated (3 x 3) symmetric tensor of objects of <T>, effectively containing 6 elements, derived from VectorSpace
CSymmTensor2D	A templated (2 x 2) symmetric tensor of objects of <T>, effectively containing 3 elements, derived from VectorSpace
CsymmTypeOfRank
CsymmTypeOfRank< Cmpt, 0 >
CsymmTypeOfRank< Cmpt, 1 >
CsymmTypeOfRank< Cmpt, 2 >
CsyncTools	Various tools to aid synchronizing lists across coupled patches. WIP
CsyringePressureFvPatchScalarField	This boundary condition provides a pressure condition, obtained from a zero-D model of the cylinder of a syringe
CTAB	The TAB Method for Numerical Calculation of Spray Droplet Breakup
CtableReader	Base class to read table data for the interpolationTable
Ctabulated6DoFAcceleration	Tabulated 6DoF acceleration
CtabulatedAnIsoSolidTransport	Transport properties package using Function1 type data for anisotropic thermal conductivity
CtabulatedSolidTransport	Transport properties package using non-uniform tabulated data for thermal conductivity vs temperature
CtabulatedTransport	Transport properties package using non-uniform tabulated data for viscosity and thermal conductivity vs temperature
CtargetCoeffTrim	Trim model where the operating characteristics of rotor (e.g. blade pitch angle) can vary to reach a specified target thrust and torque
CtargetVolumeToCell	A topoSetCellSource to select cells based on a target volume of cells. Adapts a plane until it has enough
CTDACChemistryModel	Extends StandardChemistryModel by adding the TDAC method
CTDILUPreconditioner	Simplified diagonal-based incomplete LU preconditioner for asymmetric matrices
CtemperatureCoupledBase	Common functions used in temperature coupled boundaries
CtemperatureDependentAlphaContactAngleFvPatchScalarField	Temperature-dependent alphaContactAngle scalar boundary condition
CtemperaturePhaseChangeTwoPhaseMixture
CTensor	A templated (3 x 3) tensor of objects of <T> derived from MatrixSpace
CTensor2D	A templated (2 x 2) tensor of objects of <T> derived from VectorSpace
CtetCell	A tetrahedral cell primitive
CtetDecomposer	Decomposes polyMesh into tets or pyramids
CtetherPotential
CtetherPotentialList
CtetIndices	Storage and named access for the indices of a tet which is part of the decomposition of a cell
CtetMatcher	A cellMatcher for tet cells (cellModel::TET)
CtetOverlapVolume	Calculates the overlap volume of two cells using tetrahedral decomposition
CtetPoints	Tet storage. Null constructable (unfortunately tetrahedron<point, point> is not)
►Ctetrahedron	A tetrahedron primitive
CdummyOp	Dummy
CstoreOp	Store resulting tets
CsumVolOp	Sum resulting volumes
CtetWedgeMatcher	A cellMatcher for tetWedge cells (cellModel::TETWEDGE)
CTGaussSeidelSmoother	Foam::TGaussSeidelSmoother
CThermalDiffusivity	Templated wrapper class to provide compressible turbulence models thermal diffusivity based thermal transport
CThermalPhaseChangePhaseSystem	Class to provide interfacial heat and mass transfer between a number of phases according the interfacial temperature approximated by the saturation temperature
CThermoCloud	Templated base class for thermodynamic cloud
CthermoCloud	Virtual abstract base class for templated ThermoCloud
CThermoCombustion	Thermo model wrapper for combustion models
CthermoIncompressibleTwoPhaseMixture	A two-phase incompressible transportModel
CThermoLookupTableInjection	Particle injection sources read from look-up table. Each row corresponds to an injection site
►CThermoParcel	Thermodynamic parcel class with one/two-way coupling with the continuous phase. Includes Kinematic parcel sub-models, plus:
CconstantProperties	Class to hold thermo particle constant properties
CiNew	Factory class to read-construct particles used for
CtrackingData
CthermoParcelInjectionData	Container class to provide injection data for thermodynamic parcels
CThermoPhaseModel	Class which represents a phase with a thermodynamic model. Provides access to the thermodynamic variables. Note that the thermo model itself is not returned as this class could be substituted in the hierarchy for one which mirrors the functionality, but does not include a thermo model; an incompressible phase model, for example
CthermophysicalFunction	Abstract base class for thermo-physical functions
CthermophysicalProperties	Base-class for thermophysical properties of solids, liquids and gases providing an interface compatible with the templated thermodynamics packages
CthermophysicalPropertiesSelector	Wrapper class providing run-time selection of thermophysicalProperties for the templated thermodynamics packages
CThermoReynoldsNumber	Calculates and writes particle Reynolds number field on the cloud. The normalisation factors are calculated with thermal effects
CThermoSurfaceFilm	Thermo parcel surface film model
CthirdBodyArrheniusReactionRate	Arrhenius reaction rate enhanced by third-body interaction
CthirdBodyEfficiencies	Third body efficiencies
CthreadedCollatedOFstream	Master-only drop-in replacement for OFstream
CthreePhaseInterfaceProperties	Properties to aid interFoam : 1. Correct the alpha boundary condition for dynamic contact angle. 2. Calculate interface curvature
CthresholdCellFaces	Selects the mesh cell faces specified by a threshold value. Non-triangulated by default
CTime	Class to control time during OpenFOAM simulations that is also the top-level objectRegistry
CtimeControl	General time dependent execution controller. The execution parameters are given by the "Control" and (optionally) the "Interval", with the default being to execute every time-step
CTimeFunction1	Light wrapper around Function1 to provide a mechanism to update time-based entries
CTimePaths	Address the time paths without using the Time class
Ctimer	Implements a timeout mechanism via sigalarm
CTimeScaleModel	Base class for time scale models
CtimeSelector	A List of scalarRange for selecting times
CTimeState	The time value with time-stepping information, user-defined remapping, etc
CtimeVaryingAlphaContactAngleFvPatchScalarField	A time-varying alphaContactAngle scalar boundary condition (alphaContactAngleTwoPhaseFvPatchScalarField)
CtimeVaryingMappedFixedValueFvPatchField	This boundary conditions interpolates the values from a set of supplied points in space and time
CtimeVaryingMappedFixedValuePointPatchField	A time-varying form of a mapped fixed value boundary condition
CtimeVaryingMassSorptionFvPatchScalarField	This boundary condition provides a first order fixed-value condition for a given scalar field to model time-dependent adsorption-desoprtion processes to be used with the interfaceOxideRate mass model
CtimeVaryingUniformFixedValueFaPatchField	A time-varying form of a uniform fixed value finite area boundary condition
CtimeVaryingUniformFixedValuePointPatchField	A time-varying form of a uniform fixed value boundary condition
Ctmp	A class for managing temporary objects
►Ctoken	A token holds an item read from Istream
Ccompound	Abstract base class for complex tokens
CCompound	A templated class for holding compound tokens
Ctolerances	Selector class for solution tolerances
CTomiyamaLiftForce	Tomiyama particle lift force model applicable to deformable bubbles
CtopoAction	A virtual base class for topological actions
CtopoBitSet	Base for a special purpose topoSet using labels stored as a bitSet
CtopoBoolSet	Base for a special purpose topoSet using labels stored as a boolList
CtopoCellLooper	Implementation of cellLooper. This one recognizes splitHexes and tries to make a cut such that if the neighbour was split (in a previous iteration) this one also gets split in the same direction so that the result will be a mesh without splitHexes
CtopoChangerFvMesh	Abstract base class for a topology changing fvMesh
CtopoDistanceData	For use with FaceCellWave. Determines topological distance to starting faces. Templated on passive transported data
CTopologicalMeshObject
CtopoSet	General set of labels of mesh quantity (points, cells, faces)
CtopoSetCellSource	The topoSetCellSource is a intermediate class for handling topoSet sources for selecting cells
CtopoSetCellZoneSource	The topoSetCellZoneSource is a intermediate class for handling topoSet sources for selecting cell zones
CtopoSetFaceSource	The topoSetFaceSource is a intermediate class for handling topoSet sources for selecting faces
CtopoSetFaceZoneSource	The topoSetFaceZoneSource is a intermediate class for handling topoSet sources for selecting face zones
CtopoSetPointSource	The topoSetPointSource is a intermediate class for handling topoSet sources for selecting points
CtopoSetPointZoneSource	The topoSetPointZoneSource is a intermediate class for handling topoSet sources for selecting point zones
►CtopoSetSource	Base class of a source for a topoSet
CaddToUsageTable	Class with constructor to add usage string to table
CiNew	Class used for the read-construction of
CtotalFlowRateAdvectiveDiffusiveFvPatchScalarField	This BC is used for species inlets. The diffusion and advection fluxes are considered to calculate the inlet value for the species The massFluxFraction sets the fraction of the flux of each particular species
CtotalPressureFvPatchScalarField	This boundary condition provides a total pressure condition. Four variants are possible:
CtotalTemperatureFvPatchScalarField	This boundary condition provides a total temperature condition
►CtrackedParticle	Particle class that marks cells it passes through. Used to mark cells visited by feature edges
CiNew	Factory class to read-construct particles used for
CtrackingData	Class used to pass tracking data to the trackToFace function
CtractionDisplacementCorrectionFvPatchVectorField
CtractionDisplacementFvPatchVectorField	Fixed traction boundary condition for the standard linear elastic, fixed coefficient displacement equation
CTrajectoryCollision	Trajectory collision model by N. Nordin, based on O'Rourke's collision model
CtransformBox	Defines control points based on given lower and upper boundaries for the box and additional translation, rotation and scaling vectors. The latter can be copied over from the Paraview clip or transform filters, to facilitate the definition of a more general box
CtransformFaPatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CtransformFvPatchField	Foam::transformFvPatchField
CtransformOp	Transform operation
CtranslatingWallVelocityFvPatchVectorField	This boundary condition provides a velocity condition for translational motion on walls
►CtransportData	Holds information (coordinate and distance). Walks out 0.5*distance
CtrackData	Class used to pass additional data in
CtransportModel	Base-class for all transport models used by the incompressible turbulence models
CTrapezoid	Trapezoidal ODE solver of order (1)2
CtreeBoundBox	Standard boundBox with extra functionality for use in octree
►CtreeDataCell	Encapsulation of data needed to search in/for cells. Used to find the cell containing a point (e.g. cell-cell mapping)
CfindIntersectOp
CfindNearestOp
►CtreeDataEdge	Holds data for octree to work on an edges subset
CfindIntersectOp
CfindNearestOp
►CtreeDataFace	Encapsulation of data needed to search for faces
CfindIntersectOp
CfindNearestOp
►CtreeDataPoint	Holds (reference to) pointField. Encapsulation of data needed for octree searches. Used for searching for nearest point. No bounding boxes around points. Only overlaps and calcNearest are implemented, rest makes little sense
CfindIntersectOp
CfindNearestOp
►CtreeDataPrimitivePatch	Encapsulation of data needed to search on PrimitivePatches
CfindAllIntersectOp
CfindIntersectOp
CfindNearestOp
CfindSelfIntersectOp
Ctriad	Representation of a 3D Cartesian coordinate system as a Vector of row vectors
►Ctriangle	A triangle primitive used to calculate face normals and swept volumes
CdummyOp	Dummy
CstoreOp	Store resulting tris
CsumAreaOp	Sum resulting areas
Ctriangle2D	2-D triangle and queries
CtriangleFuncs	Contains various triangle static functions
►CtriFace	A triangular face using a FixedList of labels corresponding to mesh vertices
CHash	Deprecated(2021-04) hashing functor. Use hasher()
Chasher	Hashing functor for triFace (commutative)
CtrimModel	Base class for trim models for handling blade characteristics and thrust-torque relations
CtriPoints	Triangle storage. Null constructable (unfortunately triangle<point, point> is not)
CtriSurface	Triangulated surface description with patch information
CtriSurfaceGeoMesh	The triSurface GeoMesh (for holding face fields)
CtriSurfaceLoader	Convenience class for loading single or multiple surface files from the constant/triSurface (or other) directory
CtriSurfaceMesh	IOoject and searching on triSurface
CtriSurfaceMeshFeatures
CtriSurfaceMeshPointSet	A sampleSet from all points of a triSurfaceMesh
CtriSurfacePointGeoMesh
CtriSurfaceRegionSearch	Helper class to search on triSurface. Creates an octree for each region of the surface and only searches on the specified regions
CtriSurfaceSearch	Helper class to search on triSurface
CtriSurfaceTools	A collection of tools for triSurface
CTroeFallOffFunction	The Troe fall-off function
CTuple2	A 2-tuple for storing two objects of dissimilar types. The container is similar in purpose to std::pair, but does not expose its members directly
CturbGen	Generate a turbulent velocity field conforming to a given energy spectrum and being divergence free
CTurbulenceModel	Templated abstract base class for turbulence models
CturbulenceModel	Abstract base class for turbulence models (RAS, LES and laminar)
CturbulentDFSEMInletFvPatchVectorField	The turbulentDFSEMInlet is a synthesised-eddy based velocity inlet boundary condition to generate synthetic turbulence-alike time-series from a given set of turbulence statistics for LES and hybrid RANS-LES computations
CturbulentDigitalFilterInletFvPatchField	Digital-filter based boundary condition for vector- and scalar-based quantities (e.g. U or T) to generate synthetic turbulence-alike time-series from input turbulence statistics for LES and DES turbulent flow computations
CturbulentDispersionModel
CturbulentInletFvPatchField	This boundary condition produces spatiotemporal-variant field by summing a set of pseudo-random numbers and a given spatiotemporal-invariant mean field. The field can be any type, e.g. scalarField. At a single point and time, all components are summed by the same random number, e.g. velocity components (u, v, w) are summed by the same random number, p; thus, output is (u+p, v+p, w+p)
CturbulentIntensityKineticEnergyInletFvPatchScalarField	This boundary condition provides a turbulent kinetic energy condition, based on user-supplied turbulence intensity, defined as a fraction of the mean velocity:
CturbulentMixingLengthDissipationRateInletFvPatchScalarField	This boundary condition provides an inlet condition for turbulent kinetic energy dissipation rate, i.e. epsilon, based on a specified mixing length. The patch values are calculated using:
CturbulentMixingLengthFrequencyInletFvPatchScalarField	This boundary condition provides a turbulence specific dissipation, \(\omega\) (omega) inlet condition based on a specified mixing length. The patch values are calculated using:
CtwoDPointCorrector	Class applies a two-dimensional correction to mesh motion point field
CtwoPhaseMixture	A two-phase mixture model
CtwoPhaseMixtureEThermo
CtwoPhaseMixtureThermo
CtwoPhaseSystem	Class which solves the volume fraction equations for two phases
CTwoResistanceHeatTransferPhaseSystem	Class which models interfacial heat transfer between a number of phases. Two heat transfer models are stored at each interface, one for each phase. This permits definition of an interface temperature with which heat transfer occurs. It also allows derived systems to define other thermodynamic properties at the interface and therefore represent phase changes
CtypeOfInnerProduct
CtypeOfInnerProduct< Cmpt, CompactSpatialTensor< Cmpt >, CompactSpatialTensorT< Cmpt > >
CtypeOfInnerProduct< Cmpt, CompactSpatialTensor< Cmpt >, Tensor< Cmpt > >
CtypeOfInnerProduct< Cmpt, CompactSpatialTensor< Cmpt >, Vector< Cmpt > >
CtypeOfInnerProduct< Cmpt, CompactSpatialTensorT< Cmpt >, CompactSpatialTensor< Cmpt > >
CtypeOfInnerProduct< Cmpt, CompactSpatialTensorT< Cmpt >, SpatialVector< Cmpt > >
CtypeOfInnerProduct< Cmpt, SpatialTensor< Cmpt >, CompactSpatialTensor< Cmpt > >
CtypeOfInnerProduct< Cmpt, SpatialTensor< Cmpt >, SpatialTensor< Cmpt > >
CtypeOfInnerProduct< Cmpt, SpatialTensor< Cmpt >, SpatialVector< Cmpt > >
CtypeOfInnerProduct< Type, RectangularMatrix< Type >, RectangularMatrix< Type > >
CtypeOfInnerProduct< Type, RectangularMatrix< Type >, SquareMatrix< Type > >
CtypeOfInnerProduct< Type, SquareMatrix< Type >, RectangularMatrix< Type > >
CtypeOfInnerProduct< Type, SquareMatrix< Type >, SquareMatrix< Type > >
CtypeOfMag	The magnitude type for given argument
CtypeOfOuterProduct
CtypeOfOuterProduct< Cmpt, SpatialVector< Cmpt >, SpatialVector< Cmpt > >
CtypeOfRank
CtypeOfRank< Cmpt, 0 >
CtypeOfRank< Cmpt, 1 >
CtypeOfRank< Cmpt, 2 >
CtypeOfSolve	The extended precision type (solveScalar for float)
CtypeOfSolve< scalar >	Type to use for extended precision
CtypeOfSolve< SphericalTensor< Cmpt > >
CtypeOfSolve< SymmTensor< Cmpt > >
CtypeOfSolve< Tensor< Cmpt > >
CtypeOfSolve< Vector< Cmpt > >
CtypeOfSum
CtypeOfSum< SphericalTensor2D< Cmpt >, SymmTensor2D< Cmpt > >
CtypeOfSum< SphericalTensor2D< Cmpt >, Tensor2D< Cmpt > >
CtypeOfSum< SphericalTensor< Cmpt >, SymmTensor< Cmpt > >
CtypeOfSum< SphericalTensor< Cmpt >, Tensor< Cmpt > >
CtypeOfSum< SymmTensor2D< Cmpt >, SphericalTensor2D< Cmpt > >
CtypeOfSum< SymmTensor< Cmpt >, SphericalTensor< Cmpt > >
CtypeOfSum< SymmTensor< Cmpt >, Tensor< Cmpt > >
CtypeOfSum< Tensor2D< Cmpt >, SphericalTensor2D< Cmpt > >
CtypeOfSum< Tensor< Cmpt >, SphericalTensor< Cmpt > >
CtypeOfSum< Tensor< Cmpt >, SymmTensor< Cmpt > >
CtypeOfTranspose	Abstract template class to provide the transpose form of a form
CtypeOfTranspose< Cmpt, BarycentricTensor< Cmpt > >
CtypeOfTranspose< Cmpt, CompactSpatialTensor< Cmpt > >
CtypeOfTranspose< Cmpt, CompactSpatialTensorT< Cmpt > >
CtypeOfTranspose< Cmpt, RowVector< Cmpt > >
CtypeOfTranspose< Cmpt, SpatialTensor< Cmpt > >
CtypeOfTranspose< Cmpt, Tensor< Cmpt > >
CtypeOfTranspose< Cmpt, Vector< Cmpt > >
CtypeOp	Extract type (as a word) from an object, typically using its type() method
CUDictionary	Template dictionary class which does not manages the storage associated with it
CUIListStream	Similar to IStringStream but using an externally managed buffer for its input. This allows the input buffer to be filled (and refilled) from various sources
Cuiliststream	Similar to std::istringstream, but with an externally managed input buffer
►CUILList	Template class for intrusive linked lists
Cconst_iterator	A const_iterator
Cconst_reverse_iterator
Citerator	A non-const iterator
Creverse_iterator
CUIndirectList	A List with indirect addressing. Like IndirectList but does not store addressing
CUIPBstream
CUIPstream
CUIPstreamBase	Base class for input inter-processor communications stream (ie, parallel streams). Not to be used directly, thus contructors are protected
►CUList	A 1D vector of objects of type <T>, where the size of the vector is known and can be used for subscript bounds checking, etc
Cgreater	A list compare binary predicate for reverse sort
CHash	Deprecated(2021-04) hashing functor. Use hasher()
Chasher	Hashing functor for UList
Cless	A list compare binary predicate for normal sort
CUMISTLimiter	Class with limiter function which returns the limiter for the UMIST differencing scheme
CuncoupledSixDoFRigidBodyDisplacementPointPatchVectorField	Foam::uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField
CundoableMeshCutter	The main refinement handler. Gets cellCuts which is structure that describes which cells are to be cut and in what way. Maintains an undo list (if told so during construction). Apart from undo list is just wrapper around meshCutter
Cuniform
CuniformDensityHydrostaticPressureFvPatchScalarField	This boundary condition provides a hydrostatic pressure condition, calculated as:
CuniformDiffusivity	Uniform uniform finite volume mesh motion diffusivity
CUniformDimensionedField	Dimensioned<Type> registered with the database as a registered IOobject which has the functionality of a uniform field and allows values from the top-level code to be passed to boundary conditions etc
CuniformDistance
CUniformField	A class representing the concept of a uniform field which stores only the single value and providing the operator[] to return it
CuniformFixedGradientFvPatchField	This boundary condition provides a uniform fixed gradient condition
CuniformFixedValueFvPatchField	This boundary condition provides a uniform fixed value condition
CuniformFixedValuePointPatchField	Enables the specification of a uniform fixed value boundary condition
CuniformGrid	Generate a uniform grid of points inside the surfaces to be conformed to of the conformalVoronoiMesh
CuniformInletOutletFvPatchField	Variant of inletOutlet boundary condition with uniform inletValue
CuniformInterpolatedDisplacementPointPatchVectorField	Interpolates pre-specified motion
CuniformInterpolationTable	Table with uniform interval in independent variable, with linear interpolation
CuniformJumpAMIFvPatchField	This boundary condition provides a jump condition, using the cyclicAMI condition as a base. The jump is specified as a time-varying uniform value across the patch
CuniformJumpFvPatchField	This boundary condition provides a jump condition, using the cyclic condition as a base. The jump is specified as a time-varying uniform value across the patch
CUniformList	A single value that is represented as a list with an operator[] to access the value. This can be useful for templated operations expecting a list accessor
CuniformNormalFixedValueFvPatchVectorField	This boundary condition provides a uniform surface-normal vector boundary condition by its magnitude
CuniformSet	A sampler type which provides a uniform distribution of nPoints sample locations along a straight line specified between a given start and an end points
CuniformTotalPressureFvPatchScalarField	This boundary condition provides a time-varying form of the uniform total pressure boundary condition Foam::totalPressureFvPatchField
CuniformValue
CunmappedPassivePositionParticleCloud	PassivePositionParticleCloud but with autoMap and writing disabled. Only used for its objectRegistry to store lagrangian fields
CUnsortedMeshedSurface	A surface geometry mesh, in which the surface zone information is conveyed by the 'zoneId' associated with each face
CunwatchedIOdictionary	UnwatchedIOdictionary is like IOdictionary but stores dependencies as files instead of fileMonitor watchIndices. Used to read controlDict since there fileMonitor not yet setup
CUOListStream	An OSstream attached to an unallocated external buffer
CUOPBstream
CUOprocess	Random UO process
CUOPstream
CUOPstreamBase	Base class for output inter-processor communications stream (ie, parallel streams). Not to be used directly, thus contructors are protected
CUpdateableMeshObject
CupdateMethod	Abstract base class for optimisation methods
CupdateOp	Update operation
►CUPstream	Inter-processor communications stream
CcommsStruct	Structure for communicating between processors
Ccommunicator	Helper class for allocating/freeing communicators
ClistEq	CombineReduce operator for lists. Used for counting
CUPtrDictionary	Template dictionary class which does not manages the storage associated with it
►CUPtrList	A list of pointers to objects of type <T>, without allocation/deallocation management of the pointers - this is to be done elsewhere. The operator[] returns a reference to the object, not the pointer
Cconst_iterator	Random-access iterator with const access
Cgreater	A UPtrList compare binary predicate for reverse sort order
Citerator	Random-access iterator with non-const access
Cless
Cvalue_compare
Cupwind	Upwind differencing scheme class
CupwindCECCellToFaceStencilObject
CupwindCFCCellToFaceStencilObject
CupwindCPCCellToFaceStencilObject
CupwindEdgeInterpolation	Upwind differencing scheme class
CupwindFECCellToFaceStencilObject
CUpwindFitData	Data for the quadratic fit correction interpolation scheme to be used with upwind biased stencil
CUpwindFitScheme	Upwind biased fit surface interpolation scheme that applies an explicit correction to linear
CvaluePointPatchField	Foam::valuePointPatchField
CvanAlbadaLimiter	Class with limiter function which returns the limiter for the vanAlbada differencing scheme based on r obtained from the LimiterFunc class
CvanLeerLimiter	Class with limiter function which returns the limiter for the vanLeer differencing scheme based on r obtained from the LimiterFunc class
CVariableHardSphere	Variable Hard Sphere BinaryCollision Model
CvariableHeightFlowRateFvPatchScalarField	This boundary condition provides a phase fraction condition based on the local flow conditions, whereby the values are constrained to lay between user-specified upper and lower bounds. The behaviour is described by:
CvariableHeightFlowRateInletVelocityFvPatchVectorField	This boundary condition provides a velocity boundary condition for multphase flow based on a user-specified volumetric flow rate
CvariablesSet	Base class for creating a set of variables
CVector	Templated 3D Vector derived from VectorSpace adding construction from 3 components, element access using x(), y() and z() member functions and the inner-product (dot-product) and cross product operators
CVector2D	Templated 2D Vector derived from VectorSpace adding construction from 2 components, element access using x() and y() member functions and the inner-product (dot-product)
CvectorLessOp
►CVectorSpace	Templated vector space
CConstBlock	Const sub-block type
CVectorSpaceOps	General looping form. Executing at index <I> with termination at <N>
CVectorSpaceOps< N, N >	Loop termination form, when index and loop count <N> are identical
CvectorTensorTransform	Vector-tensor class used to perform translations and rotations in 3D space
CvelocityComponentLaplacianFvMotionSolver	Mesh motion solver for an fvMesh. Based on solving the cell-centre Laplacian for the given component of the motion velocity
CvelocityDisplacementMotionSolver	Mesh motion solver for a polyMesh. Wraps a displacement motion solver in a velocity motion solver
CvelocityFilmShellFvPatchVectorField
CvelocityLaplacianFvMotionSolver	Mesh motion solver for an fvMesh. Based on solving the cell-centre Laplacian for the motion velocity
CvelocityMotionSolver	Virtual base class for velocity motion solver
CveryInhomogeneousMixture	The very inhomogeneous mixture contains species ("ft", "fu", "b")
CvibrationShellFvPatchScalarField
CVirtualMassForce	Calculates particle virtual mass force
CvirtualMassModel
CviscosityModel	An abstract base class for incompressible viscosityModels
CVoidFraction	Creates particle void fraction field on carrier phase
CvolBSplinesBase	Class constructing a number of volumetric B-Splines boxes, read from dynamicMeshDict. Useful for various sensitivities and optMeshMovement classes
CvolMesh	Mesh data needed to do the Finite Volume discretisation
CvolPointInterpolation	Interpolate from cell centres to points (vertices) using inverse distance weighting
CvolSurfaceMapping	Volume to surface and surface to volume mapping
CvolumeCombineOp	Combine operator for volume types
CvolumetricBSplinesMotionSolver	A mesh motion solver based on volumetric B-Splines
CvolumeType	An enumeration wrapper for classification of a location as being inside/outside of a volume
CvoxelMeshSearch	Fast, non-parallel searching in mesh without use of octree
CvtkPTraits	Names for VTK primitive types
CvtkUnstructuredReader	Reader for vtk UNSTRUCTURED_GRID legacy files. Supports single CELLS, POINTS etc. entry only
CwalkPatch	Collection of static functions to do various simple patch related things
►CwallBoundedParticle	Particle class that tracks on triangles of boundary faces. Use trackToEdge similar to trackToFace on particle
CiNew	Factory class to read-construct particles used for
CtrackingData	Class used to pass tracking data to the trackToFace function
►CwallBoundedStreamLineParticle	Particle class that samples fields as it passes through. Used in streamline calculation
CiNew	Factory class to read-construct particles used for
CtrackingData	Class used to pass tracking data to the trackToEdge function
CwallBoundedStreamLineParticleCloud	A Cloud of streamLine particles
CWallCollisionRecord	Record of a collision between the particle holding the record and a wall face at the position relative to the centre of the particle
CwallDampingModel
CwallDependentModel	A class which provides on-demand creation and caching of wall distance and wall normal fields for use by multiple models
CwallDist	Interface to run-time selectable methods to calculate the distance-to-wall and normal-to-wall fields
CwallDistData	Wall distance calculation. Like wallDist but also transports extra data (template argument)
CwallFunctionBlenders	The class wallFunctionBlenders is a base class that hosts common entries for various derived wall-function boundary conditions to be used in low- and high-Reynolds number applications
CwallFunctionCoefficients	Class to host the wall-function coefficients being used in the wall function boundary conditions
CwallFvPatch	Foam::wallFvPatch
CwallHeatTransferFvPatchScalarField	This boundary condition provides an enthalpy condition for wall heat transfer
CWallInteractionModel	Templated wall interaction model class
CwallLayerCells	After construction is a list of <refineCell> of cells within a certain distance to the wall and with the wall normal direction
CWallLocalSpringSliderDashpot	Forces between particles and walls, interacting with a spring, slider, damper model
CwallLubricationModel
CWallModel	Templated wall interaction class
CwallNormalInfo	Holds information regarding nearest wall point. Used in wall refinement
CwallPoint	Holds information regarding nearest wall point. Used in wall distance calculation
CwallPointData	Holds information (coordinate and normal) regarding nearest wall point
CwallPointPatch	Foam::wallPointPatch
►CwallPoints	For use with FaceCellWave. Determines topological distance to starting faces
CtrackData	Class used to pass additional data in
CwallPointYPlus	Holds information (coordinate and yStar) regarding nearest wall point
CwallPolyPatch	Foam::wallPolyPatch
CWallSiteData	Stores the patch ID and templated data to represent a collision with a wall to be passed to the wall model
CWallSpringSliderDashpot	Forces between particles and walls, interacting with a spring, slider, damper model
CwaveAlphaFvPatchScalarField	Example of the boundary condition specification:
CwaveDisplacementPointPatchVectorField	Foam::waveDisplacementPointPatchVectorField
CwaveMakerPointPatchVectorField	Point motion boundary condition to generate waves based on either piston or flap motions
CwaveMethod	Direct (one-to-one cell correspondence) mesh-to-mesh interpolation class
CwaveModel	Base class for waveModels
CwaveSurfacePressureFvPatchScalarField	This is a pressure boundary condition, whose value is calculated as the hydrostatic pressure based on a given displacement:
CwaveTransmissiveFvPatchField	This boundary condition provides a wave transmissive outflow condition, based on solving DDt(W, field) = 0 at the boundary W is the wave velocity and field is the field to which this boundary condition is applied
CwaveVelocityFvPatchVectorField	Example of the boundary condition specification:
CwaWallFunctionFvPatchScalarField
CWeberNumberReacting	Creates particle Weber number field on the cloud
CwedgeFaePatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CwedgeFaPatch	Wedge front and back plane patch
CwedgeFaPatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CwedgeFvPatch	Wedge front and back plane patch
CwedgeFvPatchField	This boundary condition is similar to the cyclic condition, except that it is applied to 2-D geometries
CwedgeFvsPatchField	Foam::wedgeFvsPatchField
CwedgeMatcher	A cellMatcher for wedge cells (cellModel::WEDGE)
CwedgePointPatch	Wedge front and back plane patch
CwedgePointPatchField	Wedge front and back plane patch field
CwedgePolyPatch	Wedge front and back plane patch
Cweighted	Interpolation scheme class using weights looked-up from the objectRegistry
CweightedFlux	Weighted flux interpolation scheme class
CweightedPosition	Wrapper for position + weight to be used in e.g. averaging
CWenYuDragForce	Particle-drag model wherein drag forces (per unit carrier-fluid velocity) are dynamically computed based on the Wen-Yu drag model
CwindowModel	Base class for windowing models
CWLFTransport	Transport package using the Williams-Landel-Ferry model
Cword	A class for handling words, derived from Foam::string
CwordRe	A wordRe is a Foam::word, but can contain a regular expression for matching words or strings
►CwordRes	A List of wordRe with additional matching capabilities
Cfilter	Functor wrapper of allow/deny lists of wordRe for filtering
Cmatcher	Functor wrapper of a list of wordRe for matching
CworldConnectBitOrEq
CwriteFreeSurface	A function object to write the control points on the free surface
CXiEqModel	Base-class for all XiEq models used by the b-XiEq combustion model. The available models are : basicXiSubXiEq.H Gulder.H instabilityXiEq.H SCOPEBlendXiEq.H SCOPEXiEq.H
CXiGModel	Base-class for all Xi generation models used by the b-Xi combustion model. See Technical Report SH/RE/01R for details on the PDR modelling. For details on the use of XiGModel see XiModel.H. The model available is instabilityG.H
CXiModel	Base-class for all Xi models used by the b-Xi combustion model. See Technical Report SH/RE/01R for details on the PDR modelling
CxorEqOp
CxorEqOp2
CxorOp
CxorOp2
►Czero	A class representing the concept of 0 (zero) that can be used to avoid manipulating objects known to be zero at compile-time. It is also used for tagged dispatch
Cnull	A zero class with a null output adapter
CzeroATCcells	Base class for selecting cells on which to zero the ATC term
CzeroField	A class representing the concept of a field of 0 used to avoid unnecessary manipulations for objects which are known to be zero at compile-time
CzeroFieldField	A class representing the concept of a field of zeroFields used to avoid unnecessary manipulations for objects which are known to be zero at compile-time
CzeroFixedValuePointPatchField	Enables the specification of a zero fixed value boundary condition
CzeroGradientFaPatchField	Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd
CzeroGradientFvPatchField	This boundary condition applies a zero-gradient condition from the patch internal field onto the patch faces
CzeroGradientPointPatchField	Foam::zeroGradientPointPatchField
CzoltanRenumber	Renumber using Zoltan
Czone	Base class for mesh zones
CzoneCPCStencil	Computes a cell point cell stencil in a narrow band. resizes in case of topological change
CzoneDistribute	Class for parallel communication in a narrow band. It either provides a Map with the neighbouring values of the selected region or returns a Map of the required values in global addressing. Also holds a reference to the stencil Before the data transfer the communication has to be set up: exchangeFields_.setUpCommforZone(interfaceCell_); Is used in the plicRDF
CzoneIdentifier	Identifies a mesh zone by name and index, with optional physical type and group information
CZoneMesh	A list of mesh zones
CzoneMotion	Intermediate class for handling "zonified" motion. Can select motion for the entire mesh, or restrict to a subset of points based on a specified cellSet or cellZone(s)
CzoneToCell	A topoSetCellSource to convert cellZone(s) to a cellSet
CzoneToFace	A topoSetFaceSource to convert faceZone(s) to a faceSet
CzoneToPoint	A topoSetPointSource to convert pointZone(s) to a pointSet
NstdFoam