multiPhysicsFoam – Fsi

Docs: fsiInterface

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

Overview

fsiInterface couples a fluid region with a deforming solid region (solidStVK) along a common surface, using a partitioned Dirichlet-Neumann scheme. The solid receives the fluid traction as a Neumann condition on its displacement D. The fluid interface patch is moved to the deformed solid surface by the interfaceTrackingFvMesh dynamic mesh of the fluid region. The class has very little logic of its own. It builds a patch-to-patch mapping in the deformed solid configuration, defines a geometric interface residual for the DNA loop, and logs the total force on the solid. The traction transfer lives in the regionCoupledTraction boundary condition. The displacement transfer lives in movingInterfacePatches (src/dynamicFvMesh).

Interface Conditions

Let $\Gamma$ be the interface between the fluid region $f$ and the solid region $s$. $\mathbf{x}_0$ is the undeformed position of a solid interface point.

Kinematic condition

$$ \mathbf{x}_f = \mathbf{x}_0 + \mathbf{D}_s \quad \text{on } \Gamma $$

The fluid interface points follow the solid point displacement pointD. Velocity continuity is not imposed through fsiInterface. In all FSI tutorials the fluid velocity on the interface uses movingWallVelocity, so the fluid velocity at the wall equals the velocity of the moving mesh.

Dynamic condition

$$ \mathbf{n}_s \cdot \boldsymbol{\sigma}_s = -\,\mathbf{n}_f \cdot \boldsymbol{\sigma}_f \quad \text{on } \Gamma $$

regionCoupledTraction implements this as a fixed-gradient condition on D. The fluid traction $\mathbf{t}_f = \boldsymbol{\sigma}_f\cdot\mathbf{n}_f$ (fluid patch normals) is mapped to the solid patch and its sign is flipped, $\mathbf{t} = -\mathbf{t}_f$. The normal gradient is then

$$ \frac{\partial \mathbf{D}}{\partial n} = \frac{1}{K}\left[\,\mathbf{t} - \mathbf{n}\cdot\boldsymbol{\sigma}_s + K\,\mathbf{n}_0\cdot\nabla\mathbf{D}\,\right], \qquad \mathbf{n} = \frac{\mathbf{F}^{-T}\cdot\mathbf{n}_0}{\lvert\mathbf{F}^{-T}\cdot\mathbf{n}_0\rvert} $$

At convergence of the solid Picard loop, $\mathbf{n}\cdot\boldsymbol{\sigma}_s = \mathbf{t}$ holds in the deformed configuration.

Symbol	Description	Unit
$\mathbf{D}_s$	Solid total displacement (`D`, point field `pointD`)	m
$\boldsymbol{\sigma}_f$	Fluid Cauchy stress (`sigma` in the fluid region)	Pa
$\boldsymbol{\sigma}_s$	Solid Cauchy stress (`sigma` in the solid region)	Pa
$\mathbf{n}_0$	Undeformed solid patch normal	–
$\mathbf{n}$	Deformed solid patch normal	–
$\mathbf{F}^{-1}$	Inverse deformation gradient (`Finv`)	–
$K$	Implicit stiffness $2\mu+\lambda$ (`impK`, $1/K$ = `rImpK`)	Pa

Interface residual

The DNA convergence measure is the mismatch between the deformed solid interface points and the fluid interface points. The point positions of the side listed second in coupledPatchPair (side B) are mapped to side A:

$$ r_\Gamma = \frac{\lVert \mathbf{x}_s - \mathbf{x}_f \rVert_2} {\max\left(\lVert \mathbf{x}_s \rVert_2,\ \lVert \mathbf{x}_f \rVert_2,\ \text{SMALL}\right)}, \qquad \mathbf{x}_s = \mathbf{x}_0 + \mathbf{D}_s $$

The norms are global sums over all interface points (gSum). The face-wise field written with outputIntResField is $\lvert\mathbf{x}_s-\mathbf{x}_f\rvert$, interpolated from points to faces on patch A.

Implementation

Which side is the solid is decided at run time. Side A is assumed to be the solid unless the mesh of side B holds a pointVectorField named pointD.

Construction. The constructor reads the fsiInterfaceCoeffs sub-dict, which must be present but is not used. It then builds the interface-to-interface mapping (makeInterfaceToInterface()):
1. The solid mesh is moved temporarily to points + pointD.
2. An interfaceToInterfaceMapping of type interfaceTransferMethod (AMI or directMap) is built between the two patches.
3. The solid mesh is moved back and its moving flag is reset. The solid therefore stays total Lagrangian.
Mapping updates. interfaces_->update() calls updateInterpolatorAndGlobalPatches() only if mesh A is changing(). The mapping is then rebuilt every interpolatorUpdateFrequency time steps (0 = never), or when mesh A changes without moving (topology change). A rebuild goes through the same deformed-configuration step as in 1.
DNA loop for D (multiRegionSystem::solve()). The stand-alone PIMPLE call is skipped when D is DNA-coupled. Each DNA iteration then runs:
1. solvePIMPLE() on the fluid region(s). This updates the fluid sigma.
2. assembleAndSolveEqns("D"). The solid momentum equation is solved with regionCoupledTraction on the interface. The BC also stores the total force $\sum \mathbf{t}\,\lvert\mathbf{S}_0\rvert$ on the interface via setTotalForce().
3. meshMotionCorrector() on all regions. For the fluid interfaceTrackingFvMesh with fsiInterface yes, the solid pointD on the neighbour patch is mapped to the fluid patch. The mapping is built in the deformed solid configuration as in 1. The mapped displacement is relaxed by the patch’s own acceleration model (accType, relax in dynamicMeshDict). The increment relative to the previous iteration is imposed on the fluid patch, and the motion solver moves the interior points.
4. interfaces_->update(). This runs step 2 and info(), which prints Total force on solid interface: (...).
5. dnaControl evaluates normIntRes("D") against maxIntRes.
After the loop, postSolvePIMPLE() runs on the fluid region(s).

