Initial commit

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/VoFphaseCompressibleTurbulenceModels/Make/files

+VoFphaseCompressibleTurbulenceModels.C
+compressibleInterPhaseTransportModel.C
+
+LIB = $(FOAM_LIBBIN)/libVoFphaseCompressibleTurbulenceModels

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/VoFphaseCompressibleTurbulenceModels/Make/options

+EXE_INC = \
+    -I../twoPhaseMixtureThermo \
+    -I$(LIB_SRC)/transportModels/compressible/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/transportModels/twoPhaseMixture/lnInclude \
+    -I$(LIB_SRC)/transportModels/interfaceProperties/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/phaseCompressible/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude
+
+LIB_LIBS = \
+    -ltwoPhaseMixtureThermo \
+    -lcompressibleTransportModels \
+    -lfluidThermophysicalModels \
+    -lspecie \
+    -ltwoPhaseMixture \
+    -ltwoPhaseProperties \
+    -linterfaceProperties \
+    -lturbulenceModels \
+    -lcompressibleTurbulenceModels \
+    -lincompressibleTransportModels \
+    -lfiniteVolume \
+    -lmeshTools

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/VoFphaseCompressibleTurbulenceModels/VoFphaseCompressibleTurbulenceModel.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2017 OpenFOAM Foundation
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Typedef
+    Foam::VoFphaseCompressibleTurbulenceModel
+
+Description
+    Typedef for VoFphaseCompressibleTurbulenceModel
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef VoFphaseCompressibleTurbulenceModel_H
+#define VoFphaseCompressibleTurbulenceModel_H
+
+#include "VoFphaseCompressibleTurbulenceModelFwd.H"
+#include "PhaseCompressibleTurbulenceModel.H"
+#include "ThermalDiffusivity.H"
+#include "fluidThermo.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+      typedef ThermalDiffusivity<PhaseCompressibleTurbulenceModel<fluidThermo>>
+          VoFphaseCompressibleTurbulenceModel;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/VoFphaseCompressibleTurbulenceModels/VoFphaseCompressibleTurbulenceModelFwd.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2017 OpenFOAM Foundation
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Typedef
+    Foam::VoFphaseCompressibleTurbulenceModel
+
+Description
+    Forward declaration of typedef for VoFphaseCompressibleTurbulenceModel
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef VoFphaseCompressibleTurbulenceModelFwd_H
+#define VoFphaseCompressibleTurbulenceModelFwd_H
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    class fluidThermo;
+
+    template<class TransportModel>
+    class PhaseCompressibleTurbulenceModel;
+
+    template<class BasicTurbulenceModel>
+    class ThermalDiffusivity;
+
+      typedef ThermalDiffusivity<PhaseCompressibleTurbulenceModel<fluidThermo>>
+          VoFphaseCompressibleTurbulenceModel;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/VoFphaseCompressibleTurbulenceModels/VoFphaseCompressibleTurbulenceModels.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2017 OpenFOAM Foundation
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "PhaseCompressibleTurbulenceModel.H"
+#include "fluidThermo.H"
+#include "addToRunTimeSelectionTable.H"
+#include "makeTurbulenceModel.H"
+
+#include "ThermalDiffusivity.H"
+#include "EddyDiffusivity.H"
+
+#include "laminarModel.H"
+#include "RASModel.H"
+#include "LESModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+defineTurbulenceModelTypes
+(
+    volScalarField,
+    volScalarField,
+    compressibleTurbulenceModel,
+    PhaseCompressibleTurbulenceModel,
+    ThermalDiffusivity,
+    fluidThermo
+);
+
+makeBaseTurbulenceModel
+(
+    volScalarField,
+    volScalarField,
+    compressibleTurbulenceModel,
+    PhaseCompressibleTurbulenceModel,
+    ThermalDiffusivity,
+    fluidThermo
+);
+
+#define makeLaminarModel(Type)                                                 \
+    makeTemplatedLaminarModel                                                  \
+    (fluidThermoPhaseCompressibleTurbulenceModel, laminar, Type)
+
+#define makeRASModel(Type)                                                     \
+    makeTemplatedTurbulenceModel                                               \
+    (fluidThermoPhaseCompressibleTurbulenceModel, RAS, Type)
+
+#define makeLESModel(Type)                                                     \
+    makeTemplatedTurbulenceModel                                               \
+    (fluidThermoPhaseCompressibleTurbulenceModel, LES, Type)
+
+
+// -------------------------------------------------------------------------- //
+// Laminar models
+// -------------------------------------------------------------------------- //
+
+#include "Stokes.H"
+makeLaminarModel(Stokes);
+
+#include "Maxwell.H"
+makeLaminarModel(Maxwell);
+
+
+// -------------------------------------------------------------------------- //
+// RAS models
+// -------------------------------------------------------------------------- //
+
+#include "kEpsilon.H"
+makeRASModel(kEpsilon);
+
+#include "kOmegaSST.H"
+makeRASModel(kOmegaSST);
+
+
+// -------------------------------------------------------------------------- //
+// LES models
+// -------------------------------------------------------------------------- //
+
+#include "Smagorinsky.H"
+makeLESModel(Smagorinsky);
+
+#include "kEqn.H"
+makeLESModel(kEqn);
+
+
+// ************************************************************************* //

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/VoFphaseCompressibleTurbulenceModels/compressibleInterPhaseTransportModel.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2017-2018 OpenFOAM Foundation
+    Copyright (C) 2020 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "compressibleInterPhaseTransportModel.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::compressibleInterPhaseTransportModel::compressibleInterPhaseTransportModel
+(
+    const volScalarField& rho,
+    const volVectorField& U,
+    const surfaceScalarField& phi,
+    const surfaceScalarField& rhoPhi,
+    const surfaceScalarField& alphaPhi10,
+    const twoPhaseMixtureThermo& mixture
+)
+:
+    twoPhaseTransport_(false),
+    mixture_(mixture),
+    phi_(phi),
+    alphaPhi10_(alphaPhi10)
+{
+    {
+        IOdictionary turbulenceProperties
+        (
+            IOobject
+            (
+                turbulenceModel::propertiesName,
+                U.time().constant(),
+                U.db(),
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE
+            )
+        );
+
+        const word simulationType
+        (
+            turbulenceProperties.get<word>("simulationType")
+        );
+
+        if (simulationType == "twoPhaseTransport")
+        {
+            twoPhaseTransport_ = true;
+        }
+    }
+
+    if (twoPhaseTransport_)
+    {
+        const volScalarField& alpha1(mixture_.alpha1());
+        const volScalarField& alpha2(mixture_.alpha2());
+
+        const volScalarField& rho1 = mixture_.thermo1().rho();
+        const volScalarField& rho2 = mixture_.thermo2().rho();
+
+        alphaRhoPhi1_ =
+        (
+            new surfaceScalarField
+            (
+                IOobject::groupName("alphaRhoPhi", alpha1.group()),
+                fvc::interpolate(rho1)*alphaPhi10_
+            )
+        );
+
+        alphaRhoPhi2_ =
+        (
+            new surfaceScalarField
+            (
+                IOobject::groupName("alphaRhoPhi", alpha2.group()),
+                fvc::interpolate(rho2)*(phi_ - alphaPhi10_)
+            )
+        );
+
+        turbulence1_ =
+        (
+            ThermalDiffusivity<PhaseCompressibleTurbulenceModel<fluidThermo>>
+            ::New
+            (
+                alpha1,
+                rho1,
+                U,
+                alphaRhoPhi1_(),
+                phi,
+                mixture.thermo1()
+            )
+        );
+
+        turbulence2_ =
+        (
+            ThermalDiffusivity<PhaseCompressibleTurbulenceModel<fluidThermo>>
+            ::New
+            (
+                alpha2,
+                rho2,
+                U,
+                alphaRhoPhi2_(),
+                phi,
+                mixture.thermo2()
+            )
+        );
+    }
+    else
+    {
+        turbulence_ = compressible::turbulenceModel::New
+        (
+            rho,
+            U,
+            rhoPhi,
+            mixture
+        );
+
+        turbulence_->validate();
+    }
+}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+Foam::tmp<Foam::volScalarField>
+Foam::compressibleInterPhaseTransportModel::alphaEff() const
+{
+    if (twoPhaseTransport_)
+    {
+        return
+            mixture_.alpha1()*mixture_.thermo1().alphaEff
+            (
+                turbulence1_->alphat()
+            )
+          + mixture_.alpha2()*mixture_.thermo2().alphaEff
+            (
+                turbulence2_->alphat()
+            );
+    }
+    else
+    {
+        return mixture_.alphaEff(turbulence_->alphat());
+    }
+}
+
+
+Foam::tmp<Foam::fvVectorMatrix>
+Foam::compressibleInterPhaseTransportModel::divDevRhoReff
+(
+    volVectorField& U
+) const
+{
+    if (twoPhaseTransport_)
+    {
+        return
+            turbulence1_->divDevRhoReff(U)
+          + turbulence2_->divDevRhoReff(U);
+    }
+    else
+    {
+        return turbulence_->divDevRhoReff(U);
+    }
+}
+
+
+void Foam::compressibleInterPhaseTransportModel::correctPhasePhi()
+{
+    if (twoPhaseTransport_)
+    {
+        const volScalarField& rho1 = mixture_.thermo1().rho();
+        const volScalarField& rho2 = mixture_.thermo2().rho();
+
+        alphaRhoPhi1_.ref() = fvc::interpolate(rho1)*alphaPhi10_;
+        alphaRhoPhi2_.ref() = fvc::interpolate(rho2)*(phi_ - alphaPhi10_);
+    }
+}
+
+
+void Foam::compressibleInterPhaseTransportModel::correct()
+{
+    if (twoPhaseTransport_)
+    {
+        turbulence1_->correct();
+        turbulence2_->correct();
+    }
+    else
+    {
+        turbulence_->correct();
+    }
+}
+
+
+// ************************************************************************* //

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/VoFphaseCompressibleTurbulenceModels/compressibleInterPhaseTransportModel.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2017-2018 OpenFOAM Foundation
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::compressibleInterPhaseTransportModel
+
+Description
+    Transport model selection class for the compressibleInterFoam family of
+    solvers.
+
+    By default the standard mixture transport modelling approach is used in
+    which a single momentum stress model (laminar, non-Newtonian, LES or RAS) is
+    constructed for the mixture.  However if the \c simulationType in
+    constant/turbulenceProperties is set to \c twoPhaseTransport the alternative
+    Euler-Euler two-phase transport modelling approach is used in which separate
+    stress models (laminar, non-Newtonian, LES or RAS) are instantiated for each
+    of the two phases allowing for different modeling for the phases.
+
+SourceFiles
+    compressibleInterPhaseTransportModel.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef compressibleInterPhaseTransportModel_H
+#define compressibleInterPhaseTransportModel_H
+
+#include "twoPhaseMixture.H"
+#include "twoPhaseMixtureThermo.H"
+#include "turbulentFluidThermoModel.H"
+#include "VoFphaseCompressibleTurbulenceModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+             Class compressibleInterPhaseTransportModel Declaration
+\*---------------------------------------------------------------------------*/
+
+class compressibleInterPhaseTransportModel
+{
+    // Private data
+
+        //- Switch to select two-phase or mixture transport modelling
+        Switch twoPhaseTransport_;
+
+        //- Two-phase mixture
+        const twoPhaseMixtureThermo& mixture_;
+
+        //- Mixture volumetric flux
+        const surfaceScalarField& phi_;
+
+        //- Phase volumetric flux
+        const surfaceScalarField& alphaPhi10_;
+
+        //- Phase-1 mass-flux (constructed for two-phase transport)
+        tmp<surfaceScalarField> alphaRhoPhi1_;
+
+        //- Phase-2 mass-flux (constructed for two-phase transport)
+        tmp<surfaceScalarField> alphaRhoPhi2_;
+
+        //- Mixture transport model (constructed for mixture transport)
+        autoPtr<compressible::turbulenceModel> turbulence_;
+
+        //- Phase-1 transport model (constructed for two-phase transport)
+        autoPtr
+        <
+            ThermalDiffusivity<PhaseCompressibleTurbulenceModel<fluidThermo>>
+        > turbulence1_;
+
+        //- Phase-2 transport model (constructed for two-phase transport)
+        autoPtr
+        <
+            ThermalDiffusivity<PhaseCompressibleTurbulenceModel<fluidThermo>>
+        > turbulence2_;
+
+
+    // Private Member Functions
+
+        //- No copy construct
+        compressibleInterPhaseTransportModel
+        (
+            const compressibleInterPhaseTransportModel&
+        ) = delete;
+
+        //- No copy assignment
+        void operator=(const compressibleInterPhaseTransportModel&) = delete;
+
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        compressibleInterPhaseTransportModel
+        (
+            const volScalarField& rho,
+            const volVectorField& U,
+            const surfaceScalarField& phi,
+            const surfaceScalarField& rhoPhi,
+            const surfaceScalarField& alphaPhi10,
+            const twoPhaseMixtureThermo& mixture
+        );
+
+
+    // Member Functions
+
+        //- Return the effective temperature transport coefficient
+        tmp<volScalarField> alphaEff() const;
+
+        //- Return the effective momentum stress divergence
+        tmp<fvVectorMatrix> divDevRhoReff(volVectorField& U) const;
+
+        //- Correct the phase mass-fluxes
+        // (required for the two-phase transport option)
+        void correctPhasePhi();
+
+        //- Correct the phase or mixture transport models
+        void correct();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/alphaSuSp.H

+volScalarField::Internal Sp
+(
+    IOobject
+    (
+        "Sp",
+        runTime.timeName(),
+        mesh
+    ),
+    mesh,
+    dimensionedScalar(dgdt.dimensions(), Zero)
+);
+
+volScalarField::Internal Su
+(
+    IOobject
+    (
+        "Su",
+        runTime.timeName(),
+        mesh
+    ),
+    mesh,
+    dimensionedScalar(dgdt.dimensions(), Zero)
+);
+
+forAll(dgdt, celli)
+{
+    if (dgdt[celli] > 0.0)
+    {
+        Sp[celli] -= dgdt[celli]/max(1.0 - alpha1[celli], 1e-4);
+        Su[celli] += dgdt[celli]/max(1.0 - alpha1[celli], 1e-4);
+    }
+    else if (dgdt[celli] < 0.0)
+    {
+        Sp[celli] += dgdt[celli]/max(alpha1[celli], 1e-4);
+    }
+}
+
+volScalarField::Internal divU
+(
+    mesh.moving()
+  ? fvc::div(phiCN() + mesh.phi())
+  : fvc::div(phiCN())
+);

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/compressibleAlphaEqnSubCycle.H

+tmp<surfaceScalarField> talphaPhi1(alphaPhi10);
+
+if (nAlphaSubCycles > 1)
+{
+    dimensionedScalar totalDeltaT = runTime.deltaT();
+
+    talphaPhi1 = new surfaceScalarField
+    (
+        IOobject
+        (
+            "alphaPhi1",
+            runTime.timeName(),
+            mesh
+        ),
+        mesh,
+        dimensionedScalar(alphaPhi10.dimensions(), Zero)
+    );
+
+    surfaceScalarField rhoPhiSum
+    (
+        IOobject
+        (
+            "rhoPhiSum",
+            runTime.timeName(),
+            mesh
+        ),
+        mesh,
+        dimensionedScalar(rhoPhi.dimensions(), Zero)
+    );
+
+    tmp<volScalarField> trSubDeltaT;
+
+    if (LTS)
+    {
+        trSubDeltaT =
+            fv::localEulerDdt::localRSubDeltaT(mesh, nAlphaSubCycles);
+    }
+
+    for
+    (
+        subCycle<volScalarField> alphaSubCycle(alpha1, nAlphaSubCycles);
+        !(++alphaSubCycle).end();
+    )
+    {
+        #include "alphaEqn.H"
+        talphaPhi1.ref() += (runTime.deltaT()/totalDeltaT)*alphaPhi10;
+        rhoPhiSum += (runTime.deltaT()/totalDeltaT)*rhoPhi;
+    }
+
+    rhoPhi = rhoPhiSum;
+}
+else
+{
+    #include "alphaEqn.H"
+}
+
+rho == alpha1*rho1 + alpha2*rho2;
+
+const surfaceScalarField& alphaPhi1 = talphaPhi1();
+surfaceScalarField alphaPhi2("alphaPhi2", phi - alphaPhi1);
+
+volScalarField::Internal contErr
+(
+    (
+        fvc::ddt(rho) + fvc::div(rhoPhi)
+      - (fvOptions(alpha1, mixture.thermo1().rho())&rho1)
+      - (fvOptions(alpha2, mixture.thermo2().rho())&rho2)
+    )()
+);

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/Make/files

+compressibleInterDyMFoam.C
+
+EXE = $(FOAM_APPBIN)/compressibleInterDyMFoam

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/Make/options

+EXE_INC = \
+    -I.. \
+    -I../../VoF \
+    -I../twoPhaseMixtureThermo \
+    -I../VoFphaseCompressibleTurbulenceModels/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/transportModels/compressible/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/transportModels/twoPhaseMixture/lnInclude \
+    -I$(LIB_SRC)/transportModels/interfaceProperties/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/phaseCompressible/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/dynamicFvMesh/lnInclude
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -lfvOptions \
+    -lmeshTools \
+    -ltwoPhaseMixtureThermo \
+    -ltwoPhaseSurfaceTension \
+    -lcompressibleTransportModels \
+    -lfluidThermophysicalModels \
+    -lspecie \
+    -ltwoPhaseMixture \
+    -ltwoPhaseProperties \
+    -linterfaceProperties \
+    -lturbulenceModels \
+    -lcompressibleTurbulenceModels \
+    -lVoFphaseCompressibleTurbulenceModels \
+    -ldynamicMesh \
+    -ldynamicFvMesh

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/alphaSuSp.H

+volScalarField::Internal Sp
+(
+    IOobject
+    (
+        "Sp",
+        runTime.timeName(),
+        mesh
+    ),
+    mesh,
+    dimensionedScalar(dgdt.dimensions(), Zero)
+);
+
+volScalarField::Internal Su
+(
+    IOobject
+    (
+        "Su",
+        runTime.timeName(),
+        mesh
+    ),
+    mesh,
+    dimensionedScalar(dgdt.dimensions(), Zero)
+);
+
+forAll(dgdt, celli)
+{
+    if (dgdt[celli] > 0.0 && alpha1[celli] > 0.0)
+    {
+        Sp[celli] -= dgdt[celli]*alpha1[celli];
+        Su[celli] += dgdt[celli]*alpha1[celli];
+    }
+    else if (dgdt[celli] < 0.0 && alpha1[celli] < 1.0)
+    {
+        Sp[celli] += dgdt[celli]*(1.0 - alpha1[celli]);
+    }
+}
+
+volScalarField::Internal divU
+(
+    mesh.moving()
+  ? fvc::div(phiCN() + mesh.phi())
+  : fvc::div(phiCN())
+);

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/compressibleInterDyMFoam.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2017 OpenFOAM Foundation
+    Copyright (C) 2019 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    compressibleInterDyMFoam
+
+Description
+    Solver for two compressible, non-isothermal immiscible fluids using a VOF
+    (volume of fluid) phase-fraction based interface capturing approach,
+    with optional mesh motion and mesh topology changes including adaptive
+    re-meshing.
+
+    The momentum and other fluid properties are of the "mixture" and a single
+    momentum equation is solved.
+
+    Turbulence modelling is generic, i.e. laminar, RAS or LES may be selected.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "dynamicFvMesh.H"
+#include "CMULES.H"
+#include "EulerDdtScheme.H"
+#include "localEulerDdtScheme.H"
+#include "CrankNicolsonDdtScheme.H"
+#include "subCycle.H"
+#include "compressibleInterPhaseTransportModel.H"
+#include "pimpleControl.H"
+#include "fvOptions.H"
+#include "CorrectPhi.H"
+#include "fvcSmooth.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    argList::addNote
+    (
+        "Solver for two compressible, non-isothermal immiscible fluids"
+        " using VOF phase-fraction based interface capturing.\n"
+        "With optional mesh motion and mesh topology changes including"
+        " adaptive re-meshing."
+    );
+
+    #include "postProcess.H"
+
+    #include "setRootCaseLists.H"
+    #include "createTime.H"
+    #include "createDynamicFvMesh.H"
+    #include "initContinuityErrs.H"
+    #include "createDyMControls.H"
+    #include "createFields.H"
+    #include "createUf.H"
+    #include "CourantNo.H"
+    #include "setInitialDeltaT.H"
+
+    volScalarField& p = mixture.p();
+    volScalarField& T = mixture.T();
+    const volScalarField& psi1 = mixture.thermo1().psi();
+    const volScalarField& psi2 = mixture.thermo2().psi();
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+    Info<< "\nStarting time loop\n" << endl;
+
+    while (runTime.run())
+    {
+        #include "readDyMControls.H"
+
+        // Store divU and divUp from the previous mesh so that it can be mapped
+        // and used in correctPhi to ensure the corrected phi has the
+        // same divergence
+        volScalarField divU("divU0", fvc::div(fvc::absolute(phi, U)));
+        volScalarField divUp("divUp", fvc::div(fvc::absolute(phi, U), p));
+
+        if (LTS)
+        {
+            #include "setRDeltaT.H"
+        }
+        else
+        {
+            #include "CourantNo.H"
+            #include "alphaCourantNo.H"
+            #include "setDeltaT.H"
+        }
+
+        ++runTime;
+
+        Info<< "Time = " << runTime.timeName() << nl << endl;
+
+        // --- Pressure-velocity PIMPLE corrector loop
+        while (pimple.loop())
+        {
+            if (pimple.firstIter() || moveMeshOuterCorrectors)
+            {
+                scalar timeBeforeMeshUpdate = runTime.elapsedCpuTime();
+
+                mesh.update();
+
+                if (mesh.changing())
+                {
+                    MRF.update();
+
+                    Info<< "Execution time for mesh.update() = "
+                        << runTime.elapsedCpuTime() - timeBeforeMeshUpdate
+                        << " s" << endl;
+
+                    gh = (g & mesh.C()) - ghRef;
+                    ghf = (g & mesh.Cf()) - ghRef;
+                }
+
+                if ((mesh.changing() && correctPhi))
+                {
+                    // Calculate absolute flux from the mapped surface velocity
+                    phi = mesh.Sf() & Uf;
+
+                    #include "correctPhi.H"
+
+                    // Make the fluxes relative to the mesh motion
+                    fvc::makeRelative(phi, U);
+
+                    mixture.correct();
+                }
+
+                if (mesh.changing() && checkMeshCourantNo)
+                {
+                    #include "meshCourantNo.H"
+                }
+            }
+
+            #include "alphaControls.H"
+            #include "compressibleAlphaEqnSubCycle.H"
+
+            turbulence.correctPhasePhi();
+
+            #include "UEqn.H"
+            #include "TEqn.H"
+
+            // --- Pressure corrector loop
+            while (pimple.correct())
+            {
+                #include "pEqn.H"
+            }
+
+            if (pimple.turbCorr())
+            {
+                turbulence.correct();
+            }
+        }
+
+        rho = alpha1*rho1 + alpha2*rho2;
+
+        // Correct p_rgh for consistency with p and the updated densities
+        p_rgh = p - rho*gh;
+        p_rgh.correctBoundaryConditions();
+
+        runTime.write();
+
+        runTime.printExecutionTime(Info);
+    }
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/correctPhi.H

+CorrectPhi
+(
+    U,
+    phi,
+    p,
+    dimensionedScalar("rAUf", dimTime/rho.dimensions(), 1),
+    divU,
+    pimple
+);
+
+//***HGW phi.oldTime() = phi;
+
+#include "continuityErrs.H"

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/pEqn.H

+{
+    volScalarField rAU("rAU", 1.0/UEqn.A());
+    surfaceScalarField rAUf("rAUf", fvc::interpolate(rAU));
+    volVectorField HbyA(constrainHbyA(rAU*UEqn.H(), U, p_rgh));
+    surfaceScalarField phiHbyA
+    (
+        "phiHbyA",
+        fvc::flux(HbyA)
+      + MRF.zeroFilter(fvc::interpolate(rho*rAU)*fvc::ddtCorr(U, Uf))
+    );
+    MRF.makeRelative(phiHbyA);
+
+    surfaceScalarField phig
+    (
+        (
+            mixture.surfaceTensionForce()
+          - ghf*fvc::snGrad(rho)
+        )*rAUf*mesh.magSf()
+    );
+
+    phiHbyA += phig;
+
+    // Update the pressure BCs to ensure flux consistency
+    constrainPressure(p_rgh, U, phiHbyA, rAUf, MRF);
+
+    // Make the fluxes relative to the mesh motion
+    fvc::makeRelative(phiHbyA, U);
+
+    tmp<fvScalarMatrix> p_rghEqnComp1;
+    tmp<fvScalarMatrix> p_rghEqnComp2;
+
+    if (pimple.transonic())
+    {
+        #include "rhofs.H"
+
+        surfaceScalarField phid1("phid1", fvc::interpolate(psi1)*phi);
+        surfaceScalarField phid2("phid2", fvc::interpolate(psi2)*phi);
+
+        p_rghEqnComp1 =
+            pos(alpha1)
+           *(
+                (
+                    fvc::ddt(alpha1, rho1) + fvc::div(alphaPhi1*rho1f)
+                  - (fvOptions(alpha1, mixture.thermo1().rho())&rho1)
+                )/rho1
+              - fvc::ddt(alpha1) - fvc::div(alphaPhi1)
+              + (alpha1/rho1)
+               *correction
+                (
+                    psi1*fvm::ddt(p_rgh)
+                  + fvm::div(phid1, p_rgh) - fvm::Sp(fvc::div(phid1), p_rgh)
+                )
+            );
+        p_rghEqnComp1.ref().relax();
+
+        p_rghEqnComp2 =
+            pos(alpha2)
+           *(
+               (
+                   fvc::ddt(alpha2, rho2) + fvc::div(alphaPhi2*rho2f)
+                 - (fvOptions(alpha2, mixture.thermo2().rho())&rho2)
+               )/rho2
+             - fvc::ddt(alpha2) - fvc::div(alphaPhi2)
+             + (alpha2/rho2)
+              *correction
+               (
+                   psi2*fvm::ddt(p_rgh)
+                 + fvm::div(phid2, p_rgh) - fvm::Sp(fvc::div(phid2), p_rgh)
+               )
+           );
+        p_rghEqnComp2.ref().relax();
+    }
+    else
+    {
+         p_rghEqnComp1 =
+            fvc::ddt(rho1) + psi1*correction(fvm::ddt(p_rgh))
+          + fvc::div(phi, rho1) - fvc::Sp(fvc::div(phi), rho1);
+
+        p_rghEqnComp2 =
+            fvc::ddt(rho2) + psi2*correction(fvm::ddt(p_rgh))
+          + fvc::div(phi, rho2) - fvc::Sp(fvc::div(phi), rho2);
+    }
+
+    // Cache p_rgh prior to solve for density update
+    volScalarField p_rgh_0(p_rgh);
+
+    while (pimple.correctNonOrthogonal())
+    {
+        fvScalarMatrix p_rghEqnIncomp
+        (
+            fvc::div(phiHbyA)
+          - fvm::laplacian(rAUf, p_rgh)
+        );
+
+        solve
+        (
+            (
+                (max(alpha1, scalar(0))/rho1)*p_rghEqnComp1()
+              + (max(alpha2, scalar(0))/rho2)*p_rghEqnComp2()
+            )
+          + p_rghEqnIncomp,
+            mesh.solver(p_rgh.select(pimple.finalInnerIter()))
+        );
+
+        if (pimple.finalNonOrthogonalIter())
+        {
+            p = max(p_rgh + (alpha1*rho1 + alpha2*rho2)*gh, pMin);
+            p_rgh = p - (alpha1*rho1 + alpha2*rho2)*gh;
+
+            dgdt =
+            (
+                pos(alpha2)*(p_rghEqnComp2 & p_rgh)/rho2
+              - pos(alpha1)*(p_rghEqnComp1 & p_rgh)/rho1
+            );
+
+            phi = phiHbyA + p_rghEqnIncomp.flux();
+
+            U = HbyA
+              + rAU*fvc::reconstruct((phig + p_rghEqnIncomp.flux())/rAUf);
+            U.correctBoundaryConditions();
+            fvOptions.correct(U);
+        }
+    }
+
+    {
+        Uf = fvc::interpolate(U);
+        surfaceVectorField n(mesh.Sf()/mesh.magSf());
+        Uf += n*(fvc::absolute(phi, U)/mesh.magSf() - (n & Uf));
+    }
+
+    // Update densities from change in p_rgh
+    mixture.thermo1().correctRho(psi1*(p_rgh - p_rgh_0));
+    mixture.thermo2().correctRho(psi2*(p_rgh - p_rgh_0));
+
+    rho = alpha1*rho1 + alpha2*rho2;
+
+    // Correct p_rgh for consistency with p and the updated densities
+    p = max(p_rgh + rho*gh, pMin);
+    p_rgh = p - rho*gh;
+    p_rgh.correctBoundaryConditions();
+
+
+
+    K = 0.5*magSqr(U);
+}

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/compressibleInterFilmFoam/Make/files

+VoFPatchTransfer/VoFPatchTransfer.C
+VoFSolidificationMeltingSource/VoFSolidificationMeltingSource.C
+VoFSolidificationMeltingSource/VoFSolidificationMeltingSourceIO.C
+compressibleInterFilmFoam.C
+
+EXE = $(FOAM_APPBIN)/compressibleInterFilmFoam

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/compressibleInterFilmFoam/Make/options

+EXE_INC = \
+    -I.. \
+    -I../../VoF \
+    -I../twoPhaseMixtureThermo \
+    -I../VoFphaseCompressibleTurbulenceModels/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/fvOptions/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/transportModels/compressible/lnInclude \
+    -I$(LIB_SRC)/transportModels/twoPhaseMixture/lnInclude \
+    -I$(LIB_SRC)/transportModels/interfaceProperties/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/phaseCompressible/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/thermophysicalProperties/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/SLGThermo/lnInclude \
+    -I$(LIB_SRC)/regionModels/regionModel/lnInclude \
+    -I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/dynamicFvMesh/lnInclude
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -lfvOptions \
+    -lmeshTools \
+    -ltwoPhaseMixtureThermo \
+    -ltwoPhaseSurfaceTension \
+    -lcompressibleTransportModels \
+    -lfluidThermophysicalModels \
+    -lspecie \
+    -ltwoPhaseMixture \
+    -ltwoPhaseProperties \
+    -linterfaceProperties \
+    -lturbulenceModels \
+    -lcompressibleTurbulenceModels \
+    -lVoFphaseCompressibleTurbulenceModels \
+    -lSLGThermo \
+    -lsurfaceFilmModels \
+    -lsurfaceFilmDerivedFvPatchFields \
+    -ldynamicMesh \
+    -ldynamicFvMesh

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/compressibleInterFilmFoam/TEqn.H

+{
+    fvScalarMatrix TEqn
+    (
+        fvm::ddt(rho, T) + fvm::div(rhoPhi, T)
+      - fvm::Sp(contErr, T)
+      - fvm::laplacian(turbulence.alphaEff(), T)
+      + (
+            (
+                fvc::div(fvc::absolute(phi, U), p)
+              + fvc::ddt(rho, K) + fvc::div(rhoPhi, K)
+            )()() - contErr*K
+        )
+       *(
+           alpha1/mixture.thermo1().Cv()
+         + alpha2/mixture.thermo2().Cv()
+        )()()
+     ==
+        fvOptions(rho, T)
+      + pos(Srho)
+       *(
+            surfaceFilm.Sh()()/mixture.thermo1().Cp()()
+          + surfaceFilm.Tref*Srho
+        )
+    );
+
+    TEqn.relax();
+
+    fvOptions.constrain(TEqn);
+
+    TEqn.solve();
+
+    fvOptions.correct(T);
+
+    mixture.correctThermo();
+    mixture.correct();
+}

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/compressibleInterFilmFoam/VoFPatchTransfer/VoFPatchTransfer.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2017 OpenFOAM Foundation
+    Copyright (C) 2018-2021 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "VoFPatchTransfer.H"
+#include "twoPhaseMixtureThermo.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace regionModels
+{
+namespace surfaceFilmModels
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(VoFPatchTransfer, 0);
+addToRunTimeSelectionTable(transferModel, VoFPatchTransfer, dictionary);
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+VoFPatchTransfer::VoFPatchTransfer
+(
+    surfaceFilmRegionModel& film,
+    const dictionary& dict
+)
+:
+    transferModel(type(), film, dict),
+    deltaFactorToVoF_
+    (
+        coeffDict_.getOrDefault<scalar>("deltaFactorToVoF", 1.0)
+    ),
+    deltaFactorToFilm_
+    (
+        coeffDict_.getOrDefault<scalar>("deltaFactorToFilm", 0.5)
+    ),
+    alphaToVoF_
+    (
+        coeffDict_.getOrDefault<scalar>("alphaToVoF", 0.5)
+    ),
+    alphaToFilm_
+    (
+        coeffDict_.getOrDefault<scalar>("alphaToFilm", 0.1)
+    ),
+    transferRateCoeff_
+    (
+        coeffDict_.getOrDefault<scalar>("transferRateCoeff", 0.1)
+    ),
+    patchIDs_(),
+    patchTransferredMasses_()
+{
+    const polyBoundaryMesh& pbm = film.regionMesh().boundaryMesh();
+
+    const label nPatches
+    (
+        pbm.size() - film.regionMesh().globalData().processorPatches().size()
+    );
+
+    wordRes patchNames;
+    if (coeffDict_.readIfPresent("patches", patchNames))
+    {
+        patchIDs_ = pbm.patchSet(patchNames).sortedToc();
+
+        Info<< "        applying to " << patchIDs_.size() << " patches:" << nl;
+
+        for (const label patchi : patchIDs_)
+        {
+            Info<< "            " << pbm[patchi].name() << endl;
+        }
+    }
+    else
+    {
+        Info<< "            applying to all patches" << endl;
+
+        patchIDs_ = identity(nPatches);
+    }
+
+    patchTransferredMasses_.resize(patchIDs_.size(), Zero);
+
+    if (patchIDs_.empty())
+    {
+        FatalErrorInFunction
+            << "No patches selected"
+            << exit(FatalError);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+VoFPatchTransfer::~VoFPatchTransfer()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void VoFPatchTransfer::correct
+(
+    scalarField& availableMass,
+    scalarField& massToTransfer
+)
+{
+    NotImplemented;
+}
+
+
+void VoFPatchTransfer::correct
+(
+    scalarField& availableMass,
+    scalarField& massToTransfer,
+    scalarField& energyToTransfer
+)
+{
+    // Do not correct if no patches selected
+    if (!patchIDs_.size()) return;
+
+    const scalarField& delta = film().delta();
+    const scalarField& rho = film().rho();
+    const scalarField& magSf = film().magSf();
+
+    const polyBoundaryMesh& pbm = film().regionMesh().boundaryMesh();
+
+
+    const twoPhaseMixtureThermo& thermo
+    (
+        film().primaryMesh().lookupObject<twoPhaseMixtureThermo>
+        (
+            twoPhaseMixtureThermo::dictName
+        )
+    );
+
+    const volScalarField& heVoF = thermo.thermo1().he();
+    const volScalarField& TVoF = thermo.thermo1().T();
+    const volScalarField CpVoF(thermo.thermo1().Cp());
+    const volScalarField& rhoVoF = thermo.thermo1().rho()();
+    const volScalarField& alphaVoF = thermo.alpha1();
+
+    forAll(patchIDs_, pidi)
+    {
+        const label patchi = patchIDs_[pidi];
+        label primaryPatchi = -1;
+
+        forAll(film().intCoupledPatchIDs(), i)
+        {
+            const label filmPatchi = film().intCoupledPatchIDs()[i];
+
+            if (filmPatchi == patchi)
+            {
+                primaryPatchi = film().primaryPatchIDs()[i];
+            }
+        }
+
+        if (primaryPatchi != -1)
+        {
+            scalarField deltaCoeffs
+            (
+                film().primaryMesh().boundary()[primaryPatchi].deltaCoeffs()
+            );
+            film().toRegion(patchi, deltaCoeffs);
+
+            scalarField hp(heVoF.boundaryField()[primaryPatchi]);
+            film().toRegion(patchi, hp);
+
+            scalarField Tp(TVoF.boundaryField()[primaryPatchi]);
+            film().toRegion(patchi, Tp);
+
+            scalarField Cpp(CpVoF.boundaryField()[primaryPatchi]);
+            film().toRegion(patchi, Cpp);
+
+            scalarField rhop(rhoVoF.boundaryField()[primaryPatchi]);
+            film().toRegion(patchi, rhop);
+
+            scalarField alphap(alphaVoF.boundaryField()[primaryPatchi]);
+            film().toRegion(patchi, alphap);
+
+            scalarField Vp
+            (
+                film().primaryMesh().boundary()[primaryPatchi]
+               .patchInternalField(film().primaryMesh().V())
+            );
+            film().toRegion(patchi, Vp);
+
+            const polyPatch& pp = pbm[patchi];
+            const labelList& faceCells = pp.faceCells();
+
+            // Accumulate the total mass removed from patch
+            scalar dMassPatch = 0;
+
+            forAll(faceCells, facei)
+            {
+                const label celli = faceCells[facei];
+
+                scalar dMass = 0;
+
+                if
+                (
+                    delta[celli] > 2*deltaFactorToVoF_/deltaCoeffs[facei]
+                 || alphap[facei] > alphaToVoF_
+                )
+                {
+                    dMass =
+                        transferRateCoeff_*delta[celli]*rho[celli]*magSf[celli];
+
+                    massToTransfer[celli] += dMass;
+                    energyToTransfer[celli] += dMass*film().hs()[celli];
+                }
+
+                if
+                (
+                    alphap[facei] > 0
+                 && delta[celli] > 0
+                 && delta[celli] < 2*deltaFactorToFilm_/deltaCoeffs[facei]
+                 && alphap[facei] < alphaToFilm_
+                )
+                {
+                    dMass =
+                        -transferRateCoeff_*alphap[facei]*rhop[facei]*Vp[facei];
+
+                    massToTransfer[celli] += dMass;
+                    energyToTransfer[celli] += dMass*hp[facei];
+                }
+
+                availableMass[celli] -= dMass;
+                dMassPatch += dMass;
+            }
+
+            patchTransferredMasses_[pidi] += dMassPatch;
+            addToTransferredMass(dMassPatch);
+        }
+    }
+
+    transferModel::correct();
+
+    if (writeTime())
+    {
+        scalarField patchTransferredMasses0
+        (
+            getModelProperty<scalarField>
+            (
+                "patchTransferredMasses",
+                scalarField(patchTransferredMasses_.size(), Zero)
+            )
+        );
+
+        scalarField patchTransferredMassTotals(patchTransferredMasses_);
+        Pstream::listCombineGather
+        (
+            patchTransferredMassTotals,
+            plusEqOp<scalar>()
+        );
+        patchTransferredMasses0 += patchTransferredMassTotals;
+
+        setModelProperty<scalarField>
+        (
+            "patchTransferredMasses",
+            patchTransferredMasses0
+        );
+
+        patchTransferredMasses_ = 0;
+    }
+}
+
+
+void VoFPatchTransfer::patchTransferredMassTotals
+(
+    scalarField& patchMasses
+) const
+{
+    // Do not correct if no patches selected
+    if (!patchIDs_.size()) return;
+
+    scalarField patchTransferredMasses
+    (
+        getModelProperty<scalarField>
+        (
+            "patchTransferredMasses",
+            scalarField(patchTransferredMasses_.size(), Zero)
+        )
+    );
+
+    scalarField patchTransferredMassTotals(patchTransferredMasses_);
+    Pstream::listCombineGather(patchTransferredMassTotals, plusEqOp<scalar>());
+
+    forAll(patchIDs_, pidi)
+    {
+        const label patchi = patchIDs_[pidi];
+        patchMasses[patchi] +=
+            patchTransferredMasses[pidi] + patchTransferredMassTotals[pidi];
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace surfaceFilmModels
+} // End namespace regionModels
+} // End namespace Foam
+
+// ************************************************************************* //

OpenFOAM-v2112/applications/solvers/multiphase/compressibleInterFoam/compressibleInterFilmFoam/VoFPatchTransfer/VoFPatchTransfer.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2017 OpenFOAM Foundation
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::regionModels::surfaceFilmModels::VoFPatchTransfer
+
+Description
+    Transfer mass between the film and the VoF in the continuous phase.
+
+SourceFiles
+    VoFPatchTransfer.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef VoFPatchTransfer_H
+#define VoFPatchTransfer_H
+
+#include "transferModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace regionModels
+{
+namespace surfaceFilmModels
+{
+
+/*---------------------------------------------------------------------------*\
+                      Class VoFPatchTransfer Declaration
+\*---------------------------------------------------------------------------*/
+
+class VoFPatchTransfer
+:
+    public transferModel
+{
+    // Private member functions
+
+        //- No copy construct
+        VoFPatchTransfer(const VoFPatchTransfer&) = delete;
+
+        //- No copy assignment
+        void operator=(const VoFPatchTransfer&) = delete;
+
+
+protected:
+
+        //- Factor of the cell height above which the film is transferred
+        //  to the VoF
+        scalar deltaFactorToVoF_;
+
+        //- Factor of the cell height below which the VoF may be transferred
+        //  to the film
+        scalar deltaFactorToFilm_;
+
+        //- VoF limit above which all of the film is transferred to the VoF
+        scalar alphaToVoF_;
+
+        //- VoF limit below which the VoF may be transferred to the film
+        scalar alphaToFilm_;
+
+        //- Transfer rate coefficient
+        scalar transferRateCoeff_;
+
+        //- List of patch IDs at which the film is removed
+        labelList patchIDs_;
+
+        //- Transferred mass for each patch at which the film is removed
+        scalarField patchTransferredMasses_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("VoFPatchTransfer");
+
+
+    // Constructors
+
+        //- Construct from surface film model
+        VoFPatchTransfer(surfaceFilmRegionModel& film, const dictionary& dict);
+
+
+    //- Destructor
+    virtual ~VoFPatchTransfer();
+
+
+    // Member Functions
+
+        //- Correct
+        virtual void correct
+        (
+            scalarField& availableMass,
+            scalarField& massToTransfer
+        );
+
+        //- Correct kinematic and thermodynamic transfers
+        virtual void correct
+        (
+            scalarField& availableMass,
+            scalarField& massToTransfer,
+            scalarField& energyToTransfer
+        );
+
+        //- Accumulate the total mass injected for the patches into the
+        //  scalarField provided
+        virtual void patchTransferredMassTotals
+        (
+            scalarField& patchMasses
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace surfaceFilmModels
+} // End namespace regionModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //