multiPhysicsFoam – Interface-Tracking

Docs: capillaryInterface

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

Overview

capillaryInterface couples two incompressible fluid regions that share a sharp, deforming interface, e.g. a gas bubble (one region) in a liquid (the other region). It uses ALE interface tracking: each phase is its own mesh, and the mesh boundary follows the interface. The interface type holds the interface physics: a finite-area mesh (faMesh) on side A, a constant surface tension $\sigma$, the surface velocity $\mathbf{u}_s$ and the curvature $\kappa$ taken from the faMesh. The jump conditions are applied by four dedicated partitioned p-U boundary conditions, which abort if they are not used together with a capillaryInterface. Coupling runs through the special DNA field pUPimple. No monolithic variant exists.

Interface Conditions

Region $A$ is the first entry of coupledPatchPair and carries the faMesh. Region $B$ is the second entry. $\mathbf{n}$ is the unit normal of the side-A patch (outward from $A$), and $\mathbf{n}_B = -\mathbf{n}$. $\mathbf{u}_s$ is the surface velocity on the faMesh (see Implementation). The conditions below are written the way the BCs evaluate them, after interpolating the neighbour side onto the local patch.

Jump conditions (Dirichlet sides)

Velocity, set on side B (regionCoupledVelocityValue):

$$ \mathbf{U}_B = \mathbf{U}_A - \mathbf{n}_B\,(\mathbf{n}_B\cdot\mathbf{u}_s) + \mathbf{n}_B\,\frac{\phi_{\text{mesh},B}}{|\mathbf{S}_f|} \quad \text{on } \Gamma $$

The tangential velocity is continuous. The normal component of the side-A velocity is replaced by the side-B mesh normal velocity, corrected by the normal part of $\mathbf{u}_s$ (which is the side-A mesh normal velocity, see updateUs()).

Pressure, set on side A (regionCoupledPressureValue, field p):

$$ p_A = p_B + 2(\mu_B - \mu_A)\,\nabla_s\cdot\mathbf{u}_s - \sigma\kappa + (\rho_B - \rho_A)\,(\mathbf{x}_f - \mathbf{x}_\text{ref})\cdot\mathbf{g} \quad \text{on } \Gamma $$

The viscous term is the normal-stress jump, using $\partial u_n/\partial n = -\nabla_s\cdot\mathbf{u}_s$. The gravity term implies that p is the pressure without the hydrostatic part $\rho\,\mathbf{g}\cdot(\mathbf{x}-\mathbf{x}_\text{ref})$ (inferred from the formula). $\mathbf{x}_\text{ref}$ is PISO.pRefPoint of region A. If the field is named pKin, the same jump is applied in kinematic form: $p_{\text{kin},A} = \big(\rho_B\,p_{\text{kin},B} + \text{jump terms}\big)/\rho_A$.

Flux conditions (Neumann sides)

Velocity, set on side A (regionCoupledVelocityFlux, diffusivity $\mu_A$):

$$ \mu_A \frac{\partial \mathbf{U}_A}{\partial n} = -(\mathbf{I} - \mathbf{n}\mathbf{n})\cdot\big(\mu_B \partial_{n_B}\mathbf{U}_B\big) + \mathbf{f}_{\sigma,t} - \mu_A\,\mathbf{n}\,(\nabla_s\cdot\mathbf{u}_s) + (\mu_B - \mu_A)\,(\nabla_s\mathbf{u}_s)\cdot\mathbf{n} $$

with the tangential surface-tension force

$$ \mathbf{f}_{\sigma,t} = \sigma\,\frac{1}{S_f}\sum_{e} \mathbf{L}_e\,c_e \;-\; \sigma\kappa\,\mathbf{n} $$

($\mathbf{L}_e$: edge length vectors, $c_e$: edgeLengthCorrection). With a constant $\sigma$ this is only the discretisation difference between the edge-integrated force and $\sigma\kappa\mathbf{n}$. The tangential shear stress is continuous. The normal component comes from continuity, not from side B.

Pressure, set on side B (regionCoupledPressureFlux):

$$ k_B\,\frac{\partial p_B}{\partial n_B} = -\,\mathbf{n}_B\cdot\frac{\partial \mathbf{U}_B}{\partial t} $$

The neighbour flux is added in fluxJump() and subtracted again in the generic flux BC, so it cancels. The pressure gradient on side B depends only on the local normal acceleration. $k_B$ is the BC’s diffusivity (see Known Limitations: with diffusivity "v" it actually evaluates to $\rho_B$, not $1/\rho_B$; it is $1$ for pKin).

Symbol	Description	Unit
$\mathbf{U}$	Velocity	m/s
$p$	Pressure (static, without hydrostatic part)	Pa
$\mathbf{u}_s$	Surface velocity on the `faMesh` (`<patchA>Us`)	m/s
$\sigma$	Surface tension (`sigma`, constant)	N/m
$\kappa$	Face curvature, `faMesh::faceCurvatures()`	1/m
$\mu_A,\mu_B$	Dynamic viscosities from each region’s `transportProperties`	Pa·s
$\rho_A,\rho_B$	Densities from each region’s `transportProperties`	kg/m³
$\mathbf{g}$	Gravity (`constant/<regionA>/g`)	m/s²
$\phi_\text{mesh}$	Mesh flux `fvc::meshPhi` on the patch	m³/s

Implementation

Construction: reads capillaryInterfaceCoeffs/sigma (required) and creates the area field sigma<regionA><patchA> (uniform $\sigma$, zeroGradient, not written). The faMesh of region A is looked up by the name <patchA>FaMesh. If none is registered, a new faMesh(meshA) is built from region A’s finite-area definition and given that name. The interfaceTrackingFvMesh motion solver gives its own faMesh the same name so it can be shared (whether the lookup finds it in the current OpenFOAM versions has not been verified).
update(): called by every partitioned p-U BC in updateCoeffs(). This is the base-class regionInterfaceType::update():
- after a topology change (not pure motion), clear Us/Phis, re-fetch the faMesh and rebuild the global patches;
- updateK(): on the edges of the curvatureCorrectedSurfacePatches, replace $\kappa$ by an average of neighbouring faces (wedge axis/fixed contact lines);
- correct(): updateUs() sets $\mathbf{u}_s = \mathbf{U}_A - (\mathbf{U}_A\cdot\mathbf{n})\mathbf{n} + w_A\,\mathbf{n}$ with $w_A = \phi_{\text{mesh},A}/|\mathbf{S}_f|$, then fixes the Us boundary values. updatePhis() sets the edge flux $\phi_s = (\mathbf{u}_s)_e\cdot\mathbf{L}_e$. $\sigma$ is not updated (TODO for a surfactant equation of state).
DNA loop for pUPimple (multiRegionSystem::solve()): every coupling iteration runs solvePIMPLE() on all regions (the BCs above are evaluated inside it), then meshMotionCorrector() (interface-tracking mesh motion), then interfaces_->update(). After the loop, postSolvePIMPLE() runs. The standalone solvePIMPLE() call is skipped when pUPimple is coupled. Convergence is checked from the jump/flux residuals of the fields listed under residualControl (U, p), which must exist in both regions.
interfaces_->update() (regionInterfaceTypeList; once in preSolve() and after every DNA iteration): rebuilds the interpolator if the mesh changes (subject to interpolatorUpdateFrequency), then calls info(). info() logs min/max/average curvature, the maximum capillary Courant number, the total surface-tension force and the total viscous + pressure force on side A.
getMinDeltaT(): capillary time-step limit (Brackbill-type), applied only if region A has a registered volScalarField rho:
$$ \Delta t_\sigma = \texttt{maxCapillaryCo}\,\sqrt{\frac{\rho_{A,\min}\,\Delta x_{\min}^3}{2\pi\,\sigma}} $$
where $\Delta x_{\min}$ is the minimum faMesh lPN (distance between neighbouring face centres) and maxCapillaryCo is read from system/controlDict (default 1.0). The solver uses it only with adjustTimeStep yes (setDeltaT.H). Only $\rho_A$ enters, not $\rho_A + \rho_B$.

Coefficients and dictionary keywords

Keyword	Location	Default	Description
`sigma`	`capillaryInterfaceCoeffs`	required	Surface tension, `dimensionedScalar`
`coupled`	interface entry	`true`	Switch coupling on/off
`couplingStartTime`	interface entry	`0`	Enable coupling after this time
`curvatureCorrectedSurfacePatches`	top level of `regionInterfaceProperties`	required	`faPatch` names for curvature correction (may be `0()`)
`interpolatorUpdateFrequency`	top level	`1`	Interpolator rebuild interval in time steps (`0` = never rebuild)
`interfaceTransferMethod`	top level	`AMI`	`AMI` or `directMap`; requires a `<method>Coeffs` sub-dict
`maxCapillaryCo`	`system/controlDict`	`1.0`	Capillary Courant limit for `getMinDeltaT()`

There is no keyword to pick a curvature method: $\kappa$ is always faMesh::faceCurvatures(). The standalone utility calcCurvature writes the same curvature (curvature) plus the normal component of the edge-integrated force (curvatureNew) as volume fields for post-processing. It looks for a patch named freeSurface or interface.

Coupled Fields

coupledFields (pUPimple); couples U and p together:

Field	Required boundary conditions (side A / side B)	Description
`U`	`regionCoupledVelocityFlux` / `regionCoupledVelocityValue`	Velocity: shear-stress balance on A, continuity on B
`p` (or `pKin`)	`regionCoupledPressureValue` / `regionCoupledPressureFlux`	Pressure: normal-stress (Laplace) jump on A, acceleration-based gradient on B

The side assignment is fixed by the code: the BCs on side A read $\mathbf{u}_s$, $\kappa$ and the faMesh normals directly, and regionCoupledVelocityValue interpolates $\mathbf{u}_s$ from its neighbour. The faMesh side must therefore carry U flux / p value. All four BCs need interfaceType (capillaryInterface);.

Fields and objects required:

Object	Region	Used by
`U`, `p`, `phi`	A and B	BCs, `updateUs()`, `info()`
`transportProperties` with `rho`, `mu`	A and B	BCs, `info()`; also `nu` if a region solves `pKin` (checked: $\mu = \rho\nu$)
`g` (`uniformDimensionedVectorField`)	A	`regionCoupledPressureValue`
`PISO { pRefPoint ...; }` in `system/<regionA>/fvSolution`	A	`regionCoupledPressureValue`
`volScalarField rho`	A (optional)	enables `getMinDeltaT()`; also used for `meshPhi`
finite-area mesh on the interface patch	A	everything

Created at run time (not written): sigma<regionA><patchA> (areaScalarField), <patchA>Us (areaVectorField), <patchA>Phis (edgeScalarField).

Compatible Region Types

Region type (side A)	Region type (side B)	Notes
`interTrackFluid`	`interTrackFluid`	Used by all tutorials, but disabled in `src/multiRegionSystem/Make/files`
`icoFluid`	`icoFluid`	Follows the same conventions (`p` in Pa, `rho` field, `PISO.pRefPoint`, `closedVolume`, `interfaceShadow`, `space`). Inferred, untested. No `g` is created.
`pimpleFluid`	`pimpleFluid`	BCs contain a `pKin` branch. `regionCoupledPressureValue` still needs a `PISO { pRefPoint; }` entry, which `pimpleFluid` itself does not read. Untested.

The region needs a moving mesh whose interface patch follows the interface (interfaceTrackingFvMesh from libinterfaceTrackingFvMesh, see src/dynamicFvMesh). Otherwise the interface stays fixed. See icoFluid and pimpleFluid.

Case Setup

`regionInterfaceProperties` entry

From tutorials/multiphaseFlow/2dRisingBubble/constant/regionInterfaceProperties:

partitionedCoupledPatches
(
 fluidAfluidB
 {
 interfaceType (capillaryInterface);

 coupledPatchPair
 (
 (fluidA interface)
 (fluidB interfaceShadow)
 );

 coupledFields
 (
 pUPimple
 );

 capillaryInterfaceCoeffs
 {
 sigma sigma [ 1 0 -2 0 0 0 0 ] 0.07232;
 }
 }
);

monolithicCoupledPatches
();

curvatureCorrectedSurfacePatches 0();

interpolatorUpdateFrequency 0;

interfaceTransferMethod directMap;

directMapCoeffs
{}

`multiRegionProperties` DNA entry

DNA
{
 pUPimple
 {
 maxCoupleIter 10;

 residualControl
 {
 U
 {
 maxJumpRes 1e-5;
 outputJumpResField yes;
 maxFluxRes 1e-4;
 outputFluxResField yes;
 }

 p
 {
 maxJumpRes 1e-5;
 outputJumpResField yes;
 maxFluxRes 1e-5;
 outputFluxResField yes;
 }
 }
 }
}

Boundary conditions

Side A (0/fluidA/orig/partitioned/U and p, patch interface, carries the faMesh):

interface
{
 type regionCoupledVelocityFlux;
 diffusivity "mu";
 interfaceType (capillaryInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform (0 0 0);
}

interface
{
 type regionCoupledPressureValue;
 diffusivity "v";
 interfaceType (capillaryInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform 0;
}

Side B (0/fluidB/orig/partitioned/U and p, patch interfaceShadow):

interfaceShadow
{
 type regionCoupledVelocityValue;
 diffusivity "mu";
 interfaceType (capillaryInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform (0 0 0);
}

interfaceShadow
{
 type regionCoupledPressureFlux;
 diffusivity "v";
 interfaceType (capillaryInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform 0;
}

Other required files (from `2dRisingBubble`)

constant/fluidA/faMesh/faMeshDefinition – faMesh on patch "interface" (Allrun: makeFaMesh -region fluidA)
constant/fluid{A,B}/transportProperties – rho, v, mu
constant/fluidA/g – gravity
constant/fluidA/dynamicMeshDict – dynamicFvMesh interfaceTrackingFvMesh; movingSurfacePatches (interface ...)
system/fluidA/fvSolution – PISO { pRefPoint; pRefValue; } hasSpacePatch yes;
system/fluidB/fvSolution – closedVolume yes;
system/faSchemes, system/fluidA/faSchemes, faSolution
system/controlDict – libs ("libinterfaceTrackingFvMesh.so" ...)

Known Limitations

No runnable tutorial: all three tutorials select interTrackFluid, which is commented out in src/multiRegionSystem/Make/files (together with pUCoupledIcoFluid). They would fail when the region type is selected at run time (inferred).
Constant surface tension: sigma_ is created once from sigma and never updated (correct() has only a TODO for an equation of state). There is no Marangoni effect or surfactant transport.
No curvature model choice: $\kappa$ = faMesh::faceCurvatures(). The only correction is the averaging on curvatureCorrectedSurfacePatches, and that keyword is mandatory even when it is empty.
diffusivity "v" gives $\rho$, not $1/\rho$ (code bug in diffCoeff() of both genericRegionCoupledJump and genericRegionCoupledFlux): "v" is renamed to "rho" before the == "v" test, so the reciprocal is never taken. For regionCoupledPressureFlux this makes $\partial p_B/\partial n = -\mathbf{n}_B\cdot\partial_t\mathbf{U}_B/\rho_B$ instead of $-\rho_B\,\mathbf{n}_B\cdot\partial_t\mathbf{U}_B$. The effect on the tutorials was inferred, not tested.
Pressure flux ignores the neighbour: the neighbour flux cancels in regionCoupledPressureFlux, so side B gets a purely local Neumann condition (convective and viscous normal terms are commented out).
Fixed side roles: the faMesh must be on the first patch of coupledPatchPair, and that side must carry the U flux / p value BCs (see above). The hard-coded field names are U, p, phi, rho, g, transportProperties.
update() runs once per BC evaluation: every coupled BC calls rgInterface().update(), so $\mathbf{u}_s$ and the curvature correction are recomputed up to four times per corrector (cost only).
Capillary time step: uses only $\rho_A$ and $\min(\Delta x)$ of the faMesh. It is skipped when region A has no rho volume field. The info() capillary Courant number uses the transportProperties value instead.
correctUsBoundaryConditions(): for faPatches next to a slip or symmetry U patch it assigns the full internal Us field to the patch value (and computes an unused normal N). This looks like a bug, but none of the tutorials reach it, so it is untested.
Phis and normal/tangentialSurfaceTensionForce() are computed or available but not used by any BC (regionCoupledVelocityFlux recomputes the forces itself).
Serial only (inferred): 2dRisingBubble/Allrun -P prints “Running this case in parallel is currently not supported”.
No monolithic coupling: monolithicCoupledPatches must stay empty for this interface.

Tutorials

No runnable tutorial exists: all of the cases below use interTrackFluid in both regions, and that region type is disabled. They remain the reference setups (./Allrun -p -S).

Tutorial	Description
`tutorials/multiphaseFlow/2dRisingBubble`	2D gas bubble rising in liquid, $\sigma = 0.07232$ N/m, `directMap` transfer
`tutorials/multiphaseFlow/3dOscillatingBubble`	3D oscillating bubble, $\sigma = 0.0727$ N/m
`tutorials/multiphaseFlow/3dDuineveldRisingBubble`	3D rising bubble (Duineveld experiment), $\sigma = 0.0727$ N/m

References

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

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

Overview

regionCoupledVelocityValue is the Dirichlet (jump) half of the partitioned velocity coupling across a sharp, mesh-tracked fluid-fluid interface. It acts on a volVectorField (the velocity U) and derives from genericRegionCoupledJump<vector>, i.e. from fixedValue. The patch value is the neighbour velocity, interpolated onto this patch, with its normal component replaced by the normal velocity of the local mesh. The tangential velocity is therefore continuous. The partner condition on the other side is regionCoupledVelocityFlux. Both belong to capillaryInterface, and this BC aborts if the first entry of its interfaceType list is not capillaryInterface. The pressure is coupled by regionCoupledPressureValue and regionCoupledPressureFlux in the same pUPimple DNA loop.

Mathematical Formulation

Region $A$ is the first entry of coupledPatchPair and carries the finite-area mesh of the capillaryInterface. This BC sits on side $B$ (see Known Limitations). $\mathcal{I}_{A\to B}$ is the patch-to-patch interpolation (interfaceTransferMethod), $\mathbf{n}_B$ the outward unit normal of the local patch.

$$ \mathbf{U}_B^{*} = \mathcal{I}_{A\to B}(\mathbf{U}_A) - \mathbf{n}_B\left(\mathbf{n}_B\cdot\mathcal{I}_{A\to B}(\mathbf{u}_s)\right) + \mathbf{n}_B\,\frac{\phi_{\text{mesh},B}}{|\mathbf{S}_f|} \quad \text{on } \Gamma_B $$

$\mathbf{U}_B^{*}$ is then passed through the acceleration model:

$$ \mathbf{U}_B^{k} = \mathbf{U}_B^{k-1} + \omega\left(\mathbf{U}_B^{*} - \mathbf{U}_B^{k-1}\right) $$

with $\omega$ = relax (fixed), the Aitken factor (aitken), or an IQN-ILS update (IQNILS).

The surface velocity $\mathbf{u}_s$ of the capillaryInterface is $\mathbf{U}_A - (\mathbf{U}_A\cdot\mathbf{n}_A)\mathbf{n}_A + w_A\mathbf{n}_A$, where $w_A$ is the side-A mesh normal velocity. The term $-\mathbf{n}_B(\mathbf{n}_B\cdot\mathbf{u}_s)$ therefore removes the normal part of $\mathbf{U}_A$ up to the side-A mesh motion. The last term imposes the side-B mesh normal velocity.

The diffusive momentum flux handed to regionCoupledVelocityFlux is

$$ \mathbf{F}_B = \mu_B\,(\mathbf{I}-\mathbf{n}_B\mathbf{n}_B)\cdot\frac{\partial\mathbf{U}_B}{\partial n}, \qquad \frac{\partial\mathbf{U}_B}{\partial n} = \Delta_f\left(\mathbf{U}_B - \mathbf{U}_P - \mathbf{k}\cdot\nabla\mathbf{U}_P\right) $$

The non-orthogonal term $\mathbf{k}\cdot\nabla\mathbf{U}_P$ is only present with nonOrthCorr yes. With secondOrder yes the gradient is $2\Delta_f(\mathbf{U}_B - \mathbf{U}_P - \mathbf{k}\cdot\nabla\mathbf{U}_P) - \mathbf{n}_B\cdot\nabla\mathbf{U}_P$. In both cases the normal component is removed.

Symbol	Description	Unit
$\mathbf{U}$	Velocity	m/s
$\mathbf{u}_s$	Surface velocity of the `capillaryInterface` (`Us()`, on side A)	m/s
$\phi_{\text{mesh},B}$	Boundary value of `fvc::meshPhi(rho, U)` if a `volScalarField rho` is registered in region B, otherwise `fvc::meshPhi(U)`	m³/s
$\mathbf{S}_f$	Face area vector of the local patch	m²
$\mu_B$	Diffusivity `mu` of region B (field or `transportProperties`)	Pa·s
$\Delta_f$	Patch `deltaCoeffs`	1/m
$\mathbf{k}$	Non-orthogonal part of the face-to-cell vector, $\mathbf{d}-\mathbf{n}(\mathbf{n}\cdot\mathbf{d})$	m
$\omega$	Relaxation factor from the acceleration model	–

Implementation

updateCoeffs() is the generic one of genericRegionCoupledJump. Each call:

Returns immediately if the patch is already updated or the interface has coupled no. In that case the patch keeps its last value.
Calls update() on the interface named first in interfaceType. For capillaryInterface this refreshes the curvature and the surface velocity $\mathbf{u}_s$ (correct()).
Looks up the neighbour field with the local field name (U), interpolates its patch values onto this patch and adds valueJump(). valueJump() returns $-\mathbf{n}_B(\mathbf{n}_B\cdot\mathcal{I}_{A\to B}(\mathbf{u}_s)) + \mathbf{n}_B\,\phi_{\text{mesh},B}/|\mathbf{S}_f|$.
Assigns the result, relaxes it with the acceleration model and calls fixedValue::updateCoeffs().

The matrix coefficients come from the vector specialisations in genericRegionCoupledJump. gradientInternalCoeffs() is the fixedValue one ($-\Delta_f$). gradientBoundaryCoeffs() subtracts the normal part of the current face gradient explicitly, using the current cell values. At convergence only the tangential gradient enters the viscous term of the momentum equation. snGrad() drops the normal part in the same way. If a volTensorField named grad(U) is registered, it is used for the non-orthogonal and second-order terms; otherwise fvc::grad(U) is computed on every call.

flux() returns snGrad()*k. k comes from diffCoeff() with the hardcoded diffusivity name mu: the patch values of a registered volScalarField mu, otherwise the scalar mu from the region’s registered transportProperties dictionary.

The DNA loop for pUPimple (multiRegionSystem::solve()) runs solvePIMPLE() on all regions, in which this BC is evaluated, then meshMotionCorrector() and interfaces_->update(). The jump residual for U is taken from this BC, because the side-A U patch carries a flux BC:

$$ r = \frac{\lVert \mathbf{U}_B - \mathcal{I}_{A\to B}(\mathbf{U}_A) - \text{valueJump}\rVert_2} {\max\left(\min\left(\lVert\mathbf{U}_B\rVert_2,\ \lVert\mathcal{I}_{A\to B}(\mathbf{U}_A)+\text{valueJump}\rVert_2\right),\ \text{SMALL}\right)} $$

The class also defines updatePhi(), which would overwrite the boundary phi with the negated interpolated neighbour flux. The call in the base class is commented out, so it is never executed.

correctClosedVolumePhi() (used by icoFluid and interTrackFluid when closedVolume is on in fvSolution) looks for the patch carrying this BC (or regionCoupledMassTransferVelocityValue). It sets phi = U·Sf there and removes the net flux, weighted by $|\phi|$, so the net volume flux through the interface is zero.

Dictionary Entries

Keyword	Description	Required	Default
`type`	`regionCoupledVelocityValue`	yes	—
`interfaceType`	List of interface type names. The first entry is the interface this BC belongs to and must be `capillaryInterface`. The neighbour region and patch are taken from the matching interface entry in `regionInterfaceProperties`	yes	—
`value`	Initial patch value. Read if present. If missing, the patch values are not initialised	in practice yes	—
`diffusivity`	Read, but ignored: the BC always uses `mu`	no	empty
`neighbourFieldName`	Read by the coupling manager. Not used by this BC, which looks up the neighbour field by the local name	no	local field name
`jumpCoefficient`	Read by the base class, not used, not written back	no	empty
`accType`	Acceleration model: `fixed`, `aitken` or `IQNILS`. A warning is printed if missing	no	`fixed`
`relax`	(Initial) relaxation factor	no	`1.0`
`couplingReuse`	`IQNILS` only: number of previous time steps whose coupling data are reused	no	`0`
`nonOrthCorr`	Non-orthogonal correction in `snGrad()` / matrix coefficients	no	`false`
`secondOrder`	Second-order face-normal gradient	no	`false`

write() writes interfaceType, the resolved neighbourFieldName, diffusivity mu, accType, relax (and couplingReuse for IQNILS), nonOrthCorr, secondOrder and value.

Usage

tutorials/multiphaseFlow/2dRisingBubble/0/fluidB/orig/partitioned/U (side B):

interfaceShadow
{
 type regionCoupledVelocityValue;
 diffusivity "mu"; // ignored, always mu
 interfaceType (capillaryInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform (0 0 0);
}

Partner on side A, 0/fluidA/orig/partitioned/U:

interface
{
 type regionCoupledVelocityFlux;
 diffusivity "mu";
 interfaceType (capillaryInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform (0 0 0);
}

constant/regionInterfaceProperties:

partitionedCoupledPatches
(
 fluidAfluidB
 {
 interfaceType (capillaryInterface);

 coupledPatchPair
 (
 (fluidA interface) // side A: faMesh, VelocityFlux, PressureValue
 (fluidB interfaceShadow) // side B: VelocityValue, PressureFlux
 );

 coupledFields
 (
 pUPimple
 );

 capillaryInterfaceCoeffs
 {
 sigma sigma [ 1 0 -2 0 0 0 0 ] 0.07232;
 }
 }
);

constant/multiRegionProperties (U and p must exist in both regions):

DNA
{
 pUPimple
 {
 maxCoupleIter 10;

 residualControl
 {
 U { maxJumpRes 1e-5; maxFluxRes 1e-4; }
 p { maxJumpRes 1e-5; maxFluxRes 1e-5; }
 }
 }
}

Known Limitations

capillaryInterface only. capInterface() aborts if the first interfaceType entry is not capillaryInterface.
Must sit on side B (inferred). $\mathbf{u}_s$ lives on the side-A finite-area mesh and is interpolated “from the neighbour”. On side A, the side-A field would be mapped as if it belonged to side B.
diffusivity is ignored. diffusivityName() is hardcoded to mu.
neighbourFieldName has no effect. The neighbour velocity is looked up by the local field name.
value should be given. The base class reads it only if present and does not initialise the patch otherwise.
updatePhi() is dead code, so the boundary phi is not set from the neighbour by this BC.
The header example omits interfaceType, which is required.
No runnable tutorial. All tutorials that use this BC run on interTrackFluid, which is commented out in src/multiRegionSystem/Make/files.
Partitioned only. There is no monolithic variant.

Tutorials

Tutorial	Description
`tutorials/multiphaseFlow/2dRisingBubble`	2D rising gas bubble, `interTrackFluid` + `interTrackFluid` (region type currently disabled)
`tutorials/multiphaseFlow/3dDuineveldRisingBubble`	3D rising bubble (Duineveld), same setup
`tutorials/multiphaseFlow/3dOscillatingBubble`	3D oscillating bubble, same setup

The BC is set in the 0/fluidB/orig/partitioned/U variant of each tutorial.

References

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 – Interface-Tracking

Docs: capillaryInterface

Overview

Interface Conditions

Jump conditions (Dirichlet sides)

Flux conditions (Neumann sides)

Implementation

Coefficients and dictionary keywords

Coupled Fields

Compatible Region Types

Case Setup

regionInterfaceProperties entry

multiRegionProperties DNA entry

Boundary conditions

Other required files (from 2dRisingBubble)

Known Limitations

Tutorials

References

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

Overview

Mathematical Formulation

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

Docs: zeroGradientCorrected

Overview

Mathematical Formulation

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

`regionInterfaceProperties` entry

`multiRegionProperties` DNA entry

Other required files (from `2dRisingBubble`)

The `corrected` type