correct() is a no-op. getMinDeltaT() returns GREAT, so the interface does not limit the time step.

If coupled no, regionCoupledTraction returns before updating its gradient. dnaControl then stops after the first pass, and the interface residual returns 0 for non-coupled interfaces. couplingStartTime switches coupling on once that time is reached.

Coupled Fields

Field	Required boundary conditions (fluid / solid)	Description
`D`	none (the fluid has no `D`) / `regionCoupledTraction`	Solid displacement, driven by the fluid traction

Fields looked up, but not coupled through a patch field pair:

Field	Region	Used by	Provided by
`pointD`	solid	`fsiInterface` (mapping, residual, solid-side detection), `movingInterfacePatches`	`solidStVK`
`sigma` (`volSymmTensorField`)	fluid	`regionCoupledTraction` (fluid traction)	`pimpleFluid` (also declared by `icoFluid`, `rhoPimpleFluid`, `overPimpleFluid`, `buoyantPimpleFluid`)
`sigma`, `impK`, `rImpK`, `gradD`, `Finv`	solid	`regionCoupledTraction`	`solidStVK`

Only maxIntRes is meaningful for D. The fluid has no D field, so jump and flux residuals are not evaluated for this interface. regionCoupledTraction uses a direct flux, so it cannot provide a flux residual anyway.

fsiInterface creates no fields itself. With outputIntResField yes, dnaControl writes DinitialIntRes and DfinalIntRes on mesh A.

Compatible Region Types

Region type (fluid side)	Region type (solid side)	Notes
`pimpleFluid`	`solidStVK`	Used in all FSI tutorials. The fluid mesh must be `interfaceTrackingFvMesh` with `fsiInterface yes` on the interface patch
`pimpleFluid transportTemperature`	`solidStVK conductTemperature`	Combined with `heatTransferInterface` on the same patch pair (`heatedBeamInCrossFlow`)
`icoFluid`, `rhoPimpleFluid`, `overPimpleFluid`, `buoyantPimpleFluid`	`solidStVK`	These provide a `sigma` stress field. Untested: no tutorial, and the dynamic-mesh support of each region type has not been checked

Case Setup

`regionInterfaceProperties` entry

From tutorials/fluidStructureInteraction/HronTurekFsi3:

partitionedCoupledPatches
(
 fluidsolid
 {
 interfaceType (fsiInterface);

 coupledPatchPair
 (
 (fluid interfaceShadow)
 (solid interface)
 );

 coupledFields
 (
 D
 );

 coupled no; // default yes
 couplingStartTime 2.0; // default 0; switches coupling on at t >= 2

 fsiInterfaceCoeffs // required, currently no entries read
 {}
 }
);

monolithicCoupledPatches
(
);

curvatureCorrectedSurfacePatches 0(); // required (no default)

interpolatorUpdateFrequency 0; // default 1; 0 = build mapping once

interfaceTransferMethod AMI; // default AMI; or directMap

directMapCoeffs
{}

AMICoeffs // <interfaceTransferMethod>Coeffs is required
{}

interfaceTransferMethod, <method>Coeffs and interpolatorUpdateFrequency are top-level entries and apply to every interface in the file. beamInCrossFlow and heatedBeamInCrossFlow use directMap and coupled yes.

FSI and conjugate heat transfer on the same patch pair (heatedBeamInCrossFlow):

interfaceType (fsiInterface heatTransferInterface);
coupledFields
(
 D
 T
);

`multiRegionProperties` DNA entry

regions
(
 ( fluid (pimpleFluid) )
 ( solid (solidStVK) )
);

DNA
{
 D
 {
 maxCoupleIter 100;

 residualControl
 {
 maxIntRes 1e-7;
 outputIntResField yes;
 }
 }
}

Fluid dynamic mesh (`constant/fluid/dynamicMeshDict`)

From HronTurekFsi3. The interfaceShadow entry names the solid patch and region:

dynamicFvMesh interfaceTrackingFvMesh;

solver velocityLaplacian;

diffusivity quadratic inverseDistance 2(interfaceShadow cylinder);

twoDMotion yes;

motionPlaneNormal (0 0 1);

