multiPhysicsFoam – Multiphase

Docs: calcCurvature

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

Overview

calcCurvature is a standalone application that builds the finite-area mesh (faMesh) of a case and evaluates the mean curvature of that surface for a single time. It writes two volume fields, curvature and curvatureNew. Both are zero everywhere except on the boundary patch named freeSurface or interface. The curvature it computes is the same faMesh::faceCurvatures() that capillaryInterface uses for the surface-tension pressure jump. Use it to check the curvature quality of a surface mesh (e.g. a spherical bubble, where $\kappa$ should be uniform) before running a capillary case. It is a single-mesh tool: it does not read multiRegionProperties and knows nothing about regions beyond the standard -region option.

Method

Time and mesh. The time is selected with the standard time options (see Usage). The run time is set to the first selected time, and only that time is processed. The mesh is created as a dynamicFvMesh (region from -region, default region0). If constant/[<region>/]dynamicMeshDict is absent, a staticFvMesh is used. The mesh is never moved.
Finite-area mesh. faMesh(mesh) is constructed for the default area name, i.e. it reads the faMesh written by makeFaMesh (constant/[<region>/]faMesh).
Patch detection. The boundary is scanned for a patch named freeSurface or interface. If both exist, the one with the higher patch index wins. If neither exists, the application aborts with a bare FatalError (no message).
Curvature (curvature). The faMesh face curvature is copied into the detected patch:
$$ \mathbf{k}_N = \frac{1}{S_f}\sum_{e \in f} \mathbf{L}_e\, c_e, \qquad \kappa = \operatorname{sign}\!\left(\mathbf{k}_N\cdot\mathbf{n}_f\right)\,|\mathbf{k}_N| $$
with $S_f$ the face area, $\mathbf{L}_e$ the edge length vectors (Le()), $c_e$ the edge length correction (edgeLengthCorrection(), $c_e = \cos\!\big(\tfrac{1}{2}\arcsin|\mathbf{n}_a\times\mathbf{n}_b|\big)$ from the two edge point normals) and $\mathbf{n}_f$ the faMesh face area normal. $\kappa$ is therefore signed relative to the faMesh normal.
Alternative curvature (curvatureNew). The same edge sum $\mathbf{k}_N$ is computed again. A unit “normal” is built from it, $\hat{\mathbf{n}} = \mathbf{k}_N/|\mathbf{k}_N|$, falling back to the fvPatch face normal where $|S_f\,\mathbf{k}_N| \le$ SMALL. The written value is
$$ \kappa_\text{new} = \hat{\mathbf{n}}\cdot\mathbf{k}_N $$
Because $\hat{\mathbf{n}}$ is parallel to $\mathbf{k}_N$, this is $|\mathbf{k}_N| = |\kappa|$ wherever the fallback is not active, i.e. the unsigned curvature.
Report. Min/max and arithmetic mean (unweighted by face area) of both patch fields are printed to the log.

Usage

Command line (standalone application):

calcCurvature [-region <name>] [-time <ranges> | -latestTime] [-constant] [-noZero]

Option	Description
`-region <name>`	Mesh region to operate on. Default: `region0` (case root).
`-time <ranges>`	Time ranges to select (e.g. `0.1`, `:10,20 40:70`). Only the first selected time is processed.
`-latestTime`	Select the latest time. On its own, this processes the latest time; combined with other selections only the earliest one is processed.
`-constant`	Include `constant/` in the time list.
`-noZero`	Exclude `0/` from the time list.

Without time options all time directories (including 0/) are selected, so the earliest time is processed. If no time directory matches, constant/ is used with a warning.

Typical sequence for a single-mesh case:

blockMesh
makeFaMesh
calcCurvature

Input / Output

Read

File	Description
`constant/[<region>/]polyMesh`	Volume mesh; must contain a patch named `freeSurface` or `interface`
`constant/[<region>/]faMesh`	Finite-area mesh from `makeFaMesh` on that patch
`constant/[<region>/]dynamicMeshDict`	Optional; selects the `dynamicFvMesh` type (static if absent)
`system/[<region>/]faSchemes`, `faSolution`	Required by the `faMesh`
`system/[<region>/]fvSchemes`, `fvSolution`	Required by the `fvMesh`

Written to <time>/[<region>/] of the processed time:

Field	Type	Unit	Content
`curvature`	`volScalarField`	1/m	0 in all cells and on all other patches; signed $\kappa$ on the free-surface/interface patch
`curvatureNew`	`volScalarField`	1/m	0 in all cells and on all other patches; $\kappa_\text{new}$ (unsigned, see Method) on that patch

All patches are of type calculated. No other fields are read or written.

Known Limitations

Single time only. The selected time list is not looped over. Only the earliest selected time is processed, even if -time selects several.
Fixed patch names. The patch must be called exactly freeSurface or interface. There is no option to pick another name (e.g. interfaceShadow). A missing patch aborts with an empty error message.
faMesh must cover exactly that patch. The faMesh face values are assigned directly to the patch, so the faMesh must be built on that patch only, with the same face count and ordering. A faMesh on a different or additional patch causes a size mismatch.
curvatureNew is unsigned. Its “normal” is derived from the edge sum itself rather than from the surface normal, so it carries no sign. It is not the signed normal force density that its comments suggest.
Mean of face values. The printed average is an unweighted face average, not an area-weighted one.
Libraries for the dynamicMeshDict. The application links only finiteVolume, finiteArea, dynamicFvMesh, dynamicMesh and meshTools. A dynamicMeshDict that selects a mesh type or motion solver from another library (e.g. interfaceTrackingFvMesh, or a motion solver from fvMotionSolvers) needs that library loaded through the dictionary’s library entries. Otherwise the selection fails.
No parallel-specific handling. Min/max/average are evaluated per processor without reduction.

Tutorials

Tutorial	Description
`tutorials/multiphaseFlow/3dDuineveldRisingBubble/baseMeshes/meshA`	Base bubble mesh generation (`blockMesh`, `makeFaMesh` on patch `interface`). The `calcCurvature` call is present but commented out in `Allrun`.
`tutorials/multiphaseFlow/3dDuineveldRisingBubble/hexBaseMeshes/meshA`	Same for the hex base mesh; the call is likewise commented out.

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

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

Overview

interFluid solves the flow of two incompressible, isothermal, immiscible fluids (for example water and air) on one mesh. It captures the interface with the algebraic Volume-of-Fluid (VOF) method: one phase-fraction field $\alpha_1$ is transported with a MULES-limited, interface-compressed equation, and a single mixture momentum equation is solved with the PIMPLE algorithm. The momentum equation is written in terms of the pressure minus its hydrostatic part, $p_{rgh}$. The region type is a port of OpenFOAM’s interFoam solver into the regionType framework, built on the same pattern as pimpleFluid. It supports laminar, RANS and LES turbulence modelling, surface tension (CSF), MRF, fvOptions and mesh motion through dynamicFvMesh. It can run standalone, or as the fluid side of a fluid-structure interaction (FSI) case. For FSI it provides the Cauchy stress tensor sigma to fsiInterface, it supports mesh motion driven by the solid’s displacement, and it is laminar only. It cannot take part in any other kind of inter-region coupling yet.

Governing Equations

Continuity

$$ \nabla \cdot \mathbf{U} = 0 $$

Phase-fraction transport

$$ \frac{\partial \alpha_1}{\partial t} + \nabla \cdot \left(\alpha_1 \mathbf{U}\right) + \nabla \cdot \left(\alpha_1 (1 - \alpha_1)\,\mathbf{U}_r\right) = 0, \qquad \alpha_2 = 1 - \alpha_1 $$

The third term is an artificial interface-compression term. It is non-zero only inside the transition region ($0 < \alpha_1 < 1$) and works against the numerical smearing of the interface. The compression velocity is never assembled as a vector field. The code uses its face flux directly:

$$ \phi_r = c_\alpha \left| \frac{\phi}{|\mathbf{S}_f|} \right| \hat{\mathbf{n}}_f \cdot \mathbf{S}_f $$

$\phi_r$ is set to zero on all non-coupled boundary faces, so compression never moves phase across a domain boundary.

Mixture properties

$$ \rho = \alpha_1 \rho_1 + \alpha_2 \rho_2, \qquad \mu = \alpha_1 \rho_1 \nu_1 + \alpha_2 \rho_2 \nu_2, \qquad \nu = \mu / \rho $$

Momentum

$$ \frac{\partial (\rho \mathbf{U})}{\partial t} + \nabla \cdot \left(\rho \mathbf{U}\mathbf{U}\right) - \nabla \cdot \mathbf{R} = -\nabla p_{rgh} - (\mathbf{g} \cdot \mathbf{h})\,\nabla \rho + \mathbf{F}_\sigma + \mathbf{S}_U $$

In the discrete momentum equation the convective term uses the mass flux rhoPhi. This flux is rebuilt from the bounded MULES phase flux (see below), so momentum and phase transport stay consistent.

Surface tension (CSF)

$$ \mathbf{F}_\sigma = \sigma \kappa \nabla \alpha_1, \qquad \kappa = -\nabla \cdot \hat{\mathbf{n}}, \qquad \hat{\mathbf{n}}_f = \frac{(\nabla \alpha_1)_f}{|(\nabla \alpha_1)_f| + \delta_N} $$

At walls with an alphaContactAngle-type boundary condition, the interface normal is rotated so that the interface meets the wall at the prescribed contact angle.

Gravity decomposition and pressure recovery

$$ p_{rgh} = p - \rho\, \mathbf{g} \cdot \mathbf{h}, \qquad gh = \mathbf{g} \cdot \mathbf{x}_C - gh_\text{ref}, \qquad gh_f = \mathbf{g} \cdot \mathbf{x}_{C_f} - gh_\text{ref} $$

The solver solves for $p_{rgh}$. The static pressure $p = p_{rgh} + \rho\,gh$ is recovered after each pressure correction.

Stress tensor (for FSI coupling)

After each pressureCorrector() call (once per outer corrector) the Cauchy stress tensor is updated:

$$ \boldsymbol{\sigma} = -p\,\mathbf{I} + \mu\left[\nabla\mathbf{U} + (\nabla\mathbf{U})^T - \tfrac{2}{3}(\nabla\cdot\mathbf{U})\,\mathbf{I}\right] $$

The bracket is OpenFOAM’s devTwoSymm(fvc::grad(U)). Since $\nabla\cdot\mathbf{U} = 0$, its trace term vanishes up to discretisation error. The pressure is $p$, which is already dimensional, so unlike pimpleFluid no $\rho$ factor is needed. $\mu$ is the local mixture dynamic viscosity, so the viscous traction switches between water and air values across the interface. The field is sigma, and fsiInterface uses it to compute the traction on the solid side (via regionCoupledTraction).

This is the stress formula of pimpleFluid with only the molecular viscosity kept: $\rho\left(-p_\text{kin}\mathbf{I} - \mathbf{R}^\text{dev}\right) = -p\,\mathbf{I} + \mu_\text{eff}\,\texttt{devTwoSymm}(\nabla\mathbf{U})$ with $\mu_\text{eff} \to \mu$. The turbulent (Reynolds-stress) part is not included, because the VOF turbulence wrapper (incompressibleInterPhaseTransportModel) has no public devRhoReff(). The expression is exact for laminar flow.

Note

The field sigma (Cauchy stress, Pa) is not the same thing as the entry sigma in transportProperties (surface tension coefficient, N/m). They only share a name.

Symbol	Description	Unit
$\alpha_1$, $\alpha_2$	Phase fraction of phase 1 / phase 2	–
$\mathbf{U}$	Mixture velocity (shared by both phases)	m/s
$\phi$	Volumetric face flux	m³/s
$p$	Static pressure	Pa
$p_{rgh}$	Pressure minus hydrostatic contribution	Pa
$\rho_1$, $\rho_2$ / $\rho$	Phase densities / mixture density	kg/m³
$\nu_1$, $\nu_2$ / $\mu$	Phase kinematic viscosities / mixture dynamic viscosity	m²/s / Pa·s
$\mathbf{R}$	Effective stress tensor (viscous + turbulent)	Pa
$\mathbf{U}_r$, $\phi_r$	Compression velocity / compression flux	m/s / m³/s
$c_\alpha$	Interface-compression coefficient (`cAlpha`)	–
$\sigma$	Surface tension coefficient	N/m
$\kappa$	Interface curvature	1/m
$\hat{\mathbf{n}}$	Interface unit normal	–
$\mathbf{g}$	Gravitational acceleration	m/s²
$h_\text{ref}$	Reference height (`constant/hRef`, optional)	m
$\mathbf{F}_\sigma$	Surface tension force	N/m³
$\mathbf{S}_U$	Momentum source (from `fvOptions`)	N/m³
$\boldsymbol{\sigma}$	Cauchy stress tensor (FSI)	Pa

Numerical Algorithm

The framework drives interFluid through the regionType PIMPLE phases. For every outer corrector (nOuterCorrectors), regionTypeList::solvePIMPLE() calls prePredictor(), then momentumPredictor(), then pressureCorrector(). This is the same order as the loop body of stock interFoam.

Mesh motion (prePredictor(), dynamic meshes only). Runs mesh().controlledUpdate() once per time step, or on every outer corrector if moveMeshOuterCorrectors yes. Then it recomputes gh/ghf, updates MRF and, if correctPhi is on, restores a divergence-free flux on the moved mesh. It also corrects Uf.
Phase-fraction transport (prePredictor()). Re-reads the alpha controls, then solves the $\alpha_1$ equation with MULES. There are two options:
- explicit MULES (MULESCorr no), which applies a limited flux in one step, or
- semi-implicit MULES (MULESCorr yes), which first solves an implicit, upwind-bounded predictor and then applies nAlphaCorr limited high-order correction passes.
With nAlphaSubCycles > 1 this step is sub-cycled and the mass flux rhoPhi is averaged over time across the sub-cycles. Afterwards $\rho = \alpha_1\rho_1 + \alpha_2\rho_2$ is updated, and mixture.correct() recomputes the normals, curvature and surface-tension force.
Momentum predictor (momentumPredictor()). Builds the momentum matrix with rho/rhoPhi and caches it. If momentumPredictor yes, it solves the matrix against the explicit surface-tension, buoyancy and $p_{rgh}$-gradient forcing, reconstructed from face fluxes.
Pressure correction, PISO loop (pressureCorrector()). Runs nCorrectors times. It builds $r_{AU} = 1/A$, $\mathbf{H}/A$ and a Rhie–Chow-consistent phiHbyA (including ddtCorr, which is aware of mesh motion). It adds the surface-tension and gravity flux:

$$ \phi_g = \left(\mathbf{F}_{\sigma,f} - gh_f\,\nabla^\perp_f \rho\right) r_{AU,f}\,|\mathbf{S}_f| $$

and solves the pressure equation:

$$ \nabla \cdot \left( r_{AU,f}\,\nabla p_{rgh} \right) = \nabla \cdot \phi_{HbyA} $$

The non-orthogonal corrector sub-loop is controlled by nNonOrthogonalCorrectors. On the final non-orthogonal iteration the solver corrects the flux and the velocity:

$$ \phi = \phi_{HbyA} - \left(r_{AU,f}\nabla p_{rgh}\right)_f, \qquad \mathbf{U} = \mathbf{H}/A + r_{AU}\,\mathcal{R}\!\left(\frac{\phi_g - \left(r_{AU,f}\nabla p_{rgh}\right)_f}{r_{AU,f}}\right) $$

where $\mathcal{R}$ is the face-to-cell reconstruction (fvc::reconstruct). It then reports continuity errors, corrects Uf, makes the flux relative to the mesh motion and recovers $p = p_{rgh} + \rho\,gh$. For closed domains it also applies the reference-pressure shift. 5. Turbulence correction (end of pressureCorrector()). Calls turbulence->correct() when pimple.turbCorr() is true. 6. Stress update (end of pressureCorrector()). Recomputes sigma from the new $p$ and $\mathbf{U}$ for FSI coupling. This runs on every outer corrector, including in standalone runs.

The scheme is fully segregated. $\alpha_1$, $\mathbf{U}$/$p_{rgh}$ and the turbulence fields are each solved with the other fields frozen, and the outer correctors provide the non-linear coupling between them.

Time-step control

getMinDeltaT() computes the flow Courant number over all cells and the interface Courant number $\mathrm{Co}_\alpha$ over cells with $0.01 < \alpha_1 < 0.99$. It returns:

$$ \Delta t_\text{stab} = \Delta t \cdot \min\!\left( \frac{\mathrm{Co}_\text{max}}{\mathrm{Co} + \epsilon},\; \frac{\mathrm{Co}_{\alpha,\text{max}}}{\mathrm{Co}_\alpha + \epsilon} \right) $$

The solver’s setDeltaT.H then limits how fast the step can grow (at most a factor of 1.2 per step, damped) and caps it at maxDeltaT.

Sub-Models

Sub-model	Selection mechanism	Notes
Two-phase mixture	`constant/transportProperties`	`immiscibleIncompressibleTwoPhaseMixture`; `phases (<phase1> <phase2>)` plus a per-phase `transportModel`/`nu`/`rho` sub-dict
Surface tension	`constant/transportProperties` (`sigma`)	Run-time selectable `surfaceTensionModel`; a constant value is enough
Turbulence (laminar / RANS / LES)	`constant/turbulenceProperties`	`incompressibleInterPhaseTransportModel`, evaluated on mixture properties
Gravity / reference height	`constant/g`, `constant/hRef` (optional)	`hRef` defaults to 0
Moving Reference Frame (MRF)	`constant/MRFProperties`	`IOMRFZoneList`
`fvOptions`	`system/fvOptions`	Explicit/implicit momentum sources, porosity
Mesh motion	`constant/dynamicMeshDict`	Any stock `dynamicFvMesh` + `motionSolver` (e.g. `dynamicMotionSolverFvMesh`)

Required Fields

Field	Type	Description	Unit
`alpha.<phase1>`	`volScalarField`	Phase fraction of the first phase listed in `phases` (e.g. `alpha.water`)	–
`U`	`volVectorField`	Velocity	m/s
`p_rgh`	`volScalarField`	Pressure minus hydrostatic contribution	Pa
Turbulence fields	–	As required by the selected model (e.g. `k`, `epsilon`, `omega`, `nut`)	–

Additionally created at runtime:

Field	Type	Description	Condition
`phi`	`surfaceScalarField`	Volumetric face flux (written)	always
`p`	`volScalarField`	Static pressure $p_{rgh} + \rho\,gh$ (written)	always
`alphaPhi0.<phase1>`	`surfaceScalarField`	MULES phase flux (written; read back on restart)	always
`rho`, `rhoPhi`	vol / surface scalar	Mixture density and mass flux (not written)	always
`gh`, `ghf`	vol / surface scalar	$\mathbf{g}\cdot\mathbf{h}$ at cell and face centres (not written)	always
`alphaPhiUn`	`surfaceScalarField`	Unlimited compressed flux, registered for the `scalarTransport` function object (not written)	always
`sigma`	`volSymmTensorField`	Cauchy stress tensor $-p\mathbf{I} + \mu\,\texttt{devTwoSymm}(\nabla\mathbf{U})$ (written)	always (FSI)
`Uf`	`surfaceVectorField`	Face velocity	moving mesh only
`uniform/cumulativeContErr`	`uniformDimensionedScalarField`	Cumulative continuity error	always

Case Setup

Required dictionaries

constant/transportProperties – phases, per-phase nu/rho, sigma
constant/turbulenceProperties – turbulence model selection
constant/g – gravitational acceleration
system/fvSolution – alpha solver controls, PIMPLE sub-dict, linear solvers
system/fvSchemes – discretisation schemes

Optional: constant/hRef, constant/MRFProperties, system/fvOptions, constant/dynamicMeshDict.

`transportProperties`

phases (water air);

water
{
 transportModel Newtonian;
 nu 1e-06;
 rho 1000;
}

air
{
 transportModel Newtonian;
 nu 1.48e-05;
 rho 1;
}

sigma 0.07;

`multiRegionProperties` entry

regions
(
 ( fluid (interFluid) )
);

For FSI, pair it with a solid region:

regions
(
 ( fluid (interFluid) )
 ( solid (solidStVK) )
);

`controlDict` (singleRegionMode)

When running as a standalone single-region case via singleRegionMode:

application multiPhysicsFoam;

singleRegionMode yes;
regionType interFluid;

Key `fvSolution` settings

The alpha controls are read from the solver entry that matches alpha.<phase1> on every time step. nAlphaCorr and nAlphaSubCycles are mandatory.

solvers
{
 "alpha.water.*"
 {
 nAlphaCorr 2; // MULES correction passes (mandatory)
 nAlphaSubCycles 1; // alpha sub-cycles per time step (mandatory)
 cAlpha 1; // interface compression (0 = off)

 MULESCorr yes; // semi-implicit MULES predictor-corrector
 nLimiterIter 5; // MULES limiter iterations
 alphaApplyPrevCorr no; // reuse previous correction flux
 icAlpha 0; // isotropic compression coefficient
 scAlpha 0; // shear compression coefficient

 solver smoothSolver; // used for the MULESCorr predictor
 smoother symGaussSeidel;
 tolerance 1e-8;
 relTol 0;
 }

 "pcorr.*" { solver PCG; preconditioner DIC; tolerance 1e-5; relTol 0; }
 p_rgh { solver PCG; preconditioner DIC; tolerance 1e-7; relTol 0.05; }
 p_rghFinal { $p_rgh; relTol 0; }
 U { solver smoothSolver; smoother symGaussSeidel; tolerance 1e-6; relTol 0; }
}

