multiPhysicsFoam – Solid-Mechanics

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

$$ \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} \quad \text{on } \Gamma_s $$

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

Docs: solidSymmetry

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

Overview

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

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

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

Mathematical Formulation

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

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

Vector field, first order (default)

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

Vector field, second order (`secondOrder yes`)

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

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

Scalar field

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

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

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

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

Implementation

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

evaluate() (called from correctBoundaryConditions()):

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

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

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

Dictionary Entries

Vector version:

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

Scalar version:

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

The scalar version does not read secondOrder.

Required registered fields:

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

Usage

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

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

With the second-order correction:

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

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

Known Limitations

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

Tutorials

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

No tutorial uses the scalar version or secondOrder yes.

References

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

Docs: solidTraction

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

Overview

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

Mathematical Formulation

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

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

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

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

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

The patch value is then reconstructed from the gradient:

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

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

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

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

Implementation

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

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

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

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

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

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

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

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

Dictionary Entries

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

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

Required registered fields on the solid mesh:

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

Usage

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

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

Uniform pressure ramped in time from a table file:

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

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

Known Limitations

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

Tutorials

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

References

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

multiPhysicsFoam – Solid-Mechanics

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

Known Limitations

Tutorials

References

Docs: solidSymmetry

Overview

Mathematical Formulation

Vector field, first order (default)

Vector field, second order (secondOrder yes)

Scalar field

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

Docs: solidTraction

Overview

Mathematical Formulation

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

`mechanicalProperties`

`multiRegionProperties` entry

Key `fvSolution` settings

Key `fvSchemes` settings

Boundary conditions for `D`

Vector field, second order (`secondOrder yes`)