All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages

Class List

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

[detail level 12345]

CGAL | |

indexedCellOps | |

indexedVertexOps | |

indexedCell | |

Rebind_TDS | |

indexedVertex | |

Rebind_TDS | |

indexedFace | |

Rebind_TDS | |

Foam | Namespace for OpenFOAM |

combustionModels | |

diffusion | 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 |

FSD | Flame Surface Dennsity (FDS) combustion model |

infinitelyFastChemistry | 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 |

laminar | Laminar combustion model |

noCombustion | Dummy combustion model for 'no combustion' |

PaSR | Partially stirred reactor combustion model. The model calculates a finite rate, based on both turbulence and chemistry time scales. Depending on mesh resolution, the Cmix parameter can be used to scale the turbulence mixing time scale |

psiChemistryCombustion | |

psiCombustionModel | |

psiThermoCombustion | |

rhoChemistryCombustion | |

rhoCombustionModel | |

rhoThermoCombustion | |

singleStepCombustion | Base class for combustion models using singleStepReactingMixture |

reactionRateFlameAreaModels | |

relaxation | Consumption rate per unit of flame area obtained from a relaxation equation |

consumptionSpeed | Correlation function for laminar consumption speed obtained from flamelet solution at increasing strain rates |

meshReaders | A namespace for holding various types of mesh readers |

STARCD | Read pro-STAR vrt/cel/bnd files. The protected data in meshReader are filled |

meshWriters | A namespace for holding various types of mesh writers |

STARCD | Writes polyMesh in pro-STAR (v4) bnd/cel/vrt format |

solidBodyMotionFunctions | Namespace for solid-body motions |

axisRotationMotion | Constant velocity rotation around CoG. Similar to rotatingMotion but motion specified as rotation vector |

linearMotion | SolidBodyMotionFvMesh 6DoF motion function. Constant velocity displacement |

multiMotion | Combination of SolidBodyMotionFvMesh 6DoF motion functions |

oscillatingLinearMotion | SolidBodyMotionFvMesh 6DoF motion function. Oscillating displacement |

oscillatingRotatingMotion | SolidBodyMotionFvMesh 6DoF motion function. Oscillating rotation |

rotatingMotion | SolidBodyMotionFvMesh 6DoF motion function |

SDA | Ship design analysis (SDA) 3DoF motion function |

tabulated6DoFMotion | Tabulated 6DoF motion function |

fileFormats | |

edgeMeshFormat | Provide a means of reading/writing the single-file OpenFOAM edge format |

edgeMeshFormatsCore | A collection of helper functions for reading/writing edge formats |

extendedFeatureEdgeMeshFormat | Provide a means of reading extendedFeatureEdgeMesh as featureEdgeMesh |

NASedgeFormat | Nastran edge reader |

OBJedgeFormat | Provide a means of reading/writing Alias/Wavefront OBJ format |

STARCDedgeFormat | Read/write the lines from pro-STAR vrt/cel files |

VTKedgeFormat | Provide a means of writing VTK legacy format |

extendedEdgeMeshFormat | Provide a means of reading/writing the single-file OpenFOAM extendedEdgeMesh format |

NASCore | Core routines used when reading/writing NASTRAN files |

STARCDCore | Core routines used when reading/writing pro-STAR vrt/cel/bnd files |

AC3DsurfaceFormat | Provide a means of reading/writing AC3D format |

AC3DsurfaceFormatCore | Internal class used by the AC3DsurfaceFormat |

FTRsurfaceFormat | Reading of the (now deprecated and infrequently used) Foam Trisurface Format |

GTSsurfaceFormat | Provide a means of reading/writing GTS format. The output is never sorted by zone and is only written if it consists entirely of triangles |

NASsurfaceFormat | Nastran surface reader |

OBJsurfaceFormat | Provide a means of reading/writing Alias/Wavefront OBJ format |

OFFsurfaceFormat | Provide a means of reading/writing Geomview OFF polyList format |

OFSsurfaceFormat | Provide a means of reading/writing the single-file OpenFOAM surface format |

OFSsurfaceFormatCore | Internal class used by the OFSsurfaceFormat |

SMESHsurfaceFormat | Provide a means of writing tetgen SMESH format |

STARCDsurfaceFormat | Read/write the surface shells from pro-STAR vrt/cel files |

STARCDsurfaceFormatCore | Internal class used by the STARCDsurfaceFormat |

STLsurfaceFormat | Provide a means of reading/writing STL files (ASCII and binary) |

STLsurfaceFormatCore | Internal class used by the STLsurfaceFormat |

surfaceFormatsCore | A collection of helper functions for reading/writing surface formats |

TRIsurfaceFormat | Provide a means of reading/writing .tri format |

TRIsurfaceFormatCore | Internal class used by the TRIsurfaceFormat |

VTKsurfaceFormat | Provide a means of reading/writing VTK legacy format. The output is never sorted by zone |

VTKsurfaceFormatCore | Internal class used by the VTKsurfaceFormat |

WRLsurfaceFormat | Provide a means of writing VRML97 (wrl) format |

WRLsurfaceFormatCore | Internal class used by the WRLsurfaceFormat |

X3DsurfaceFormat | Provide a means of writing x3d format |

X3DsurfaceFormatCore | Internal class used by the X3DsurfaceFormat |

porosityModels | |

DarcyForchheimer | |

fixedCoeff | |

powerLaw | |

SRF | Namespace for single rotating frame (SRF) models |

rpm | Basic SRF model whereby angular velocity is specified in terms of a (global) axis and revolutions-per-minute [rpm] |

SRFModel | Top level model for single rotating frame |

fv | Namespace for finite-volume |

boundedConvectionScheme | Bounded form of the selected convection scheme |

convectionScheme | Abstract base class for convection schemes |

gaussConvectionScheme | Basic second-order convection using face-gradients and Gauss' theorem |

multivariateGaussConvectionScheme | Basic second-order convection using face-gradients and Gauss' theorem |

d2dt2Scheme | Abstract base class for d2dt2 schemes |

EulerD2dt2Scheme | First-order Euler implicit d2dt2 using the current and two previous time-step values |

steadyStateD2dt2Scheme | SteadyState d2dt2 which returns 0 |

backwardDdtScheme | Second-order backward-differencing ddt using the current and two previous time-step values |

boundedDdtScheme | Bounded form of the selected ddt scheme |

CoEulerDdtScheme | Courant number limited first-order Euler implicit/explicit ddt |

CrankNicolsonDdtScheme | Second-oder CrankNicolson implicit ddt using the current and previous time-step fields as well as the previous time-step ddt |

ddtScheme | Abstract base class for ddt schemes |

EulerDdtScheme | Basic first-order Euler implicit/explicit ddt using only the current and previous time-step values |

localEulerDdtScheme | Local time-step first-order Euler implicit/explicit ddt. The reciprocal of the local time-step field is looked-up from the database with the name provided |

SLTSDdtScheme | Stabilised local time-step first-order Euler implicit/explicit ddt. The time-step is adjusted locally so that an advective equations remains diagonally dominant |

steadyStateDdtScheme | SteadyState implicit/explicit ddt which returns 0 |

divScheme | Abstract base class for div schemes |

gaussDivScheme | Basic second-order div using face-gradients and Gauss' theorem |

fourthGrad | Second-order gradient scheme using least-squares |

gaussGrad | Basic second-order gradient scheme using face-interpolation and Gauss' theorem |

gradScheme | Abstract base class for gradient schemes |

LeastSquaresGrad | 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: |

LeastSquaresVectors | Least-squares gradient scheme vectors |

leastSquaresGrad | Second-order gradient scheme using least-squares |

cellLimitedGrad | CellLimitedGrad gradient scheme applied to a runTime selected base gradient scheme |

cellMDLimitedGrad | CellMDLimitedGrad gradient scheme applied to a runTime selected base gradient scheme |

faceLimitedGrad | FaceLimitedGrad gradient scheme applied to a runTime selected base gradient scheme |

faceMDLimitedGrad | FaceMDLimitedGrad gradient scheme applied to a runTime selected base gradient scheme |

gaussLaplacianScheme | Basic second-order laplacian using face-gradients and Gauss' theorem |

laplacianScheme | Abstract base class for laplacian schemes |

CentredFitSnGradScheme | |

correctedSnGrad | Simple central-difference snGrad scheme with non-orthogonal correction |

faceCorrectedSnGrad | Simple central-difference snGrad scheme with non-orthogonal correction |

limitedSnGrad | Run-time selected snGrad scheme with limited non-orthogonal correction |

orthogonalSnGrad | Simple central-difference snGrad scheme without non-orthogonal correction |

snGradScheme | Abstract base class for snGrad schemes |

uncorrectedSnGrad | Simple central-difference snGrad scheme without non-orthogonal correction |

fixedTemperatureConstraint | Fixed temperature equation constraint |

temperatureLimitsConstraint | Constraint for temperature to apply limits between minimum and maximum values |

ExplicitSetValue | |

IOoptionList | IOoptionList |

option | Finite volume options abtract base class. Provides a base set of controls, e.g |

iNew | Return pointer to new fvOption object created |

optionList | List of finite volume options |

actuationDiskSource | Actuation disk source |

effectivenessHeatExchangerSource | Heat exchanger source model, in which the heat exchanger is defined as a selection of cells |

explicitPorositySource | Explicit porosity source |

MRFSource | Multiple Reference Frame (MRF) source |

pressureGradientExplicitSource | Creates a pressure gradient source |

radialActuationDiskSource | Actuation disk source including radial thrust |

rotorDiskSource | Cell based momemtum source |

flapData | |

CodedSource | |

SemiImplicitSource | Semi-implicit source, described using an input dictionary. The injection rate coefficients are specified as pairs of Su-Sp coefficients, i.e |

interRegionExplicitPorositySource | Inter-region explicit porosity source |

constantHeatTransfer | Constant heat transfer model. htcConst [W/m2/K] and area/volume [1/m] must be provided |

interRegionHeatTransferModel | Base class for inter region heat exchange. The derived classes must provide the heat transfer coeffisine (htc) which is used as follows in the energy equation |

tabulatedHeatTransfer | Tabulated heat transfer model. The heat exchange area per unit volume must be provided. The 2D table returns the heat transfer coefficient by querying the local and neighbour region velocities |

variableHeatTransfer | Variable heat transfer model depending on local values. The area of contact between regions (area) must be provided. The Nu number is calculated as: |

explicitSetValue | Set values field values explicity |

codedSource | Constructs on-the-fly fvOption source |

fvc | Namespace of functions to calculate explicit derivatives |

fvm | Namespace of functions to calculate implicit derivatives returning a matrix |

MULES | |

limitFuncs | Namespace for limiting functions |

null | |

magSqr | |

rhoMagSqr | |

LimitFuncs | Class to create NVD/TVD limited weighting-factors |

distributionModels | |

distributionModel | |

exponential | |

fixedValue | |

general | |

multiNormal | |

normal | |

RosinRammler | |

uniform | |

radiation | Namespace for radiation modelling |

cloudAbsorptionEmission | Retrieves absorption/emission data from a cloud object |

cloudScatter | Cloud radiation scatter model |

greyDiffusiveRadiationMixedFvPatchScalarField | 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 |

greyDiffusiveViewFactorFixedValueFvPatchScalarField | This boundary condition provides a grey-diffuse condition for radiative heat flux, `Qr` , for use with the view factor model |

wideBandDiffusiveRadiationMixedFvPatchScalarField | This boundary condition provides a wide-band, diffusive radiation condition, where the patch temperature is specified |

absorptionCoeffs | |

blackBodyEmission | Class black body emission |

fvDOM | Finite Volume Discrete Ordinates Method. Solves the RTE equation for n directions in a participating media, not including scatter |

radiativeIntensityRay | Radiation intensity for a ray in a given direction |

noRadiation | No radiation - does nothing to energy equation source terms (returns zeros) |

opaqueSolid | Radiation for solid opaque solids - does nothing to energy equation source terms (returns zeros) but creates absorptionEmissionModel and scatterModel |

P1 | Works well for combustion applications where optical thickness, tau is large, i.e. tau = a*L > 3 (L = distance between objects) |

radiationModel | Top level model for radiation modelling |

viewFactor | 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 |

absorptionEmissionModel | Model to supply absorption and emission coefficients for radiation modelling |

binaryAbsorptionEmission | Radiation coefficient based on two absorption models |

constantAbsorptionEmission | Constant radiation absorption and emission coefficients for continuous phase |

greyMeanAbsorptionEmission | GreyMeanAbsorptionEmission radiation absorption and emission coefficients for continuous phase |

greyMeanSolidAbsorptionEmission | GreyMeanSolidAbsorptionEmission radiation absorption and emission coefficients for continuous phase |

noAbsorptionEmission | Dummy absorption-emission model for 'none' |

wideBandAbsorptionEmission | WideBandAbsorptionEmission radiation absorption and emission coefficients for continuous phase |

constantScatter | Constant radiation scatter coefficient |

noScatter | Dummy scatter model for 'none' |

scatterModel | Base class for radiation scattering |

mixtureFractionSoot | This soot model is purely an state model. The ammount of soot produced is determined by a single step chemistry as : |

noSoot | NoSoot |

sootModel | Base class for soor models |

regionModels | |

surfaceFilmModels | |

kinematicSingleLayer | |

noFilm | |

filmSubModelBase | |

constantFilmThermo | |

thermoData | |

filmThermoModel | |

liquidFilmThermo | |

filmTurbulenceModel | Base class for film turbulence models |

laminar | Film laminar turbulence model |

contactAngleForce | |

force | Base class for film (stress-based) force models |

forceList | |

thermocapillaryForce | |

curvatureSeparation | |

drippingInjection | |

injectionModel | Base class for film injection models, handling mass transfer from the film |

injectionModelList | |

removeInjection | |

constantRadiation | |

filmRadiationModel | |

noRadiation | |

primaryRadiation | |

standardRadiation | |

constantViscosity | |

filmViscosityModel | |

liquidViscosity | |

thixotropicViscosity | |

constantHeatTransfer | |

heatTransferModel | |

mappedConvectiveHeatTransfer | |

noPhaseChange | |

phaseChangeModel | |

solidification | |

standardPhaseChange | |

surfaceFilmModel | Base class for surface film models |

thermoSingleLayer | |

pyrolysisModels | |

noPyrolysis | |

pyrolysisModel | Base class for pyrolysis models |

pyrolysisModelCollection | |

reactingOneDim | |

thermalBaffleModels | |

noThermo | |

thermalBaffle | |

thermalBaffleModel | |

regionModel | |

regionModel1D | |

regionModelFunctionObject | |

regionModelFunctionObjectList | |

singleLayerRegion | |

AveragingMethods | |

Basic | Basic lagrangian averaging procedure |

Dual | Dual-mesh lagrangian averaging procedure |

Moment | Moment lagrangian averaging procedure |

CorrectionLimitingMethods | |

absolute | Correction limiting method based on the absolute particle velocity |

noCorrectionLimiting | |

relative | Correction limiting method based on the relative particle velocity |

DampingModels | |

NoDamping | |

Relaxation | Relaxation collisional damping model |

IsotropyModels | |

NoIsotropy | |

Stochastic | Stochastic return-to-isotropy model |

PackingModels | |

Explicit | Explicit model for applying an inter-particle stress to the particles |

Implicit | Implicit model for applying an inter-particle stress to the particles |

NoPacking | |

ParticleStressModels | |

exponential | Exponential inter-particle stress model of the same form as used in twoPhaseEulerFoam |

HarrisCrighton | Inter-particle stress model of Harris and Crighton |

Lun | Inter-particle stress model of Lun et al |

TimeScaleModels | |

equilibrium | Equlibrium model for the time scale over which properties of a dispersed phase tend towards the mean value |

isotropic | Model for the time scale over which the velocity field of a dispersed phase tends towards an isotropic distribution |

nonEquilibrium | Non-Equlibrium model for the time scale over which properties of a dispersed phase tend towards the mean value |

energyScalingFunctions | |

doubleSigmoid | |

noScaling | |

shifted | |

shiftedForce | |

sigmoid | |

pairPotentials | |

azizChen | Foam::pairPotentials::azizChen |

coulomb | |

dampedCoulomb | |

exponentialRepulsion | |

lennardJones | |

maitlandSmith | Foam::pairPotentials::maitlandSmith |

noInteraction | |

electrostaticPotential | |

tetherPotentials | |

harmonicSpring | |

pitchForkRing | |

restrainedHarmonicSpring | |

extrudeModels | |

linearDirection | Extrudes by transforming points in a specified direction by a given distance |

linearNormal | Extrudes by transforming points normal to the surface by a given distance |

linearRadial | |

radial | |

sigmaRadial | |

wedge | Extrudes by rotating a surface around an axis |

meshTools | Collection of static functions to do various simple mesh related things |

ListListOps | Various utility functions to work on Lists of Lists (usually resulting from 'gather'ing and combining information from individual processors) |

functionEntries | Namespace for containing a functionEntry |

calcEntry | Uses dynamic compilation to provide calculating functionality for entering dictionary entries |

codeStream | Dictionary entry that contains C++ OpenFOAM code that is compiled to generate the entry itself. So |

includeEntry | Specify an include file when reading dictionaries, expects a single string to follow |

includeIfPresentEntry | Specify a file to include if it exists. Expects a single string to follow |

inputModeEntry | Specify the input mode when reading dictionaries, expects a single word to follow |

removeEntry | Remove a dictionary entry |

constant | Collection of constants |

atomic | Atomic constants |

electromagnetic | Electromagnetic constants |

universal | Universal constants |

physicoChemical | Physico-chemical constants |

standard | |

mathematical | Mathematical constants |

debug | Namespace for handling debugging switches |

polyMeshTools | Collection of static functions operating on polyMesh (mainly checks) so that need access to patch information |

primitiveMeshTools | Collection of static functions operating on primitiveMesh (mainly checks) |

stringOps | Collection of static functions to do various simple string-related operations |

POSIX | OS-specific functions implemented in POSIX |

calcTypes | Namespace for post-processing calculation functions |

addSubtract | Adds/subtracts a field or value to/from a base field |

components | Writes scalar fields corresponding to each component of the supplied field (name) for each time |

div | Writes scalar fields corresponding to the divergence of the supplied field (name) for each time |

interpolate | Interpolates volume fields to surface fields for each time |

mag | Calculates and writes the magnitude of a field for each time |

magGrad | Writes scalar fields corresponding to the magnitude ot the gradient of the supplied field (name) for each time |

magSqr | Calculates and writes the magnitude-sqaured of a field for each time |

randomise | Adds a random component to a field, with a given perturbation magnitude |

fieldValues | |

cellSource | This function object provides a 'cell source' variant of the fieldValues function object. Given a list of user-specified fields and a selection of mesh cells, a number of operations can be performed, such as sums, averages and integrations |

faceSource | This function object provides a 'face source' variant of the fieldValues function object. Given a list of user-specified fields and a selection of mesh (or general surface) faces, a number of operations can be performed, such as sums, averages and integrations |

fieldValueDelta | This function object provides a differencing option between two 'field value' function objects |

PstreamGlobals | Global functions and variables for working with parallel streams, but principally for gamma/mpi |

Foam | |

compressible | |

RASModels | Namespace for compressible RAS turbulence models |

alphatFilmWallFunctionFvPatchScalarField | 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 |

mutkFilmWallFunctionFvPatchScalarField | This boundary condition provides a turbulent viscosity condition when using wall functions, based on turbulence kinetic energy, for use with surface film models |

