Boundary condition types

Every patch type the application can assign, the parameters each one asks for, and the OpenFOAM entry it writes into every field.

A boundary condition here is one physical concept. The application fans it out across the whole field set, so you choose "Velocity inlet" once and it writes fixedValue into 0/U, zeroGradient into 0/p, turbulentIntensityKineticEnergyInlet into 0/k and so on. You never name a patch type per field.

---

The thirteen

A patch with no type assigned is an error. OpenFOAM decides whether a wall function may be constructed from the mesh patch type, not from the field entry, so the mesh patch type in the third column is written into blockMeshDict and applied to an existing mesh's constant/polyMesh/boundary as well.

Outflow, Symmetry, Periodic, Empty (2D) and Wedge (axisymmetric) take no parameters. They are geometric statements applied identically to every field.

---

Parameters

Which fields the patch editor shows, by type.

Intensity and length scale are converted to k, omega and epsilon and the derived values are shown live under the fields. You never type a turbulence quantity.

---

The base fan-out

What each type writes into each field before any family-specific overlay. Fields the case does not carry are simply not written.

* The k and nut types on the two wall rows are the wall-function values. They change with the wall treatment — see Wall treatment below.

The This writes box on the patch pane shows this table for the case in front of you, one line per field actually present. That box, not this page, is the authority for a specific case.

Entries written alongside the type

---

What a wall writes

Wall motion and roughness change the patch type, not only a value.

Roughness is not offered on a slip wall — there is no boundary layer for it to roughen.

Wall treatment

The Wall treatment control on the Models pane changes the k and nut types on every Wall and Thermal wall patch. It is one control applied as a coherent set rather than a per-patch choice.

omega stays omegaWallFunction and epsilon stays epsilonWallFunction under all three. Roughness, above, replaces the nut type outright: a rough wall takes nutkRoughWallFunction whatever the treatment.

What y+ is and why the choice matters is in y+ and wall treatment; the model list is in Turbulence and viscosity models.

---

Family overlays

The base table is refined once the physics family is known. These are applied in order and each one only touches the fields it owns.

Two-phase VoF. p is derived from p_rgh and carries calculated rather than a condition of its own. alpha is inletOutlet at every opening — a fixedValue on an outlet would hold the free surface at a fixed height against the flow. A pressure outlet, an outflow or a far field gets p_rgh totalPressure and U pressureInletOutletVelocity; a wall gets p_rgh fixedFluxPressure and alpha zeroGradient. Symmetry and periodic override everything and apply unchanged.

totalPressure rather than prghTotalPressure on the opening, deliberately. p_rgh is measured from the hydrostatic datum, so setting it to the ambient value at an opening lets the solver add the weight of the column above each face itself. prghTotalPressure subtracts that weight instead, which fixes the absolute pressure at the ambient value at every depth — right for a patch that only ever sees air, and a statement that the floor of the tank is open to the atmosphere on a far field that reaches it.

Euler-Euler. One U.<phase> per phase and an alpha.<phase> for the dispersed phase only. At a wall the dispersed phase gets slip rather than no-slip — holding it to no-slip puts a boundary layer on bubbles. p_rgh is prghPressure at a pressure outlet and fixedFluxPressure elsewhere.

Species and passive scalars. Mass fractions (reacting, spray) and the transported scalar behave identically: fixedValue at an inlet or far field, inletOutlet at a pressure outlet or fan, zeroGradient everywhere else.

Conduction. There is no flow, so every condition that switches on flow direction — inletOutlet, freestream — would look up a flux that does not exist and fail. T is reduced to fixedValue at an inlet, pressure inlet, far field or thermal wall and zeroGradient elsewhere. Nothing else is written.

Atmospheric. A velocity inlet or far field is replaced by the logarithmic profile: atmBoundaryLayerInletVelocity, atmBoundaryLayerInletK, atmBoundaryLayerInletEpsilon, atmBoundaryLayerInletOmega. A non-slip wall gets atmEpsilonWallFunction, atmOmegaWallFunction and atmNutkWallFunction. constant/turbulenceProperties is unchanged; only the boundary library differs, and libatmosphericModels.so is added to controlDict's libs.

Compressible. alphat is added: compressible::alphatWallFunction at a wall, calculated elsewhere, and the geometric type on symmetry or periodic.

Buoyant. p becomes calculated and the pressure condition moves to p_rgh — fixedFluxPressure where p would have been zeroGradient. alphat is alphatJayatillekeWallFunction at a wall. A Boussinesq case registers no thermo model, so externalWallHeatFluxTemperature is downgraded to fixedValue — there is nothing for kappaMethod to look up.

Anything else. Any field none of the above names still gets a condition, or the case is written with NOT ASSIGNED in it and stops on the first read: fixedValue at an inlet, pressure inlet or far field; zeroGradient at a pressure outlet, outflow or fan; and at a wall fixedValue for a vector field, zeroGradient for a scalar.

---

Constraints

These are checked and reported on the Problems tab.

Patch names

A patch name becomes an OpenFOAM dictionary keyword, so:

Renaming a patch here does not rename it in an already generated mesh.

A new patch added by name is given a starting type guessed from the name: a name containing inlet becomes a Velocity inlet, outlet a Pressure outlet, farfield/freestream/external a Far field, and wall/body/ground a Wall. Anything else is left unassigned.

Two-dimensional cases

OpenFOAM has no two-dimensional solver. A 2-D case is a three-dimensional mesh one cell thick whose side faces are declared empty, and the solver then drops that direction entirely.

• A case marked two-dimensional needs at least one Empty (2D) patch. With none, the solver treats it as 3-D.
• One empty patch is enough and is the usual arrangement: the application's own blockMeshDict puts both thin faces into a single patch named frontAndBack, which is the standard OpenFOAM idiom.
• Turning the two-dimensional switch on adds that patch; turning it off removes it.
• The thin direction cannot be the flow direction — that is the direction the answer is in.

Axisymmetric cases

• Exactly two Wedge (axisymmetric) patches, one each side of the axis. Not one, not three. One of a pair is the common mistake and OpenFOAM's own error for it names a field rather than the patch.
• A case cannot be both two-dimensional and axisymmetric. Empty and wedge are alternative ways of removing the same direction.

Everything else

• Every patch needs a condition, on every field, before the case can run.
• The patch list must match the mesh. When a mesh has been generated and the names disagree, the boundary list says which patches the mesh actually has and offers "Use the mesh's patches". Left alone, the solver stops on the first field it reads with an error that names a keyword rather than the problem.
• Something must fix the pressure level. With no Pressure outlet, Far field or Outflow anywhere on the boundary, only pressure differences are determined, and pRefCell 0 / pRefValue 0 are written into fvSolution to pin it. This is reported as information, not an error.
• A Marine & Waves case needs a Wave inlet. Without one, constant/waveProperties names a patch that generates nothing.

Periodic

The application writes type cyclic; into every field and type cyclic; into the mesh patch. It does not write a neighbourPatch entry, so the pairing between the two halves of a cyclic patch has to already exist in the mesh — from an imported mesh, or from a createPatch mesh operation.

---

Patch names on a generated mesh

The background block gives its faces fixed names, which is what the boundary list starts from on a case with no imported mesh.

snappyHexMesh adds the body: one patch named body, or one patch per part when the geometry has been split into parts.