[bikooo3878]

Hello everyone

I am learning how to use chtMultiRegion and have been reading the documentation and inspecting the tutorials when something stopped me in externalCoupledHeater. It is the patch between leftSolid and heater where a thermal resistance exists.

Now this resistance exists on both patches (heater_to_leftSolid and leftSolid_to_heater) But doesn't this create twice the desired value? I have tried to remove the resistance from one of the patches and no errors occurred so is it safe to assume this tutorial added half the resistance to each patch?

    heater_to_leftSolid
    {
        type            compressible::turbulentTemperatureCoupledBaffleMixed;
        value           uniform 300;
        Tnbr            T;
        kappaMethod     solidThermo;
        thicknessLayers ( 0.001 );
        kappaLayers     ( 0.0005 );

    leftSolid_to_heater
    {
        type            compressible::turbulentTemperatureCoupledBaffleMixed;
        value           uniform 300;
        Tnbr            T;
        kappaMethod     solidThermo;
        thicknessLayers ( 0.001 );
        kappaLayers     ( 0.0005 );
    }

I couldn't fine the answer to this question here nor in the description



I hope I haven't missed something obvious before asking and thank you all

[Tobi]

Dear Mostafa,

your analysis are correct. You can remove one resistance from one side and make the other side layer thickness larger. This should be identical, hence, you are absolutely correct that in the tutorial half the resistance is applied on both sides.

[bikooo3878]

Thank you for your answer and many thanks for all the effort you make to spread your knowledge.

Please don't stop

[Yann]

Originally Posted by Tobi

Dear Mostafa,

your analysis are correct. You can remove one resistance from one side and make the other side layer thickness larger. This should be identical, hence, you are absolutely correct that in the tutorial half the resistance is applied on both sides.

Hi Tobias,

Are you sure about this?

I'm working on a chtMultiRegionSimpleFoam case and I have an interface between 2 solids where I use the turbulentTemperatureCoupledBaffleMixed with kappaLayers to model the thermal resistance between these solids.
Since I read this thread few months ago, I defined kappaLayers and kappaThicknesses on one side of the interface only. It leads to something like this:

    solid1_to_solid2
    {
        type            compressible::turbulentTemperatureCoupledBaffleMixed;
        value           uniform 300;
        Tnbr            T;
    }    
    solid2_to_solid1
    {
        type            compressible::turbulentTemperatureCoupledBaffleMixed;
        value           uniform 300;
        Tnbr            T;
        kappaMethod     solidThermo;
        thicknessLayers ( 0.001 );
        kappaLayers     ( 0.0005 );
      }

With this setup, I get different wall heat fluxes on both patches so it seems to violate energy conservation.
When defining the same layers on both sides (see below) I get coherent wall heat fluxes.

    solid1_to_solid2
    {
        type            compressible::turbulentTemperatureCoupledBaffleMixed;
        value           uniform 300;
        Tnbr            T;
        kappaMethod     solidThermo;
        thicknessLayers ( 0.001 );
        kappaLayers     ( 0.0005 );
    }    
    solid2_to_solid1
    {
        type            compressible::turbulentTemperatureCoupledBaffleMixed;
        value           uniform 300;
        Tnbr            T;
        kappaMethod     solidThermo;
        thicknessLayers ( 0.001 );
        kappaLayers     ( 0.0005 );
     }

I did not dig into the code to see exactly how the layers are handled, but from this test it looks like the layers should be fully defined on both sides of the interface to work properly.

Let me know your opinion about that!


Cheers,
Yann


EDIT: I'm running OpenFOAM-v2012 but I don't think it is version-dependent

[LuGonMon]

Hi all,

I have face up the same question as I started adding layers between solids. I have been reading posts about the kappalayers addition but I haven't found a clear answer to this question. I think that you have to add the thicknessLayers and kappaLayers terms in both patches. However, I don't know if the thickness has to be splitted in half or it must be the whole thickness in both patches.

In this case I'm running OpenFOAM 8

[jairoandres]

Dear Yann,

I would like to clarify something. Based on what you mentioned, is it correct to conclude that both regions must have the exact same thin-layer configuration to establish a thin layer region between them? If possible, could you share more about any additional tests you might have conducted to corroborate this?

Best regards,

Jairo

[Yann]

Hello Jairo,

Based on my tests, you need indeed the same layer configuration on both faces to maintain energy conservation.
However, I did not make further validation tests on this matter. If you do so, please share your conclusions here, I would be glad to have additional information about it.

Also please note I only tested this on OpenFOAM-v2012, and there might have been some updates on new versions, or on other development branches such as the OpenFOAM foundation (I know they renamed the BC in OpenFOAM-11 but I don't know if the code itself changed)

I just had a look to OpenFOAM-v2306, (https://doc.openfoam.com/2306/tools/...edBaffleMixed/) and my understanding of the code is that you indeed need the full layers configuration on each side, since this is what the code uses to compute the conductivity at the interface.
Have a look at the kappa member function in the code :

tmp<Foam::scalarField>
turbulentTemperatureCoupledBaffleMixedFvPatchScalarField::kappa
(
    const scalarField& Tp
) const
{
    // Get kappa from relevant thermo
    tmp<scalarField> tk(temperatureCoupledBase::kappa(Tp));

    // Optionally modify with explicit resistance
    if (thicknessLayer_ || thicknessLayers_.size())
    {
        scalarField KDelta(tk*patch().deltaCoeffs());

        // Harmonic averaging of kappa*deltaCoeffs
        {
            KDelta = 1.0/KDelta;
            if (thicknessLayer_)
            {
                const scalar t = db().time().timeOutputValue();
                KDelta +=
                    thicknessLayer_().value(t)
                   /kappaLayer_().value(t);
            }
            if (thicknessLayers_.size())
            {
                forAll(thicknessLayers_, iLayer)
                {
                    KDelta += thicknessLayers_[iLayer]/kappaLayers_[iLayer];
                }
            }
            KDelta = 1.0/KDelta;
        }

        // Update kappa from KDelta
        tk = KDelta/patch().deltaCoeffs();
    }

    return tk;
}

source: https://develop.openfoam.com/Develop...hScalarField.C

Let me know what you think about it!
Yann