zhyang-dev/OpenFOAM-12
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

multiphaseEuler: Function to extract wall boiling model properties

Browse Source 
This function looks up wall boiling wall functions and collects and
writes out the following data:

  - Bubble departure diameter
  - Bubble departure frequency
  - Nucleation site density
  - Effective liquid fraction at the wall
  - Quenching heat flux
  - Evaporative heat flux

Example of function object specification:

    \verbatim
    writeWallBoilingProperties
    {
        type            wallBoilingProperties;
        functionObjectLibs ( "libmultiphaseEulerFoamFunctionObjects.so" );
        writeControl    writeTime;
        phase           liquid;
    }
    \endverbatim

Patch contributed by Juho Peltola, VTT.
This commit is contained in:
Will Bainbridge
2022-11-03 17:17:43 +00:00
parent ee4f05411d
commit 0da49126b4
6 changed files with 482 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
applications/solvers/modules/fluid/multiphaseEuler/functionObjects/Make/files
View File

@ -2,5 +2,6 @@ populationBalanceMoments/populationBalanceMoments.C
populationBalanceSizeDistribution/populationBalanceSizeDistribution.C
phaseForces/phaseForces.C
phaseMap/phaseMap.C
wallBoilingProperties/wallBoilingProperties.C
LIB = $(FOAM_LIBBIN)/libmultiphaseEulerFoamFunctionObjects

2
applications/solvers/modules/fluid/multiphaseEuler/functionObjects/Make/options
View File

@ -1,6 +1,7 @@
EXE_INC = \
-I../phaseSystems/lnInclude \
-I../interfacialModels/lnInclude \
-I../multiphaseCompressibleMomentumTransportModels/lnInclude \
-I$(LIB_SRC)/physicalProperties/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
-I$(LIB_SRC)/MomentumTransportModels/momentumTransportModels/lnInclude \
@ -15,6 +16,7 @@ EXE_INC = \
LIB_LIBS = \
-lphaseSystem \
-lmultiphaseSystems \
-lmultiphaseMomentumTransportModels \
-leulerianInterfacialModels \
-leulerianInterfacialCompositionModels \
-lmultiphaseMomentumTransportModels \

200
applications/solvers/modules/fluid/multiphaseEuler/functionObjects/wallBoilingProperties/wallBoilingProperties.C Normal file
View File

