| absorptionCoeffs | |
| absorptionCoeffs | Absorption coefficients class used in greyMeanAbsorptionEmission and wideBandAbsorptionEmission |
| absorptionEmissionModel | Model to supply absorption and emission coefficients for radiation modelling |
| aC10H7CH3 | AlphaMethylNaphthalene |
| AC3DsurfaceFormat< Face > | Provide a means of reading/writing AC3D format |
| AC3DsurfaceFormatCore | Internal class used by the AC3DsurfaceFormat |
| accessOp< T > | |
| activeBaffleVelocityFvPatchVectorField | Boundary condition that modifies mesh areas based on velocity |
| actuationDiskSource | Actuation disk zone definition. Constant values for momentum source for actuation disk |
| addPatchCellLayer | Adds layers of cells to outside of polyPatch |
| addSubtract | Adds/subtracts a field or value to/from a base field |
| topoSetSource::addToUsageTable | Class with constructor to add usage string to table |
| advectiveFvPatchField< Type > | Advective outflow boundary condition based on solving DDt(psi, U) = 0 at the boundary |
| 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 |
| algebraicPairGAMGAgglomeration | Agglomerate using the pair algorithm |
| alphaContactAngleFvPatchScalarField | Abstract base class for alphaContactAngle boundary conditions |
| alphaFixedPressureFvPatchScalarField | A fixed-pressure alphaContactAngle boundary |
| alphaSgsJayatillekeWallFunctionFvPatchScalarField | |
| alphaSgsJayatillekeWallFunctionFvPatchScalarField | Thermal wall function for turbulent thermal diffusivity based on the Jayatilleke thermal wall function |
| alphaSgsWallFunctionFvPatchScalarField | |
| alphaSgsWallFunctionFvPatchScalarField | Boundary condition for thermal diffusivity when using wall functions
- replicates OpenFOAM v1.5 (and earlier) behaviour
|
| alphatWallFunctionFvPatchScalarField | Boundary condition for turbulent thermal diffusivity when using wall functions
- replicates OpenFOAM v1.5 (and earlier) behaviour
- Turbulent Prandtl number defaults to 0.85 if unspecified
|
| Analytical< Type > | Analytical integration |
| andEqOp< T > | |
| andEqOp2< T1, T2 > | |
| andOp< T > | |
| andOp2< T1, T2 > | |
| andOp3< T, T1, T2 > | |
| angularOscillatingDisplacementPointPatchVectorField | Foam::angularOscillatingDisplacementPointPatchVectorField |
| angularOscillatingVelocityPointPatchVectorField | Foam::angularOscillatingVelocityPointPatchVectorField |
| anisotropicFilter | Anisotropic filter |
| APIdiffCoefFunc | API function for vapour mass diffusivity |
| Ar | Liquid Ar |
| arcEdge | Defines the arcEdge of a circle in terms of 3 points on its circumference |
| argList | Extract command arguments and options from the supplied argc and argv parameters |
| ArrheniusReactionRate | Arrhenius reaction rate |
| ash | Coal ash |
| incompressible::atmBoundaryLayerInletEpsilonFvPatchScalarField | |
| atmBoundaryLayerInletEpsilonFvPatchScalarField | Boundary condition specifies a epsilon inlet for the atmospheric boundary layer (ABL). This boundaty is to be used in conjunction with ABLInletVelocity |
| incompressible::atmBoundaryLayerInletVelocityFvPatchVectorField | |
| atmBoundaryLayerInletVelocityFvPatchVectorField | Boundary condition specifies a atmospheric boundary layer (ABL) velocity inlet profile given the friction velocity value, flow direction n and direction of the parabolic coordinate z |
| atomicWeightTable::atomicWeight | Structure to hold the element name and atomic weight pair |
| atomicWeightTable | A table of atomic weights for all the elements |
| atomizationModel | Base class for selecting the atomization model |
| 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 |
| 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 |
| autoHexMeshDriver | Main meshing driver |
| autoLayerDriver | All to do with adding layers |
| autoPtr< T > | 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 |
| autoRefineDriver | |
| autoSnapDriver | All to do with snapping to surface |
| AverageIOField< Type > | A primitive field + average with IO |
| azizChen | Foam::pairPotentials::azizChen |
| backwardDdtScheme< Type > | Second-order backward-differencing ddt using the current and two previous time-step values |
| barotropicCompressibilityModel | Abstract class for barotropic compressibility models |
| basic | Basic sub-grid obstacle drag model. Details supplied by J Puttock 2/7/06 |
| basicChemistryModel | Base class for chemistry models |
| basicKinematicCloud | Cloud class to introduce kinematic parcels |
| basicKinematicParcel | |
| basicMixture | Foam::basicMixture |
| basicMultiComponentMixture | Combustion mixture |
| basicPsiThermo | Basic thermodynamic properties based on compressibility |
| BasicReactingMultiphaseParcel< ThermoType > | |
| BasicReactingParcel< ThermoType > | |
| basicRhoThermo | Basic thermodynamic properties based on density |
| basicSource | Basic source abtract class |
| basicSourceList | List of explict sources |
| basicSubGrid | Basic sub-grid obstacle flame-wrinking enhancement factor model. Details supplied by J Puttock 2/7/06 |
| basicSubGrid | |
| XiGModel::basicSubGrid | Basic sub-grid obstacle flame-wrinking generation rate coefficient model. Details supplied by J Puttock 2/7/06 |
| basicSymmetryFvPatchField< Type > | A symmetry patch |
| basicSymmetryPointPatchField< Type > | A Symmetry boundary condition for pointField |
| basicThermo | Basic thermodynamic properties |
| basicThermoCloud | Cloud class to introduce thermodynamic parcels |
| basicThermoParcel | |
| bC10H7CH3 | BetaMethylNaphthalene |
| BICCG | Diagonal incomplete LU preconditioned BiCG solver derived from the general preconditioned BiCG solver PBiCG but with the choice of preconditioner pre-selected |
| BiIndirectList< T > | Indexes into negList (negative index) or posList (zero or positive index) |
| biLinearFitPolynomial | BiLinear polynomial for interpolation fitting |
| binaryAbsorptionEmission | Radiation coefficient based on two absorption models |
| BinaryCollisionModel< CloudType > | Templated DSMC particle collision class |
| BirdCarreau | An incompressible Bird-Carreau non-Newtonian viscosity model |
| blackBodyEmission | Class black body emission |
| blended< Type > | Linear/upwind blended differencing scheme |
| blobsSheetAtomization | Primary Breakup Model for pressure swirl atomizers |
| blobsSwirlInjector | Model for parcels injection in pressure Swirl Atomizers |
| block | Creates a single block of cells from point coordinates, numbers of cells in each direction and expansion ratio |
| blockDescriptor | Block descriptor. 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 | |
| booleanSurface | Surface-surface intersection. Given two surfaces construct combined surface |
| boundaryCutter | Does modifications to boundary faces |
| 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 |
| boundaryRegion | The boundaryRegion persistent data saved as a Map<dictionary> |
| boundaryToFace | A topoSetSource to select all external (boundary) faces |
| boundBox | A bounding box defined in terms of the points at its extremities |
| boundedBackwardDdtScheme | Second-order bounded-backward-differencing ddt using the current and two previous time-step values |
| boxToCell | A topoSetSource to select cells based on cell centres inside box |
| boxToFace | A topoSetSource to select faces based on face centres inside box |
| boxToPoint | A topoSetSource to select points based on whether they are inside box |
| breakupModel | Base class for selecting a breakup model |
| BSpline | An implementation of B-splines |
| bufferedAccumulator< Type > | |
| buoyantPressureFvPatchScalarField | Set the pressure gradient boundary condition appropriately for buoyant flow |
| C | Graphite |
| C10H22 | NDecane |
| C12H26 | NDodecane |
| C13H28 | NTriDecane |
| C14H30 | NTetraDecane |
| C16H34 | NHexaDecane |
| C2H5OH | Ethanol |
| C2H6 | Ethane |
| C2H6O | DiMethylEther |
| C3H6O | Acetone |
| C3H8 | Propane |
| C4H10O | DiEthylEther |
| C6H14 | NHexane |
| C6H6 | Benzene |
| C7H16 | NHeptane |
| C7H8 | Toluene |
| C8H10 | EthylBenzene |
| C8H18 | NOctane |
| C9H20 | NNonane |
| CaCO3 | Calcium carbonate (limestone) |
| calcType | Base class for post-processing calculation functions |
| calculatedFvPatchField< Type > | Foam::calculatedFvPatchField |
| calculatedFvsPatchField< Type > | Foam::calculatedFvsPatchField |
| calculatedPointPatchField< Type > | A calculated boundary condition for pointField |
| Callback< CallbackType > | Abstract class to handle automatic call-back registration with the CallbackRegistry. Derive from this class and extend by adding the appropriate callback functions |
| CallbackRegistry< CallbackType > | Base class with which callbacks are registered |
| CarnahanStarlingRadial | |
| CatmullRomSpline | An implementation of Catmull-Rom splines (sometimes known as Overhauser splines) |
| CECCellToCellStencil | |
| CECCellToFaceStencil | Combined corresponding cellToCellStencil of owner and neighbour |
| cell | A cell is defined as a list of faces with extra functionality |
| cellClassification | 'Cuts' a mesh with a surface |
| cellCuts | Description of cuts across cells |
| cellDistFuncs | Collection of functions used in wall distance calculation |
| meshReader::cellFaceIdentifier | Identify cell faces in terms of cell Id and face Id |
| cellFeatures | Cell analysis class |
| cellInfo | Holds information regarding type of cell. Used in inside/outside determination in cellClassification |
| cellLimitedGrad< Type > | CellLimitedGrad gradient scheme applied to a runTime selected base gradient scheme |
| cellLooper | Abstract base class. Concrete implementations know how to cut a cell (i.e. determine a loop around the circumference) |
| 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 |
| 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 |
| cellMDLimitedGrad< Type > | CellMDLimitedGrad gradient scheme applied to a runTime selected base gradient scheme |
| 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 |
| cellMotionFvPatchField< Type > | Foam::cellMotionFvPatchField |
| cellPointWeight | Foam::cellPointWeight |
| cellPointWeightWallModified | Foam::cellPointWeightWallModified |
| cellQuality | Class calculates cell quality measures |
| cellSet | A collection of cell labels |
| cellSets | |
| cellShape | An analytical geometric cellShape |
| cellSource | Cell source variant of field value function object. Values of user- specified fields reported for collections of cells |
| cellSplitter | Does pyramidal decomposition of selected cells. So all faces will become base of pyramid with as top a user-supplied point (usually the cell centre) |
| cellTable | The cellTable persistent data saved as a Map<dictionary> |
| cellToCell | A topoSetSource to select the cells from another cellSet |
| cellToCellStencil | Baseclass for extended cell centred addressing. Contains per cell a list of neighbouring cells and/or boundaryfaces in global addressing |
| cellToFace | A topoSetSource to select a faceSet from cells |
| cellToFaceStencil | Baseclass for extended cell-to-facel stencils (face values from neighbouring cells) |
| cellToPoint | A topoSetSource to select points based on usage in cells |
| cellZone | A subset of mesh cells |
| cellZoneSet | Like cellSet but updates cellZone when writing |
| centredCECCellToFaceStencilObject | |
| centredCFCCellToFaceStencilObject | |
| centredCFCFaceToCellStencilObject | |
| centredCPCCellToFaceStencilObject | |
| centredFECCellToFaceStencilObject | |
| CentredFitData< Polynomial > | Data for the quadratic fit correction interpolation scheme |
| CentredFitScheme< Type, Polynomial, Stencil > | Centred fit surface interpolation scheme which applies an explicit correction to linear |
| CFCCellToCellStencil | |
| CFCCellToFaceStencil | Combined corresponding cellToCellStencil of owner and neighbour |
| CFCFaceToCellStencil | |
| CH3OH | Methanol |
| CH4N2O | Urea, note that some of the properties are unavailable in the literature and have been copied from water |
| channelIndex | Does averaging of fields over layers of cells. Assumes layered mesh |
| ChemicallyActivatedReactionRate< ReactionRate, ChemicallyActivationFunction > | General class for handling chemically-activated bimolecular reactions |
| chemistryReader< ThermoType > | Abstract class for reading chemistry |
| chemistrySolver< CompType, ThermoType > | An abstract base class for solving chemistry |
| chemkinReader | Foam::chemkinReader |
| ChomiakInjector | Injector model based on an idea of Jerzy Chomiak |
| Chung | Chung compressibility model |
| clippedLinear< Type > | Central-differencing interpolation scheme using clipped-weights to improve stability on meshes with very rapid variations in cell size |
| clock | Read access to the system clock with formatting |
| clockTime | Starts timing (using rtc) and returns elapsed time from start. Better resolution (2uSec instead of ~20mSec) than cpuTime |
| clockTimeImpl | Starts timing (using rtc) and returns elapsed time from start. Better resolution (2uSec instead of ~20mSec) than cpuTime |
| Cloud< ParticleType > | |
| cloud | A cloud is a collection of lagrangian particles |
| cloudAbsorptionEmission | Retrieves absorption/emission data from a cloud object |
| cloudScatter | Cloud radiation scatter model |
| cloudSet | |
| cmptDivideOp< T > | |
| cmptDivideOp2< T1, T2 > | |
| cmptDivideOp3< T, T1, T2 > | |
| cmptMultiplyOp< T > | |
| cmptMultiplyOp2< T1, T2 > | |
| cmptMultiplyOp3< T, T1, T2 > | |
| CoalParcel< ThermoType > | |
| CoalParcel | |
| CoEulerDdtScheme< Type > | Courant number limited first-order Euler implicit/explicit ddt |
| collisionModel | Base case for selecting a collision model |
| combineFaces | Combines boundary faces into single face. The faces get the patch of the first face ('the master') |
| combineNsTransPs | |
| combustionModel | Base class for all non-premixed combustion models |
| commonRailInjector | Common-rail injector |
| commSchedule | Determines the order in which a set of processors should communicate with one another |
| Pstream::commsStruct | Structure for communicating between processors |
| CompactListList< T > | A packed storage unstructured matrix of objects of type <T> using an offset table for access |
| CompactListList_dev< T, Container > | A packed storage unstructured matrix of objects of type <T> using an offset table for access |
| complex | Extension to the c++ complex library type |
| components | Writes scalar fields corresponding to each component of the supplied field (name) for each time |
| CompositionModel< CloudType > | Templated reacting parcel composition model class Consists of carrier species (via thermo package), and additional liquids and solids |
| token::compound | Abstract base class for complex tokens |
| token::Compound< T > | A templated class for holding compound tokens |
| CompoundToken | An abstract base class for managing compound tokens |
| compressible | Auto creation of fields to provide backwards compatibility with runtime selectable wall functions |
| conductivityModel | |
| ConeInjection< CloudType > | Cone injection |
| ConeInjectionMP< CloudType > | Cone injection multi-point |
| octree< Type >::const_iterator | An STL const_iterator for octree |
| HashTable< T, Key, Hash >::const_iterator | An STL-conforming const_iterator |
| LPtrList< LListBase, T >::const_iterator | An STL-conforming const_iterator |
| LList< LListBase, T >::const_iterator | An STL-conforming const_iterator |
| UILList< LListBase, T >::const_iterator | An STL-conforming const_iterator |
| DLListBase::const_iterator | An STL-conforming const_iterator |
| SLListBase::const_iterator | An STL-conforming const_iterator |
| PackedList< nBits >::const_iterator | The const_iterator for PackedList |
| Constant< Type > | Templated basic entry that holds a constant value |
| constant | Constant laminar flame speed model |
| constantAbsorptionEmission | Constant radiation absorption and emission coefficients for continuous phase |
| constantAlphaContactAngleFvPatchScalarField | A constant alphaContactAngle scalar boundary condition (alphaContactAngleFvPatchScalarField) |
| DsmcParcel< ParcelType >::constantProperties | Class to hold DSMC particle constant properties |
| KinematicParcel< ParcelType >::constantProperties | Class to hold kinematic particle constant properties |
| ReactingMultiphaseParcel< ParcelType >::constantProperties | Class to hold reacting multiphase particle constant properties |
| ReactingParcel< ParcelType >::constantProperties | Class to hold reacting particle constant properties |
| ThermoParcel< ParcelType >::constantProperties | Class to hold thermo particle constant properties |
| molecule::constantProperties | Class to hold molecule constant properties |
| ConstantRateDevolatilisation< CloudType > | Constant rate devolatisation model
- need to set vapourisation temperature to 600 K
|
| constantScatter | Constant radiation scatter coefficient |
| constInjector | Injector model with specified Constant values for the droplet diameter and spray cone angle |
| constTransport< thermo > | Constant properties Transport package. Templated into a given thermodynamics package (needed for thermal conductivity) |
| convectionScheme< Type > | Abstract base class for convection schemes |
| coordinateRotation | A coordinate rotation specified per local axes and the base class for other rotation specifications |
| coordinateSystem | A cartesian coordinate system and the base class for other coordinate system specifications |
| coordinateSystems | Provides a centralized coordinateSystem collection |
| coordSet | Holds list of sampling positions |
| correctedSnGrad< Type > | Simple central-difference snGrad scheme with non-orthogonal correction |
| correlationFunction< Type > | |
| coulomb | |
| coupledFacePair | Data associated with a pair of coupled faces |
| coupledFacePointPatch | Coupled patch for post-processing. Used as the base class for processor and cyclic pointPatches |
| coupledFvPatch | An abstract base class for patches that couple regions of the computational domain e.g. cyclic and processor-processor links |
| coupledFvPatchField< Type > | Foam::coupledFvPatchField |
| coupledFvsPatchField< Type > | Foam::coupledFvsPatchField |
| coupledPointPatch | Coupled patch for post-processing. Used as the base class for processor and cyclic pointPatches |
| coupledPointPatchField< Type > | A Coupled boundary condition for pointField |
| coupledPolyPatch | The coupledPolyPatch is an abstract base class for patches that couple regions of the computational domain e.g. cyclic and processor-processor links |
| COxidationDiffusionLimitedRate< CloudType > | |
| COxidationDiffusionLimitedRate | Diffusion limited rate surface reaction model for coal parcels. Limited to: |
| COxidationKineticDiffusionLimitedRate< CloudType > | |
| COxidationKineticDiffusionLimitedRate | Kinetic/diffusion limited rate surface reaction model for coal parcels. Limited to: |
| COxidationMurphyShaddix< CloudType > | |
| COxidationMurphyShaddix | Limited to C(s) + O2 -> CO2 |
| CPCCellToCellStencil | |
| CPCCellToFaceStencil | Combined corresponding cellToCellStencil of owner and neighbour |
| cpuTime | Starts timing CPU usage and return elapsed time from start |
| cpuTimeImpl | Starts timing CPU usage and return elapsed time from start |
| CrankNicholsonDdtScheme< Type > | Second-oder CrankNicholson implicit ddt using the current and previous time-step fields as well as the previous time-step ddt |
| CrossPowerLaw | An incompressible Cross-Power law non-Newtonian viscosity model |
| crossProduct< arg1, arg2 > | |
| csvSetWriter< Type > | |
| csvTableReader< Type > | |
| cubeRootVolDelta | Simple cube-root of cell volume delta used in LES models |
| cubic< Type > | 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 |
| curve | A single curve in a graph |
| curvedEdge | Define a curved edge that is parameterized for 0<lambda<1 between the start and end point |
| curveSet | |
| curve::curveStyle | The style (line, symbol, etc) of a curve |
| cuttingPlane | Constructs plane through mesh |
| cvsTableReader | Reads an interpolation table from a file - CSV-format |
| cyclicFvPatch | Cyclic-plane patch |
| cyclicFvPatchField< Type > | Foam::cyclicFvPatchField |
| cyclicFvsPatchField< Type > | Foam::cyclicFvsPatchField |
| cyclicGAMGInterface | GAMG agglomerated cyclic interface |
| cyclicGAMGInterfaceField | GAMG agglomerated cyclic interface field |
| cyclicLduInterface | An abstract base class for cyclic coupled interfaces |
| cyclicLduInterfaceField | Abstract base class for cyclic coupled interfaces |
| cyclicPointPatch | Cyclic patch for post-processing |
| cyclicPointPatchField< Type > | Cyclic front and back plane patch field |
| cyclicPolyPatch | Cyclic plane patch |
| 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 |
| cylindricalCS | Cylindrical coordinate system |
| cylindricalInletVelocityFvPatchVectorField | Describes an inlet vector boundary condition in cylindrical coordinates given a central axis, central point, rpm, axial and radial velocity |
| d2dt2Scheme< Type > | Abstract base class for d2dt2 schemes |
| dampedCoulomb | |
| DataEntry< Type > | 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 |
| ddtScheme< Type > | Abstract base class for ddt schemes |
| DeardorffDiffStress | Differential SGS Stress Equation Model for compressible flows |
| DeardorffDiffStress | Differential SGS Stress Equation Model for incompressible flows |
| decompositionMethod | Abstract base class for decomposition |
| definedHollowConeInjector | An injector model for hollow/solid cone injection |
| definedInjector | User specified MFR vs time and velocity vs time |
| definedPressureSwirlInjector | Pressure swirl injector model with user-defined cone-angle/interval vs. time |
| degenerateMatcher | Collection of all hex degenerate matchers (hex, wedge, prism etc.) Has static member function to match a shape |
| DevolatilisationModel< CloudType > | Templated devolatilisation model class |
| DiagonalMatrix< Type > | DiagonalMatrix<Type> is a 2D diagonal matrix of objects of type Type, size nxn |
| diagonalPreconditioner | Diagonal preconditioner for both symmetric and asymmetric matrices |
| diagonalSolver | Foam::diagonalSolver |
| DiagTensor< Cmpt > | Templated 3D DiagTensor derived from VectorSpace |
| 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 |
| DICPreconditioner | Simplified diagonal-based incomplete Cholesky preconditioner for symmetric matrices (symmetric equivalent of DILU). The reciprocal of the preconditioned diagonal is calculated and stored |
| DICSmoother | Simplified diagonal-based incomplete Cholesky smoother for symmetric matrices |
| Dictionary< T > | Gerneral purpose template dictionary class which manages the storage associated with it |
| 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:
- exact match
- pattern match (in reverse order)
- optional recursion into the enclosing (parent) dictionaries
|
| DictionaryBase< IDLListType, T > | Base dictionary class templated on both the form of doubly-linked list it uses as well as the type it holds |
| dictionaryEntry | A keyword and a list of tokens is a 'dictionaryEntry' |
| dictionaryName | |
| dieselMixture< ThermoType > | Foam::dieselMixture |
| 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 |
| DILUPreconditioner | Simplified diagonal-based incomplete LU preconditioner for asymmetric matrices. The reciprocal of the preconditioned diagonal is calculated and stored |
| DILUSmoother | Simplified diagonal-based incomplete LU smoother for asymmetric matrices |
| dimensioned< Type > | Generic dimensioned Type class |
| DimensionedField< Type, GeoMesh > | Field with dimensions and associated with geometry type GeoMesh which is used to size the field and a reference to it is maintained |
| SlicedGeometricField< Type, PatchField, SlicedPatchField, GeoMesh >::DimensionedInternalField | The internalField of a SlicedGeometricField |
| dimensionSet | Dimension set for the base types. This type may be used to implement rigorous dimension checking for algebraic manipulation |
| directInteractionList | |
| directionalDiffusivity | Directional finite volume mesh motion diffusivity |
| directionInfo | Holds direction in which to split cell (in fact a local coordinate axes). Information is a label and a direction |
| directionMixedFvPatchField< Type > | Foam::directionMixedFvPatchField |
| directions | Set of directions for each cell in the mesh. Either uniform and size=1 or one set of directions per cell |
| directMappedFixedValueFvPatchField< Type > | Recycles the value at a set of cells or patch faces back to *this. Can not sample internal faces (since volField not defined on faces) |
| directMappedFvPatch | Foam::directMappedFvPatch |
| directMappedPatchBase | Determines a mapping between patch face centres and mesh cell or face centres and processors they're on |
| directMappedPointPatch | DirectMapped patch |
| directMappedPolyPatch | Determines a mapping between patch face centres and mesh cell or face centres and processors they're on |
| directMappedVelocityFluxFixedValueFvPatchField | Recycles the velocity and flux at a patch to this patch |
| directMappedWallFvPatch | Foam::directMappedWallFvPatch |
| directMappedWallPointPatch | DirectMapped patch |
| directMappedWallPolyPatch | Determines a mapping between patch face centres and mesh cell or face centres and processors they're on |
| dispersionLESModel | Foam::dispersionLESModel |
| DispersionModel< CloudType > | |
| dispersionModel | Foam::dispersionModel |
| DispersionRASModel< CloudType > | |
| dispersionRASModel | Dispersion RAS model |
| displacementComponentLaplacianFvMotionSolver | Mesh motion solver for an fvMesh. Based on solving the cell-centre Laplacian for the given component of the motion displacement |
| displacementFvMotionSolver | Base class for fvMotionSolvers which calculate displacement |
| displacementInterpolationFvMotionSolver | Mesh motion solver for an fvMesh |
| displacementLaplacianFvMotionSolver | Mesh motion solver for an fvMesh. Based on solving the cell-centre Laplacian for the motion displacement |
| displacementSBRStressFvMotionSolver | Mesh motion solver for an fvMesh. Based on solving the cell-centre solid-body rotation stress equations for the motion displacement |
| distanceSurface | A sampledSurface defined by a distance to a surface |
| distributedTriSurfaceMesh | IOoject and searching on distributed triSurface. All processor hold (possibly overlapping) part of the overall surface. All queries are distributed to the processor that can answer it and the result sent back |
| distribution | |
| div | Writes scalar fields corresponding to the divergence of the supplied field (name) for each time |
| divideEqOp< T > | |
| divideEqOp2< T1, T2 > | |
| divideOp< T > | |
| divideOp2< T1, T2 > | |
| divideOp3< T, T1, T2 > | |
| divScheme< Type > | Abstract base class for div schemes |
| dlLibraryTable | A table of dynamically loaded libraries |
| DLList< T > | Non-intrusive doubly-linked list |
| DLListBase | Base doubly-linked list |
| DLPtrList< T > | Non-intrusive doubly-linked pointer list |
| domainDecomposition | |
| domainDecomposition | Automatic domain decomposition class for FOAM meshes |
| doubleSigmoid | |
| downwind< Type > | Downwind differencing scheme class |
| DragModel< CloudType > | Templated drag model class |
| dragModel | Foam::dragModel |
| DsmcBaseCloud | Virtual abstract base class for templated DsmcCloud |
| DsmcCloud< ParcelType > | Templated base class for dsmc cloud |
| dsmcFields | Calculate intensive fields:
- UMean
- translationalT
- internalT
- overallT from averaged extensive fields from a DSMC calculation
|
| dsmcParcel | |
| DsmcParcel< ParcelType > | DSMC parcel class |
| dummyIPstreamImpl | Dummy implementation of the IPstreamImpl abstract base class |
| dummyOPstreamImpl | Dummy implementation of the OPstreamImpl abstract base class |
| dummyPstreamImpl | Dummy implementation of the PstreamImpl abstract base class |
| duplicatePoints | Duplicate points |
| dxSurfaceWriter< Type > | |
| dynamicAlphaContactAngleFvPatchScalarField | A dynamic alphaContactAngle scalar boundary condition (alphaContactAngleFvPatchScalarField) |
| DynamicField< T, SizeInc, SizeMult, SizeDiv > | Dynamically sized Field |
| dynamicFvMesh | Abstract base class for geometry and/or topology changing fvMesh |
| dynamicInkJetFvMesh | Mesh motion specifically for the "pumping" system of an ink-jet injector |
| DynamicList< T, SizeInc, SizeMult, SizeDiv > | A 1D vector of objects of type <T> that resizes itself as necessary to accept the new objects |
| dynamicMotionSolverFvMesh | The dynamicMotionSolverFvMesh |
| dynamicRefineFvMesh | A fvMesh with built-in refinement |
| dynOneEqEddy | One Equation Eddy Viscosity Model for compressible flows |
| dynOneEqEddy | One Equation Eddy Viscosity Model for incompressible flows |
| eConstThermo< equationOfState > | Constant properties thermodynamics package templated on an equation of state |
| edge | An edge is a list of two point labels. The functionality it provides supports the discretisation on a 2-D flat mesh |
| 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 |
| edgeFaceCirculator | Walks from starting face around edge |
| 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.) |
| EdgeMap< T > | Map from edge (expressed as its endpoints) to value |
| edgeMesh | Points connected by edges |
| edgeStats | Helper class to calculate minimum edge length on mesh |
| edgeSurface | Description of surface in form of 'cloud of edges' |
| edgeVertex | Combines edge or vertex in single label. Used to specify cuts across cell circumference |
| egrMixture< ThermoType > | Foam::egrMixture |
| electrostaticPotential | |
| electrostaticPotential | |
| emptyFvPatch | A patch which will not exist in the fvMesh. Typical example is a front and back plane of a 2-D geometry |
| emptyFvPatchField< Type > | Foam::emptyFvPatchField |
| emptyFvsPatchField< Type > | Foam::emptyFvsPatchField |
| emptyPointPatch | Empty plane patch |
| emptyPointPatchField< Type > | An empty boundary condition for pointField |
| emptyPolyPatch | Empty front and back plane patch. Used for 2-D geometries |
| energyScalingFunction | |
| engineMesh | Foam::engineMesh |
| enginePiston | Foam::enginePiston |
| engineTime | Manage time in terms of engine RPM and crank-angle |
| engineValve | Foam::engineValve |
| enrichedPatch | The enriched patch contains a double set of faces from the two sides of the sliding interface before the cutting |
| 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 |
| ensightMesh | |
| ensightPart | Base class for ensightPartCells and ensightPartFaces |
| 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 |
| entry | A keyword and a list of tokens is an 'entry' |
| epsilonWallFunctionFvPatchScalarField | Boundary condition for epsilon when using wall functions
- calculates epsilon and G
- epsilon values added directly into the matrix to act as a constraint
|
| epsilonWallFunctionFvPatchScalarField | Boundary condition for epsilon when using wall functions
- calculates epsilon and G
- epsilon values added directly into the matrix to act as a constraint
|
| ePsiThermo< MixtureType > | Internal energy for a mixture based on compressibility |
| eqEqOp< T > | |
| eqEqOp2< T1, T2 > | |
| eqEqOp3< T, T1, T2 > | |
| eqMagOp< T > | |
| eqMagOp2< T1, T2 > | |
| eqMinusOp< T > | |
| eqMinusOp2< T1, T2 > | |
| eqOp< T > | |
| eqOp2< T1, T2 > | |
| 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 |
| error | Class to handle errors and exceptions in a simple, consistent stream-based manner |
| errorDrivenRefinement | Refines and coarsens based on error estimate |
| errorEstimate< Type > | Residual error estimation |
| errorManip< Err > | 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< Err, T > | ErrorManipArg |
| ETAB | The Enhanced TAB model |
| Euler< Type > | Euler-implicit integration |
| EulerCoordinateRotation | A coordinateRotation defined in the z-x-y Euler convention |
| EulerD2dt2Scheme< Type > | First-order Euler implicit d2dt2 using the current and two previous time-step values |
| EulerDdtScheme< Type > | Basic first-order Euler implicit/explicit ddt using only the current and previous time-step values |
| EulerImplicit< CompType, ThermoType > | An Euler implicit solver for chemistry |
| evaluateError | Foam::evaluateError |
| evaporationModel | Base class for selecting an evaporation model |
| ExactParticle< ParticleType > | Special version of Particle to do tracking on non-convex cells |
| explicitSource | Explicit source |
| exponential | |
| exponential | Exponential pdf |
| exponentialDiffusivity | Mesh motion diffusivity maipulator which returns the exp(-alpha/D) of the given diffusivity D |
| exponentialRepulsion | |
| extendedCellToFaceStencil | Calculates/constains the extended cell-to-face stencil |
| extendedCentredCellToFaceStencil | |
| extendedCentredFaceToCellStencil | |
| extendedFaceToCellStencil | Note: transformations on coupled patches not supported. Problem is the positions of cells reachable through these patches |
| extendedLeastSquaresGrad< Type > | Second-order gradient scheme using least-squares |
| extendedLeastSquaresVectors | Extended molecule least-squares gradient scheme vectors |
| extendedUpwindCellToFaceStencil | Creates upwind stencil by shifting a centred stencil to upwind and downwind faces and optionally removing all non-(up/down)wind faces ('pureUpwind') |
| extrude2DMesh | Given 2D mesh insert all the topology changes to extrude. Does not work in parallel |
| extrudedMesh | |
| extrudeModel | Top level extrusion model class |
| face | A face is a list of labels corresponding to mesh vertices |
| faceAreaPairGAMGAgglomeration | Agglomerate using the pair algorithm |
| FaceCellWave< Type > | Wave propagation of information through grid. Every iteration information goes through one layer of cells. Templated on information that is transferred |
| faceCollapser | Collapses faces into edges. Used to remove sliver faces (faces with small area but non-zero span) |
| faceCoupleInfo | Container for information needed to couple to meshes. When constructed from two meshes and a geometric tolerance finds the corresponding boundary faces |
| faceLimitedGrad< Type > | FaceLimitedGrad gradient scheme applied to a runTime selected base gradient scheme |
| 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 |
| faceMDLimitedGrad< Type > | FaceMDLimitedGrad gradient scheme applied to a runTime selected base gradient scheme |
| faceMesh | Storage for surface mesh i.e. points and faces |
| faceOnlySet | |
| facePointPatch | A pointPatch based on a polyPatch |
| faceSet | A list of face labels |
| faceSets | |
| faceSource | Face source variant of field value function object. Values of user- specified fields reported for collections of faces |
| faceToCell | A topoSetSource to select cells based on usage in faces |
| faceToCellStencil | Baseclass for extended cell centred addressing. Contains per cell a list of neighbouring faces in global addressing |
| faceToFace | A topoSetSource to select faces based on usage in another faceSet |
| faceToPoint | A topoSetSource to select points based on usage in faces |
| faceTriangulation | Triangulation of faces. Handles concave polygons as well (inefficiently) |
| faceZone | A subset of mesh faces organised as a primitive patch |
| faceZoneSet | Like faceSet but updates faceZone when writing |
| faceZoneToCell | A topoSetSource to select cells based on side of faceZone |
| faceZoneToFaceZone | A topoSetSource to select faces based on usage in another faceSet |
| FallOffReactionRate< ReactionRate, FallOffFunction > | General class for handling unimolecular/recombination fall-off reactions |
| fanFvPatchField< Type > | Foam::fanFvPatchField |
| 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 |
| featureEdgeMesh | Features (lines), readable from file |
| FECCellToFaceStencil | All cells connected via edge to face |
| fft | Fast fourier transform derived from the Numerical Recipes in C routine |
| Field< Type > | Generic templated field type |
| FieldActivatedInjection< CloudType > | Injection at specified positions, with the conditions: |
| fieldAverage | Calculates the field averages given list of fieldAverageItems, e.g |
| fieldAverageItem | Helper class to describe what form of averaging to apply. A set will be applied to each base field in Foam::fieldAverage, of the form: |
| fieldDictionary | Read field as dictionary (without mesh) |
| FieldField< Field, Type > | Generic field type |
| probes::fieldGroup< Type > | Class used for grouping field types |
| FieldMapper | Abstract base class to hold the Field mapping addressing and weights |
| fieldMinMax | Calculates scalar minimim and maximum field values |
| multivariateScheme< Type, Scheme >::fieldScheme | SurfaceInterpolationScheme sub-class returned by operator(field) |
| multivariateSelectionScheme< Type >::fieldScheme | SurfaceInterpolationScheme sub-class returned by operator(field) |
| multivariateSurfaceInterpolationScheme< Type >::fieldScheme | SurfaceInterpolationScheme sub-class returned by operator(field) |
| multivariateUpwind< Type >::fieldScheme | SurfaceInterpolationScheme sub-class returned by operator(field) |
| multivariateSurfaceInterpolationScheme< Type >::fieldTable | FieldTable |
| fieldToCell | A topoSetSource to select cells based on field values |
| fieldValue | Base class for field value -based function objects |
| FIFOStack< T > | A FIFO stack based on a singly-linked list. Operations are push(), pop(), top(), bottom() and empty() |
| fileDiffusivity | Motion diffusivity read from given file name |
| fileName | A class for handling file names |
| fileStat | Wrapper for stat() system call |
| filteredLinear2Limiter< LimiterFunc > | Class to generate weighting factors for the filteredLinear2 differencing scheme |
| filteredLinear2VLimiter< LimiterFunc > | Class to generate weighting factors for the filteredLinear2V differencing scheme |
| filteredLinear3Limiter< LimiterFunc > | Class to generate weighting factors for the filteredLinear differencing scheme |
| filteredLinear3VLimiter< LimiterFunc > | Class to generate weighting factors for the filteredLinear3V differencing scheme |
| filteredLinearLimiter< LimiterFunc > | Class to generate weighting factors for the filteredLinear differencing scheme |
| FitData< FitDataType, ExtendedStencil, Polynomial > | 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) |
| fixed | Fixed value model for Xi. See XiModel.H for more details on flame wrinkling modelling |
| fixedAxis | SixDoFRigidBodyMotionConstraint. Body may only rotate around an axis fixed in global space |
| fixedBlended< Type > | Two-scheme fixed-blending differencing scheme |
| fixedEnthalpyFvPatchScalarField | A fixed boundary condition for enthalpy |
| fixedFluxPressureFvPatchScalarField | Foam::fixedFluxPressureFvPatchScalarField |
| fixedGradientFvPatchField< Type > | Foam::fixedGradientFvPatchField |
| fixedInternalEnergyFvPatchScalarField | A fixed boundary condition for internal energy |
| fixedInternalValueFvPatchField< Type > | Boundary condition providing 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 |
| fixedLine | SixDoFRigidBodyMotionConstraint. Reference point may only move along a line |
| FixedList< T, Size > | A 1D vector of objects of type <T> with a fixed size <Size> |
| fixedNormalSlipFvPatchField< Type > | Foam::fixedNormalSlipFvPatchField |
| fixedNormalSlipPointPatchField< Type > | Slip with user-specified normal |
| fixedOrientation | SixDoFRigidBodyMotionConstraint. Orientation of body fixed global space. Only valid where the predicted deviation from alignment is < 90 degrees |
| fixedPlane | SixDoFRigidBodyMotionConstraint. Reference point may only move along a plane |
| fixedPoint | SixDoFRigidBodyMotionConstraint. Point fixed in space |
| fixedPressureCompressibleDensityFvPatchScalarField | Calculate compressible density as a function of pressure and fluid properties |
| fixedRhoFvPatchScalarField | Foam::fixedRhoFvPatchScalarField |
| incompressible::fixedShearStressFvPatchVectorField | |
| fixedShearStressFvPatchVectorField | Set a constant shear stress as tau0 = -nuEff dU/dn |
| fixedUnburntEnthalpyFvPatchScalarField | Fixed boundary condition for unburnt |
| fixedValue | |
| fixedValue | Returns a fixed value |
| fixedValueFvPatchField< Type > | Foam::fixedValueFvPatchField |
| fixedValueFvsPatchField< Type > | Foam::fixedValueFvsPatchField |
| fixedValuePointPatchField< Type > | A FixedValue boundary condition for pointField |
| flowRateInletVelocityFvPatchVectorField | Describes a volumetric/mass flow normal vector boundary condition by its magnitude as an integral over its area |
| fluentFvMesh | |
| flux< Type > | |
| flux< scalar > | |
| fluxCorrectedVelocityFvPatchVectorField | Velocity outlet boundary condition for patches where the pressure is specified. The outflow velocity is obtained by "zeroGradient" and then corrected from the flux. If reverse flow is possible or expected use the "pressureInletOutletVelocityFvPatchVectorField" BC instead |
| foamChemistryReader< ThermoType > | Chemistry reader for OpenFOAM format |
| foamFileSurfaceWriter< Type > | A surfaceWriter for foamFiles |
| forceCoeffs | Derived from the forces function object, creates a specialisation to calculate lift and drag forces |
| forces | Calculates the forces and moments by integrating the pressure and skin-friction forces over a given list of patches |
| fourthGrad< Type > | Second-order gradient scheme using least-squares |
| FreeStream< CloudType > | 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 |
| freestreamFvPatchField< Type > | Foam::freestreamFvPatchField |
| freestreamPressureFvPatchScalarField | Foam::freestreamPressureFvPatchScalarField |
| frictionalStressModel | |
| FTRsurfaceFormat< Face > | Reading of the (now deprecated and infrequently used) Foam Trisurface Format |
| functionEntry | A functionEntry causes entries to be added/manipulated on the specified dictionary given an input stream |
| functionObject | Abstract base-class for Time/database function objects |
| functionObjectList | List of function objects with start(), execute() and end() functions that is called for each object |
| fvBoundaryMesh | Foam::fvBoundaryMesh |
| fvBoundaryMeshMapper | Foam::fvBoundaryMeshMapper |
| fvDOM | Finite Volume Discrete Ordinates Method. Solves the RTE equation for n directions in a participating media, not including scatter |
| fvFieldDecomposer | Finite Volume volume and surface field decomposer |
| fvFieldReconstructor | FV volume and surface field reconstructor |
| fvMatrix< Type > | 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 |
| fvMesh | Mesh data needed to do the Finite Volume discretisation |
| 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 |
| fvMeshLduAddressing | Foam::fvMeshLduAddressing |
| fvMeshMapper | Class holds all the necessary information for mapping fields associated with fvMesh |
| 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 |
| fvMotionSolver | Virtual base class for finite volume mesh motion solvers |
| fvMotionSolverEngineMesh | Foam::fvMotionSolverEngineMesh |
| fvPatch | Foam::fvPatch |
| fvPatchField< Type > | Abstract base class with a fat-interface to all derived classes covering all possible ways in which they might be used |
| fvPatchFieldMapper | Foam::fvPatchFieldMapper |
| fvFieldReconstructor::fvPatchFieldReconstructor | |
| fvPatchMapper | Mapping class for a fvPatchField |
| 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 |
| fvMatrix< Type >::fvSolver | Solver class returned by the solver function |
| fvsPatchField< Type > | An abstract base class with a fat-interface to all derived classes covering all possible ways in which they might be used |
| fvSurfaceMapper | FV surface mapper |
| GAMGAgglomeration | Geometric agglomerated algebraic multigrid agglomeration class |
| GAMGInterface | Abstract base class for GAMG agglomerated interfaces |
| GAMGInterfaceField | Abstract base class for GAMG agglomerated interface fields |
| GAMGPreconditioner | Geometric agglomerated algebraic multigrid preconditioner |
| GAMGSolver | Geometric agglomerated algebraic multigrid solver |
| GammaLimiter< LimiterFunc > | Class with limiter function which returns the limiter for the Gamma differencing scheme based on phict obtained from the LimiterFunc class |
| gaussConvectionScheme< Type > | Basic second-order convection using face-gradients and Gauss' theorem |
| gaussDivScheme< Type > | Basic second-order div using face-gradients and Gauss' theorem |
| gaussGrad< Type > | Basic second-order gradient scheme using face-interpolation and Gauss' theorem |
| gaussLaplacianScheme< Type, GType > | Basic second-order laplacian using face-gradients and Gauss' theorem |
| GaussSeidelSmoother | A lduMatrix::smoother for Gauss-Seidel |
| GenEddyVisc | General base class for all compressible models that can be implemented as an eddy viscosity, i.e. algebraic and one-equation models |
| GenEddyVisc | General base class for all incompressible models that can be implemented as an eddy viscosity, i.e. algebraic and one-equation models |
| general | |
| general | General pdf |
| genericFvPatch | FV variant of the genericPolyPatch |
| genericFvPatchField< Type > | Foam::genericFvPatchField |
| genericPointPatch | DirectMapped patch |
| genericPointPatchField< Type > | Foam::genericPointPatchField |
| genericPolyPatch | Determines a mapping between patch face centres and mesh cell centres and processors they're on |
| GenSGSStress | General base class for all compressible models that directly solve for the SGS stress tensor B |
| GenSGSStress | General base class for all incompressible models that directly solve for the SGS stress tensor B |
| geomCellLooper | Implementation of cellLooper. Does pure geometric cut through cell |
| geomDecomp | Geometrical domain decomposition |
| GeoMesh< MESH > | Generic mesh wrapper used by volMesh, surfaceMesh, pointMesh etc |
| GeometricField< Type, PatchField, GeoMesh >::GeometricBoundaryField | |
| GeometricField< Type, PatchField, GeoMesh > | Generic GeometricField class |
| 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 |
| geometricSurfacePatch | The geometricSurfacePatch is like patchIdentifier but for surfaces. Holds type, name and index |
| 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 |
| GidaspowConductivity | |
| GidaspowErgunWenYu | D. Gidaspow, Multiphase flow and fluidization, Academic Press, New York, 1994 |
| GidaspowRadial | |
| 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 |
| GidaspowViscosity | |
| GidaspowViscosity | |
| 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 by using parallel communication |
| globalPointPatch | Foam::globalPointPatch |
| globalPointPatchField< Type > | Foam::globalPointPatchField |
| globalPoints | Calculates points shared by more than two processor patches or cyclic patches |
| gnuplotGraph | Output in gnuplot (http://www.gnuplot.info) format |
| gnuplotSetWriter< Type > | |
| GradientDispersionRAS< CloudType > | The velocity is perturbed in the direction of -grad(k), with a Gaussian random number distribution with variance sigma. where sigma is defined below |
| 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 |
| gradientEnthalpyFvPatchScalarField | Gradient boundary condition for enthalpy |
| gradientInternalEnergyFvPatchScalarField | Gradient boundary condition for internal energy |
| gradientUnburntEnthalpyFvPatchScalarField | Gradient boundary condition for unburnt |
| gradScheme< Type > | Abstract base class for gradient schemes |
| granularPressureModel | |
| graph | Class to create, store and output qgraph files |
| greyDiffusiveRadiationMixedFvPatchScalarField | |
| greyDiffusiveRadiationMixedFvPatchScalarField | Radiation temperature specified |
| greyMeanAbsorptionEmission | GreyMeanAbsorptionEmission radiation absorption and emission coefficients for continuous phase |
| GTSsurfaceFormat< Face > | 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 |
| Gulder | Simple Gulder model for XiEq based on Gulders correlation with a linear correction function to give a plausible profile for XiEq |
| Gulders | Laminar flame speed obtained from Gulder's correlation |
| GuldersEGR | Laminar flame speed obtained from Gulder's correlation with EGR modelling |
| H2O | Water |
| harmonic | Harmonic-mean differencing scheme class |
| harmonicSpring | |
| Hash< PrimitiveType > | Hash function class for primitives. All non-primitives used to hash entries on hash tables likely need a specialized version of this class |
| string::hash | Hashing function class, shared by all the derived classes |
| FixedList< T, Size >::Hash< HashT > | Hashing function class |
| multiphaseMixture::interfacePair::hash | |
| Hash< Foam::label > | Hash specialization for hashing labels |
| Hash< void * > | Hash specialization for hashing pointer addresses |
| HashPtrTable< T, Key, Hash > | A HashTable specialization for hashing pointers |
| HashSet< Key, Hash > | A HashTable with keys but without contents |
| hashSignedLabel | Hash for signed integers (Hash<label> only works for unsigned ints) |
| HashTable< T, Key, Hash > | An STL-conforming hash table |
| HashTableName | |
| hCombustionThermo | Foam::hCombustionThermo |
| hConstThermo< equationOfState > | Constant properties thermodynamics package templated into the equationOfState |
| HeatTransferModel< CloudType > | Templated heat transfer model class |
| heatTransferModel | Foam::heatTransferModel |
| HerschelBulkley | Herschel-Bulkley non-Newtonian viscosity model |
| hexBlock | Hex block definition used in the cfx converter |
| hexCellLooper | Implementation of cellLooper |
| hexMatcher | A cellMatcher for hex cells |
| hexRef8 | Refinement of (split) hexes using polyTopoChange |
| hhuCombustionThermo | Foam::hhuCombustionThermo |
| hhuMixtureThermo< MixtureType > | Foam::hhuMixtureThermo |
| hierarchGeomDecomp | Does hierarchical decomposition of points. Works by first sorting the points in x direction into equal sized bins, then in y direction and finally in z direction |
| Histogram< List > | Calculates the counts per bin of a list |
| hollowConeInjector | A hollow cone injector with randomly distributed parcels between the inner and outer cone angle |
| homogeneousDynSmagorinsky | The Isochoric homogeneous dynamic Smagorinsky Model for incompressible flows |
| homogeneousMixture< ThermoType > | Foam::homogeneousMixture |
| hPolynomialThermo< EquationOfState, PolySize > | Thermodynamics package templated on the equation of state, using polynomial functions for cp, h and s |
| hPsiMixtureThermo< MixtureType > | Foam::hPsiMixtureThermo |
| hPsiThermo< MixtureType > | Enthalpy for a mixture based on compressibility |
| hReactionThermo | Foam::hReactionThermo |
| HrenyaSinclairConductivity | |
| HrenyaSinclairViscosity | |
| HrenyaSinclairViscosity | |
| hRhoMixtureThermo< MixtureType > | Foam::hRhoMixtureThermo |
| hRhoThermo< MixtureType > | Enthalpy for a mixture based on density |
| hsCombustionThermo | Sensible enthalpy variant of combustionThermo |
| hsPsiMixtureThermo< MixtureType > | Foam::hsPsiMixtureThermo |
| hsPsiThermo< MixtureType > | Sensible enthalpy for a mixture based on compressibility |
| hsReactionThermo | Sensible enthalpy variant for reactionThermo |
| hsRhoMixtureThermo< MixtureType > | Foam::hsRhoMixtureThermo |
| hsRhoThermo< MixtureType > | Sensible enthalpy for a mixture based on density |
| iC3H8O | Iso-propanol |
| IC8H18 | Iso-Octane |
| ICCG | Incomplete Cholesky preconditioned CG solver derived from the general preconditioned CG solver PCG but with the choice of preconditioner pre-selected |
| icoPolynomial< PolySize > | Incompressible, polynomial form of equation of state, using a polynomial function for density |
| IDDESDelta | IDDESDelta used by the IDDES (improved low Re Spalart-Allmaras DES model) The min and max delta are calculated using the double distance of the min or max from the face centre to the cell centre |
| IDEA | The IDEA fuel is constructed by adding 30% alphaMethylNaphthalene with 70% n-decane |
| IDLList< T > | Intrusive doubly-linked list |
| ifEqEqOp< value > | Reduction class. If x and y are not equal assign value |
| IFstream | Input from file stream |
| IFstreamAllocator | A std::istream with ability to handle compressed files |
| ignition | Foam::ignition |
| ignitionSite | Foam::ignitionSite |
| ILList< LListBase, T > | Template class for intrusive linked lists |
| Imanip< T > | |
| 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 |
| incompressible | Incompressible gas/liquid equation of state |
| indexedOctree< Type > | Non-pointer based hierarchical recursive searching |
| indexedOctreeName | |
| indexedParticle | |
| indexedParticleCloud | A Cloud of particles carrying an additional index |
| IndirectList< T > | A List with indirect addressing |
| ignitionSite::iNew | Class used for the read-construction of |
| ExactParticle< ParticleType >::iNew | Factory class to read-construct particles used for parallel transfer |
| basicSource::iNew | Return pointer to new basicSource object created |
| TimeActivatedExplicitSource< Type >::iNew | Return pointer to new TimeActivatedExplicitSource object created |
| MRFZone::iNew | Return a pointer to a new MRFZone created on freestore |
| porousZone::iNew | Return pointer to new porousZone created on freestore from Istream |
| sampledSet::iNew | Class used for the read-construction of |
| sampledSurface::iNew | Class used for the PtrLists read-construction |
| searchableSurface::iNew | Class used for the read-construction of |
| topoSetSource::iNew | Class used for the read-construction of |
| Reaction< ReactionThermo >::iNew | Class used for the read-construction of PtrLists of reaction |
| functionObject::iNew | Return a pointer to a new functionObject created on freestore |
| INew< T > | A helper class when constructing from an Istream |
| Particle< ParticleType >::iNew | Factory class to read-construct particles used for |
| injector::iNew | Return a pointer to a new injector created on freestore |
| phase::iNew | Return a pointer to a new phase created on freestore |
| 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 |
| InflowBoundaryModel< CloudType > | Templated inflow boundary model class |
| InfoProxy< T > | A helper class for outputting values to Ostream |
| inhomogeneousMixture< ThermoType > | Foam::inhomogeneousMixture |
| InjectionModel< CloudType > | Templated injection model class |
| injector | Spray injector |
| injectorModel | The injectormodel is used to set initial droplet size and the velocity direction |
| injectorType | Base class for injectors |
| inletOutletFvPatchField< Type > | Foam::inletOutletFvPatchField |
| inletOutletTotalTemperatureFvPatchScalarField | Foam::inletOutletTotalTemperatureFvPatchScalarField |
| innerProduct< arg1, arg2 > | |
| innerProduct< SphericalTensor2D< Cmpt >, SphericalTensor2D< Cmpt > > | |
| innerProduct< SphericalTensor2D< Cmpt >, Tensor2D< Cmpt > > | |
| innerProduct< SphericalTensor2D< Cmpt >, Vector2D< Cmpt > > | |
| innerProduct< SphericalTensor< Cmpt >, SphericalTensor< Cmpt > > | |
| innerProduct< SphericalTensor< Cmpt >, SymmTensor< Cmpt > > | |
| innerProduct< SphericalTensor< Cmpt >, Tensor< Cmpt > > | |
| innerProduct< SphericalTensor< Cmpt >, Vector< Cmpt > > | |
| innerProduct< SymmTensor< Cmpt >, SphericalTensor< Cmpt > > | |
| innerProduct< SymmTensor< Cmpt >, SymmTensor< Cmpt > > | |
| innerProduct< SymmTensor< Cmpt >, Tensor< Cmpt > > | |
| innerProduct< SymmTensor< Cmpt >, Vector< Cmpt > > | |
| innerProduct< Tensor2D< Cmpt >, SphericalTensor2D< Cmpt > > | |
| innerProduct< Tensor2D< Cmpt >, Tensor2D< Cmpt > > | |
| innerProduct< Tensor2D< Cmpt >, Vector2D< Cmpt > > | |
| innerProduct< Tensor< Cmpt >, SphericalTensor< Cmpt > > | |
| innerProduct< Tensor< Cmpt >, SymmTensor< Cmpt > > | |
| innerProduct< Vector2D< Cmpt >, SphericalTensor2D< Cmpt > > | |
| innerProduct< Vector2D< Cmpt >, Tensor2D< Cmpt > > | |
| innerProduct< Vector< Cmpt >, SphericalTensor< Cmpt > > | |
| innerProduct< Vector< Cmpt >, SymmTensor< Cmpt > > | |
| inputModeEntry | Specify the input mode when reading dictionaries, expects a single word to follow |
| 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 |
| instabilityG | Flame-surface instabilityG flame-wrinking generation rate coefficient model used in XiModel.H |
| instant | An instant of time. Contains the time value and name |
| IntegrationScheme< Type >::integrationResult | Helper class to supply results of integration |
| IntegrationScheme< Type > | Top level model for Integration schemes |
| interactionLists | |
| interfaceCompressionLimiter | Interface compression scheme currently based on the generic limited scheme although it does not use the NVD/TVD functions |
| multiphaseMixture::interfacePair | |
| interfaceProperties | Contains the interface properties |
| alphaContactAngleFvPatchScalarField::interfaceThetaProps | |
| internalWriter | Write fields (internal) |
| interpolate | Interpolates volume fields to surface fields for each time |
| interpolation< Type > | Abstract base class for interpolation |
| interpolationCell< Type > | Foam::interpolationCell |
| interpolationCellPatchConstrained< Type > | 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 |
| interpolationCellPoint< Type > | Foam::interpolationCellPoint |
| interpolationCellPointFace< Type > | Foam::interpolationCellPointFace |
| interpolationCellPointWallModified< Type > | Same as interpolationCellPoint, but if interpolating a wall face, uses cell centre value instead |
| interpolationLookUpTable< Type > | A list of lists. Interpolates based on the first dimension. The values must be positive and monotonically increasing in each dimension |
| interpolationTable< Type > | A list of times and values. The time values must be positive and monotonically increasing |
| intersectedSurface | Given triSurface and intersection creates the intersected (properly triangulated) surface. (note: intersection is the list of points and edges 'shared' by two surfaces) |
| intersection | Foam::intersection |
| 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 |
| IObasicSourceList | IObasicSourceList |
| 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 |
| IOerror | Report an I/O error |
| IOField< Type > | A primitive field of type <T> with automated input and output |
| IOList< T > | A List of objects of type <T> with automated input and output |
| IOMap< T > | A Map of objects of type <T> with automated input and output |
| 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 |
| IOOutputFilter< OutputFilter > | IOdictionary wrapper around OutputFilter to allow them to read from their associated dictionaries |
| IOPosition< ParticleType > | Helper IO class to read and write particle positions |
| IOPtrList< T > | A PtrList of objects of type <T> with automated input and output |
| IOstream | An IOstream is an abstract base class for all input/output systems; be they streams, files, token lists etc |
| IPstream | Input inter-processor communications stream |
| IPstreamImpl | Abstract base class for IPstream operations that depend on the parallel library used. Foam::IPstreamImpl::New will lookup the entry "PstreamImplementation" in the global controlDict file (i.e. the one found by Foam::dotFoam) and tries to first load a library named lib<PstreamImplementation>Pstream.so, and then instantiate the class <PstreamImplementation>IPstreamImpl |
| IrreversibleReaction< ReactionThermo, ReactionRate > | Simple extension of Reaction to handle reversible reactions using equilibrium thermodynamics |
| ISLList< T > | Intrusive singly-linked list |
| isNotEqOp< T > | Comparison operator for probes class |
| isoSurface | A surface formed by the iso value. After "Regularised Marching Tetrahedra: improved iso-surface extraction", G.M. Treece, R.W. Prager and A.H. Gee |
| isoSurfaceCell | A surface formed by the iso value. After "Polygonising A Scalar Field Using Tetrahedrons", Paul Bourke and "Regularised Marching Tetrahedra: improved iso-surface extraction", G.M. Treece, R.W. Prager and A.H. Gee |
| ISstream | Generic input stream |
| 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 |
| IStringStream | Input from memory buffer stream |
| octree< Type >::iterator | An STL iterator for octree |
| HashTable< T, Key, Hash >::iterator | An STL-conforming iterator |
| StaticHashTable< T, Key, Hash >::Iterator< TRef, TableRef > | An STL iterator |
| LList< LListBase, T >::iterator | An STL-conforming iterator |
| LPtrList< LListBase, T >::iterator | An STL-conforming iterator |
| UILList< LListBase, T >::iterator | An STL-conforming iterator |
| DLListBase::iterator | An STL-conforming iterator |
| SLListBase::iterator | An STL-conforming iterator |
| PackedList< nBits >::iterator | Used for PackedList |
| PtrList< T >::iterator | An STL-conforming iterator |
| UPtrList< T >::iterator | An STL iterator |
| PackedList< nBits >::iteratorBase | The iterator base for PackedList |
| ITstream | Input token stream |
| janafThermo< equationOfState > | JANAF tables based thermodynamics package templated into the equationOfState |
| JanevReactionRate | Janev, Langer, Evans and Post reaction rate |
| JobInfo | Helper class for recording information about run/finished jobs |
| JohnsonJacksonFrictionalStress | |
| jplotGraph | Jplot graph output |
| jplotSetWriter< Type > | |
| jumpCyclicFvPatchField< Type > | Foam::jumpCyclicFvPatchField |
| kappatJayatillekeWallFunctionFvPatchScalarField | Boundary condition for (kinematic) turbulent thermal conductivity when using wall functions, using Jayatilleke P function |
| kEpsilon | Standard k-epsilon turbulence model for compressible flows |
| kEpsilon | Standard k-epsilon turbulence model for incompressible flows |
| Keyed< T > | A container with an integer key attached to any item |
| keyType | A class for handling keywords in dictionaries |
| kinematicCloud | Virtual abstract base class for templated KinematicCloud |
| KinematicCloud< ParcelType > | Templated base class for kinematic cloud |
| KinematicLookupTableInjection< CloudType > | Particle injection sources read from look-up table. Each row corresponds to an injection site |
| KinematicParcel< ParcelType > | Kinematic parcel class with one/two-way coupling with the continuous phase |
| kinematicParcelInjectionData | Container class to provide injection data for kinematic parcels |
| kineticTheoryModel | |
| Kmesh | Calculate the wavenumber vector field corresponding to the space vector field of a finite volume mesh; |
| kOmega | Standard high Reynolds-number k-omega turbulence model for incompressible flows |
| kOmegaSST | Implementation of the k-omega-SST turbulence model for compressible flows |
| kOmegaSST | Implementation of the k-omega-SST turbulence model for incompressible flows |
| kOmegaSSTSAS | |
| kOmegaSSTSAS | KOmegaSSTSAS LES turbulence model for incompressible flows |
| kqRWallFunctionFvPatchField< Type > | Boundary condition for turbulence k, Q, and R when using wall functions. Simply acts as a zero gradient condition |
| kqRWallFunctionFvPatchField< Type > | Boundary condition for turbulence k, Q, and R when using wall functions. Simply acts as a zero gradient condition |
| KRR4 | Foam::KRR4 |
| KTS | Simple Kolmogorov time-scale (KTS) model for the flame-wrinling generation rate |
| 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 |
| labelBits | A 29bits label and 3bits direction packed into single label |
| labelledTri | Triangle with additional region number |
| labelToCell | A topoSetSource to select cells based on explicitly given labels |
| labelToFace | A topoSetSource to select faces given explicitly provided face labels |
| labelToPoint | A topoSetSource to select points given explicitly provided labels |
| lagrangianFieldDecomposer | Lagrangian field decomposer |
| lagrangianWriter | Write fields (internal) |
| LamBremhorstKE | Lam and Bremhorst low-Reynolds number k-epsilon turbulence model for incompressible flows |
| laminar | Dummy turbulence model for laminar compressible flow |
| laminar | Turbulence model for laminar compressible flow |
| laminar | LES model for laminar incompressible flow. It simply returns laminar properties |
| laminar | Dummy turbulence model for laminar incompressible flow |
| incompressible::laminar | Turbulence model for laminar incompressible flow |
| laminarFlameSpeed | Abstract class for laminar flame speed |
| LandauTellerReactionRate | Landau-Teller reaction rate |
| LangmuirHinshelwoodReactionRate | Power series reaction rate |
| laplaceFilter | Laplace filter for LES |
| laplacianScheme< Type, GType > | Abstract base class for laplacian schemes |
| LarsenBorgnakkeVariableHardSphere< CloudType > | Variable Hard Sphere BinaryCollision Model with Larsen Borgnakke internal energy redistribution. Based on the INELRS subroutine in Bird's DSMC0R.FOR |
| LaunderGibsonRSTM | Launder-Gibson Reynolds stress turbulence model for compressible flows |
| LaunderGibsonRSTM | Launder-Gibson Reynolds stress turbulence model for incompressible flows |
| LaunderSharmaKE | Launder and Sharma low-Reynolds k-epsilon turbulence model for compressible and combusting flows |
| LaunderSharmaKE | Launder and Sharma low-Reynolds k-epsilon turbulence model for incompressible flows |
| layerAdditionRemoval | Cell layer addition mesh modifier |
| layeredEngineMesh | Foam::layeredEngineMesh |
| layerParameters | Simple container to keep together layer specific information |
| lduAddressing | The class contains the addressing required by the lduMatrix: upper, lower and losort |
| lduInterface | An abstract base class for implicitly-coupled interfaces e.g. processor and cyclic patches |
| lduInterfaceField | An abstract base class for implicitly-coupled interface fields e.g. processor and cyclic patch fields |
| 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 |
| lduMesh | Abstract base class for meshes which provide LDU addressing for the construction of lduMatrix and LDU-solvers |
| lduPrimitiveMesh | Simplest contrete lduMesh which stores the addressing needed bu lduMatrix |
| lduScheduleEntry | Struct to hold the patch index and the initialisation flag for the patch schedule |
| leastSquaresGrad< Type > | Second-order gradient scheme using least-squares |
| leastSquaresVectors | Least-squares gradient scheme vectors |
| lennardJones | |
| LESdelta | Abstract base class for LES deltas |
| LESfilter | Abstract class for LES filters |
| LESModel | Base class for all compressible flow LES SGS models |
| incompressible::LESModel | Base class for all incompressible flow LES SGS models |
| UList< T >::less | Less function class that can be used for sorting |
| instant::less | Less function class used in sorting instants |
| 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 |
| LIFOStack< T > | A LIFO stack based on a singly-linked list. Operations are push(), pop(), top(), bottom() and empty() |
| Limited01Limiter< LimitedScheme > | A LimitedLimiter with the range 0-1 |
| limitedCubicLimiter< LimiterFunc > | 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< LimiterFunc > | Class with limiter function which returns the limiter for the limitedCubicV differencing scheme based on r obtained from the LimiterFunc class |
| LimitedLimiter< LimitedScheme > | Foam::LimitedLimiter |
| limitedLinearLimiter< LimiterFunc > | Class with limiter function which returns the limiter for the TVD limited linear differencing scheme based on r obtained from the LimiterFunc class |
| LimitedScheme< Type, Limiter, LimitFunc > | Class to create NVD/TVD limited weighting-factors |
| limitedSnGrad< Type > | Central-difference snGrad scheme with limited non-orthogonal correction |
| limitedSurfaceInterpolationScheme< Type > | Abstract base class for limited surface interpolation schemes |
| LimitFuncs | Class to create NVD/TVD limited weighting-factors |
| limitWith< Type > | LimitWith differencing scheme limits the specified scheme with the specified limiter |
| LindemannFallOffFunction | Lindemann fall-off function |
| line< Point, PointRef > | A line primitive |
| linear | Linear compressibility model |
| linear< Type > | Central-differencing interpolation scheme class |
| linearAxialAngularSpring | SixDoFRigidBodyMotionRestraints model. Linear axial angular spring |
| linearFitPolynomial | Linear polynomial for interpolation fitting |
| linearNormal | Extrudes by transforming points normal to the surface by a given distance |
| linearRadial | |
| linearSpring | SixDoFRigidBodyMotionRestraints model. Linear spring |
| linearUpwind< Type > | LinearUpwind interpolation scheme class derived from upwind and returns upwind weighting factors but also applies an explicit correction |
| linearUpwindV< Type > | LinearUpwindV interpolation scheme class derived from upwind and returns upwind weighting factors but also applies an explicit correction |
| linearValveFvMesh | A sliding linear valve |
| linearValveLayersFvMesh | A sliding linear valve with layers |
| lineDivide | Divides a line into segments |
| lineEdge | A straight edge between the start point and the end point |
| link | |
| LList< LListBase, T >::link | Link structure |
| DLListBase::link | Link structure |
| SLListBase::link | Link structure |
| liquid | The thermophysical properties of a liquid |
| LiquidEvaporation< CloudType > | Liquid evaporation model
- uses ideal gas assumption
|
| liquidMixture | A mixture of liquids |
| LISA | Primary Breakup Model for pressure swirl atomizers |
| List< T > | A 1D array of objects of type <T>, where the size of the vector is known and used for subscript bounds checking, etc |
| listEq | CombineReduce operator for lists. Used for counting |
| listUpdateOp< Type > | List update operation |
| LList< LListBase, T > | Template class for non-intrusive linked lists |
| localBlended< Type > | Two-scheme localBlended differencing scheme |
| localEulerDdtScheme< Type > | 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 |
| LocalInteraction< CloudType > | Patch interaction specified on a patch-by-patch basis |
| localMax< Type > | LocalMax-mean differencing scheme class |
| localMin< Type > | LocalMin-mean differencing scheme class |
| 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 |
| ensightPart::localPoints | Track the points used by the part and map global to local indices |
| locDynOneEqEddy | Localised Dynamic One Equation Eddy Viscosity Model for incompressible flows |
| lowReOneEqEddy | One Equation Eddy Viscosity Model for compressible flow |
| LPtrList< LListBase, T > | Template class for non-intrusive linked PtrLists |
| LRR | Launder, Reece and Rodi Reynolds-stress turbulence model for compressible flows |
| LRR | Launder, Reece and Rodi Reynolds-stress turbulence model for incompressible flows |
| LRRDiffStress | Differential SGS Stress Equation Model for incompressible flows |
| LunPressure | |
| LunSavageRadial | |
| LUscalarMatrix | Foam::LUscalarMatrix |
| 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< Type > | |
| magSqr | Calculates and writes the magnitude-sqaured of a field for each time |
| maitlandSmith | Foam::pairPotentials::maitlandSmith |
| manualDecomp | Decomposition given a cell-to-processor association in a file |
| ManualInjection< CloudType > | Manual injection |
| Map< T > | A HashTable to objects of type <T> with a label key |
| 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 |
| 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 |
| MapFvSurfaceField | Map Surface internal field on topology change. This is a partial template specialisation, see MapGeometricFields |
| MapFvVolField | Map volume internal field on topology change. This is a partial template specialisation, see MapGeometricFields |
| MapInternalField< Type, MeshMapper, GeoMesh > | Generic internal field mapper. For "real" mapping, add template specialisations for mapping of internal fields depending on mesh type |
| MapInternalField< Type, MeshMapper, pointMesh > | |
| MapInternalField< Type, MeshMapper, surfaceMesh > | |
| MapInternalField< Type, MeshMapper, volMesh > | |
| mapPatchChange | Class containing mesh-to-mesh mapping information after a patch change operation |
| MapPointField | Map point field on topology change. This is a partial template specialisation for GeoMesh=pointMesh |
| 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 |
| MarshakRadiationFixedTMixedFvPatchScalarField | Marshak boundary for radiation G field
- radiation temperature specified
|
| MarshakRadiationFvPatchScalarField | Marshak boundary for radiation G field
- radiation temperature taken from patch value
|
| Matrix< Form, Type > | A templated 2D matrix of objects of <T>, where the n x m matrix dimensions are known and used for subscript bounds checking, etc |
| maxDeltaxyz | MaxDeltaxyz takes the maximum of the three dimensions per cell: max(hx, hy, hz). Valid for structures hexahedral cells only |
| maxEqOp< T > | |
| maxEqOp2< T1, T2 > | |
| maxhxhyhzDelta | MaxhxhyhzDelta takes the maximum of the three dimensions per cell: max(hx, hy, hz). Valid for structures hexahedral cells only |
| maxOp< T > | |
| maxOp2< T1, T2 > | |
| maxOp3< T, T1, T2 > | |
| MaxwellianThermal< CloudType > | Wall interaction setting microscopic velocity to a random one drawn from a Maxwellian distribution corresponding to a specified temperature |
| maxwellSlipUFvPatchVectorField | Maxwell slip boundary condition including thermal creep and surface curvature terms that can be optionally switched off |
| MB | Liquid nC3H7COOCH3 or (MB) methyl butyrate (used for biodiesel surrogate) |
| memberFunctionSelectionTables | Macros to enable the easy declaration of member function selection tables |
| mergePolyMesh | Add a given mesh to the original mesh to create a single new mesh |
| Merkle | Merkle cavitation model |
| meshCutAndRemove | Like meshCutter but also removes non-anchor side of cell |
| meshCutter | Cuts (splits) cells |
| meshDualiser | |
| meshDualiser | Creates dual of polyMesh. Every point becomes a cell (or multiple cells for feature points), a walk around every edge creates faces between them |
| MeshedSurface< Face > | A surface geometry mesh with zone information, not to be confused with the similarly named surfaceMesh, which actually refers to the cell faces of a volume mesh |
| MeshedSurfaceIOAllocator | A helper class for storing points, faces and zones |
| MeshedSurfaceProxy< Face > | A proxy for writing MeshedSurface, UnsortedMeshedSurface and surfMesh to various file formats |
| MeshObject< Mesh, Type > | Templated abstract base-class for dynamic mesh objects used to automate their allocation to the mesh database and the mesh-modifier event-loop |
| meshReader | This class supports creating polyMeshes with baffles |
| meshRefinement | Helper class which maintains intersections of (changing) mesh with (static) surfaces |
| meshSearch | Various (local, not parallel) searches on polyMesh; uses (demand driven) octree to search |
| meshToMesh | Mesh to mesh interpolation class |
| meshTriangulation | Triangulation of mesh faces. Generates (multiply connected) trisurface |
| MeshWave< Type > | FaceCellWave plus data |
| meshWriter | Write OpenFOAM meshes and/or results to another CFD format
|
| messageStream | Class to handle messaging in a simple, consistent stream-based manner |
| metisDecomp | Metis domain decomposition |
| midPoint< Type > | Mid-point interpolation (weighting factors = 0.5) scheme class |
| midPointAndFaceSet | |
| midPointSet | |
| minEqOp< T > | |
| minEqOp2< T1, T2 > | |
| minEqOpFace | |
| MinmodLimiter< LimiterFunc > | Class with limiter function which returns the limiter for the Minmod differencing scheme |
| minModOp< T > | |
| minModOp2< T1, T2 > | |
| minModOp3< T, T1, T2 > | |
| minOp< T > | |
| minOp2< T1, T2 > | |
| minOp3< T, T1, T2 > | |
| minusEqOp< T > | |
| minusEqOp2< T1, T2 > | |
| minusOp< T > | |
| minusOp2< T1, T2 > | |
| minusOp3< T, T1, T2 > | |
| mirrorFvMesh | |
| MixedDiffuseSpecular< CloudType > | Wall interaction setting microscopic velocity to a random one drawn from a Maxwellian distribution corresponding to a specified temperature |
| mixedEnthalpyFvPatchScalarField | Mixed boundary conditions for enthalpy |
| mixedFixedValueSlipFvPatchField< Type > | A mixed boundary type that blends between fixedValue and slip, as opposed to the standard mixed condition that blends between fixedValue and fixedGradient; required to implement maxwellSlipU condition |
| mixedFvPatchField< Type > | Foam::mixedFvPatchField |
| mixedInternalEnergyFvPatchScalarField | Mixed boundary conditions for internal energy |
| mixedPointPatchField< Type > | A mixed FixedValue / ZeroGradient boundary condition for pointField |
| mixedSmagorinsky | The mixed Isochoric Smagorinsky Model for incompressible flows |
| mixedUnburntEnthalpyFvPatchScalarField | Mixed boundary condition for unburnt |
| mixerFvMesh | A rotating slider mesh |
| mixture | |
| molecule | Foam::molecule |
| moleculeCloud | |
| morphFieldMapper | Abstract base class to hold the Field mapping for mesh morphs |
| motionDiffusivity | Abstract base class for cell-centre mesh motion diffusivity |
| motionDirectionalDiffusivity | MotionDirectional finite volume mesh motion diffusivity |
| motionSmoother | Given a displacement moves the mesh by scaling the displacement back until there are no more mesh errors |
| motionSolver | Virtual base class for mesh motion solver |
| movingConeTopoFvMesh | Sample topoChangerFvMesh that moves an object in x direction and introduces/removes layers |
| movingWallVelocityFvPatchVectorField | Foam::movingWallVelocityFvPatchVectorField |
| mpiIPstreamImpl | MPI implementation of the IPstreamImpl abstract base class |
| mpiOPstreamImpl | MPI implementation of the OPstreamImpl abstract base class |
| mpiPstreamImpl | MPI implementation of the PstreamImpl abstract base class |
| MRFZone | MRF zone definition based on cell zone and parameters obtained from a control dictionary constructed from the given stream |
| MRFZones | Container class for a set of MRFZones with the MRFZone member functions implemented to loop over the functions for each MRFZone |
| multiComponentMixture< ThermoType > | Foam::multiComponentMixture |
| multiDirRefinement | Does multiple pass refinement to refine cells in multiple directions |
| multiHoleInjector | The unit injector |
| multiNormal | |
| multiNormal | A multiNormal pdf |
| multiphaseMixture | Incompressible multi-phase mixture with built in solution for the phase fractions with interface compression for interface-capturing |
| multiplyEqOp< T > | |
| multiplyEqOp2< T1, T2 > | |
| multiplyOp< T > | |
| multiplyOp2< T1, T2 > | |
| multiplyOp3< T, T1, T2 > | |
| multivariateGaussConvectionScheme< Type > | Basic second-order convection using face-gradients and Gauss' theorem |
| multivariateScheme< Type, Scheme > | Generic multi-variate discretisation scheme class which may be instantiated for any of the NVD, CNVD or NVDV schemes |
| multivariateSelectionScheme< Type > | Generic multi-variate discretisation scheme class for which any of the NVD, CNVD or NVDV schemes may be selected for each variable |
| multivariateSurfaceInterpolationScheme< Type > | Abstract base class for multi-variate surface interpolation schemes |
| multivariateUpwind< Type > | Upwind-difference form of the multivariate surfaceInterpolationScheme |
| MUSCLLimiter< LimiterFunc > | Class with limiter function which returns the limiter for the van Leer's MUSCL differencing scheme |
| muSgsWallFunctionFvPatchScalarField | Spalart Allmaas wall function boundary condition for compressible flows |
| mutkWallFunctionFvPatchScalarField | Boundary condition for turbulent (kinematic) viscosity when using wall functions, based on turbulence kinetic energy.
- replicates OpenFOAM v1.5 (and earlier) behaviour
|
| mutLowReWallFunctionFvPatchScalarField | Boundary condition for turbulent (kinematic) viscosity when for use with low Reynolds number models |
| mutRoughWallFunctionFvPatchScalarField | Boundary condition for turbulent (kinematic) viscosity when using wall functions for rough walls |
| mutSpalartAllmarasStandardRoughWallFunctionFvPatchScalarField | Wall function boundary condition for rough walls |
| mutSpalartAllmarasStandardWallFunctionFvPatchScalarField | Wall function boundary condition for walls |
| mutSpalartAllmarasWallFunctionFvPatchScalarField | Wall function boundary condition for walls |
| mutWallFunctionFvPatchScalarField | Boundary condition for turbulent (kinematic) viscosity when using wall functions
- replicates OpenFOAM v1.5 (and earlier) behaviour
|
| N2 | Liquid N2 |
| NamedEnum< Enum, nEnum > | Initialise the NamedEnum HashTable from the static list of names |
| NASsurfaceFormat< Face > | Nastran surface reader |
| NASsurfaceFormatCore | Internal class used by the NASsurfaceFormat |
| nbrToCell | A topoSetSource to select cells based on number of neighbouring cells (i.e. number of internal or coupled faces) |
| nC3H8O | Propanol |
| nearestEqOp | |
| directMappedPatchBase::nearestEqOp | |
| nearestToCell | A topoSetSource to select cells nearest to points |
| nearestToPoint | A topoSetSource to select points nearest to points |
| 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 |
| Newtonian | An incompressible Newtonian viscosity model |
| ensightMesh::nFacePrimitives | |
| nil | A zero-sized class without any storage. Used, for example, in HashSet |
| noAbsorptionEmission | Dummy absorption-emission model for 'none' |
| noAtomization | Secondary atomization model for the spray |
| noBreakup | Spray breakup "off" |
| noCollision | No collisions between parcels All parcels move independently of eachother |
| noCombustion | |
| combustionModel::noCombustion | No combustion |
| indexedOctree< Type >::node | |
| NoDevolatilisation< CloudType > | Dummy devolatilisation model for 'none' |
| NoDispersion< CloudType > | Place holder for 'none' option |
| noDispersion | No turbulent dispersion of the parcels |
| NoDrag< CloudType > | Dummy drag model for 'none' |
| noDragModel | Standard drag law model with a lower limit on the Cd-value |
| noEvaporation | Set the relaxation-times to something negative. this will disable evaporation |
| noHeatTransfer | No heat transfer. return a negative value to prevent the liquid being heated up |
| NoHeatTransfer< CloudType > | Dummy heat transfer model for 'none' |
| NoInflow< CloudType > | Not inserting any particles |
| NoInjection< CloudType > | Place holder for 'none' option |
| noInteraction | |
| noiseFFT | FFT of the pressure field |
| NonEquilibriumReversibleReaction< ReactionThermo, ReactionRate > | Simple extension of Reaction to handle reversible reactions using equilibrium thermodynamics |
| noneViscosity | |
| noneViscosity | |
| NonlinearKEShih | Shih's quadratic non-linear k-epsilon turbulence model for incompressible flows |
| NoPhaseChange< CloudType > | Dummy phase change model for 'none' |
| NoPostProcessing< CloudType > | Place holder for 'none' option |
| noPreconditioner | Null preconditioner for both symmetric and asymmetric matrices |
| noRadiation | No radiation - does nothing to energy equation source terms (returns zeros) |
| normal | |
| normal | A normal pdf |
| normalToFace | A topoSetSource to select faces based on normal |
| noScaling | |
| NoSurfaceReaction< CloudType > | Dummy surface reaction model for 'none' |
| NSRDSfunc0 | NSRDS function number 100 |
| NSRDSfunc1 | NSRDS function number 101 |
| NSRDSfunc14 | NSRDS function number 114 |
| NSRDSfunc2 | NSRDS function number 102 |
| NSRDSfunc3 | NSRDS function number 103 |
| NSRDSfunc4 | NSRDS function number 104 |
| NSRDSfunc5 | NSRDS function number 105 |
| NSRDSfunc6 | NSRDS function number 106 |
| NSRDSfunc7 | NSRDS-AICHE function number 107 |
| null< Type > | |
| nullSurfaceWriter< Type > | |
| nuSgsWallFunctionFvPatchScalarField | Spalart Allmaras wall function boundary condition for incompressible flows |
| nutkWallFunctionFvPatchScalarField | Boundary condition for turbulent (kinematic) viscosity when using wall functions, based on turbulence kinetic energy.
- replicates OpenFOAM v1.5 (and earlier) behaviour
|
| nutLowReWallFunctionFvPatchScalarField | Boundary condition for turbulent (kinematic) viscosity when for use with low Reynolds number models |
| nutRoughWallFunctionFvPatchScalarField | Boundary condition for turbulent (kinematic) viscosity when using wall functions for rough walls |
| nutSpalartAllmarasStandardRoughWallFunctionFvPatchScalarField | Wall function boundary condition for rough walls |
| nutSpalartAllmarasStandardWallFunctionFvPatchScalarField | Wall function boundary condition for walls |
| nutSpalartAllmarasWallFunctionFvPatchScalarField | Wall function boundary condition for walls |
| nutWallFunctionFvPatchScalarField | Boundary condition for turbulent (kinematic) viscosity when using wall functions
- replicates OpenFOAM v1.5 (and earlier) behaviour
|
| NVDTVD | Foam::NVDTVD |
| NVDVTVDV | Foam::NVDVTVDV |
| objectHit | This class describes a combination of target object index and success flag |
| 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 |
| objectRegistry | Registry of regIOobjects |
| OBJsurfaceFormat< Face > | Provide a means of reading/writing Alias/Wavefront OBJ format |
| octree< Type > | Octree, templated on type of shapes it refers to |
| octreeDataCell | Encapsulation of data needed to search in/for cells |
| octreeDataEdges | Holds data for octree to work on an edges subset |
| octreeDataFace | Holds data for octree to work on mesh faces |
| octreeDataFaceList | Holds data for octree to work on list of faces on a bMesh (= PrimitivePatch which holds faces, not references them) Same as octreeDataFace except for that |
| octreeDataPoint | Encapsulation of data needed for octree searches |
| octreeDataPointTreeLeaf | Template specialisation for octreeDataPoint |
| octreeDataTriSurface | Encapsulates data for octree searches on triSurface |
| octreeDataTriSurfaceTreeLeaf | Template specialisation for octreeDataTriSurfaceTreeLeaf |
| octreeLine< Type > | Iterates over intersections of line with octree leaf elements |
| ode< CompType, ThermoType > | An ODE solver for chemistry |
| ODE | Abstract base class for the ODE solvers |
| ODEChemistryModel< CompType, ThermoType > | Extends base chemistry model by adding a thermo package, and ODE functions. Introduces chemistry equation system and evaluation of chemical source terms |
| ODESolver | Selection for ODE solver |
| offsetOp< T > | |
| offsetOp< face > | Used to offset faces in Pstream::combineOffset |
| OFFsurfaceFormat< Face > | Provide a means of reading/writing Geomview OFF polyList format |
| OFSsurfaceFormat< Face > | Provide a means of reading/writing the single-file OpenFOAM surface format |
| OFSsurfaceFormatCore | Internal class used by the OFSsurfaceFormat |
| OFstream | Output to file stream |
| OFstreamAllocator | A std::ostream with ability to handle compressed files |
| Omanip< T > | |
| omegaWallFunctionFvPatchScalarField | Provides a wall function boundary condition/constraint on omega |
| omegaWallFunctionFvPatchScalarField | Provides a wall function boundary condition/constraint on omega |
| 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 |
| oneEqEddy | One Equation Eddy Viscosity Model for incompressible flows |
| oneEqEddy | One Equation Eddy Viscosity Model for incompressible flows |
| 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 |
| 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 |
| openFoamTableReader< Type > | Reads an interpolation table from a file - OpenFOAM-format |
| oppositeFace | Class containing opposite face for a prismatic cell with addresing and a possibility of failure |
| OPstream | Output inter-processor communications stream |
| OPstreamImpl | Abstract base class for OPstream operations that depend on the parallel library used. Foam::OPstreamImpl::New will lookup the entry "PstreamImplementation" in the global controlDict file (i.e. the one found by Foam::dotFoam) and tries to first load a library named lib<PstreamImplementation>Pstream.so, and then instantiate the class <PstreamImplementation>OPstreamImpl |
| orEqOp< T > | |
| orEqOp2< T1, T2 > | |
| orientedSurface | Given point flip all faces such that normals point in same direction |
| orOp< T > | |
| orOp2< T1, T2 > | |
| orOp3< T, T1, T2 > | |
| ORourkeCollisionModel | Collision model by P.J. O'Rourke |
| oscillatingDisplacementPointPatchVectorField | Foam::oscillatingDisplacementPointPatchVectorField |
| oscillatingFixedValueFvPatchField< Type > | Foam::oscillatingFixedValueFvPatchField |
| oscillatingVelocityPointPatchVectorField | Foam::oscillatingVelocityPointPatchVectorField |
| osha1stream | A basic output stream for calculating SHA1 digests |
| OSHA1stream | The output stream for calculating SHA1 digests |
| OSPRELimiter< LimiterFunc > | Class with limiter function which returns the limiter for the OSPRE differencing scheme based on r obtained from the LimiterFunc class |
| OSstream | Generic output stream |
| Ostream | An Ostream is an abstract base class for all output systems (streams, files, token lists, etc) |
| OStringStream | Output to memory buffer stream |
| outerProduct< arg1, arg2 > | |
| outerProduct< Cmpt, SphericalTensor2D< Cmpt > > | |
| outerProduct< Cmpt, SphericalTensor< Cmpt > > | |
| outerProduct< Cmpt, SymmTensor< Cmpt > > | |
| outerProduct< SphericalTensor2D< Cmpt >, Cmpt > | |
| outerProduct< SphericalTensor< Cmpt >, Cmpt > | |
| outerProduct< SymmTensor< Cmpt >, Cmpt > | |
| outletInletFvPatchField< Type > | Foam::outletInletFvPatchField |
| outletMappedUniformInletFvPatchField< Type > | Averages the field over the "outlet" patch specified by name "outletPatchName" and applies this as the uniform value of the field over this patch |
| outletStabilised< Type > | Outlet-stabilised interpolation scheme which applies upwind differencing to the faces of the cells adjacent to outlets |
| OutputFilterFunctionObject< OutputFilter > | A functionObject wrapper around OutputFilter to allow them to be created via the functions list within controlDict |
| outputFilterOutputControl | |
| P1 | Works well for combustion applications where optical thickness, tau is large, i.e. tau = a*L > 3 (L = distance between objects) |
| PackedList< nBits > | A dynamically allocatable list of packed unsigned integers |
| Pair< Type > | An ordered pair of two objects of type <T> with first() and second() elements |
| pairGAMGAgglomeration | Agglomerate using the pair algorithm |
| pairPotential | |
| pairPotentialList | |
| parabolicCylindricalCS | Parabolic cylindrical coordinate system |
| parcel | A parcel of particles |
| parMetisDecomp | |
| ParRunControl | Helper class for initializing parallel jobs from the command arguments |
| ParSortableList< Type > | Implementation of PSRS parallel sorting routine |
| partialSlipFvPatchField< Type > | Foam::partialSlipFvPatchField |
| partialWrite | Allows some fields/registered objects to be written more often than others |
| Particle< ParticleType > | |
| particleForces | Provides a mechanism to calculate particle forces Note: forces are force per unit mass (accelerations) |
| passiveParticle | |
| passiveParticleCloud | A Cloud of passive particles |
| patchCloudSet | Like cloudSet but samples nearest patch face |
| patchDataWave< TransferType > | Takes a set of patches to start MeshWave from |
| pointFieldDecomposer::patchFieldDecomposer | Point patch field decomposer class |
| fvFieldDecomposer::patchFieldDecomposer | Patch field decomposer class |
| meshToMesh::patchFieldInterpolator | Patch-field interpolation class |
| fvMeshSubset::patchFieldSubset | Patch-field subset interpolation class |
| patchIdentifier | Identifies patch by name, patch index and physical type |
| PatchInjection< CloudType > | Patch injection |
| patchInteractionData | Helper class for the LocalInteraction patch interaction model |
| PatchInteractionModel< CloudType > | Templated patch interaction model class |
| PatchPostProcessing< CloudType > | Standard post-processing |
| patchProbes | Set of locations to sample.at patches |
| patchToFace | A topoSetSource to select faces based on usage in patches |
| PatchTools | A collection of tools for searching, sorting PrimitivePatch information |
| PatchToPatchInterpolation< FromPatch, ToPatch > | Interpolation class dealing with transfer of data between two primitivePatches |
| 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 |
| patchWriter | Write patch fields |
| patchZones | Calculates zone number for every face of patch |
| 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 |
| pdf | |
| pdf | A library of runtime-selectable PDF's |
| PDRDragModel | Base-class for sub-grid obstacle drag models. The available drag model is at basic.H |
| PDRkEpsilon | Standard k-epsilon turbulence model with additional source terms corresponding to PDR basic drag model (basic.H) |
| perfectGas | Perfect gas equation of state |
| perfectInterface | Hack of attachDetach to couple patches when they perfectly align. Does not decouple. Used by stitchMesh app. Does geometric matching |
| phase | Single incompressible phase derived from the phase-fraction. Used as part of the multiPhaseMixture for interface-capturing multi-phase simulations |
| PhaseChangeModel< CloudType > | Templated phase change model class |
| phaseChangeTwoPhaseMixture | |
| phaseModel | |
| phaseProperties | Helper class to manage multi-component phase properties |
| phasePropertiesList | Simple container for a list of phase properties |
| PhiLimiter | Class with limiter function which returns the limiter for the Phi differencing scheme |
| PhiScheme< Type, PhiLimiter > | Class to create the weighting-factors based on the face-flux |
| pitchForkRing | |
| plane | Geometric class that creates a 2D plane and can return the intersection point between a line and the plane |
| plusEqMagSqrOp< T > | |
| plusEqMagSqrOp2< T1, T2 > | |
| plusEqOp< T > | |
| plusEqOp2< T1, T2 > | |
| plusOp< T > | |
| plusOp2< T1, T2 > | |
| plusOp3< T, T1, T2 > | |
| pointBoundaryMesh | Foam::pointBoundaryMesh |
| pointBoundaryMeshMapper | Foam::pointBoundaryMeshMapper |
| pointConstraint | Accumulates point constraints through successive applications of the applyConstraint function |
| pointData | Holds information regarding nearest wall point. Used in pointEdgeWave. (so not standard meshWave) |
| pointEdgePoint | Holds information regarding nearest wall point. Used in pointEdgeWave. (so not standard meshWave) To be used in wall distance calculation |
| PointEdgeWave< Type > | Wave propagation of information through grid. Every iteration information goes through one layer of edges. Templated on information that is transferred |
| pointFieldDecomposer | Point field decomposer |
| pointFieldReconstructor | Point field reconstructor |
| PointHit< Point > | 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< Point > | 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 |
| pointLinear | Face-point interpolation scheme class derived from linear and returns linear weighting factors but also applies an explicit correction |
| pointLinear< Type > | |
| 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 |
| pointMesh | Mesh representing a set of points created from polyMesh |
| pointMeshMapper | Class holds all the necessary information for mapping fields associated with pointMesh |
| pointPatch | Basic pointPatch represents a set of points from the mesh |
| pointPatchField< Type > | Abstract base class for point-mesh patch fields |
| pointPatchFieldMapper | Foam::pointPatchFieldMapper |
| pointPatchFieldMapperPatchRef | Foam::pointPatchFieldMapperPatchRef |
| pointFieldReconstructor::pointPatchFieldReconstructor | |
| fvMeshSubset::pointPatchFieldSubset | Patch-field subset interpolation class |
| pointPatchInterpolation | Foam::pointPatchInterpolation |
| pointPatchMapper | Mapping class for a pointPatchField |
| pointSet | A set of point labels |
| pointToCell | A topoSetSource to select cells based on usage of points |
| pointToFace | A topoSetSource to select faces based on use of points |
| pointToPoint | A topoSetSource to select points based on usage in pointSet |
| pointZone | A subset of mesh points. The labels of points in the zone can be obtained from the addressing() list |
| pointZoneSet | Like pointSet but updates pointZone when writing |
| 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 |
| polyBoundaryMesh | Foam::polyBoundaryMesh |
| polyBoundaryMeshEntries | Foam::polyBoundaryMeshEntries |
| polyDualMesh | Creates dual of polyMesh |
| 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 |
| polyMesh | Mesh consisting of general polyhedral cells |
| polyMeshAdder | Adds two meshes without using any polyMesh morphing |
| polyMeshGeometry | Updateable mesh geometry and checking routines |
| polyMeshModifier | Virtual base class for mesh modifiers |
| polyModifyCell | Class describing modification of a cell |
| polyModifyFace | Class describing modification of a face |
| polyModifyPoint | Class describing modification of a point |
| 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 |
| Polynomial< PolySize > | Polynomial templated on size (order): |
| polynomialTransport< Thermo, PolySize > | Transport package using polynomial functions for mu and kappa |
| polyPatch | A patch is a list of labels that address the faces in the global face list |
| polyPatchID | A class holds the data needed to identify a patch in a dynamic mesh |
| polyRemoveCell | Class containing data for cell removal |
| polyRemoveFace | Class containing data for face removal |
| polyRemovePoint | Class containing data for point removal |
| polyTopoChange | Direct mesh changes based on v1.3 polyTopoChange syntax |
| polyTopoChanger | List of mesh modifiers defining the mesh dynamics |
| porousZone | Porous zone definition based on cell zones |
| porousZones | A centralized porousZone collection |
| PostProcessingModel< CloudType > | Templated post-processing model class |
| potential | |
| powerLaw | Standard power-law non-Newtonian viscosity model |
| powerSeriesReactionRate | Power series reaction rate |
| powProduct< arg1, arg2 > | |
| PrandtlDelta | Simple cube-root of cell volume delta used in LES models |
| lduMatrix::preconditioner | Abstract base-class for lduMatrix preconditioners |
| prefixOSstream | Version of OSstream which prints a prefix on each line |
| pressureDirectedInletOutletVelocityFvPatchVectorField | Velocity inlet/outlet boundary condition for pressure boundary where the pressure is specified. zero-gradient is applied for outflow (as defined by the flux) and for inflow the velocity is obtained from the flux with the specified `inletDirection' |
| pressureDirectedInletVelocityFvPatchVectorField | Velocity inlet boundary condition for patches where the pressure is specified. The inflow velocity is obtained from the flux with the specified "inletDirection" direction. If reverse flow is possible or expected use the "pressureDirectedInletOutletVelocityFvPatchVectorField" BC instead |
| pressureGradientExplicitSource | Creates a cell set pressure gradient source |
| pressureInletOutletVelocityFvPatchVectorField | Velocity inlet/outlet boundary condition patches for where the pressure is specified. zero-gradient is applied for outflow (as defined by the flux) and for inflow the velocity is obtained from the patch-face normal component of the internal-cell value |
| pressureInletUniformVelocityFvPatchVectorField | Velocity inlet boundary condition for patches where the pressure is specified. The uniform inflow velocity is obtained by averaging the flux over the patch and apply it in the direction normal to the patch faces |
| pressureInletVelocityFvPatchVectorField | Velocity inlet boundary condition for patches where the pressure is specified. The inflow velocity is obtained from the flux with a direction normal to the patch faces. If reverse flow is possible or expected use the "pressureInletOutletVelocityFvPatchVectorField" BC instead |
| pressureNormalInletOutletVelocityFvPatchVectorField | Velocity inlet/outlet boundary condition for patches where the pressure is specified. zero-gradient is applied for outflow (as defined by the flux) and for inflow the velocity is obtained from the flux with a direction normal to the patch faces |
| pressureSwirlInjector | Randomly distribute the parcels between the inner and outer cone angle |
| 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 |
| primitiveMesh | Cell-face mesh analysis engine |
| primitiveMeshGeometry | Updateable mesh geometry + checking routines |
| PrimitivePatch< Face, FaceList, PointField, PointType > | A list of faces which address into the list of points |
| PrimitivePatchInterpolation< Patch > | Interpolation class within a primitive patch. Allows interpolation from points to faces and vice versa |
| PrimitivePatchName | |
| prismMatcher | A cellMatcher for prism cells |
| probes | Set of locations to sample |
| processorFvPatch | Processor patch |
| processorFvPatchField< Type > | Foam::processorFvPatchField |
| processorFvsPatchField< Type > | Foam::processorFvsPatchField |
| processorGAMGInterface | GAMG agglomerated processor interface |
| processorGAMGInterfaceField | GAMG agglomerated processor interface field |
| processorLduInterface | An abstract base class for processor coupled interfaces |
| processorLduInterfaceField | Abstract base class for processor coupled interfaces |
| processorMeshes | Container for processor mesh addressing |
| processorPointPatch | Processor patch boundary needs to be such that the ordering of points in the patch is the same on both sides |
| processorPointPatchField< Type > | Foam::processorPointPatchField |
| processorPolyPatch | Neighbour processor patch |
| fvFieldDecomposer::processorSurfacePatchFieldDecomposer | Processor patch field decomposer class. Surface field is assumed |
| ProcessorTopology< Patch, ProcPatch > | Determines processor-processor connection. After instantiation contains on all processors the processor-processor connection table |
| fvFieldDecomposer::processorVolPatchFieldDecomposer | Processor patch field decomposer class. Maps either owner or |
| procLduInterface | Foam::procLduInterface |
| procLduMatrix | Foam::procLduMatrix |
| proxySurfaceWriter< Type > | |
| psiChemistryModel | Chemistry model for compressibility-based thermodynamics |
| Pstream | Inter-processor communications stream |
| PstreamBase | Helper class |
| PstreamImpl | Abstract base class for Pstream operations that depend on the parallel library used. Foam::PstreamImpl::New will lookup the entry "PstreamImplementation" in the global controlDict file (i.e. the one found by Foam::dotFoam) and tries to first load a library named lib<PstreamImplementation>Pstream.so, and then instantiate the class <PstreamImplementation>PstreamImpl |
| pTraits< PrimitiveType > | Traits class for primitives |
| pTraits< bool > | |
| pTraits< label > | Template specialization for pTraits<label> |
| pTraits< Scalar > | |
| pTraits< uLabel > | Template specialization for pTraits<uLabel> |
| PtrDictionary< T > | Template dictionary class which does not manages the storage associated with it |
| PtrList< T > | 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 |
| PtrMap< T > | A HashTable of pointers to objects of type <T> with a label key |
| pureMixture< ThermoType > | Foam::pureMixture |
| pureUpwindCFCCellToFaceStencilObject | |
| PureUpwindFitScheme< Type, Polynomial, Stencil > | Upwind biased fit surface interpolation scheme that applies an explicit correction to upwind |
| pyramid< Point, PointRef, polygonRef > | 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 |
| pyrMatcher | A cellMatcher for pyr cells |
| quadraticDiffusivity | Mesh motion diffusivity maipulator which returns the sqr of the given diffusivity |
| quadraticFitPolynomial | Quadratic polynomial for centred interpolation fitting |
| quadraticFitSnGrad< Type > | |
| quadraticFitSnGrad | Simple central-difference snGrad scheme with quadratic fit correction from a larger stencil |
| quadraticFitSnGradData | Data for the quadratic fit correction snGrad scheme |
| quadraticFitSnGradData | |
| 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 |
| quaternion | Quaternion class used to perform rotations in 3D space |
| QUICKLimiter< LimiterFunc > | Class with limiter function which returns the limiter for the quadratic-upwind differencing scheme |
| QUICKVLimiter< LimiterFunc > | Class with limiter function which returns the limiter for the quadratic-upwind differencing scheme |
| qZeta | Gibson and Dafa'Alla's q-zeta two-equation low-Re turbulence model for incompressible flows |
| radialModel | |
| radiationModel | Top level model for radiation modelling |
| radiativeIntensityRay | Radiation intensity for a ray in a given direction |
| Random | Simple random number generator |
| randomise | Adds a random component to a field, with a given perturbation magnitude |
| RanzMarshall< CloudType > | The Ranz-Marshal correlation for heat transfer |
| RASModel | Abstract base class for turbulence models for compressible and combusting flows |
| incompressible::RASModel | Abstract base class for incompressible turbulence models |
| rawGraph | A raw xy graph output |
| rawSetWriter< Type > | |
| rawSurfaceWriter< Type > | |
| rawTopoChangerFvMesh | TopoChangerFvMesh without any added functionality |
| plane::ray | A direction and a reference point |
| reactingCloud | Virtual abstract base class for templated ReactingCloud |
| ReactingCloud< ParcelType > | Templated base class for reacting cloud |
| ReactingLookupTableInjection< CloudType > | Particle injection sources read from look-up table. Each row corresponds to an injection site |
| reactingMixture< ThermoType > | Foam::reactingMixture |
| reactingMultiphaseCloud | Virtual abstract base class for templated reactingMultiphaseCloud |
| ReactingMultiphaseCloud< ParcelType > | Templated base class for multiphase reacting cloud |
| ReactingMultiphaseLookupTableInjection< CloudType > | Particle injection sources read from look-up table. Each row corresponds to an injection site |
| ReactingMultiphaseParcel< ParcelType > | Multiphase variant of the reacting parcel class with one/two-way coupling with the continuous phase |
| reactingMultiphaseParcelInjectionData | Container class to provide injection data for reacting multiphase parcels |
| reactingParcel | Base class for reacting parcel - simply used to set the contiguous flag |
| ReactingParcel< ParcelType > | Reacting parcel class with one/two-way coupling with the continuous phase |
| reactingParcelInjectionData | Container class to provide injection data for reacting parcels |
| Reaction< ReactionThermo > | Simple extension of ReactionThermo to handle reaction kinetics in addition to the equilibrium thermodynamics already handled |
| dlLibraryTable::readDlLibrary | Class whose construction causes the reading of dynamic libraries |
| readerDatabase | Singleton caching Foam database and mesh and various. Used in Fv reader to keep track of data inbetween callbacks |
| readFields | Reads fields from the time folders and adds them to the mesh database for further post-processing |
| realizableKE | Realizable k-epsilon turbulence model for incompressible flows |
| realizableKE | Realizable k-epsilon turbulence model for compressible flows |
| Rebound< CloudType > | Simple rebound patch interaction model |
| receivingReferralList | |
| RectangularMatrix< Type > | 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 |
| reducedUnits | |
| refCount | Reference counter for tmp<field> |
| referredCell | |
| referredCellList | |
| referredMolecule | |
| refineCell | Container with cells to refine. Refinement given as single direction |
| refinementData | Transfers refinement levels such that slow transition between levels is maintained. Used in meshWave |
| refinementDistanceData | Transfers refinement levels such that slow transition between levels is maintained. Used in FaceCellWave |
| refinementHistory | All refinement history. Used in unrefinement |
| refinementIterator | Utility class to do iterating meshCutter until all requests satisfied |
| refinementParameters | Simple container to keep together refinement specific information |
| refinementSurfaces | Container for data on surfaces used for surface-driven refinement. Contains all the data about the level of refinement needed per surface |
| reflectionVectors | Container for reflection vectors (= unit normal of nearest wall) |
| reflectParcel | The parcels are reflected back from the wall in an inelastic collision |
| regExp | Wrapper around POSIX extended regular expressions |
| regionProperties | |
| regionProperties | Simple class to hold region information for coupled region simulations |
| regionSide | Determines the 'side' for every face and connected to a singly-connected (through edges) region of faces. Gets set of faces and a list of mesh edges ('fenceEdges') which should not be crossed. Used in splitting a mesh region |
| regionSplit | This class separates the mesh into distinct unconnected regions, each of which is then given a label |
| regionToCell | TopoSetSource. Select cells belonging to topological connected region (that contains given point) |
| regIOobject | RegIOobject is an abstract class derived from IOobject to handle automatic object registration with the objectRegistry |
| reitzDiwakar | Secondary breakup model for the spray |
| reitzKHRT | Secondary breakup model which uses the Kelvin-Helmholtz instability theory to predict the 'stripped' droplets... and the Raleigh-Taylor instability as well |
| removeCells | Given list of cells to remove insert all the topology changes |
| removeEntry | Remove a dictionary entry |
| removeFaces | Given list of faces to remove insert all the topology changes. Contains helper function to get consistent set of faces to remove |
| removeParcel | Remove parcel, regardless of boundary type |
| removePoints | Removes selected points from mesh and updates faces using these points |
| 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 |
| restrainedHarmonicSpring | |
| reuseTmp< TypeR, Type1 > | |
| reuseTmp< TypeR, TypeR > | |
| reuseTmpDimensionedField< TypeR, Type1, GeoMesh > | |
| reuseTmpDimensionedField< TypeR, TypeR, GeoMesh > | |
| reuseTmpFieldField< Field, TypeR, Type1 > | |
| reuseTmpFieldField< Field, TypeR, TypeR > | |
| reuseTmpGeometricField< TypeR, Type1, PatchField, GeoMesh > | |
| reuseTmpGeometricField< TypeR, TypeR, PatchField, GeoMesh > | |
| reuseTmpTmp< TypeR, Type1, Type12, Type2 > | |
| reuseTmpTmp< TypeR, Type1, Type12, TypeR > | |
| reuseTmpTmp< TypeR, TypeR, TypeR, Type2 > | |
| reuseTmpTmp< TypeR, TypeR, TypeR, TypeR > | |
| reuseTmpTmpDimensionedField< TypeR, Type1, Type12, Type2, GeoMesh > | |
| reuseTmpTmpDimensionedField< TypeR, Type1, Type12, TypeR, GeoMesh > | |
| reuseTmpTmpDimensionedField< TypeR, TypeR, TypeR, Type2, GeoMesh > | |
| reuseTmpTmpDimensionedField< TypeR, TypeR, TypeR, TypeR, GeoMesh > | |
| reuseTmpTmpFieldField< Field, TypeR, Type1, Type12, Type2 > | |
| reuseTmpTmpFieldField< Field, TypeR, Type1, Type12, TypeR > | |
| reuseTmpTmpFieldField< Field, TypeR, TypeR, TypeR, Type2 > | |
| reuseTmpTmpFieldField< Field, TypeR, TypeR, TypeR, TypeR > | |
| reuseTmpTmpGeometricField< TypeR, Type1, Type12, Type2, PatchField, GeoMesh > | |
| reuseTmpTmpGeometricField< TypeR, Type1, Type12, TypeR, PatchField, GeoMesh > | |
| reuseTmpTmpGeometricField< TypeR, TypeR, TypeR, Type2, PatchField, GeoMesh > | |
| reuseTmpTmpGeometricField< TypeR, TypeR, TypeR, TypeR, PatchField, GeoMesh > | |
| reverseLinear< Type > | Inversed weight central-differencing interpolation scheme class |
| ReversibleReaction< ReactionThermo, ReactionRate > | Simple extension of Reaction to handle reversible reactions using equilibrium thermodynamics |
| rhoChemistryModel | Chemistry model for density-based thermodynamics |
| rhoMagSqr< Type > | |
| RK | Foam::RK |
| RNGkEpsilon | Renormalisation group k-epsilon turbulence model for compressible flows |
| RNGkEpsilon | Renormalisation group k-epsilon turbulence model for incompressible flows |
| RosinRammler | |
| RosinRammler | Rosin-Rammler pdf |
| rotatedBoxToCell | A topoSetSource to select cells based on cell centres inside rotated/skewed box (parallelopiped?) |
| rotatingPressureInletOutletVelocityFvPatchVectorField | Velocity inlet/outlet boundary condition in a rotating frame for patches where the pressure is specified. zero-gradient is applied for outflow (as defined by the flux) and for inflow the velocity is obtained from the flux with a direction normal to the patch faces |
| rotatingTotalPressureFvPatchScalarField | Foam::rotatingTotalPressureFvPatchScalarField |
| rotatingWallVelocityFvPatchVectorField | Foam::rotatingWallVelocityFvPatchVectorField |
| rpm | Basic SRF model whereby angular velocity is specified in terms of a (global) axis and revolutions-per-minute [rpm] |
| runTimeSelectionTables | Macros to enable the easy declaration of run-time selection tables |
| RutlandFlashBoil | Evaporation model with flash boiling |
| sammMesh | |
| sammMesh | A messy mesh class which supports the possibility of creating a shapeMesh for regular Samm meshes (no arbitrary interfaces or collapsed SAMM cells). If any of these special feateres exist, the mesh is created as polyMesh |
| sampledCuttingPlane | A sampledSurface defined by a plane |
| sampledIsoSurface | A sampledSurface defined by a surface of iso value. Always triangulated. To be used in sampleSurfaces / functionObjects. Recalculates iso surface only if time changes |
| sampledIsoSurfaceCell | A sampledSurface defined by a surface of iso value. Always triangulated. To be used in sampleSurfaces / functionObjects. Recalculates iso surface only if time changes |
| sampledPatch | A sampledSurface on a patch. Non-triangulated by default |
| sampledPlane | A sampledSurface defined by a cuttingPlane. Always triangulated |
| sampledSet | Holds list of sampling points which is filled at construction time. Various implementations of this base class to e.g. get sampling points at uniform distance along a line (uniformSet) or directly specified (cloudSet) |
| sampledSets | Set of sets to sample. Call sampledSets.write() to sample&write files |
| sampledSurface | An abstract class for surfaces with sampling |
| sampledSurfaces | Set of surfaces to sample |
| sampledThresholdCellFaces | A sampledSurface defined by the cell faces corresponding to a threshold value |
| sampledTriSurfaceMesh | A sampledSurface from a triSurfaceMesh. It samples on the points/triangles of the triSurface |
| saturateEvaporationModel | Saturate evaporation model. Characteristic time is calculated to immediately saturate the cell It should be mentioned that this is coupled with the (implicit) way evaporation is done in parcel, since the evaporation time depends on the integration step |
| scalarMatrices | Scalar matrices |
| scalarProduct< arg1, arg2 > | |
| scalarRange | A scalar range specifier |
| scalarRanges | A List of scalarRange |
| scaleSimilarity | General base class for all scale similarity models for incompressible flows |
| scatterModel | Base class for radiation scattering |
| SchaefferFrictionalStress | |
| SchillerNaumann | |
| SchnerrSauer | SchnerrSauer cavitation model |
| SCOPE | Laminar flame speed obtained from the SCOPE correlation |
| 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 | |
| XiEqModel::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 |
| scotchDecomp | Scotch domain decomposition |
| SDA | Ship design analysis (SDA) 3DoF motion function |
| 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 |
| 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:
- shift test vector with two small vectors (of size gap_) perpendicular to the original. Test with + and - this vector. Only if both register a hit is it seen as one.
- extend the test vector slightly (with SMALL) to account for numerical inaccuracies
|
| sendingReferralList | |
| septernion | Septernion class used to perform translations and rotations in 3D space |
| sequential< CompType, ThermoType > | Foam::sequential |
| setsToFaceZone | A topoSetSource to select faces based on usage in a faceSet and cellSet |
| setToCellZone | A topoSetSource to select cells based on usage in a cellSet |
| setToFaceZone | A topoSetSource to select faces based on usage in a faceSet. Sets flipMap to true |
| setToPointZone | A topoSetSource to select points based on usage in a pointSet |
| setUpdater | Keeps cell/face/vertex sets uptodate. Both the ones loaded and the ones on disk |
| SFCDLimiter< LimiterFunc > | Class with limiter function which returns the limiter for the SFCD differencing scheme based on phict obtained from the LimiterFunc class |
| SHA1 | Functions to compute SHA1 message digest according to the NIST specification FIPS-180-1 |
| SHA1Digest | The SHA1 message digest |
| sha1streambuf | A streambuf class for calculating SHA1 digests |
| shapeToCell | A topoSetSource to select cells based on cell shape |
| shellSurfaces | Encapsulates queries for volume refinement ('refine all cells within shell') |
| SHF | Secondary Breakup Model to take account of the different breakup regimes, bag, molutimode, shear... |
| shifted | |
| shiftedForce | |
| SIBS | Foam::SIBS |
| sigFpe | Set up trapping for floating point exceptions (signal FPE) |
| sigFpeImpl | Set up trapping for floating point exceptions (signal FPE) |
| sigInt | Signal handler for INT interupt |
| sigIntImpl | Signal handler for INT interupt |
| sigmaRadial | |
| sigmoid | |
| sigQuit | Signal handler for QUIT interupt |
| sigQuitImpl | Signal handler for QUIT interupt |
| sigSegv | Signal handler for SEGV interupt |
| sigSegvImpl | Signal handler for SEGV interupt |
| simpleFilter | Simple top-hat filter used in dynamic LES models |
| simpleGeomDecomp | |
| simpleMatrix< Type > | A simple square matrix solver with scalar coefficients |
| SinclairJacksonRadial | |
| SingleKineticRateDevolatilisation< CloudType > | Single kinetic rate devolatisation model |
| SingleMixtureFraction< CloudType > | Templated parcel multi-phase, multi-component class |
| SinglePhaseMixture< CloudType > | Templated parcel single phase, multi-component class |
| singlePhaseTransportModel | A simple single-phase transport model based on viscosityModel |
| sixDoFRigidBodyDisplacementPointPatchVectorField | Foam::sixDoFRigidBodyDisplacementPointPatchVectorField |
| sixDoFRigidBodyMotion | Six degree of freedom motion for a rigid body. Angular momentum stored in body fixed reference frame. Reference orientation of the body (where Q = I) must align with the cartesian axes such that the Inertia tensor is in principle component form |
| sixDoFRigidBodyMotionConstraint | Base class for defining constraints for sixDoF motions |
| sixDoFRigidBodyMotionRestraint | Base class for defining restraints for sixDoF motions |
| sixDoFRigidBodyMotionState | Holds the motion state of sixDoF object. Wrapped up together to allow rapid scatter to other processors. The processors must all maintain exactly the same state data to avoid any drift or inconsistency |
| SKA | Sea Keeping Analysis (SKA) 6DoF motion function |
| skewCorrected< Type > | Skewness-corrected interpolation scheme that applies an explicit correction to given scheme |
| skewCorrectionVectors | Skew-correction vectors for the skewness-corrected interpolation scheme |
| slicedFvPatchField< Type > | Specialization of fvPatchField which creates the underlying fvPatchField as a slice of the given complete field |
| slicedFvsPatchField< Type > | Specialization of fvsPatchField which creates the underlying fvsPatchField as a slice of the given complete field |
| SlicedGeometricField< Type, PatchField, SlicedPatchField, GeoMesh > | Specialization of GeometricField which holds slices of given complete fields in a form that they act as a GeometricField |
| slidingInterface | Sliding interface mesh modifier. Given two face zones, couple the master and slave side using a cutting procedure |
| slipFvPatchField< Type > | Foam::slipFvPatchField |
| slipPointPatchField< Type > | Foam::slipPointPatchField |
| SLList< T > | Non-intrusive singly-linked list |
| SLListBase | Base singly-linked list |
| SLPtrList< T > | Non-intrusive singly-linked pointer list |
| SLTSDdtScheme< Type > | Stabilised local time-step first-order Euler implicit/explicit ddt. The time-step is adjusted locally so that an advective equations remains diagonally dominant |
| Smagorinsky | The choric Smagorinsky Model for compressible flows |
| Smagorinsky | The Isochoric Smagorinsky Model for incompressible flows |
| Smagorinsky2 | The Isochoric Smagorinsky Model for incompressible flows |
| Smanip< T > | |
| SMESHsurfaceFormat< Face > | Provide a means of writing tetgen SMESH format |
| smoluchowskiJumpTFvPatchScalarField | Smoluchowski temperature jump boundary condition |
| smoothDelta | Smoothed delta which takes a given simple geometric delta and applies smoothing to it such that the ratio of deltas between two cells is no larger than a specified amount, typically 1.15 |
| lduMatrix::smoother | Abstract base-class for lduMatrix smoothers |
| 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 |
| snapParameters | Simple container to keep together snap specific information |
| snGradScheme< Type > | Abstract base class for snGrad schemes |
| solid | The thermophysical properties of a solid |
| solidBodyMotionFunction | Base class for defining solid-body motions |
| solidBodyMotionFvMesh | Solid-body motion of the mesh specified by a run-time selectable motion function |
| solidMixture | Foam::solidMixture |
| solidParticle | Simple solid spherical particle class with one-way coupling with the continuous phase |
| solidParticleCloud | A Cloud of solid particles |
| solidWallHeatFluxTemperatureFvPatchScalarField | |
| solidWallHeatFluxTemperatureFvPatchScalarField | Heat flux boundary condition for temperature on solid region |
| solidWallMixedTemperatureCoupledFvPatchScalarField | Mixed boundary condition for temperature, to be used by the conjugate heat transfer solver. Both sides use a mix of zeroGradient and neighbourvalue |
| solidWallMixedTemperatureCoupledFvPatchScalarField | |
| solution | Selector class for relaxation factors, solver type and solution |
| lduMatrix::solver | Abstract base-class for lduMatrix solvers |
| lduMatrix::solverPerformance | Class returned by the solver, containing performance statistics |
| SortableList< T > | A list that is sorted upon construction or when explicitly requested with the sort() method |
| sortLabelledTri | Helper class which when constructed with a triSurface sorts the faces according to region number (or rather constructs a mapping) |
| SpalartAllmaras | Spalart-Allmaras 1-eqn mixing-length model for incompressible external flows |
| SpalartAllmaras | SpalartAllmaras for compressible flows |
| SpalartAllmaras | |
| SpalartAllmaras | Spalart-Allmaras one-eqn mixing-length model for compressible external flows |
| SpalartAllmaras | SpalartAllmaras DES (SA + LES) turbulence model for incompressible flows |
| SpalartAllmarasDDES | SpalartAllmaras DDES LES turbulence model for incompressible flows |
| SpalartAllmarasDDES | |
| SpalartAllmarasIDDES | SpalartAllmarasIDDES LES turbulence model for incompressible flows |
| SpalartAllmarasIDDES | |
| specie | Base class of the thermophysical property types |
| Reaction< ReactionThermo >::specieCoeffs | Class to hold the specie index and its coefficients in the |
| chemkinReader::specieElement | Species element |
| speciesTable | A table of species |
| speciesTransport | Basic species transport type based on the use of a fitting function for nu |
| specieThermo< thermo > | Basic thermodynamics type based on the use of fitting functions for cp, h, s obtained from the template argument type thermo. All other properties are derived from these primitive functions |
| spectEddyVisc | The Isochoric spectral Eddy Viscosity Model for incompressible flows |
| SpecularReflection< CloudType > | Reversing the wall-normal component of the particle velocity |
| SphereDrag< CloudType > | Drag model based on assumption of solid spheres |
| sphereToCell | A topoSetSource to select cells based on cell centres inside sphere |
| sphericalAngularSpring | SixDoFRigidBodyMotionRestraints model. Spherical angular spring |
| sphericalCS | Spherical coordinate system |
| SphericalTensor< Cmpt > | 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 |
| SphericalTensor2D< Cmpt > | 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 |
| splineEdge | A curvedEdge interface for Catmull-Rom splines |
| splitCell | Description of cell after splitting. Contains cellLabel and pointers to cells it it split in. See directedRefinement |
| refinementHistory::splitCell8 | |
| spray | A spray is a cloud of parcels |
| SquareMatrix< Type > | 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 |
| SRFFreestreamVelocityFvPatchVectorField | Freestream velocity patch to be used with SRF model to apply the appropriate rotation transformation in time and space |
| SRFModel | Top level model for single rotating frame
- Steady state only - no time derivatives included
|
| SRFVelocityFvPatchVectorField | Velocity patch to be used with SRF model |
| SRIFallOffFunction | The SRI fall-off function |
| stabiliseOp< T > | |
| stabiliseOp2< T1, T2 > | |
| stabiliseOp3< T, T1, T2 > | |
| standardDragModel | Standard drag law model with a lower limit on the Cd-value |
| standardEvaporationModel | Standard evaporation model based on the logarithmic expression of the ration of pressure differences |
| StandardWallInteraction< CloudType > | Wall interaction model. Three choices:
- rebound - optionally specify elasticity and resitution coefficients
- stick - particles assigined zero velocity
- escape - remove particle from the domain
|
| STARCD | Writes polyMesh in pro-STAR (v4) bnd/cel/vrt format |
| STARCD | Read pro-STAR vrt/cel/bnd files. The protected data in meshReader are filled |
| STARCDCoordinateRotation | A coordinateRotation defined by the STAR-CD convention |
| STARCDsurfaceFormat< Face > | Read/write the surface shells from pro-STAR vrt/cel files |
| STARCDsurfaceFormatCore | Internal class used by the STARCDsurfaceFormat |
| starMesh | |
| starMesh | A messy mesh class which supports the possibility of creating a shapeMesh for regular Star meshes (no arbitrary interfaces or collapsed SAMM cells). If any of these special feateres exist, the mesh is created as polyMesh |
| StaticAssertionFailed | Macros and classes to provide static (compile-time) assertions |
| StaticAssertionFailed< true > | Specialization for successful assertions |
| StaticAssertionTest< Test > | Helper class for handling static assertions |
| staticEngineMesh | Foam::staticEngineMesh |
| staticFvMesh | Foam::staticFvMesh |
| StaticHashTable< T, Key, Hash > | STL conforming hash table |
| staticPressure | Converts kinematic pressure to static pressure, from the name of the pressure field, and density, i.e |
| steadyStateD2dt2Scheme< Type > | SteadyState d2dt2 which returns 0 |
| steadyStateDdtScheme< Type > | SteadyState implicit/explicit ddt which returns 0 |
| STLpoint | A vertex point representation for STL files |
| STLsurfaceFormat< Face > | Provide a means of reading/writing STL files (ASCII and binary) |
| STLsurfaceFormatCore | Internal class used by the STLsurfaceFormat |
| STLtriangle | A triangle representation for STL files |
| StochasticDispersionRAS< CloudType > | The velocity is perturbed in random direction, 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 |
| string | A class for handling character strings derived from std::string |
| subCycle< GeometricField > | Perform a subCycleTime on a field |
| subCycleTime | A class for managing sub-cycling times |
| SubDimensionedField< Type, GeoMesh > | SubDimensionedField is a DimensionedField obtained as a section of another DimensionedField |
| SubField< Type > | SubField is a Field obtained as a section of another Field |
| SubList< T > | A List obtained as a section of another List |
| substance | |
| forces::sumOp | Sum operation class to accumulate the pressure, viscous forces and moments |
| sumOp< T > | |
| sumOp2< T1, T2 > | |
| sumOp3< T, T1, T2 > | |
| SuperBeeLimiter< LimiterFunc > | Class with limiter function which returns the limiter for the SuperBee differencing scheme based on r obtained from the LimiterFunc class |
| supersonicFreestreamFvPatchVectorField | Supersonic free stream condition |
| surfaceDisplacementPointPatchVectorField | Displacement fixed by projection onto triSurface. Use in a displacement fvMotionSolver as a bc on the pointDisplacement field |
| surfaceDisplacementPointPatchVectorField | |
| surfaceFeatures | Holds feature edges/points of surface |
| surfaceFormatsCore | A collection of helper functions for reading/writing surface formats |
| surfaceInterpolateFields | Reads fields from the time folders and adds them to the mesh database for further post-processing |
| surfaceInterpolation | Cell to surface interpolation scheme. Included in fvMesh |
| surfaceInterpolationScheme< Type > | Abstract base class for surface interpolation schemes |
| surfaceIntersection | Basic surface-surface intersection description. Constructed from two surfaces it creates a description of the intersection |
| surfaceLocation | Contains information about location on a triSurface: |
| surfaceMesh | Mesh data needed to do the Finite Volume discretisation |
| surfaceNormalFixedValueFvPatchVectorField | Describes a surface normal vector boundary condition by its magnitude. Note: The value is positive for outward-pointing vectors |
| surfacePatch | 'Patch' on surface as subset of triSurface |
| surfacePatchIOList | IOobject for a surfacePatchList |
| SurfaceReactionModel< CloudType > | Templated surface reaction model class |
| surfaceRegistry | Wraps the normal objectRegistry with a local instance for surfaces |
| surfaceSets | Various utilities to handle sets relating mesh to surface. Note: work in progress. Used in meshing tools |
| surfaceSlipDisplacementFvPatchField< Type > | FvPatchField corresponding to surfaceSlipDisplacementPointPatchField. Is just a slip type since all hard work (projection) is done in the pointPatch field |
| surfaceSlipDisplacementPointPatchVectorField | Displacement follows a triSurface. Use in a displacement fvMotionSolver as a bc on the pointDisplacement field. Following is done by calculating the projection onto the surface according to the projectMode
- NEAREST : nearest
- POINTNORMAL : intersection with point normal
- FIXEDNORMAL : intersection with fixed vector
|
| surfaceToCell | A topoSetSource to select cells based on relation to surface |
| surfaceToPoint | A topoSetSource to selects points based on relation to surface |
| surfaceWriter< Type > | |
| surfAndLabel | Hold surface and label |
| surfFields | Fields for surfMesh |
| surfGeoMesh | The surfMesh GeoMesh (for holding fields) |
| surfMesh | A surface mesh consisting of general polygon faces |
| surfPointFields | Point fields for surfMesh |
| surfPointGeoMesh | The surfMesh GeoMesh (for holding fields) |
| surfZone | A surface zone on a MeshedSurface |
| surfZoneIdentifier | An identifier for a surface zone on a meshed surface |
| surfZoneIOList | IOobject for a surfZoneList |
| sutherlandTransport< thermo > | Transport package using Sutherland's formula |
| SVD | Singular value decomposition of a rectangular matrix |
| swirlFlowRateInletVelocityFvPatchVectorField | Describes a volumetric/mass flow normal vector boundary condition by its magnitude as an integral over its area with a swirl component determined by the RPM |
| swirlInjector | The swirl injector |
| Switch | A simple wrapper around bool so that it can be read as a word: true/false, on/off, yes/no or y/n or none |
| SyamlalConductivity | |
| 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 |
| SyamlalRogersOBrienPressure | |
| SyamlalViscosity | |
| SyamlalViscosity | |
| symmetryFvPatch | Symmetry-plane patch |
| symmetryFvPatchField< Type > | Foam::symmetryFvPatchField |
| symmetryFvsPatchField< Type > | Foam::symmetryFvsPatchField |
| symmetryPointPatch | Symmetry-plane patch |
| symmetryPointPatchField< Type > | A Symmetry boundary condition for pointField |
| symmetryPolyPatch | Symmetry-plane patch |
| SymmTensor< Cmpt > | 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, rank > | |
| symmTypeOfRank< Cmpt, 0 > | |
| symmTypeOfRank< Cmpt, 1 > | |
| symmTypeOfRank< Cmpt, 2 > | |
| syncTools | Various tools to aid synchronizing lists across coupled patches |
| syringePressureFvPatchScalarField | Pressure boundary condition obtained from a 0-D model of the cylinder of a syringe |
| systemCall | Executes system calls, entered in the form of a string list |
| TAB | The TAB Method for Numerical Calculation of Spray Droplet Breakup |
| Table< Type > | 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 the form, e.g. for an entry <entryName> that is (scalar, vector): |
| tableReader< Type > | Base class to read table data for the interpolationTable |
| tabulatedAxialAngularSpring | SixDoFRigidBodyMotionRestraints model. Axial angular spring with moment values drawn from an interpolation table. Linear damping |
| Tensor< Cmpt > | 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 |
| Tensor2D< Cmpt > | 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 |
| tetCell | A tetrahedral cell primitive |
| tetherPotential | |
| tetherPotentialList | |
| tetMatcher | A cellMatcher for tet cells |
| tetrahedron< Point, PointRef > | A tetrahedron primitive |
| tetWedgeMatcher | A cellMatcher for tetWedge cells |
| ThermoCloud< ParcelType > | Templated base class for thermodynamic cloud |
| thermoCloud | Virtual abstract base class for templated ThermoCloud |
| ThermoLookupTableInjection< CloudType > | Particle injection sources read from look-up table. Each row corresponds to an injection site |
| ThermoParcel< ParcelType > | Thermodynamic parcel class with one/two-way coupling with the continuous phase. Includes Kinematic parcel sub-models, plus:
|
| thermoParcelInjectionData | Container class to provide injection data for thermodynamic parcels |
| thermophysicalFunction | Abstract base class for thermo-physical functions |
| ThermoType | |
| thirdBodyArrheniusReactionRate | Arrhenius reaction rate enhanced by third-body interation |
| thirdBodyEfficiencies | Third body efficiencies |
| threePhaseInterfaceProperties | |
| threePhaseInterfaceProperties | Properties to aid interFoam : 1. Correct the alpha boundary condition for dynamic contact angle. 2. Calculate interface curvature |
| threePhaseMixture | |
| threePhaseMixture | |
| thresholdCellFaces | Selects the mesh cell faces specified by a threshold value. Non-triangulated by default |
| Time | Class to control time during OpenFOAM simulations that is also the top-level objectRegistry |
| TimeActivatedExplicitSource< Type > | Time activated explicit source |
| TimeActivatedExplicitSourceList< Type > | List of time activeted explict sources |
| TimePaths | A class for addressing time paths without using the Time class |
| timer | Implements a timeout mechanism via sigalarm |
| timeSelector | A List of scalarRange for selecting times |
| TimeState | The time value with time-stepping information, user-defined remapping, etc |
| timeVaryingAlphaContactAngleFvPatchScalarField | A time-varying alphaContactAngle scalar boundary condition (alphaContactAngleFvPatchScalarField) |
| timeVaryingFlowRateInletVelocityFvPatchVectorField | A time-varying form of a flow normal vector boundary condition |
| timeVaryingMappedFixedValueFvPatchField< Type > | Foam::timeVaryingMappedFixedValueFvPatchField |
| timeVaryingMappedPressureDirectedInletVelocityFvPatchVectorField | Velocity inlet boundary condition for patches where the pressure is specified. The inflow velocity is obtained from the flux with the "inletDirection" direction mapped from a time/space-varying table |
| timeVaryingMappedTotalPressureFvPatchScalarField | Foam::timeVaryingMappedTotalPressureFvPatchScalarField |
| timeVaryingUniformFixedValueFvPatchField< Type > | A time-varying form of a uniform fixed value boundary condition |
| timeVaryingUniformFixedValuePointPatchField< Type > | A time-varying form of a uniform fixed value boundary condition |
| timeVaryingUniformInletOutletFvPatchField< Type > | A time-varying form of a uniform fixed value boundary condition |
| timeVaryingUniformTotalPressureFvPatchScalarField | A time-varying form of a uniform total pressure boundary condition |
| tmp< T > | A class for managing temporary objects |
| token | A token holds items read from Istream |
| tolerances | Selector class for solution tolerances |
| topoAction | A virtual base class for topological actions |
| 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 |
| topoChangerFvMesh | Abstract base class for a topology changing fvMesh |
| topoSet | General set of labels of mesh quantity (points, cells, faces) |
| topoSetSource | Base class of a source for a topoSet |
| toroidalCS | Toroidal coordinate system, always in degrees |
| totalPressureFvPatchScalarField | Foam::totalPressureFvPatchScalarField |
| totalTemperatureFvPatchScalarField | Foam::totalTemperatureFvPatchScalarField |
| KinematicParcel< ParcelType >::trackData | Class used to pass kinematic tracking data to the trackToFace function |
| ThermoParcel< ParcelType >::trackData | Class used to pass thermo tracking data to the trackToFace function |
| ReactingMultiphaseParcel< ParcelType >::trackData | Class used to pass reacting tracking data to the trackToFace function |
| DsmcParcel< ParcelType >::trackData | Class used to pass kinematic tracking data to the trackToFace function |
| Particle< ParticleType >::trackData | Class used to pass tracking data to the trackToFace function |
| solidParticle::trackData | Class used to pass tracking data to the trackToFace function |
| trackedParticle::trackData | Class used to pass tracking data to the trackToFace function |
| ReactingParcel< ParcelType >::trackData | Class used to pass reacting tracking data to the trackToFace function |
| molecule::trackData | Class used to pass tracking data to the trackToFace function |
| trackedParticle | Particle class that marks cells it passes through. Used to mark cells visited by feature edges. Uses ExactParticle tracking class so will work on concave cells |
| tractionDisplacementCorrectionFvPatchVectorField | |
| tractionDisplacementFvPatchVectorField | Fixed traction boundary condition for the standard linear elastic, fixed coefficient displacement equation |
| trajectoryCollisionModel | Collision model by P.J. O'Rourke. Implemented as described in the KIVA manual |
| transformFvPatchField< Type > | Foam::transformFvPatchField |
| translatingWallVelocityFvPatchVectorField | Foam::translatingWallVelocityFvPatchVectorField |
| 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 |
| transportModel | Base-class for all transport models used by the incompressible turbulence models |
| treeBoundBox | Standard boundBox + extra functionality for use in octree |
| treeDataCell | Encapsulation of data needed to search in/for cells. Used to find the cell containing a point (e.g. cell-cell mapping) |
| treeDataEdge | Holds data for octree to work on an edges subset |
| treeDataFace | Encapsulation of data needed to search for faces |
| 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 |
| treeDataPrimitivePatch< Face, FaceList, PointField, PointType > | Encapsulation of data needed to search on PrimitivePatches |
| treeDataTriSurface | Encapsulates data for (indexedOc)tree searches on triSurface |
| treeElem< Type > | Common functionality of treeNode and treeLeaf |
| treeLeaf< Type > | An octree treeLeaf |
| treeNode< Type > | Class to implement octree |
| triangle< Point, PointRef > | A triangle primitive used to calculate face normals and swept volumes |
| triangleFuncs | Various triangle functions |
| triFace | A triangle face primitive using a FixedList |
| triSurface | Triangulated surface description with patch information |
| TRIsurfaceFormat< Face > | Provide a means of reading/writing .tri format |
| TRIsurfaceFormatCore | Internal class used by the TRIsurfaceFormat |
| triSurfaceGeoMesh | The triSurface GeoMesh (for holding fields) |
| triSurfaceMesh | IOoject and searching on triSurface |
| triSurfaceSearch | Helper class to search on triSurface |
| triSurfaceTools | A collection of tools for triSurfaceMesh |
| TroeFallOffFunction | The Troe fall-off function |
| Tuple< Type1, Type2 > | A 2 Tuple. Differs from Tuple in that the two elements can be different type |
| Tuple2< Type1, Type2 > | A 2-tuple |
| turbGen | Generate a turbulent velocity field conforming to a given energy spectrum and being divergence free |
| turbulenceModel | Abstract base class for compressible turbulence models (RAS, LES and laminar) |
| incompressible::turbulenceModel | Abstract base class for incompressible turbulence models (RAS, LES and laminar) |
| incompressible::turbulentHeatFluxTemperatureFvPatchScalarField | |
| turbulentHeatFluxTemperatureFvPatchScalarField | Fixed heat flux boundary condition for temperature |
| turbulentHeatFluxTemperatureFvPatchScalarField | |
| turbulentInletFvPatchField< Type > | Generate a fluctuating inlet condition by adding a random component to a reference (mean) field. Input: referenceField Mean field. fluctuationScale RMS fluctuation, provided as the fraction of the mean field. alpha temporal correlation factor; the fraction of the new random component added to the previous time-step (defaults to 0.1) |
| turbulentIntensityKineticEnergyInletFvPatchScalarField | Calculate turbulent kinetic energy from the intensity provided as a fraction of the mean velocity |
| turbulentMixingLengthDissipationRateInletFvPatchScalarField | Calculate epsilon via the mixing length [m] |
| incompressible::turbulentMixingLengthDissipationRateInletFvPatchScalarField | Calculate epsilon via the mixing length [m] |
| incompressible::turbulentMixingLengthFrequencyInletFvPatchScalarField | Calculate omega via the mixing length |
| turbulentMixingLengthFrequencyInletFvPatchScalarField | Calculate omega via the mixing length |
| turbulentTemperatureCoupledBaffleFvPatchScalarField | |
| turbulentTemperatureCoupledBaffleFvPatchScalarField | Harmonic fixed value boundary condition for temperature, to be used for heat-transfer on back-to-back baffles |
| turbulentTemperatureCoupledBaffleMixedFvPatchScalarField | Mixed boundary condition for temperature, to be used for heat-transfer on back-to-back baffles |
| twoDPointCorrector | Class applies a two-dimensional correction to mesh motion point field |
| twoPhaseMixture | A two-phase incompressible transportModel |
| typeOfRank< Cmpt, rank > | |
| typeOfRank< Cmpt, 0 > | |
| typeOfRank< Cmpt, 1 > | |
| typeOfRank< Cmpt, 2 > | |
| typeOfSum< arg1, arg2 > | |
| typeOfSum< SphericalTensor2D< Cmpt >, Tensor2D< Cmpt > > | |
| typeOfSum< SphericalTensor< Cmpt >, SymmTensor< Cmpt > > | |
| typeOfSum< SphericalTensor< Cmpt >, Tensor< Cmpt > > | |
| typeOfSum< SymmTensor< Cmpt >, SphericalTensor< Cmpt > > | |
| typeOfSum< SymmTensor< Cmpt >, Tensor< Cmpt > > | |
| typeOfSum< Tensor2D< Cmpt >, SphericalTensor2D< Cmpt > > | |
| typeOfSum< Tensor< Cmpt >, SphericalTensor< Cmpt > > | |
| typeOfSum< Tensor< Cmpt >, SymmTensor< Cmpt > > | |
| UDictionary< T > | Template dictionary class which does not manages the storage associated with it |
| UIDLList< T > | Intrusive doubly-linked list |
| UILList< LListBase, T > | Template class for intrusive linked lists |
| UIndirectList< T > | A List with indirect addressing. Like IndirectList but does not store addressing |
| UList< T > | 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 |
| UMISTLimiter< LimiterFunc > | Class with limiter function which returns the limiter for the UMIST differencing scheme |
| uncorrectedSnGrad< Type > | Simple central-difference snGrad scheme without non-orthogonal correction |
| uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField | Foam::uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField |
| 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 |
| uniform | |
| uniform | Uniform pdf |
| uniformDensityHydrostaticPressureFvPatchScalarField | Hydrostatic pressure boundary condition calculated as |
| uniformDiffusivity | Uniform uniform finite volume mesh motion diffusivity |
| UniformDimensionedField< Type > | 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 |
| uniformFixedValueFvPatchField< Type > | Foam::uniformFixedValueFvPatchField |
| uniformFixedValuePointPatchField< Type > | Foam::uniformFixedValuePointPatchField |
| uniformSet | |
| cellToCellStencil::unionEqOp | Combine operator for labelLists |
| cellToFaceStencil::unionEqOp | Combine operator for labelLists |
| unitInjector | The unit injector |
| UnsortedMeshedSurface< Face > | A surface geometry mesh, in which the surface zone information is conveyed by the 'zoneId' associated with each face |
| UOprocess | Random UO process |
| UPtrDictionary< T > | Template dictionary class which does not manages the storage associated with it |
| UPtrList< T > | A 1D array of pointers to objects of type <T>, where the size of the array is known and used for subscript bounds checking, etc |
| upwind< Type > | Upwind differencing scheme class |
| upwindCECCellToFaceStencilObject | |
| upwindCFCCellToFaceStencilObject | |
| upwindCPCCellToFaceStencilObject | |
| upwindFECCellToFaceStencilObject | |
| UpwindFitData< Polynomial > | Data for the quadratic fit correction interpolation scheme to be used with upwind biased stencil.
- linearCorrection = true : fit calculated for corrected linear scheme
- linearCorrection = false : fit calculated for corrected upwind scheme
|
| UpwindFitScheme< Type, Polynomial, Stencil > | Upwind biased fit surface interpolation scheme that applies an explicit correction to linear |
| valuePointPatchField< Type > | Foam::valuePointPatchField |
| valveBank | A list of valves |
| vanAlbadaLimiter< LimiterFunc > | Class with limiter function which returns the limiter for the vanAlbada differencing scheme based on r obtained from the LimiterFunc class |
| vanDriestDelta | Simple cube-root of cell volume delta used in incompressible LES models |
| vanDriestDelta | Simple cube-root of cell volume delta used in compressible LES models |
| vanLeerLimiter< LimiterFunc > | Class with limiter function which returns the limiter for the vanLeer differencing scheme based on r obtained from the LimiterFunc class |
| VariableHardSphere< CloudType > | Variable Hard Sphere BinaryCollision Model |
| Vector< Cmpt > | 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 |
| Vector2D< Cmpt > | 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) |
| VectorSpace< Form, Cmpt, nCmpt > | Templated vector space |
| VectorSpaceOps< N, I > | |
| VectorSpaceOps< 0, 0 > | |
| velocityComponentLaplacianFvMotionSolver | Mesh motion solver for an fvMesh. Based on solving the cell-centre Laplacian for the given component of the motion velocity |
| velocityLaplacianFvMotionSolver | Mesh motion solver for an fvMesh. Based on solving the cell-centre Laplacian for the motion velocity |
| IOstream::versionNumber | Version number type |
| veryInhomogeneousMixture< ThermoType > | Foam::veryInhomogeneousMixture |
| viscosityModel | |
| viscosityModel | An abstract base class for incompressible viscosityModels |
| volMesh | Mesh data needed to do the Finite Volume discretisation |
| volPointInterpolation | Foam::volPointInterpolation |
| vtkMesh | Encapsulation of VTK mesh data. Holds mesh or meshsubset and polyhedral-cell decomposition on it |
| VTKsurfaceFormat< Face > | Provide a means of writing VTK legacy format. The output is never sorted by zone |
| VTKsurfaceFormatCore | Internal class used by the VTKsurfaceFormat |
| vtkSurfaceWriter< Type > | |
| vtkTopo | Polyhedral cell decomposition for VTK |
| walkPatch | Collection of static functions to do various simple patch related things |
| wallDist | Calculation of distance to nearest wall for all cells and boundary. Uses meshWave to do actual calculation |
| wallDistData< TransferType > | Wall distance calculation. Like wallDist but also transports extra data (template argument) |
| wallDistReflection | Wall distance and reflection vector calculation. See wallDist.H |
| wallFvPatch | Foam::wallFvPatch |
| wallHeatTransferFvPatchScalarField | Enthalpy boundary conditions for wall heat transfer |
| WallInteractionModel< CloudType > | Templated wall interaction model class |
| Wallis | Wallis compressibility model |
| wallLayerCells | After construction is a list of <refineCell> of cells within a certain distance to the wall and with the wall normal direction |
| wallModel | A wall interaction model |
| wallNormalInfo | Holds information regarding nearest wall point. Used in wall refinement |
| wallPoint | Holds information regarding nearest wall point. Used in wall distance calculation |
| wallPointData< Type > | Holds information (coordinate and normal) regarding nearest wall point |
| wallPointPatch | Foam::wallPointPatch |
| wallPointYPlus | Holds information (coordinate and yStar) regarding nearest wall point |
| wallPolyPatch | Foam::wallPolyPatch |
| waveTransmissiveFvPatchField< Type > | Foam::waveTransmissiveFvPatchField |
| wedge | Extrudes by rotating a surface around an axis
- extrusion is opposite the surface/patch normal so inwards the source mesh
- axis direction has to be consistent with this.
- use -mergeFaces option if doing full 360 and want to merge front and back
- note direction of axis. This should be consistent with rotating against the patch normal direction. If you get it wrong you'll see all cells with extreme aspect ratio and internal faces wrong way around in checkMesh
|
| wedgeFvPatch | Wedge front and back plane patch |
| wedgeFvPatchField< Type > | Foam::wedgeFvPatchField |
| wedgeFvsPatchField< Type > | Foam::wedgeFvsPatchField |
| wedgeMatcher | A cellMatcher for wedge cells |
| wedgePointPatch | Wedge front and back plane patch |
| wedgePointPatchField< Type > | Wedge front and back plane patch field |
| wedgePolyPatch | Wedge front and back plane patch |
| weighted< Type > | Interpolation scheme class using weights looked-up from the objectRegistry |
| 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 |
| wideBandAbsorptionEmission | WideBandAbsorptionEmission radiation absorption and emission coefficients for continuous phase |
| wideBandDiffusiveRadiationMixedFvPatchScalarField | |
| wideBandDiffusiveRadiationMixedFvPatchScalarField | Radiation temperature specified |
| 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 |
| wordReListMatcher | A wrapper for matching a List of wordRe |
| writeFuns | Various functions for collecting and writing binary data |
| writer< Type > | Base class for graphics format writing. Entry points are
- write(..).
Write to an Ostream a table of points with corresponding values.
- write(scalar/vector/sphericalTensor/symmTensor/tensor).
Write single scalar/vector/sphericalTensor/symmTensor/tensor. Default is to write space separated components
|
| graph::writer | Abstract base class for a graph writer |
| writeRegisteredObject | Takes over the writing of registered IO objects |
| WRLsurfaceFormat< Face > | Provide a means of writing VRML97 (wrl) format |
| WRLsurfaceFormatCore | Internal class used by the WRLsurfaceFormat |
| X3DsurfaceFormat< Face > | Provide a means of writing x3d format |
| X3DsurfaceFormatCore | Internal class used by the X3DsurfaceFormat |
| Xfer< T > | A simple container for copying or transferring objects of type <T> |
| XiEqModel | Base-class for all XiEq models used by the b-XiEq combustion model. The available models are : basicXiSubXiEq.H Gulder.H instabilityXiEq.H SCOPEBlendXiEq.H SCOPEXiEq.H |
| XiGModel | Base-class for all Xi generation models used by the b-Xi combustion model. See Technical Report SH/RE/01R for details on the PDR modelling. For details on the use of XiGModel see XiModel.H. The model available is instabilityG.H |
| XiModel | Base-class for all Xi models used by the b-Xi combustion model. See Technical Report SH/RE/01R for details on the PDR modelling |
| xmgraceSetWriter< Type > | |
| xmgrGraph | Output and agr file for xmgrace (http://plasma-gate.weizmann.ac.il/Grace/) |
| zero | A class representing the concept of 0 used to avoid unnecessary manipulations for objects that are known to be zero at compile-time |
| 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 |
| zeroGradientFvPatchField< Type > | Foam::zeroGradientFvPatchField |
| zeroGradientPointPatchField< Type > | Foam::zeroGradientPointPatchField |
| ZoneID< ZoneType > | A class that holds the data needed to identify a zone in a dynamic mesh |
| ZoneMesh< ZoneType, MeshType > | List of mesh zones |
| zoneToCell | A topoSetSource to select faces based on cellZone |
| zoneToFace | A topoSetSource to select faces based on faceZone |
| zoneToPoint | A topoSetSource to select points based on pointZone |
