multiPhysicsFoam – Heat-Transfer

Docs: conductTemperature

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

Overview

conductTemperature models transient heat conduction in a solid. It solves a single energy equation for the temperature T, using density rho, specific heat cv and thermal conductivity kappa. There is no velocity field, no advection and no pressure-velocity coupling. It is meant to be the solid side of a conjugate heat transfer problem, coupled to a fluid region (usually pimpleFluid transportTemperature) through a heatTransferInterface. It can also be stacked with a solid mechanics region type (e.g. solidStVK) for thermo-FSI.

Governing Equations

Energy (heat conduction)

$$ \frac{\partial \left( \rho \, c_v \, T \right)}{\partial t} = \nabla \cdot \left( \kappa \, \nabla T \right) $$

Symbol	Description	Unit
$T$	Temperature	K
$\rho$	Density	kg/m³
$c_v$	Specific heat capacity	J/(kg K) = m²/(s² K)
$\kappa$	Thermal conductivity	W/(m K) = kg m/(s³ K)

The equation is assembled as

fvm::ddt(rho_*cv_, T()) == fvm::laplacian(kappa_(), T(), "laplacian(kappa,T)")

so fvSchemes must provide a laplacian(kappa,T) entry (or a default laplacian scheme). The equation has no source term.

Numerical Algorithm

conductTemperature does not run its own solve loop. usesPIMPLE() returns false. solveRegion(), prePredictor(), momentumPredictor(), pressureCorrector(), meshMotionCorrector() and postSolve() are all no-ops. The temperature is solved only when multiRegionSystem asks for it:

The region does not override selfCoupledFieldNames(), so the base default (an empty list) applies. T is therefore solved only when it appears as a partitioned-coupled field, i.e. when the case has a DNA { T { ... } } entry in multiRegionProperties and T is listed in coupledFields of an interface in regionInterfaceProperties.
Inside each DNA coupling iteration, multiRegionSystem::assembleAndSolveEqns<fvMatrix, scalar>("T") calls setCoupledEqns("T"). This assembles the equation above and stores it under the key T<regionName>MeshconductTemperatureTypeEqn. The equation is then relaxed (relaxationFactors in fvSolution) and solved. The region Picard corrector (maxCorr / relTol / tolerance per field in fvSolution) can re-assemble and re-solve it within one DNA iteration. setCoupledEqns ignores its fieldName argument and always assembles the T equation.
correct() only calls kappa.correctBoundaryConditions().
getMinDeltaT() returns GREAT, so this region never limits the global time step.

Sub-Models

None. The region does not read fvOptions, a thermophysical model or turbulence. All material properties come from transportProperties or from optional field files.

Required Fields

Field	Type	Read mode	Description	Unit
`T`	`volScalarField`	`MUST_READ`, `AUTO_WRITE`	Temperature	K
`kappa`	`volScalarField`	`READ_IF_PRESENT`, `AUTO_WRITE`	Thermal conductivity. If there is no file, a uniform field is created from `transportProperties` with `calculated` patches.	W/(m K)
`rho`	`volScalarField`	`READ_IF_PRESENT`, `NO_WRITE`	Density. If there is no file, it is uniform from `transportProperties`.	kg/m³
`cv`	`volScalarField`	`READ_IF_PRESENT`, `NO_WRITE`	Specific heat. If there is no file, it is uniform from `transportProperties`.	m²/(s² K)

T and kappa are created through lookupOrRead. If a sibling region type on the same mesh has already registered a field with that name, that field is reused. rho and cv are always constructed by this region.

Case Setup

Required dictionaries

constant/<region>/transportProperties – rho, cv, kappa (all required, dimensioned)
system/<region>/fvSolution – T solver, relaxationFactors
system/<region>/fvSchemes – ddt and laplacian(kappa,T) schemes
0/<region>/T – temperature with coupled BC on the interface patch

`multiRegionProperties` entry

regions
(
 ( fluid (pimpleFluid transportTemperature) )
 ( solid (conductTemperature) )
);

DNA
{
 T
 {
 maxCoupleIter 20;

 residualControl
 {
 maxJumpRes 1e-07;
 outputJumpResField no;
 maxFluxRes 1e-07;
 outputFluxResField no;
 }
 }
}

`transportProperties`

All three entries are looked up as dimensionedScalar and are required, even when a field file overrides them:

rho rho [1 -3 0 0 0 0 0] 1.0;
cv cv [0 2 -2 -1 0 0 0] 100.0;
kappa kappa [1 1 -3 -1 0 0 0] 100.0;

Key `fvSolution` settings

solvers
{
 T
 {
 solver PCG;
 preconditioner DIC;
 tolerance 1e-15;
 relTol 0;
 minIter 2;
 maxIter 250;
 }
}

relaxationFactors
{
 T 1.0;
}

Interface boundary condition on `T`

On the solid side of a partitioned heatTransferInterface (flux side; the fluid side then uses regionCoupledTemperatureJump):

top
{
 type regionCoupledHeatFlux;
 interfaceType (heatTransferInterface);
 secondOrder false;
 nonOrthCorr false;
 value $internalField;
}

The coupled patch fields look up the diffusivity field kappa by default (set the patch keyword diffusivity to use another name). This matches the field that conductTemperature registers.

Coupling

Interface type	Exchanged fields	Coupling mode
`heatTransferInterface`	`T` (temperature jump / heat flux via `regionCoupledTemperatureJump` / `regionCoupledHeatFlux`, using `kappa`)	partitioned (DNA)

heatTransferInterface only provides the jumpCoefficient (from heatTransferInterfaceCoeffs). The patch fields do the actual transfer. Monolithic coupling is commented out in multiRegionSystem::solve(), so only partitioned coupling is available at the moment.

Known Limitations

Coupled use only. selfCoupledFieldNames() is not overridden, so T is never solved unless it is DNA-coupled. A standalone (single-region) conductTemperature case does not advance T. Use laplacianFluid for standalone conduction.
No source terms. fvOptions are not read or applied.
Static mesh only. meshMotionCorrector() is a no-op and the equation contains no mesh-flux terms.
No time-step control. getMinDeltaT() returns GREAT; deltaT must be chosen by the user or limited by other regions.
Constant rho and cv in time. They are read once and never updated (NO_WRITE). Only kappa gets a boundary refresh in correct(), and its values are never recomputed (for example as a function of T).
No non-orthogonal corrector loop. The coupled solve path has no correctNonOrthogonal() loop, so nNonOrthogonalCorrectors in fvSolution is not used by this region.
No output/post-processing. postSolve() is a no-op. No derived fields (e.g. heat flux) are written.

Tutorials

Tutorial path	Description
`tutorials/conjugateHeatTransfer/flowOverHeatedPlate`	Flow over a heated plate (`pimpleFluid transportTemperature` + `conductTemperature`)
`tutorials/conjugateHeatTransfer/ShellAndTubeHeatExchanger`	Shell-and-tube heat exchanger, two fluid regions + `conductTemperature` solid
`tutorials/fluidStructureInteraction/heatedBeamInCrossFlow`	Heated beam in cross-flow, thermo-FSI (`solidStVK conductTemperature` solid)

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

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

Overview

heatTransferInterface couples the temperature field T of two regions that share an interface, usually a fluid (pimpleFluid transportTemperature) and a solid (conductTemperature). It is used for conjugate heat transfer (CHT) and, stacked with fsiInterface on the same patch pair, for thermo-FSI. The interface class itself holds only one parameter, the constant jumpCoefficient. All transfer work happens in the two partitioned boundary conditions regionCoupledTemperatureJump and regionCoupledHeatFlux, which are solved inside the DNA coupling loop of multiRegionSystem.

Interface Conditions

Let side $A$ carry the regionCoupledTemperatureJump BC (Dirichlet side) and side $B$ carry the regionCoupledHeatFlux BC (Neumann side). These sides are set by the BC types in 0/<region>/T. They do not depend on the order in coupledPatchPair.

Jump condition

$$ T_A = c \, T_B \quad \text{on } \Gamma $$

