multiPhysicsFoam – Uncoupled

Docs: fixedGradientCorrected

Mon, 01 Jan 0001 00:00:00 +0000

Overview

fixedGradientCorrected is a Neumann condition for fields of any type (scalar, vector, sphericalTensor, symmTensor, tensor). It prescribes the patch-normal gradient. Its patch value and value coefficients include a non-orthogonal correction $\mathbf{c}\cdot\nabla\phi_P$, evaluated on a small sub-mesh around the patch. Unlike fixedValueCorrected, the correction enters the matrix directly, through valueBoundaryCoeffs. It comes from the foam-extend interface-tracking solver (interTrackFoam, Tuković). The BC is compiled into libinterfaceTrackingFvMesh. It derives from the common base correctedFvPatchField (type corrected). The base class, the sub-mesh machinery, the corrected type and the porting status (interTrackFluid disabled, patchCorrected snGrad not ported) are described on the fixedValueCorrected page.

Mathematical Formulation

$$ \left.\frac{\partial\phi}{\partial n}\right|_b = g \quad \text{on } \partial\Omega, \qquad \phi_b = \phi_P + \phi_c + \delta\, g $$

with the correction from the base class

$$ \mathbf{c} = \boldsymbol{\Delta} - \mathbf{n}\,(\mathbf{n}\cdot\boldsymbol{\Delta}), \qquad \phi_c = \mathbf{c}\cdot(\nabla\phi)_P $$

Matrix coefficients:

Coefficient	Value
`valueInternalCoeffs`	$1$
`valueBoundaryCoeffs`	$\phi_c + \delta\,g$
`gradientInternalCoeffs`	$0$
`gradientBoundaryCoeffs`	$g$
`snGrad()`	$g$

Symbol	Description	Unit
$\phi$	Patch field	field unit
$g$	Prescribed normal gradient (`gradient`)	field unit/m
$\mathbf{n}$	Patch unit normal	–
$\boldsymbol{\Delta}$	Patch delta vector (`patch().delta()`)	m
$\mathbf{c}$	Correction vector	m
$\phi_c$	Stored correction (`corrVecGrad`), updated in `updateCoeffs()`	field unit
$\delta$	$1/$`patch().deltaCoeffs()`	m

Note on OpenFOAM.com. fvPatch::delta() is patch-normal for every non-coupled patch in OpenFOAM.com, so $\mathbf{c} \equiv \mathbf{0}$ and $\phi_c \equiv 0$. The coefficients reduce to those of stock fixedGradient.

Implementation

Construction: the base class reads volFieldName (required) and the optional corrVecGrad. This class then reads gradient (required). If value is given, it is used as the initial patch value. Otherwise $\phi_P + \delta g + \phi_c$ is used, with $\phi_c = 0$ at that point unless corrVecGrad was given. nGradInternal is set to $g$.
updateCoeffs() (base class): recomputes $\mathbf{c}$ if the mesh moves, rebuilds $\phi_c$ on the patch sub-mesh (gradient scheme snGradCorr(<volFieldName>)). It is called whenever an fvMatrix for the field is constructed, so valueBoundaryCoeffs always uses the current $\phi_c$.
evaluate(): the class declares evaluate() without the Pstream::commsTypes argument. It therefore does not override fvPatchField::evaluate(const Pstream::commsTypes), which correctBoundaryConditions() calls. In practice the base evaluate runs, and that only resets the updated flag. The patch value is not recomputed from $\phi_P + \phi_c + \delta g$ after a solve. It keeps its initial value unless code assigns it explicitly. Only the matrix coefficients follow the formula above.
Mapping: autoMap/rmap map the value and gradient.
Sub-mesh motion: interfaceTrackingFvMesh::update() moves the sub-mesh only for U and p.
write(): type, volFieldName, corrVecGrad, gradient, value.

Dictionary Entries

Keyword	Description	Required	Default
`type`	`fixedGradientCorrected`	yes	–
`volFieldName`	Name of the volume field this patch field belongs to	yes	– (no default)
`gradient`	Prescribed normal gradient $g$	yes	–
`value`	Initial patch value	no	$\phi_P + \delta g + \phi_c$
`corrVecGrad`	Initial stored correction $\phi_c$	no	zero

The library must be loaded with libs ("libinterfaceTrackingFvMesh.so"); in system/controlDict.

Usage

outlet
{
 type fixedGradientCorrected;
 volFieldName p;
 gradient uniform 0;
 value uniform 0;
}

Known Limitations

Patch value not updated by correctBoundaryConditions() because the evaluate() signature does not match (see Implementation). Explicit operators that use patch values (fvc::grad, fvc::interpolate, face fluxes) see a stale value.
No correction in OpenFOAM.com (patch-normal delta()). The cost of the sub-mesh gradient remains on every updateCoeffs().
Interface-tracking context not available: interTrackFluid is disabled and patchCorrected is not ported (see fixedValueCorrected).
volFieldName has no default and must match the field name.
Sub-mesh motion only for U and p.

In practice, use the stock fixedGradient instead.

Tutorials

No tutorial uses fixedGradientCorrected.

References

Tuković, Ž., Jasak, H., A moving mesh finite volume interface tracking method for surface tension dominated interfacial fluid flow, Computers & Fluids 55, 2012. DOI: 10.1016/j.compfluid.2011.11.003
Alkfri, A., Habes, C., Marschall, H., multiRegionFoam: A Unified Multiphysics Framework for Multi-Region Coupled Continuum-Physical Problems, Engineering with Computers, 2023. DOI: 10.1007/s00366-024-01974-4

Docs: fixedValueCorrected

Mon, 01 Jan 0001 00:00:00 +0000

Overview

fixedValueCorrected is a Dirichlet condition for fields of any type (scalar, vector, sphericalTensor, symmTensor, tensor). On top of the fixed value it stores a non-orthogonal correction $\mathbf{c}\cdot\nabla\phi_P$ of the near-wall value. The correction is evaluated on a small sub-mesh around the patch. It comes from the foam-extend interface-tracking solver (interTrackFoam, Tuković), where it is used on patches whose near-wall cells become skewed as the mesh follows a moving interface. The fixed-value matrix coefficients themselves are not corrected. The correction only reaches the discretisation through snGradCorrection(), which is called by the patchCorrected snGrad scheme. That scheme is not ported (see Known Limitations).

The BC is compiled into libinterfaceTrackingFvMesh, not libmultiRegionSystem, so this library must be loaded. It is one of three types derived from the common base correctedFvPatchField:

Type	Page
`fixedValueCorrected`	this page
`fixedGradientCorrected`	fixedGradientCorrected
`zeroGradientCorrected`	zeroGradientCorrected
`corrected`	the base class itself, registered as a type but not usable on its own (see below)

Mathematical Formulation

$$ \phi_b = \phi_\text{fixed} \quad \text{on } \partial\Omega $$

With $\mathbf{n}$ the patch unit normal, $\boldsymbol{\Delta}$ the patch delta vector and $\delta = 1/\texttt{deltaCoeffs}$, the base class defines the correction vector and the stored correction

$$ \mathbf{c} = \boldsymbol{\Delta} - \mathbf{n}\,(\mathbf{n}\cdot\boldsymbol{\Delta}), \qquad \phi_c = \mathbf{c}\cdot(\nabla\phi)_P $$

and the corrected normal gradient

$$ \left.\frac{\partial\phi}{\partial n}\right|_b = \frac{\phi_b - \phi_P}{\delta} - \frac{\phi_c}{\delta} = \frac{\phi_b - (\phi_P + \phi_c)}{\delta} $$

The matrix coefficients are those of plain fixedValue:

Coefficient	Value
`valueInternalCoeffs`	$0$
`valueBoundaryCoeffs`	$\phi_b$
`gradientInternalCoeffs`	$-1/\delta$
`gradientBoundaryCoeffs`	$\phi_b/\delta$
`snGradCorrection()`	$-\phi_c/\delta$

Symbol	Description	Unit
$\phi$	Patch field	field unit
$\mathbf{n}$	Patch unit normal	–
$\boldsymbol{\Delta}$	Patch delta vector (`patch().delta()`)	m
$\mathbf{c}$	Correction vector (`correctionVectors()`)	m
$(\nabla\phi)_P$	Cell gradient next to the patch, computed on the patch sub-mesh	field unit/m
$\phi_c$	Stored correction (`corrVecGrad`)	field unit
$\delta$	$1/$`patch().deltaCoeffs()`	m

Note on OpenFOAM.com. In OpenFOAM.com (v2512 and v2606), fvPatch::delta() returns the patch-normal delta for every non-coupled patch. So $\mathbf{c} \equiv \mathbf{0}$ and $\phi_c \equiv 0$ identically. The BC then behaves exactly like stock fixedValue, but still does the sub-mesh work described below on every update. The correction is only non-zero in foam-extend, where delta() is the full $\mathbf{C}_f - \mathbf{C}_P$.

Implementation

Base class correctedFvPatchField (type corrected).

Construction: reads volFieldName (required) and, if present, corrVecGrad. It computes the correction vectors $\mathbf{c}$. It does not read value or patchType.
updateCoeffs(): if the mesh is moving, recomputes $\mathbf{c}$. Then it always calls updateCorrVecGrad():
1. On first use, builds a patch sub-mesh (fvMeshSubset) from the patch face cells plus all their neighbouring cells. The sub-mesh takes its fvSchemes/fvSolution from the region mesh.
2. Interpolates the volume field named volFieldName onto the sub-mesh.
3. For each component, computes fvc::grad with the gradient scheme named snGradCorr(<volFieldName>) (normally covered by gradSchemes { default ...; }).
4. Stores $\phi_c = \mathbf{c}\cdot(\nabla\phi)_P$ and $\mathbf{n}\cdot(\nabla\phi)_P$ (nGradInternal, not used by any active code path).
movePatchSubMesh(): moves the sub-mesh points to the current mesh points. interfaceTrackingFvMesh::update() calls it after each mesh motion for every fixedValueCorrected, fixedGradientCorrected or zeroGradientCorrected patch of the fields U and p only. The sub-meshes of other fields are not moved.
write(): writes type, volFieldName and corrVecGrad.

fixedValueCorrected.

Construction: reads value (required) in addition to the base keywords.
fixesValue() returns true, so no pressure reference is needed if the BC is used on p.
All assignment operators (=, +=, -=, *=, /= with fields, patch fields or constants) are no-ops, as in stock fixedValue. The value can only be changed with ==.
evaluate() is not overridden, so the value stays fixed.
write(): base entries plus value.

patchCorrectedSnGrad (not compiled). The source is in src/dynamicFvMesh/interfaceTrackingFvMesh/patchCorrectedSnGrad. It is a central snGrad scheme with explicit non-orthogonal correction, using the gradient scheme snGradCorr(<field>). On patches of type fixedValueCorrected it replaces the boundary correction by snGradCorrection(). This is the only code path through which the stored correction would enter a discretised equation. The entry in src/dynamicFvMesh/Make/files is commented out (“NEEDS TO BE PORTED STILL”), so the scheme cannot be selected.

The `corrected` type

makePatchFields(corrected) registers the base class as type corrected for scalar, vector, sphericalTensor, symmTensor and tensor fields. The base class does not implement any matrix coefficients (valueInternalCoeffs etc. fall back to fvPatchField, which raises NotImplemented). It does not read or write value, so its patch values are uninitialised. It also does not override evaluate(). type corrected; is therefore not a usable boundary condition. Use one of the three derived types.

Dictionary Entries

Keyword	Description	Required	Default
`type`	`fixedValueCorrected`	yes	–
`volFieldName`	Name of the volume field this patch field belongs to (e.g. `U`, `p`). Used to look up the field for the sub-mesh gradient.	yes	– (no default)
`value`	Fixed patch value	yes	–
`corrVecGrad`	Initial stored correction $\phi_c$ (written on output; overwritten at the first update)	no	zero

Library loading (system/controlDict of the case):

libs
(
 "libinterfaceTrackingFvMesh.so"
);

Usage

movingWall
{
 type fixedValueCorrected;
 volFieldName U;
 value uniform (0 0 0);
}

The field must be the one named in volFieldName. The sub-mesh is only kept in step with mesh motion if the field is U or p and the region mesh is an interfaceTrackingFvMesh.

Known Limitations

No effect in OpenFOAM.com. The patch delta is patch-normal, so the correction vectors and $\phi_c$ are identically zero. The BC is equivalent to fixedValue, at the cost of a sub-mesh construction and a gradient evaluation per component on every updateCoeffs().
patchCorrected snGrad scheme not ported. Even with a non-zero correction, nothing in the compiled code would use snGradCorrection(). The matrix coefficients are those of plain fixedValue.
Interface-tracking region type disabled. The BCs were meant for interTrackFluid, which is commented out in src/multiRegionSystem/Make/files. The multiphaseFlow tutorials that need it (2dRisingBubble, 3dDuineveldRisingBubble, 3dOscillatingBubble) cannot currently be run. Only 3dDuineveldRisingBubble mentions patchCorrected, and only in comments in its base-mesh fvSchemes.
volFieldName has no default and must match the field name. Otherwise the field lookup in updateCoeffs() fails.
Sub-mesh motion only for U and p. For any other field, the sub-mesh keeps its initial geometry while the mesh moves.
corrected is not a standalone BC (see above).

In practice, use the stock fixedValue instead.

Tutorials

No tutorial uses fixedValueCorrected (or any *Corrected type). The FSI tutorials beamInCrossFlow, heatedBeamInCrossFlow and HronTurekFsi3 load libinterfaceTrackingFvMesh.so for their interfaceTrackingFvMesh fluid mesh, but their fields use stock and regionCoupled* boundary conditions.

References

Tuković, Ž., Jasak, H., A moving mesh finite volume interface tracking method for surface tension dominated interfacial fluid flow, Computers & Fluids 55, 2012. DOI: 10.1016/j.compfluid.2011.11.003
Alkfri, A., Habes, C., Marschall, H., multiRegionFoam: A Unified Multiphysics Framework for Multi-Region Coupled Continuum-Physical Problems, Engineering with Computers, 2023. DOI: 10.1007/s00366-024-01974-4

Docs: paraboloidInletVelocity

Mon, 01 Jan 0001 00:00:00 +0000

Overview

paraboloidInletVelocity is a fixedValue condition for a velocity field. It prescribes a velocity in the $+x$ direction whose magnitude is parabolic in both $y$ and $z$, as found in the developed laminar inflow of a rectangular channel. The peak velocity can be ramped up smoothly from zero with a half-cosine. The BC is based on the setInletVelocity function object of Ž. Tuković and was taken over from the foam-extend solid-mechanics toolbox. It is used for the 3-D FSI benchmark “beam in cross-flow”. The profile is written in global coordinates: the inlet must be normal to $x$, and the channel must be placed as described below.

Mathematical Formulation

$$ \mathbf{U}_b = U(t)\; \frac{y\,(2y_m - y)\,\left(z_m^2 - z^2\right)}{y_m^2\, z_m^2}\; \mathbf{e}_x $$

$(y, z)$ are the global coordinates of each face centre. The profile reaches $U(t)$ at $y = y_m$, $z = 0$. It is zero at $y = 0$, $y = 2y_m$ and $z = \pm z_m$. The time function is

$$ U(t) = \begin{cases} \dfrac{U_\text{max}}{2}\left[1 - \cos\left(\dfrac{\pi\, t}{t_\text{max}}\right)\right] & t < t_\text{end} \\[2ex] U_\text{max} & t \ge t_\text{end} \end{cases} $$

With $t_\text{end} = t_\text{max}$ (as in the tutorials), this is a smooth ramp from $0$ to $U_\text{max}$, after which the velocity is constant. With $t_\text{end} > t_\text{max}$, the velocity follows the cosine further (it oscillates between $0$ and $U_\text{max}$) until $t_\text{end}$, and then jumps to $U_\text{max}$. With $t_\text{end} < t_\text{max}$, the ramp is cut off and the velocity jumps to $U_\text{max}$ at $t_\text{end}$. With $t_\text{end} \le 0$, $U(t) = U_\text{max}$ from the start.

Symbol	Description	Unit
$\mathbf{U}_b$	Patch velocity	m/s
$U_\text{max}$	`maxVelocity`, peak velocity at full load	m/s
$y_m$	`yWidth`: $y$ position of the peak, i.e. half the channel height for a channel $0 \le y \le 2y_m$	m
$z_m$	`zWidth`: half-width in $z$ for a channel $-z_m \le z \le z_m$ (or the full width with a symmetry plane at $z=0$)	m
$t_\text{end}$	`timeVaryingEndTime`	s
$t_\text{max}$	`timeAtMaxVelocity`	s
$t$	`time().value()`	s

Implementation

updateCoeffs() computes $U(t)$ from the current time value and evaluates the formula for every face centre. It assigns the result with operator== and calls fixedValue::updateCoeffs(). The profile does not depend on the patch normal or the internal field.

snGrad() returns $(\mathbf{U}_b - \mathbf{U}_P^{*})\,/\,\delta$, where $\mathbf{U}_P^{*} = \mathbf{U}_P + \mathbf{k}\cdot(\nabla\mathbf{U})_P$ and $\mathbf{k} = (\mathbf{I}-\mathbf{n}\mathbf{n})\cdot\boldsymbol{\Delta}$. The correction is only applied if a volTensorField named grad(<U>) is registered. Otherwise the plain $(\mathbf{U}_b-\mathbf{U}_P)/\delta$ is used.

gradientBoundaryCoeffs() returns $(\mathbf{U}_b - \mathbf{k}\cdot(\nabla\mathbf{U})_P)/\delta$. If no grad(<U>) field is registered, it computes fvc::grad(U) on the fly for this. gradientInternalCoeffs() and the value coefficients are inherited from fixedValue.

A second-order variant exists in both functions, but it is hard-coded off (secondOrder_ = false) and cannot be selected from the dictionary.

Note on OpenFOAM.com. fvPatch::delta() is patch-normal for non-coupled patches, so $\mathbf{k} \equiv \mathbf{0}$. The non-orthogonal correction does nothing, and the gradient coefficients are those of a plain fixedValue condition. The on-the-fly fvc::grad(U) in gradientBoundaryCoeffs() still costs time on every matrix assembly.

write() writes maxVelocity, yWidth, zWidth, timeVaryingEndTime, timeAtMaxVelocity, then type and value.

Dictionary Entries

Keyword	Description	Required	Default
`type`	`paraboloidInletVelocity`	yes	–
`maxVelocity`	Peak velocity $U_\text{max}$	yes	–
`yWidth`	$y_m$, $y$ coordinate of the peak (half channel height)	yes	–
`zWidth`	$z_m$, $z$ half-width of the profile	yes	–
`timeVaryingEndTime`	$t_\text{end}$. `0` gives a constant velocity from the start.	yes	–
`timeAtMaxVelocity`	$t_\text{max}$, end of the cosine ramp	yes if `timeVaryingEndTime > 0`	`0` (not read otherwise)
`value`	Initial patch value (required by `fixedValue`, overwritten at the first update)	yes	–

Usage

From tutorials/fluidStructureInteraction/beamInCrossFlow/0/fluid/orig/partitioned/U. The fluid domain is $0 \le y \le 0.4$, $-0.4 \le z \le 0$ with a symmetry plane at $z = 0$, so yWidth 0.2 puts the peak at mid-height and zWidth 0.4 puts it on the symmetry plane:

inlet
{
 type paraboloidInletVelocity;
 maxVelocity 0.3;
 yWidth 0.2;
 zWidth 0.4;
 timeVaryingEndTime 1.0;
 timeAtMaxVelocity 1.0;
 value uniform (0 0 0);
}

Known Limitations

x-direction and global coordinates only. The velocity always points along $+\mathbf{e}_x$. $y$ and $z$ are absolute coordinates, so the channel must start at $y = 0$ and be centred on $z = 0$. The profile cannot be translated or rotated.
No clipping. Faces outside $0 \le y \le 2y_m$, $|z| \le z_m$ get a negative (reversed) velocity.
timeAtMaxVelocity must be positive when timeVaryingEndTime > 0. Otherwise $U(t)$ divides by zero.
Uses time().value(), not the user time (timeOutputValue()), unlike solidTraction’s series.
Second-order correction not selectable (hard-coded off).
Non-orthogonal correction has no effect in OpenFOAM.com, but gradientBoundaryCoeffs() still computes fvc::grad(U) on each call unless grad(U) is registered (see the note above).

Tutorials

Tutorial	Description
`tutorials/fluidStructureInteraction/beamInCrossFlow`	Inlet of the `pimpleFluid` region, ramped to 0.3 m/s over 1 s.
`tutorials/fluidStructureInteraction/heatedBeamInCrossFlow`	Same inlet in the thermo-FSI variant (`pimpleFluid transportTemperature`).

References

Cardiff, P., Karač, A., De Jaeger, P., Jasak, H., Nagy, J., Ivanković, A., Tuković, Ž., An open-source finite volume toolbox for solid mechanics and fluid-solid interaction simulations, arXiv:1808.10736, 2018.
Alkfri, A., Habes, C., Marschall, H., multiRegionFoam: A Unified Multiphysics Framework for Multi-Region Coupled Continuum-Physical Problems, Engineering with Computers, 2023. DOI: 10.1007/s00366-024-01974-4

Docs: solidSymmetry

Mon, 01 Jan 0001 00:00:00 +0000

Overview

solidSymmetry is a symmetry-plane condition ported from the foam-extend solid-mechanics toolbox (Cardiff, Tuković), where it is also known as symmetryDisplacement. It exists for two field types, both registered under the same type name:

solidSymmetryFvPatchVectorField, intended for the total displacement D of a solid region (solidStVK). It mirrors the near-wall displacement across the plane, so the normal displacement on the patch is zero and the tangential displacement is free. An optional second-order correction is available.
solidSymmetryFvPatchScalarField, the scalar counterpart. It sets the patch value to the corrected near-wall value (zero normal gradient).

Both classes derive from the stock symmetry constraint (symmetryFvPatchField). They only replace snGrad() and evaluate(), so the patch must be of mesh type symmetry. The class keeps the matrix coefficients (implicit part) of the stock condition.

Mathematical Formulation

Let $\mathbf{n}$ be the patch unit normal, $\boldsymbol{\Delta}$ the patch delta vector (face centre minus cell centre), $\delta = 1/\texttt{deltaCoeffs}$ the cell-to-face distance, and $\mathbf{R} = \mathbf{I} - 2\,\mathbf{n}\mathbf{n}$ the reflection tensor. The non-orthogonal correction vector and the corrected near-wall value are

$$ \mathbf{k} = (\mathbf{I} - \mathbf{n}\mathbf{n}) \cdot \boldsymbol{\Delta}, \qquad \mathbf{D}_P^{*} = \mathbf{D}_P + \mathbf{k} \cdot (\nabla \mathbf{D})_P $$

Vector field, first order (default)

$$ \mathbf{D}_b = \tfrac{1}{2}\left(\mathbf{D}_P^{*} + \mathbf{R}\,\mathbf{D}_P^{*}\right) = (\mathbf{I} - \mathbf{n}\mathbf{n})\,\mathbf{D}_P^{*}, \qquad \left.\frac{\partial \mathbf{D}}{\partial n}\right|_b = \frac{\mathbf{R}\,\mathbf{D}_P^{*} - \mathbf{D}_P^{*}}{2\,\delta} = -\frac{(\mathbf{n}\cdot\mathbf{D}_P^{*})\,\mathbf{n}}{\delta} $$