PIMPLE
{
 momentumPredictor no;
 nOuterCorrectors 1;
 nCorrectors 3;
 nNonOrthogonalCorrectors 0;

 // Moving mesh
 correctPhi yes; // defaults to yes if mesh is dynamic
 checkMeshCourantNo no;
 moveMeshOuterCorrectors no;

 // Pressure reference (closed domains)
 p_rghRefCell 0;
 pRefValue 0;
}

Key `fvSchemes` entries

divSchemes
{
 div(rhoPhi,U) Gauss linearUpwind grad(U);
 div(phi,alpha) Gauss vanLeer; // bounded TVD scheme for advection
 div(phirb,alpha) Gauss linear; // compression term
 div(((rho*nuEff)*dev2(T(grad(U))))) Gauss linear;
}

ddt(alpha) accepts Euler or CrankNicolson (with an off-centering coefficient). localEuler (LTS) is not supported.

Adjustable time stepping (`controlDict`)

adjustTimeStep yes;
maxCo 1; // maximum flow Courant number
maxAlphaCo 1; // maximum interface Courant number
maxDeltaT 1; // upper bound on time-step size

Coupling

interFluid participates in the following multi-region interfaces:

Interface type	Exchanged fields	Coupling modes
`fsiInterface`	Displacement `D`, traction `sigma·n`	partitioned (DNA)

FSI works the same way as for pimpleFluid, and nothing FSI-specific is needed in the fluid’s own boundary conditions:

Fluid → solid (traction). The solid’s regionCoupledTraction boundary condition looks up the fluid’s registered sigma field by name on the neighbour mesh and takes sigma·n on the interface patch. sigma only has to exist under that name, so it does not need to be listed in coupledFields. Because $p$ includes the hydrostatic part ($p_{rgh} + \rho\,gh$) and $\mu$ is the mixture viscosity, the traction is correct whether the wall is wetted by water or by air.
Solid → fluid (displacement). The fluid mesh follows the solid through a dynamicMeshDict (a dynamicMotionSolverFvMesh plus a motion solver), set up as in the pimpleFluid FSI tutorials (e.g. HronTurekFsi3). The DNA loop calls meshMotionCorrector() for the D field. The fluid interface patch uses standard boundary conditions, e.g. movingWallVelocity for U and fixedFluxPressure for p_rgh.

setCoupledEqns is still a no-op, and the region registers no self-coupled fields of its own. Other interface types (heatTransferInterface, capillaryInterface, massTransferInterface) are not supported, since the region has no temperature field and no interface-coupled boundary conditions.

Known Limitations

FSI is the only coupling. Only fsiInterface (partitioned, DNA) is supported. There is no monolithic coupling and no thermal or mass-transfer coupling (see Coupling).
Laminar FSI traction. sigma contains only the molecular viscous stress. With a RAS/LES model the fluid flow itself is turbulent, but the traction passed to the solid misses the Reynolds-stress part. That part is usually small compared with the pressure at a wall, but it is not zero.
No FSI tutorial yet. Coupling with solidStVK has been shown to run, but there is no complete, validated VOF-FSI tutorial in the repository yet.
Two incompressible phases only. Both densities are constant. There is no compressibility, no more than two phases, and no phase change (the Su/Sp alpha sources are zero). For phase change across a sharp interface, interTrackFluid with massTransferInterface is intended (currently disabled in src/multiRegionSystem/Make/files).
Isothermal. No energy equation is solved.
No local time stepping (LTS). The localEuler branch in the alpha equation is kept for fidelity with the stock code, but it is dead code.
Simplified correctPhi after mesh motion. The flux correction uses a constant rAUf = 1 instead of stock interFoam’s time-persisted 1/UEqn.A(). The PISO loop still enforces continuity on the new mesh; only the initial flux guess is affected.
Mesh motion not yet validated. The code path follows pimpleFluid, but no finished tutorial uses a dynamicMeshDict yet.
sigma is always computed and written. This adds a grad(U) evaluation per outer corrector and one more field per write time, even in standalone runs where nothing reads it.
No wave generation. waveModels is linked but not used by this region.
Diffuse interface. As with any algebraic VOF/CSF method, the interface is smeared over a few cells and parasitic currents can appear near the interface in surface-tension-dominated flows.

Tutorials

Tutorial path	Description
`tutorials/singleRegion/interFluid/damBreak`	2D laminar collapse of a water column over an obstacle, adapted from `interFoam/laminar/damBreak` (static mesh, single-region, adjustable time step)

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
Rusche, H., Computational Fluid Dynamics of Dispersed Two-Phase Flows at High Phase Fractions, PhD thesis, Imperial College London, 2002.
Brackbill, J. U., Kothe, D. B., Zemach, C., A continuum method for modeling surface tension, Journal of Computational Physics 100(2), 335–354, 1992. DOI: 10.1016/0021-9991(92)90240-Y
Deshpande, S. S., Anumolu, L., Trujillo, M. F., Evaluating the performance of the two-phase flow solver interFoam, Computational Science & Discovery 5, 014016, 2012. DOI: 10.1088/1749-4699/5/1/014016

Docs: massTransferInterface

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

Overview

massTransferInterface models phase change (evaporation/condensation) at a sharp interface between two fluid regions, e.g. a liquid and its vapour. It is not a species/concentration interface: there is no Henry or partition coefficient and no species field. The interface is assumed to sit at a fixed saturation temperature $T_{sat}$. The interfacial mass flux $\dot m$ follows from the energy balance: the net conductive heat that reaches the interface from both sides at $T = T_{sat}$, divided by the latent heat $h_{lv}$.

The interface type itself only computes $\dot m$ and the matching heat-flux jump. These quantities enter the solution through dedicated partitioned boundary conditions (regionCoupledPhaseChangeHeatFlux for T, regionCoupledMassTransfer* for U and p). The U/p conditions also need a capillaryInterface on the same patch pair (surface tension, curvature, interface velocity). The two interface types are therefore used together.

Status: No tutorial uses this interface type, and the interface-tracking fluid region it was written for (interTrackFluid) is disabled in src/multiRegionSystem/Make/files. Treat this page as a description of the code, not of a validated feature.

Interface Conditions

Below, $A$ and $B$ are the two regions of the coupledPatchPair and $\mathbf{n}_A$, $\mathbf{n}_B$ the outward patch normals. In the BC formulas “own” is the side the BC sits on and “nbr” is the other side. $\mathbf{n}_\varepsilon$ is the interface normal $\mathbf{n}$ on the meshA side of the capillaryInterface and $-\mathbf{n}$ on the other side.

Mass flux from the energy balance (`massTransferInterface::saturatedFlux`)

Both temperature fields are copied, the interface patch values are set to $T_{sat}$ (fixedValue), and the normal gradients are evaluated:

$$ q_{sat} = k_A \left.\frac{\partial T_A}{\partial n_A}\right|_{T_\Gamma = T_{sat}} + k_B \left.\frac{\partial T_B}{\partial n_B}\right|_{T_\Gamma = T_{sat}} $$ $$ \dot m = -\frac{q_{sat}}{h_{lv}} \quad \text{(set to } 0 \text{ at time index 1)} $$

$-q_{sat}$ is the net heat conducted into the interface from both sides. It is consumed as latent heat, so $\dot m > 0$ when the interface gains heat (evaporation).

Temperature flux condition (`regionCoupledPhaseChangeHeatFlux`)

$$ k_{own} \frac{\partial T_{own}}{\partial n_{own}} = -\,k_{nbr} \frac{\partial T_{nbr}}{\partial n_{nbr}} + q_{sat} $$

The other side of T must carry a jump-type BC. That BC provides the value continuity $T_{own} = T_{nbr}$; this interface type adds no temperature jump.

Velocity jump (`regionCoupledMassTransferVelocityValue`)

$$ \mathbf{u}_{own} = \mathbf{u}_{nbr} + \left(\frac{1}{\rho_{own}} - \frac{1}{\rho_{nbr}}\right)\dot m\, \mathbf{n}_\varepsilon $$

Pressure jump (`regionCoupledMassTransferPressureValue`)

$$ p_{own} = p_{nbr} + 2\,(\mu_{nbr} - \mu_{own})\,\nabla_s\!\cdot\mathbf{u}_s - \sigma \kappa + (\rho_{nbr} - \rho_{own})\,\mathbf{g}\cdot(\mathbf{x}_f - \mathbf{x}_{ref}) - \left(\frac{1}{\rho_{own}} - \frac{1}{\rho_{nbr}}\right)\dot m^2 $$

If the pressure field is called pKin (kinematic pressure), the same jump is built from $\rho_{nbr}\,p_{kin,nbr}$ and the result is divided by $\rho_{own}$.

Momentum flux jump (`regionCoupledMassTransferVelocityFlux`)

The diffusive flux $\mu_{own}\,\partial\mathbf{u}_{own}/\partial n$ is set to the negated normal component of the neighbour flux plus

$$ \mathbf{f}_{\sigma,t} - \mu_{own}\,\mathbf{n}\,\nabla_s\!\cdot\mathbf{u}_s + (\mu_{nbr} - \mu_{own})\,(\nabla_s \mathbf{u}_s)\cdot\mathbf{n} + \dot m \left[\left(\frac{\dot m}{\rho_{own}}\mathbf{n}_\varepsilon - \mathbf{u}_{own}\right) - \left(\frac{\dot m}{\rho_{nbr}}\mathbf{n}_\varepsilon - \mathbf{u}_{nbr}\right)\right] $$

where $\mathbf{f}_{\sigma,t}$ is the tangential part of the surface-tension force from the capillaryInterface finite-area mesh.

Symbol	Description	Unit
$T$	Temperature (field `T` in both regions)	K
$T_{sat}$	Saturation temperature (`TSat`)	K
$h_{lv}$	Latent heat of vaporisation (`hlv`)	J/kg
$k_A$, $k_B$	Thermal conductivity, entry `k` in each region’s `transportProperties`	W/(m K)
$q_{sat}$	Heat-flux imbalance at saturation (`<patchA>fluxMTJump`)	W/m²
$\dot m$	Interfacial mass flux (`<patchA>mDotS`)	kg/(m² s)
$\rho$, $\mu$	Density and dynamic viscosity from `transportProperties`	kg/m³, Pa s
$\sigma$, $\kappa$, $\mathbf{u}_s$	Surface tension, curvature, interface velocity from `capillaryInterface`	N/m, 1/m, m/s
$\mathbf{g}$, $\mathbf{x}_{ref}$	Gravity (`g`) and `PISO.pRefPoint`	m/s², m

Implementation

Construction. Reads massTransferInterfaceCoeffs from the interface entry. Creates on the interface finite-area mesh (aMesh(), built from region A if no <patchA>FaMesh is registered) the area fields hlvInterface (uniform $h_{lv}$) and mDotInterface (zero), both NO_WRITE.
correct() calls updateMDotS():
- saturatedFlux() looks up T in both regions and the scalar k from each region’s transportProperties dictionary. It then computes $q_{sat}$ as above on copies of T (the solved fields are not changed).
- The result is stored in the area field <patchA>fluxMTJump. The area field <patchA>mDotS is set to $-q_{sat}/h_{lv}$, or to zero when timeIndex() == 1. Both fields are created on demand and are NO_WRITE.
- mDotInterface is set to mDotS. A diagnostic line (time, integrated $\dot m$, region volumes) is printed to the log.
Boundary conditions read the results: regionCoupledPhaseChangeHeatFlux uses fluxMTJump() as the flux jump of T. The regionCoupledMassTransfer* conditions interpolate mDotS() to their patch.
getMinDeltaT() returns GREAT (no time-step restriction). info() is empty.

Coupled Fields

Field	Required boundary conditions (side A / side B)	Description
`T`	`regionCoupledPhaseChangeHeatFlux` with `interfaceType (massTransferInterface ...)` on one side / a `genericRegionCoupledJump`-derived BC on the other (inferred: `regionCoupledScalarJump`; `regionCoupledTemperatureJump` needs a `heatTransferInterface` listed first)	Temperature, flux jump $q_{sat}$
`U` (via `pUPimple`)	`regionCoupledMassTransferVelocityValue` / `regionCoupledMassTransferVelocityFlux`	Velocity with mass-flux jump, `interfaceType (capillaryInterface massTransferInterface)`
`p` (via `pUPimple`)	`regionCoupledMassTransferPressureValue` / `regionCoupledPressureFlux` (inferred: there is no mass-transfer pressure-flux BC)	Pressure with recoil term $\dot m^2$

The BC’s interfaceType list order matters. The first entry is the default interface of the BC. regionCoupledPhaseChangeHeatFlux aborts unless its first entry is massTransferInterface. regionCoupledMassTransferPressureValue and regionCoupledMassTransferVelocityFlux abort unless their first entry is capillaryInterface. Each BC finds the second interface type by name on the same patch.

Fields and dictionaries needed in both regions:

Name	Type	Used by
`T`	`volScalarField`	`saturatedFlux()`
`transportProperties`	registered `IOdictionary` with `k` (and `rho`, `mu` for the `U`/`p` BCs, `nu` if `pKin` is used)	interface, BCs
`U`, `p` (or `pKin`), `phi`	vol/surface fields	`regionCoupledMassTransfer*` BCs
`g`	`uniformDimensionedVectorField`	`regionCoupledMassTransferPressureValue`
`PISO.pRefPoint`	entry in `fvSolution`	`regionCoupledMassTransferPressureValue`

Compatible Region Types

No compiled region type combination has been shown to work. The table lists what the code requires (inferred, untested).

Region type (side A)	Region type (side B)	Notes
`interTrackFluid`	`interTrackFluid`	Intended pairing (moving-mesh interface tracking, as in the `capillaryInterface` tutorials). Disabled in `src/multiRegionSystem/Make/files`.
`icoFluid` + `transportTemperature`	`icoFluid` + `transportTemperature`	`icoFluid` provides `U`, `p`, `phi`, `transportProperties` (`rho`, `mu`) and documents these BCs (see `icoFluid`). `transportTemperature` provides `T`. Both read `kappa`, so `k` must be added to `transportProperties` as well. `g` must be provided separately.
any + `conductTemperature`	—	Only the `T` part can work (no `U`/`p`); `k` must be added next to `kappa`.

The interface needs k as a single uniform dimensionedScalar per region. A non-uniform kappa field (see transportTemperature, conductTemperature) is not used.

Case Setup

No tutorial exists. The snippets below are assembled from the keywords the code reads and from the structure of tutorials/multiphaseFlow/2dRisingBubble (which uses capillaryInterface only). They have not been run.

`regionInterfaceProperties` entry

partitionedCoupledPatches
(
 fluidAfluidB
 {
 interfaceType (capillaryInterface massTransferInterface);

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

 coupledFields
 (
 pUPimple
 T
 );

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

 massTransferInterfaceCoeffs
 {
 hlv hlv [ 0 2 -2 0 0 0 0 ] 2.257e6; // required, J/kg
 TSat TSat [ 0 0 0 1 0 0 0 ] 373.15; // required, K
 }
 }
);

monolithicCoupledPatches
();

curvatureCorrectedSurfacePatches 0();

interpolatorUpdateFrequency 0;

interfaceTransferMethod directMap;

directMapCoeffs
{}

Keyword	Where	Default	Description
`hlv`	`massTransferInterfaceCoeffs`	— (required)	Latent heat $h_{lv}$
`TSat`	`massTransferInterfaceCoeffs`	— (required)	Saturation temperature $T_{sat}$
`coupled`	interface entry	`true`	Base class switch
`couplingStartTime`	interface entry	`0`	Base class
`interfaceTransferMethod`	top level	`AMI`	Patch-to-patch mapping used by the BCs. See also the conformity note in Known Limitations.
`curvatureCorrectedSurfacePatches`	top level	— (required)	Base class, needed by every interface type

All interface types listed in interfaceType receive the same entry, so they share coupledPatchPair and coupledFields.

`multiRegionProperties` DNA entry

DNA
{
 pUPimple
 {
 maxCoupleIter 10;

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

 T
 {
 maxCoupleIter 10;
 residualControl { maxJumpRes 1e-5; maxFluxRes 1e-5; }
 }
}

Boundary conditions

Based on the capillaryInterface BCs in tutorials/multiphaseFlow/2dRisingBubble/0/fluidA/orig/partitioned/U and .../fluidB/orig/partitioned/p, with the mass-transfer variants substituted:

// 0/fluidA/U
interface
{
 type regionCoupledMassTransferVelocityFlux;
 diffusivity "mu";
 interfaceType (capillaryInterface massTransferInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform (0 0 0);
}

// 0/fluidB/U
interfaceShadow
{
 type regionCoupledMassTransferVelocityValue;
 diffusivity "mu";
 interfaceType (capillaryInterface massTransferInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform (0 0 0);
}

// 0/fluidA/p
interface
{
 type regionCoupledMassTransferPressureValue;
 diffusivity "v";
 interfaceType (capillaryInterface massTransferInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform 0;
}

// 0/fluidB/T
interfaceShadow
{
 type regionCoupledPhaseChangeHeatFlux;
 interfaceType (massTransferInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform 373.15;
}

regionCoupledPhaseChangeHeatFlux fixes its diffusivity name to k. It uses a volScalarField k if the region has one, otherwise k from transportProperties.

Known Limitations

correct() runs on every coupled BC update. regionInterfaceTypeList::update() does not call correct(), but every genericRegionCoupledJump/Flux-derived BC calls rgInterface().update() in its updateCoeffs(), which calls correct(). rgInterface() resolves only the first entry of the BC’s interfaceType list, so $\dot m$ is updated only by BCs that list massTransferInterface first (e.g. regionCoupledPhaseChangeHeatFlux on T). The U/p mass-transfer BCs list capillaryInterface first and never trigger it. When it does run, it runs once per such BC evaluation, i.e. several times per coupling iteration.
No runnable tutorial. No tutorial uses massTransferInterface. The interTrackFluid region type it was written for is commented out in src/multiRegionSystem/Make/files.
Constant properties. $h_{lv}$, $T_{sat}$ and k are single uniform scalars. $T_{sat}$ does not depend on pressure.
Conformal interface assumed. saturatedFlux() adds patch-A and patch-B face values index by index without mapping. Results are written into an area field on the finite-area mesh of region A. This only makes sense if both patches and the aMesh have the same faces in the same order (inferred). The BCs on side A also call interpolateFromNbrField on mDotS, which is already defined on A (inferred to be harmless only for identical conformal patches).
First time step forced to $\dot m = 0$. The check is timeIndex() == 1, so the first step after a restart is presumably not affected, because the time index continues from uniform/time (inferred).
regionCoupledMassTransferVelocityValue::updatePhi() is never called. The mass-flux correction of the boundary phi it implements is dead code.
No temperature constraint at the interface. $T_{sat}$ is used only to compute $q_{sat}$. T on the patches is not fixed to $T_{sat}$, and the saturation check (checkSaturation) is computed and then discarded.
Name clash risk with k (inferred). The heat-flux BC prefers a volScalarField k. In a turbulent region that is the turbulent kinetic energy, not the conductivity.
Diagnostics are always on. updateMDotS() and the velocity BC write an Info line on every call. The output fields are NO_WRITE, so $\dot m$ is not written to disk.
Partitioned only. Monolithic coupling is not available.

Tutorials

Tutorial	Description
—	No tutorial uses `massTransferInterface`. `tutorials/multiphaseFlow/2dRisingBubble` shows the companion `capillaryInterface` setup (also on the disabled `interTrackFluid`).

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

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

Overview

regionCoupledMassTransferPressureValue is the Dirichlet (jump) half of the partitioned pressure coupling across a sharp liquid-vapour interface with phase change. It acts on a volScalarField (p or pKin) and derives from genericRegionCoupledJump<scalar>, i.e. from fixedValue. It applies the same normal-stress jump as regionCoupledPressureValue and adds the recoil pressure $-(1/\rho_\text{own}-1/\rho_\text{nbr})\,\dot m^2$. There is no mass-transfer pressure-flux BC; the partner is presumably regionCoupledPressureFlux (inferred). The BC needs a capillaryInterface as the first interfaceType entry and a massTransferInterface on the same patch pair.

Mathematical Formulation

The BC sits on side A (“own”), which carries the faMesh of the capillaryInterface; “nbr” is side B. $\tilde{\dot m} = \mathcal{I}_{\text{nbr}\to\text{own}}(\dot m)$.

For a field named p:

$$ p_\text{own}^{*} = \mathcal{I}(p_\text{nbr}) + 2(\mu_\text{nbr}-\mu_\text{own})\,\nabla_s\cdot\mathbf{u}_s - \sigma\kappa + (\rho_\text{nbr}-\rho_\text{own})\,(\mathbf{x}_f-\mathbf{x}_\text{ref})\cdot\mathbf{g} - \left(\frac{1}{\rho_\text{own}}-\frac{1}{\rho_\text{nbr}}\right)\tilde{\dot m}^2 \quad \text{on } \Gamma $$

For a field named pKin:

$$ p_{\text{kin,own}}^{*} = \frac{1}{\rho_\text{own}}\Big[\rho_\text{nbr}\,\mathcal{I}(p_\text{kin,nbr}) + 2(\mu_\text{nbr}-\mu_\text{own})\,\nabla_s\cdot\mathbf{u}_s - \sigma\kappa + (\rho_\text{nbr}-\rho_\text{own})\,(\mathbf{x}_f-\mathbf{x}_\text{ref})\cdot\mathbf{g} - \left(\frac{1}{\rho_\text{own}}-\frac{1}{\rho_\text{nbr}}\right)\tilde{\dot m}^2\Big] $$

followed by relaxation, $p^{k} = p^{k-1} + \omega\,(p^{*} - p^{k-1})$.

Symbol	Description	Unit
$p$, $p_\text{kin}$	Pressure / kinematic pressure	Pa / m²/s²
$\dot m$	Interfacial mass flux, `mDotS()` of the `massTransferInterface`	kg/(m² s)
$\mathbf{u}_s$	Surface velocity on the `faMesh` (`Us()`)	m/s
$\sigma$, $\kappa$	Surface tension and face curvature from the `capillaryInterface`	N/m, 1/m
$\mu$, $\rho$	`mu`, `rho` from each region’s `transportProperties`	Pa·s, kg/m³
$\mathbf{g}$	`uniformDimensionedVectorField g` of the local region	m/s²
$\mathbf{x}_\text{ref}$	`PISO.pRefPoint` from the local `fvSolution`	m

Implementation

updateCoeffs() is the generic one of genericRegionCoupledJump: return if updated or coupled no; call update() on the first interfaceType (the capillaryInterface); interpolate the neighbour field (looked up by the local field name); add valueJump(); relax; call fixedValue::updateCoeffs().

valueJump() is that of regionCoupledPressureValue with the extra recoil term. It aborts unless the first interfaceType is capillaryInterface, finds the massTransferInterface by type name and interpolates mDotS() from the neighbour side. PISO.pRefPoint, g, and mu/rho of both regions are required. The mesh flux and patch normals are computed but not used.

Since only the first interface is update()d, $\dot m$ is not recomputed by this BC. It changes only when a BC that lists massTransferInterface first (e.g. regionCoupledPhaseChangeHeatFlux on T) is updated. Until then the recoil term is zero and the BC behaves like regionCoupledPressureValue.

The p jump residual of the pUPimple DNA loop is taken from this BC (side A is checked first). flux() uses the hardcoded diffusivity v, for which diffCoeff() returns $\rho$ instead of $1/\rho$ (1 for pKin); the partner regionCoupledPressureFlux cancels this flux.

Dictionary Entries

Keyword	Description	Required	Default
`type`	`regionCoupledMassTransferPressureValue`	yes	—
`interfaceType`	List of interface type names. First entry must be `capillaryInterface`; `massTransferInterface` must also be listed	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 `v`	no	empty
`neighbourFieldName`	Read by the coupling manager, not used by this BC	no	local field name
`jumpCoefficient`	Read by the base class, not used, not written back	no	empty
`accType`	Acceleration model: `fixed`, `aitken`, `IQNILS`. A warning is printed if missing	no	`fixed`
`relax`	(Initial) relaxation factor	no	`1.0`
`couplingReuse`	`IQNILS` only	no	`0`
`nonOrthCorr`	Non-orthogonal correction in `snGrad()` / matrix coefficients	no	`false`
`secondOrder`	Second-order face-normal gradient	no	`false`

Entries read from other files: PISO { pRefPoint (...); } in the local fvSolution, g in the local constant/, and mu, rho in transportProperties of both regions.

Usage

No tutorial uses this BC. Untested entry on side A, following massTransferInterface:

// 0/fluidA/p
interface
{
 type regionCoupledMassTransferPressureValue;
 interfaceType (capillaryInterface massTransferInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform 0;
}

Partner on side B (inferred):

// 0/fluidB/p
interfaceShadow
{
 type regionCoupledPressureFlux;
 interfaceType (capillaryInterface massTransferInterface);
 value uniform 0;
}

The regionInterfaceProperties entry is shown on the regionCoupledMassTransferVelocityValue page and in massTransferInterface.

Known Limitations

Untested, no tutorial; the intended region type interTrackFluid is disabled.
$\dot m$ is only updated through another BC. See Implementation.
mDotS() is interpolated from the neighbour although it is defined on side A (inferred), where this BC sits. Harmless only for identical conformal patches.
Must sit on side A (inferred): $\sigma$, $\kappa$ and $\nabla_s\cdot\mathbf{u}_s$ are used without interpolation.
No dedicated flux partner. regionCoupledPressureFlux does not account for phase change.
Constant properties, PISO.pRefPoint required, diffusivity and neighbourFieldName ignored (as for regionCoupledPressureValue).

Tutorials

Tutorial	Description
—	No tutorial uses `regionCoupledMassTransferPressureValue`.

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

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

Overview

regionCoupledMassTransferVelocityFlux is the Neumann (flux) half of the partitioned velocity coupling across a sharp liquid-vapour interface with phase change. It acts on a volVectorField (U) and derives from genericRegionCoupledFlux<vector>, i.e. from fixedGradient. It uses the same stress balance as regionCoupledVelocityFlux and adds the momentum flux $\dot m\,[\![\mathbf{u}_\text{rel}]\!]$ that the mass flux carries across the interface. The partner condition on the other side is regionCoupledMassTransferVelocityValue. The BC needs a capillaryInterface as the first interfaceType entry and a massTransferInterface on the same patch pair.

Mathematical Formulation

“own” is the side the BC sits on (side A, which carries the faMesh) and “nbr” the other side. $\mathbf{n}$ is the faMesh face normal, $\mathbf{n}_\varepsilon = \mathbf{n}$ if the local region is meshA of the capillaryInterface (otherwise $-\mathbf{n}$). $\tilde{\mathbf{F}}$ is the interpolated diffusive flux of the partner BC ($\mu_\text{nbr}$ times the tangential face-normal gradient) and $\tilde{\dot m} = \mathcal{I}_{\text{nbr}\to\text{own}}(\dot m)$.

$$ \mu_\text{own}\frac{\partial \mathbf{U}_\text{own}}{\partial n} = -(\mathbf{I}-\mathbf{n}\mathbf{n})\cdot\tilde{\mathbf{F}} + \mathbf{f}_{\sigma,t} - \mu_\text{own}\,\mathbf{n}\,(\nabla_s\cdot\mathbf{u}_s) + (\mu_\text{nbr}-\mu_\text{own})\,(\nabla_s\mathbf{u}_s)\cdot\mathbf{n} + \tilde{\dot m}\left[\left(\frac{\tilde{\dot m}}{\rho_\text{own}}\mathbf{n}_\varepsilon - \mathbf{U}_\text{own}\right) - \left(\frac{\tilde{\dot m}}{\rho_\text{nbr}}\mathbf{n}_\varepsilon - \mathbf{U}_\text{nbr}\right)\right] $$

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{U}_\text{own}$ are the current patch values (previous iteration) and $\mathbf{U}_\text{nbr}$ the neighbour patch values without interpolation (see Known Limitations). The gradient is relaxed, $g^{k} = g^{k-1} + \omega\,(g^{*} - g^{k-1})$, and the patch value is reconstructed from it in evaluate() as described for regionCoupledVelocityFlux.

Symbol	Description	Unit
$\mathbf{U}$	Velocity	m/s
$\dot m$	Interfacial mass flux, `mDotS()` of the `massTransferInterface`	kg/(m² s)
$\mathbf{u}_s$	Surface velocity on the `faMesh` (`Us()`)	m/s
$\sigma$, $\kappa$	Surface tension and face curvature from the `capillaryInterface`	N/m, 1/m
$\mathbf{L}_e$, $c_e$	`faMesh` edge length vectors and `edgeLengthCorrection()`	m, –
$\mu$, $\rho$	`mu`, `rho` from each region’s `transportProperties`	Pa·s, kg/m³

Implementation

updateCoeffs() is the generic one of genericRegionCoupledFlux: return if updated or coupled no; call update() on the first interfaceType (the capillaryInterface); interpolate and negate the neighbour flux() (the neighbour patch field is refCast to genericRegionCoupledJump<vector>); add fluxJump(); divide by diffCoeff() (hardcoded name mu: registered volScalarField mu, else transportProperties); relax; call fixedGradient::updateCoeffs().

fluxJump():

aborts unless the first interfaceType is capillaryInterface; finds the massTransferInterface by type name;
computes $\nabla_s\cdot\mathbf{u}_s$, $\nabla_s\mathbf{u}_s$ and the edge-integrated surface-tension force on the faMesh;
reads mu and rho of both regions from transportProperties; if a region has a pKin field, its mu must equal rho*nu exactly, otherwise the run stops;
interpolates mDotS() from the neighbour side.

Because only the first interface is update()d, $\dot m$ is not recomputed by this BC. It changes only when a BC that lists massTransferInterface first (e.g. regionCoupledPhaseChangeHeatFlux on T) is updated.

The U flux residual of the pUPimple DNA loop is taken from this BC if it sits on side A: $\lVert\mu_\text{own}\partial_n\mathbf{U}_\text{own} + \tilde{\mathbf{F}} - \text{fluxJump}\rVert_2$, normalised as in genericRegionCoupledFlux.

Dictionary Entries

Keyword	Description	Required	Default
`type`	`regionCoupledMassTransferVelocityFlux`	yes	—
`interfaceType`	List of interface type names. First entry must be `capillaryInterface`; `massTransferInterface` must also be listed	yes	—
`gradient`	Initial patch-normal gradient. Read if present; otherwise zero gradient and the patch value is set from the internal field	no	zero
`value`	Not read (`fixedGradient` ignores it). Written by `write()`	no	—
`diffusivity`	Read, but ignored: the BC always uses `mu`	no	empty
`neighbourFieldName`	Read by the coupling manager, not used by this BC	no	local field name
`accType`	Acceleration model for the gradient: `fixed`, `aitken`, `IQNILS`. A warning is printed if missing	no	`fixed`
`relax`	(Initial) relaxation factor	no	`1.0`
`couplingReuse`	`IQNILS` only	no	`0`
`nonOrthCorr`	Non-orthogonal correction in `evaluate()`	no	`false`
`secondOrder`	Second-order reconstruction of the patch value	no	`false`

write() does not write gradient.

Usage

No tutorial uses this BC. Untested entry on side A, following massTransferInterface:

// 0/fluidA/U
interface
{
 type regionCoupledMassTransferVelocityFlux;
 interfaceType (capillaryInterface massTransferInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform (0 0 0);
}

Partner on side B:

// 0/fluidB/U
interfaceShadow
{
 type regionCoupledMassTransferVelocityValue;
 interfaceType (capillaryInterface massTransferInterface);
 value uniform (0 0 0);
}

The regionInterfaceProperties entry is shown on the regionCoupledMassTransferVelocityValue page and in massTransferInterface.

Known Limitations

Neighbour velocity is not interpolated (bug). $\mathbf{U}_\text{nbr}$ in the mass-flux term is the raw neighbour patch field, combined index by index with local fields. This is only correct for conformal patches with identical face order; otherwise the sizes may not even match.
mDotS() is interpolated from the neighbour although it is defined on side A (inferred), where this BC sits. Harmless only for identical conformal patches.
Must sit on side A (inferred): faMesh normals, $\mathbf{u}_s$, $\sigma$, $\kappa$ are used without interpolation.
$\dot m$ is only updated through another BC. See Implementation.
Exact mu == rho*nu check for regions with pKin.
Relaxation history starts from the patch value (inferred). The base class initialises the acceleration model with the patch values but relaxes the gradient; harmless with relax 1.
Untested, no tutorial; interTrackFluid is disabled.

Tutorials

Tutorial	Description
—	No tutorial uses `regionCoupledMassTransferVelocityFlux`.

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

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

Overview

regionCoupledMassTransferVelocityValue is the Dirichlet (jump) half of the partitioned velocity coupling across a sharp liquid-vapour interface with phase change. It acts on a volVectorField (U) and derives from genericRegionCoupledJump<vector>, i.e. from fixedValue. The patch value is the interpolated neighbour velocity plus the jump in normal velocity that a mass flux $\dot m$ produces between two phases of different density. The partner condition on the other side is regionCoupledMassTransferVelocityFlux. The BC needs both a capillaryInterface and a massTransferInterface on the same patch pair, and the pressure is coupled by regionCoupledMassTransferPressureValue and (inferred) regionCoupledPressureFlux. It is the phase-change counterpart of regionCoupledVelocityValue.

Mathematical Formulation

“own” is the side the BC sits on and “nbr” the other side. $\mathcal{I}_{\text{nbr}\to\text{own}}$ is the patch-to-patch interpolation. $\mathbf{n}_\varepsilon$ is the local patch normal if the local region is meshA of the capillaryInterface, and its negative otherwise. In both cases it points out of region A.

$$ \mathbf{U}_\text{own}^{*} = \mathcal{I}_{\text{nbr}\to\text{own}}(\mathbf{U}_\text{nbr}) + \left(\frac{1}{\rho_\text{own}} - \frac{1}{\rho_\text{nbr}}\right)\tilde{\dot m}\,\mathbf{n}_\varepsilon, \qquad \tilde{\dot m} = \mathcal{I}_{\text{nbr}\to\text{own}}(\dot m) \quad \text{on } \Gamma $$

followed by relaxation, $\mathbf{U}^{k} = \mathbf{U}^{k-1} + \omega\,(\mathbf{U}^{*} - \mathbf{U}^{k-1})$.

Unlike regionCoupledVelocityValue, no surface-velocity or mesh-velocity correction of the normal component is applied. That version is still in the source but commented out.

The diffusive momentum flux handed to regionCoupledMassTransferVelocityFlux is the same as for regionCoupledVelocityValue: $\mu_\text{own}$ times the tangential part of the face-normal gradient (normal component removed in the vector snGrad() of genericRegionCoupledJump).

Symbol	Description	Unit
$\mathbf{U}$	Velocity	m/s
$\dot m$	Interfacial mass flux, `mDotS()` of the `massTransferInterface` (area field on the side-A `faMesh`)	kg/(m² s)
$\rho_\text{own}$, $\rho_\text{nbr}$	`rho` from each region’s `transportProperties`	kg/m³
$\mathbf{n}_\varepsilon$	Interface normal pointing out of region A	–
$\mu_\text{own}$	Diffusivity `mu` (field or `transportProperties`)	Pa·s

Implementation

updateCoeffs() is the generic one of genericRegionCoupledJump: return if updated or coupled no; call update() on the first interfaceType; interpolate the neighbour U (looked up by the local field name); add valueJump(); relax; call fixedValue::updateCoeffs().

valueJump():

finds the capillaryInterface and the massTransferInterface by type name on this patch (rgInterface(<type>)), independent of their order in interfaceType;
interpolates mDotS() from the neighbour side;
reads rho of both regions from transportProperties;
refCasts the neighbour U patch field to genericRegionCoupledFlux<vector> and uses its values only for a diagnostic line;
prints U Dirichlet boundary contributions: ... (integrated volume fluxes of the neighbour velocity, of the jump term and of mesh motion plus $\dot m/\rho$) on every call.

Only the interface listed first in interfaceType is update()d by this BC. With (capillaryInterface massTransferInterface) the massTransferInterface is not corrected here. $\dot m$ is only recomputed when a BC that lists massTransferInterface first (e.g. regionCoupledPhaseChangeHeatFlux on T) is updated. Otherwise it stays at its initial value of zero.

The class has two more functions that are not used in the solution:

updatePhi() would set the boundary phi to the negated interpolated neighbour flux plus $\pm(1/\rho_\text{own}-1/\rho_\text{nbr})\dot m\,|\mathbf{S}_f|$. The call in the base class is commented out.
The member correctClosedVolumePhi(phi, U, p, rAU) would correct the interface flux to the net volume flux $-\dot m/\rho\,|\mathbf{S}_f|$. It is never called. The global correctClosedVolumePhi() used by icoFluid and interTrackFluid (closedVolume on) recognises this BC, but forces the net volume flux through the patch to zero.

The U jump residual is evaluated on this BC if the side-A U patch is not jump-derived (as in the intended setup): $\lVert\mathbf{U}_\text{own} - \mathcal{I}(\mathbf{U}_\text{nbr}) - \text{valueJump}\rVert_2$, normalised as in genericRegionCoupledJump.

Dictionary Entries

Keyword	Description	Required	Default
`type`	`regionCoupledMassTransferVelocityValue`	yes	—
`interfaceType`	List of interface type names. Must contain `capillaryInterface` and `massTransferInterface`; the first entry is the one this BC `update()`s	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	no	local field name
`jumpCoefficient`	Read by the base class, not used, not written back	no	empty
`accType`	Acceleration model: `fixed`, `aitken`, `IQNILS`. A warning is printed if missing	no	`fixed`
`relax`	(Initial) relaxation factor	no	`1.0`
`couplingReuse`	`IQNILS` only	no	`0`
`nonOrthCorr`	Non-orthogonal correction in `snGrad()` / matrix coefficients	no	`false`
`secondOrder`	Second-order face-normal gradient	no	`false`

rho (and mu) must be present in transportProperties of both regions.

Usage

No tutorial uses this BC. The entry below follows massTransferInterface and has not been run. Side B (second in coupledPatchPair):

// 0/fluidB/U
interfaceShadow
{
 type regionCoupledMassTransferVelocityValue;
 interfaceType (capillaryInterface massTransferInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform (0 0 0);
}

Partner on side A:

// 0/fluidA/U
interface
{
 type regionCoupledMassTransferVelocityFlux;
 interfaceType (capillaryInterface massTransferInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform (0 0 0);
}

regionInterfaceProperties (excerpt):

fluidAfluidB
{
 interfaceType (capillaryInterface massTransferInterface);

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

 coupledFields
 (
 pUPimple
 T
 );

 capillaryInterfaceCoeffs { sigma sigma [1 0 -2 0 0 0 0] 0.07232; }
 massTransferInterfaceCoeffs { hlv hlv [0 2 -2 0 0 0 0] 2.257e6; TSat TSat [0 0 0 1 0 0 0] 373.15; }
}

The full case setup, including the T coupling that drives $\dot m$, is in massTransferInterface.

Known Limitations

Untested, no tutorial. The interface-tracking region type it was written for (interTrackFluid) is disabled in src/multiRegionSystem/Make/files.
$\dot m$ is only updated through another BC. See Implementation.
Must sit on side B (inferred). mDotS() lives on the side-A faMesh and is interpolated “from the neighbour”.
Neighbour must be flux-derived. The neighbour U patch field is refCast to genericRegionCoupledFlux<vector> (for a log line only); any other type aborts.
Closed-volume correction ignores phase change. With closedVolume on, the global correctClosedVolumePhi() forces zero net volume flux through this patch, which contradicts a non-zero $\dot m$ (inferred).
No normal mesh-velocity term. The normal velocity is not tied to the mesh motion as in regionCoupledVelocityValue (inferred from the commented-out code; intent unclear).
Log output on every call; diffusivity and neighbourFieldName are ignored.

Tutorials

Tutorial	Description
—	No tutorial uses `regionCoupledMassTransferVelocityValue`.

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

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

Overview

regionCoupledPressureFlux is the Neumann (flux) half of the partitioned pressure coupling across a sharp, mesh-tracked fluid-fluid interface. It acts on a volScalarField (p or pKin) and derives from genericRegionCoupledFlux<scalar>, i.e. from fixedGradient. Although it is built on the generic flux-matching scheme, its fluxJump() cancels the neighbour flux. The normal pressure gradient therefore depends only on the local normal acceleration $\mathbf{n}\cdot\partial\mathbf{U}/\partial t$. The partner condition on the other side is regionCoupledPressureValue (or regionCoupledMassTransferPressureValue, inferred: there is no mass-transfer pressure-flux BC). It is used with capillaryInterface.

Mathematical Formulation

The BC sits on side $B$ in all tutorials. $\mathbf{n}_B$ is the outward patch normal and $\tilde F = \mathcal{I}_{A\to B}(F_A)$ the interpolated neighbour flux snGrad(p_A)*k_A. The generic flux BC sets $k_B\,\partial p_B/\partial n = -\tilde F + \text{fluxJump}$ with

$$ \text{fluxJump} = \tilde F - \mathbf{n}_B\cdot\left(\frac{\partial\mathbf{U}_B}{\partial t}\right)_b $$

so that

$$ k_B\,\frac{\partial p_B}{\partial n} = -\,\mathbf{n}_B\cdot\left(\frac{\partial\mathbf{U}_B}{\partial t}\right)_b \quad \text{on } \Gamma_B $$

This is the normal momentum balance at the interface without the convective and viscous terms (the code that included them is commented out). The gradient is relaxed by the acceleration model, $g^{k} = g^{k-1} + \omega\,(g^{*} - g^{k-1})$, and the patch value is reconstructed as $p_B = p_P + \mathbf{k}\cdot\nabla p_P + g/\Delta_f$ (first order) or $p_P + \mathbf{k}\cdot\nabla p_P + (g + \mathbf{n}\cdot\nabla p_P)/(2\Delta_f)$ (secondOrder yes); the $\mathbf{k}$ term only with nonOrthCorr yes.

The diffusivity $k_B$ comes from diffCoeff() with the hardcoded name v:

Field name	Intended $k_B$	Actual $k_B$
`pKin`	$1$	$1$
any other (e.g. `p`)	$1/\rho_B$	$\rho_B$ (registered `volScalarField rho`, else `rho` from `transportProperties`)

For p the imposed gradient is therefore $-\mathbf{n}_B\cdot\partial_t\mathbf{U}_B/\rho_B$ instead of $-\rho_B\,\mathbf{n}_B\cdot\partial_t\mathbf{U}_B$ (see Known Limitations).

Symbol	Description	Unit
$p$	Pressure (`p`) or kinematic pressure (`pKin`)	Pa or m²/s²
$(\partial\mathbf{U}/\partial t)_b$	Patch value of `fvc::ddt(U)` in the local region	m/s²
$k_B$	Diffusivity from `diffCoeff()`	see table
$\Delta_f$	Patch `deltaCoeffs`	1/m

Implementation

updateCoeffs() is the generic one of genericRegionCoupledFlux:

Return if updated or coupled no (gradient frozen).
Call update() on the first interfaceType.
Look up the neighbour field by the local field name and refCast its patch field to genericRegionCoupledJump<scalar>; interpolate its flux() and negate it.
Add fluxJump(), divide by diffCoeff(), relax, call fixedGradient::updateCoeffs().

fluxJump() repeats step 3 to get $\tilde F$ and returns $\tilde F - \mathbf{n}_B\cdot(\partial_t\mathbf{U})_b$. It also reads rho and mu from the local transportProperties (required to exist), but does not use them. Unlike the other capillary BCs it never calls capInterface(), so it does not check the interface type.

The p flux residual of the pUPimple DNA loop comes from this BC, because the side-A pressure patch carries a jump BC. The neighbour flux cancels in it as well:

$$ r_\text{raw} = \left| k_B\,\partial_n p_B + \mathbf{n}_B\cdot(\partial_t\mathbf{U}_B)_b \right| $$

normalised as described in genericRegionCoupledFlux.

Dictionary Entries

Keyword	Description	Required	Default
`type`	`regionCoupledPressureFlux`	yes	—
`interfaceType`	List of interface type names; the first entry is updated by this BC. Tutorials use `(capillaryInterface)`	yes	—
`gradient`	Initial patch-normal gradient. Read if present; otherwise zero gradient and the patch value is set from the internal field	no	zero
`value`	Not read (`fixedGradient` ignores it). Written by `write()`	no	—
`diffusivity`	Read, but ignored: the BC always uses `v`	no	empty
`neighbourFieldName`	Read by the coupling manager, not used by this BC	no	local field name
`accType`	Acceleration model for the gradient: `fixed`, `aitken`, `IQNILS`. A warning is printed if missing	no	`fixed`
`relax`	(Initial) relaxation factor	no	`1.0`
`couplingReuse`	`IQNILS` only	no	`0`
`nonOrthCorr`	Non-orthogonal correction in `evaluate()`	no	`false`
`secondOrder`	Second-order reconstruction of the patch value	no	`false`

write() does not write gradient.

Usage

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

interfaceShadow
{
 type regionCoupledPressureFlux;
 diffusivity "v"; // ignored, always v
 interfaceType (capillaryInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform 0; // not read
}

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

interface
{
 type regionCoupledPressureValue;
 interfaceType (capillaryInterface);
 value uniform 0;
}

The interface and DNA entries are shown on the regionCoupledVelocityValue page and in capillaryInterface.

Known Limitations

Wrong diffusivity for p (bug). diffCoeff() renames v to rho before it checks for v, so the reciprocal is never taken and $k_B = \rho_B$. For a field named p the imposed gradient is off by a factor $\rho_B^2$ and has the wrong units. pKin is not affected. The tutorials use p.
Simplified normal momentum balance. Convective and viscous contributions to the normal pressure gradient are not included.
Neighbour flux has no effect. The interpolated neighbour flux cancels. It is still computed, and the neighbour patch field must derive from genericRegionCoupledJump<scalar>, otherwise the refCast aborts.
No interface-type check. Any interface type listed first is accepted; it is only update()d.
diffusivity and neighbourFieldName are ignored; gradient is not written to the time directories.
No runnable tutorial. The tutorials use the disabled interTrackFluid.

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/p 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: regionCoupledPressureValue

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

Overview

regionCoupledPressureValue is the Dirichlet (jump) half of the partitioned pressure coupling across a sharp, mesh-tracked fluid-fluid interface. It acts on a volScalarField (p, or the kinematic pressure pKin) and derives from genericRegionCoupledJump<scalar>, i.e. from fixedValue. The patch value is the interpolated neighbour pressure plus the normal-stress jump: capillary pressure $\sigma\kappa$, the viscous normal-stress jump and a hydrostatic correction. The partner condition on the other side is regionCoupledPressureFlux. Both belong to capillaryInterface, and this BC aborts if the first entry of its interfaceType list is not capillaryInterface. The variant with phase change is regionCoupledMassTransferPressureValue.

Mathematical Formulation

Region $A$ is the first entry of coupledPatchPair and carries the faMesh of the capillaryInterface. This BC sits on side $A$ (see Known Limitations). $\mathcal{I}_{B\to A}$ is the patch-to-patch interpolation.

For a field named p:

$$ p_A^{*} = \mathcal{I}_{B\to 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_A $$

For a field named pKin the same jump is applied in kinematic form:

$$ p_{\text{kin},A}^{*} = \frac{1}{\rho_A}\Big[\rho_B\,\mathcal{I}_{B\to A}(p_{\text{kin},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}\Big] $$

The viscous term is the jump of $2\mu\,\partial u_n/\partial n$ with $\partial u_n/\partial n = -\nabla_s\cdot\mathbf{u}_s$. The gravity term implies that p excludes the hydrostatic part $\rho\,\mathbf{g}\cdot(\mathbf{x}-\mathbf{x}_\text{ref})$ (inferred from the formula). The value is then relaxed: $p_A^{k} = p_A^{k-1} + \omega\,(p_A^{*} - p_A^{k-1})$.

Symbol	Description	Unit
$p$, $p_\text{kin}$	Pressure / kinematic pressure	Pa / m²/s²
$\mathbf{u}_s$	Surface velocity on the `faMesh` (`Us()`)	m/s
$\sigma$	Surface tension (`sigma()` of the `capillaryInterface`)	N/m
$\kappa$	Face curvature, `faMesh::faceCurvatures()`	1/m
$\mu_A$, $\mu_B$	`mu` from each region’s `transportProperties`	Pa·s
$\rho_A$, $\rho_B$	`rho` from each region’s `transportProperties`	kg/m³
$\mathbf{g}$	`uniformDimensionedVectorField g` of region A	m/s²
$\mathbf{x}_f$	Patch face centres	m
$\mathbf{x}_\text{ref}$	`PISO.pRefPoint` from region A’s `fvSolution`	m

Implementation

updateCoeffs() is the generic one of genericRegionCoupledJump: return if updated or coupled no; call update() on the first interfaceType (curvature and $\mathbf{u}_s$); interpolate the neighbour field (looked up by the local field name) onto this patch; add valueJump(); relax; call fixedValue::updateCoeffs().

valueJump():

takes $\sigma$, $\kappa$ and $\mathbf{u}_s$ from the capillaryInterface and computes $\nabla_s\cdot\mathbf{u}_s$ with fac::div;
reads pRefPoint from the PISO sub-dictionary of region A’s fvSolution and looks up g in region A (both required);
reads mu and rho of both regions from their registered transportProperties dictionaries;
for pKin returns the bracket above divided by $\rho_A$, minus the interpolated neighbour value, so that the base class sum gives the kinematic formula.

It also computes the mesh flux and the patch normals, but does not use them.

The jump residual for p in the pUPimple DNA loop is taken from this BC, because side A is checked first: $\lVert p_A - \mathcal{I}_{B\to A}(p_B) - \text{valueJump}\rVert_2$, normalised as described in genericRegionCoupledJump.

flux() (inherited) returns snGrad()*k with $k$ from diffCoeff() and the hardcoded diffusivity name v. diffCoeff() maps v to rho, but the step that should take the reciprocal is never reached, so $k = \rho_A$ instead of $1/\rho_A$ ($k = 1$ for pKin). The partner regionCoupledPressureFlux cancels this flux, so the error does not reach the solution.

Dictionary Entries

Keyword	Description	Required	Default
`type`	`regionCoupledPressureValue`	yes	—
`interfaceType`	List of interface type names. The first entry must be `capillaryInterface`	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 `v`	no	empty
`neighbourFieldName`	Read by the coupling manager, not used by this BC	no	local field name
`jumpCoefficient`	Read by the base class, not used, not written back	no	empty
`accType`	Acceleration model: `fixed`, `aitken`, `IQNILS`. A warning is printed if missing	no	`fixed`
`relax`	(Initial) relaxation factor	no	`1.0`
`couplingReuse`	`IQNILS` only	no	`0`
`nonOrthCorr`	Non-orthogonal correction in `snGrad()` / matrix coefficients	no	`false`
`secondOrder`	Second-order face-normal gradient	no	`false`

Entries read from other files:

Entry	File	Required
`PISO { pRefPoint (x y z); }`	`system/<regionA>/fvSolution`	yes
`g`	`constant/<regionA>/g` (registered `uniformDimensionedVectorField`)	yes
`mu`, `rho`	`constant/<region>/transportProperties`, both regions	yes

Usage

tutorials/multiphaseFlow/2dRisingBubble/0/fluidA/orig/partitioned/p (side A):

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

Partner on side B, 0/fluidB/orig/partitioned/p:

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

system/fluidA/fvSolution must contain PISO { ... pRefPoint (0 0 0); }. The interface and DNA entries are shown on the regionCoupledVelocityValue page and in capillaryInterface.

Known Limitations

capillaryInterface only. capInterface() aborts unless the first interfaceType entry is capillaryInterface.
Must sit on side A (inferred). $\sigma$, $\kappa$ and $\nabla_s\cdot\mathbf{u}_s$ are taken from the side-A faMesh index by index, without interpolation.
Constant properties. $\mu$ and $\rho$ are single scalars from transportProperties; registered mu or rho fields are not used.
PISO.pRefPoint is required, even if the region solver uses a PIMPLE dictionary.
diffCoeff() returns $\rho$ instead of $1/\rho$ for the diffusivity v. Without consequence for this BC (see Implementation).
diffusivity and neighbourFieldName are ignored.
The header example omits interfaceType, which is required.
No runnable tutorial. The tutorials use the disabled interTrackFluid.

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/fluidA/orig/partitioned/p 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: regionCoupledVelocityFlux

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

Overview

regionCoupledVelocityFlux is the Neumann (flux) 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 genericRegionCoupledFlux<vector>, i.e. from fixedGradient. It sets the normal velocity gradient so that the tangential viscous stress balances the neighbour stress plus the tangential surface-tension force. The normal component of the gradient follows from surface continuity. The partner condition on the other side is regionCoupledVelocityValue. Both belong to capillaryInterface, and this BC aborts if the first entry of its interfaceType list is not capillaryInterface.

Mathematical Formulation

Region $A$ is the first entry of coupledPatchPair and carries the finite-area mesh (faMesh) of the capillaryInterface. This BC sits on side $A$ (see Known Limitations). $\mathbf{n}$ is the faMesh face normal (faceAreaNormals()), $\mathcal{I}_{B\to A}$ the patch-to-patch interpolation, and $\mathbf{F}_B$ the flux computed by regionCoupledVelocityValue on side B ($\mu_B$ times the tangential part of $\partial\mathbf{U}_B/\partial n_B$). With $\tilde{\mathbf{F}} = \mathcal{I}_{B\to A}(\mathbf{F}_B)$, the gradient is

$$ \mu_A \frac{\partial \mathbf{U}_A}{\partial n} = -\tilde{\mathbf{F}} + \mathbf{n}(\mathbf{n}\cdot\tilde{\mathbf{F}}) + \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} \quad \text{on } \Gamma_A $$

The first two terms are $-(\mathbf{I}-\mathbf{n}\mathbf{n})\cdot\tilde{\mathbf{F}}$. The tangential surface-tension force is

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

The normal term $-\mu_A\mathbf{n}\,\nabla_s\cdot\mathbf{u}_s$ uses $\partial u_n/\partial n = -\nabla_s\cdot\mathbf{u}_s$ (incompressibility at the surface). The gradient is relaxed by the acceleration model: $g^{k} = g^{k-1} + \omega\,(g^{*} - g^{k-1})$.

The patch value is reconstructed from the gradient in evaluate():

$$ \mathbf{U}_A = \mathbf{U}_P + \mathbf{k}\cdot\nabla\mathbf{U}_P + \frac{1}{\Delta_f}\,\frac{\partial \mathbf{U}_A}{\partial n} \qquad\text{or}\qquad \mathbf{U}_A = \mathbf{U}_P + \mathbf{k}\cdot\nabla\mathbf{U}_P + \frac{1}{2\Delta_f}\left(\frac{\partial \mathbf{U}_A}{\partial n} + \mathbf{n}\cdot\nabla\mathbf{U}_P\right) $$

(first order / secondOrder yes; the $\mathbf{k}$ term only with nonOrthCorr yes).

Symbol	Description	Unit
$\mathbf{U}$	Velocity	m/s
$\mathbf{u}_s$	Surface velocity on the `faMesh` (`Us()`)	m/s
$\sigma$	Surface tension (`sigma()` of the `capillaryInterface`)	N/m
$\kappa$	Face curvature, `faMesh::faceCurvatures()`	1/m
$\mathbf{L}_e$, $c_e$	Edge length vectors and `edgeLengthCorrection()` of the `faMesh`	m, –
$\mu_A$, $\mu_B$	`mu` from each region’s `transportProperties`	Pa·s
$\Delta_f$	Patch `deltaCoeffs`	1/m
$\mathbf{k}$	Non-orthogonal part of the face-to-cell vector	m

Implementation

updateCoeffs() is the generic one of genericRegionCoupledFlux:

Return if already updated or if the interface has coupled no (the gradient is then frozen).
Call update() on the first interfaceType (refreshes curvature and $\mathbf{u}_s$ of the capillaryInterface).
Look up the neighbour U by the local field name and refCast its patch field to genericRegionCoupledJump<vector>. Its flux() is interpolated onto this patch and negated.
Add fluxJump() and divide by k = diffCoeff(). diffCoeff() uses the hardcoded name mu: the patch values of a registered volScalarField mu, otherwise the scalar mu from transportProperties.
Relax the gradient with the acceleration model and call fixedGradient::updateCoeffs().

fluxJump() computes $\nabla_s\cdot\mathbf{u}_s$ (fac::div), $\nabla_s\mathbf{u}_s$ (fac::grad) and the edge-integrated surface-tension force on the faMesh. $\mu_A$ and $\mu_B$ are always read from the transportProperties dictionaries, not from fields. If a region has a pKin field, its mu must equal rho*nu from the same dictionary (exact floating-point comparison), otherwise the run stops with a fatal error. Each call prints Us <value> (the volume swept by $\mathbf{u}_s$ in one time step) to the log.

evaluate() uses the registered grad(U) if it exists, otherwise fvc::grad(U).

The U flux residual of the pUPimple DNA loop is taken from this BC (side A is checked first):

$$ r = \frac{\lVert \mu_A\,\partial_n\mathbf{U}_A + \tilde{\mathbf{F}} - \text{fluxJump}\rVert_2} {\max\left(\min\left(\lVert\mu_A\,\partial_n\mathbf{U}_A\rVert_2,\ \lVert -\tilde{\mathbf{F}}+\text{fluxJump}\rVert_2\right),\ \text{SMALL}\right)} $$

with $\partial_n\mathbf{U}_A$ from snGrad() of the patch.

Dictionary Entries

Keyword	Description	Required	Default
`type`	`regionCoupledVelocityFlux`	yes	—
`interfaceType`	List of interface type names. The first entry must be `capillaryInterface`	yes	—
`gradient`	Initial patch-normal gradient. Read if present; otherwise zero gradient and the patch value is set from the internal field	no	zero
`value`	Not read (`fixedGradient` ignores it). Written by `write()`	no	—
`diffusivity`	Read, but ignored: the BC always uses `mu`	no	empty
`neighbourFieldName`	Read by the coupling manager, not used by this BC	no	local field name
`accType`	Acceleration model for the gradient: `fixed`, `aitken`, `IQNILS`. A warning is printed if missing	no	`fixed`
`relax`	(Initial) relaxation factor	no	`1.0`
`couplingReuse`	`IQNILS` only	no	`0`
`nonOrthCorr`	Non-orthogonal correction in `evaluate()`	no	`false`
`secondOrder`	Second-order reconstruction of the patch value	no	`false`

write() does not write gradient. After a restart or decomposePar the gradient therefore starts from zero.

Usage

tutorials/multiphaseFlow/2dRisingBubble/0/fluidA/orig/partitioned/U (side A):

interface
{
 type regionCoupledVelocityFlux;
 diffusivity "mu"; // ignored, always mu
 interfaceType (capillaryInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform (0 0 0); // not read
}

Partner on side B, 0/fluidB/orig/partitioned/U:

interfaceShadow
{
 type regionCoupledVelocityValue;
 interfaceType (capillaryInterface);
 value uniform (0 0 0);
}

The regionInterfaceProperties and multiRegionProperties entries are shown on the regionCoupledVelocityValue page and in capillaryInterface.

Known Limitations

capillaryInterface only. capInterface() aborts unless the first interfaceType entry is capillaryInterface.
Must sit on side A (inferred). The faMesh normals, $\mathbf{u}_s$, $\sigma$ and $\kappa$ are used index by index on the patch without interpolation, which is only valid on the side that owns the faMesh.
Partner must be jump-derived. The neighbour U patch field is refCast to genericRegionCoupledJump<vector>; any other type aborts.
Exact mu == rho*nu check for regions with pKin. Rounding in the input values can trigger the fatal error.
diffusivity and neighbourFieldName are ignored.
Relaxation history starts from the patch value (inferred). The base class initialises the acceleration model with the patch values but relaxes the gradient. With relax 1 (the default, used in all tutorials) this has no effect.
gradient is not written to the time directories.
No runnable tutorial. The tutorials use the disabled interTrackFluid.

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/fluidA/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: 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

multiPhysicsFoam – Multiphase

Docs: calcCurvature

Overview

Method

Usage

Input / Output

Known Limitations

Tutorials

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

Overview

Governing Equations

Continuity

Phase-fraction transport

Mixture properties

Momentum

Surface tension (CSF)

Gravity decomposition and pressure recovery

Stress tensor (for FSI coupling)

Note

Numerical Algorithm

Time-step control

Sub-Models

Required Fields

Case Setup

Required dictionaries

transportProperties

multiRegionProperties entry

controlDict (singleRegionMode)

Key fvSolution settings

Key fvSchemes entries

Adjustable time stepping (controlDict)

Coupling

Known Limitations

Tutorials

References

Docs: massTransferInterface

Overview

Interface Conditions

Mass flux from the energy balance (massTransferInterface::saturatedFlux)

Temperature flux condition (regionCoupledPhaseChangeHeatFlux)

Velocity jump (regionCoupledMassTransferVelocityValue)

Pressure jump (regionCoupledMassTransferPressureValue)

Momentum flux jump (regionCoupledMassTransferVelocityFlux)

Implementation

Coupled Fields

Compatible Region Types

Case Setup

regionInterfaceProperties entry

multiRegionProperties DNA entry

Boundary conditions

Known Limitations

Tutorials

References

Docs: regionCoupledMassTransferPressureValue

Overview

Mathematical Formulation

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

Docs: regionCoupledMassTransferVelocityFlux

`regionInterfaceProperties` entry

`multiRegionProperties` DNA entry

Other required files (from `2dRisingBubble`)

`transportProperties`

`multiRegionProperties` entry

`controlDict` (singleRegionMode)

Key `fvSolution` settings

Key `fvSchemes` entries

Adjustable time stepping (`controlDict`)

Mass flux from the energy balance (`massTransferInterface::saturatedFlux`)

Temperature flux condition (`regionCoupledPhaseChangeHeatFlux`)

Velocity jump (`regionCoupledMassTransferVelocityValue`)

Pressure jump (`regionCoupledMassTransferPressureValue`)

Momentum flux jump (`regionCoupledMassTransferVelocityFlux`)

`regionInterfaceProperties` entry

`multiRegionProperties` DNA entry