fWallFunctionFvPatchScalarField | This boundary condition provides a turbulence damping function, f, wall function condition for low- and high Reynolds number, turbulent flow cases |

v2WallFunctionFvPatchScalarField | This boundary condition provides a turbulence stress normal to streamlines wall function condition for low- and high-Reynolds number, turbulent flow cases |

kEpsilon | Standard k-epsilon turbulence model for compressible flows |

kOmegaSST | Implementation of the k-omega-SST turbulence model for compressible flows |

laminar | Dummy turbulence model for laminar compressible flow |

LaunderGibsonRSTM | Launder-Gibson Reynolds stress turbulence model for compressible flows |

LaunderSharmaKE | Launder and Sharma low-Reynolds k-epsilon turbulence model for compressible and combusting flows |

LRR | Launder, Reece and Rodi Reynolds-stress turbulence model for compressible flows |

realizableKE | Realizable k-epsilon turbulence model for compressible flows |

RNGkEpsilon | Renormalisation group k-epsilon turbulence model for compressible flows |

SpalartAllmaras | Spalart-Allmaras one-eqn mixing-length model for compressible external flows |

v2f | Lien and Kalitzin's v2-f turbulence model for incompressible flows, with a limit imposed on the turbulent viscosity given by Davidson et al |

PDRkEpsilon | Standard k-epsilon turbulence model with additional source terms corresponding to PDR basic drag model (basic.H) |

LESModels | Namespace for compressible LES models |

DeardorffDiffStress | Differential SGS Stress Equation Model for compressible flows |

GenEddyVisc | General base class for all compressible models that can be implemented as an eddy viscosity, i.e. algebraic and one-equation models |

GenSGSStress | General base class for all compressible models that directly solve for the SGS stress tensor B |

homogeneousDynOneEqEddy | One Equation Eddy Viscosity Model for compressible flows |

lowReOneEqEddy | One Equation Eddy Viscosity Model for compressible flow |

oneEqEddy | One Equation Eddy Viscosity Model for compressible flows |

Smagorinsky | The choric Smagorinsky Model for compressible flows |

SpalartAllmaras | SpalartAllmaras for compressible flows |

vanDriestDelta | Simple cube-root of cell volume delta used in compressible LES models |

turbulenceModels | Namespace for compressible turbulence turbulence models |

thermalBaffleFvPatchScalarField | |

LESdelta | Abstract base class for compressible LES deltas |

DESModel | Extension of LES models to provide an interface for Detached Eddy Simulation turbulence models |

LESModel | Base class for all compressible flow LES SGS models |

convectiveHeatTransferFvPatchScalarField | This boundary condition provides a convective heat transfer coefficient condition |

turbulentMixingLengthDissipationRateInletFvPatchScalarField | |

turbulentMixingLengthFrequencyInletFvPatchScalarField | This boundary condition provides a turbulence specific dissipation, (omega) inlet condition based on a specified mixing length. The patch values are calculated using: |

alphatJayatillekeWallFunctionFvPatchScalarField | This boundary condition provides a thermal wall function for turbulent thermal diffusivity (usually`alphat` ) based on the Jayatilleke model |

alphatWallFunctionFvPatchScalarField | This boundary condition provides a turbulent thermal diffusivity conditon when using wall functions |

epsilonLowReWallFunctionFvPatchScalarField | This boundary condition provides a turbulence dissipation wall function condition for low- and high-Reynolds number turbulent flow cases |

epsilonWallFunctionFvPatchScalarField | This boundary condition provides a turbulence dissipation wall function condition for high Reynolds number, turbulent flow cases |

kLowReWallFunctionFvPatchScalarField | This boundary condition provides a turbulence kinetic energy wall function condition for low- and high-Reynolds number turbulent flow cases |

kqRWallFunctionFvPatchField | This boundary condition is applied to turbulence `k` , `q` , and `R` when using wall functions, and simply enforces a zero-gradient condition |

mutkRoughWallFunctionFvPatchScalarField | This boundary condition provides a turbulent viscosity condition when using wall functions for rough walls, based on turbulence kinetic energy. The condition manipulates the E parameter to account for roughness effects |

mutkWallFunctionFvPatchScalarField | This boundary condition provides a turbulent viscosity condition when using wall functions, based on turbulence kinetic energy |

mutLowReWallFunctionFvPatchScalarField | This boundary condition provides a turbulent viscosity condition for use with low Reynolds number models. It sets `nut` to zero, and provides an access function to calculate y+ |

mutURoughWallFunctionFvPatchScalarField | This boundary condition provides a turbulent viscosity condition when using wall functions for rough walls, based on velocity |

mutUSpaldingWallFunctionFvPatchScalarField | This boundary condition provides a turbulent viscosity condition when using wall functions for rough walls, based on velocity, using Spalding's law to give a continuous nut profile to the wall (y+ = 0) |

mutUWallFunctionFvPatchScalarField | This boundary condition provides a turbulent viscosity condition when using wall functions, based on velocity |

mutWallFunctionFvPatchScalarField | This boundary condition provides a turbulent viscosity condition when using wall functions, based on turbulence kinetic energy |

omegaWallFunctionFvPatchScalarField | This boundary condition provides a wall function constraint on turbulnce specific dissipation, omega. The values are computed using: |

RASModel | Abstract base class for turbulence models for compressible and combusting flows |

thermalBaffle1DFvPatchScalarField | |

turbulentHeatFluxTemperatureFvPatchScalarField | |

turbulentTemperatureCoupledBaffleMixedFvPatchScalarField | |

turbulentTemperatureRadCoupledMixedFvPatchScalarField | |

laminar | Turbulence model for laminar compressible flow |

turbulenceModel | Abstract base class for compressible turbulence models (RAS, LES and laminar) |

sixDoFRigidBodyMotionConstraints | Namespace for six DoF motion constraints |

axis | SixDoFRigidBodyMotionConstraint. Body may only rotate around an axis fixed in global space |

line | SixDoFRigidBodyMotionConstraint. Reference point may only move along a line |

orientation | Fix orientation of body in global space |

plane | SixDoFRigidBodyMotionConstraint. Reference point may only move along a plane |

point | Point fixed in space |

sixDoFRigidBodyMotionRestraints | Namespace for six DoF motion restraints |

linearAxialAngularSpring | SixDoFRigidBodyMotionRestraints model. Linear axial angular spring |

linearDamper | SixDoFRigidBodyMotionRestraints model. Linear spring |

linearSpring | SixDoFRigidBodyMotionRestraints model. Linear spring |

sphericalAngularDamper | SixDoFRigidBodyMotionRestraints model. Spherical angular damper |

sphericalAngularSpring | SixDoFRigidBodyMotionRestraints model. Spherical angular spring |

tabulatedAxialAngularSpring | SixDoFRigidBodyMotionRestraints model. Axial angular spring with moment values drawn from an interpolation table. Linear damping |

compressibilityModels | Namespace for compressibility models |

Chung | Chung compressibility model |

linear | Linear compressibility model |

Wallis | Wallis compressibility model |

laminarFlameSpeedModels | Namespace for laminar flame speed models |

constant | Constant laminar flame speed model |

Gulders | Laminar flame speed obtained from Gulder's correlation |

GuldersEGR | Laminar flame speed obtained from Gulder's correlation with EGR modelling |

RaviPetersen | Laminar flame speed obtained from Ravi and Petersen's correlation |

SCOPE | Laminar flame speed obtained from the SCOPE correlation |

species | |

thermo | |

viscosityModels | A namespace for various incompressible viscosityModel implementations |

BirdCarreau | An incompressible Bird-Carreau non-Newtonian viscosity model |

CrossPowerLaw | An incompressible Cross-Power law non-Newtonian viscosity model |

HerschelBulkley | Herschel-Bulkley non-Newtonian viscosity model |

Newtonian | An incompressible Newtonian viscosity model |

powerLaw | Standard power-law non-Newtonian viscosity model |

LESModels | Namespace for LES SGS models |

continuousGasKEqn | One-equation SGS model for the gas-phase in a two-phase system supporting phase-inversion |

NicenoKEqn | One-equation SGS model for the continuous phase in a two-phase system including bubble-generated turbulence |

SmagorinskyZhang | The Smagorinsky SGS model including bubble-generated turbulence |

LESeddyViscosity | Eddy viscosity LES SGS model base class |

kEqn | One Equation Eddy Viscosity Model |

Smagorinsky | The Smagorinsky SGS model |

RASModels | Namespace for RAS turbulence models |

continuousGasKEpsilon | K-epsilon model for the gas-phase in a two-phase system supporting phase-inversion |

LaheyKEpsilon | Continuous-phase k-epsilon model including bubble-generated turbulence |

mixtureKEpsilon | Mixture k-epsilon turbulence model for two-phase gas-liquid systems |

fWallFunctionFvPatchScalarField | This boundary condition provides a turbulence damping function, f, wall function condition for low- and high Reynolds number, turbulent flow cases |

v2WallFunctionFvPatchScalarField | This boundary condition provides a turbulence stress normal to streamlines wall function condition for low- and high-Reynolds number, turbulent flow cases |

kEpsilon | Standard k-epsilon turbulence model |

kineticTheoryModel | |

phasePressureModel | |

incompressible | |

LESModels | Namespace for incompressible LES models |

DeardorffDiffStress | Differential SGS Stress Equation Model for incompressible flows |

dynLagrangian | Dynamic eddy-viscosity model with Lagrangian averaging for incompressible flow |

dynOneEqEddy | Localised Dynamic One Equation Eddy Viscosity Model for incompressible flows |

GenEddyVisc | General base class for all incompressible models that can be implemented as an eddy viscosity, i.e. algebraic and one-equation models |

GenSGSStress | General base class for all incompressible models that directly solve for the SGS stress tensor B |

homogeneousDynOneEqEddy | One Equation Eddy Viscosity Model for incompressible flows |

homogeneousDynSmagorinsky | The Isochoric homogeneous dynamic Smagorinsky Model for incompressible flows |

kOmegaSSTSAS | KOmegaSSTSAS LES turbulence model for incompressible flows based on: |

laminar | LES model for laminar incompressible flow. It simply returns laminar properties |

LRRDiffStress | Differential SGS Stress Equation Model for incompressible flows |

mixedSmagorinsky | The mixed Isochoric Smagorinsky Model for incompressible flows |

oneEqEddy | One Equation Eddy Viscosity Model for incompressible flows |

scaleSimilarity | General base class for all scale similarity models for incompressible flows |

Smagorinsky | The Isochoric Smagorinsky Model for incompressible flows |

Smagorinsky2 | The Isochoric Smagorinsky Model for incompressible flows |

SpalartAllmaras | SpalartAllmaras DES (SA + LES) turbulence model for incompressible flows |

SpalartAllmarasDDES | SpalartAllmaras DDES LES turbulence model for incompressible flows |

SpalartAllmarasIDDES | SpalartAllmarasIDDES LES turbulence model for incompressible flows |

spectEddyVisc | The Isochoric spectral Eddy Viscosity Model for incompressible flows |

vanDriestDelta | Simple cube-root of cell volume delta used in incompressible LES models |

RASModels | Namespace for incompressible RAS turbulence models |

fWallFunctionFvPatchScalarField | This boundary condition provides a turbulence damping function, f, wall function condition for low- and high Reynolds number, turbulent flow cases |

v2WallFunctionFvPatchScalarField | This boundary condition provides a turbulence stress normal to streamlines wall function condition for low- and high-Reynolds number, turbulent flow cases |

kEpsilon | Standard k-epsilon turbulence model for incompressible flows |

kkLOmega | Low Reynolds-number k-kl-omega turbulence model for incompressible flows |

kOmega | Standard high Reynolds-number k-omega turbulence model for incompressible flows |

kOmegaSST | Implementation of the k-omega-SST turbulence model for incompressible flows |

LamBremhorstKE | Lam and Bremhorst low-Reynolds number k-epsilon turbulence model for incompressible flows |

laminar | Dummy turbulence model for laminar incompressible flow |

LaunderGibsonRSTM | Launder-Gibson Reynolds stress turbulence model for incompressible flows |

LaunderSharmaKE | Launder and Sharma low-Reynolds k-epsilon turbulence model for incompressible flows |

LienCubicKE | Lien cubic non-linear k-epsilon turbulence model for incompressible flows |

LienCubicKELowRe | Lien cubic non-linear low-Reynolds k-epsilon turbulence models for incompressible flows |

LienLeschzinerLowRe | Lien and Leschziner low-Reynolds k-epsilon turbulence model for incompressible flows |

LRR | Launder, Reece and Rodi Reynolds-stress turbulence model for incompressible flows |

NonlinearKEShih | Shih's quadratic non-linear k-epsilon turbulence model for incompressible flows |

qZeta | Gibson and Dafa'Alla's q-zeta two-equation low-Re turbulence model for incompressible flows |

realizableKE | Realizable k-epsilon turbulence model for incompressible flows |

RNGkEpsilon | Renormalisation group k-epsilon turbulence model for incompressible flows |

SpalartAllmaras | Spalart-Allmaras 1-eqn mixing-length model for incompressible external flows |

v2f | Lien and Kalitzin's v2-f turbulence model for incompressible flows, with a limit imposed on the turbulent viscosity given by Davidson et al |

turbulenceModels | Namespace for incompressible turbulence turbulence models |

DESModel | Extension of LES models to provide an interface for Detached Eddy Simulation turbulence models |

LESdelta | Abstract base class for incompressible LES deltas |

LESModel | Base class for all incompressible flow LES SGS models |

atmBoundaryLayerInletEpsilonFvPatchScalarField | This boundary condition specifies an inlet value for the turbulence dissipation, (`epsilon` ), appropriate for atmospheric boundary layers (ABL), and designed to be used in conjunction with the `ABLInletVelocity` inlet velocity boundary condition |

turbulentMixingLengthDissipationRateInletFvPatchScalarField | |

turbulentMixingLengthFrequencyInletFvPatchScalarField | This boundary condition provides a turbulence specific dissipation, (omega) inlet condition based on a specified mixing length. The patch values are calculated using: |

alphatJayatillekeWallFunctionFvPatchScalarField | This boundary condition provides a kinematic turbulent thermal conductivity for using wall functions, using the Jayatilleke 'P' function |

epsilonLowReWallFunctionFvPatchScalarField | This boundary condition provides a turbulence dissipation wall function condition for low- and high-Reynolds number turbulent flow cases |

epsilonWallFunctionFvPatchScalarField | This boundary condition provides a turbulence dissipation wall function condition for high Reynolds number, turbulent flow cases |

kLowReWallFunctionFvPatchScalarField | This boundary condition provides a turbulence kinetic energy wall function condition for low- and high-Reynolds number turbulent flow cases |

kqRWallFunctionFvPatchField | This boundary condition provides a suitable condition for turbulence `k` , `q` , and `R` fields for the case of high Reynolds number flow using wall functions |

nutkAtmRoughWallFunctionFvPatchScalarField | This boundary condition provides a turbulent kinematic viscosity for atmospheric velocity profiles. It is desinged to be used in conjunction with the atmBoundaryLayerInletVelocity boundary condition. The values are calculated using: |

nutkRoughWallFunctionFvPatchScalarField | This boundary condition provides a turbulent kinematic viscosity condition when using wall functions for rough walls, based on turbulence kinetic energy. The condition manipulates the E parameter to account for roughness effects |

nutkWallFunctionFvPatchScalarField | This boundary condition provides a turbulent kinematic viscosity condition when using wall functions, based on turbulence kinetic energy |

nutLowReWallFunctionFvPatchScalarField | This boundary condition provides a turbulent kinematic viscosity condition for use with low Reynolds number models. It sets `nut` to zero, and provides an access function to calculate y+ |

nutURoughWallFunctionFvPatchScalarField | This boundary condition provides a turbulent kinematic viscosity condition when using wall functions for rough walls, based on velocity |

nutUSpaldingWallFunctionFvPatchScalarField | This boundary condition provides a turbulent kinematic viscosity condition when using wall functions for rough walls, based on velocity, using Spalding's law to give a continuous nut profile to the wall (y+ = 0) |

nutUTabulatedWallFunctionFvPatchScalarField | This boundary condition provides a turbulent kinematic viscosity condition when using wall functions. As input, the user specifies a look-up table of U+ as a function of near-wall Reynolds number. The table should be located in the $FOAM_CASE/constant directory |

nutUWallFunctionFvPatchScalarField | This boundary condition provides a turbulent kinematic viscosity condition when using wall functions, based on velocity |

nutWallFunctionFvPatchScalarField | This boundary condition provides a turbulent kinematic viscosity condition when using wall functions, based on turbulence kinetic energy |

omegaWallFunctionFvPatchScalarField | This boundary condition provides a wall function constraint on turbulnce specific dissipation, omega. The values are computed using: |

RASModel | Abstract base class for incompressible turbulence models |

atmBoundaryLayerInletVelocityFvPatchVectorField | This boundary condition specifies a velocity inlet profile appropriate for atmospheric boundary layers (ABL). The profile is derived from the friction velocity, flow direction and the direction of the parabolic co-ordinate `z` |

turbulentHeatFluxTemperatureFvPatchScalarField | Fixed heat boundary condition to specify temperature gradient. Input heat source either specified in terms of an absolute power [W], or as a flux [W/m2] |

laminar | Turbulence model for laminar incompressible flow |

turbulenceModel | Abstract base class for incompressible turbulence models (RAS, LES and laminar) |

foamyHexMeshChecks | |

DelaunayMeshTools | |

vectorTools | Collection of functions for testing relationships between two vectors |

faceSelections | |

faceZoneSelection | Deselect cells not reachable from 'inside' points |

searchableSurfaceSelection | Selects all (internal or coupled) faces intersecting the searchableSurface |

helpTypes | |

helpBoundary | |

helpFunctionObject | |

vtkPV3Readers | A collection of helper functions when building a reader interface in ParaView3 |

partInfo | Bookkeeping for GUI checklists and the multi-block organization |

vtkPV4Readers | A collection of helper functions when building a reader interface in ParaView3 |

partInfo | Bookkeeping for GUI checklists and the multi-block organization |

tabulatedWallFunctions | |

general | Computes U+ as a function of Reynolds number by inverting table of y+ vs U+ |

SpaldingsLaw | Computes U+ as a function of Reynolds number by inverting Spaldings law |

tabulatedWallFunction | Base class for models that generate tabulated wall function data |

PDRDragModels | |

basic | Basic sub-grid obstacle drag model. Details supplied by J Puttock 2/7/06 |

XiEqModels | |

basicSubGrid | Basic sub-grid obstacle flame-wrinking enhancement factor model. Details supplied by J Puttock 2/7/06 |

Gulder | Simple Gulder model for XiEq based on Gulders correlation with a linear correction function to give a plausible profile for XiEq |

instability | 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 |

SCOPEBlend | 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 |

SCOPEXiEq | 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 |

XiGModels | |

basicSubGrid | Basic sub-grid obstacle flame-wrinking generation rate coefficient model. Details supplied by J Puttock 2/7/06 |

instabilityG | Flame-surface instabilityG flame-wrinking generation rate coefficient model used in XiModel.H |

KTS | Simple Kolmogorov time-scale (KTS) model for the flame-wrinling generation rate |

XiModels | |

algebraic | 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 |

fixed | Fixed value model for Xi. See XiModel.H for more details on flame wrinkling modelling |

transport | 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 |

phaseChangeTwoPhaseMixtures | |

Kunz | 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 |

Merkle | Merkle cavitation model |

SchnerrSauer | SchnerrSauer cavitation model |

dragModels | |

blended | Blends two drag models based on the phase fractions to handle phase-inversion |