Vector field, second order (`secondOrder yes`)

$$ \mathbf{D}_b = (\mathbf{I} - \mathbf{n}\mathbf{n}) \cdot \left( \mathbf{D}_P^{*} + \tfrac{\delta}{2}\, \mathbf{n}\cdot(\nabla\mathbf{D})_P \right) $$ $$ \left.\frac{\partial \mathbf{D}}{\partial n}\right|_b = -\frac{2\,(\mathbf{n}\cdot\mathbf{D}_P^{*})\,\mathbf{n}}{\delta} - \mathbf{n}\left(\mathbf{n} \cdot \left[\mathbf{n}\cdot(\nabla\mathbf{D})_P\right]\right) $$

The tangential part of the value is extrapolated over half a cell with the mean of the zero face gradient and the cell gradient. The normal part of the gradient is the one-sided second-order estimate $2(\mathbf{D}_b - \mathbf{D}_P)\cdot\mathbf{n}/\delta - (\partial_n D_n)_P$.

Scalar field

A scalar is invariant under reflection, so $\mathbf{R}\,T = T$ and the formulas above reduce to

$$ T_b = T_P + \mathbf{k}\cdot(\nabla T)_P, \qquad \left.\frac{\partial T}{\partial n}\right|_b = 0 $$

Symbol	Description	Unit
$\mathbf{D}$, $T$	Patch field (vector / scalar)	field unit
$\mathbf{n}$	Patch unit normal (`patch().nf()`)	–
$\boldsymbol{\Delta}$	Patch delta vector (`patch().delta()`)	m
$\delta$	$1/$`patch().deltaCoeffs()`	m
$\mathbf{k}$	Non-orthogonal correction vector	m
$(\nabla\mathbf{D})_P$	Cell-centre gradient from the registered field `gradD`	field unit/m
$(\nabla T)_P$	Cell-centre gradient from the registered field `grad(<field>)`	field unit/m

Note on OpenFOAM.com. In OpenFOAM.com (v2512 and v2606), fvPatch::delta() returns the patch-normal delta $\mathbf{n}(\mathbf{n}\cdot(\mathbf{C}_f-\mathbf{C}_P))$ for all non-coupled patches. Then $\mathbf{k} \equiv \mathbf{0}$, $\mathbf{D}_P^{*} = \mathbf{D}_P$, and the non-orthogonal correction does nothing. It was written for foam-extend, where delta() is the full $\mathbf{C}_f - \mathbf{C}_P$. With the default first-order setting, the vector condition therefore gives exactly the values and normal gradient of the stock symmetry condition. The scalar condition is equivalent to stock symmetry / zeroGradient for scalars.

Implementation

Construction. The dictionary constructor calls the stock symmetry constructor. That constructor ignores value and evaluates the field once with the stock symmetry formula. The constructor then checks that the patch is exactly a symmetryFvPatch (isType). Any other patch type, including symmetryPlane, stops the run with a FatalIOError. The vector version reads the optional secondOrder switch and prints it. Both versions print “Symmetry boundary condition with non-orthogonal correction”.

evaluate() (called from correctBoundaryConditions()):

Calls updateCoeffs() if needed. This is the base no-op.
Looks up the cell gradient on the patch.
- Vector: the volTensorField named gradD, whatever the name of the field the BC is attached to.
- Scalar: the volVectorField named grad(<fieldName>), e.g. grad(T).
The lookup is mandatory. If the field is not registered on the mesh, the run stops with a fatal error.
Builds $\mathbf{D}_P^{*}$ and assigns the patch value with the formula above.
Vector only: calls the base evaluate(), which resets the updated flag. The scalar version does not call it.

snGrad() returns the normal gradient above. It is used wherever the patch gradient is requested explicitly. The matrix coefficients are inherited from the stock transform/basicSymmetry implementation: for vectors the implicit diagonal is $|n_i|$ per component. Because gradientBoundaryCoeffs() is snGrad() - gradientInternalCoeffs()·D_P, the overridden snGrad() (including the second-order term) enters fvm::laplacian as an explicit source. For scalars, the inherited coefficients are those of a zero-gradient condition.

In solidStVK. The momentum equation uses fvm::laplacian(impKf, D, "laplacian(DD,D)"), which picks up the coefficients above. gradD = fvc::grad(D) is recomputed in postSolve() from the patch values set in evaluate(). solidStVK registers gradD, so the vector BC works on its D field. It also works on any other vector field of that region, but it always uses gradD.

Dictionary Entries

Vector version:

Keyword	Description	Required	Default
`type`	`solidSymmetry`	yes	–
`secondOrder`	Second-order correction of value and normal gradient (`Switch`)	no	`false`
`patchType`	Generic `fvPatchField` keyword, read by the stock base class	no	–
`value`	Not read. The initial value comes from the stock symmetry evaluation. Written on output.	no	–

Scalar version:

Keyword	Description	Required	Default
`type`	`solidSymmetry`	yes	–
`patchType`	Generic `fvPatchField` keyword	no	–
`value`	Not read (see above). Written on output.	no	–

The scalar version does not read secondOrder.

Required registered fields:

Field	Type	Needed by	Provided by
`gradD`	`volTensorField`	vector version	`solidStVK`
`grad(<fieldName>)`	`volVectorField`	scalar version	no shipped region type

Usage

The mesh patch must be of type symmetry (e.g. symmetry symmetry (...) in blockMeshDict). From tutorials/fluidStructureInteraction/beamInCrossFlow/0/solid/orig/partitioned/D:

symmetry
{
 type solidSymmetry;
 patchType symmetry;
 value uniform (0 0 0);
}

With the second-order correction:

symmetry
{
 type solidSymmetry;
 secondOrder yes;
 value uniform (0 0 0);
}

For other fields of the solid region on the same patch, the tutorials use the stock condition (e.g. T in heatedBeamInCrossFlow: type symmetry;).