@ -0,0 +1,200 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
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 "wallBoilingProperties.H"
#include "addToRunTimeSelectionTable.H"
#include "alphatWallBoilingWallFunctionFvPatchScalarField.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace functionObjects
{
defineTypeNameAndDebug(wallBoilingProperties, 0);
addToRunTimeSelectionTable
(
functionObject,
wallBoilingProperties,
dictionary
);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::functionObjects::wallBoilingProperties::wallBoilingProperties
(
const word& name,
const Time& runTime,
const dictionary& dict
)
:
fvMeshFunctionObject(name, runTime, dict),
phase_
(
mesh_.lookupObject<phaseModel>
(
IOobject::groupName("alpha", dict.lookup("phase"))
)
),
fluid_(mesh_.lookupObject<phaseSystem>("phaseProperties"))
{
read(dict);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::functionObjects::wallBoilingProperties::~wallBoilingProperties()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool Foam::functionObjects::wallBoilingProperties::read(const dictionary& dict)
{
fvMeshFunctionObject::read(dict);
return true;
}
bool Foam::functionObjects::wallBoilingProperties::execute()
{
return true;
}
bool Foam::functionObjects::wallBoilingProperties::write()
{
volScalarField dDepartureField
(
volScalarField::New
(
IOobject::groupName("dDeparture", phase_.name()),
mesh_,
dimensionedScalar(dimLength, 0)
)
);
volScalarField fDepartureField
(
volScalarField::New
(
IOobject::groupName("fDeparture", phase_.name()),
mesh_,
dimensionedScalar(inv(dimTime), 0)
)
);
volScalarField nucSiteDensityField
(
volScalarField::New
(
IOobject::groupName("nucleationSiteDensity", phase_.name()),
mesh_,
dimensionedScalar(inv(dimArea), 0)
)
);
volScalarField fLiquidField
(
volScalarField::New
(
IOobject::groupName("fLiquid", phase_.name()),
mesh_,
dimensionedScalar(dimless, 0)
)
);
volScalarField quenchingHeatFluxField
(
volScalarField::New
(
IOobject::groupName("quenchingHeatFlux", phase_.name()),
mesh_,
dimensionedScalar(dimEnergy*inv(dimTime*dimArea), 0)
)
);
volScalarField evaporativeHeatFluxField
(
volScalarField::New
(
IOobject::groupName("evaporativeHeatFlux", phase_.name()),
mesh_,
dimensionedScalar(dimEnergy*inv(dimTime*dimArea), 0)
)
);
typedef compressible::alphatWallBoilingWallFunctionFvPatchScalarField
alphatWallBoilingWallFunction;
const word alphatName =
IOobject::groupName("alphat", phase_.name());
if (phase_.mesh().foundObject<volScalarField>(alphatName))
{
const volScalarField& alphat =
phase_.mesh().lookupObject<volScalarField>(alphatName);
const volScalarField::Boundary& alphatBf = alphat.boundaryField();
forAll(alphatBf, patchi)
{
if (isA<alphatWallBoilingWallFunction>(alphatBf[patchi]))
{
const alphatWallBoilingWallFunction& alphatw =
refCast
<
const alphatWallBoilingWallFunction
>(alphatBf[patchi]);
dDepartureField.boundaryFieldRef()[patchi] =
alphatw.dDeparture();
fDepartureField.boundaryFieldRef()[patchi] =
alphatw.depFrequency();
nucSiteDensityField.boundaryFieldRef()[patchi] =
alphatw.nucSiteDensity();
fLiquidField.boundaryFieldRef()[patchi] =
alphatw.wallLiquidFraction();
quenchingHeatFluxField.boundaryFieldRef()[patchi] =
alphatw.quenching();
evaporativeHeatFluxField.boundaryFieldRef()[patchi] =
alphatw.evaporative();
}
}
}
dDepartureField.write();
fDepartureField.write();
nucSiteDensityField.write();
fLiquidField.write();
quenchingHeatFluxField.write();
evaporativeHeatFluxField.write();
return true;
}
// ************************************************************************* //

149
applications/solvers/modules/fluid/multiphaseEuler/functionObjects/wallBoilingProperties/wallBoilingProperties.H Normal file
View File

@ -0,0 +1,149 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
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::functionObjects::wallBoilingProperties
Description
This function looks up wall boiling wall functions and collects and writes
out out the following data:
- Bubble departure diameter
- Bubble departure frequency
- Nucleation site density
- Effective liquid fraction at the wall
- Quenching heat flux
- Evaporative heat flux
Example of function object specification:
\verbatim
writeWallBoilingProperties
{
type wallBoilingProperties;
functionObjectLibs ( "libmultiphaseEulerFoamFunctionObjects.so" );
writeControl writeTime;
phase liquid;
}
\endverbatim
Usage
\table
Property | Description | Required | Default value
type | type name: wallBoilingProperties | yes |
phase | phase name | yes | none
\endtable
SourceFiles
wallBoilingProperties.C
\*---------------------------------------------------------------------------*/
#ifndef wallBoilingProperties_H
#define wallBoilingProperties_H
#include "fvMeshFunctionObject.H"
#include "phaseSystem.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace functionObjects
{
/*---------------------------------------------------------------------------*\
Class wallBoilingProperties Declaration
\*---------------------------------------------------------------------------*/
class wallBoilingProperties
:
public fvMeshFunctionObject
{
// Private data
//- Phase model
const phaseModel& phase_;
//- Constant access to phaseSystem
const phaseSystem& fluid_;
public:
//- Runtime type information
TypeName("wallBoilingProperties");
// Constructors
//- Construct from Time and dictionary
wallBoilingProperties
(
const word& name,
const Time& runTime,
const dictionary& dict
);
//- Disallow default bitwise copy construction
wallBoilingProperties(const wallBoilingProperties&) = delete;
//- Destructor
virtual ~wallBoilingProperties();
// Member Functions
//- Read the wallBoilingProperties data
virtual bool read(const dictionary&);
//- Return the list of fields required
virtual wordList fields() const
{
return wordList::null();
}
//- Calculate the wallBoilingProperties field
virtual bool execute();
//- Write the wallBoilingProperties field
virtual bool write();
// Member Operators
//- Disallow default bitwise assignment
void operator=(const wallBoilingProperties&) = delete;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace functionObjects
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

118
applications/solvers/modules/fluid/multiphaseEuler/multiphaseCompressibleMomentumTransportModels/derivedFvPatchFields/alphatWallBoilingWallFunction/alphatWallBoilingWallFunctionFvPatchScalarField.C
View File

@ -79,7 +79,11 @@ alphatWallBoilingWallFunctionFvPatchScalarField
AbyV_(p.size(), 0),
alphatConv_(p.size(), 0),
dDep_(p.size(), 1e-5),
fDep_(p.size(), 0),
N_(p.size(), 0),
fLiquid_(p.size(), 0),
qq_(p.size(), 0),
qe_(p.size(), 0),
partitioningModel_(nullptr),
nucleationSiteModel_(nullptr),
departureDiamModel_(nullptr),
@ -107,7 +111,11 @@ alphatWallBoilingWallFunctionFvPatchScalarField
AbyV_(p.size(), 0),
alphatConv_(p.size(), 0),
dDep_(p.size(), 1e-5),
fDep_(p.size(), 0),
N_(p.size(), 0),
fLiquid_(p.size(), 0),
qq_(p.size(), 0),
qe_(p.size(), 0),
partitioningModel_(nullptr),
nucleationSiteModel_(nullptr),
departureDiamModel_(nullptr),
@ -164,9 +172,24 @@ alphatWallBoilingWallFunctionFvPatchScalarField
dict.subDict("departureFreqModel")
);
if (dict.found("dDep"))
if (dict.found("dDeparture"))
{
dDep_ = scalarField("dDep", dict, p.size());
dDep_ = scalarField("dDeparture", dict, p.size());
}
if (dict.found("depFrequency"))
{
fDep_ = scalarField("depFrequency", dict, p.size());
}
if (dict.found("nucSiteDensity"))
{
N_ = scalarField("nucSiteDensity", dict, p.size());
}
if (dict.found("wallLiquidFraction"))
{
fLiquid_ = scalarField("wallLiquidFraction", dict, p.size());
}
if (dict.found("qQuenching"))
@ -174,6 +197,11 @@ alphatWallBoilingWallFunctionFvPatchScalarField
qq_ = scalarField("qQuenching", dict, p.size());
}
if (dict.found("qEvaporation"))
{
qq_ = scalarField("qEvaporation", dict, p.size());
}
break;
}
}
@ -212,7 +240,11 @@ alphatWallBoilingWallFunctionFvPatchScalarField
AbyV_(mapper(psf.AbyV_)),
alphatConv_(mapper(psf.alphatConv_)),
dDep_(mapper(psf.dDep_)),
fDep_(mapper(psf.fDep_)),
N_(mapper(psf.N_)),
fLiquid_(mapper(psf.fLiquid_)),
qq_(mapper(psf.qq_)),
qe_(mapper(psf.qe_)),
partitioningModel_(psf.partitioningModel_, false),
nucleationSiteModel_(psf.nucleationSiteModel_, false),
departureDiamModel_(psf.departureDiamModel_, false),
@ -232,7 +264,11 @@ alphatWallBoilingWallFunctionFvPatchScalarField
AbyV_(psf.AbyV_),
alphatConv_(psf.alphatConv_),
dDep_(psf.dDep_),
fDep_(psf.fDep_),
N_(psf.N_),
fLiquid_(psf.fLiquid_),
qq_(psf.qq_),
qe_(psf.qe_),
partitioningModel_(psf.partitioningModel_, false),
nucleationSiteModel_(psf.nucleationSiteModel_, false),
departureDiamModel_(psf.departureDiamModel_, false),
@ -252,7 +288,11 @@ void alphatWallBoilingWallFunctionFvPatchScalarField::autoMap
m(AbyV_, AbyV_);
m(alphatConv_, alphatConv_);
m(dDep_, dDep_);
m(fDep_, fDep_);
m(N_, N_);
m(fLiquid_, fLiquid_);
m(qq_, qq_);
m(qe_, qe_);
}
@ -270,7 +310,11 @@ void alphatWallBoilingWallFunctionFvPatchScalarField::rmap
AbyV_.rmap(tiptf.AbyV_, addr);
alphatConv_.rmap(tiptf.alphatConv_, addr);
dDep_.rmap(tiptf.dDep_, addr);
fDep_.rmap(tiptf.fDep_, addr);
N_.rmap(tiptf.N_, addr);
fLiquid_.rmap(tiptf.fLiquid_, addr);
qq_.rmap(tiptf.qq_, addr);
qe_.rmap(tiptf.qe_, addr);
}
@ -287,7 +331,11 @@ void alphatWallBoilingWallFunctionFvPatchScalarField::reset
AbyV_.reset(tiptf.AbyV_);
alphatConv_.reset(tiptf.alphatConv_);
dDep_.reset(tiptf.dDep_);
fDep_.reset(tiptf.fDep_);
N_.reset(tiptf.N_);
fLiquid_.reset(tiptf.fLiquid_);
qq_.reset(tiptf.qq_);
qe_.reset(tiptf.qe_);
}
@ -316,13 +364,17 @@ void alphatWallBoilingWallFunctionFvPatchScalarField::updateCoeffs()
const scalarField& vaporw = vapor.boundaryField()[patchi];
// Partitioning
// NOTE! Assumes 1-thisPhase for liquid fraction in
// multiphase simulations
const scalarField fLiquid(partitioningModel_->fLiquid(1 - vaporw));
// NOTE! Assumes that there is only only one liquid phase and all
// other phases are vapor
const phaseModel& liquid = fluid.phases()[otherPhaseName_];
const scalarField& liquidw = liquid.boundaryField()[patchi];
fLiquid_ = partitioningModel_->fLiquid(liquidw);
operator==
(
calcAlphat(*this)*(1 - fLiquid)/max(vaporw, scalar(1e-8))
calcAlphat(*this)*(vaporw/(1 - liquidw + small) )
*(1 - fLiquid_)/max(vaporw, scalar(1e-8))
);
break;
}
@ -441,7 +493,7 @@ void alphatWallBoilingWallFunctionFvPatchScalarField::updateCoeffs()
const scalarField liquidw(liquid.boundaryField()[patchi]);
// Partitioning
const scalarField fLiquid(partitioningModel_->fLiquid(liquidw));
fLiquid_ = partitioningModel_->fLiquid(liquidw);
// Convective thermal diffusivity
alphatConv_ = calcAlphat(alphatConv_);
@ -483,8 +535,7 @@ void alphatWallBoilingWallFunctionFvPatchScalarField::updateCoeffs()
);
// Bubble departure frequency:
const scalarField fDep
(
fDep_ =
departureFreqModel_->fDeparture
(
liquid,
@ -494,12 +545,10 @@ void alphatWallBoilingWallFunctionFvPatchScalarField::updateCoeffs()
Tsatw,
L,
dDep_
)
);
);
// Nucleation site density:
const scalarField N
(
N_ =
nucleationSiteModel_->N
(
liquid,
@ -509,9 +558,8 @@ void alphatWallBoilingWallFunctionFvPatchScalarField::updateCoeffs()
Tsatw,
L,
dDep_,
fDep
)
);
fDep_
);
// Area fractions:
@ -523,12 +571,12 @@ void alphatWallBoilingWallFunctionFvPatchScalarField::updateCoeffs()
const scalarField Al
(
fLiquid*4.8*exp(min(-Ja/80, log(vGreat)))
fLiquid_*4.8*exp(min(-Ja/80, log(vGreat)))
);
scalarField A2(min(pi*sqr(dDep_)*N*Al/4, scalar(1)));
scalarField A2(min(pi*sqr(dDep_)*N_*Al/4, scalar(1)));
const scalarField A1(max(1 - A2, scalar(1e-4)));
scalarField A2E(min(pi*sqr(dDep_)*N*Al/4, scalar(5)));
scalarField A2E(min(pi*sqr(dDep_)*N_*Al/4, scalar(5)));
if (volatileSpecie != "none" && !liquid.pure())
{
@ -542,15 +590,15 @@ void alphatWallBoilingWallFunctionFvPatchScalarField::updateCoeffs()
// wall boiling
dmdtf_ =
(1 - relax_)*dmdtf_
+ relax_*(1.0/6.0)*A2E*dDep_*rhoVaporw*fDep*AbyV_;
+ relax_*(1.0/6.0)*A2E*dDep_*rhoVaporw*fDep_*AbyV_;
// Quenching heat transfer coefficient
const scalarField hQ
(
2*(alphaw*Cpw)*fDep
2*(alphaw*Cpw)*fDep_
*sqrt
(
(0.8/max(fDep, small))/(pi*alphaw/rhoLiquidw)
(0.8/max(fDep_, small))/(pi*alphaw/rhoLiquidw)
)
);
@ -560,7 +608,7 @@ void alphatWallBoilingWallFunctionFvPatchScalarField::updateCoeffs()
+ relax_*(A2*hQ*max(Tw - Tl, scalar(0)));
// Evaporation heat flux
const scalarField qe(dmdtf_*L/AbyV_);
qe_ = dmdtf_*L/AbyV_;
// Effective thermal diffusivity that corresponds to the
// calculated convective, quenching and evaporative heat
@ -570,7 +618,7 @@ void alphatWallBoilingWallFunctionFvPatchScalarField::updateCoeffs()
(
(
A1*alphatConv_
+ (qq_ + qe)/max(hew.snGrad(), scalar(1e-16))
+ (qq_ + qe_)/max(hew.snGrad(), scalar(1e-16))
)
/max(liquidw, scalar(1e-8))
);
@ -585,7 +633,7 @@ void alphatWallBoilingWallFunctionFvPatchScalarField::updateCoeffs()
{
const scalarField qc
(
fLiquid*A1*(alphatConv_ + alphaw)*hew.snGrad()
fLiquid_*A1*(alphatConv_ + alphaw)*hew.snGrad()
);
const scalarField qEff
@ -596,11 +644,11 @@ void alphatWallBoilingWallFunctionFvPatchScalarField::updateCoeffs()
Info<< " L: " << gMin(L) << " - " << gMax(L) << endl;
Info<< " Tl: " << gMin(Tl) << " - " << gMax(Tl)
<< endl;
Info<< " N: " << gMin(N) << " - " << gMax(N) << endl;
Info<< " N: " << gMin(N_) << " - " << gMax(N_) << endl;
Info<< " dDep_: " << gMin(dDep_) << " - "
<< gMax(dDep_) << endl;
Info<< " fDep: " << gMin(fDep) << " - "
<< gMax(fDep) << endl;
Info<< " fDep: " << gMin(fDep_) << " - "
<< gMax(fDep_) << endl;
Info<< " Al: " << gMin(Al) << " - " << gMax(Al)
<< endl;
Info<< " A1: " << gMin(A1) << " - " << gMax(A1)
@ -613,10 +661,10 @@ void alphatWallBoilingWallFunctionFvPatchScalarField::updateCoeffs()
<< gMax(dmdtf_) << endl;
Info<< " qc: " << gMin(qc) << " - " << gMax(qc)
<< endl;
Info<< " qq: " << gMin(fLiquid*qq_) << " - "
<< gMax(fLiquid*qq_) << endl;
Info<< " qe: " << gMin(fLiquid*qe) << " - "
<< gMax(fLiquid*qe) << endl;
Info<< " qq: " << gMin(fLiquid_*qq_) << " - "
<< gMax(fLiquid_*qq_) << endl;
Info<< " qe: " << gMin(fLiquid_*qe_) << " - "
<< gMax(fLiquid_*qe_) << endl;
Info<< " qEff: " << gMin(qEff) << " - "
<< gMax(qEff) << endl;
Info<< " alphat: " << gMin(*this) << " - "
@ -672,8 +720,12 @@ void alphatWallBoilingWallFunctionFvPatchScalarField::write(Ostream& os) const
writeEntry(os, "phaseType", phaseTypeNames_[phaseType_]);
writeEntry(os, "alphatConv", alphatConv_);
writeEntry(os, "dDep", dDep_);
writeEntry(os, "dDeparture", dDep_);
writeEntry(os, "depFrequency", fDep_);
writeEntry(os, "nucSiteDensity", N_);
writeEntry(os, "wallLiquidFraction", fLiquid_);
writeEntry(os, "qQuenching", qq_);
writeEntry(os, "qEvaporative", qe_);
switch (phaseType_)
{

47
applications/solvers/modules/fluid/multiphaseEuler/multiphaseCompressibleMomentumTransportModels/derivedFvPatchFields/alphatWallBoilingWallFunction/alphatWallBoilingWallFunctionFvPatchScalarField.H
View File

@ -184,12 +184,25 @@ private:
//- Convective turbulent thermal diffusivity
scalarField alphatConv_;
//- Departure diameter field
//- Departure diameter
scalarField dDep_;
//- Departure frequency
scalarField fDep_;
//- Nucleation site density
scalarField N_;
//- Wall liquid fraction
scalarField fLiquid_;
//- Quenching surface heat flux
scalarField qq_;
//- Evaporative surface heat flux
scalarField qe_;
//- Run-time selected heat flux partitioning model
autoPtr<wallBoilingModels::partitioningModel>
partitioningModel_;
@ -269,12 +282,42 @@ public:
// Member Functions
//- Return the departure diameter field
//- Return the departure diameter field [m]
const scalarField& dDeparture() const
{
return dDep_;
}
//- Return the departure frequency field [Hz]
const scalarField& depFrequency() const
{
return fDep_;
}
//- Return the nucleation site density field [1/m^2]
const scalarField& nucSiteDensity() const
{
return N_;
}
//- Return the wall liquid fraction field [-]
const scalarField& wallLiquidFraction() const
{
return fLiquid_;
}
//- Return the quenching surface heat flux field [W/m^2]
const scalarField& quenching() const
{
return qq_;
}
//- Return the evaporative surface heat flux field [W/m^2]
const scalarField& evaporative() const
{
return qe_;
}
// Mapping functions