Ergun | 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 |

Gibilaro | 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 |

GidaspowErgunWenYu | D. Gidaspow, Multiphase flow and fluidization, Academic Press, New York, 1994 |

GidaspowSchillerNaumann | 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 |

interface | Drag between phase separated by a VoF resolved interface |

SchillerNaumann | |

SyamlalOBrien | Syamlal, M., Rogers, W. and O'Brien, T. J. (1993) MFIX documentation, Theory Guide. Technical Note DOE/METC-94/1004. Morgantown, West Virginia, USA |

WenYu | 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 |

noDrag | |

segregated | Segregated drag model for use in regions with no obvious dispersed phase |

TomiyamaAnalytic | Analytic drag model of Tomiyama et al |

TomiyamaCorrelated | Correlation of Tomiyama et al |

heatTransferModels | |

RanzMarshall | |

noHeatTransfer | |

diameterModels | |

IATEsources | |

dummy | |

randomCoalescence | Random coalescence IATE source as defined in paper: |

turbulentBreakUp | Turbulence-induced break-up IATE source as defined in paper: |

wakeEntrainmentCoalescence | Bubble coalescence due to wake entrainment IATE source as defined in paper: |

constant | Constant dispersed-phase particle diameter model |

isothermal | Isothermal dispersed-phase particle diameter model |

IATE | IATE (Interfacial Area Transport Equation) bubble diameter model |

IATEsource | IATE (Interfacial Area Transport Equation) bubble diameter model run-time selectable sources |

iNew | Class used for the read-construction of |

aspectRatioModels | |

constantAspectRatio | |

VakhrushevEfremov | |

liftModels | |

constantLiftCoefficient | Constant coefficient lift model |

noLift | |

TomiyamaLift | Lift model of Tomiyama et al |

swarmCorrections | |

noSwarm | |

TomiyamaSwarm | |

turbulentDispersionModels | |

constantTurbulentDispersionCoefficient | Constant coefficient turbulent dispersion model |

Gosman | Turbulent dispersion model of Gosman et al |

noTurbulentDispersion | |

virtualMassModels | |

constantVirtualMassCoefficient | Constant coefficient virtual mass model |

Lamb | Virtual mass model of Lamb |

noVirtualMass | |

wallLubricationModels | |

Antal | Wall lubrication model of Antal et al |

noWallLubrication | |

kineticTheoryModels | |

conductivityModels | |

Gidaspow | |

HrenyaSinclair | |

Syamlal | |

frictionalStressModels | |

JohnsonJackson | |

Schaeffer | |

granularPressureModels | |

Lun | |

SyamlalRogersOBrien | |

radialModels | |

CarnahanStarling | |

LunSavage | |

SinclairJackson | |

viscosityModels | |

Gidaspow | |

HrenyaSinclair | |

Syamlal | |

conductivityModel | |

frictionalStressModel | |

granularPressureModel | |

radialModel | |

noneViscosity | |

viscosityModel | |

blendingMethods | |

hyperbolic | |

linear | |

noBlending | |

combustionModel | Base class for combustion models |

consumptionSpeed | |

reactionRateFlameArea | Abstract class for reaction rate per flame area unit |

ensightFile | Ensight output with specialized write() for strings, integers and floats. Correctly handles binary write as well |

ensightGeoFile | Specialized Ensight output with extra geometry file header |

ensightPart | Base class for ensightPartCells and ensightPartFaces |

localPoints | Track the points used by the part and map global to local indices |

ensightPartCells | An implementation of ensightPart to hold volume mesh cells |

ensightPartFaces | An implementation of ensightPart to hold volume mesh faces |

ensightParts | A collection of several ensightPart elements |

meshReader | This class supports creating polyMeshes with baffles |

cellFaceIdentifier | Identify cell faces in terms of cell Id and face Id |

boundaryRegion | The boundaryRegion persistent data saved as a Map<dictionary> |

cellTable | The cellTable persistent data saved as a Map<dictionary> |

meshWriter | Write OpenFOAM meshes and/or results to another CFD format |

polyDualMesh | Creates dual of polyMesh |

dynamicFvMesh | Abstract base class for geometry and/or topology changing fvMesh |

dynamicInkJetFvMesh | Mesh motion specifically for the "pumping" system of an ink-jet injector |

dynamicMotionSolverFvMesh | The dynamicMotionSolverFvMesh |

dynamicRefineFvMesh | A fvMesh with built-in refinement |

multiSolidBodyMotionFvMesh | Solid-body motion of the mesh specified by a run-time selectable motion function |

solidBodyMotionDisplacementPointPatchVectorField | Enables the specification of a fixed value boundary condition using the solid body motion functions |

solidBodyMotionFunction | Base class for defining solid-body motions |

solidBodyMotionFvMesh | Solid-body motion of the mesh specified by a run-time selectable motion function |

staticFvMesh | Foam::staticFvMesh |

attachDetach | 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 |

boundaryMesh | Addressing for all faces on surface of mesh. Can either be read from polyMesh or from triSurface. Used for repatching existing meshes |

boundaryPatch | Like polyPatch but without reference to mesh. patchIdentifier::index is not used. Used in boundaryMesh to hold data on patches |

minEqOp< labelPair > | |

createShellMesh | Creates mesh by extruding a patch |

extrudePatchMesh | |

fvMeshAdder | Adds two fvMeshes without using any polyMesh morphing. Uses fvMeshAdder |

fvMeshDistribute | Sends/receives parts of mesh+fvfields to neighbouring processors. Used in load balancing |

fvMeshTools | A collection of tools for operating on an fvMesh |

layerAdditionRemoval | Cell layer addition mesh modifier |

cellCuts | Description of cuts across cells |

cellLooper | Abstract base class. Concrete implementations know how to cut a cell (i.e. determine a loop around the circumference) |

geomCellLooper | Implementation of cellLooper. Does pure geometric cut through cell |

hexCellLooper | Implementation of cellLooper |

topoCellLooper | 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 |

directionInfo | Holds direction in which to split cell (in fact a local coordinate axes). Information is a label and a direction |

directions | Set of directions for each cell in the mesh. Either uniform and size=1 or one set of directions per cell |

edgeVertex | Combines edge or vertex in single label. Used to specify cuts across cell circumference |

boundaryCutter | Does modifications to boundary faces |

meshCutAndRemove | Like meshCutter but also removes non-anchor side of cell |

meshCutter | Cuts (splits) cells |

multiDirRefinement | Does multiple pass refinement to refine cells in multiple directions |

refinementIterator | Utility class to do iterating meshCutter until all requests satisfied |

undoableMeshCutter | 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 |

refineCell | Container with cells to refine. Refinement given as single direction |

splitCell | Description of cell after splitting. Contains cellLabel and pointers to cells it it split in. See directedRefinement |

wallLayerCells | After construction is a list of <refineCell> of cells within a certain distance to the wall and with the wall normal direction |

wallNormalInfo | Holds information regarding nearest wall point. Used in wall refinement |

badQualityToCell | Selects bad quality cells (using snappyHexMesh/cvMesh mesh quality selector) |

badQualityToFace | Selects bad quality faces (using snappyHexMesh/cvMesh mesh quality selector) |

motionSmoother | Given a displacement moves the mesh by scaling the displacement back until there are no more mesh errors |

motionSmootherAlgo | Given a displacement moves the mesh by scaling the displacement back until there are no more mesh errors |

motionSmootherData | |

polyMeshGeometry | Updateable mesh geometry and checking routines |

componentDisplacementMotionSolver | Virtual base class for displacement motion solver |

componentVelocityMotionSolver | Virtual base class for velocity motion solver |

displacementMotionSolver | Virtual base class for displacement motion solver |

motionSolver | Virtual base class for mesh motion solver |

velocityMotionSolver | Virtual base class for velocity motion solver |

perfectInterface | Hack of attachDetach to couple patches when they perfectly align. Does not decouple. Used by stitchMesh app. Does geometric matching |

faceCoupleInfo | Container for information needed to couple to meshes. When constructed from two meshes and a geometric tolerance finds the corresponding boundary faces |

polyMeshAdder | Adds two meshes without using any polyMesh morphing |

polyMeshFilter | Remove the edges and faces of a polyMesh whilst satisfying the given mesh quality criteria |

polyMeshFilterSettings | Class to store the settings for the polyMeshFilter class |

attachPolyTopoChanger | 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 |

polyMeshModifier | Virtual base class for mesh modifiers |

polyAddCell | Class containing data for cell addition |

polyAddFace | 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 |

polyAddPoint | Class containing data for point addition |

addPatchCellLayer | Adds layers of cells to outside of polyPatch. Can optionally create stand-alone extruded mesh (addToMesh=false) |

combineFaces | Combines boundary faces into single face. The faces get the patch of the first face ('the master') |

duplicatePoints | Duplicate points |

edgeCollapser | 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 |

faceCollapser | Collapses faces into edges. Used to remove sliver faces (faces with small area but non-zero span) |

ifEqEqOp | Reduction class. If x and y are not equal assign value |

hexRef8 | Refinement of (split) hexes using polyTopoChange |

polyModifyCell | Class describing modification of a cell |

polyModifyFace | Class describing modification of a face |

polyModifyPoint | Class describing modification of a point |

pointEdgeCollapse | Determines length of string of edges walked to point |

CompactListList | A packed storage unstructured matrix of objects of type <T> using an offset table for access |

polyTopoChange | Direct mesh changes based on v1.3 polyTopoChange syntax |

refinementData | Transfers refinement levels such that slow transition between levels is maintained. Used in FaceCellWave |

refinementDistanceData | Transfers refinement levels such that slow transition between levels is maintained. Used in FaceCellWave |

refinementHistory | All refinement history. Used in unrefinement |

splitCell8 | |

removeCells | Given list of cells to remove insert all the topology changes |

removeFaces | Given list of faces to remove insert all the topology changes. Contains helper function to get consistent set of faces to remove |

polyRemoveCell | Class containing data for cell removal |

polyRemoveFace | Class containing data for face removal |

polyRemovePoint | Class containing data for point removal |

faceEqOp | Combine-reduce operator to combine data on faces. Takes care |

removePoints | Removes selected points from mesh and updates faces using these points |

tetDecomposer | |

topoAction | A virtual base class for topological actions |

polyTopoChanger | List of mesh modifiers defining the mesh dynamics |

repatchPolyTopoChanger | 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 |

setUpdater | Keeps cell/face/vertex sets uptodate. Both the ones loaded and the ones on disk |

enrichedPatch | The enriched patch contains a double set of faces from the two sides of the sliding interface before the cutting |

slidingInterface | Sliding interface mesh modifier. Given two face zones, couple the master and slave side using a cutting procedure |

edgeMesh | Points connected by edges |

extendedEdgeMesh | Description of feature edges and points |

extendedFeatureEdgeMesh | ExtendedEdgeMesh + IO |

featureEdgeMesh | EdgeMesh + IO |

engineMesh | Foam::engineMesh |

fvMotionSolverEngineMesh | Foam::fvMotionSolverEngineMesh |

layeredEngineMesh | Foam::layeredEngineMesh |

staticEngineMesh | Foam::staticEngineMesh |

enginePiston | Foam::enginePiston |

engineTime | Manage time in terms of engine RPM and crank-angle |

engineValve | Foam::engineValve |

valveBank | A list of valves |

ignition | Foam::ignition |

ignitionSite | Foam::ignitionSite |

iNew | Class used for the read-construction of |

coordSet | Holds list of sampling positions |

csvSetWriter | Write set in csv format |

ensightSetWriter | |

gnuplotSetWriter | |

jplotSetWriter | |

rawSetWriter | |

vtkSetWriter | |

writer | Base class for graphics format writing. Entry points are |

xmgraceSetWriter | |

vtkUnstructuredReader | Reader for vtk unstructured_grid legacy files. Supports single CELLS, POINTS etc. entry only |

IOMRFZoneList | List of MRF zones with IO functionality. MRF zones are specified by a list of dictionary entries, e.g |

MRFZone | MRF zone definition based on cell zone and parameters obtained from a control dictionary constructed from the given stream |

MRFZoneList | List container for MRF zomes |

IOporosityModelList | List of porosity models with IO functionality |

porosityModel | Top level model for porosity models |

iNew | Return pointer to new porosityModel object created on the freestore |

porosityModelList | List container for porosity models |

pimpleControl | PIMPLE control class to supply convergence information/checks for the PIMPLE loop |

simpleControl | SIMPLE control class to supply convergence information/checks for the SIMPLE loop |

solutionControl | Base class for solution control classes |

fieldData | |

SRFFreestreamVelocityFvPatchVectorField | |

SRFVelocityFvPatchVectorField | Freestream velocity condition to be used in conjunction with the single rotating frame (SRF) model (see: SRFModel class) |

basicSymmetryFvPatchField | A symmetry patch |