Known Limitations

Non-orthogonal correction has no effect in OpenFOAM.com. The patch delta is patch-normal, so $\mathbf{k} = \mathbf{0}$ (see the note above). With secondOrder no, the vector BC is numerically identical to stock symmetry. It still needs gradD.
Hard-coded gradient name (vector). The vector version always reads gradD. It is only usable in a region that registers a volTensorField named gradD, i.e. solidStVK.
Scalar version needs grad(<field>). No compiled region type registers a volVectorField with that name. Unless something else in the case provides it, the scalar BC fails on its first evaluation. Because it is equivalent to the stock condition in OpenFOAM.com, use symmetry for scalar fields instead.
Patch type symmetry only. symmetryPlane and other patch types are rejected.
value is ignored on read. The initial patch value is always the stock symmetry evaluation of the internal field.

Tutorials

Tutorial	Description
`tutorials/fluidStructureInteraction/beamInCrossFlow`	`D` of the `solidStVK` solid on the `symmetry` patch (first order).
`tutorials/fluidStructureInteraction/heatedBeamInCrossFlow`	Same `D` setup in a thermo-FSI case. `T` on the same patch uses stock `symmetry`.

No tutorial uses the scalar version or secondOrder yes.

References

Cardiff, P., Karač, A., De Jaeger, P., Jasak, H., Nagy, J., Ivanković, A., Tuković, Ž., An open-source finite volume toolbox for solid mechanics and fluid-solid interaction simulations, arXiv:1808.10736, 2018.
Alkfri, A., Habes, C., Marschall, H., multiRegionFoam: A Unified Multiphysics Framework for Multi-Region Coupled Continuum-Physical Problems, Engineering with Computers, 2023. DOI: 10.1007/s00366-024-01974-4

Docs: solidTraction

Mon, 01 Jan 0001 00:00:00 +0000

Overview

solidTraction imposes a known surface traction $\mathbf{t}$ and/or normal pressure $p$ on the displacement field D of a solid region. It is the uncoupled counterpart of the FSI traction BC: use it for loaded or traction-free solid surfaces that are not coupled to another region. The class derives from fixedGradient (vector only). In each update it recomputes the displacement normal gradient so that the stress on the patch matches the prescribed load. The traction and the pressure can each be given as a constant field, as a time series, or as a separate volume field. It was ported from the foam-extend solid-mechanics toolbox (Cardiff, Tuković). It reads the fields of solidStVK (impK, rImpK, gradD, sigma, Finv).

Mathematical Formulation

The target condition is a traction balance in the current (deformed) configuration:

$$ \mathbf{n}_c \cdot \boldsymbol{\sigma} = \mathbf{t} - p\,\mathbf{n}_c \quad \text{on } \partial\Omega_t, \qquad \mathbf{n}_c = \frac{\mathbf{F}^{-T}\cdot\mathbf{n}_0}{\lvert \mathbf{F}^{-T}\cdot\mathbf{n}_0 \rvert} $$

It is imposed through the normal gradient of D, in the segregated “implicit stiffness” form used by solidStVK:

$$ \mathbf{g}^{\,new} = \frac{1}{K}\left[ \left(\mathbf{t} - p\,\mathbf{n}_c\right) - \mathbf{n}_c\cdot\boldsymbol{\sigma} + K\, \mathbf{n}_0\cdot\nabla\mathbf{D} \right], \qquad \mathbf{g} \leftarrow \omega\,\mathbf{g}^{\,new} + (1-\omega)\,\mathbf{g}^{\,old} $$

$\boldsymbol{\sigma}$ and $\nabla\mathbf{D}$ are the current patch values. When the iteration has converged, $\mathbf{g} = \mathbf{n}_0\cdot\nabla\mathbf{D}$, so the bracket requires $\mathbf{n}_c\cdot\boldsymbol{\sigma} = \mathbf{t} - p\,\mathbf{n}_c$. The $K\,\mathbf{n}_0\cdot\nabla\mathbf{D}$ term mirrors the implicit/explicit Laplacian pair in the solidStVK momentum equation.

The patch value is then reconstructed from the gradient:

$$ \mathbf{D}_b = \begin{cases} \mathbf{D}_P + \mathbf{k}\cdot(\nabla\mathbf{D})_P + \delta\,\mathbf{g} & \text{first order} \\[1ex] \mathbf{D}_P + \mathbf{k}\cdot(\nabla\mathbf{D})_P + \tfrac{\delta}{2}\left(\mathbf{g} + \mathbf{n}_0\cdot(\nabla\mathbf{D})_P\right) & \texttt{secondOrder yes} \end{cases} $$

with $\mathbf{k} = (\mathbf{I}-\mathbf{n}_0\mathbf{n}_0)\cdot\boldsymbol{\Delta}$.

Symbol	Description	Unit
$\mathbf{D}$	Total displacement (patch field)	m
$\mathbf{t}$	Prescribed traction (`traction`, `tractionSeries` or `tractionField`)	Pa
$p$	Prescribed pressure, positive = compressive (`pressure`, `pressureSeries` or `pressureField`)	Pa
$\mathbf{n}_0$	Patch unit normal of the undeformed mesh	–
$\mathbf{n}_c$	Deformed unit normal from `Finv`	–
$\boldsymbol{\sigma}$	Cauchy stress, patch values of `sigma`	Pa
$\mathbf{F}^{-1}$	Inverse deformation gradient, patch values of `Finv`	–
$K$	Implicit stiffness, patch values of `impK` ($1/K$ from `rImpK`)	Pa
$\mathbf{g}$	Patch normal gradient (`gradient`)	–
$\omega$	`relaxationFactor`	–
$\delta$	$1/$`patch().deltaCoeffs()`	m
$\boldsymbol{\Delta}$, $\mathbf{k}$	Patch delta vector and non-orthogonal correction vector	m

Note on OpenFOAM.com. In OpenFOAM.com, fvPatch::delta() is patch-normal for non-coupled patches, so $\mathbf{k} \equiv \mathbf{0}$ and the non-orthogonal term in $\mathbf{D}_b$ has no effect.