In the code, the jump BC sets its value to $T_B + \texttt{valueJump}$ with $\texttt{valueJump} = T_B\,(c - 1)$, where $T_B$ is the neighbour patch value interpolated onto side $A$. With the default tutorial value $c = 1$ this is plain temperature continuity.

Flux condition

$$ \kappa_A \nabla T_A \cdot \mathbf{n}_A + \kappa_B \nabla T_B \cdot \mathbf{n}_B = 0 \quad \text{on } \Gamma $$

The flux BC sets its gradient to

$$ \left.\frac{\partial T}{\partial n}\right|_B = -\frac{\left(\kappa_A \, \partial_n T_A\right)_{A \to B}}{\kappa_B} $$

where $\left(\kappa_A \, \partial_n T_A\right)_{A \to B}$ is the flux of the jump side (flux() = snGrad() * kappa), interpolated onto side $B$. The flux jump of regionCoupledHeatFlux is always zero (fluxJump() returns *this * 0).

Symbol	Description	Unit
$T$	Temperature (coupled field)	K
$c$	`jumpCoefficient` (dimensionless, uniform, constant)	–
$\kappa$	Diffusivity looked up by the BC (default field name `kappa`)	W/(m K) (see note below)
$\mathbf{n}_A, \mathbf{n}_B$	Outward patch normals of side $A$ / $B$	–
$\Gamma$	Interface (coupled patch pair)	–

The flux balance only means energy conservation when $\kappa$ has the same units on both sides. The code does not check this; see Known Limitations.

Implementation

heatTransferInterface derives from regionInterfaceType and is registered in its IOdictionary run-time selection table. At run time:

Construction (regionInterfaceType base): the object is named <regionA><PatchA><RegionB><PatchB>HeatTransferInterface, for example fluidInterfaceSolidTopHeatTransferInterface. The base class builds global patches for both sides and creates the interface-to-interface mapping immediately (interfaceTransferMethod, default AMI; see Case Setup). heatTransferInterface then reads heatTransferInterfaceCoeffs/jumpCoefficient.
correct(): no-op. It is called from regionInterfaceType::update(), which each coupled BC calls in updateCoeffs(). Because heatTransferInterface creates no faMesh, update() does no curvature work.
getMinDeltaT(): returns GREAT. The interface never limits the time step.
info(): empty.
Mapping update: when the interface reports changing(), regionInterfaceTypeList::update() calls updateInterpolatorAndGlobalPatches(). The mapping and global patches are rebuilt every interpolatorUpdateFrequency time steps (0 disables this).
Boundary conditions (in each DNA iteration, when T is assembled and solved by multiRegionSystem):
- regionCoupledTemperatureJump::updateCoeffs() looks up the neighbour T, interpolates its patch values, adds valueJump(), applies the acceleration model (accType, relax) and fixes the value.
- regionCoupledHeatFlux::updateCoeffs() asks the neighbour jump BC for flux(), interpolates it, negates it, divides it by the local kappa, applies the acceleration model and fixes the gradient.
- regionCoupledTemperatureJump looks up the interface found through its own interfaceType entry as a heatTransferInterface (to read jumpCoefficient) and stops with a FatalError if it is another type. regionCoupledHeatFlux defines the same check but never calls it.
Residuals: the DNA loop evaluates the jump residual $|T_A - T_B - \texttt{valueJump}|$ and the flux residual $|q_B + q_{A\to B} - 0|$ through the generic jump/flux BCs. These are checked against maxJumpRes / maxFluxRes.

Diffusivity lookup

regionCoupledTemperatureJump and regionCoupledHeatFlux override diffusivityName(). It returns the patch keyword diffusivity if that is set, otherwise kappa. diffCoeff() then:

uses the patch values of the volScalarField with that name, if one is registered on the region mesh;
otherwise reads a uniform dimensionedScalar with that name from the region’s transportProperties (the dictionary must be registered on the mesh).

Coupled Fields

Field	Required boundary conditions (side A / side B)	Description
`T`	`regionCoupledTemperatureJump` / `regionCoupledHeatFlux`	Temperature. Value continuity (×`jumpCoefficient`) on the jump side, heat-flux continuity on the flux side.

Fields needed but not created by the interface:

Field	Where it must exist	Source
`T`	both regions, same name	region type (e.g. `transportTemperature`, `conductTemperature`)
`kappa` (or the name given by `diffusivity`)	both regions, as `volScalarField` or as a `transportProperties` entry	region type or `transportProperties`

The interface creates no fields. The BC keyword neighbourFieldName is read and written by interfaceToInterfaceCoupleManager, but the jump/flux BCs always look up the neighbour field by the local field name.

Compatible Region Types

The region types below assemble a T equation in setCoupledEqns and/or register a diffusivity the BCs can find. Rows marked tutorial are run in the shipped tutorials. The other rows follow from the code and are untested.

Region type (side A)	Region type (side B)	Notes
`pimpleFluid transportTemperature`	`conductTemperature`	Tutorial (`flowOverHeatedPlate`, `ShellAndTubeHeatExchanger`). Both register `kappa` (W/(m K)). Fluid takes the jump BC, solid the flux BC.
`pimpleFluid transportTemperature`	`solidStVK conductTemperature`	Tutorial (`heatedBeamInCrossFlow`), with `fsiInterface` on the same patch pair. `T`/`kappa` come from `conductTemperature`, not `solidStVK`.
`rhoPimpleFluid`	`conductTemperature`	Untested. `rhoPimpleFluid` registers `kappa` from `turbulence->kappaEff()` and assembles a `T` equation in `setCoupledEqns`.
`laplacianFluid`	any of the above	Untested. `laplacianFluid` registers `DT` (m²/s), not `kappa`. Set `diffusivity DT;` on its patch, or provide `kappa` in its `transportProperties`. Mixing `DT` with a `kappa` in W/(m K) breaks flux consistency.
`conductPotentialTemperature`	any of the above	Untested. The conductivity is a `dimensionedScalar` `k` in `transportProperties` (not a field). Set `diffusivity k;` so the fallback lookup finds it.

See docs/regions/conductTemperature.md, docs/regions/transportTemperature.md, docs/regions/pimpleFluid.md, docs/regions/rhoPimpleFluid.md, docs/regions/solidStVK.md, docs/regions/laplacianFluid.md and docs/regions/conductPotentialTemperature.md.

Case Setup

`regionInterfaceProperties` entry

From tutorials/conjugateHeatTransfer/flowOverHeatedPlate/constant/regionInterfacePropertiesPartitioned:

partitionedCoupledPatches
(
 fluidsolid
 {
 interfaceType (heatTransferInterface);
 coupledPatchPair
 (
 (fluid interface)
 (solid top)
 );
 coupledFields
 (
 T
 );
 heatTransferInterfaceCoeffs
 {
 // Jump coefficient
 jumpCoefficient jumpCoefficient [ 0 0 0 0 0 0 0 ] 1;
 }
 }
);

monolithicCoupledPatches
(
);

curvatureCorrectedSurfacePatches 0();

interpolatorUpdateFrequency 1;

interfaceTransferMethod directMap;

directMapCoeffs
{}

Thermo-FSI stacks both interface types on one patch pair (tutorials/fluidStructureInteraction/heatedBeamInCrossFlow/constant/regionInterfaceProperties):

fluidsolid
{
 interfaceType (fsiInterface heatTransferInterface);
 coupledPatchPair
 (
 (fluid interfaceShadow)
 (solid interface)
 );
 coupledFields
 (
 D
 T
 );
 coupled yes;
 fsiInterfaceCoeffs
 {}
 heatTransferInterfaceCoeffs
 {
 // Jump coefficient
 jumpCoefficient jumpCoefficient [ 0 0 0 0 0 0 0 ] 1;
 }
}

Keywords

Per-interface entry (inside partitionedCoupledPatches):

