multiPhysicsFoam – Phase-Change

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

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

Overview

regionCoupledPhaseChangeHeatFlux is the flux side (Neumann side) of the temperature coupling of massTransferInterface (evaporation/condensation between two fluid regions). It derives from genericRegionCoupledFlux<scalar> (and so from fixedGradient). It fixes the normal temperature gradient so that the conductive heat fluxes of both sides add up to the interfacial heat-flux jump $q_{sat}$, which massTransferInterface computes and consumes as latent heat. The interface found through the first interfaceType entry must be a massTransferInterface. The partner on the neighbour region must be a genericRegionCoupledJump<scalar>-derived BC. The class does not prescribe which one: regionCoupledScalarJump with interfaceType (massTransferInterface) and diffusivity k fits (inferred). regionCoupledTemperatureJump only works if a heatTransferInterface on the same patch pair is listed first in its own interfaceType.

Mathematical Formulation

Let $B$ be this patch and $A$ the neighbour (jump-side) patch:

$$ k_B \frac{\partial T_B}{\partial n_B} + k_A \frac{\partial T_A}{\partial n_A} = q_{sat} \quad \text{on } \Gamma $$

imposed as the gradient

$$ \left.\frac{\partial T_B}{\partial n}\right|_b = \frac{-\,\mathcal{I}_{A\to B}\!\left(k_A\, \partial_n T_A\right) + q_{sat}}{k_B} $$

followed by relaxation with the acceleration model. The flux jump is the heat-flux imbalance at saturation computed by massTransferInterface:

$$ 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}}, \qquad \dot m = -\frac{q_{sat}}{h_{lv}} $$

The value continuity $T_A = T_B$ comes from the jump-side partner. This BC does not fix $T_\Gamma$ to $T_{sat}$.

Symbol	Description	Unit
$T$	Temperature (field `T` in both regions)	K
$k_B$	Thermal conductivity, diffusivity name fixed to `k`	W/(m K)
$k_A\,\partial_n T_A$	`flux()` of the jump-side partner (its own `diffusivity`)	W/m²
$q_{sat}$	`massTransferInterface::fluxMTJump()` (area field `<patchA>fluxMTJump`)	W/m²
$T_{sat}$, $h_{lv}$	Saturation temperature and latent heat of the interface	K, J/kg
$\dot m$	Interfacial mass flux of the interface	kg/(m² s)

Implementation

Run-time work is inherited from genericRegionCoupledFlux<scalar> (see there). The class adds:

fluxJump(): returns the internal field of massTransInterface().fluxMTJump(), an areaScalarField on the interface’s finite-area mesh. It is used as is, without interpolation between the two sides.
massTransInterface(): checks that the interface matched through the first interfaceType entry is a massTransferInterface, otherwise FatalError. Called from fluxJump(), i.e. in every updateCoeffs() and every residual evaluation.
diffusivityName(): hard-coded to k. The diffusivity keyword is read by the base class but ignored. diffCoeff() takes a volScalarField k of the local region if one is registered, otherwise the uniform k from the region’s transportProperties.

Per DNA iteration of T, updateCoeffs() first calls the interface’s update(). This runs massTransferInterface::correct() → updateMDotS(), which recomputes $q_{sat}$ from copies of both T fields with the interface patches set to $T_{sat}$ (and sets $\dot m$ to zero at time index 1). The jump-side partner triggers the same update. The BC then refCasts the neighbour T patch field to genericRegionCoupledJumpFvPatchField<scalar>, interpolates and negates its flux(), adds $q_{sat}$, divides by $k_B$, relaxes and fixes the gradient. The flux residual $|k_B g_B + \mathcal{I}(q_A) - q_{sat}|$ is checked against maxFluxRes.

Dictionary Entries

Keyword	Description	Required	Default
`type`	`regionCoupledPhaseChangeHeatFlux`	yes	—
`interfaceType`	Interface type list. The first entry must be `massTransferInterface`.	yes	—
`diffusivity`	Read by the base class but ignored (`k` is always used)	no	—
`neighbourFieldName`	Read and written, not used	no	local field name (`T`)
`accType`	`fixed`, `aitken` or `IQNILS`	no	`fixed` (with warning)
`relax`	Initial / fixed relaxation factor	no	`1.0`
`couplingReuse`	`IQNILS` only: reused time steps	no	`0`
`nonOrthCorr`	Non-orthogonal correction in `evaluate()`	no	`false`
`secondOrder`	Second-order value evaluation	no	`false`
`gradient`	Initial gradient; if given, the initial patch value is evaluated from it	no	zero
`value`	Not read (only written)	no	—

The interface parameters ($T_{sat}$, $h_{lv}$) are read from massTransferInterfaceCoeffs in constant/regionInterfaceProperties; see docs/interfaces/massTransferInterface.md.

Usage

There is no tutorial. Entry pattern (from docs/interfaces/massTransferInterface.md):

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

Partner on the other region (inferred: the class only requires a genericRegionCoupledJump<scalar>-derived BC):

// 0/fluidA/T
interface
{
 type regionCoupledScalarJump;
 interfaceType (massTransferInterface);
 diffusivity "k";
 accType aitken;
 relax 0.75;
 value uniform 373.15;
}

Both regions need a uniform k in their transportProperties (read by the interface and by this BC). The patch pair is declared in partitionedCoupledPatches with interfaceType (... massTransferInterface), coupledFields (T ...) and a massTransferInterfaceCoeffs sub-dictionary.

Known Limitations

No tutorial; untested. No case uses this BC or massTransferInterface. The interTrackFluid region type it was written for is commented out in src/multiRegionSystem/Make/files.
Needs massTransferInterface first in interfaceType; any other type aborts in fluxJump().
Conformal patches assumed. $q_{sat}$ lives on the finite-area mesh of the interface (built on side A) and is returned without mapping. If this BC is on side B, the result is only correct when both patches have the same faces in the same order (inferred). Otherwise the field sizes do not match.
Diffusivity name fixed to k. The diffusivity keyword is ignored, yet write() writes diffusivity k;. A registered volScalarField k takes precedence over the transportProperties entry. In a turbulent region that field is the turbulent kinetic energy, not the conductivity (inferred).
Interface update on every call. The interface’s correct() (recomputing $q_{sat}$ and $\dot m$, with an Info line) runs in every updateCoeffs() of every BC coupled through this interface.
$T_{sat}$ is not imposed on the interface temperature; it only enters $q_{sat}$.
Inherited from genericRegionCoupledFlux: partner must be a jump BC, value ignored on input, gradient not written, first relaxation uses the patch values as reference, neighbourFieldName unused, IQNILS not parallel-consistent, partitioned only.

Tutorials

Tutorial	Description
—	No tutorial uses `regionCoupledPhaseChangeHeatFlux`.

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 – Phase-Change

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

Overview

Mathematical Formulation

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

Docs: regionCoupledMassTransferVelocityValue

Overview

Mathematical Formulation

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

Docs: regionCoupledPhaseChangeHeatFlux

Overview

Mathematical Formulation

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

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