Implementation

Construction. The dictionary constructor reads secondOrder, setEffectiveTraction and relaxationFactor. It reads gradient and value if present, otherwise it starts from zero gradient and the patch-internal value. It then sets up the traction and the pressure. For each, exactly one of three forms is allowed. Giving two forms of the same quantity stops the run (FatalError):

Traction	Pressure	Behaviour
`traction`	`pressure`	Patch field (`uniform` or `nonuniform`), constant in time
`tractionSeries {...}`	`pressureSeries {...}`	`interpolationTable` sub-dictionary, interpolated at `time().timeOutputValue()`. The value is uniform over the patch.
`tractionField <name>`	`pressureField <name>`	A `volVectorField` / `volScalarField` with that name is constructed by the BC (`MUST_READ` from the time directory, `AUTO_WRITE`), and its boundary values on this patch are used

If neither a series nor a field is given, traction and pressure are read as plain patch fields, so both are required.

updateCoeffs() (skipped if already updated in this evaluation):

Once per time step (tracked through curTimeIndex_), calls correctBoundaryConditions() on the tractionField / pressureField, if one is used.
Updates $\mathbf{t}$ and $p$ from the field or the series.
If setEffectiveTraction is on, subtracts the patch values of a volScalarField named p from the pressure. This applies the effective rather than the total traction, which is meant for poro-elastic solids.
Looks up impK, rImpK, gradD, sigma and Finv on the patch. All are mandatory.
Computes $\mathbf{n}_c$ and the relaxed gradient $\mathbf{g}$ above, then calls fixedGradient::updateCoeffs().

evaluate() calls updateCoeffs() if needed. It looks up the cell gradient field named grad<fieldName> (i.e. gradD for D), sets $\mathbf{D}_b$ by the formula above and resets the updated flag. The matrix coefficients are those of the stock fixedGradient condition: the gradient $\mathbf{g}$ enters the Laplacian as an explicit flux.

Interaction with solidStVK. D boundary conditions are updated when the momentum equation for D is assembled. sigma, gradD and Finv come from the previous Picard / DNA iteration (updated in solidStVK::postSolve()), so the traction is enforced iteratively. It converges together with the PICARD loop on D. The relaxationFactor gives extra under-relaxation of the gradient if this loop oscillates.

write() writes the form actually used for traction and pressure (tractionField/tractionSeries/traction, and likewise for pressure), then secondOrder, setEffectiveTraction, relaxationFactor, value and gradient.

Dictionary Entries

Keyword	Description	Required	Default
`type`	`solidTraction`	yes	–
`traction`	Traction patch field (vector)	yes, unless `tractionSeries` or `tractionField` is given	–
`tractionSeries`	`interpolationTable<vector>` sub-dictionary (`file`, optional `outOfBounds`, `readerType`)	alternative to `traction`	–
`tractionField`	Name of a `volVectorField` to read from the time directory	alternative to `traction`	–
`pressure`	Pressure patch field (scalar, positive = compressive)	yes, unless `pressureSeries` or `pressureField` is given	–
`pressureSeries`	`interpolationTable<scalar>` sub-dictionary	alternative to `pressure`	–
`pressureField`	Name of a `volScalarField` to read from the time directory	alternative to `pressure`	–
`secondOrder`	Second-order reconstruction of the patch value	no	`false`
`setEffectiveTraction`	Subtract the region’s `p` field from the pressure	no	`false`
`relaxationFactor`	Under-relaxation $\omega$ of the gradient	no	`1.0`
`gradient`	Initial normal gradient	no	zero
`value`	Initial patch value	no	patch-internal value

In the series sub-dictionary, outOfBounds defaults to warn and readerType to openFoam. Both are standard OpenFOAM interpolationTable keywords.

Required registered fields on the solid mesh:

Field	Type	Provided by
`impK`, `rImpK`	`volScalarField`	`solidStVK`
`gradD`	`volTensorField`	`solidStVK`
`sigma`	`volSymmTensorField`	`solidStVK`
`Finv`	`volTensorField`	`solidStVK`
`grad<fieldName>`	`volTensorField`	`solidStVK` (`gradD`, when the BC is on `D`)
`p`	`volScalarField`	only with `setEffectiveTraction yes`; no shipped solid region type provides it

Usage

Traction-free surface (0/<solid>/D):

freeSurface
{
 type solidTraction;
 traction uniform (0 0 0);
 pressure uniform 0;
 value uniform (0 0 0);
}

Uniform pressure ramped in time from a table file:

loadedSurface
{
 type solidTraction;
 traction uniform (0 0 0);
 pressureSeries
 {
 file "$FOAM_CASE/constant/solid/pressureSeries";
 outOfBounds clamp;
 }
 relaxationFactor 0.8;
 value uniform (0 0 0);
}

with constant/solid/pressureSeries in the openFoam table format, e.g. ( (0 0) (1 1e4) ).

Known Limitations

Only for solidStVK. The fields impK, rImpK, gradD, sigma and Finv are looked up unconditionally. No other compiled region type provides all of them.
Field and series data are uniform or per face only. tractionSeries / pressureSeries give a value that is uniform over the patch. traction / pressure are constant in time. For space- and time-varying loads, use tractionField / pressureField and drive that field’s own boundary conditions (they are corrected once per time step).
setEffectiveTraction needs a p field on the solid mesh. No shipped solid region type registers one.
Non-orthogonal correction has no effect in OpenFOAM.com (patch-normal delta(); see the note above).
Copies lose the field link. The mapping and copy constructors do not copy tractionFieldPtr_ / pressureFieldPtr_. A cloned patch field (e.g. a stored old-time or previous-iteration copy) keeps the last traction/pressure values and stops following the field. The original boundary condition of D is not affected.
Inconsistent gradient names. updateCoeffs() always reads gradD, while evaluate() reads grad<fieldName>. On a field other than D the two differ.