interfaceTrackingFvMeshCoeffs
 movingSurfacePatches
 (
 interfaceShadow
 {
 fsiInterface yes; // default false

 neighbourPatch interface; // solid patch
 neighbourMesh solid; // solid region (required with fsiInterface yes)

 accType aitken; // fixed (default) | aitken | IQNILS
 relax 0.05; // default 1.0

 normalMotionDir no;

 fixedSurfacePatches 0();

 interfaceDeformationLimit interfaceDeformationLimit [ 0 0 0 0 0 0 0 ] 0.0;

 interpolatorUpdateFrequency 0; // default 0

 pointNormalsCorrectionPatches 0();

 interfaceTransferMethod AMI; // default AMI

 directMapCoeffs{}

 AMICoeffs{}

 smoothing no;

 smoothSurfaceMeshCoeffs{}
 }
 );

This mapping (fluid mesh motion) is separate from the fsiInterface mapping (traction and residual). Both are configured independently. The tutorials use the same method in both places.

Boundary conditions

Solid 0/solid/D (HronTurekFsi3/0/solid/orig/partitioned/D):

interface
{
 type regionCoupledTraction;
 neighbourFieldName sigma;
 interfaceType (fsiInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform (0 0 0);
}

interfaceType is required. secondOrder and nonOrthCorr default to false. accType and relax may also be set here to relax the traction gradient (default fixed, 1.0). None of the tutorials do this. neighbourFieldName is read by the coupling manager, but regionCoupledTraction always looks up the fluid field named sigma.

Fluid 0/fluid/U, 0/fluid/pKin and 0/fluid/pointMotionU (HronTurekFsi3/0/fluid/orig/partitioned/):

// U
interfaceShadow
{
 type movingWallVelocity;
 value uniform (0 0 0);
}

// pKin
interfaceShadow
{
 type zeroGradient;
 value uniform 0;
}

// pointMotionU
interfaceShadow
{
 type fixedValue; // overwritten each motion step by interfaceTrackingFvMesh
 value uniform (0 0 0);
}

interfaceTrackingFvMesh requires the pointMotionU interface patch to be fixedValue. It refCasts it to fixedValuePointPatchVectorField.

Known Limitations

Partitioned only. There is no monolithic FSI path, because monolithic coupling is disabled in multiRegionSystem.
Solid must be solidStVK. The solid side is detected by the presence of pointD. regionCoupledTraction needs impK, rImpK, gradD, sigma and Finv, which only solidStVK provides.
The fluid mesh motion is not done by fsiInterface. Without an interfaceTrackingFvMesh entry with fsiInterface yes on the fluid patch, the fluid mesh does not follow the solid. The interface residual then never drops.
Two independent mappings. fsiInterface (traction, residual) and movingInterfacePatches (displacement) each build their own interface-to-interface mapping from different dictionaries. Inconsistent settings are not detected.
Mapping is built on the configuration at construction time when interpolatorUpdateFrequency 0, as in all tutorials. With large deformations, the AMI/directMap weights are not refreshed. This is inferred from the code and has not been tested for large-deformation cases.
Update trigger only checks mesh A. changing() and moving() look only at the region listed first in coupledPatchPair. If the static solid is listed first, the fsiInterface mapping is never rebuilt, whatever the value of interpolatorUpdateFrequency. The tutorials list the fluid first. This is inferred from the code and untested.
Residual normalisation depends on the coordinate origin. $r_\Gamma$ is normalised by the magnitude of the absolute point positions. Moving the geometry away from the origin makes the same mismatch look smaller. Inferred from the code.
Total force uses the undeformed area. The logged total force sums the traction times the undeformed face area $\lvert\mathbf{S}_0\rvert$. It is a diagnostic only.
fsiInterfaceCoeffs is required but unused, and correct() is a no-op.
RBF transfer is unavailable (it needs Eigen and is disabled), so only AMI and directMap can be used.

Tutorials

Tutorial	Description
`tutorials/fluidStructureInteraction/HronTurekFsi3`	Hron-Turek FSI3 benchmark (pimpleFluid + solidStVK), AMI transfer, coupling starts at t = 2 s
`tutorials/fluidStructureInteraction/beamInCrossFlow`	Elastic beam in cross-flow (pimpleFluid + solidStVK), directMap transfer
`tutorials/fluidStructureInteraction/heatedBeamInCrossFlow`	Heated elastic beam in cross-flow; `fsiInterface` + `heatTransferInterface` on one patch pair (pimpleFluid + transportTemperature / solidStVK + conductTemperature)

All three are run with ./Allrun -p (partitioned).

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

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

Overview

regionCoupledTraction applies the fluid load to the solid in a partitioned fluid-structure interaction. It acts on the solid displacement D (volVectorField) and derives from genericRegionCoupledFlux<vector>, i.e. from fixedGradient. It uses the “direct flux” path of the base class: the gradient is computed entirely from the fluid traction and the solid stress state, with no flux matching against a partner BC. There is no partner coupled BC on the fluid side, because the fluid has no D field. The fluid side follows the solid through the interfaceTrackingFvMesh mesh motion, and its velocity usually uses movingWallVelocity. The BC belongs to fsiInterface and aborts if the first entry of its interfaceType list is not fsiInterface. The solid region must be solidStVK.

Mathematical Formulation

The fluid traction is evaluated on the fluid patch, mapped to the solid patch and its sign is flipped:

$$ \mathbf{t} = -\,\mathcal{I}_{f\to s}\!\left(\boldsymbol{\sigma}_f\cdot\mathbf{n}_f\right) $$

The normal displacement gradient is then

This is the usual segregated traction condition: the explicit stress $\mathbf{n}\cdot\boldsymbol{\sigma}_s$ is replaced by the implicit $K\,\partial\mathbf{D}/\partial n$ part. At convergence of the solid Picard loop $\mathbf{n}\cdot\boldsymbol{\sigma}_s = \mathbf{t}$ holds in the deformed configuration. 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 $\mathbf{D}_b = \mathbf{D}_P + \mathbf{k}\cdot\nabla\mathbf{D}_P + g/\Delta_f$ (first order) or $\mathbf{D}_P + \mathbf{k}\cdot\nabla\mathbf{D}_P + (g + \mathbf{n}_0\cdot\nabla\mathbf{D}_P)/(2\Delta_f)$ (secondOrder yes); the $\mathbf{k}$ term only with nonOrthCorr yes.

Symbol	Description	Unit
$\mathbf{D}$	Solid total displacement	m
$\boldsymbol{\sigma}_f$	Fluid Cauchy stress, `volSymmTensorField sigma` of the fluid region	Pa
$\mathbf{n}_f$	Outward unit normal of the fluid patch	–
$\boldsymbol{\sigma}_s$	Solid Cauchy stress (`sigma` of the solid)	Pa
$\mathbf{n}_0$	Undeformed solid patch normal	–
$\mathbf{n}$	Deformed solid patch normal	–
$\mathbf{F}^{-1}$	Inverse deformation gradient (`Finv`)	–
$K$	Implicit stiffness (`impK`); $1/K$ = `rImpK`	Pa
$\nabla\mathbf{D}$	Displacement gradient (`gradD`)	–

Implementation

updateCoeffs() is the generic one of genericRegionCoupledFlux with useDirectFlux() returning true:

Return if updated or if the interface has coupled no. The gradient is then frozen at its last value. With couplingStartTime, the coupling is switched on once that time is reached.
Call update() on the first interfaceType, i.e. the fsiInterface.
Set gradient() = flux(), relax it, call fixedGradient::updateCoeffs().

flux():

checks that the first interfaceType is fsiInterface;
looks up the fluid field named sigma (hardcoded) in the neighbour region, takes its patch values on the neighbour patch, dots them with the neighbour patch normals, interpolates the result to the solid patch and negates it;
looks up impK, rImpK, gradD, sigma and Finv on the solid patch (all provided by solidStVK);
calls fsiInterface::setTotalForce() with $\sum \mathbf{t}\,\lvert\mathbf{S}_0\rvert$ (undeformed face areas). The interface logs this value in info().

evaluate() uses the registered grad(D) if one exists. solidStVK registers its gradient as gradD, so in practice fvc::grad(D) is computed on every evaluation.

In the DNA loop for D (multiRegionSystem::solve()), each iteration runs solvePIMPLE() on the fluid (updating the fluid sigma), then assembles and solves D with this BC, then meshMotionCorrector() and interfaces_->update(). Convergence is judged by the fsiInterface interface residual (maxIntRes). The jump and flux residuals of the generic base classes cannot be used: rawResidual()/normResidual() abort for a direct-flux BC, and the fluid has no D field anyway.

Dictionary Entries

Keyword	Description	Required	Default
`type`	`regionCoupledTraction`	yes	—
`interfaceType`	List of interface type names. The first entry must be `fsiInterface`	yes	—
`neighbourFieldName`	Read by the coupling manager, but ignored: the fluid field is always looked up as `sigma`	no	local field name (`D`)
`gradient`	Initial displacement 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 by the base class, not used (direct flux)	no	empty
`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() writes diffusivity only if it was set, and does not write gradient.

Usage

Solid 0/solid/D from tutorials/fluidStructureInteraction/HronTurekFsi3/0/solid/orig/partitioned/D:

interface
{
 type regionCoupledTraction;
 neighbourFieldName sigma; // ignored, sigma is hardcoded
 interfaceType (fsiInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform (0 0 0); // not read
}

The matching fluid patch has no coupled BC. In the tutorials it uses movingWallVelocity for U, zeroGradient for pKin, and fixedValue for pointMotionU (driven by interfaceTrackingFvMesh with fsiInterface yes).

constant/regionInterfaceProperties:

partitionedCoupledPatches
(
 fluidsolid
 {
 interfaceType (fsiInterface);

 coupledPatchPair
 (
 (fluid interfaceShadow)
 (solid interface)
 );

 coupledFields
 (
 D
 );

 fsiInterfaceCoeffs
 {}
 }
);

constant/multiRegionProperties:

DNA
{
 D
 {
 maxCoupleIter 100;

 residualControl
 {
 maxIntRes 1e-7;
 }
 }
}

The full setup (dynamic mesh, transfer method, coupling start time) is described in fsiInterface.

Known Limitations

fsiInterface and solidStVK only. The interface type is checked; the solid fields impK, rImpK, gradD, sigma and Finv are only provided by solidStVK.
The fluid stress must be called sigma. neighbourFieldName is read but not used.
No generic residuals. Use the fsiInterface interface residual (maxIntRes); jump/flux residuals abort for this BC.
Relaxation history starts from the patch value (inferred). The base class initialises the acceleration model with the patch values of D but relaxes the gradient. With relax 1 (the default, used in all tutorials) this has no effect.
Total force uses the undeformed area and is set on every call of flux(). It is a diagnostic only.
gradient is not written to the time directories, so a restart starts from zero gradient until the first update.
Partitioned only. There is no monolithic FSI path.

Tutorials

Tutorial	Description
`tutorials/fluidStructureInteraction/HronTurekFsi3`	Hron-Turek FSI3 benchmark (`pimpleFluid` + `solidStVK`), AMI transfer, coupling starts at t = 2 s
`tutorials/fluidStructureInteraction/beamInCrossFlow`	Elastic beam in cross-flow (`pimpleFluid` + `solidStVK`), directMap transfer
`tutorials/fluidStructureInteraction/heatedBeamInCrossFlow`	Heated elastic beam; `fsiInterface` + `heatTransferInterface` on one patch pair

The BC is set in the 0/solid/orig/partitioned/D variant of each tutorial (./Allrun -p).

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

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

Overview

solidPointDisplacement is a function object (library libmultiRegionFOs) that monitors the displacement of one point of a solid region. At start-up it picks the mesh point closest to a user-given location. At every execution it writes the time, the three components and the magnitude of the point displacement field pointD at that point to a .dat file. pointD is provided by the solidStVK region type. The typical use is the tip displacement of an elastic structure in FSI benchmarks such as Hron-Turek FSI3.

Method

Region. The region keyword names the solid mesh. If it is omitted, solid is used when a mesh of that name exists, otherwise region0.
Point selection (constructor, once). The vector point is read. On each processor the mesh point with the smallest distance $|\mathbf{x}_i - \mathbf{x}_\text{probe}|$ is found by a brute-force search over all points of the reference (undeformed) mesh. Only the processor(s) holding the global minimum distance keep their point. If several processors tie (e.g. a point on a processor boundary), the one with the highest processor number is kept. Each processor that keeps a point prints its distance to the given location. If no processor ends up with a point, the run aborts.

Note: this search always uses the mesh solid if it exists, otherwise region0, regardless of the region keyword (see Known Limitations).
Sampling (execute(), once per time step by default). In mesh region, the pointVectorField pointD is looked up. Its value at the chosen point is taken without interpolation. All other processors contribute zero, and the values are summed over processors. The master writes one line
$$ t \quad D_x \quad D_y \quad D_z \quad |\mathbf{D}| $$
If pointD does not exist in that mesh, a message pointVectorField pointD not found is printed and nothing is written for that step.

write() does nothing and read() ignores the dictionary, so changes to the entry during the run (runTimeModifiable) have no effect.

Usage

system/controlDict entry (function object):

functions
{
 displacement
 {
 type solidPointDisplacement;
 libs (multiRegionFOs);
 region solid;
 point (0.6 0.2 0.0075);
 }
}

Keyword	Description	Required	Default
`type`	`solidPointDisplacement`	yes	—
`libs`	`(multiRegionFOs)`	yes	—
`point`	Location (m); the closest solid mesh point is monitored	yes	—
`region`	Name of the solid mesh that holds `pointD`	no	`solid` if that mesh exists, else `region0`

The standard function object controls that OpenFOAM handles outside the object itself (e.g. executeControl, executeInterval, timeStart, timeEnd) can be added. The object itself reads no other keywords.

Input / Output

Read

Field	Type	Mesh	Description
`pointD`	`pointVectorField`	`region`	Point displacement (m); registered by `solidStVK`

Written (master processor only):

<case>/postProcessing/<startTime>/solidPointDisplacement_<name>.dat

<name> is the function object entry name (e.g. displacement) and <startTime> is the case start time. In parallel runs the file is still written to the undecomposed case directory (processor*/../postProcessing). The file starts with the header # Time Dx Dy Dz magD, followed by one space-separated line per execution. The file is opened anew at start-up, so a restart from the same start time overwrites the earlier file.

Known Limitations

region is only partly honoured. The closest-point search always uses mesh solid (or region0 if there is no solid mesh). The sampling uses region. In practice the solid region must be called solid. With another name the search falls back to region0, which does not exist in a multi-region case, and the run aborts.
Nearest mesh point, no interpolation. The monitored location is the closest existing mesh point, not the exact point. The distance is printed at start-up, so check it in the log.
Requires pointD. Only region types that register a pointVectorField called pointD (currently solidStVK) can be monitored. Other fields cannot be selected.
Reference configuration. The point is selected on the solid mesh points at start-up. This is correct for the total-Lagrangian solidStVK, whose mesh never moves.
Brute-force search. The point search is $O(N_\text{points})$ per processor. This is negligible since it runs only once.
Distributed cases. With distributed data (no shared case directory), writing to processor*/../postProcessing can fail.
Header comment. The class description in the header refers to “temperature” and least-squares vol-to-point interpolation. Both are wrong: the object reads pointD directly.

Tutorials

Tutorial	Description
`tutorials/fluidStructureInteraction/HronTurekFsi3`	Beam tip displacement at `(0.6 0.2 0.0075)` (entry `displacement` in `system/functions`, included from `controlDict`); plotted by `deflection.gnuplot` from `postProcessing/0/solidPointDisplacement_displacement.dat`
`tutorials/fluidStructureInteraction/beamInCrossFlow`	Ships a `deflection.gnuplot` that reads the same file, but its `controlDict` defines no `solidPointDisplacement` entry, so the file is not produced

Docs: solidStVK

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

Overview

solidStVK solves the transient momentum balance for an elastic solid undergoing large deformations. It uses the St. Venant-Kirchhoff hyperelastic law and a total Lagrangian formulation: the unknown is the total displacement D, and every equation is assembled on the undeformed (reference) mesh, which is never moved. The discretisation follows the segregated finite-volume solid-mechanics approach of foam-extend (Cardiff et al.). It uses an implicit “stiffness” Laplacian with explicit deferred correction, and a Rhie-Chow-type momentum stabilisation. The region type is built to act as the structural partner of a fluid region, coupled through fsiInterface. On its own it does not solve anything (see Known Limitations).

Governing Equations

Momentum (total Lagrangian)

The equation assembled in setCoupledEqns() is

$$ \rho \frac{\partial^2 \mathbf{D}}{\partial t^2} = \underbrace{\nabla \cdot \left( K \nabla \mathbf{D} \right)}_{\text{implicit}} - \underbrace{\nabla \cdot \left( K \nabla \mathbf{D} \right)}_{\text{explicit}} + \nabla \cdot \left( J\, \mathbf{F}^{-1} \cdot \boldsymbol{\sigma} \right) + \mathbf{S}_\text{stab} $$

with the implicit stiffness $K = 2\mu + \lambda$. The implicit and explicit Laplacians cancel at convergence, so the converged solution satisfies $\rho\,\ddot{\mathbf{D}} = \nabla_0 \cdot \mathbf{P}^T$ with the first Piola-Kirchhoff stress $\mathbf{P} = J \boldsymbol{\sigma} \mathbf{F}^{-T}$. No body force (gravity) term is included.

Kinematics

$$ \mathbf{F} = \mathbf{I} + (\nabla \mathbf{D})^T, \qquad J = \det \mathbf{F} $$

St. Venant-Kirchhoff constitutive law

$$ \mathbf{C} = \mathbf{F}^T \mathbf{F}, \qquad \mathbf{E} = \tfrac{1}{2}\left( \mathbf{C} - \mathbf{I} \right), \qquad \mathbf{S} = 2\mu\,\mathbf{E} + \lambda\,\mathrm{tr}(\mathbf{E})\,\mathbf{I} $$ $$ \boldsymbol{\sigma} = \frac{1}{J}\, \mathbf{F}\, \mathbf{S}\, \mathbf{F}^T $$

Lamé parameters

$$ \mu = \frac{E}{2(1+\nu)}, \qquad \lambda = \begin{cases} \dfrac{\nu E}{(1+\nu)(1-2\nu)} & \text{plane strain / 3-D} \\[2ex] \dfrac{\nu E}{(1+\nu)(1-\nu)} & \text{plane stress (\texttt{planeStress yes})} \end{cases} $$

Symbol	Description	Unit
$\mathbf{D}$	Total displacement	m
$\rho$	Solid density	kg/m³
$E$	Young’s modulus	Pa
$\nu$	Poisson’s ratio	–
$\mu,\ \lambda$	Lamé parameters	Pa
$K$	Implicit stiffness $2\mu+\lambda$ (`impK`, `impKf`)	Pa
$\mathbf{F}$	Deformation gradient	–
$J$	Jacobian $\det\mathbf{F}$	–
$\mathbf{E}$	Green-Lagrange strain	–
$\mathbf{S}$	2nd Piola-Kirchhoff stress	Pa
$\boldsymbol{\sigma}$	Cauchy stress (`sigma`)	Pa
$\mathbf{S}_\text{stab}$	Momentum stabilisation term	Pa/m

Momentum stabilisation

$\mathbf{S}_\text{stab}$ is evaluated explicitly on the displacement increment DD $= \mathbf{D} - \mathbf{D}^\text{old}$ and its gradient gradDD. Its diffusivity is $\gamma = s\,K$, where $s$ is the scale factor, interpolated to faces as $\gamma_f$:

`type`	Term
`RhieChow` (default)	$\nabla\cdot(\gamma_f \nabla \mathbf{DD}) - \nabla\cdot\left(\gamma_f\, \mathbf{S}_f \cdot (\nabla\mathbf{DD})_f\right)$, i.e. compact minus non-compact Laplacian
`JamesonSchmidtTurkel`	$-\nabla\cdot\left(\lvert\mathbf{S}_f\rvert\, \nabla \left[\nabla\cdot(\gamma_f \nabla \mathbf{DD})\right]\right)$ (fourth-order damping)
`Laplacian`	$\nabla\cdot(\gamma_f \nabla \mathbf{DD})$
`none`	$\mathbf{0}$

On faces where $K$ differs between owner and neighbour (material interfaces), $\gamma_f$ is replaced by interfaceScaleFactor·$\tfrac{1}{2}(K_\text{own}+K_\text{nei})$. On coupled non-processor patches this replacement is applied to every face.

Numerical Algorithm

usesPIMPLE() returns false. solveRegion(), prePredictor(), momentumPredictor(), pressureCorrector() and meshMotionCorrector() are all no-ops. selfCoupledFieldNames() is not overridden, so it returns an empty list. The displacement equation is solved only when D appears in the DNA (partitioned) coupled field list. In that case each DNA iteration of multiRegionSystem::solve() runs:

solvePIMPLE() on the fluid region(s). D is a special FSI field, and stand-alone PIMPLE is skipped whenever D is DNA-coupled.
assembleAndSolveEqns<fvMatrix, vector>("D"). For solidStVK this is a Picard loop:
1. setCoupledEqns("D") stores D.prevIter() and assembles the momentum equation above. It registers the equation as D<mesh>MeshsolidStVKTypeEqn.
2. The equation is relaxed (relaxationFactors.equations) and solved.
3. postSolve() relaxes the field D (relaxationFactors.fields). It then updates DD, gradD = fvc::grad(D), gradDD, F, Finv, J, sigma, interpolates D to pointD (volPointInterpolation), updates pointDD and sets the solid velocity U = fvc::ddt(D).
4. The loop repeats until the region’s PICARD.D criteria are met (maxCorr, tolerance, relTol). If no PICARD entry is given, it runs one pass per DNA iteration.
meshMotionCorrector() on all regions. The fluid mesh follows pointD of the solid (via interfaceTrackingFvMesh). Then interfaces_->update().
DNA convergence is checked with the fsiInterface residual: the mismatch between the deformed solid interface points (points + pointD) and the fluid interface points.

correct(), which runs from regionTypeList::preSolve() once per time step, only calls D.correctBoundaryConditions().

getMinDeltaT() returns GREAT, so the solid never limits the time step.

Sub-Models

Sub-model	Selection mechanism	Notes
Momentum stabilisation	`stabilisation` sub-dict in `mechanicalProperties`	`none`, `RhieChow`, `JamesonSchmidtTurkel`, `Laplacian`

No fvOptions, thermal-stress, plasticity or other constitutive models are available. The material law is fixed to St. Venant-Kirchhoff.

Required Fields

Field	Type	Description	Unit
`D`	`volVectorField`	Total displacement (must be read)	m

Created at runtime. All of these are read if present and auto-written unless stated otherwise:

Field	Type	Description	Unit	Default
`DD`	`volVectorField`	Displacement increment over the time step	m	0
`gradD`	`volTensorField`	Displacement gradient	–	0
`gradDD`	`volTensorField`	Gradient of displacement increment	–	0
`F`	`volTensorField`	Deformation gradient	–	`I`
`Finv`	`volTensorField`	Inverse deformation gradient	–	`I`
`J`	`volScalarField`	Jacobian	–	1
`sigma`	`volSymmTensorField`	Cauchy stress	Pa	0
`U`	`volVectorField`	Solid velocity $\partial\mathbf{D}/\partial t$	m/s	0
`impK`	`volScalarField`	Implicit stiffness $2\mu+\lambda$	Pa	uniform
`impKf`	`surfaceScalarField`	Face implicit stiffness	Pa	uniform
`rImpK`	`volScalarField`	$1/K$ (read if present, not written)	1/Pa	$1/K$
`pointD`	`pointVectorField`	Displacement interpolated to points	m	from `D`
`pointDD`	`pointVectorField`	Point displacement increment	m	from `DD`

pointD is the field that fsiInterface, interfaceTrackingFvMesh and the solidPointDisplacement function object look up. Its presence is also how fsiInterface tells which side of the interface is the solid.

Case Setup

Required dictionaries

constant/<solid>/mechanicalProperties – rho, E, nu, planeStress, optional stabilisation
constant/<solid>/dynamicMeshDict – staticFvMesh (the solid mesh is never moved)
system/<solid>/fvSolution – D solver, relaxation, PICARD loop for D
system/<solid>/fvSchemes – d2dt2, ddt, grad and the named laplacian schemes

`mechanicalProperties`

planeStress no; // required; yes => plane-stress lambda

rho rho [1 -3 0 0 0 0 0] 1000; // required
nu nu [0 0 0 0 0 0 0] 0.4; // required
E E [1 -1 -2 0 0 0 0] 5.6e6; // required

// Optional. If absent: { type RhieChow; scaleFactor 0.1; }
stabilisation
{
 type RhieChow; // none | RhieChow | JamesonSchmidtTurkel | Laplacian
 scaleFactor 0.1; // required unless type none or useCellZones yes
 useCellZones false; // default false; then <cellZoneName>ScaleFactor per zone
 interfaceScaleFactor 0.01; // default 0.01; used on material-interface faces
}

`multiRegionProperties` entry

regions
(
 ( fluid (pimpleFluid) )
 ( solid (solidStVK) )
);

DNA
{
 D
 {
 maxCoupleIter 100;

 residualControl
 {
 maxIntRes 1e-7;
 outputIntResField yes;
 }
 }
}

solidStVK can be stacked with other region types on the same mesh, e.g. ( solid (solidStVK conductTemperature) ) in heatedBeamInCrossFlow.

Key `fvSolution` settings

solvers
{
 "D|DD"
 {
 solver PCG;
 preconditioner FDIC;
 tolerance 1e-09;
 relTol 0.1;
 }
}

relaxationFactors
{
 fields
 {
 "DD|D" 0.9; // applied to D in postSolve()
 }
}

PICARD
{
 D
 {
 maxCorr 1000; // Picard (outer) corrections per DNA iteration
 tolerance 1e-09;
 relTol 1e-09;
 infoFrequency 100;
 }
}

Key `fvSchemes` settings

The momentum equation and the RhieChow stabilisation use the named Laplacian scheme laplacian(DD,D):

d2dt2Schemes { default backward; }
ddtSchemes { default backward; }
gradSchemes { default leastSquares; }
divSchemes { default Gauss linear; }

laplacianSchemes
{
 default none;
 laplacian(DD,D) Gauss linear corrected;
}

interpolationSchemes { default linear; } // also used for interpolate(impK)

With default none, the JamesonSchmidtTurkel stabilisation also needs JSTinner and JSTouter Laplacian entries. The Laplacian stabilisation needs an entry for its default scheme name.

Boundary conditions for `D`

Patch role	BC type
FSI interface (solid side)	`regionCoupledTraction` (with `interfaceType (fsiInterface)`)
Clamped	`fixedValue`
Symmetry plane	`solidSymmetry`
Prescribed traction / pressure (uncoupled)	`solidTraction`

interface
{
 type regionCoupledTraction;
 neighbourFieldName sigma;
 interfaceType (fsiInterface);
 secondOrder false;
 nonOrthCorr false;
 value uniform (0 0 0);
}

regionCoupledTraction and solidTraction look up impK, rImpK, gradD, sigma and Finv from the solid region. All of these are provided by solidStVK.

Coupling

Interface type	Exchanged fields	Coupling modes
`fsiInterface`	Fluid traction `sigma·n` → solid (`regionCoupledTraction` on `D`); solid `pointD` → fluid mesh motion (`interfaceTrackingFvMesh`)	partitioned (DNA)
`heatTransferInterface`	`T`, heat flux (through a stacked `conductTemperature`, not `solidStVK` itself)	partitioned (DNA)

Notes on fsiInterface with this region type:

The interface mapping is built with the solid mesh temporarily moved to its deformed configuration (points + pointD). The mesh is then moved back, so the solid stays total Lagrangian.
The fluid traction is mapped to the solid patch and its sign is flipped. The deformed normal is computed as $\mathbf{n} = \mathbf{F}^{-T}\mathbf{n}_0 / |\cdot|$.
The interface residual for DNA convergence is the point-position mismatch between the deformed solid patch and the fluid patch.

Known Limitations

Requires DNA coupling of D — solveRegion() is a no-op and selfCoupledFieldNames() returns an empty list. If D is not listed in a partitionedCoupledPatches coupledFields entry (and in the DNA dict), the displacement equation is never solved. Single-region (stand-alone solid) runs are therefore not supported.
Partitioned only — there is no monolithic FSI path (monolithic coupling is disabled in multiRegionSystem).
St. Venant-Kirchhoff only — linear elastic in Green strain. It is not suited to large compressive strains. No other material laws, thermal expansion, or body forces (gravity) are implemented.
Constant, uniform material properties — rho, E, nu are single dimensionedScalars read from mechanicalProperties.
No time-step control — getMinDeltaT() returns GREAT.
Static solid mesh — meshMotionCorrector() is a no-op. The staticFvMesh reference configuration is used throughout, and deformation is represented only through D/pointD.
Unused code — solidStVKDdtCoeffs.H (ddt-scheme coefficients) and the threeK member are present but not used anywhere.

Tutorials

Tutorial path	Description
`tutorials/fluidStructureInteraction/HronTurekFsi3`	Hron-Turek FSI3 benchmark (pimpleFluid + solidStVK)
`tutorials/fluidStructureInteraction/beamInCrossFlow`	Elastic beam in cross-flow (pimpleFluid + solidStVK)
`tutorials/fluidStructureInteraction/heatedBeamInCrossFlow`	Heated elastic beam in cross-flow; FSI plus conjugate heat transfer (pimpleFluid + transportTemperature / solidStVK + conductTemperature)

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 – Fsi

Docs: fsiInterface

Overview

Interface Conditions

Kinematic condition

Dynamic condition

Interface residual

Implementation

Coupled Fields

Compatible Region Types

Case Setup

regionInterfaceProperties entry

multiRegionProperties DNA entry

Fluid dynamic mesh (constant/fluid/dynamicMeshDict)

Boundary conditions

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

Overview

Mathematical Formulation

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

Docs: solidPointDisplacement

Overview

Method

Usage

Input / Output

Known Limitations

Tutorials

Docs: solidStVK

Overview

Governing Equations

Momentum (total Lagrangian)

Kinematics

St. Venant-Kirchhoff constitutive law

Lamé parameters

Momentum stabilisation

Numerical Algorithm

Sub-Models

Required Fields

Case Setup

Required dictionaries

mechanicalProperties

multiRegionProperties entry

Key fvSolution settings

Key fvSchemes settings

Boundary conditions for D

Coupling

`regionInterfaceProperties` entry

`multiRegionProperties` DNA entry

Fluid dynamic mesh (`constant/fluid/dynamicMeshDict`)

`transportProperties`

`multiRegionProperties` entry

`controlDict` (singleRegionMode)

Key `fvSolution` settings

Key `fvSchemes` entries

Adjustable time stepping (`controlDict`)

`mechanicalProperties`

`multiRegionProperties` entry

Key `fvSolution` settings

Key `fvSchemes` settings

Boundary conditions for `D`