calculatedFvPatchField | 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` |

coupledFvPatchField | Abstract base class for coupled patches |

directionMixedFvPatchField | Base class for direction-mixed boundary conditions |

fixedGradientFvPatchField | This boundary condition supplies a fixed gradient condition, such that the patch values are calculated using: |

fixedValueFvPatchField | This boundary condition supplies a fixed value constraint, and is the base class for a number of other boundary conditions |

mixedFvPatchField | This boundary condition provides a base class for 'mixed' type boundary conditions, i.e. conditions that mix fixed value and patch-normal gradient conditions |

slicedFvPatchField | Specialization of fvPatchField which creates the underlying fvPatchField as a slice of the given complete field |

transformFvPatchField | Foam::transformFvPatchField |

zeroGradientFvPatchField | This boundary condition applies a zero-gradient condition from the patch internal field onto the patch faces |

cyclicFvPatchField | This boundary condition enforces a cyclic condition between a pair of boundaries |

cyclicACMIFvPatchField | 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 |

cyclicAMIFvPatchField | 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 |

cyclicSlipFvPatchField | This boundary condition is a light wrapper around the cyclicFvPatchField condition, providing no new functionality |

emptyFvPatchField | 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 |

jumpCyclicFvPatchField | This boundary condition provides a base class for coupled-cyclic conditions with a specified 'jump' (or offset) between the values |

jumpCyclicAMIFvPatchField | 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 |

nonuniformTransformCyclicFvPatchField | This boundary condition enforces a cyclic condition between a pair of boundaries, incorporating a non-uniform transformation |

processorFvPatchField | This boundary condition enables processor communication across patches |

processorCyclicFvPatchField | This boundary condition enables processor communication across cyclic patches |

symmetryFvPatchField | This boundary condition enforces a symmetry constraint |

symmetryPlaneFvPatchField | This boundary condition enforces a symmetryPlane constraint |

wedgeFvPatchField | This boundary condition is similar to the cyclic condition, except that it is applied to 2-D geometries |

activeBaffleVelocityFvPatchVectorField | 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 |

activePressureForceBaffleVelocityFvPatchVectorField | This boundary condition is applied to the flow velocity, to simulate the opening of a baffle due to local flow conditions, by merging the behaviours of wall and cyclic conditions |

advectiveFvPatchField | This boundary condition provides an advective outflow condition, based on solving DDt(psi, U) = 0 at the boundary |

codedFixedValueFvPatchField | Constructs on-the-fly a new boundary condition (derived from fixedValueFvPatchField) which is then used to evaluate |

codedMixedFvPatchField | Constructs on-the-fly a new boundary condition (derived from mixedFvPatchField) which is then used to evaluate |

cylindricalInletVelocityFvPatchVectorField | This boundary condition describes an inlet vector boundary condition in cylindrical co-ordinates given a central axis, central point, rpm, axial and radial velocity |

externalCoupledMixedFvPatchField | This boundary condition provides an interface to an external application. Values are transferred as plain text files, where OpenFOAM data is written as: |

fanFvPatchField | This boundary condition provides a jump condition, using the `cyclic` condition as a base |

fanPressureFvPatchScalarField | This boundary condition can be applied to assign either a pressure inlet or outlet total pressure condition for a fan |

fixedFluxPressureFvPatchScalarField | 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 |

fixedInternalValueFvPatchField | 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 |

fixedJumpFvPatchField | This boundary condition provides a jump condition, using the `cyclic` condition as a base |

fixedJumpAMIFvPatchField | This boundary condition provides a jump condition, across non-conformal cyclic path-pairs, employing an arbitraryMeshInterface (AMI) |

fixedMeanFvPatchField | This boundary condition extrapolates field to the patch using the near-cell values and adjusts the distribution to match the specified mean value |

fixedNormalSlipFvPatchField | This boundary condition sets the patch-normal component to a fixed value |

fixedPressureCompressibleDensityFvPatchScalarField | This boundary condition calculates a (liquid) compressible density as a function of pressure and fluid properties: |

flowRateInletVelocityFvPatchVectorField | This boundary condition provides a velocity boundary condition, derived from the flux (volumetric or mass-based), whose direction is assumed to be normal to the patch |

fluxCorrectedVelocityFvPatchVectorField | 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: |

freestreamFvPatchField | 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 |

freestreamPressureFvPatchScalarField | This boundary condition provides a free-stream condition for pressure. It is a zero-gradient condition that constrains the flux across the patch based on the free-stream velocity |

inletOutletFvPatchField | This boundary condition provides a generic outflow condition, with specified inflow for the case of return flow |

inletOutletTotalTemperatureFvPatchScalarField | 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 |

interstitialInletVelocityFvPatchVectorField | Inlet velocity in which the actual interstitial velocity is calculated by dividing the specified inletVelocity field with the local phase-fraction |

mappedFieldFvPatchField | This boundary condition provides a self-contained version of the `mapped` condition. It does not use information on the patch; instead it holds thr data locally |

interpolation | Abstract base class for interpolation |

mappedPatchFieldBase | Functionality for sampling fields using mappedPatchBase. Every call to mappedField() returns a sampled field, optionally scaled to maintain an area-weighted average |

mappedFixedInternalValueFvPatchField | This boundary condition maps the boundary and internal values of a neighbour patch field to the boundary and internal values of *this |

mappedFixedPushedInternalValueFvPatchField | This boundary condition maps the boundary values of a neighbour patch field to the boundary and internal cell values of *this |

mappedFixedValueFvPatchField | This boundary condition maps the value at a set of cells or patch faces back to *this |

mappedFlowRateFvPatchVectorField | Describes a volumetric/mass flow normal vector boundary condition by its magnitude as an integral over its area |

mappedVelocityFluxFixedValueFvPatchField | This boundary condition maps the velocity and flux from a neighbour patch to this patch |

movingWallVelocityFvPatchVectorField | This boundary condition provides a velocity condition for cases with moving walls. In addition, it should also be applied to 'moving' walls for moving reference frame (MRF) calculations |

oscillatingFixedValueFvPatchField | This boundary condition provides an oscillating condition in terms of amplitude and frequency |

outletInletFvPatchField | This boundary condition provides a generic inflow condition, with specified outflow for the case of return flow |

outletMappedUniformInletFvPatchField | This boundary conditon averages the field over the "outlet" patch specified by name "outletPatchName" and applies this as the uniform value of the field over this patch |

outletPhaseMeanVelocityFvPatchVectorField | 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 |

partialSlipFvPatchField | This boundary condition provides a partial slip condition. The amount of slip is controlled by a user-supplied field |

phaseHydrostaticPressureFvPatchScalarField | This boundary condition provides a phase-based hydrostatic pressure condition, calculated as: |

pressureDirectedInletOutletVelocityFvPatchVectorField | This velocity inlet/outlet boundary condition is applied to pressure boundaries where the pressure is specified. A zero-gradient condtion is applied for outflow (as defined by the flux); for inflow, the velocity is obtained from the flux with the specified inlet direction |

pressureDirectedInletVelocityFvPatchVectorField | 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 |

pressureInletOutletParSlipVelocityFvPatchVectorField | 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 |

pressureInletOutletVelocityFvPatchVectorField | This velocity inlet/outlet boundary condition is applied to pressure 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 and the tangential patch velocity can be optionally specified |

pressureInletUniformVelocityFvPatchVectorField | 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 |

pressureInletVelocityFvPatchVectorField | 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 |

pressureNormalInletOutletVelocityFvPatchVectorField | 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 |

prghPressureFvPatchScalarField | This boundary condition provides static pressure condition for p_rgh, calculated as: |

rotatingPressureInletOutletVelocityFvPatchVectorField | 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 |

rotatingTotalPressureFvPatchScalarField | This boundary condition provides a total pressure condition for patches in a rotating frame |

rotatingWallVelocityFvPatchVectorField | This boundary condition provides a rotational velocity condition |

slipFvPatchField | This boundary condition provides a slip constraint |

supersonicFreestreamFvPatchVectorField | This boundary condition provides a supersonic free-stream condition |

surfaceNormalFixedValueFvPatchVectorField | This boundary condition provides a surface-normal vector boundary condition by its magnitude |

swirlFlowRateInletVelocityFvPatchVectorField | 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) |

syringePressureFvPatchScalarField | This boundary condition provides a pressure condition, obtained from a zero-D model of the cylinder of a syringe |

AverageIOField | A primitive field + average with IO |

timeVaryingMappedFixedValueFvPatchField | This boundary conditions interpolates the values from a set of supplied points in space and time. Supplied data should be specified in constant/boundaryData/<patchname> where: |

totalPressureFvPatchScalarField | This boundary condition provides a total pressure condition. Four variants are possible: |

totalTemperatureFvPatchScalarField | This boundary condition provides a total temperature condition |

translatingWallVelocityFvPatchVectorField | This boundary condition provides a velocity condition for translational motion on walls |

turbulentInletFvPatchField | This boundary condition generates a fluctuating inlet condition by adding a random component to a reference (mean) field |

turbulentIntensityKineticEnergyInletFvPatchScalarField | This boundary condition provides a turbulent kinetic energy condition, based on user-supplied turbulence intensity, defined as a fraction of the mean velocity: |

uniformDensityHydrostaticPressureFvPatchScalarField | This boundary condition provides a hydrostatic pressure condition, calculated as: |

uniformFixedGradientFvPatchField | This boundary condition provides a uniform fixed gradient condition |

uniformFixedValueFvPatchField | This boundary condition provides a uniform fixed value condition |

uniformInletOutletFvPatchField | Variant of inletOutlet boundary condition with uniform inletValue |

uniformJumpFvPatchField | 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 |

uniformJumpAMIFvPatchField | 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 |

uniformTotalPressureFvPatchScalarField | This boundary condition provides a time-varying form of the uniform total pressure boundary condition |

variableHeightFlowRateFvPatchScalarField | 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: |

variableHeightFlowRateInletVelocityFvPatchVectorField | This boundary condition provides a velocity boundary condition for multphase flow based on a user-specified volumetric flow rate |

waveSurfacePressureFvPatchScalarField | This is a pressure boundary condition, whose value is calculated as the hydrostatic pressure based on a given displacement: |

waveTransmissiveFvPatchField | This boundary condition provides a wave transmissive outflow condition, based onsolving DDt(psi, U) = 0 at the boundary |

directFvPatchFieldMapper | Direct fvPatchFieldMapper |

fvPatchField | Abstract base class with a fat-interface to all derived classes covering all possible ways in which they might be used |

fvMatrix | 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 |

fvSolver | Solver class returned by the solver function |

fvPatchFieldMapper | Foam::fvPatchFieldMapper |

calculatedFvsPatchField | Foam::calculatedFvsPatchField |

coupledFvsPatchField | Foam::coupledFvsPatchField |

fixedValueFvsPatchField | Foam::fixedValueFvsPatchField |

slicedFvsPatchField | Specialization of fvsPatchField which creates the underlying fvsPatchField as a slice of the given complete field |

cyclicFvsPatchField | Foam::cyclicFvsPatchField |

cyclicACMIFvsPatchField | Foam::cyclicACMIFvsPatchField |

cyclicAMIFvsPatchField | Foam::cyclicAMIFvsPatchField |

cyclicSlipFvsPatchField | Foam::cyclicSlipFvsPatchField |

emptyFvsPatchField | Foam::emptyFvsPatchField |

nonuniformTransformCyclicFvsPatchField | Foam::nonuniformTransformCyclicFvsPatchField |

processorFvsPatchField | Foam::processorFvsPatchField |

processorCyclicFvsPatchField | Foam::processorCyclicFvsPatchField |

symmetryFvsPatchField | Foam::symmetryFvsPatchField |

symmetryPlaneFvsPatchField | Foam::symmetryPlaneFvsPatchField |

wedgeFvsPatchField | Foam::wedgeFvsPatchField |

fvsPatchField | An abstract base class with a fat-interface to all derived classes covering all possible ways in which they might be used |

SlicedGeometricField | Specialization of GeometricField which holds slices of given complete fields in a form that they act as a GeometricField |

DimensionedInternalField | The internalField of a SlicedGeometricField |

GeometricField | Generic GeometricField class |

GeometricBoundaryField | |

smoothData | Helper class used by the fvc::smooth and fvc::spread functions |

trackData | Class used to pass additional data in |

sweepData | Helper class used by fvc::sweep function |

fvSchemes | Selector class for finite volume differencing schemes. fvMesh is derived from fvShemes so that all fields have access to the fvSchemes from the mesh reference they hold |

fvSolution | 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 |

leastSquaresVectors | Least-squares gradient scheme vectors |

CentredFitSnGradData | Data for centred fit snGrad schemes |

UIndirectList | A List with indirect addressing |

faceAreaPairGAMGAgglomeration | Agglomerate using the pair algorithm |

extendedCellToCellStencil | Baseclass for cell-to-cell stencils |

extendedCentredCellToCellStencil | |

CECCellToCellStencil | |

cellToCellStencil | Baseclass for extended cell centred addressing. Contains per cell a list of neighbouring cells and/or boundaryfaces in global addressing |

unionEqOp | Combine operator for labelLists |

CFCCellToCellStencil | |

CPCCellToCellStencil | |

centredCECCellToCellStencilObject | |

centredCFCCellToCellStencilObject | |

centredCPCCellToCellStencilObject | |

extendedCellToFaceStencil | Calculates/constains the extended cell-to-face stencil |

extendedCentredCellToFaceStencil | |

extendedUpwindCellToFaceStencil | Creates upwind stencil by shifting a centred stencil to upwind and downwind faces and optionally removing all non-(up/down)wind faces ('pureUpwind') |

CECCellToFaceStencil | Combined corresponding cellToCellStencil of owner and neighbour |

cellToFaceStencil | Base class for extended cell-to-face stencils (face values from neighbouring cells) |

unionEqOp | Combine operator for labelLists |

CFCCellToFaceStencil | Combined corresponding cellToCellStencil of owner and neighbour |

CPCCellToFaceStencil | Combined corresponding cellToCellStencil of owner and neighbour |

FECCellToFaceStencil | All cells connected via edge to face |

centredCECCellToFaceStencilObject | |

centredCFCCellToFaceStencilObject | |

centredCPCCellToFaceStencilObject | |

centredFECCellToFaceStencilObject | |

pureUpwindCFCCellToFaceStencilObject | |

upwindCECCellToFaceStencilObject | |

upwindCFCCellToFaceStencilObject | |

upwindCPCCellToFaceStencilObject | |

upwindFECCellToFaceStencilObject | |

extendedCentredFaceToCellStencil | |

extendedFaceToCellStencil | Note: transformations on coupled patches not supported. Problem is the positions of cells reachable through these patches |

CFCFaceToCellStencil | |

faceToCellStencil | Baseclass for extended cell centred addressing. Contains per cell a list of neighbouring faces in global addressing |

centredCFCFaceToCellStencilObject | |

fvBoundaryMesh | Foam::fvBoundaryMesh |

fvMesh | Mesh data needed to do the Finite Volume discretisation |

fvMeshLduAddressing | Foam::fvMeshLduAddressing |

fvBoundaryMeshMapper | Foam::fvBoundaryMeshMapper |

fvMeshMapper | Class holds all the necessary information for mapping fields associated with fvMesh |

fvPatchMapper | Mapping class for a fvPatchField |

fvSurfaceMapper | FV surface mapper |

fvMeshSubset | Post-processing mesh subset tool. Given the original mesh and the list of selected cells, it creates the mesh consisting only of the desired cells, with the mapping list for points, faces, and cells |

coupledFvPatch | An abstract base class for patches that couple regions of the computational domain e.g. cyclic and processor-processor links |

genericFvPatch | FV variant of the genericPolyPatch |

cyclicFvPatch | Cyclic-plane patch |

cyclicACMIFvPatch | Cyclic patch for Arbitrarily Coupled Mesh Interface (ACMI) |

cyclicAMIFvPatch | Cyclic patch for Arbitrary Mesh Interface (AMI) |

cyclicSlipFvPatch | Cyclic-plane patch |

emptyFvPatch | A patch which will not exist in the fvMesh. Typical example is a front and back plane of a 2-D geometry |

nonuniformTransformCyclicFvPatch | Cyclic-plane patch |

processorFvPatch | Processor patch |

processorCyclicFvPatch | Processor patch |

symmetryFvPatch | Symmetry patch for non-planar or multi-plane patches |

symmetryPlaneFvPatch | Symmetry-plane patch |

wedgeFvPatch | Wedge front and back plane patch |

mappedFvPatch | Foam::mappedFvPatch |

mappedWallFvPatch | Foam::mappedWallFvPatch |

regionCoupledBaseFvPatch | Base class of regionCoupledFvPatch with common functionality for regionCoupledFvPatch and regionCoupledWallFvPatch |

regionCoupledFvPatch | Common functionality for regionCoupleFvPatch and regionCoupledWallFvPatch |

regionCoupledWallFvPatch | Foam::regionCoupledWallFvPatch |

wallFvPatch | Foam::wallFvPatch |

fvPatch | A finiteVolume patch using a polyPatch and a fvBoundaryMesh |

singleCellFvMesh | 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 |

agglomPatchFieldMapper | Patch field mapper class for agglomerated meshes |

nearWallDist | Distance calculation for cells with face on a wall. Searches pointNeighbours to find closest |

nearWallDistNoSearch | Distance calculation for cells with face on a wall. Does not search anything, just takes normal component of distance |

patchDist | Calculation of distance to nearest patch for all cells and boundary. Uses meshWave to do actual calculation |

reflectionVectors | Container for reflection vectors (= unit normal of nearest wall) |

wallDist | Specialisation of patchDist for wall distance calculation |

wallDistData | Wall distance calculation. Like wallDist but also transports extra data (template argument) |

wallDistReflection | Wall distance and reflection vector calculation. See wallDist.H |

wallPointYPlus | Holds information (coordinate and yStar) regarding nearest wall point |

interpolationCell | Uses the cell value for any point in the cell |

interpolationCellPatchConstrained | 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 |

cellPointWeight | Foam::cellPointWeight |

interpolationCellPoint | Given cell centre values and point (vertex) values decompose into tetrahedra and linear interpolate within them |

interpolationCellPointFace | Foam::interpolationCellPointFace |

cellPointWeightWallModified | Foam::cellPointWeightWallModified |

interpolationCellPointWallModified | Same as interpolationCellPoint, but if interpolating a wall face, uses cell centre value instead |

interpolationPointMVC | Given cell centre values interpolates to vertices and uses these to do a Mean Value Coordinates interpolation |

pointPatchField | Abstract base class for point-mesh patch fields |

pointMVCWeight | Container to calculate weights for interpolating directly from vertices of cell using Mean Value Coordinates |

MapInternalField< Type, MeshMapper, surfaceMesh > | |

MapInternalField< Type, MeshMapper, volMesh > | |

blendedSchemeBase | Base class for blended schemes to provide access to the blending factor surface field |

blended | Linear/upwind blended differencing scheme |

filteredLinearLimiter | Class to generate weighting factors for the filteredLinear differencing scheme |

filteredLinear2Limiter | Class to generate weighting factors for the filteredLinear2 differencing scheme |

filteredLinear2VLimiter | Class to generate weighting factors for the filteredLinear2V differencing scheme |

filteredLinear3Limiter | Class to generate weighting factors for the filteredLinear differencing scheme |

filteredLinear3VLimiter | Class to generate weighting factors for the filteredLinear3V differencing scheme |

GammaLimiter | Class with limiter function which returns the limiter for the Gamma differencing scheme based on phict obtained from the LimiterFunc class |

LimitedLimiter | Foam::LimitedLimiter |

Limited01Limiter | A LimitedLimiter with the range 0-1 |

limitedCubicLimiter | Class with limiter function which returns the limiter for the TVD limited centred-cubic differencing scheme based on r obtained from the LimiterFunc class |

limitedCubicVLimiter | Class with limiter function which returns the limiter for the limitedCubicV differencing scheme based on r obtained from the LimiterFunc class |

limitedLinearLimiter | Class with limiter function which returns the limiter for the TVD limited linear differencing scheme based on r obtained from the LimiterFunc class |

LimitedScheme | Class to create NVD/TVD limited weighting-factors |

NVDTVD | Foam::NVDTVD |

NVDVTVDV | Foam::NVDVTVDV |

limitedSurfaceInterpolationScheme | Abstract base class for limited surface interpolation schemes |

limitWith | LimitWith differencing scheme limits the specified scheme with the specified limiter |

MinmodLimiter | Class with limiter function which returns the limiter for the Minmod differencing scheme |

MUSCLLimiter | Class with limiter function which returns the limiter for the van Leer's MUSCL differencing scheme |

OSPRELimiter | Class with limiter function which returns the limiter for the OSPRE differencing scheme based on r obtained from the LimiterFunc class |

PhiLimiter | Class with limiter function which returns the limiter for the Phi differencing scheme |

PhiScheme | Class to create the weighting-factors based on the face-flux |

QUICKLimiter | Class with limiter function which returns the limiter for the quadratic-upwind differencing scheme |

QUICKVLimiter | Class with limiter function which returns the limiter for the quadratic-upwind differencing scheme |

SFCDLimiter | Class with limiter function which returns the limiter for the SFCD differencing scheme based on phict obtained from the LimiterFunc class |

SuperBeeLimiter | Class with limiter function which returns the limiter for the SuperBee differencing scheme based on r obtained from the LimiterFunc class |

UMISTLimiter | Class with limiter function which returns the limiter for the UMIST differencing scheme |

upwind | Upwind differencing scheme class |

vanAlbadaLimiter | Class with limiter function which returns the limiter for the vanAlbada differencing scheme based on r obtained from the LimiterFunc class |

vanLeerLimiter | Class with limiter function which returns the limiter for the vanLeer differencing scheme based on r obtained from the LimiterFunc class |

multivariateIndependentScheme | 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 |

multivariateScheme | Generic multi-variate discretisation scheme class which may be instantiated for any of the NVD, CNVD or NVDV schemes |

fieldScheme | SurfaceInterpolationScheme sub-class returned by operator(field) |

multivariateSelectionScheme | Generic multi-variate discretisation scheme class for which any of the NVD, CNVD or NVDV schemes may be selected for each variable |

fieldScheme | SurfaceInterpolationScheme sub-class returned by operator(field) |

multivariateSurfaceInterpolationScheme | Abstract base class for multi-variate surface interpolation schemes |

fieldScheme | SurfaceInterpolationScheme sub-class returned by operator(field) |

fieldTable | FieldTable |

multivariateUpwind | Upwind-difference form of the multivariate surfaceInterpolationScheme |

fieldScheme | SurfaceInterpolationScheme sub-class returned by operator(field) |

biLinearFitPolynomial | BiLinear polynomial for interpolation fitting |

CentredFitData | Data for the quadratic fit correction interpolation scheme |

CentredFitScheme | Centred fit surface interpolation scheme which applies an explicit correction to linear |

clippedLinear | Central-differencing interpolation scheme using clipped-weights to improve stability on meshes with very rapid variations in cell size |

CoBlended | Two-scheme Courant number based blending differencing scheme |

cubic | Cubic interpolation scheme class derived from linear and returns linear weighting factors but also applies an explicit correction |

cubicUpwindFitPolynomial | Cubic polynomial for upwind biased interpolation fitting |

downwind | Downwind differencing scheme class |

FitData | 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) |

fixedBlended | Two-scheme fixed-blending differencing scheme |

harmonic | Harmonic-mean differencing scheme class |

limiterBlended | Blends two specified schemes using the limiter function provided by a limitedSurfaceInterpolationScheme |

linear | Central-differencing interpolation scheme class |

linearFitPolynomial | Linear polynomial for interpolation fitting |

linearUpwind | LinearUpwind interpolation scheme class derived from upwind and returns upwind weighting factors and also applies a gradient-based explicit correction |

linearUpwindV | LinearUpwindV interpolation scheme class derived from upwind and returns upwind weighting factors but also applies an explicit correction |

localBlended | Two-scheme localBlended differencing scheme |

localMax | LocalMax-mean differencing scheme class |

localMin | LocalMin-mean differencing scheme class |

LUST | LUST: Linear-upwind stabilised transport |

midPoint | Mid-point interpolation (weighting factors = 0.5) scheme class |

outletStabilised | Outlet-stabilised interpolation scheme which applies upwind differencing to the faces of the cells adjacent to outlets |

pointLinear | |

PureUpwindFitScheme | Upwind biased fit surface interpolation scheme that applies an explicit correction to upwind |

quadraticFitPolynomial | Quadratic polynomial for centred interpolation fitting |

quadraticLinearFitPolynomial | Quadratic/linear polynomial for interpolation fitting: quadratic normal to the face, linear in the plane of the face for consistency with 2nd-order Gauss |

quadraticLinearUpwindFitPolynomial | Quadratic polynomial for upwind biased interpolation fitting |

quadraticUpwindFitPolynomial | Quadratic polynomial for upwind biased interpolation fitting |

reverseLinear | Inversed weight central-differencing interpolation scheme class |

skewCorrected | Skewness-corrected interpolation scheme that applies an explicit correction to given scheme |

skewCorrectionVectors | Skew-correction vectors for the skewness-corrected interpolation scheme |

UpwindFitData | Data for the quadratic fit correction interpolation scheme to be used with upwind biased stencil |

UpwindFitScheme | Upwind biased fit surface interpolation scheme that applies an explicit correction to linear |

weighted | Interpolation scheme class using weights looked-up from the objectRegistry |

surfaceInterpolation | Cell to surface interpolation scheme. Included in fvMesh |

surfaceInterpolationScheme | Abstract base class for surface interpolation schemes |

pointConstraints | Application of (multi-)patch point contraints |

volPointInterpolation | Interpolate from cell centres to points (vertices) using inverse distance weighting |

surfaceMesh | Mesh data needed to do the Finite Volume discretisation |

volMesh | Mesh data needed to do the Finite Volume discretisation |

MGridGenGAMGAgglomeration | Agglomerate using the MGridGen algorithm |

pairPatchAgglomeration | Primitive patch pair agglomerate method |

displacementComponentLaplacianFvMotionSolver | Mesh motion solver for an fvMesh. Based on solving the cell-centre Laplacian for the given component of the motion displacement |

velocityComponentLaplacianFvMotionSolver | Mesh motion solver for an fvMesh. Based on solving the cell-centre Laplacian for the given component of the motion velocity |

displacementInterpolationMotionSolver | Mesh motion solver for an fvMesh |

displacementLaplacianFvMotionSolver | Mesh motion solver for an fvMesh. Based on solving the cell-centre Laplacian for the motion displacement |

displacementLayeredMotionMotionSolver | Mesh motion solver for an (multi-block) extruded fvMesh. Gets given the structure of the mesh blocks and boundary conditions on these blocks |

pointEdgeStructuredWalk | Determines length of string of edges walked to point |

displacementSBRStressFvMotionSolver | Mesh motion solver for an fvMesh. Based on solving the cell-centre solid-body rotation stress equations for the motion displacement |

fvMotionSolverCore | Base class for fvMesh based motionSolvers |

velocityLaplacianFvMotionSolver | Mesh motion solver for an fvMesh. Based on solving the cell-centre Laplacian for the motion velocity |

cellMotionFvPatchField | Foam::cellMotionFvPatchField |

surfaceSlipDisplacementFvPatchField | FvPatchField corresponding to surfaceSlipDisplacementPointPatchField. Is just a slip type since all hard work (projection) is done in the pointPatch field |

directionalDiffusivity | Directional finite volume mesh motion diffusivity |

fileDiffusivity | Motion diffusivity read from given file name |

inverseDistanceDiffusivity | Inverse distance to the given patches motion diffusivity |

inverseFaceDistanceDiffusivity | Inverse distance to the given patches motion diffusivity |

inversePointDistanceDiffusivity | Inverse distance to the given patches motion diffusivity |

inverseVolumeDiffusivity | Inverse cell-volume motion diffusivity |

exponentialDiffusivity | Mesh motion diffusivity maipulator which returns the exp(-alpha/D) of the given diffusivity D |

quadraticDiffusivity | Mesh motion diffusivity maipulator which returns the sqr of the given diffusivity |

motionDiffusivity | Abstract base class for cell-centre mesh motion diffusivity |

motionDirectionalDiffusivity | MotionDirectional finite volume mesh motion diffusivity |

uniformDiffusivity | Uniform uniform finite volume mesh motion diffusivity |

angularOscillatingDisplacementPointPatchVectorField | Foam::angularOscillatingDisplacementPointPatchVectorField |

angularOscillatingVelocityPointPatchVectorField | Foam::angularOscillatingVelocityPointPatchVectorField |

oscillatingDisplacementPointPatchVectorField | Foam::oscillatingDisplacementPointPatchVectorField |

oscillatingVelocityPointPatchVectorField | Foam::oscillatingVelocityPointPatchVectorField |

surfaceDisplacementPointPatchVectorField | |

surfaceSlipDisplacementPointPatchVectorField | 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 |

timeVaryingMappedFixedValuePointPatchField | A time-varying form of a mapped fixed value boundary condition |

uniformInterpolatedDisplacementPointPatchVectorField | Interpolates pre-specified motion |

waveDisplacementPointPatchVectorField | Foam::waveDisplacementPointPatchVectorField |

bladeModel | Blade model class |

lookupProfile | Look-up based profile data - drag and lift coefficients are lineraly interpolated based on the supplied angle of attack |

profileModel | Base class for profile models |

profileModelList | Base class for profile models |

seriesProfile | Series-up based profile data - drag and lift coefficients computed as sum of cosine series |

fixedTrim | Fixed trim coefficients |

targetCoeffTrim | Target trim forces/coefficients |

trimModel | Trim model base class |

genericFvPatchField | 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 |

genericPointPatchField | A generic version of calculatedPointPatchField, useful as a fallback for handling unknown patch types |

Cloud | Base cloud calls templated on particle type |

IOPosition | Helper IO class to read and write particle positions |

indexedParticle | Adds label index to base particle |

indexedParticleCloud | A Cloud of particles carrying an additional index |

InteractionLists | Builds direct interaction list, specifying which local (real) cells are potentially in range of each other |

referredWallFace | Storage for referred wall faces. Stores patch index, face and associated points |

particle | Base particle class |

iNew | Factory class to read-construct particles used for |

TrackingData | |

passiveParticle | Copy of base particle |

passiveParticleCloud | A Cloud of passive particles |

coalCloudList | |

COxidationDiffusionLimitedRate | |

COxidationHurtMitchell | |

COxidationKineticDiffusionLimitedRate | |

COxidationMurphyShaddix | |

DsmcBaseCloud | Virtual abstract base class for templated DsmcCloud |

BinaryCollisionModel | Templated DSMC particle collision class |

WallInteractionModel | Templated wall interaction model class |

InflowBoundaryModel | Templated inflow boundary model class |

DsmcCloud | Templated base class for dsmc cloud |

DsmcParcel | DSMC parcel class |

constantProperties | Class to hold DSMC particle constant properties |

iNew | Factory class to read-construct particles used for |

trackingData | Class used to pass kinematic tracking data to the trackToFace function |

LarsenBorgnakkeVariableHardSphere | Variable Hard Sphere BinaryCollision Model with Larsen Borgnakke internal energy redistribution. Based on the INELRS subroutine in Bird's DSMC0R.FOR |

NoBinaryCollision | No collison BinaryCollision Model |

VariableHardSphere | Variable Hard Sphere BinaryCollision Model |

FreeStream | 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 |

NoInflow | Not inserting any particles |

MaxwellianThermal | Wall interaction setting microscopic velocity to a random one drawn from a Maxwellian distribution corresponding to a specified temperature |

MixedDiffuseSpecular | 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 |

SpecularReflection | Reversing the wall-normal component of the particle velocity |

kinematicCloud | Virtual abstract base class for templated KinematicCloud |

reactingCloud | Virtual abstract base class for templated ReactingCloud |

reactingMultiphaseCloud | Virtual abstract base class for templated reactingMultiphaseCloud |

thermoCloud | Virtual abstract base class for templated ThermoCloud |

CollisionModel | Templated collision model class |

CollidingCloud | Adds coolisions to kinematic clouds |

cloudSolution | Stores all relevant solution info for cloud |

InjectionModelList | List of injection models |

DispersionModel | |

PatchInteractionModel | Templated patch interaction model class |

SurfaceFilmModel | Templated wall surface film model class |

StochasticCollisionModel | Templated stochastic collision model class |

KinematicCloud | Templated base class for kinematic cloud |

PackingModel | Base class for packing models |

NoPacking | |

DampingModel | Base class for collisional damping models |

IsotropyModel | Base class for collisional return-to-isotropy models |

MPPICCloud | Adds MPPIC modelling to kinematic clouds |

CompositionModel | Templated reacting parcel composition model class Consists of carrier species (via thermo package), and additional liquids and solids |

PhaseChangeModel | Templated phase change model class |

ReactingCloud | Templated base class for reacting cloud |

DevolatilisationModel | Templated devolatilisation model class |

SurfaceReactionModel | Templated surface reaction model class |

ReactingMultiphaseCloud | Templated base class for multiphase reacting cloud |

HeatTransferModel | Templated heat transfer model class |

ThermoCloud | Templated base class for thermodynamic cloud |

Analytical | Analytical integration |

Euler | Euler-implicit integration |

IntegrationScheme | Top level model for Integration schemes |

integrationResult | Helper class to supply results of integration |

CollidingParcel | Wrapper around kinematic parcel types to add collision modelling |

constantProperties | Class to hold thermo particle constant properties |

iNew | Factory class to read-construct particles used for |

CollisionRecordList | |

PairCollisionRecord | Record of a collision between the particle holding the record and the particle with the stored id |

WallCollisionRecord | Record of a collision between the particle holding the record and a wall face at the position relative to the centre of the particle |

KinematicParcel | Kinematic parcel class with rotational motion (as spherical particles only) and one/two-way coupling with the continuous phase |

constantProperties | Class to hold kinematic particle constant properties |

iNew | Factory class to read-construct particles used for |

TrackingData | |

MPPICParcel | Wrapper around kinematic parcel types to add MPPIC modelling |

iNew | Factory class to read-construct particles used for |

TrackingData | |

AveragingMethod | Base class for lagrangian averaging methods |

ReactingMultiphaseParcel | Multiphase variant of the reacting parcel class with one/two-way coupling with the continuous phase |

constantProperties | Class to hold reacting multiphase particle constant properties |

iNew | Factory class to read-construct particles used for |

ReactingParcel | Reacting parcel class with one/two-way coupling with the continuous phase |

constantProperties | Class to hold reacting particle constant properties |

iNew | Factory class to read-construct particles used for |

TrackingData | |

ThermoParcel | Thermodynamic parcel class with one/two-way coupling with the continuous phase. Includes Kinematic parcel sub-models, plus: |

constantProperties | Class to hold thermo particle constant properties |

iNew | Factory class to read-construct particles used for |

TrackingData | |

phaseProperties | Helper class to manage multi-component phase properties |

phasePropertiesList | Simple container for a list of phase properties |

CloudFunctionObject | Templated cloud function object base class |

CloudFunctionObjectList | List of cloud function objects |

FacePostProcessing | Records particle face quantities on used-specified face zone |

ParticleCollector | 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 |

ParticleErosion | Creates particle erosion field, Q |

ParticleTracks | Records particle state (all variables) on each call to postFace |

ParticleTrap | Traps particles within a given phase fraction for multi-phase cases |

PatchPostProcessing | Standard post-processing |

VoidFraction | Creates particle void fraction field on carrier phase |

CloudSubModelBase | Base class for cloud sub-models |

ParticleForceList | List of particle forces |

NoCollision | Place holder for 'none' option |

PairModel | Templated pair interaction class |

WallModel | Templated wall interaction class |

PairCollision | |

PairSpringSliderDashpot | Pair forces between particles colliding with a spring, slider, damper model |

WallLocalSpringSliderDashpot | Forces between particles and walls, interacting with a spring, slider, damper model |

WallSpringSliderDashpot | Forces between particles and walls, interacting with a spring, slider, damper model |

WallSiteData | Stores the patch ID and templated data to represent a collision with a wall to be passed to the wall model |

NoDispersion | Place holder for 'none' option |

CellZoneInjection | Injection positions specified by a particle number density within a cell set |

ConeInjection | Multi-point cone injection model |

TimeDataEntry | Light wrapper around DataEntry to provide a mechanism to update time-based entries |

ConeNozzleInjection | Cone injection |

FieldActivatedInjection | Injection at specified positions, with the conditions: |

InflationInjection | 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 |

InjectionModel | Templated injection model class |

KinematicLookupTableInjection | Particle injection sources read from look-up table. Each row corresponds to an injection site |

kinematicParcelInjectionData | Container class to provide injection data for kinematic parcels |

ManualInjection | Manual injection |

NoInjection | Place holder for 'none' option |

PatchFlowRateInjection | Patch injection |

PatchInjection | Patch injection |

patchInjectionBase | |

ErgunWenYuDragForce | Ergun-Wen-Yu drag model for solid spheres |

NonSphereDragForce | Drag model for non-spherical particles |

PlessisMasliyahDragForce | PlessisMasliyahDragForce drag model for solid spheres |

SphereDragForce | Drag model based on assumption of solid spheres |

WenYuDragForce | Wen-Yu drag model for solid spheres |

forceSuSp | Helper container for force Su and Sp terms |

GravityForce | Calculates particle gravity force |

LiftForce | Base class for particle lift force models |

SaffmanMeiLiftForce | Saffman-Mei particle lift force model applicable to spherical particles |

TomiyamaLiftForce | Tomiyama particle lift force model applicable to deformable bubbles |

NonInertialFrameForce | Calculates particle non-inertial reference frame force. Variable names as from Landau and Lifshitz, Mechanics, 3rd Ed, p126-129 |

ParamagneticForce | Calculates particle paramagnetic (magnetic field) force |

ParticleForce | Abstract base class for particle forces |

PressureGradientForce | Calculates particle pressure gradient force |

SRFForce | Calculates particle SRF reference frame force |

VirtualMassForce | Calculates particle virtual mass force |

LocalInteraction | Patch interaction specified on a patch-by-patch basis |

patchInteractionData | Helper class for the LocalInteraction patch interaction model |

patchInteractionDataList | List container for patchInteractionData class |

MultiInteraction | Runs multiple patch interaction models in turn. Takes dictionary where all the subdictionaries are the interaction models |

NoInteraction | Dummy class for 'none' option - will raise an error if any functions are called that require return values |

Rebound | Simple rebound patch interaction model |

StandardWallInteraction | Wall interaction model. Three choices: |

NoStochasticCollision | Dummy collision model for 'none' |

NoSurfaceFilm | Place holder for 'none' option |

CorrectionLimitingMethod | Base class for correction limiting methods |

ParticleStressModel | Base class for inter-particle stress models |

TimeScaleModel | Base class for time scale models |

NoComposition | Dummy class for 'none' option - will raise an error if any functions are called that require return values |

SingleMixtureFraction | Templated parcel multi-phase, multi-component class |

SinglePhaseMixture | Templated parcel single phase, multi-component class |

ReactingLookupTableInjection | Particle injection sources read from look-up table. Each row corresponds to an injection site |

reactingParcelInjectionData | Container class to provide injection data for reacting parcels |

LiquidEvaporation | Liquid evaporation model |

LiquidEvaporationBoil | Liquid evaporation model |

NoPhaseChange | Dummy phase change model for 'none' |

ConstantRateDevolatilisation | Constant rate devolatisation model |

NoDevolatilisation | Dummy devolatilisation model for 'none' |

SingleKineticRateDevolatilisation | Single kinetic rate devolatisation model |

ReactingMultiphaseLookupTableInjection | Particle injection sources read from look-up table. Each row corresponds to an injection site |

reactingMultiphaseParcelInjectionData | Container class to provide injection data for reacting multiphase parcels |

SuppressionCollision | Inter-cloud collision model, whereby the `canReact` flag can be used to inhibit devolatilisation and surface reactions |

NoSurfaceReaction | Dummy surface reaction model for 'none' |

NoHeatTransfer | Dummy heat transfer model for 'none' |

RanzMarshall | The Ranz-Marshall correlation for heat transfer |

ThermoLookupTableInjection | Particle injection sources read from look-up table. Each row corresponds to an injection site |

thermoParcelInjectionData | Container class to provide injection data for thermodynamic parcels |

ThermoSurfaceFilm | Thermo parcel surface film model |

bufferedAccumulator | |

correlationFunction | |

distribution | Accumulating histogram of values. Specified bin resolution automatic generation of bins |

molecule | Foam::molecule |

constantProperties | Class to hold molecule constant properties |

iNew | Factory class to read-construct particles used for |

trackingData | Class used to pass tracking data to the trackToFace function |

moleculeCloud | |

reducedUnits | |

electrostaticPotential | |

energyScalingFunction | |

pairPotential | |

pairPotentialList | |

potential | |

tetherPotential | |

tetherPotentialList | |

solidParticle | Simple solid spherical particle class with one-way coupling with the continuous phase |

iNew | Factory class to read-construct particles used for |

trackingData | Class used to pass tracking data to the trackToFace function |

solidParticleCloud | A Cloud of solid particles |

sprayCloud | Virtual abstract base class for templated SprayCloud |

AtomizationModel | Templated atomization model class |

BreakupModel | Templated break-up model class |

SprayCloud | Templated base class for spray cloud |

SprayParcel | Reacing spray parcel, with added functionality for atomization and breakup |

constantProperties | Class to hold reacting particle constant properties |

iNew | Factory class to read-construct particles used for |

BlobsSheetAtomization | Primary Breakup Model for pressure swirl atomizers |

LISAAtomization | Primary Breakup Model for pressure swirl atomizers |

NoAtomization | Dummy phase change model for 'none' |

ETAB | The Enhanced TAB model |

NoBreakup | Dummy breakup model for 'none' |

PilchErdman | Particle secondary breakup model, based on the reference: |

ReitzDiwakar | Secondary breakup model |

ReitzKHRT | Secondary breakup model which uses the Kelvin-Helmholtz instability theory to predict the 'stripped' droplets... and the Raleigh-Taylor instability as well |

SHF | Secondary Breakup Model to take account of the different breakup regimes, bag, molutimode, shear... |

TAB | The TAB Method for Numerical Calculation of Spray Droplet Breakup |

ORourkeCollision | Collision model by P.J. O'Rourke |

TrajectoryCollision | Trajectory collision model by N. Nordin, based on O'Rourke's collision model |

DispersionRASModel | Base class for particle dispersion models based on RAS turbulence |

GradientDispersionRAS | The velocity is perturbed in the direction of -grad(k), with a Gaussian random number distribution with variance sigma. where sigma is defined below |

StochasticDispersionRAS | The velocity is perturbed in random direction, with a Gaussian random number distribution with variance sigma. where sigma is defined below |

BrownianMotionForce | Calculates particle Brownian motion force |

autoLayerDriver | All to do with adding layers |

autoRefineDriver | |

autoSnapDriver | All to do with snapping to surface |

listPlusEqOp | |

layerParameters | Simple container to keep together layer specific information |

pointData | Variant of pointEdgePoint with some transported additional data. WIP - should be templated on data like wallDistData. Passive vector v_ is not a coordinate (so no enterDomain/leaveDomain transformation needed) |

refinementParameters | Simple container to keep together refinement specific information |

snapParameters | Simple container to keep together snap specific information |

displacementMeshMoverMotionSolver | Mesh motion solver for an fvMesh. Based on solving the cell-centre Laplacian for the motion displacement |

externalDisplacementMeshMover | 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) |

medialAxisMeshMover | 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. This fraction is then used to scale the motion |

meshRefinement | Helper class which maintains intersections of (changing) mesh with (static) surfaces |

normalLess | To compare normals |

pTraits< labelList > | Template specialization for pTraits<labelList> so we can have fields |

pTraits< vectorList > | Template specialization for pTraits<labelList> so we can have fields |

patchFaceOrientation | Transport of orientation for use in PatchEdgeFaceWave |

refinementFeatures | Encapsulates queries for features |

refinementSurfaces | Container for data on surfaces used for surface-driven refinement. Contains all the data about the level of refinement needed per surface |

surfaceZonesInfo | |

shellSurfaces | Encapsulates queries for volume refinement ('refine all cells within shell') |

trackedParticle | Particle class that marks cells it passes through. Used to mark cells visited by feature edges |

iNew | Factory class to read-construct particles used for |

trackingData | Class used to pass tracking data to the trackToFace function |

block | Creates a single block of cells from point coordinates, numbers of cells in each direction and an expansion ratio |

blockDescriptor | 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 |

blockMesh | A multi-block mesh generator |

arcEdge | Defines the arcEdge of a circle in terms of 3 points on its circumference |

BSpline | An implementation of B-splines |

CatmullRomSpline | An implementation of Catmull-Rom splines (sometimes known as Overhauser splines) |

curvedEdge | Define a curved edge that is parameterized for 0<lambda<1 between the start and end point |

lineDivide | Divides a line into segments |

lineEdge | A straight edge between the start point and the end point |

polyLine | A series of straight line segments, which can also be interpreted as a series of control points for splines, etc |

polyLineEdge | A curvedEdge defined in terms of a series of straight line segments |

splineEdge | A curvedEdge interface for Catmull-Rom splines |

extrudeModel | Top level extrusion model class |

combine | Combine operator for AMIInterpolation |

FaceCellWave | Wave propagation of information through grid. Every iteration information goes through one layer of cells. Templated on information that is transferred |

MeshWave | FaceCellWave plus data |

patchEdgeFaceInfo | |

patchEdgeFaceRegion | Transport of region for use in PatchEdgeFaceWave |

patchEdgeFaceRegions | Transport of regions for use in PatchEdgeFaceWave |

PatchEdgeFaceWave | Wave propagation of information along patch. Every iteration information goes through one layer of faces. Templated on information that is transferred |

updateOp | Update operation |

transformOp | Transform operation |

patchPatchDist | Like wallDist but calculates on a patch the distance to nearest neighbouring patches. Uses PatchEdgeFaceWave to do actual calculation |

pointEdgePoint | Holds information regarding nearest wall point. Used in PointEdgeWave. (so not standard FaceCellWave) To be used in wall distance calculation |

combineEqOp | Reduction class. If x and y are not equal assign value |

PointEdgeWave | Wave propagation of information through grid. Every iteration information goes through one layer of edges |

listUpdateOp | List update operation |

AMIInterpolation | Interpolation class dealing with transfer of data between two primitive patches with an arbitrary mesh interface (AMI) |

AMIMethod | Base class for Arbitrary Mesh Interface (AMI) methods |

directAMI | Direct mapped Arbitrary Mesh Interface (AMI) method |

faceAreaWeightAMI | Face area weighted Arbitrary Mesh Interface (AMI) method |

mapNearestAMI | Nearest-mapping Arbitrary Mesh Interface (AMI) method |

partialFaceAreaWeightAMI | Partial face area weighted Arbitrary Mesh Interface (AMI) method |

faceAreaIntersect | Face intersection class |

cyclicACMIGAMGInterfaceField | GAMG agglomerated cyclic interface for Arbitrarily Coupled Mesh Interface (ACMI) fields |

cyclicAMIGAMGInterfaceField | GAMG agglomerated cyclic interface field |

cyclicACMIGAMGInterface | GAMG agglomerated cyclic ACMI interface |

cyclicAMIGAMGInterface | GAMG agglomerated cyclic AMI interface |

cyclicACMILduInterface | An abstract base class for cyclic ACMI coupled interfaces |

cyclicACMILduInterfaceField | Abstract base class for cyclic ACMI coupled interfaces |

cyclicACMIPointPatch | Cyclic AMI point patch - place holder only |

cyclicACMIPointPatchField | Cyclic ACMI front and back plane patch field |

cyclicACMIPolyPatch | Cyclic patch for Arbitrarily Coupled Mesh Interface (ACMI) |

cyclicAMILduInterface | An abstract base class for cyclic AMI coupled interfaces |

cyclicAMILduInterfaceField | Abstract base class for cyclic AMI coupled interfaces |

cyclicAMIPointPatch | Cyclic AMI point patch - place holder only |

cyclicAMIPointPatchField | Cyclic AMI front and back plane patch field |

cyclicAMIPolyPatch | Cyclic patch for Arbitrary Mesh Interface (AMI) |

cellClassification | 'Cuts' a mesh with a surface |

cellInfo | Holds information regarding type of cell. Used in inside/outside determination in cellClassification |

cellDistFuncs | Collection of functions used in wall distance calculation |

patchDataWave | Takes a set of patches to start MeshWave from |

patchWave | 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 |

wallPoint | Holds information regarding nearest wall point. Used in wall distance calculation |

wallPointData | Holds information (coordinate and normal) regarding nearest wall point |

cellFeatures | Cell analysis class |

cellQuality | Class calculates cell quality measures |

cartesianCS | Cylindrical coordinate system |

axesRotation | A coordinate rotation specified using global axis |

coordinateRotation | Abstract base class for coordinate rotation |

EulerCoordinateRotation | A coordinateRotation defined in the z-x-y Euler convention |

localAxesRotation | A local coordinate rotation. Each rotational tensor is defined with two vectors (dir and e3) where dir = cellC - origin and e3 is the rotation axis. Per each cell an axesRotation type of rotation is created |

STARCDCoordinateRotation | A coordinateRotation defined by the STAR-CD convention |

coordinateSystem | Base class for other coordinate system specifications |

coordinateSystems | Provides a centralized coordinateSystem collection |

cylindricalCS | Cylindrical coordinate system |

edgeFaceCirculator | Walks from starting face around edge |

indexedOctree | Non-pointer based hierarchical recursive searching |

node | Tree node. Has up pointer and down pointers |

treeDataEdge | Holds data for octree to work on an edges subset |

findIntersectOp | |

findNearestOp | |

treeDataFace | Encapsulation of data needed to search for faces |

findIntersectOp | |

findNearestOp | |

treeDataPoint | 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 |

findIntersectOp | |

findNearestOp | |

treeDataPrimitivePatch | Encapsulation of data needed to search on PrimitivePatches |

findAllIntersectOp | |

findIntersectOp | |

findNearestOp | |

findSelfIntersectOp | |

mappedPointPatch | MappedPointPatch patch |

mappedWallPointPatch | MappedWallPointPatch patch |

mappedPatchBase | Determines a mapping between patch face centres and mesh cell or face centres and processors they're on |

maxProcEqOp | |

nearestEqOp | |

mappedPolyPatch | Determines a mapping between patch face centres and mesh cell or face centres and processors they're on |

mappedVariableThicknessWallPolyPatch | Foam::mappedVariableThicknessWallPolyPatch |

mappedWallPolyPatch | Determines a mapping between patch face centres and mesh cell or face centres and processors they're on |

meshSearch | Various (local, not parallel) searches on polyMesh; uses (demand driven) octree to search |

meshSearchFACECENTRETETSMeshObject | MeshObject wrapper around meshSearch(mesh, polyMesh::FACECENTRETETS) |

meshSearchMeshObject | MeshObject wrapper around meshSearch(mesh) |

meshStructure | Detect extruded mesh structure given a set of patch faces |

pointTopoDistanceData | For use with PointEdgeWave. Determines topological distance to starting points |

topoDistanceData | For use with FaceCellWave. Determines topological distance to starting faces |

momentOfInertia | |

primitiveMeshGeometry | Updateable mesh geometry + checking routines |

regionCoupledGAMGInterfaceField | GAMG agglomerated region coupled interface field |

regionCoupledWallGAMGInterfaceField | GAMG agglomerated region coupled interface field |

regionCoupledBaseGAMGInterface | Base class for GAMG agglomerated coupled region interface |

regionCoupledGAMGInterface | GAMG agglomerated coupled region interface |

regionCoupledWallGAMGInterface | GAMG agglomerated coupled region interface |

regionCoupledLduInterface | An abstract base class for region coupled interfaces |

regionCoupledPointPatch | Cyclic AMI point patch - place holder only |

regionCoupledWallPointPatch | Cyclic AMI point patch - place holder only |

regionCoupledBase | Base class with common functinality for regionCoupled polyPatch. It includes AMI |

regionCoupledPolyPatch | Region coupled polyPatch |

regionCoupledWallPolyPatch | RegionCoupledWall |

minEqOpFace | |

localPointRegion | 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 |

regionSplit | This class separates the mesh into distinct unconnected regions, each of which is then given a label according to globalNumbering() |

closedTriSurfaceMesh | 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 |

searchableBox | Searching on bounding box |

searchableCylinder | Searching on cylinder |

searchablePlane | Searching on (infinite) plane. See plane.H |

searchablePlate | 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 |

searchableSphere | Searching on sphere |

searchableSurface | Base class of (analytical or triangulated) surface. Encapsulates all the search routines. WIP |

iNew | Class used for the read-construction of |

searchableSurfaceCollection | Set of transformed searchableSurfaces. Does not do boolean operations. So when meshing might find parts 'inside' |

searchableSurfaces | Container for searchableSurfaces |

searchableSurfacesQueries | A collection of tools for searchableSurfaces |

searchableSurfaceWithGaps | SearchableSurface using multiple slightly shifted underlying surfaces to make sure pierces don't go through gaps: |

triSurfaceMesh | IOoject and searching on triSurface |

boxToCell | A topoSetSource to select cells based on cell centres inside box(es) |

cellToCell | A topoSetSource to select the cells from another cellSet |

cylinderAnnulusToCell | A topoSetSource to select cells based on cell centres inside a cylinder annulus |

cylinderToCell | A topoSetSource to select cells based on cell centres inside a cylinder |

faceToCell | A topoSetSource to select cells based on usage in faces |

faceZoneToCell | A topoSetSource to select cells based on side of faceZone |

fieldDictionary | Read field as dictionary (without mesh) |

fieldToCell | A topoSetSource to select cells based on field values |

labelToCell | A topoSetSource to select cells based on explicitly given labels |

nbrToCell | A topoSetSource to select cells based on number of neighbouring cells (i.e. number of internal or coupled faces) |

nearestToCell | A topoSetSource to select cells nearest to points |

pointToCell | A topoSetSource to select cells based on usage of points |

regionToCell | TopoSetSource. Select cells belonging to topological connected region (that contains given points) |

rotatedBoxToCell | A topoSetSource to select cells based on cell centres inside rotated/skewed box (parallelopiped?) |

shapeToCell | A topoSetSource to select cells based on cell shape |

sphereToCell | A topoSetSource to select cells based on cell centres inside sphere |

surfaceToCell | A topoSetSource to select cells based on relation to surface |

targetVolumeToCell | A topoSetSource to select cells based on the wanted volume of selected cells. Adapts a plane until it has enough |

zoneToCell | A topoSetSource to select faces based on cellZone |

setToCellZone | A topoSetSource to select cells based on usage in a cellSet |

boundaryToFace | A topoSetSource to select all external (boundary) faces |

boxToFace | A topoSetSource to select faces based on face centres inside box |

cellToFace | A topoSetSource to select a faceSet from cells |

faceToFace | A topoSetSource to select faces based on usage in another faceSet |

labelToFace | A topoSetSource to select faces given explicitly provided face labels |

normalToFace | A topoSetSource to select faces based on normal |

patchToFace | A topoSetSource to select faces based on usage in patches |

pointToFace | A topoSetSource to select faces based on use of points |

regionToFace | A topoSetSource to select faces belonging to topological connected region (that contains given point) |

zoneToFace | A topoSetSource to select faces based on faceZone |

faceZoneToFaceZone | A topoSetSource to select faces based on usage in another faceSet |

searchableSurfaceToFaceZone | A topoSetSource to select faces based on intersection (of cell-cell vector) with a surface |

setAndNormalToFaceZone | A topoSetSource to select faces based on usage in a faceSet, where the normal vector is used to orient the faces |

setsToFaceZone | A topoSetSource to select faces based on usage in a faceSet and cellSet |

setToFaceZone | A topoSetSource to select faces based on usage in a faceSet. Sets flipMap to true |

boxToPoint | A topoSetSource to select points based on whether they are inside box |

cellToPoint | A topoSetSource to select points based on usage in cells |

faceToPoint | A topoSetSource to select points based on usage in faces |

labelToPoint | A topoSetSource to select points given explicitly provided labels |

nearestToPoint | A topoSetSource to select points nearest to points |

pointToPoint | A topoSetSource to select points based on usage in pointSet |

surfaceToPoint | A topoSetSource to selects points based on relation to surface |

zoneToPoint | A topoSetSource to select points based on pointZone |

setToPointZone | A topoSetSource to select points based on usage in a pointSet |

cellSet | A collection of cell labels |

cellZoneSet | Like cellSet but updates cellZone when writing |

faceSet | A list of face labels |

faceZoneSet | Like faceSet but updates faceZone when writing |

pointSet | A set of point labels |

pointZoneSet | Like pointSet but updates pointZone when writing |

topoSet | General set of labels of mesh quantity (points, cells, faces) |

topoSetSource | Base class of a source for a topoSet |

addToUsageTable | Class with constructor to add usage string to table |

iNew | Class used for the read-construction of |

surfaceSets | Various utilities to handle sets relating mesh to surface. Note: work in progress. Used in meshing tools |

tetOverlapVolume | Calculates the overlap volume of two cells using tetrahedral decomposition |

booleanSurface | Surface-surface intersection. Given two surfaces construct combined surface |

edgeSurface | Description of surface in form of 'cloud of edges' |

intersectedSurface | Given triSurface and intersection creates the intersected (properly triangulated) surface. (note: intersection is the list of points and edges 'shared' by two surfaces) |

edgeIntersections | 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.) |

surfaceIntersection | Basic surface-surface intersection description. Constructed from two surfaces it creates a description of the intersection |

orientedSurface | Given point flip all faces such that normals point in same direction |

surfaceFeatures | Holds feature edges/points of surface |

surfaceLocation | Contains information about location on a triSurface: |

triangleFuncs | Various triangle functions |

triSurfaceRegionSearch | Helper class to search on triSurface. Creates an octree for each region of the surface and only searches on the specified regions |

triSurfaceSearch | Helper class to search on triSurface |

pointToPointPlanarInterpolation | Interpolates between two sets of unstructured points using 2D Delaunay triangulation. Used in e.g. timeVaryingMapped bcs |

triSurfaceTools | A collection of tools for triSurface |

twoDPointCorrector | Class applies a two-dimensional correction to mesh motion point field |

adaptiveSolver | |

EulerSI | Semi-implicit Euler ODE solver of order (0)1 |

ODESolver | Abstract base-class for ODE system solvers |

stepState | |

RKCK45 | 4/5th Order Cash-Karp Runge-Kutta ODE solver |

RKDP45 | 4/5th Order Dormandâ€“Prince Runge-Kutta ODE solver |

RKF45 | 4/5th Order Runge-Kutta-Fehlberg ODE solver |

rodas23 | L-stable, stiffly-accurate embedded Rosenbrock ODE solver of order (2)3 |

rodas34 | L-stable, stiffly-accurate embedded Rosenbrock ODE solver of order (3)4 |

Rosenbrock12 | L-stable embedded Rosenbrock ODE solver of order (1)2 |

Rosenbrock23 | L-stable embedded Rosenbrock ODE solver of order (2)3 |

Rosenbrock34 | L-stable embedded Rosenbrock ODE solver of order (3)4 |

seulex | An extrapolation-algorithm, based on the linearly implicit Euler method with step size control and order selection |

SIBS | Foam::SIBS |

Trapezoid | Trapezoidal ODE solver of order (1)2 |

ODESystem | Abstract base class for the systems of ordinary differential equations |

dynamicIndexedOctree | Non-pointer based hierarchical recursive searching. Storage is dynamic, so elements can be deleted |

node | Tree node. Has up pointer and down pointers |

dynamicTreeDataPoint | 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 |

labelBits | A 29bits label and 3bits direction packed into single label |

treeDataCell | Encapsulation of data needed to search in/for cells. Used to find the cell containing a point (e.g. cell-cell mapping) |

findIntersectOp | |

findNearestOp | |

volumeType | |

subCycleField | |

subCycle | Perform a subCycleTime on a field |

circulator | Walks over a container as if it were circular. The container must have the following members defined: |

CirculatorBase | Base class for circulators |

const_circulator | Walks over a container as if it were circular. The container must have the following members defined: |

Dictionary | Gerneral purpose template dictionary class which manages the storage associated with it |

DictionaryBase | Base dictionary class templated on both the form of doubly-linked list it uses as well as the type it holds |

PtrDictionary | Template dictionary class which does not manages the storage associated with it |

UDictionary | Template dictionary class which does not manages the storage associated with it |

UPtrDictionary | Template dictionary class which does not manages the storage associated with it |

HashPtrTable | A HashTable specialization for hashing pointers |

HashSet | A HashTable with keys but without contents |

List | A 1D array of objects of type <T>, where the size of the vector is known and used for subscript bounds checking, etc |

UList | 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 |

greater | Greater function class that can be used for sorting |

less | Less function class that can be used for sorting |

HashTable | An STL-conforming hash table |

const_iterator | An STL-conforming const_iterator |

iterator | An STL-conforming iterator |

iteratorBase | The iterator base for HashTable |

HashTableCore | Template-invariant bits for HashTable |

iteratorEnd | A zero-sized end iterator |

Map | A HashTable to objects of type <T> with a label key |

PtrMap | A HashTable of pointers to objects of type <T> with a label key |

StaticHashTable | STL conforming hash table |

Iterator | An STL iterator |

StaticHashTableCore | Template-invariant bits for StaticHashTable |

iteratorEnd | A zero-sized end iterator |

Keyed | A container with an integer key attached to any item |

ILList | Template class for intrusive linked lists |

LList | Template class for non-intrusive linked lists |

const_iterator | An STL-conforming const_iterator |

iterator | An STL-conforming iterator |

link | Link structure |

LPtrList | Template class for non-intrusive linked PtrLists |

const_iterator | An STL-conforming const_iterator |

iterator | An STL-conforming iterator |

UILList | Template class for intrusive linked lists |

const_iterator | An STL-conforming const_iterator |

const_reverse_iterator | An STL-conforming const_reverse_iterator |

iterator | An STL-conforming iterator |

DLListBase | Base doubly-linked list |

const_iterator | An STL-conforming const_iterator |

const_reverse_iterator | An STL-conforming const_reverse_iterator |

iterator | An STL-conforming iterator |

link | Link structure |

SLListBase | Base singly-linked list |

const_iterator | An STL-conforming const_iterator |

iterator | An STL-conforming iterator |

link | Link structure |

DLList | Non-intrusive doubly-linked list |

DLPtrList | Non-intrusive doubly-linked pointer list |

FIFOStack | A FIFO stack based on a singly-linked list |

IDLList | Intrusive doubly-linked list |

ISLList | Intrusive singly-linked list |

LIFOStack | A LIFO stack based on a singly-linked list |

SLList | Non-intrusive singly-linked list |

SLPtrList | Non-intrusive singly-linked pointer list |

UIDLList | Intrusive doubly-linked list |

BiIndirectList | Indexes into negList (negative index) or posList (zero or positive index) |

BinSum | Sums into bins |

Distribution | Accumulating histogram of component values. Specified bin resolution, automatic generation of bins |

DynamicList | A 1D vector of objects of type <T> that resizes itself as necessary to accept the new objects |

FixedList | A 1D vector of objects of type <T> with a fixed size <Size> |

Hash | Hashing function class |

Histogram | Calculates the counts per bin of a list |

IndirectListAddressing | A helper class for storing addresses |

IndirectList | A List with indirect addressing |

PtrList | A templated 1D list of pointers to objects of type <T>, where the size of the array is known and used for subscript bounds checking, etc |

iterator | An STL-conforming iterator |

SortableList | A list that is sorted upon construction or when explicitly requested with the sort() method |

accessOp | |

offsetOp | |

ListAppendEqOp | Helper class for list to append y onto the end of x |

PackedBoolList | A bit-packed bool list |

PackedList | A dynamically allocatable list of packed unsigned integers |

const_iterator | The const_iterator for PackedList |

iterator | Used for PackedList |

iteratorBase | The iterator base for PackedList |

PackedListCore | Template-invariant bits for PackedList |

autoPtr | An auto-pointer similar to the STL auto_ptr but with automatic casting to a reference to the type and with pointer allocation checking on access |

tmp | A class for managing temporary objects |

ParSortableList | Implementation of PSRS parallel sorting routine |

SubList | A List obtained as a section of another List |

UPtrList | A templated 1D list of pointers to objects of type <T>, where the size of the array is known and used for subscript bounds checking, etc |

iterator | An STL iterator |

NamedEnum | Initialise the NamedEnum HashTable from the static list of names |

Callback | Abstract class to handle automatic call-back registration with the CallbackRegistry. Derive from this class and extend by adding the appropriate callback functions |

CallbackRegistry | Base class with which callbacks are registered |

dictionaryName | |

dictionary | A list of keyword definitions, which are a keyword followed by any number of values (e.g. words and numbers). The keywords can represent patterns which are matched using Posix regular expressions. The general order for searching is as follows: |

dictionaryEntry | A keyword and a list of tokens is a 'dictionaryEntry' |

entry | A keyword and a list of tokens is an 'entry' |

functionEntry | A functionEntry causes entries to be added/manipulated on the specified dictionary given an input stream |

primitiveEntry | A keyword and a list of tokens is a 'primitiveEntry'. An primitiveEntry can be read, written and printed, and the types and values of its tokens analysed |

codedBase | Base class for function objects and boundary conditions using dynamic code |

dlLibraryTable | A table of dynamically loaded libraries |

dynamicCode | Tools for handling dynamic code compilation |

dynamicCodeContext | Encapsulation of dynamic code dictionaries |

CocoParserErrors | Templated class to shadow the error handling for Coco/R parsers |

error | Class to handle errors and exceptions in a simple, consistent stream-based manner |

IOerror | Report an I/O error |

errorManip | 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) |

errorManipArg | ErrorManipArg |

messageStream | Class to handle messaging in a simple, consistent stream-based manner |

StaticAssertionFailed | Forward declaration of StaticAssertionFailed |

StaticAssertionFailed< true > | Specialization for successful assertions |

StaticAssertionTest | Helper class for handling static assertions |

functionObject | Abstract base-class for Time/database function objects |

iNew | Return a pointer to a new functionObject created on freestore |

functionObjectFile | Base class for output file data handling |

functionObjectList | List of function objects with start(), execute() and end() functions that is called for each object |

IOOutputFilter | IOdictionary wrapper around OutputFilter to allow them to read from their associated dictionaries |

OutputFilterFunctionObject | A functionObject wrapper around OutputFilter to allow them to be created via the functions entry within controlDict |

outputFilterOutputControl | An output control for function objects. The default is time-step execution at every interval |

IOobject | IOobject defines the attributes of an object for which implicit objectRegistry management is supported, and provides the infrastructure for performing stream I/O |

IOobjectList | List of IOobjects with searching and retrieving facilities |

CompactIOField | 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 |

CompactIOList | 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 |

IOdictionary | IOdictionary is derived from dictionary and IOobject to give the dictionary automatic IO functionality via the objectRegistry. To facilitate IO, IOdictioanry is provided with a constructor from IOobject and writeData and write functions |

IOField | A primitive field of type <T> with automated input and output |

IOList | A List of objects of type <T> with automated input and output |

IOMap | A Map of objects of type <T> with automated input and output |

IOPtrList | A PtrList of objects of type <T> with automated input and output |

IFstreamAllocator | A std::istream with ability to handle compressed files |

IFstream | Input from file stream |

OFstreamAllocator | A std::ostream with ability to handle compressed files |

OFstream | Output to file stream |

sha1streambuf | A streambuf class for calculating SHA1 digests |

osha1stream | A basic output stream for calculating SHA1 digests |

OSHA1stream | The output stream for calculating SHA1 digests |

INew | A helper class when constructing from an Istream or dictionary |

InfoProxy | A helper class for outputting values to Ostream |

Smanip | |

Imanip | |

Omanip | |

IOstream | An IOstream is an abstract base class for all input/output systems; be they streams, files, token lists etc |

versionNumber | Version number type |

Istream | 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 |

Ostream | An Ostream is an abstract base class for all output systems (streams, files, token lists, etc) |

IPstream | Input inter-processor communications stream |

OPstream | Output inter-processor communications stream |

Pstream | Inter-processor communications stream |

PstreamBuffers | Buffers for inter-processor communications streams (UOPstream, UIPstream) |

UIPstream | Input inter-processor communications stream operating on external buffer |

UOPstream | Output inter-processor communications stream operating on external buffer |

UPstream | Inter-processor communications stream |

commsStruct | Structure for communicating between processors |

communicator | Helper class for allocating/freeing communicators |

listEq | CombineReduce operator for lists. Used for counting |

ISstream | Generic input stream |

OSstream | Generic output stream |

prefixOSstream | Version of OSstream which prints a prefix on each line |

IStringStream | Input from memory buffer stream |

OStringStream | Output to memory buffer stream |

token | A token holds items read from Istream |

Compound | A templated class for holding compound tokens |

compound | Abstract base class for complex tokens |

ITstream | Input token stream |

objectRegistry | Registry of regIOobjects |

regIOobject | RegIOobject is an abstract class derived from IOobject to handle automatic object registration with the objectRegistry |

instant | An instant of time. Contains the time value and name |

less | Less function class used in sorting instants |

subCycleTime | A class for managing sub-cycling times |

Time | Class to control time during OpenFOAM simulations that is also the top-level objectRegistry |

TimePaths | A class for addressing time paths without using the Time class |

timeSelector | A List of scalarRange for selecting times |

TimeState | The time value with time-stepping information, user-defined remapping, etc |

dimensioned | Generic dimensioned Type class |

dimensionSet | Dimension set for the base types |

addDimensionSetsToDebug | Helper class to |

dimensionSets | |

cloud | A cloud is a collection of lagrangian particles |

DimensionedField | Field with dimensions and associated with geometry type GeoMesh which is used to size the field and a reference to it is maintained |

reuseTmpDimensionedField | |

reuseTmpDimensionedField< TypeR, TypeR, GeoMesh > | |

reuseTmpTmpDimensionedField | |

reuseTmpTmpDimensionedField< TypeR, Type1, Type12, TypeR, GeoMesh > | |

reuseTmpTmpDimensionedField< TypeR, TypeR, TypeR, Type2, GeoMesh > | |

reuseTmpTmpDimensionedField< TypeR, TypeR, TypeR, TypeR, GeoMesh > | |

SubDimensionedField | SubDimensionedField is a DimensionedField obtained as a section of another DimensionedField |

FieldField | Generic field type |

reuseTmpFieldField | |

reuseTmpFieldField< Field, TypeR, TypeR > | |

reuseTmpTmpFieldField | |

reuseTmpTmpFieldField< Field, TypeR, Type1, Type12, TypeR > | |

reuseTmpTmpFieldField< Field, TypeR, TypeR, TypeR, Type2 > | |

reuseTmpTmpFieldField< Field, TypeR, TypeR, TypeR, TypeR > | |

oneFieldField | 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 |

zeroFieldField | 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 |

DynamicField | Dynamically sized Field |

directFieldMapper | FieldMapper with direct mapping |

Field | Pre-declare SubField and related Field type |

SubField | Pre-declare related SubField type |

FieldMapper | Abstract base class to hold the Field mapping addressing and weights |

reuseTmp | |

reuseTmp< TypeR, TypeR > | |

reuseTmpTmp | |

reuseTmpTmp< TypeR, Type1, Type12, TypeR > | |

reuseTmpTmp< TypeR, TypeR, TypeR, Type2 > | |

reuseTmpTmp< TypeR, TypeR, TypeR, TypeR > | |

oneField | 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 |

UniformField | A class representing the concept of a uniform field which stores only the single value and providing the operator[] to return it |

zeroField | 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 |

reuseTmpGeometricField | |

reuseTmpGeometricField< TypeR, TypeR, PatchField, GeoMesh > | |

reuseTmpTmpGeometricField | |

reuseTmpTmpGeometricField< TypeR, Type1, Type12, TypeR, PatchField, GeoMesh > | |

reuseTmpTmpGeometricField< TypeR, TypeR, TypeR, Type2, PatchField, GeoMesh > | |

reuseTmpTmpGeometricField< TypeR, TypeR, TypeR, TypeR, PatchField, GeoMesh > | |

MapInternalField | Generic internal field mapper. For "real" mapping, add template specialisations for mapping of internal fields depending on mesh type |

geometricOneField | 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 |

geometricZeroField | A class representing the concept of a GeometricField of 1 used to avoid unnecessary manipulations for objects which are known to be zero at compile-time |

basicSymmetryPointPatchField | A Symmetry boundary condition for pointField |

calculatedPointPatchField | A calculated boundary condition for pointField |

coupledPointPatchField | A Coupled boundary condition for pointField |

fixedValuePointPatchField | A FixedValue boundary condition for pointField |

valuePointPatchField | Foam::valuePointPatchField |

zeroGradientPointPatchField | Foam::zeroGradientPointPatchField |

cyclicPointPatchField | Cyclic front and back plane patch field |

cyclicSlipPointPatchField | Cyclic + slip constraints |

emptyPointPatchField | An empty boundary condition for pointField |

nonuniformTransformCyclicPointPatchField | Cyclic + slip constraints |

processorPointPatchField | Foam::processorPointPatchField |

processorCyclicPointPatchField | Foam::processorCyclicPointPatchField |

symmetryPointPatchField | A Symmetry boundary condition for pointField |

symmetryPlanePointPatchField | A symmetry-plane boundary condition for pointField |

wedgePointPatchField | Wedge front and back plane patch field |

codedFixedValuePointPatchField | Constructs on-the-fly a new boundary condition (derived from fixedValuePointPatchField) which is then used to evaluate |

fixedNormalSlipPointPatchField | Slip with user-specified normal |

slipPointPatchField | Foam::slipPointPatchField |

timeVaryingUniformFixedValuePointPatchField | A time-varying form of a uniform fixed value boundary condition |

uniformFixedValuePointPatchField | Enables the specification of a uniform fixed value boundary condition |

directPointPatchFieldMapper | Direct pointPatchFieldMapper |

pointConstraint | Accumulates point constraints through successive applications of the applyConstraint function |

combineConstraintsEqOp | Reduce operator |

pointPatchFieldMapper | Foam::pointPatchFieldMapper |

pointPatchFieldMapperPatchRef | Foam::pointPatchFieldMapperPatchRef |

UniformDimensionedField | 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 |

argList | Extract command arguments and options from the supplied argc and argv parameters |

ParRunControl | Helper class for initializing parallel jobs from the command arguments |

clock | Read access to the system clock with formatting |

simpleObjectRegistryEntry | |

simpleObjectRegistry | Object registry for simpleRegIOobject. Maintains ordering |

simpleRegIOobject | Abstract base class for registered object with I/O. Used in debug symbol registration |

JobInfo | Helper class for recording information about run/finished jobs |

curve | A single curve in a graph |

curveStyle | The style (line, symbol, etc) of a curve |

graph | Class to create, store and output qgraph files |

writer | Abstract base class for a graph writer |

gnuplotGraph | Output in gnuplot (http://www.gnuplot.info) format |

jplotGraph | Jplot graph output |

rawGraph | A raw xy graph output |

xmgrGraph | Output and agr file for xmgrace (http://plasma-gate.weizmann.ac.il/Grace/) |

interpolation2DTable | 2D table interpolation. The data must be in ascending order in both dimensions x and y |

interpolationLookUpTable | A list of lists. Interpolates based on the first dimension. The values must be positive and monotonically increasing in each dimension |

interpolationTable | An interpolation/look-up table of scalar vs <Type> values. The reference scalar values must be monotonically increasing |

csvTableReader | Reads an interpolation table from a file - CSV-format |

openFoamTableReader | Reads an interpolation table from a file - OpenFOAM-format |

tableReader | Base class to read table data for the interpolationTable |

interpolationWeights | Abstract base class for interpolating in 1D |

linearInterpolationWeights | |

splineInterpolationWeights | Catmull-Rom spline interpolation |

PatchToPatchInterpolation | Interpolation class dealing with transfer of data between two primitivePatches |

PrimitivePatchInterpolation | Interpolation class within a primitive patch. Allows interpolation from points to faces and vice versa |

uniformInterpolationTable | Table with uniform interval in independant variable, with linear interpolation |

Matrix | A templated 2D matrix of objects of <T>, where the n x m matrix dimensions are known and used for subscript bounds checking, etc |

DiagonalMatrix | DiagonalMatrix<Type> is a 2D diagonal matrix of objects of type Type, size nxn |

lduAddressing | The class contains the addressing required by the lduMatrix: upper, lower and losort |

cyclicLduInterface | An abstract base class for cyclic coupled interfaces |

lduInterface | An abstract base class for implicitly-coupled interfaces e.g. processor and cyclic patches |

processorLduInterface | An abstract base class for processor coupled interfaces |

cyclicLduInterfaceField | Abstract base class for cyclic coupled interfaces |

lduInterfaceField | An abstract base class for implicitly-coupled interface fields e.g. processor and cyclic patch fields |

processorLduInterfaceField | Abstract base class for processor coupled interfaces |

lduScheduleEntry | Struct to hold the patch index and the initialisation flag for the patch schedule |

lduMatrix | 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 |

preconditioner | Abstract base-class for lduMatrix preconditioners |

smoother | Abstract base-class for lduMatrix smoothers |

solver | Abstract base-class for lduMatrix solvers |

diagonalPreconditioner | Diagonal preconditioner for both symmetric and asymmetric matrices |

DICPreconditioner | Simplified diagonal-based incomplete Cholesky preconditioner for symmetric matrices (symmetric equivalent of DILU). The reciprocal of the preconditioned diagonal is calculated and stored |

DILUPreconditioner | Simplified diagonal-based incomplete LU preconditioner for asymmetric matrices. The reciprocal of the preconditioned diagonal is calculated and stored |

FDICPreconditioner | Faster version of the DICPreconditioner diagonal-based incomplete Cholesky preconditioner for symmetric matrices (symmetric equivalent of DILU) in which the the reciprocal of the preconditioned diagonal and the upper coefficients divided by the diagonal are calculated and stored |

GAMGPreconditioner | Geometric agglomerated algebraic multigrid preconditioner |

noPreconditioner | Null preconditioner for both symmetric and asymmetric matrices |

DICSmoother | Simplified diagonal-based incomplete Cholesky smoother for symmetric matrices |

DICGaussSeidelSmoother | 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 |

DILUSmoother | Simplified diagonal-based incomplete LU smoother for asymmetric matrices |

DILUGaussSeidelSmoother | 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 |

FDICSmoother | Simplified diagonal-based incomplete Cholesky smoother for symmetric matrices |

GaussSeidelSmoother | A lduMatrix::smoother for Gauss-Seidel |

nonBlockingGaussSeidelSmoother | 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 |

symGaussSeidelSmoother | A lduMatrix::smoother for symmetric Gauss-Seidel |

BICCG | Diagonal incomplete LU preconditioned BiCG solver derived from the general preconditioned BiCG solver PBiCG but with the choice of preconditioner pre-selected |

diagonalSolver | Foam::diagonalSolver |

algebraicPairGAMGAgglomeration | Agglomerate using the pair algorithm |

dummyAgglomeration | Agglomerate without combining cells. Used for testing |

GAMGAgglomeration | Geometric agglomerated algebraic multigrid agglomeration class |

pairGAMGAgglomeration | Agglomerate using the pair algorithm |

eagerGAMGProcAgglomeration | 'Eager' processor agglomeration of GAMGAgglomerations: at every level agglomerates 'mergeLevels' number of processors onto the minimum processor number |

GAMGProcAgglomeration | Processor agglomeration of GAMGAgglomerations |

manualGAMGProcAgglomeration | Manual processor agglomeration of GAMGAgglomerations |

masterCoarsestGAMGProcAgglomeration | Processor agglomeration of GAMGAgglomerations |

noneGAMGProcAgglomeration | Processor agglomeration of GAMGAgglomerations |

procFacesGAMGProcAgglomeration | 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 |

GAMGSolver | Geometric agglomerated algebraic multigrid solver |

cyclicGAMGInterfaceField | GAMG agglomerated cyclic interface field |

GAMGInterfaceField | Abstract base class for GAMG agglomerated interface fields |

processorCyclicGAMGInterfaceField | GAMG agglomerated processor interface field |

processorGAMGInterfaceField | GAMG agglomerated processor interface field |

cyclicGAMGInterface | GAMG agglomerated cyclic interface |

GAMGInterface | Abstract base class for GAMG agglomerated interfaces |

processorCyclicGAMGInterface | GAMG agglomerated processor interface |

processorGAMGInterface | GAMG agglomerated processor interface |

ICCG | Incomplete Cholesky preconditioned CG solver derived from the general preconditioned CG solver PCG but with the choice of preconditioner pre-selected |

PBiCG | Preconditioned bi-conjugate gradient solver for asymmetric lduMatrices using a run-time selectable preconditiioner |

PCG | Preconditioned conjugate gradient solver for symmetric lduMatrices using a run-time selectable preconditioner |

smoothSolver | Iterative solver for symmetric and asymetric matrices which uses a run-time selected smoother e.g. GaussSeidel to converge the solution to the required tolerance |

LduInterfaceField | An abstract base class for implicitly-coupled interface fields e.g. processor and cyclic patch fields |

LduInterfaceFieldPtrsList | |

LduMatrix | 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 |

preconditioner | Abstract base-class for LduMatrix preconditioners |

smoother | Abstract base-class for LduMatrix smoothers |

solver | Abstract base-class for LduMatrix solvers |

Amultiplier | |

SolverPerformance | SolverPerformance is the class returned by the LduMatrix solver containing performance statistics |

DiagonalPreconditioner | Diagonal preconditioner for both symmetric and asymmetric matrices |

TDILUPreconditioner | Simplified diagonal-based incomplete LU preconditioner for asymmetric matrices |

NoPreconditioner | Null preconditioner for both symmetric and asymmetric matrices |

TGaussSeidelSmoother | Foam::TGaussSeidelSmoother |

DiagonalSolver | Foam::DiagonalSolver |

PBiCCCG | Preconditioned bi-conjugate gradient solver for asymmetric lduMatrices using a run-time selectable preconditiioner |

PBiCICG | Preconditioned bi-conjugate gradient solver for asymmetric lduMatrices using a run-time selectable preconditiioner |

PCICG | Preconditioned conjugate gradient solver for symmetric lduMatrices using a run-time selectable preconditiioner |

SmoothSolver | Iterative solver for symmetric and assymetric 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 |

LUscalarMatrix | Foam::LUscalarMatrix |

procLduInterface | IO interface for processorLduInterface |

procLduMatrix | I/O for lduMatrix and interface values |

RectangularMatrix | A templated 2D rectangular matrix of objects of <T>, where the n x n matrix dimension is known and used for subscript bounds checking, etc |

SVD | Singular value decomposition of a rectangular matrix |

simpleMatrix | A simple square matrix solver with scalar coefficients |

solution | Selector class for relaxation factors, solver type and solution |

SquareMatrix | A templated 2D square matrix of objects of <T>, where the n x n matrix dimension is known and used for subscript bounds checking, etc |

SymmetricSquareMatrix | A templated 2D square symmetric matrix of objects of <T>, where the n x n matrix dimension is known and used for subscript bounds checking, etc |

tolerances | Selector class for solution tolerances |

refCount | Reference counter for various OpenFOAM components |

Xfer | A simple container for copying or transferring objects of type <T> |

boundBox | A bounding box defined in terms of the points at its extremities |

data | Database for solution data, solver performance and other reduced data |

GeoMesh | Generic mesh wrapper used by volMesh, surfaceMesh, pointMesh etc |

DynamicID | A class that holds the data needed to identify things (zones, patches) in a dynamic mesh |

coupleGroupIdentifier | Encapsulates using patchGroups to specify coupled patch |

patchIdentifier | Identifies patch by name, patch index and physical type |

lduMesh | Abstract base class for meshes which provide LDU addressing for the construction of lduMatrix and LDU-solvers |

procLess | Less operator for pairs of <processor><index> |

lduPrimitiveMesh | Simplest contrete lduMesh which stores the addressing needed by lduMatrix |

MeshObject | Templated abstract base-class for optional mesh objects used to automate their allocation to the mesh database and the mesh-modifier event-loop |

meshObject | |

TopologicalMeshObject | |

GeometricMeshObject | |

MoveableMeshObject | |

UpdateableMeshObject | |

cell | A cell is defined as a list of faces with extra functionality |

cellMatcher | 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 |

degenerateMatcher | Collection of all hex degenerate matchers (hex, wedge, prism etc.) Has static member function to match a shape |

hexMatcher | A cellMatcher for hex cells |

prismMatcher | A cellMatcher for prism cells |

pyrMatcher | A cellMatcher for pyr cells |

tetMatcher | A cellMatcher for tet cells |

tetWedgeMatcher | A cellMatcher for tetWedge cells |

wedgeMatcher | A cellMatcher for wedge cells |

cellModel | Maps a geometry to a set of cell primitives, which enables geometric cell data to be calculated without access to the primitive geometric level. This means mapping a 3D geometry to a set of pyramids which are each described by a cell face and the cell centre point |

cellModeller | A static collection of cell models, and a means of looking them up |

cellShape | An analytical geometric cellShape |

edge | An edge is a list of two point labels. The functionality it provides supports the discretisation on a 2-D flat mesh |

EdgeMap | Map from edge (expressed as its endpoints) to value |

face | A face is a list of labels corresponding to mesh vertices |

offsetOp< face > | Hash specialization to offset faces in ListListOps::combineOffset |

oppositeFace | Class containing opposite face for a prismatic cell with addressing and a possibility of failure |

tetCell | A tetrahedral cell primitive |

triFace | A triangular face using a FixedList of labels corresponding to mesh vertices |

offsetOp< triFace > | Hash specialization to offset faces in ListListOps::combineOffset |

pointBoundaryMesh | Foam::pointBoundaryMesh |

pointMesh | Mesh representing a set of points created from polyMesh |

MapInternalField< Type, MeshMapper, pointMesh > | |

pointBoundaryMeshMapper | Foam::pointBoundaryMeshMapper |

pointMapper | This object provides mapping and fill-in information for point data between the two meshes after the topological change. It is constructed from mapPolyMesh |

pointMeshMapper | Class holds all the necessary information for mapping fields associated with pointMesh |

pointPatchMapper | Mapping class for a pointPatchField |

coupledPointPatch | Coupled patch for post-processing. Used as the base class for processor and cyclic pointPatches |

genericPointPatch | Substitute for unknown patches. Used for postprocessing when only basic polyPatch info is needed |

cyclicPointPatch | Cyclic patch for post-processing |

cyclicSlipPointPatch | Cyclic patch with slip constraint |

emptyPointPatch | Empty plane patch |

nonuniformTransformCyclicPointPatch | Cyclic patch with slip constraint |

processorPointPatch | Processor patch boundary needs to be such that the ordering of points in the patch is the same on both sides |

processorCyclicPointPatch | Processor patch boundary needs to be such that the ordering of points in the patch is the same on both sides |

symmetryPointPatch | Symmetry patch for non-planar or multi-plane patches |

symmetryPlanePointPatch | Symmetry-plane patch |

wedgePointPatch | Wedge front and back plane patch |

coupledFacePointPatch | Coupled patch for post-processing. Used as the base class for processor and cyclic pointPatches |

wallPointPatch | Foam::wallPointPatch |

facePointPatch | A pointPatch based on a polyPatch |

pointPatch | Basic pointPatch represents a set of points from the mesh |

globalIndex | Calculates a unique integer (label so might not have enough room - 2G max) for processor + local index. E.g |

globalMeshData | Various mesh related information for a parallel run. Upon construction, constructs all info using parallel communication |

ListPlusEqOp | |

globalPoints | Calculates points shared by more than two processor patches or cyclic patches |

cellMapper | This object provides mapping and fill-in information for cell data between the two meshes after the topological change. It is constructed from mapPolyMesh |

faceMapper | This object provides mapping and fill-in information for face data between the two meshes after the topological change. It is constructed from mapPolyMesh |

mapAddedPolyMesh | 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 |

mapDistribute | Class containing processor-to-processor mapping information |

transform | Default transformation behaviour |

transformPosition | Default transformation behaviour for position |

mapDistributeLagrangian | Class containing mesh-to-mesh mapping information for particles |

mapDistributePolyMesh | 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 |

mapPatchChange | Class containing mesh-to-mesh mapping information after a patch change operation |

mapPolyMesh | Class containing mesh-to-mesh mapping information after a change in polyMesh topology |

mapSubsetMesh | Class containing mesh-to-mesh mapping information after a subset operation |

morphFieldMapper | Abstract base class to hold the Field mapping for mesh morphs |

objectMap | An objectMap is a pair of labels defining the mapping of an object from another object, e.g. a cell mapped from a point |

polyBoundaryMesh | Foam::polyBoundaryMesh |

polyBoundaryMeshEntries | Foam::polyBoundaryMeshEntries |

polyMesh | Mesh consisting of general polyhedral cells |

polyMeshTools | |

polyMeshTetDecomposition | 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 |

tetIndices | Storage and named access for the indices of a tet which is part of the decomposition of a cell |

coupledPolyPatch | The coupledPolyPatch is an abstract base class for patches that couple regions of the computational domain e.g. cyclic and processor-processor links |

genericPolyPatch | Substitute for unknown patches. Used for postprocessing when only basic polyPatch info is needed |

cyclicPolyPatch | Cyclic plane patch |

cyclicSlipPolyPatch | Copy of cyclicSlip - used to be able to instantiate cyclicSlip pointPatch which is cyclicSlip with slip constraints |

emptyPolyPatch | Empty front and back plane patch. Used for 2-D geometries |

nonuniformTransformCyclicPolyPatch | Transform boundary used in extruded regions. Allows non-uniform transforms. Wip |

oldCyclicPolyPatch | '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) |

processorPolyPatch | Neighbour processor patch |

processorCyclicPolyPatch | Neighbour processor patch |

symmetryPolyPatch | Symmetry patch for non-planar or multi-plane patches |

symmetryPlanePolyPatch | Symmetry-plane patch |

wedgePolyPatch | Wedge front and back plane patch |

wallPolyPatch | Foam::wallPolyPatch |

polyPatch | A patch is a list of labels that address the faces in the global face list |

dummyTransform | |

pTraits< List< T > > | |

pTraits< UList< T > > | |

pTraits< Field< T > > | |

pTraits< face > | |

syncTools | Various tools to aid synchronizing lists across coupled patches. WIP |

cellZone | A subset of mesh cells |

faceZone | A subset of mesh faces organised as a primitive patch |

pointZone | A subset of mesh points. The labels of points in the zone can be obtained from the addressing() list |

zone | Base class for zones |

ZoneMesh | A list of mesh zones |

PatchTools | A collection of tools for searching, sorting PrimitivePatch information |

primitiveMesh | Cell-face mesh analysis engine |

primitiveMeshTools | |

patchZones | Calculates zone number for every face of patch |

walkPatch | Collection of static functions to do various simple patch related things |

PrimitivePatch | A list of faces which address into the list of points |

line | A line primitive |

objectHit | This class describes a combination of target object index and success flag |

PointHit | This class describes the interaction of a face and a point. It carries the info of a successful hit and (if successful), returns the interaction point |

pointHitSort | Container for sorting intersections |

PointIndexHit | 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 |

plane | Geometric class that creates a 2D plane and can return the intersection point between a line and the plane |

ray | A direction and a reference point |

pyramid | 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 |

tetPoints | Tet storage. Null constructable (unfortunately tetrahedron<point, point> is not) |

tetrahedron | A tetrahedron primitive |

dummyOp | Dummy |

storeOp | Store resulting tets |

sumVolOp | Sum resulting volumes |

intersection | Foam::intersection |

triangle | A triangle primitive used to calculate face normals and swept volumes |

commSchedule | Determines the order in which a set of processors should communicate with one another |

ProcessorTopology | Determines processor-processor connection. After instantiation contains on all processors the processor-processor connection table |

treeBoundBox | Standard boundBox + extra functionality for use in octree |

pTraits< bool > | |

Switch | A simple wrapper around bool so that it can be read as a word: true/false, on/off, yes/no, y/n, t/f, or none |

complex | Extension to the c++ complex library type |

Tensor | Templated 3D tensor derived from VectorSpace adding construction from 9 components, element access using xx(), xy() etc. member functions and the inner-product (dot-product) and outer-product of two Vectors (tensor-product) operators |

Pair | An ordered pair of two objects of type <T> with first() and second() elements |

demandDrivenEntry | Class for demand-driven dictionary entries |

DiagTensor | Templated 3D DiagTensor derived from VectorSpace |

CompatibilityConstant | Templated basic entry that holds a constant value for backwards compatibility (when DataEntry type is not present) |

Constant | Templated basic entry that holds a constant value |

CSV | Templated CSV container data entry. Reference column is always a scalar, e.g. time |

DataEntry | 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 |

polynomial | Polynomial container data entry for scalars. Items are stored in a list of Tuple2's. Data is input in the form, e.g. for an entry <entryName> that describes y = x^2 + 2x^3 |

Table | Templated table container data entry. Items are stored in a list of Tuple2's. First column is always stored as scalar entries. Data is read in Tuple2 form, e.g. for an entry <entryName> that is (scalar, vector): |

TableBase | Base class for table with bounds handling, interpolation and integration |

TableFile | Templated table container data entry where data is read from file |

Polynomial | Polynomial templated on size (order): |

polynomialFunction | Polynomial function representation |

globalIndexAndTransform | 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 |

less | Less function class used in sorting encoded transforms and indices |

vectorTensorTransform | Vector-tensor class used to perform translations and rotations in 3D space |

Hash | Hash function class for primitives. All non-primitives used to hash entries on hash tables likely need a specialized version of this class |

Hash< Foam::label > | Hash specialization for hashing labels |

Hash< Foam::string > | Hash specialization for hashing strings |

Hash< Foam::word > | Hash specialization for hashing words |

Hash< Foam::fileName > | Hash specialization for hashing fileNames |

Hash< Foam::wordRe > | Hash specialization for hashing wordRes |

Hash< Foam::keyType > | Hash specialization for hashing keyTypes |

Hash< void * > | Hash specialization for hashing pointer addresses |

SHA1 | Functions to compute SHA1 message digest according to the NIST specification FIPS-180-1 |

SHA1Digest | The SHA1 message digest |

pTraits< label > | Template specialization for pTraits<label> |

pTraits< int > | Template specialization for pTraits<int> |

pTraits< uLabel > | Template specialization for pTraits<uLabel> |

nil | A zero-sized class without any storage. Used, for example, in HashSet |

one | A class representing the concept of 1 (scalar(1.0)) used to avoid unnecessary manipulations for objects which are known to be one at compile-time |

eqOp2 | |

eqOp | |

plusEqOp2 | |

plusEqOp | |

minusEqOp2 | |

minusEqOp | |

multiplyEqOp2 | |

multiplyEqOp | |

divideEqOp2 | |

divideEqOp | |

eqMagOp2 | |

eqMagOp | |

plusEqMagSqrOp2 | |

plusEqMagSqrOp | |

maxEqOp2 | |

maxEqOp | |

minEqOp2 | |

minEqOp | |

minMagSqrEqOp2 | |

minMagSqrEqOp | |

maxMagSqrEqOp2 | |

maxMagSqrEqOp | |

andEqOp2 | |

andEqOp | |

orEqOp2 | |

orEqOp | |

eqMinusOp2 | |

eqMinusOp | |

nopEqOp2 | |

nopEqOp | |

sumOp3 | |

sumOp2 | |

sumOp | |

plusOp3 | |

plusOp2 | |

plusOp | |

minusOp3 | |

minusOp2 | |

minusOp | |

multiplyOp3 | |

multiplyOp2 | |

multiplyOp | |

divideOp3 | |

divideOp2 | |

divideOp | |

cmptMultiplyOp3 | |

cmptMultiplyOp2 | |

cmptMultiplyOp | |

cmptDivideOp3 | |

cmptDivideOp2 | |

cmptDivideOp | |

stabiliseOp3 | |

stabiliseOp2 | |

stabiliseOp | |

maxOp3 | |

maxOp2 | |

maxOp | |

minOp3 | |

minOp2 | |

minOp | |

minMagSqrOp3 | |

minMagSqrOp2 | |

minMagSqrOp | |

maxMagSqrOp3 | |

maxMagSqrOp2 | |

maxMagSqrOp | |

minModOp3 | |

minModOp2 | |

minModOp | |

andOp3 | |

andOp2 | |

andOp | |

orOp3 | |

orOp2 | |

orOp | |

eqEqOp3 | |

eqEqOp2 | |

eqEqOp | |

lessOp3 | |

lessOp2 | |

lessOp | |

lessEqOp3 | |

lessEqOp2 | |

lessEqOp | |

greaterOp3 | |

greaterOp2 | |

greaterOp | |

greaterEqOp3 | |

greaterEqOp2 | |

greaterEqOp | |

multiplyWeightedOp | |

pTraits | Traits class for primitives |

quaternion | Quaternion class used to perform rotations in 3D space |

cachedRandom | Random number generator |

Random | Simple random number generator |

labelRange | A label range specifier |

const_iterator | An STL const_iterator |

less | Less function class for sorting labelRange |

labelRanges | A list of labelRange |

const_iterator | An STL const_iterator |

scalarRange | A scalar range specifier |

scalarRanges | A List of scalarRange |

typeOfRank< Cmpt, 0 > | |

symmTypeOfRank< Cmpt, 0 > | |

septernion | Septernion class used to perform translations and rotations in 3D space |

SphericalTensor | Templated 3D SphericalTensor derived from VectorSpace adding construction from 1 component, element access using th ii() member function and the inner-product (dot-product) and outer-product operators |

outerProduct< SphericalTensor< Cmpt >, Cmpt > | |

outerProduct< Cmpt, SphericalTensor< Cmpt > > | |

innerProduct< SphericalTensor< Cmpt >, SphericalTensor< Cmpt > > | |

innerProduct< SphericalTensor< Cmpt >, Vector< Cmpt > > | |

innerProduct< Vector< Cmpt >, SphericalTensor< Cmpt > > | |

SphericalTensor2D | Templated 2D sphericalTensor derived from VectorSpace adding construction from 1 component, element access using ii() member function and the inner-product (dot-product) and outer-product operators |

outerProduct< SphericalTensor2D< Cmpt >, Cmpt > | |

outerProduct< Cmpt, SphericalTensor2D< Cmpt > > | |

innerProduct< SphericalTensor2D< Cmpt >, SphericalTensor2D< Cmpt > > | |

innerProduct< SphericalTensor2D< Cmpt >, Vector2D< Cmpt > > | |

innerProduct< Vector2D< Cmpt >, SphericalTensor2D< Cmpt > > | |

fileName | A class for handling file names |

keyType | A class for handling keywords in dictionaries |

hashedWordList | A wordList with hashed indices for faster lookup by name |

wordReListMatcher | A wrapper for matching a List of wordRe |

string | A class for handling character strings derived from std::string |

hash | Hashing function class, shared by all the derived classes |

word | A class for handling words, derived from string |

wordRe | A wordRe is a word, but can also have a regular expression for matching words |

subModelBase | 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 |

SymmTensor | Templated 3D symmetric tensor derived from VectorSpace adding construction from 6 components, element access using xx(), xy() etc. member functions and the inner-product (dot-product) and outer-product of two Vectors (tensor-product) operators |

symmTypeOfRank< Cmpt, 2 > | |

outerProduct< SymmTensor< Cmpt >, Cmpt > | |

outerProduct< Cmpt, SymmTensor< Cmpt > > | |

innerProduct< SymmTensor< Cmpt >, SymmTensor< Cmpt > > | |

innerProduct< SymmTensor< Cmpt >, Vector< Cmpt > > | |

innerProduct< Vector< Cmpt >, SymmTensor< Cmpt > > | |

typeOfSum< SphericalTensor< Cmpt >, SymmTensor< Cmpt > > | |

typeOfSum< SymmTensor< Cmpt >, SphericalTensor< Cmpt > > | |

innerProduct< SphericalTensor< Cmpt >, SymmTensor< Cmpt > > | |

innerProduct< SymmTensor< Cmpt >, SphericalTensor< Cmpt > > | |

SymmTensor2D | Templated 2D symmetric tensor derived from VectorSpace adding construction from 4 components, element access using xx(), xy() etc. member functions and the inner-product (dot-product) and outer-product of two Vectors (tensor-product) operators |

outerProduct< SymmTensor2D< Cmpt >, Cmpt > | |

outerProduct< Cmpt, SymmTensor2D< Cmpt > > | |

innerProduct< SymmTensor2D< Cmpt >, SymmTensor2D< Cmpt > > | |

innerProduct< SymmTensor2D< Cmpt >, Vector2D< Cmpt > > | |

innerProduct< Vector2D< Cmpt >, SymmTensor2D< Cmpt > > | |

typeOfSum< SphericalTensor2D< Cmpt >, SymmTensor2D< Cmpt > > | |

typeOfSum< SymmTensor2D< Cmpt >, SphericalTensor2D< Cmpt > > | |

innerProduct< SphericalTensor2D< Cmpt >, SymmTensor2D< Cmpt > > | |

innerProduct< SymmTensor2D< Cmpt >, SphericalTensor2D< Cmpt > > | |

typeOfRank< Cmpt, 2 > | |

typeOfSum< SphericalTensor< Cmpt >, Tensor< Cmpt > > | |

typeOfSum< Tensor< Cmpt >, SphericalTensor< Cmpt > > | |

innerProduct< SphericalTensor< Cmpt >, Tensor< Cmpt > > | |

innerProduct< Tensor< Cmpt >, SphericalTensor< Cmpt > > | |

typeOfSum< SymmTensor< Cmpt >, Tensor< Cmpt > > | |

typeOfSum< Tensor< Cmpt >, SymmTensor< Cmpt > > | |

innerProduct< SymmTensor< Cmpt >, Tensor< Cmpt > > | |

innerProduct< Tensor< Cmpt >, SymmTensor< Cmpt > > | |

Tensor2D | Templated 2D tensor derived from VectorSpace adding construction from 4 components, element access using xx(), xy(), yx() and yy() member functions and the iner-product (dot-product) and outer-product of two Vector2Ds (tensor-product) operators |

typeOfSum< SphericalTensor2D< Cmpt >, Tensor2D< Cmpt > > | |

typeOfSum< Tensor2D< Cmpt >, SphericalTensor2D< Cmpt > > | |

innerProduct< Tensor2D< Cmpt >, Tensor2D< Cmpt > > | |

innerProduct< SphericalTensor2D< Cmpt >, Tensor2D< Cmpt > > | |

innerProduct< Tensor2D< Cmpt >, SphericalTensor2D< Cmpt > > | |

innerProduct< Tensor2D< Cmpt >, Vector2D< Cmpt > > | |

innerProduct< Vector2D< Cmpt >, Tensor2D< Cmpt > > | |

outerProduct< Vector2D< Cmpt >, Vector2D< Cmpt > > | |

triad | Representation of a 3D Cartesian coordinate system as a Vector of vectors |

Tuple2 | A 2-tuple for storing two objects of different types |

flux | |

flux< scalar > | |

Vector | 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 |

typeOfRank< Cmpt, 1 > | |

symmTypeOfRank< Cmpt, 1 > | |

Vector2D | 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) |

typeOfRank | |

symmTypeOfRank | |

typeOfSum | |

outerProduct | |

crossProduct | |

innerProduct | |

scalarProduct | |

powProduct |