Tutorials

No tutorial uses solidTraction. The FSI tutorials use regionCoupledTraction on the coupled solid surface and fixedValue / solidSymmetry elsewhere.

References

Cardiff, P., Karač, A., De Jaeger, P., Jasak, H., Nagy, J., Ivanković, A., Tuković, Ž., An open-source finite volume toolbox for solid mechanics and fluid-solid interaction simulations, arXiv:1808.10736, 2018.
Alkfri, A., Habes, C., Marschall, H., multiRegionFoam: A Unified Multiphysics Framework for Multi-Region Coupled Continuum-Physical Problems, Engineering with Computers, 2023. DOI: 10.1007/s00366-024-01974-4

Docs: zeroGradientCorrected

Mon, 01 Jan 0001 00:00:00 +0000

Overview

zeroGradientCorrected is a zero-gradient condition for fields of any type (scalar, vector, sphericalTensor, symmTensor, tensor). Instead of copying the near-wall cell value, it sets the patch value to the cell value plus a non-orthogonal correction $\mathbf{c}\cdot\nabla\phi_P$, evaluated on a small sub-mesh around the patch. The same correction enters the matrix through valueBoundaryCoeffs. It comes from the foam-extend interface-tracking solver (interTrackFoam, Tuković). The BC is compiled into libinterfaceTrackingFvMesh. It derives from the common base correctedFvPatchField (type corrected). The base class, the sub-mesh machinery, the corrected type and the porting status (interTrackFluid disabled, patchCorrected snGrad not ported) are described on the fixedValueCorrected page.

Mathematical Formulation

$$ \left.\frac{\partial\phi}{\partial n}\right|_b = 0 \quad \text{on } \partial\Omega, \qquad \phi_b = \phi_P + \phi_c, \qquad \phi_c = \mathbf{c}\cdot(\nabla\phi)_P, \quad \mathbf{c} = \boldsymbol{\Delta} - \mathbf{n}\,(\mathbf{n}\cdot\boldsymbol{\Delta}) $$

Matrix coefficients:

Coefficient	Value
`valueInternalCoeffs`	$1$
`valueBoundaryCoeffs`	$\phi_c$
`gradientInternalCoeffs`	$0$
`gradientBoundaryCoeffs`	$0$
`snGrad()`	$0$

Symbol	Description	Unit
$\phi$	Patch field	field unit
$\mathbf{n}$	Patch unit normal	–
$\boldsymbol{\Delta}$	Patch delta vector (`patch().delta()`)	m
$\mathbf{c}$	Correction vector	m
$\phi_c$	Stored correction (`corrVecGrad`), updated in `updateCoeffs()`	field unit

Implementation

Construction: the base class reads volFieldName (required) and the optional corrVecGrad. The patch value is set to $\phi_P + \phi_c$. value is not read.
updateCoeffs() (base class): recomputes $\mathbf{c}$ if the mesh moves, rebuilds $\phi_c$ on the patch sub-mesh (gradient scheme snGradCorr(<volFieldName>)). It is called whenever an fvMatrix for the field is constructed, so valueBoundaryCoeffs uses the current $\phi_c$.
evaluate(): declared without the Pstream::commsTypes argument. It does not override fvPatchField::evaluate(const Pstream::commsTypes), which correctBoundaryConditions() calls. The base version runs, and it only resets the updated flag. The patch value is not recomputed after a solve. It stays at the construction value $\phi_P + \phi_c$ of the initial field, so it does not behave like a zero-gradient value at all.
Mapping: autoMap/rmap map the value only.
Sub-mesh motion: interfaceTrackingFvMesh::update() moves the sub-mesh only for U and p.
write(): type, volFieldName, corrVecGrad. No value is written.

Dictionary Entries

Keyword	Description	Required	Default
`type`	`zeroGradientCorrected`	yes	–
`volFieldName`	Name of the volume field this patch field belongs to	yes	– (no default)
`corrVecGrad`	Initial stored correction $\phi_c$	no	zero

The library must be loaded with libs ("libinterfaceTrackingFvMesh.so"); in system/controlDict.

Usage

outlet
{
 type zeroGradientCorrected;
 volFieldName U;
}

Known Limitations

Patch value frozen at its initial value, because the evaluate() signature does not match (see Implementation). Explicit operators that use patch values (fvc::grad, fvc::interpolate, face fluxes) see the initial value.
No correction in OpenFOAM.com (patch-normal delta()). The cost of the sub-mesh gradient remains on every updateCoeffs().
Interface-tracking context not available: interTrackFluid is disabled and patchCorrected is not ported (see fixedValueCorrected).
volFieldName has no default and must match the field name.
Sub-mesh motion only for U and p.

In practice, use the stock zeroGradient instead.

Tutorials

No tutorial uses zeroGradientCorrected.

References

Tuković, Ž., Jasak, H., A moving mesh finite volume interface tracking method for surface tension dominated interfacial fluid flow, Computers & Fluids 55, 2012. DOI: 10.1016/j.compfluid.2011.11.003
Alkfri, A., Habes, C., Marschall, H., multiRegionFoam: A Unified Multiphysics Framework for Multi-Region Coupled Continuum-Physical Problems, Engineering with Computers, 2023. DOI: 10.1007/s00366-024-01974-4

multiPhysicsFoam – Uncoupled

Docs: fixedGradientCorrected

Overview

Mathematical Formulation

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

Docs: fixedValueCorrected

Overview

Mathematical Formulation

Implementation

The corrected type

Dictionary Entries

Usage

Known Limitations

Tutorials

References

Docs: paraboloidInletVelocity

Overview

Mathematical Formulation

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

Docs: solidSymmetry

Overview

Mathematical Formulation

Vector field, first order (default)

Vector field, second order (secondOrder yes)

Scalar field

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

Docs: solidTraction

Overview

Mathematical Formulation

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

Docs: zeroGradientCorrected

Overview

Mathematical Formulation

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

The `corrected` type

Vector field, second order (`secondOrder yes`)