768 lines
22 KiB
C++
768 lines
22 KiB
C++
/*---------------------------------------------------------------------------*\
|
|
========= |
|
|
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
|
\\ / O peration | Website: https://openfoam.org
|
|
\\ / A nd | Copyright (C) 2015-2024 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 "ThermalPhaseChangePhaseSystem.H"
|
|
#include "heatTransferModel.H"
|
|
#include "alphatPhaseChangeWallFunctionBase.H"
|
|
#include "fvcVolumeIntegrate.H"
|
|
#include "fvmSup.H"
|
|
#include "rhoFluidMulticomponentThermo.H"
|
|
#include "wallBoilingHeatTransfer.H"
|
|
|
|
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
|
|
|
|
template<class BasePhaseSystem>
|
|
void Foam::ThermalPhaseChangePhaseSystem<BasePhaseSystem>::addDmdts
|
|
(
|
|
PtrList<volScalarField>& dmdts
|
|
) const
|
|
{
|
|
forAllConstIter(phaseSystem::dmdtfTable, dmdtfs_, dmdtfIter)
|
|
{
|
|
const phaseInterface interface(*this, dmdtfIter.key());
|
|
|
|
addField(interface.phase1(), "dmdt", *dmdtfIter(), dmdts);
|
|
addField(interface.phase2(), "dmdt", - *dmdtfIter(), dmdts);
|
|
}
|
|
|
|
forAllConstIter(phaseSystem::dmdtfTable, nDmdtfs_, nDmdtfIter)
|
|
{
|
|
const phaseInterface interface(*this, nDmdtfIter.key());
|
|
|
|
addField(interface.phase1(), "dmdt", *nDmdtfIter(), dmdts);
|
|
addField(interface.phase2(), "dmdt", - *nDmdtfIter(), dmdts);
|
|
}
|
|
}
|
|
|
|
|
|
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
|
|
|
|
template<class BasePhaseSystem>
|
|
Foam::ThermalPhaseChangePhaseSystem<BasePhaseSystem>::
|
|
ThermalPhaseChangePhaseSystem
|
|
(
|
|
const fvMesh& mesh
|
|
)
|
|
:
|
|
BasePhaseSystem(mesh),
|
|
volatile_(this->template lookupOrDefault<word>("volatile", "none")),
|
|
dmdt0s_(this->phases().size()),
|
|
pressureImplicit_
|
|
(
|
|
this->template lookupOrDefault<Switch>("pressureImplicit", true)
|
|
)
|
|
{
|
|
this->generateInterfacialModels(saturationModels_);
|
|
|
|
// Check that models have been specified in the correct combinations
|
|
forAllConstIter
|
|
(
|
|
saturationModelTable,
|
|
saturationModels_,
|
|
saturationModelIter
|
|
)
|
|
{
|
|
const phaseInterface& interface = saturationModelIter()->interface();
|
|
const phaseModel& phase1 = interface.phase1();
|
|
const phaseModel& phase2 = interface.phase2();
|
|
|
|
this->template validateMassTransfer
|
|
<
|
|
interfaceSaturationTemperatureModel
|
|
>(interface);
|
|
|
|
if
|
|
(
|
|
!this->heatTransferModels_.found(interface)
|
|
|| !this->heatTransferModels_[interface]->haveModelInThe(phase1)
|
|
|| !this->heatTransferModels_[interface]->haveModelInThe(phase2)
|
|
)
|
|
{
|
|
FatalErrorInFunction
|
|
<< "A heat transfer model for both sides of the "
|
|
<< interface.name() << " interface is not specified. This is "
|
|
<< "required by the corresponding saturation model"
|
|
<< exit(FatalError);
|
|
}
|
|
}
|
|
|
|
// Generate interfacial mass transfer fields, initially assumed to be zero
|
|
forAllConstIter
|
|
(
|
|
saturationModelTable,
|
|
saturationModels_,
|
|
saturationModelIter
|
|
)
|
|
{
|
|
const phaseInterface& interface = saturationModelIter()->interface();
|
|
|
|
dmdtfs_.insert
|
|
(
|
|
interface,
|
|
new volScalarField
|
|
(
|
|
IOobject
|
|
(
|
|
IOobject::groupName
|
|
(
|
|
"thermalPhaseChange:dmdtf",
|
|
interface.name()
|
|
),
|
|
this->mesh().time().name(),
|
|
this->mesh(),
|
|
IOobject::READ_IF_PRESENT,
|
|
IOobject::AUTO_WRITE
|
|
),
|
|
this->mesh(),
|
|
dimensionedScalar(dimDensity/dimTime, 0)
|
|
)
|
|
);
|
|
|
|
d2mdtdpfs_.insert
|
|
(
|
|
interface,
|
|
new volScalarField
|
|
(
|
|
IOobject
|
|
(
|
|
IOobject::groupName
|
|
(
|
|
"thermalPhaseChange:d2mdtdpf",
|
|
interface.name()
|
|
),
|
|
this->mesh().time().name(),
|
|
this->mesh(),
|
|
IOobject::NO_READ,
|
|
IOobject::AUTO_WRITE
|
|
),
|
|
this->mesh(),
|
|
dimensionedScalar((dimDensity/dimTime)/dimPressure, 0)
|
|
)
|
|
);
|
|
|
|
Tfs_.insert
|
|
(
|
|
interface,
|
|
new volScalarField
|
|
(
|
|
IOobject
|
|
(
|
|
IOobject::groupName
|
|
(
|
|
"thermalPhaseChange:Tf",
|
|
interface.name()
|
|
),
|
|
this->mesh().time().name(),
|
|
this->mesh(),
|
|
IOobject::READ_IF_PRESENT,
|
|
IOobject::AUTO_WRITE
|
|
),
|
|
(
|
|
interface.phase1().fluidThermo().T()
|
|
+ interface.phase2().fluidThermo().T()
|
|
)/2
|
|
)
|
|
);
|
|
|
|
Tsats_.insert
|
|
(
|
|
interface,
|
|
new volScalarField
|
|
(
|
|
IOobject
|
|
(
|
|
IOobject::groupName
|
|
(
|
|
"thermalPhaseChange:Tsat",
|
|
interface.name()
|
|
),
|
|
this->mesh().time().name(),
|
|
this->mesh(),
|
|
IOobject::READ_IF_PRESENT,
|
|
IOobject::AUTO_WRITE
|
|
),
|
|
saturationModels_[interface]->Tsat
|
|
(
|
|
interface.phase1().fluidThermo().p()
|
|
)
|
|
)
|
|
);
|
|
|
|
nDmdtfs_.insert
|
|
(
|
|
interface,
|
|
new volScalarField
|
|
(
|
|
IOobject
|
|
(
|
|
IOobject::groupName
|
|
(
|
|
"thermalPhaseChange:nucleation:dmdtf",
|
|
interface.name()
|
|
),
|
|
this->mesh().time().name(),
|
|
this->mesh(),
|
|
IOobject::READ_IF_PRESENT,
|
|
IOobject::AUTO_WRITE
|
|
),
|
|
this->mesh(),
|
|
dimensionedScalar(dimDensity/dimTime, 0)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
|
|
|
|
template<class BasePhaseSystem>
|
|
Foam::ThermalPhaseChangePhaseSystem<BasePhaseSystem>::
|
|
~ThermalPhaseChangePhaseSystem()
|
|
{}
|
|
|
|
|
|
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
|
|
|
|
template<class BasePhaseSystem>
|
|
const Foam::interfaceSaturationTemperatureModel&
|
|
Foam::ThermalPhaseChangePhaseSystem<BasePhaseSystem>::saturation
|
|
(
|
|
const phaseInterfaceKey& key
|
|
) const
|
|
{
|
|
return saturationModels_[key];
|
|
}
|
|
|
|
|
|
template<class BasePhaseSystem>
|
|
Foam::tmp<Foam::volScalarField>
|
|
Foam::ThermalPhaseChangePhaseSystem<BasePhaseSystem>::dmdtf
|
|
(
|
|
const phaseInterfaceKey& key
|
|
) const
|
|
{
|
|
tmp<volScalarField> tDmdtf = BasePhaseSystem::dmdtf(key);
|
|
|
|
if (dmdtfs_.found(key))
|
|
{
|
|
tDmdtf.ref() += *dmdtfs_[key];
|
|
}
|
|
|
|
if (nDmdtfs_.found(key))
|
|
{
|
|
tDmdtf.ref() += *nDmdtfs_[key];
|
|
}
|
|
|
|
return tDmdtf;
|
|
}
|
|
|
|
|
|
template<class BasePhaseSystem>
|
|
Foam::PtrList<Foam::volScalarField>
|
|
Foam::ThermalPhaseChangePhaseSystem<BasePhaseSystem>::dmdts() const
|
|
{
|
|
PtrList<volScalarField> dmdts(BasePhaseSystem::dmdts());
|
|
|
|
addDmdts(dmdts);
|
|
|
|
return dmdts;
|
|
}
|
|
|
|
|
|
template<class BasePhaseSystem>
|
|
Foam::PtrList<Foam::volScalarField>
|
|
Foam::ThermalPhaseChangePhaseSystem<BasePhaseSystem>::d2mdtdps() const
|
|
{
|
|
PtrList<volScalarField> d2mdtdps(BasePhaseSystem::d2mdtdps());
|
|
|
|
forAllConstIter(phaseSystem::dmdtfTable, d2mdtdpfs_, d2mdtdpfIter)
|
|
{
|
|
const phaseInterface interface(*this, d2mdtdpfIter.key());
|
|
|
|
addField(interface.phase1(), "d2mdtdp", *d2mdtdpfIter(), d2mdtdps);
|
|
addField(interface.phase2(), "d2mdtdp", - *d2mdtdpfIter(), d2mdtdps);
|
|
}
|
|
|
|
return d2mdtdps;
|
|
}
|
|
|
|
|
|
template<class BasePhaseSystem>
|
|
Foam::autoPtr<Foam::phaseSystem::momentumTransferTable>
|
|
Foam::ThermalPhaseChangePhaseSystem<BasePhaseSystem>::
|
|
momentumTransfer()
|
|
{
|
|
autoPtr<phaseSystem::momentumTransferTable> eqnsPtr =
|
|
BasePhaseSystem::momentumTransfer();
|
|
|
|
phaseSystem::momentumTransferTable& eqns = eqnsPtr();
|
|
|
|
this->addDmdtUfs(dmdtfs_, eqns);
|
|
this->addDmdtUfs(nDmdtfs_, eqns);
|
|
|
|
return eqnsPtr;
|
|
}
|
|
|
|
|
|
template<class BasePhaseSystem>
|
|
Foam::autoPtr<Foam::phaseSystem::momentumTransferTable>
|
|
Foam::ThermalPhaseChangePhaseSystem<BasePhaseSystem>::
|
|
momentumTransferf()
|
|
{
|
|
autoPtr<phaseSystem::momentumTransferTable> eqnsPtr =
|
|
BasePhaseSystem::momentumTransferf();
|
|
|
|
phaseSystem::momentumTransferTable& eqns = eqnsPtr();
|
|
|
|
this->addDmdtUfs(dmdtfs_, eqns);
|
|
this->addDmdtUfs(nDmdtfs_, eqns);
|
|
|
|
return eqnsPtr;
|
|
}
|
|
|
|
|
|
template<class BasePhaseSystem>
|
|
Foam::autoPtr<Foam::phaseSystem::heatTransferTable>
|
|
Foam::ThermalPhaseChangePhaseSystem<BasePhaseSystem>::heatTransfer() const
|
|
{
|
|
autoPtr<phaseSystem::heatTransferTable> eqnsPtr =
|
|
BasePhaseSystem::heatTransfer();
|
|
|
|
phaseSystem::heatTransferTable& eqns = eqnsPtr();
|
|
|
|
// Create temperatures at which to evaluate nucleation mass transfers
|
|
phaseSystem::dmdtfTable Tns;
|
|
forAllConstIter(phaseSystem::dmdtfTable, nDmdtfs_, nDmdtfIter)
|
|
{
|
|
const phaseInterface interface(*this, nDmdtfIter.key());
|
|
const interfaceSaturationTemperatureModel& satModel =
|
|
this->saturation(nDmdtfIter.key());
|
|
|
|
Tns.insert
|
|
(
|
|
interface,
|
|
satModel.Tsat(interface.phase1().fluidThermo().p()).ptr()
|
|
);
|
|
}
|
|
|
|
// Mass transfer terms
|
|
if (volatile_ != "none")
|
|
{
|
|
{
|
|
phaseSystem::dmidtfTable dmidtfs;
|
|
|
|
forAllConstIter(phaseSystem::dmdtfTable, dmdtfs_, dmdtfIter)
|
|
{
|
|
const phaseInterface interface(*this, dmdtfIter.key());
|
|
|
|
dmidtfs.insert(interface, new HashPtrTable<volScalarField>());
|
|
dmidtfs[interface]->insert
|
|
(
|
|
volatile_,
|
|
new volScalarField(*dmdtfIter())
|
|
);
|
|
}
|
|
|
|
this->addDmidtHefs
|
|
(
|
|
dmidtfs,
|
|
//Tfs_,
|
|
Tsats_,
|
|
latentHeatScheme::upwind,
|
|
latentHeatTransfer::mass,
|
|
eqns
|
|
);
|
|
}
|
|
{
|
|
phaseSystem::dmidtfTable nDmidtfs;
|
|
|
|
forAllConstIter(phaseSystem::dmdtfTable, nDmdtfs_, nDmdtfIter)
|
|
{
|
|
const phaseInterface interface(*this, nDmdtfIter.key());
|
|
|
|
nDmidtfs.insert(interface, new HashPtrTable<volScalarField>());
|
|
nDmidtfs[interface]->insert
|
|
(
|
|
volatile_,
|
|
new volScalarField(*nDmdtfIter())
|
|
);
|
|
}
|
|
|
|
this->addDmidtHefs
|
|
(
|
|
nDmidtfs,
|
|
Tns,
|
|
0,
|
|
latentHeatScheme::upwind,
|
|
eqns
|
|
);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this->addDmdtHefs
|
|
(
|
|
dmdtfs_,
|
|
//Tfs_,
|
|
Tsats_,
|
|
latentHeatScheme::upwind,
|
|
latentHeatTransfer::mass,
|
|
eqns
|
|
);
|
|
this->addDmdtHefs
|
|
(
|
|
nDmdtfs_,
|
|
Tns,
|
|
0,
|
|
latentHeatScheme::upwind,
|
|
eqns
|
|
);
|
|
}
|
|
|
|
// Lagging
|
|
{
|
|
PtrList<volScalarField> dmdts(this->phases().size());
|
|
|
|
addDmdts(dmdts);
|
|
|
|
forAll(this->phases(), phasei)
|
|
{
|
|
const phaseModel& phase = this->phases()[phasei];
|
|
|
|
if (dmdt0s_.set(phase.index()))
|
|
{
|
|
*eqns[phase.name()] +=
|
|
fvm::Sp
|
|
(
|
|
dmdt0s_[phase.index()] - dmdts[phase.index()],
|
|
phase.fluidThermo().he()
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
return eqnsPtr;
|
|
}
|
|
|
|
|
|
template<class BasePhaseSystem>
|
|
Foam::autoPtr<Foam::phaseSystem::specieTransferTable>
|
|
Foam::ThermalPhaseChangePhaseSystem<BasePhaseSystem>::specieTransfer() const
|
|
{
|
|
autoPtr<phaseSystem::specieTransferTable> eqnsPtr =
|
|
BasePhaseSystem::specieTransfer();
|
|
|
|
phaseSystem::specieTransferTable& eqns = eqnsPtr();
|
|
|
|
if (volatile_ != "none")
|
|
{
|
|
{
|
|
phaseSystem::dmidtfTable dmidtfs;
|
|
|
|
forAllConstIter(phaseSystem::dmdtfTable, dmdtfs_, dmdtfIter)
|
|
{
|
|
const phaseInterface interface(*this, dmdtfIter.key());
|
|
|
|
dmidtfs.insert(interface, new HashPtrTable<volScalarField>());
|
|
dmidtfs[interface]->insert
|
|
(
|
|
volatile_,
|
|
new volScalarField(*dmdtfIter())
|
|
);
|
|
}
|
|
|
|
this->addDmidtYf(dmidtfs, eqns);
|
|
}
|
|
|
|
{
|
|
phaseSystem::dmidtfTable nDmidtfs;
|
|
|
|
forAllConstIter(phaseSystem::dmdtfTable, nDmdtfs_, nDmdtfIter)
|
|
{
|
|
const phaseInterface interface(*this, nDmdtfIter.key());
|
|
|
|
nDmidtfs.insert(interface, new HashPtrTable<volScalarField>());
|
|
nDmidtfs[interface]->insert
|
|
(
|
|
volatile_,
|
|
new volScalarField(*nDmdtfIter())
|
|
);
|
|
}
|
|
|
|
this->addDmidtYf(nDmidtfs, eqns);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this->addDmdtYfs(dmdtfs_, eqns);
|
|
this->addDmdtYfs(nDmdtfs_, eqns);
|
|
}
|
|
|
|
return eqnsPtr;
|
|
}
|
|
|
|
|
|
template<class BasePhaseSystem>
|
|
void Foam::ThermalPhaseChangePhaseSystem<BasePhaseSystem>::
|
|
correctContinuityError()
|
|
{
|
|
dmdt0s_ = PtrList<volScalarField>(this->phases().size());
|
|
|
|
addDmdts(dmdt0s_);
|
|
|
|
BasePhaseSystem::correctContinuityError();
|
|
}
|
|
|
|
|
|
template<class BasePhaseSystem>
|
|
void
|
|
Foam::ThermalPhaseChangePhaseSystem<BasePhaseSystem>::correctInterfaceThermo()
|
|
{
|
|
typedef
|
|
Foam::heatTransferModels::wallBoilingHeatTransfer
|
|
wallBoilingHeatTransferModel;
|
|
|
|
HashTable<const wallBoilingHeatTransferModel*>
|
|
wallBoilingHeatTransferModels =
|
|
this->mesh().template lookupClass<wallBoilingHeatTransferModel>();
|
|
|
|
typedef
|
|
compressible::alphatPhaseChangeWallFunctionBase
|
|
alphatPhaseChangeWallFunction;
|
|
|
|
forAllConstIter
|
|
(
|
|
saturationModelTable,
|
|
saturationModels_,
|
|
saturationModelIter
|
|
)
|
|
{
|
|
const phaseInterface& interface = saturationModelIter()->interface();
|
|
const phaseModel& phase1 = interface.phase1();
|
|
const phaseModel& phase2 = interface.phase2();
|
|
const rhoFluidThermo& thermo1 = phase1.fluidThermo();
|
|
const rhoFluidThermo& thermo2 = phase2.fluidThermo();
|
|
const volScalarField& T1(thermo1.T());
|
|
const volScalarField& T2(thermo2.T());
|
|
|
|
const sidedBlendedHeatTransferModel& heatTransferModel =
|
|
this->heatTransferModels_[interface];
|
|
|
|
// Interfacial mass transfer update
|
|
{
|
|
volScalarField& dmdtf(*this->dmdtfs_[interface]);
|
|
volScalarField& Tf(*this->Tfs_[interface]);
|
|
|
|
volScalarField& Tsat(*this->Tsats_[interface]);
|
|
Tsat = saturationModelIter()->Tsat(thermo1.p());
|
|
|
|
const volScalarField L
|
|
(
|
|
volatile_ != "none"
|
|
? this->Li
|
|
(
|
|
interface,
|
|
volatile_,
|
|
dmdtf,
|
|
Tsat,
|
|
latentHeatScheme::symmetric
|
|
)
|
|
: this->L
|
|
(
|
|
interface,
|
|
dmdtf,
|
|
Tsat,
|
|
latentHeatScheme::symmetric
|
|
)
|
|
);
|
|
|
|
volScalarField H1(heatTransferModel.modelInThe(phase1).K(0));
|
|
volScalarField H2(heatTransferModel.modelInThe(phase2).K(0));
|
|
|
|
volScalarField dmdtfNew((H1*(Tsat - T1) + H2*(Tsat - T2))/L);
|
|
|
|
if (volatile_ != "none")
|
|
{
|
|
dmdtfNew *=
|
|
neg0(dmdtfNew)*phase1.Y(volatile_)
|
|
+ pos(dmdtfNew)*phase2.Y(volatile_);
|
|
}
|
|
|
|
if (pressureImplicit_)
|
|
{
|
|
volScalarField& d2mdtdpf(*this->d2mdtdpfs_[interface]);
|
|
|
|
const dimensionedScalar dp(rootSmall*thermo1.p().average());
|
|
|
|
const volScalarField dTsatdp
|
|
(
|
|
(
|
|
saturationModelIter()->Tsat(thermo1.p() + dp/2)
|
|
- saturationModelIter()->Tsat(thermo1.p() - dp/2)
|
|
)/dp
|
|
);
|
|
|
|
d2mdtdpf = (H1 + H2)*dTsatdp/L;
|
|
|
|
if (volatile_ != "none")
|
|
{
|
|
d2mdtdpf *=
|
|
neg0(dmdtfNew)*phase1.Y(volatile_)
|
|
+ pos(dmdtfNew)*phase2.Y(volatile_);
|
|
}
|
|
}
|
|
|
|
H1 = heatTransferModel.modelInThe(phase1).K();
|
|
H2 = heatTransferModel.modelInThe(phase2).K();
|
|
|
|
// Limit the H[12] to avoid /0
|
|
H1.max(small);
|
|
H2.max(small);
|
|
|
|
Tf = (H1*T1 + H2*T2 + dmdtfNew*L)/(H1 + H2);
|
|
|
|
Info<< Tsat.name()
|
|
<< ": min = " << gMin(Tsat.primitiveField())
|
|
<< ", mean = " << gAverage(Tsat.primitiveField())
|
|
<< ", max = " << gMax(Tsat.primitiveField())
|
|
<< endl;
|
|
|
|
Info<< Tf.name()
|
|
<< ": min = " << gMin(Tf.primitiveField())
|
|
<< ", mean = " << gAverage(Tf.primitiveField())
|
|
<< ", max = " << gMax(Tf.primitiveField())
|
|
<< endl;
|
|
|
|
const scalar dmdtfRelax =
|
|
this->mesh().solution().fieldRelaxationFactor(dmdtf.member());
|
|
|
|
dmdtf = (1 - dmdtfRelax)*dmdtf + dmdtfRelax*dmdtfNew;
|
|
|
|
Info<< dmdtf.name()
|
|
<< ": min = " << gMin(dmdtf.primitiveField())
|
|
<< ", mean = " << gAverage(dmdtf.primitiveField())
|
|
<< ", max = " << gMax(dmdtf.primitiveField())
|
|
<< ", integral = " << fvc::domainIntegrate(dmdtf).value()
|
|
<< endl;
|
|
}
|
|
|
|
// Nucleation mass transfer update
|
|
{
|
|
volScalarField& nDmdtf(*this->nDmdtfs_[interface]);
|
|
nDmdtf = Zero;
|
|
|
|
bool wallBoilingActive = false;
|
|
|
|
forAllConstIter
|
|
(
|
|
HashTable<const wallBoilingHeatTransferModel*>,
|
|
wallBoilingHeatTransferModels,
|
|
wallBoilingHeatTransferModelIter
|
|
)
|
|
{
|
|
const wallBoilingHeatTransferModel& wbht =
|
|
*wallBoilingHeatTransferModelIter();
|
|
|
|
if (!wbht.activePhaseInterface(interface)) continue;
|
|
|
|
wallBoilingActive = true;
|
|
|
|
nDmdtf += (wbht.flipSign() ? -1 : +1)*wbht.dmdtf();
|
|
}
|
|
|
|
forAllConstIter(phaseInterface, interface, interfaceIter)
|
|
{
|
|
const phaseModel& phase = interfaceIter();
|
|
|
|
const word alphatName =
|
|
IOobject::groupName("alphat", phase.name());
|
|
|
|
if (!phase.mesh().foundObject<volScalarField>(alphatName))
|
|
continue;
|
|
|
|
const volScalarField& alphat =
|
|
phase.mesh().lookupObject<volScalarField>(alphatName);
|
|
|
|
forAll(alphat.boundaryField(), patchi)
|
|
{
|
|
const fvPatchScalarField& alphatp =
|
|
alphat.boundaryField()[patchi];
|
|
|
|
if (!isA<alphatPhaseChangeWallFunction>(alphatp)) continue;
|
|
|
|
const alphatPhaseChangeWallFunction& alphatw =
|
|
refCast<const alphatPhaseChangeWallFunction>(alphatp);
|
|
|
|
if (!alphatw.activeInterface(interface)) continue;
|
|
|
|
wallBoilingActive = true;
|
|
|
|
UIndirectList<scalar> nDmdtfp
|
|
(
|
|
nDmdtf.primitiveFieldRef(),
|
|
alphatp.patch().faceCells()
|
|
);
|
|
|
|
nDmdtfp =
|
|
scalarField(nDmdtfp)
|
|
- (interfaceIter.index() == 0 ? +1 : -1)
|
|
*alphatw.dmdtf();
|
|
}
|
|
}
|
|
|
|
if (wallBoilingActive)
|
|
{
|
|
Info<< nDmdtf.name()
|
|
<< ": min = " << gMin(nDmdtf.primitiveField())
|
|
<< ", mean = " << gAverage(nDmdtf.primitiveField())
|
|
<< ", max = " << gMax(nDmdtf.primitiveField())
|
|
<< ", integral = " << fvc::domainIntegrate(nDmdtf).value()
|
|
<< endl;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
template<class BasePhaseSystem>
|
|
bool Foam::ThermalPhaseChangePhaseSystem<BasePhaseSystem>::read()
|
|
{
|
|
if (BasePhaseSystem::read())
|
|
{
|
|
bool readOK = true;
|
|
|
|
// Models ...
|
|
|
|
return readOK;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
// ************************************************************************* //
|