multiPhysicsFoam – Conjugate-Heat-Transfer

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

multiPhysicsFoam – Conjugate-Heat-Transfer

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

Overview

Mathematical Formulation

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

Docs: regionCoupledTemperatureJump

Overview

Mathematical Formulation

Implementation

Dictionary Entries

Usage

Known Limitations

Tutorials

References

`regionInterfaceProperties` entry

`multiRegionProperties` DNA entry