diffusionGasEvaporation.C

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2022 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 "diffusionGasEvaporation.H"
#include "constants.H"
#include "cutCellIso.H"
#include "volPointInterpolation.H"
#include "fvcGrad.H"
 
using namespace Foam::constant;
 
// * * * * * * * * * * *  Private Member Functions * * * * * * * * * * * * * //
 
template<class Thermo, class OtherThermo>
void Foam::meltingEvaporationModels::
diffusionGasEvaporation<Thermo, OtherThermo>::updateInterface
(
    const volScalarField& T
)
{
    const fvMesh& mesh = this->mesh_;
 
    const volScalarField& alpha = this->pair().from();
 
    scalarField ap
    (
        volPointInterpolation::New(mesh).interpolate(alpha)
    );
 
    cutCellIso cutCell(mesh, ap);
 
    forAll(interfaceArea_, celli)
    {
        const label status = cutCell.calcSubCell(celli, isoAlpha_);
        interfaceArea_[celli] = 0;
        if (status == 0) // cell is cut
        {
            interfaceArea_[celli] = mag(cutCell.faceArea())/mesh.V()[celli];
        }
    }
}
 
 
// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
template<class Thermo, class OtherThermo>
Foam::meltingEvaporationModels::diffusionGasEvaporation<Thermo, OtherThermo>
::diffusionGasEvaporation
(
    const dictionary& dict,
    const phasePair& pair
)
:
    InterfaceCompositionModel<Thermo, OtherThermo>(dict, pair),
    saturationModelPtr_
    (
        saturationModel::New
        (
            dict.subDict("saturationPressure"),
            this->mesh_
        )
    ),
    isoAlpha_(dict.getOrDefault<scalar>("isoAlpha", 0.5)),
    C_("C", dimless, dict),
    Tactivate_("Tactivate", dimTemperature, 0, dict),
    interfaceArea_
    (
        IOobject
        (
            "interfaceArea",
            this->mesh_.time().timeName(),
            this->mesh_,
            IOobject::NO_READ,
            IOobject::NO_WRITE
        ),
        this->mesh_,
        dimensionedScalar(dimless/dimLength, Zero)
    ),
    mDotc_
    (
        IOobject
        (
            "mDotc",
            this->mesh_.time().timeName(),
            this->mesh_,
            IOobject::NO_READ,
            IOobject::AUTO_WRITE
        ),
        this->mesh_,
        dimensionedScalar(dimDensity/dimTime, Zero)
    )
{}
 
 
// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 
template<class Thermo, class OtherThermo>
Foam::tmp<Foam::volScalarField>
Foam::meltingEvaporationModels::diffusionGasEvaporation<Thermo, OtherThermo>
::Kexp
(
    const volScalarField& T
)
{
    const fvMesh& mesh = this->mesh_;
 
    const word speciesName(IOobject::member(this->transferSpecie()));
 
    const typename OtherThermo::thermoType& vapourThermo =
        this->getLocalThermo
        (
            speciesName,
            this->toThermo_
        );
 
    const volScalarField& from = this->pair().from();
    const volScalarField& to = this->pair().to();
 
    const volScalarField& Yv = this->toThermo_.composition().Y(speciesName);
 
    updateInterface(T);
 
    auto tRhog = tmp<volScalarField>::New
    (
        IOobject
        (
            "tRhog",
            mesh.time().timeName(),
            mesh
        ),
        mesh,
        dimensionedScalar(dimDensity, Zero)
    );
    volScalarField& rhog = tRhog.ref();
    rhog = this->pair().to().rho();
 
    auto tDvg = tmp<volScalarField>::New
    (
        IOobject
        (
            "tDvg",
            mesh.time().timeName(),
            mesh
        ),
        mesh,
        dimensionedScalar(sqr(dimLength)/dimTime, Zero)
    );
    volScalarField& Dvg = tDvg.ref();
    Dvg = this->Dto(speciesName);
 
    tmp<volScalarField> tpSat = saturationModelPtr_->pSat(T);
 
    const volScalarField XvSat(tpSat()/this->toThermo_.p());
 
    const dimensionedScalar Wv("Wv", dimMass/dimMoles, vapourThermo.W());
    const volScalarField YvSat
    (
        XvSat
       *(
           Wv/(XvSat*Wv + (1-XvSat)*this->toThermo_.W())
        )
    );
 
    const volScalarField Ygm(max(from*YvSat + to*Yv, Zero));
 
    const multiphaseInterSystem& fluid = this->fluid();
 
    tmp<volVectorField> tnHatInt(fluid.nVolHatfv(to, from));
 
    const volScalarField gradYgm(fvc::grad(Ygm) & tnHatInt());
 
    mDotc_ =
       -pos(T - Tactivate_)
       *C_*rhog*Dvg*gradYgm*interfaceArea_
       /(1 - YvSat);
 
    if (debug && mesh.time().outputTime())
    {
        volScalarField pSat("pSat", saturationModelPtr_->pSat(T));
        pSat.write();
 
        volScalarField YvSat1("YvSat", YvSat);
        YvSat1.write();
 
        volScalarField YgmDebug("Ygm", Ygm);
        YgmDebug.write();
 
        volScalarField gradYgmD("gradYgm", gradYgm);
        gradYgmD.write();
 
        volVectorField nHatIntD("nHatInt", tnHatInt());
        nHatIntD.write();
    }
 
    return tmp<volScalarField>::New(mDotc_);
}
 
 
template<class Thermo, class OtherThermo>
Foam::tmp<Foam::volScalarField>
Foam::meltingEvaporationModels::diffusionGasEvaporation<Thermo, OtherThermo>::
KSp
(
    label variable,
    const volScalarField& refValue
)
{
    return nullptr;
}
 
 
template<class Thermo, class OtherThermo>
Foam::tmp<Foam::volScalarField>
Foam::meltingEvaporationModels::diffusionGasEvaporation<Thermo, OtherThermo>::
KSu
(
    label variable,
    const volScalarField& refValue
)
{
    return nullptr;
}
 
 
//************************************************************************ //