Keyword	Required	Default	Read by	Description
`interfaceType`	yes	–	`regionInterfaceTypeList`	List of interface types; one object is created per entry.
`coupledPatchPair`	yes	–	`regionInterfaceTypeList`	`((regionA patchA) (regionB patchB))`; must have exactly two entries.
`coupledFields`	yes	–	`regionInterfaceTypeList`	Fields coupled across this interface (`T`).
`heatTransferInterfaceCoeffs`	yes	–	`heatTransferInterface`	Sub-dictionary; `subDict` fails if it is missing.
`heatTransferInterfaceCoeffs/jumpCoefficient`	yes	– (no default in code)	`heatTransferInterface`	Dimensionless `dimensionedScalar` $c$, with $T_A = c\,T_B$.
`coupled`	no	`true`	`regionInterfaceType`	Turns the coupling on/off. When off, the coupled BCs skip `updateCoeffs()` and the residuals are zero.
`couplingStartTime`	no	`0`	`regionInterfaceType`	If `> 0` and `coupled` is off, coupling is turned on once `time >= couplingStartTime`.

Top-level entries (shared by all interfaces in the file):

Keyword	Required	Default	Description
`interfaceTransferMethod`	no	`AMI`	Patch-to-patch mapping: `AMI` or `directMap` (`RBF` is not compiled; it needs Eigen).
`<interfaceTransferMethod>Coeffs`	yes	–	Must exist (`subDict`), even when empty. Neither `AMI` nor `directMap` reads any entries from it.
`interpolatorUpdateFrequency`	no	`1`	Rebuild period (in time steps) of the mapping for changing interfaces; `0` = never.
`curvatureCorrectedSurfacePatches`	yes	–	Read by the base class for every interface type; use `0()` for heat transfer.

`multiRegionProperties` DNA entry

From tutorials/conjugateHeatTransfer/flowOverHeatedPlate/constant/multiRegionProperties:

regions
(
 (fluid (pimpleFluid transportTemperature) )
 (solid (conductTemperature) )
);

DNA
{
 T
 {
 maxCoupleIter 20;

 residualControl
 {
 maxJumpRes 1e-07;
 outputJumpResField no;
 maxFluxRes 1e-07;
 outputFluxResField no;
 }
 }
}

Boundary conditions

Jump side, fluid (tutorials/conjugateHeatTransfer/flowOverHeatedPlate/0/fluid/orig/partitioned/T):

interface
{
 type regionCoupledTemperatureJump;
 interfaceType (heatTransferInterface);

 accType aitken;
 relax 0.75;

 secondOrder false;
 nonOrthCorr false;
 value $internalField;
}

Flux side, solid (tutorials/conjugateHeatTransfer/flowOverHeatedPlate/0/solid/orig/partitioned/T):

top
{
 type regionCoupledHeatFlux;
 interfaceType (heatTransferInterface);

 secondOrder false;
 nonOrthCorr false;
 value $internalField;
}

Patch keywords common to both BCs:

Keyword	Required	Default	Description
`interfaceType`	yes	–	Interface type list. Only the first entry is used to find the interface (matched by type plus local region/patch), so `heatTransferInterface` must come first.
`diffusivity`	no	`kappa`	Name of the diffusivity field / `transportProperties` entry.
`accType`	no	`fixed` (with a warning)	Acceleration model: `fixed`, `aitken`, `IQNILS`.
`relax`	no	`1.0`	Initial relaxation factor of the acceleration model.
`nonOrthCorr`	no	`false`	Non-orthogonal correction of the coupled `snGrad`.
`secondOrder`	no	`false`	Second-order correction of the coupled `snGrad`.
`neighbourFieldName`	no	local field name	Read and written, but not used by these two BCs (see above).
`value`	–	–	Initial patch value.

The tutorials put the jump BC on the fluid side and the flux BC on the solid side. The opposite assignment is not forbidden by the code, but the flux BC refCasts the neighbour patch field to genericRegionCoupledJumpFvPatchField, so the two sides must use one jump BC and one flux BC.

Known Limitations

Partitioned only. The monolithic solve in multiRegionSystem::solve() is commented out (“need to be ported”). The *Monolithic variants of flowOverHeatedPlate and ShellAndTubeHeatExchanger (BCs monolithicTemperature, monolithicThermalDiffusivitySlave) are compiled but do not drive a monolithic solve at present.
Constant, uniform jump coefficient. jumpCoefficient is a single dimensionedScalar, read once. It cannot vary in space or time. The generic jump BC’s jumpCoefficient patch keyword (field lookup) is not used by regionCoupledTemperatureJump, which overrides valueJump().
No interface physics. correct() and info() are empty, and getMinDeltaT() returns GREAT. There is no contact resistance, no radiation and no interfacial heat source (fluxJump() is always zero).
No unit/consistency check on the diffusivity. The flux balance uses whatever field the diffusivity name resolves to on each side. For example, laplacianFluid provides DT in m²/s, while conductTemperature provides kappa in W/(m K). Mixing them silently gives a non-conservative coupling (inferred from the code).
Missing diffusivity is a fatal error. If neither a kappa field nor a kappa entry in the region’s transportProperties exists, the lookup in diffCoeff() stops the run.
Same patch names on both sides (inferred, untested). interfaceToInterfaceCoupleManager::nbrMesh()/nbrPatch() and interpolateFromNbrField() decide the side by comparing patch names only with patchA. If both coupled patches have the same name in their regions (e.g. interface/interface), side B would resolve itself as its own neighbour. All shipped tutorials use different names.
interfaceTransferMethod is global. It and its Coeffs sub-dictionary are read from the top level of regionInterfaceProperties, so all interfaces in a case share one mapping method.
neighbourFieldName has no effect on regionCoupledTemperatureJump / regionCoupledHeatFlux. The neighbour field is always looked up by the local field name.

Tutorials

Tutorial	Description
`tutorials/conjugateHeatTransfer/flowOverHeatedPlate`	Laminar flow over a heated plate: `fluid (pimpleFluid transportTemperature)` / `solid (conductTemperature)`, `directMap` transfer. Partitioned (`-p`) and monolithic (`-m`) dictionaries are provided.
`tutorials/conjugateHeatTransfer/ShellAndTubeHeatExchanger`	Two fluid regions (`inner`, `outer`) coupled to one `solid` through two `heatTransferInterface`s, `AMI` transfer, `nonOrthCorr true`. Partitioned and monolithic dictionaries are provided.
`tutorials/fluidStructureInteraction/heatedBeamInCrossFlow`	Thermo-FSI: `heatTransferInterface` stacked with `fsiInterface` on one patch pair (`solidStVK conductTemperature` solid), `directMap` transfer.

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

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

Overview

laplacianFluid solves the transient diffusion equation for a scalar field T on a static mesh. It is a direct port of the stock OpenFOAM laplacianFoam solver into the regionType framework: no velocity field, no pressure-velocity coupling, and no mesh motion are involved — only a single diffusion equation with a constant or field diffusivity DT. Despite the name T, the field is a generic passive scalar and can represent temperature or any other diffusing quantity. It is suitable as a lightweight standalone conduction region, or as one side of a multi-region coupling where only diffusive transport of a scalar is required.

Governing Equations

Diffusion

$$ \frac{\partial T}{\partial t} - \nabla \cdot \left( D_T \, \nabla T \right) = S_T $$

Symbol	Description	Unit
$T$	Transported scalar (e.g. temperature)	K (or scalar-dependent)
$D_T$	Diffusivity	m²/s
$S_T$	Source term (from `fvOptions`)	[T]/s

There is no continuity or momentum equation — laplacianFluid has no velocity field and does not support advection.

Numerical Algorithm

laplacianFluid does not run its own outer solve loop. usesPIMPLE() returns false, and solveRegion(), prePredictor(), momentumPredictor(), pressureCorrector(), and meshMotionCorrector() are all no-ops. Instead:

setCoupledEqns("T") assembles the diffusion equation as an fvScalarMatrix and registers it with multiRegionSystem.
The equation is solved through the standard coupled-matrix path (multiRegionSystem::assembleAndSolveEqns<scalar>("T")), the same mechanism used for DNA-coupled partitioned fields.
getMinDeltaT() returns GREAT, i.e. this region never constrains the global time step — deltaT must be set explicitly (no diffusion-number based adjustable time-stepping is implemented).
On write steps only, postSolve() recomputes the derived output fields gradTx, gradTy, gradTz, and DTgradT = DT * grad(T) if writeGradT is enabled (mirrors laplacianFoam’s write.H).

Non-orthogonal correction caveat: stock laplacianFoam wraps its solve in a while (simple.correctNonOrthogonal()) loop. The coupled-matrix solve path used here has no equivalent non-orthogonal corrector loop, so results will differ from laplacianFoam on non-orthogonal meshes. The closest substitute is the region’s Picard corrector (maxCorr / convergenceTolerance in fvSolution), which re-invokes setCoupledEqns() per iteration.

Sub-Models

Sub-model	Selection mechanism	Notes
`fvOptions`	`system/fvOptions`	Explicit/implicit source terms for `T`

No turbulence, transport-model, or MRF sub-models are used.

Required Fields

Field	Type	Description	Unit
`T`	`volScalarField`	Transported scalar	—
`DT`	`volScalarField`	Diffusivity — read if present, otherwise created uniform from `transportProperties`	m²/s

Additionally created at runtime if writeGradT is enabled (default true):

Field	Type	Description
`gradTx`, `gradTy`, `gradTz`	`volScalarField`	Components of $\nabla T$
`DTgradT`	`volVectorField`	Diffusive flux $D_T \nabla T$

Case Setup

Required dictionaries

constant/transportProperties – diffusivity (DT), if no DT field is supplied
system/fvSolution – T solver settings, SIMPLE.writeGradT flag
system/fvSchemes – discretisation schemes

`multiRegionProperties` entry

regions
(
 ( scalarRegion (laplacianFluid) )
);

`controlDict` (singleRegionMode)

singleRegionMode yes;
regionType laplacianFluid;

Key `fvSolution` settings

solvers
{
 T
 {
 solver PCG;
 preconditioner DIC;
 tolerance 1e-06;
 relTol 0;
 }
}

SIMPLE
{
 writeGradT true; // write grad(T) components and DT*grad(T) at write time
}

`transportProperties`

DT 4e-05; // uniform diffusivity, used if no DT field is present

Coupling

laplacianFluid exposes T via selfCoupledFieldNames(), so it is solved standalone and can also participate as a pure-diffusion side in multi-region interfaces (unlike conductTemperature, whose T is only solved through partitioned coupling):

Interface type	Exchanged fields	Coupling modes
`heatTransferInterface`	`T`, heat flux `q`	partitioned (DNA)
`defaultInterface`	`T`	partitioned (DNA)

Known Limitations

Static mesh only — meshMotionCorrector() is a no-op; moving/deforming meshes are not supported.
No non-orthogonal corrector loop — unlike laplacianFoam, the coupled solve path used here does not iterate over non-orthogonal correctors within a single time step; see the numerical algorithm note above for the workaround.

Tutorials

Tutorial path	Description
`tutorials/singleRegion/laplacianFluid/flange`	Classic OpenFOAM “flange” thermal conduction case (single-region, fixed 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

Docs: regionCoupledHeatFlux

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

Overview

regionCoupledHeatFlux is the flux side (Neumann side) of the temperature coupling used with heatTransferInterface for conjugate heat transfer and thermo-FSI. It derives from genericRegionCoupledFlux<scalar> (and so from fixedGradient). It fixes the normal temperature gradient so that the local conductive heat flux is equal and opposite to the heat flux of the value-side partner on the neighbour region, without an interfacial source. The partner must be a genericRegionCoupledJump<scalar>-derived BC, in practice regionCoupledTemperatureJump. Unlike its partner, this BC does not check the interface type (see Implementation).

Mathematical Formulation

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

$$ \kappa_A \frac{\partial T_A}{\partial n_A} + \kappa_B \frac{\partial T_B}{\partial n_B} = 0 \quad \text{on } \Gamma $$

imposed as the gradient

$$ \left.\frac{\partial T_B}{\partial n}\right|_b = -\frac{\mathcal{I}_{A\to B}\!\left(\kappa_A\, \partial_n T_A\right)}{\kappa_B} $$

followed by relaxation with the acceleration model. fluxJump() returns zero.

Symbol	Description	Unit
$T$	Temperature (field `T` in both regions)	K
$\kappa_B$	Diffusivity named by `diffusivity`, default `kappa`	W/(m K)
$\kappa_A\,\partial_n T_A$	`flux()` of the jump-side partner	W/m²
$\mathcal{I}_{A\to B}$	Interface-to-interface interpolation	–

Implementation

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

fluxJump(): returns a zero field.
diffusivityName(): the diffusivity keyword if set, otherwise kappa. diffCoeff() uses a volScalarField with that name on the local region if one is registered, otherwise a uniform dimensionedScalar from the region’s transportProperties.
heatTransInterface(): a type check plus cast to heatTransferInterface, as in regionCoupledTemperatureJump. It is declared and defined but never called, so the BC accepts any interface type listed first in interfaceType.

Per DNA iteration of T, updateCoeffs() updates the interface, refCasts the neighbour T patch field to genericRegionCoupledJumpFvPatchField<scalar>, interpolates and negates its flux(), divides by the local $\kappa$, relaxes the gradient and fixes it. evaluate() sets the patch temperature from the gradient (with the optional non-orthogonal and second-order corrections). The flux residual $|\kappa_B g_B + \mathcal{I}(q_A)|$ is checked against maxFluxRes.

Dictionary Entries

Keyword	Description	Required	Default
`type`	`regionCoupledHeatFlux`	yes	—
`interfaceType`	Interface type list; the first entry selects the interface (normally `heatTransferInterface`; not checked)	yes	—
`diffusivity`	Name of the thermal conductivity field / `transportProperties` entry	no	`kappa`
`neighbourFieldName`	Read and written, not used	no	local field name (`T`)
`accType`	`fixed`, `aitken` or `IQNILS`	no	`fixed` (with warning)
`relax`	Initial / fixed relaxation factor	no	`1.0`
`couplingReuse`	`IQNILS` only: reused time steps	no	`0`
`nonOrthCorr`	Non-orthogonal correction in `evaluate()`	no	`false`
`secondOrder`	Second-order value evaluation	no	`false`
`gradient`	Initial gradient; if given, the initial patch value is evaluated from it	no	zero
`value`	Not read (only written)	no	—

Usage

From tutorials/fluidStructureInteraction/heatedBeamInCrossFlow/0/solid/orig/partitioned/T:

interface
{
 type regionCoupledHeatFlux;
 interfaceType (heatTransferInterface);
 diffusivity "kappa";
 secondOrder false;
 nonOrthCorr false;
 value $internalField;
}

Partner in 0/fluid/orig/partitioned/T:

interfaceShadow
{
 type regionCoupledTemperatureJump;
 interfaceType (heatTransferInterface);
 diffusivity "kappa";
 accType aitken;
 relax 0.75;
 secondOrder false;
 nonOrthCorr false;
 value $internalField;
}

Interface in constant/regionInterfaceProperties (heat transfer stacked on FSI):

fluidsolid
{
 interfaceType (fsiInterface heatTransferInterface);
 coupledPatchPair
 (
 (fluid interfaceShadow)
 (solid interface)
 );
 coupledFields
 (
 D
 T
 );
 coupled yes;
 fsiInterfaceCoeffs
 {}
 heatTransferInterfaceCoeffs
 {
 jumpCoefficient jumpCoefficient [ 0 0 0 0 0 0 0 ] 1;
 }
}

Known Limitations

No interface-type check. heatTransInterface() is never called, so a wrong first interfaceType entry is not caught here. It is usually caught by the partner regionCoupledTemperatureJump, which does check.
Partner must be a jump BC of T (bad-cast error otherwise).
No interfacial heat source or contact resistance: fluxJump() is zero. For phase change use regionCoupledPhaseChangeHeatFlux.
No unit check on kappa across the two regions.
value is ignored on input and gradient is not written (restart starts from a zero gradient).
First relaxation uses the patch values as reference (inherited; the tutorials use the default fixed/relax 1 on this side, where it has no effect).
Inherited from genericRegionCoupledFlux: neighbourFieldName unused, corrections only in the evaluated value, IQNILS not parallel-consistent, partitioned only.

Tutorials

Tutorial	Description
`tutorials/conjugateHeatTransfer/flowOverHeatedPlate`	Solid side (`conductTemperature`, patch `top`), default `kappa`, no relaxation.
`tutorials/conjugateHeatTransfer/ShellAndTubeHeatExchanger`	Solid side towards both fluids (`solid_to_inner`, `solid_to_outer`), `nonOrthCorr true`, `AMI`.
`tutorials/fluidStructureInteraction/heatedBeamInCrossFlow`	Solid side (`solidStVK conductTemperature`) of the thermo-FSI interface.

References

Alkfri, A., Habes, C., Marschall, H., multiRegionFoam: A Unified Multiphysics Framework for Multi-Region Coupled Continuum-Physical Problems, Engineering with Computers, 2023. DOI: 10.1007/s00366-024-01974-4

Docs: regionCoupledPhaseChangeHeatFlux

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

Overview

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

Mathematical Formulation

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

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

imposed as the gradient

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

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

$$ q_{sat} = k_A \left.\frac{\partial T_A}{\partial n_A}\right|_{T_\Gamma = T_{sat}} + k_B \left.\frac{\partial T_B}{\partial n_B}\right|_{T_\Gamma = T_{sat}}, \qquad \dot m = -\frac{q_{sat}}{h_{lv}} $$

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

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

Implementation

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

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

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

Dictionary Entries

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

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

Usage

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

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

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

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

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

Known Limitations

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

Tutorials

Tutorial	Description
—	No tutorial uses `regionCoupledPhaseChangeHeatFlux`.

References

Alkfri, A., Habes, C., Marschall, H., multiRegionFoam: A Unified Multiphysics Framework for Multi-Region Coupled Continuum-Physical Problems, Engineering with Computers, 2023. DOI: 10.1007/s00366-024-01974-4

Docs: regionCoupledTemperatureJump

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

Overview

regionCoupledTemperatureJump is the value side (Dirichlet side) of the temperature coupling of heatTransferInterface, used for conjugate heat transfer and thermo-FSI. It derives from genericRegionCoupledJump<scalar> (and so from fixedValue). It fixes the patch temperature to the neighbour temperature, interpolated onto this patch and scaled by the interface’s jumpCoefficient $c$ ($c = 1$: temperature continuity). It also supplies its heat flux $\kappa\,\partial T/\partial n$ to the partner regionCoupledHeatFlux on the neighbour region. The interface found through the first interfaceType entry must be a heatTransferInterface.

Mathematical Formulation

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

$$ T_A = c\;\mathcal{I}_{B\to A}(T_B) \quad \text{on } \Gamma $$

implemented as $T_A = \mathcal{I}_{B\to A}(T_B) + j$ with

$$ j = \mathcal{I}_{B\to A}(T_B)\,(c - 1), $$

followed by relaxation with the acceleration model. The heat flux handed to regionCoupledHeatFlux is

$$ q_A = \kappa_A \left.\frac{\partial T_A}{\partial n}\right|_b $$

with the coupled snGrad of genericRegionCoupledJump (optional non-orthogonal and second-order corrections).

Symbol	Description	Unit
$T$	Temperature (field `T` in both regions)	K
$c$	`heatTransferInterfaceCoeffs/jumpCoefficient` (uniform, constant)	–
$\kappa_A$	Diffusivity named by `diffusivity`, default `kappa`	W/(m K)
$\mathcal{I}_{B\to A}$	Interface-to-interface interpolation	–

Implementation

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

valueJump(): looks up the neighbour T under the local field name, interpolates its neighbour patch values, and returns $\mathcal{I}(T_B)\,(c - 1)$. Here $c$ is heatTransInterface().jumpCoefficient().value(), a single scalar.
heatTransInterface(): checks that the interface matched through the first interfaceType entry has type heatTransferInterface, otherwise FatalError (“BC can only be used in combination with a heatTransferInterface”). It is called from valueJump(), so the check runs on the first updateCoeffs() and on every residual evaluation.
diffusivityName(): returns the diffusivity keyword if set, otherwise kappa. diffCoeff() uses the volScalarField with this name on the local region if one is registered, else a uniform dimensionedScalar of that name from the region’s transportProperties.

Per DNA iteration of T: the interface is updated (its correct() is a no-op), the value $\mathcal{I}(T_B) + j$ is set, relaxed (accType, relax) and fixed. The jump residual $|T_A - \mathcal{I}(T_B) - j|$ is checked against maxJumpRes.

Dictionary Entries

Keyword	Description	Required	Default
`type`	`regionCoupledTemperatureJump`	yes	—
`interfaceType`	Interface type list. The first entry must be `heatTransferInterface`.	yes	—
`diffusivity`	Name of the thermal conductivity field / `transportProperties` entry	no	`kappa`
`neighbourFieldName`	Read and written, not used	no	local field name (`T`)
`jumpCoefficient`	Read by the base class but ignored (the coefficient comes from the interface)	no	`word::null`
`accType`	`fixed`, `aitken` or `IQNILS`	no	`fixed` (with warning)
`relax`	Initial / fixed relaxation factor	no	`1.0`
`couplingReuse`	`IQNILS` only: reused time steps	no	`0`
`nonOrthCorr`	Non-orthogonal correction of `snGrad`	no	`false`
`secondOrder`	Second-order `snGrad`	no	`false`
`value`	Initial patch value (read if present, otherwise uninitialised)	effectively yes	—

Usage

From tutorials/conjugateHeatTransfer/flowOverHeatedPlate/0/fluid/orig/partitioned/T:

interface
{
 type regionCoupledTemperatureJump;
 interfaceType (heatTransferInterface);

 accType aitken;
 relax 0.75;

 secondOrder false;
 nonOrthCorr false;
 value $internalField;
}

Partner in 0/solid/orig/partitioned/T:

top
{
 type regionCoupledHeatFlux;
 interfaceType (heatTransferInterface);

 secondOrder false;
 nonOrthCorr false;
 value $internalField;
}

Interface in constant/regionInterfacePropertiesPartitioned:

partitionedCoupledPatches
(
 fluidsolid
 {
 interfaceType (heatTransferInterface);
 coupledPatchPair
 (
 (fluid interface)
 (solid top)
 );
 coupledFields
 (
 T
 );
 heatTransferInterfaceCoeffs
 {
 jumpCoefficient jumpCoefficient [ 0 0 0 0 0 0 0 ] 1;
 }
 }
);

and the T entry in the DNA block of constant/multiRegionProperties (maxCoupleIter, maxJumpRes, maxFluxRes). For thermo-FSI the interface entry lists interfaceType (fsiInterface heatTransferInterface);, while the T patches keep interfaceType (heatTransferInterface); (tutorials/fluidStructureInteraction/heatedBeamInCrossFlow).

Known Limitations

Needs heatTransferInterface first in the BC’s interfaceType list; any other type aborts in valueJump().
Constant, uniform jump coefficient. $c$ is a single dimensionedScalar read once by the interface. The jumpCoefficient patch keyword (field lookup) of regionCoupledScalarJump is not used here.
No unit check on kappa. The flux balance with the partner only conserves energy if both sides name conductivities in the same units (e.g. not DT in m²/s on one side).
Missing diffusivity is fatal when the partner first asks for flux() (no kappa field and no kappa in transportProperties).
Inherited from genericRegionCoupledJump: neighbourFieldName unused, side detection by patch name only, acceleration state carried over time steps, IQNILS not parallel-consistent, partitioned only (the *Monolithic tutorial variants use other BCs).

Tutorials

Tutorial	Description
`tutorials/conjugateHeatTransfer/flowOverHeatedPlate`	Fluid side of `fluid (pimpleFluid transportTemperature)` / `solid (conductTemperature)`, Aitken 0.75, `directMap`.
`tutorials/conjugateHeatTransfer/ShellAndTubeHeatExchanger`	Fluid side on `inner_to_solid` and `outer_to_solid`, `nonOrthCorr true`, default `fixed` relaxation, `AMI`.
`tutorials/fluidStructureInteraction/heatedBeamInCrossFlow`	Fluid side of the thermo-FSI interface (`diffusivity "kappa"`, Aitken 0.75), stacked with `fsiInterface`.

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

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

Overview

rhoPimpleFluid solves the transient, compressible Navier-Stokes equations for a Newtonian single-phase fluid with the PIMPLE (merged PISO–SIMPLE) pressure-velocity coupling algorithm. It is a port of OpenFOAM’s rhoPimpleFoam: density follows from a run-time selectable thermophysical model (fluidThermo), and an energy equation for sensible enthalpy or internal energy is solved alongside momentum. It supports compressible turbulence modelling (laminar, RANS, LES), a transonic pressure formulation, local time stepping (LTS), moving meshes, MRF and fvOptions. It is suitable for subsonic to supersonic gas flows, standalone or as the fluid side of a multi-region problem.

Governing Equations

Continuity

$$ \frac{\partial \rho}{\partial t} + \nabla \cdot \left(\rho\mathbf{U}\right) = S_\rho $$

Momentum

$$ \frac{\partial \left(\rho\mathbf{U}\right)}{\partial t} + \nabla \cdot \left(\rho\mathbf{U}\mathbf{U}\right) - \nabla \cdot \mathbf{R} = -\nabla p + \mathbf{S}_U $$

The effective stress divergence is provided by the turbulence model via compressible::turbulenceModel::divDevRhoReff(U).

Energy

The energy variable $e$ is either sensible enthalpy $h$ or sensible internal energy $e$, selected by the energy keyword in thermophysicalProperties. With $K = \tfrac{1}{2}|\mathbf{U}|^2$:

$$ \frac{\partial \left(\rho h\right)}{\partial t} + \nabla \cdot \left(\rho\mathbf{U}h\right) + \frac{\partial \left(\rho K\right)}{\partial t} + \nabla \cdot \left(\rho\mathbf{U}K\right) - \frac{\partial p}{\partial t} - \nabla \cdot \left(\alpha_\text{eff}\nabla h\right) = S_h $$

For internal energy the pressure-work term $-\partial p/\partial t$ is replaced by $\nabla \cdot \left(p\,\mathbf{U}\right)$ (div(phiv,p)). The $\partial p/\partial t$ term is only included if dpdt is enabled in the thermophysical model (default yes). With active MRF zones the term $\nabla \cdot (\phi_\text{MRF}\,p)$ is added.

Equation of state

Density is closed by the thermophysical model, $\rho = \rho(p, T)$, with compressibility $\psi = \partial\rho/\partial p$ used in the pressure equation.

Symbol	Description	Unit
$\rho$	Density	kg/m³
$\mathbf{U}$	Velocity	m/s
$p$	(Static) pressure	Pa
$T$	Temperature	K
$h$, $e$	Sensible enthalpy / internal energy	J/kg
$K$	Specific kinetic energy	m²/s²
$\psi$	Compressibility	s²/m²
$\mathbf{R}$	Effective stress tensor (viscous + turbulent)	Pa
$\alpha_\text{eff}$	Effective thermal diffusivity (laminar + turbulent)	kg/(m·s)
$S_\rho$, $\mathbf{S}_U$, $S_h$	Sources (from `fvOptions`)	—

Stress tensor (for FSI coupling)

After each pressure-correction stage the Cauchy stress tensor is updated:

$$ \boldsymbol{\sigma} = -p\,\mathbf{I} - \mathbf{R}^\text{dev} $$

where $\mathbf{R}^\text{dev}$ is turbulence::devRhoReff(). Since $p$ is the static pressure in Pa, no density scaling is applied (unlike pimpleFluid).

Numerical Algorithm

The region implements the regionType PIMPLE interface (usesPIMPLE() = true), so the outer PIMPLE loop is driven by multiRegionSystem. Per time step:

correct() — reset the outer-iteration counter; if correctPhi is active, snapshot $\nabla\cdot(\rho\mathbf{U})$ for flux correction; if LTS is active, recompute the local time-step field rDeltaT (see below).
Pre-predictor — on the first outer iteration of the step (or every iteration with moveMeshOuterCorrectors yes): mesh.controlledUpdate(); if the mesh changed, update MRF, rebuild the flux from rhoUf, apply CorrectPhi, make the flux relative and correct rhoUf; optionally print the mesh Courant number.
Momentum predictor —
- on the first outer iteration and unless SIMPLErho is set, solve the density transport equation;
- assemble the momentum matrix (cached for the pressure corrector), relax, and solve it with $-\nabla p$ if momentumPredictor yes; update $K$;
- assemble and solve the energy equation, then thermo.correct().
Pressure corrector (PISO loop, nCorrectors) — for each corrector: update $\rho$ from thermo (unless SIMPLErho), build $\mathbf{H}/A$ and $\phi_{HbyA}$ (with ddtCorr, MRF and mesh-motion corrections, optional consistent SIMPLEC treatment), constrain pressure BCs, and solve the compressible pressure equation inside the non-orthogonal loop:

$$ \frac{\partial \rho}{\partial t} + \psi\,\frac{\partial p'}{\partial t} + \nabla\cdot\phi_{HbyA} - \nabla\cdot\left(\rho\, r_{AU}\,\nabla p\right) = S_p $$

With transonic yes the flux is split into a convective part $\phi_d = (\psi_f/\rho_f)\,\phi_{HbyA}$ treated implicitly ($\nabla\cdot(\phi_d\,p)$) and the pressure equation is relaxed for diagonal dominance. Afterwards: explicit pressure relaxation, velocity correction $\mathbf{U} = \mathbf{H}/A - r_{AU}\nabla p$, pressure limiting (pressureControl), thermo.correctRho with rhoMin/rhoMax, a second density solve, continuity-error report, $\rho$ reset to thermo, rhoUf correction and $\partial p/\partial t$ update. 5. Turbulence correction — turbulence->correct() if pimple.turbCorr() (see turbOnFinalIterOnly), then update of sigma.

Steps 2–5 are repeated for nOuterCorrectors outer iterations; step 4 for nCorrectors inner iterations.

Mesh motion corrector (meshMotionCorrector(), called by multiRegionSystem::preSolve and in the FSI coupling loop) performs controlledUpdate, MRF update, flux reconstruction from rhoUf + CorrectPhi, and rhoUf correction.

Time-step control

Global time stepping — getMinDeltaT() returns $\Delta t_\text{max} = \text{maxCo}/\text{Co}\;\Delta t$, where the Courant number is evaluated from the mass flux, $\text{Co} = \tfrac{1}{2}\max\left(\sum_f|\phi|/(\rho V)\right)\Delta t$. maxCo is read from controlDict (default 1.0).
Local time stepping (LTS) — enabled automatically when fvSchemes selects ddtSchemes { default localEuler; }. getMinDeltaT() then returns GREAT (the global step is left untouched) and rDeltaT is computed per cell from the Courant number (plus an acoustic estimate with transonic), then smoothed and damped, as in stock rhoPimpleFoam.

Sub-Models

Sub-model	Selection mechanism	Notes
Thermophysical model	`constant/thermophysicalProperties`	`fluidThermo::New`; `hePsiThermo` or `heRhoThermo`; energy must be `h` or `e` variant
Turbulence (laminar / RANS / LES)	`constant/turbulenceProperties`	`compressible::turbulenceModel`
Moving Reference Frame (MRF)	`constant/MRFProperties`	`IOMRFZoneList`
`fvOptions`	`system/fvOptions` (or `constant/fvOptions`)	Sources/constraints on $\rho$, $\mathbf{U}$, $h$/$e$, $p$ (e.g. `limitTemperature`)
Dynamic mesh	`constant/dynamicMeshDict`	Any `dynamicFvMesh`; enables `rhoUf` and `correctPhi`

Required Fields

Field	Type	Description	Unit
`p`	`volScalarField`	Pressure (read by thermo)	Pa
`T`	`volScalarField`	Temperature (read by thermo)	K
`U`	`volVectorField`	Velocity	m/s
Turbulence fields	—	As required by selected model (e.g. `k`, `omega`, `nut`, `alphat`)	—

Additionally created at runtime:

Field	Type	Description	Condition
`rho`	`volScalarField`	Density (read if present, else from thermo)	always
`phi`	`surfaceScalarField`	Mass flux $\rho\mathbf{U}\cdot\mathbf{S}_f$ (read if present)	always
`K`	`volScalarField`	Kinetic energy $\tfrac12	\mathbf{U}
`dpdt`	`volScalarField`	$\partial p/\partial t$	always (zero if `dpdt no`; written only on dynamic meshes)
`kappa`	`volScalarField`	Effective thermal conductivity `kappaEff`	always (heat-transfer coupling)
`sigma`	`volSymmTensorField`	Cauchy stress tensor	always (FSI)
`rhoUf`	`surfaceVectorField`	Face momentum	dynamic mesh only
`rDeltaT`	`volScalarField`	Reciprocal local time step	LTS only
`uniform/cumulativeContErr`	`uniformDimensionedScalarField`	Cumulative continuity error	always

Case Setup

Required dictionaries

constant/thermophysicalProperties – thermo type, mixture properties
constant/turbulenceProperties – turbulence model selection
system/fvSolution – PIMPLE sub-dict and linear solver settings
system/fvSchemes – discretisation schemes (localEuler → LTS)

`multiRegionProperties` entry

regions
(
 ( gas (rhoPimpleFluid) )
);

`controlDict` (singleRegionMode)

application multiPhysicsFoam;
singleRegionMode yes;
regionType rhoPimpleFluid;

`thermophysicalProperties` (from `aerofoilNACA0012`)

thermoType
{
 type hePsiThermo;
 mixture pureMixture;
 transport const;
 thermo hConst;
 equationOfState perfectGas;
 specie specie;
 energy sensibleInternalEnergy; // or sensibleEnthalpy
}

mixture
{
 specie { molWeight 28.9; }
 thermodynamics { Cp 1005; Hf 0; }
 transport { mu 1.82e-05; Pr 0.71; }
}

Key `fvSolution` settings

PIMPLE
{
 momentumPredictor yes;
 nOuterCorrectors 1;
 nCorrectors 2;
 nNonOrthogonalCorrectors 1;

 transonic no; // implicit convective pressure term
 consistent no; // SIMPLEC-like correction
 SIMPLErho no; // skip rho transport, take rho from thermo
 turbOnFinalIterOnly true;

 // Pressure limits (pressureControl): pMin/pMax or pMinFactor/pMaxFactor
 pMinFactor 0.1;
 pMaxFactor 2;

 // Density bounds for thermo.correctRho
 rhoMin 0; // default 0
 rhoMax 1e5; // default GREAT

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

 // LTS only (ddtSchemes default localEuler)
 maxCo 0.5; // default 0.8
 rDeltaTSmoothingCoeff 0.1; // default 0.02
 rDeltaTDampingCoeff 0.9; // default 1.0 (no damping)
 maxDeltaT 1; // default GREAT
}

Adjustable time stepping (`controlDict`)

adjustTimeStep yes;
maxCo 0.5; // default 1.0
maxDeltaT 1e-4;

Coupling

Interface type	Exchanged fields	Coupling modes
`heatTransferInterface`	Temperature `T`, heat flux via `kappa`	partitioned (DNA)
`fsiInterface`	Displacement `D`, traction from `sigma`	partitioned (DNA)
`defaultInterface`	Any scalar (generic `regionCoupledScalarJump`/`Flux` BCs)	partitioned (DNA)

For partitioned heat transfer, setCoupledEqns assembles a separate temperature equation (independent of the fieldName argument):

$$ \frac{\partial \left(\rho c_{pv} T\right)}{\partial t} + \nabla\cdot\left(c_{pv,f}\,\phi\,T\right) = \nabla\cdot\left(\kappa_\text{eff}\nabla T\right) $$

with $c_{pv} = $ thermo.Cpv() and kappa refreshed from turbulence->kappaEff() on each call. The matrix is registered as T<region>MeshrhoPimpleFluidTypeEqn. The regionCoupledTemperatureJump / regionCoupledHeatFlux BCs read the diffusivity field kappa by default. selfCoupledFieldNames() is not overridden (empty list).

Known Limitations

Coupled temperature equation is decoupled from the energy equation — the DNA T equation in setCoupledEqns contains no pressure-work, kinetic-energy, MRF or fvOptions terms, and postSolve() is a no-op, so thermo.correct() is not called after the coupled T solve and he is not updated from the new T.
Heat-transfer and FSI coupling are untested — no multi-region tutorial uses rhoPimpleFluid; only single-region cases exist.
Monolithic coupling not implemented — setCoupledEqns only provides the partitioned T matrix; monolithic coupling is disabled in multiRegionSystem.
solveRegion() and postSolve() are no-ops — all work happens inside the PIMPLE hooks.
maxDeltaT not applied in getMinDeltaT() — maxDeltaT from controlDict is read but the returned value is only Courant-based.
Mesh motion corrector does not make the flux relative — unlike prePredictor, meshMotionCorrector() does not call fvc::makeRelative after CorrectPhi.
Single phase, single species — reacting or multi-species mixtures and buoyancy (gravity, p_rgh) are not handled; use buoyantPimpleFluid for buoyancy-driven flows.

Tutorials

Tutorial path	Description
`tutorials/singleRegion/rhoPimpleFluid/aerofoilNACA0012`	Compressible RANS (kOmegaSST) flow around a NACA0012 aerofoil, internal energy, `limitTemperature` fvOption
`tutorials/singleRegion/rhoPimpleFluid/obliqueShock`	Laminar supersonic oblique shock with `transonic` formulation and LTS (`localEuler`)

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

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

Overview

transportTemperature adds a temperature equation to a fluid region. It does not solve for the flow itself: it is stacked on top of a flow region type in the same region, e.g. (fluid (pimpleFluid transportTemperature)), and advects T with the velocity U and face flux phi that the companion region type owns. Material properties (rho, cp, kappa) are constant (kappa may be a non-uniform field). There is no turbulent heat flux; the turbulent variant turbulentTransportTemperature exists in the source tree but is not compiled (see Known Limitations). The typical use is the fluid side of conjugate heat transfer, coupled to conductTemperature through heatTransferInterface.

Governing Equations

Energy (temperature)

$$ \rho\, c_p \left( \frac{\partial T}{\partial t} + \nabla \cdot \left( \phi\, T \right) \right) = \nabla \cdot \left( \kappa\, \nabla T \right) $$

Symbol	Description	Unit
$T$	Temperature	K
$\phi$	Volumetric face flux (`phi`) from the companion fluid region type	m³/s
$\rho$	Density (constant)	kg/m³
$c_p$	Specific heat capacity (constant)	J/(kg K)
$\kappa$	Thermal conductivity (uniform or field)	W/(m K)

The convective term is written in conservative form $\nabla \cdot (\phi T)$ without a $-T\,\nabla\cdot\phi$ correction, so it assumes a divergence-free (incompressible, volumetric) flux. There is no source term and no viscous heating.

Numerical Algorithm

transportTemperature has no solution loop of its own. usesPIMPLE() returns false, and solveRegion(), prePredictor(), momentumPredictor(), pressureCorrector(), meshMotionCorrector() and postSolve() are all no-ops. Per time step:

preSolve(): correct() calls kappa.correctBoundaryConditions().
The companion fluid region type solves its flow (e.g. the PIMPLE loop of pimpleFluid), which updates the shared U and phi.
Inside the DNA loop for T, multiRegionSystem calls setCoupledEqns(), which assembles the equation above as an fvScalarMatrix and registers it under T<region>MeshtransportTemperatureTypeEqn. The matrix is then relaxed (relaxationFactors) and solved, with optional Picard re-assembly controlled by the region’s PICARD dictionary in fvSolution.
getMinDeltaT() returns GREAT, so this region never limits the time step. Time-step control comes from the companion fluid type (Courant number) or a fixed deltaT.

The temperature is therefore advanced once per time step, after the flow, using the flux from the end of the flow solve (one-way, segregated coupling from flow to temperature; T does not feed back into the flow).

setCoupledEqns() ignores its fieldName argument and always assembles the T equation. selfCoupledFieldNames() is not overridden (returns an empty list), so T is only solved if it is listed as a partitioned-coupled field (a DNA { T {...} } entry in multiRegionProperties and T in an interface’s coupledFields).

Sub-Models

None. transportTemperature does not construct fvOptions, a turbulence model, or a thermophysical model.

Required Fields

How each field is obtained:

Field	Type	Description	Unit	Source
`U`	`volVectorField`	Velocity	m/s	Looked up from the mesh registry (provided by the companion fluid type); read from `0/<region>/U` (`MUST_READ`) if not registered yet
`phi`	`surfaceScalarField`	Volumetric face flux	m³/s	Looked up from the registry; otherwise read if a `phi` file exists, else created as `interpolate(U) & Sf`
`T`	`volScalarField`	Temperature	K	Looked up from the registry, otherwise read from `0/<region>/T` (`MUST_READ`, written)
`kappa`	`volScalarField`	Thermal conductivity	W/(m K)	Looked up from the registry, otherwise read from `0/<region>/kappa` if present, else created uniform from `transportProperties` (written)

Because fields are looked up from the mesh registry first, the companion region type must be listed before transportTemperature so that it creates U and phi; every tutorial does this.

The coupling boundary conditions regionCoupledTemperatureJump and regionCoupledHeatFlux look up the diffusivity field kappa by default (or the name given by their diffusivity keyword), which matches the field this region type registers.

Case Setup

Required dictionaries

constant/<region>/transportProperties – rho, cp, kappa (all required)
system/<region>/fvSolution – T solver, relaxation factor for T
system/<region>/fvSchemes – ddt(T), div(phi,T), laplacian(kappa,T)

`multiRegionProperties` entry

regions
(
 (fluid (pimpleFluid transportTemperature) )
 (solid (conductTemperature) )
);

DNA
{
 T
 {
 maxCoupleIter 20;

 residualControl
 {
 maxJumpRes 1e-07;
 outputJumpResField no;
 maxFluxRes 1e-07;
 outputFluxResField no;
 }
 }
}

`transportProperties`

All three entries are read with dimensionedScalar(name, dict) and have no defaults. They can share the dictionary with the companion fluid type’s entries (transportModel, nu):

rho rho [1 -3 0 0 0 0 0] 1;
cp cp [0 2 -2 -1 0 0 0] 500.0;
kappa kappa [1 1 -3 -1 0 0 0] 5.0;

Key `fvSolution` settings

solvers
{
 T
 {
 solver GAMG;
 tolerance 1e-7;
 relTol 0;
 smoother GaussSeidel;
 }
}

relaxationFactors
{
 T 1.0;
}

Coupled `T` boundary condition (fluid side, partitioned)

interface
{
 type regionCoupledTemperatureJump;
 interfaceType (heatTransferInterface);
 accType aitken;
 relax 0.75;
 secondOrder false;
 nonOrthCorr false;
 value $internalField;
}

The solid side uses regionCoupledHeatFlux on its interface patch.

Coupling

Interface type	Exchanged fields	Coupling mode
`heatTransferInterface`	`T` (jump on fluid side), heat flux $\kappa \nabla T \cdot \mathbf{n}$ (solid side)	partitioned (DNA)

No interface type accesses transportTemperature directly. Coupling happens through the T boundary conditions above, which read kappa from the region registry. The partner region is conductTemperature in all tutorials, possibly stacked with solidStVK for thermo-FSI.

Companion flow region types: all tutorials use pimpleFluid. Any flow type that registers a volumetric U and phi on the same mesh should work in principle (e.g. icoFluid), but this is untested. rhoPimpleFluid registers a mass flux phi (rho*U & Sf), so it is dimensionally inconsistent with the equation above.

Known Limitations

Only solved as a DNA-coupled field — selfCoupledFieldNames() is not overridden, so without a DNA { T ... } entry the temperature is never solved (in particular not in single-region mode). There is no tutorials/singleRegion/transportTemperature case.
Monolithic coupling not available — monolithic coupling in multiRegionSystem::solve() is currently commented out.
Laminar heat conduction only — no turbulent diffusivity ($\kappa_t$ / Prt). turbulentTransportTemperature (src/regions/turbulentTransportTemperature) adds this but is commented out in src/multiRegionSystem/Make/files and therefore not built.
Constant properties — rho and cp are uniform constants; kappa is read once and only its boundary values are refreshed in correct(). No temperature-dependent properties.
One-way coupling — T has no effect on the flow (no buoyancy). Use buoyantPimpleFluid for natural convection.
Incompressible flux assumed — the convection term has no $\nabla\cdot\phi$ correction and expects a volumetric flux.
No fvOptions — heat sources cannot be added.
No time-step constraint — getMinDeltaT() returns GREAT; no diffusion-number based time-step limit.

Tutorials

Tutorial	Description
`tutorials/conjugateHeatTransfer/flowOverHeatedPlate`	Flow over a heated plate (pimpleFluid + transportTemperature / conductTemperature)
`tutorials/conjugateHeatTransfer/ShellAndTubeHeatExchanger`	Shell-and-tube heat exchanger with two fluid regions (inner, outer) and a solid wall
`tutorials/fluidStructureInteraction/heatedBeamInCrossFlow`	Thermo-FSI: heated beam in cross flow (fluid: pimpleFluid + transportTemperature; solid: solidStVK + conductTemperature; DNA on `D` and `T`)

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 – Heat-Transfer

Docs: conductTemperature

Overview

Governing Equations

Energy (heat conduction)

Numerical Algorithm

Sub-Models

Required Fields

Case Setup

Required dictionaries

multiRegionProperties entry

transportProperties

Key fvSolution settings

Interface boundary condition on T

Coupling

Known Limitations

Tutorials

References

Docs: heatTransferInterface

Overview

Interface Conditions

Jump condition

Flux condition

Implementation

Diffusivity lookup

Coupled Fields

Compatible Region Types

Case Setup

regionInterfaceProperties entry

Keywords

multiRegionProperties DNA entry

Boundary conditions

Known Limitations

Tutorials

References

Docs: laplacianFluid

Overview

Governing Equations

Diffusion

Numerical Algorithm

Sub-Models

Required Fields

Case Setup

Required dictionaries

multiRegionProperties entry

controlDict (singleRegionMode)

Key fvSolution settings

transportProperties

Coupling

Known Limitations

Tutorials

References

Docs: regionCoupledHeatFlux

Overview

Mathematical Formulation

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

Docs: regionCoupledPhaseChangeHeatFlux

Overview

Mathematical Formulation

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

Docs: regionCoupledTemperatureJump

Overview

Mathematical Formulation

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

Docs: rhoPimpleFluid

`multiRegionProperties` entry

`transportProperties`

Key `fvSolution` settings

Interface boundary condition on `T`

`regionInterfaceProperties` entry

`multiRegionProperties` DNA entry

`multiRegionProperties` entry

`controlDict` (singleRegionMode)

Key `fvSolution` settings

`transportProperties`

`multiRegionProperties` entry

`controlDict` (singleRegionMode)

`thermophysicalProperties` (from `aerofoilNACA0012`)

Key `fvSolution` settings

Adjustable time stepping (`controlDict`)

`multiRegionProperties` entry

`transportProperties`

Key `fvSolution` settings

Coupled `T` boundary condition (fluid side, partitioned)