zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

reactingTwoPhaseEulerFoam: Added thermal wall-functions with support for wall-boiling

Browse Source 
Code and tutorial case provided by Juho Peltola
This commit is contained in:
Henry Weller
2015-11-27 18:51:23 +00:00
parent 2588d78906
commit 2dbf835485
38 changed files with 29349 additions and 286 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseCompressibleTurbulenceModels/Make/files
View File

@ -35,7 +35,9 @@ kineticTheoryModels/frictionalStressModel/Schaeffer/SchaefferFrictionalStress.C
kineticTheoryModels/derivedFvPatchFields/JohnsonJacksonParticleTheta/JohnsonJacksonParticleThetaFvPatchScalarField.C kineticTheoryModels/derivedFvPatchFields/JohnsonJacksonParticleTheta/JohnsonJacksonParticleThetaFvPatchScalarField.C
kineticTheoryModels/derivedFvPatchFields/JohnsonJacksonParticleSlip/JohnsonJacksonParticleSlipFvPatchVectorField.C kineticTheoryModels/derivedFvPatchFields/JohnsonJacksonParticleSlip/JohnsonJacksonParticleSlipFvPatchVectorField.C
derivedFvPatchFields/alphatPhaseChangeJayatillekeWallFunction/alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField.C
derivedFvPatchFields/alphatFixedDmdtWallBoilingWallFunction/alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField.C derivedFvPatchFields/alphatFixedDmdtWallBoilingWallFunction/alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField.C
derivedFvPatchFields/alphatWallBoilingWallFunction/alphatWallBoilingWallFunctionFvPatchScalarField.C
derivedFvPatchFields/copiedFixedValue/copiedFixedValueFvPatchScalarField.C derivedFvPatchFields/copiedFixedValue/copiedFixedValueFvPatchScalarField.C
derivedFvPatchFields/fixedMultiPhaseHeatFlux/fixedMultiPhaseHeatFluxFvPatchScalarField.C derivedFvPatchFields/fixedMultiPhaseHeatFlux/fixedMultiPhaseHeatFluxFvPatchScalarField.C

265
applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseCompressibleTurbulenceModels/derivedFvPatchFields/alphatFixedDmdtWallBoilingWallFunction/alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField.C Normal file → Executable file
View File

@ -27,14 +27,6 @@ License
#include "fvPatchFieldMapper.H" #include "fvPatchFieldMapper.H"
#include "addToRunTimeSelectionTable.H" #include "addToRunTimeSelectionTable.H"
#include "twoPhaseSystem.H"
#include "ThermalPhaseChangePhaseSystem.H"
#include "MomentumTransferPhaseSystem.H"
#include "compressibleTurbulenceModel.H"
#include "ThermalDiffusivity.H"
#include "PhaseCompressibleTurbulenceModel.H"
#include "wallFvPatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam namespace Foam
@ -42,82 +34,6 @@ namespace Foam
namespace compressible namespace compressible
{ {
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
scalar alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField::maxExp_
= 50.0;
scalar alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField::tolerance_
= 0.01;
label alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField::maxIters_
= 10;
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField::checkType()
{
if (!isA<wallFvPatch>(patch()))
{
FatalErrorInFunction
<< "Patch type for patch " << patch().name() << " must be wall\n"
<< "Current patch type is " << patch().type() << nl
<< exit(FatalError);
}
}
tmp<scalarField>
alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField::Psmooth
(
const scalarField& Prat
) const
{
return 9.24*(pow(Prat, 0.75) - 1.0)*(1.0 + 0.28*exp(-0.007*Prat));
}
tmp<scalarField>
alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField::yPlusTherm
(
const scalarField& P,
const scalarField& Prat
) const
{
tmp<scalarField> typsf(new scalarField(this->size()));
scalarField& ypsf = typsf();
forAll(ypsf, faceI)
{
scalar ypt = 11.0;
for (int i=0; i<maxIters_; i++)
{
scalar f = ypt - (log(E_*ypt)/kappa_ + P[faceI])/Prat[faceI];
scalar df = 1.0 - 1.0/(ypt*kappa_*Prat[faceI]);
scalar yptNew = ypt - f/df;
if (yptNew < VSMALL)
{
ypsf[faceI] = 0;
}
else if (mag(yptNew - ypt) < tolerance_)
{
ypsf[faceI] = yptNew;
}
else
{
ypt = yptNew;
}
}
ypsf[faceI] = ypt;
}
return typsf;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField:: alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField::
@ -127,13 +43,10 @@ alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField
const DimensionedField<scalar, volMesh>& iF const DimensionedField<scalar, volMesh>& iF
) )
: :
alphatPhaseChangeWallFunctionFvPatchScalarField(p, iF), alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField(p, iF),
Prt_(0.85), relax_(1.0),
Cmu_(0.09), fixedDmdt_(0.0),
kappa_(0.41), L_(0.0)
E_(9.8),
dmdtRelax_(1.0),
fixedDmdt_(0.0)
{ {
checkType(); checkType();
} }
@ -147,13 +60,10 @@ alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField
const dictionary& dict const dictionary& dict
) )
: :
alphatPhaseChangeWallFunctionFvPatchScalarField(p, iF, dict), alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField(p, iF, dict),
Prt_(dict.lookupOrDefault<scalar>("Prt", 0.85)), relax_(dict.lookupOrDefault<scalar>("relax", 1.0)),
Cmu_(dict.lookupOrDefault<scalar>("Cmu", 0.09)), fixedDmdt_(dict.lookupOrDefault<scalar>("fixedDmdt", 0.0)),
kappa_(dict.lookupOrDefault<scalar>("kappa", 0.41)), L_(dict.lookupOrDefault<scalar>("L", 0.0))
E_(dict.lookupOrDefault<scalar>("E", 9.8)),
dmdtRelax_(dict.lookupOrDefault<scalar>("dmdtRelax", 1.0)),
fixedDmdt_(dict.lookupOrDefault<scalar>("fixedDmdt", 0.0))
{} {}
@ -166,13 +76,15 @@ alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField
const fvPatchFieldMapper& mapper const fvPatchFieldMapper& mapper
) )
: :
alphatPhaseChangeWallFunctionFvPatchScalarField(psf, p, iF, mapper), alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
Prt_(psf.Prt_), (
Cmu_(psf.Cmu_), psf,
kappa_(psf.kappa_), p,
E_(psf.E_), iF,
dmdtRelax_(psf.dmdtRelax_), mapper
fixedDmdt_(psf.fixedDmdt_) ),
fixedDmdt_(psf.fixedDmdt_),
L_(psf.L_)
{} {}
@ -182,16 +94,12 @@ alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField
const alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField& psf const alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField& psf
) )
: :
alphatPhaseChangeWallFunctionFvPatchScalarField(psf), alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField(psf),
Prt_(psf.Prt_), relax_(psf.relax_),
Cmu_(psf.Cmu_), fixedDmdt_(psf.fixedDmdt_),
kappa_(psf.kappa_), L_(psf.L_)
E_(psf.E_),
dmdtRelax_(psf.dmdtRelax_),
fixedDmdt_(psf.fixedDmdt_)
{} {}
alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField:: alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField::
alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField
( (
@ -199,13 +107,10 @@ alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField
const DimensionedField<scalar, volMesh>& iF const DimensionedField<scalar, volMesh>& iF
) )
: :
alphatPhaseChangeWallFunctionFvPatchScalarField(psf, iF), alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField(psf, iF),
Prt_(psf.Prt_), relax_(psf.relax_),
Cmu_(psf.Cmu_), fixedDmdt_(psf.fixedDmdt_),
kappa_(psf.kappa_), L_(psf.L_)
E_(psf.E_),
dmdtRelax_(psf.dmdtRelax_),
fixedDmdt_(psf.fixedDmdt_)
{} {}
@ -218,117 +123,10 @@ void alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField::updateCoeffs()
return; return;
} }
// Lookup the fluid model dmdt_ = (1 - relax_)*dmdt_ + relax_*fixedDmdt_;
const ThermalPhaseChangePhaseSystem mDotL_ = dmdt_*L_;
<
MomentumTransferPhaseSystem<twoPhaseSystem>
>& fluid =
refCast
<
const ThermalPhaseChangePhaseSystem
<
MomentumTransferPhaseSystem<twoPhaseSystem>
>
>
(
db().lookupObject<phaseSystem>("phaseProperties")
);
const phaseModel& liquid operator==(calcAlphat(*this));
(
fluid.phase1().name() == dimensionedInternalField().group()
? fluid.phase1()
: fluid.phase2()
);
const label patchi = patch().index();
// Retrieve turbulence properties from model
const phaseCompressibleTurbulenceModel& turbModel = liquid.turbulence();
const scalar Cmu25 = pow025(Cmu_);
const scalarField& y = turbModel.y()[patchi];
const tmp<scalarField> tmuw = turbModel.mu(patchi);
const scalarField& muw = tmuw();
const tmp<scalarField> talphaw = liquid.thermo().alpha(patchi);
const scalarField& alphaw = talphaw();
scalarField& alphatw = *this;
const tmp<volScalarField> tk = turbModel.k();
const volScalarField& k = tk();
const fvPatchScalarField& kw = k.boundaryField()[patchi];
const fvPatchVectorField& Uw = turbModel.U().boundaryField()[patchi];
const scalarField magUp(mag(Uw.patchInternalField() - Uw));
const scalarField magGradUw(mag(Uw.snGrad()));
const fvPatchScalarField& rhow = turbModel.rho().boundaryField()[patchi];
const fvPatchScalarField& hew =
liquid.thermo().he().boundaryField()[patchi];
const fvPatchScalarField& Tw =
liquid.thermo().T().boundaryField()[patchi];
scalarField Tp(Tw.patchInternalField());
// Heat flux [W/m2] - lagging alphatw
const scalarField qDot
(
(alphatw + alphaw)*hew.snGrad()
);
scalarField uTau(Cmu25*sqrt(kw));
scalarField yPlus(uTau*y/(muw/rhow));
scalarField Pr(muw/alphaw);
// Molecular-to-turbulent Prandtl number ratio
scalarField Prat(Pr/Prt_);
// Thermal sublayer thickness
scalarField P(this->Psmooth(Prat));
scalarField yPlusTherm(this->yPlusTherm(P, Prat));
scalarField alphatConv(this->size(), 0.0);
// Populate boundary values
forAll(alphatw, faceI)
{
// Evaluate new effective thermal diffusivity
scalar alphaEff = 0.0;
if (yPlus[faceI] < yPlusTherm[faceI])
{
scalar A = qDot[faceI]*rhow[faceI]*uTau[faceI]*y[faceI];
scalar B = qDot[faceI]*Pr[faceI]*yPlus[faceI];
scalar C = Pr[faceI]*0.5*rhow[faceI]*uTau[faceI]*sqr(magUp[faceI]);
alphaEff = A/(B + C + VSMALL);
}
else
{
scalar A = qDot[faceI]*rhow[faceI]*uTau[faceI]*y[faceI];
scalar B =
qDot[faceI]*Prt_*(1.0/kappa_*log(E_*yPlus[faceI]) + P[faceI]);
scalar magUc =
uTau[faceI]/kappa_*log(E_*yPlusTherm[faceI]) - mag(Uw[faceI]);
scalar C =
0.5*rhow[faceI]*uTau[faceI]
*(Prt_*sqr(magUp[faceI]) + (Pr[faceI] - Prt_)*sqr(magUc));
alphaEff = A/(B + C + VSMALL);
}
// Update convective heat transfer turbulent thermal diffusivity
alphatConv[faceI] = max(0.0, alphaEff - alphaw[faceI]);
}
dmdt_ = (1 - dmdtRelax_)*dmdt_ + dmdtRelax_*fixedDmdt_;
operator==(alphatConv);
fixedValueFvPatchScalarField::updateCoeffs(); fixedValueFvPatchScalarField::updateCoeffs();
} }
@ -340,12 +138,9 @@ void alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField::write
) const ) const
{ {
fvPatchField<scalar>::write(os); fvPatchField<scalar>::write(os);
os.writeKeyword("Prt") << Prt_ << token::END_STATEMENT << nl; os.writeKeyword("relax") << relax_ << token::END_STATEMENT << nl;
os.writeKeyword("Cmu") << Cmu_ << token::END_STATEMENT << nl;
os.writeKeyword("kappa") << kappa_ << token::END_STATEMENT << nl;
os.writeKeyword("E") << E_ << token::END_STATEMENT << nl;
os.writeKeyword("dmdtRelax") << dmdtRelax_ << token::END_STATEMENT << nl;
os.writeKeyword("fixedDmdt") << fixedDmdt_ << token::END_STATEMENT << nl; os.writeKeyword("fixedDmdt") << fixedDmdt_ << token::END_STATEMENT << nl;
os.writeKeyword("L") << L_ << token::END_STATEMENT << nl;
dmdt_.writeEntry("dmdt", os); dmdt_.writeEntry("dmdt", os);
writeEntry("value", os); writeEntry("value", os);
} }

63
applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseCompressibleTurbulenceModels/derivedFvPatchFields/alphatFixedDmdtWallBoilingWallFunction/alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField.H Normal file → Executable file
View File

@ -22,17 +22,19 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class Class
Foam::compressible::alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField Foam::compressible::
alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField
Group Group
grpCmpWallFunctions grpCmpWallFunctions
Description Description
A simple alphatPhaseChangeWallFunctionFvPatchScalarField with a fixed A simple alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField with
volumetric phase-change mass flux. a fixed volumetric phase-change mass flux.
SeeAlso SeeAlso
Foam::compressible::alphatPhaseChangeWallFunctionFvPatchScalarField Foam::compressible::
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
SourceFiles SourceFiles
alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField.C alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField.C
@ -42,7 +44,7 @@ SourceFiles
#ifndef compressibleAlphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField_H #ifndef compressibleAlphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField_H
#define compressibleAlphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField_H #define compressibleAlphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField_H
#include "alphatPhaseChangeWallFunctionFvPatchScalarField.H" #include "alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -57,50 +59,18 @@ namespace compressible
class alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField class alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField
: :
public alphatPhaseChangeWallFunctionFvPatchScalarField public alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
{ {
// Private data // Private data
//- Turbulent Prandtl number //- dmdt relaxationFactor
scalar Prt_; scalar relax_;
//- Cmu coefficient //- Volumetric phase-change mass flux in near wall cells
scalar Cmu_;
//- Von Karman constant
scalar kappa_;
//- E coefficient
scalar E_;
//- dmdt relaxation factor
scalar dmdtRelax_;
//- Reference dmdt
scalar fixedDmdt_; scalar fixedDmdt_;
//- Latent heat
// Solution parameters scalar L_;
static scalar maxExp_;
static scalar tolerance_;
static label maxIters_;
// Private Member Functions
//- Check the type of the patch
void checkType();
//- 'P' function
tmp<scalarField> Psmooth(const scalarField& Prat) const;
//- Calculate y+ at the edge of the thermal laminar sublayer
tmp<scalarField> yPlusTherm
(
const scalarField& P,
const scalarField& Prat
) const;
public: public:
@ -181,13 +151,6 @@ public:
// Member functions // Member functions
//- Return the rate of phase-change
virtual const scalarField& dmdt() const
{
return dmdt_;
}
// Evaluation functions // Evaluation functions
//- Update the coefficients associated with the patch field //- Update the coefficients associated with the patch field

360
applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseCompressibleTurbulenceModels/derivedFvPatchFields/alphatPhaseChangeJayatillekeWallFunction/alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField.C Executable file
View File

@ -0,0 +1,360 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2015 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 "alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField.H"
#include "fvPatchFieldMapper.H"
#include "addToRunTimeSelectionTable.H"
#include "twoPhaseSystem.H"
#include "ThermalPhaseChangePhaseSystem.H"
#include "MomentumTransferPhaseSystem.H"
#include "compressibleTurbulenceModel.H"
#include "ThermalDiffusivity.H"
#include "PhaseCompressibleTurbulenceModel.H"
#include "wallFvPatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace compressible
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
scalar alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::maxExp_
= 50.0;
scalar alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::tolerance_
= 0.01;
label alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::maxIters_
= 10;
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::checkType()
{
if (!isA<wallFvPatch>(patch()))
{
FatalErrorInFunction
<< "Patch type for patch " << patch().name() << " must be wall\n"
<< "Current patch type is " << patch().type() << nl
<< exit(FatalError);
}
}
tmp<scalarField>
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::Psmooth
(
const scalarField& Prat
) const
{
return 9.24*(pow(Prat, 0.75) - 1.0)*(1.0 + 0.28*exp(-0.007*Prat));
}
tmp<scalarField>
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::yPlusTherm
(
const scalarField& P,
const scalarField& Prat
) const
{
tmp<scalarField> typsf(new scalarField(this->size()));
scalarField& ypsf = typsf();
forAll(ypsf, faceI)
{
scalar ypt = 11.0;
for (int i=0; i<maxIters_; i++)
{
scalar f = ypt - (log(E_*ypt)/kappa_ + P[faceI])/Prat[faceI];
scalar df = 1 - 1.0/(ypt*kappa_*Prat[faceI]);
scalar yptNew = ypt - f/df;
if (yptNew < VSMALL)
{
ypsf[faceI] = 0;
}
else if (mag(yptNew - ypt) < tolerance_)
{
ypsf[faceI] = yptNew;
}
else
{
ypt = yptNew;
}
}
ypsf[faceI] = ypt;
}
return typsf;
}
tmp<scalarField>
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::calcAlphat
(
const scalarField& prevAlphat
) const
{
// Lookup the fluid model
const ThermalPhaseChangePhaseSystem
<
MomentumTransferPhaseSystem<twoPhaseSystem>
>& fluid =
refCast
<
const ThermalPhaseChangePhaseSystem
<
MomentumTransferPhaseSystem<twoPhaseSystem>
>
>
(
db().lookupObject<phaseSystem>("phaseProperties")
);
const phaseModel& liquid
(
fluid.phase1().name() == dimensionedInternalField().group()
? fluid.phase1()
: fluid.phase2()
);
const label patchi = patch().index();
// Retrieve turbulence properties from model
const phaseCompressibleTurbulenceModel& turbModel = liquid.turbulence();
const scalar Cmu25 = pow025(Cmu_);
const scalarField& y = turbModel.y()[patchi];
const tmp<scalarField> tmuw = turbModel.mu(patchi);
const scalarField& muw = tmuw();
const tmp<scalarField> talphaw = liquid.thermo().alpha(patchi);
const scalarField& alphaw = talphaw();
const tmp<volScalarField> tk = turbModel.k();
const volScalarField& k = tk();
const fvPatchScalarField& kw = k.boundaryField()[patchi];
const fvPatchVectorField& Uw = turbModel.U().boundaryField()[patchi];
const scalarField magUp(mag(Uw.patchInternalField() - Uw));
const scalarField magGradUw(mag(Uw.snGrad()));
const fvPatchScalarField& rhow = turbModel.rho().boundaryField()[patchi];
const fvPatchScalarField& hew =
liquid.thermo().he().boundaryField()[patchi];
const fvPatchScalarField& Tw =
liquid.thermo().T().boundaryField()[patchi];
scalarField Tp(Tw.patchInternalField());
// Heat flux [W/m2] - lagging alphatw
const scalarField qDot
(
(prevAlphat + alphaw)*hew.snGrad()
);
scalarField uTau(Cmu25*sqrt(kw));
scalarField yPlus(uTau*y/(muw/rhow));
scalarField Pr(muw/alphaw);
// Molecular-to-turbulent Prandtl number ratio
scalarField Prat(Pr/Prt_);
// Thermal sublayer thickness
scalarField P(this->Psmooth(Prat));
scalarField yPlusTherm(this->yPlusTherm(P, Prat));
tmp<scalarField> talphatConv(new scalarField(this->size()));
scalarField& alphatConv = talphatConv();
// Populate boundary values
forAll(alphatConv, faceI)
{
// Evaluate new effective thermal diffusivity
scalar alphaEff = 0.0;
if (yPlus[faceI] < yPlusTherm[faceI])
{
scalar A = qDot[faceI]*rhow[faceI]*uTau[faceI]*y[faceI];
scalar B = qDot[faceI]*Pr[faceI]*yPlus[faceI];
scalar C = Pr[faceI]*0.5*rhow[faceI]*uTau[faceI]*sqr(magUp[faceI]);
alphaEff = A/(B + C + VSMALL);
}
else
{
scalar A = qDot[faceI]*rhow[faceI]*uTau[faceI]*y[faceI];
scalar B =
qDot[faceI]*Prt_*(1.0/kappa_*log(E_*yPlus[faceI]) + P[faceI]);
scalar magUc =
uTau[faceI]/kappa_*log(E_*yPlusTherm[faceI]) - mag(Uw[faceI]);
scalar C =
0.5*rhow[faceI]*uTau[faceI]
*(Prt_*sqr(magUp[faceI]) + (Pr[faceI] - Prt_)*sqr(magUc));
alphaEff = A/(B + C + VSMALL);
}
// Update convective heat transfer turbulent thermal diffusivity
alphatConv[faceI] = max(0.0, alphaEff - alphaw[faceI]);
}
return talphatConv;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF
)
:
alphatPhaseChangeWallFunctionFvPatchScalarField(p, iF),
Prt_(0.85),
Cmu_(0.09),
kappa_(0.41),
E_(9.8)
{
checkType();
}
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
alphatPhaseChangeWallFunctionFvPatchScalarField(p, iF, dict),
Prt_(dict.lookupOrDefault<scalar>("Prt", 0.85)),
Cmu_(dict.lookupOrDefault<scalar>("Cmu", 0.09)),
kappa_(dict.lookupOrDefault<scalar>("kappa", 0.41)),
E_(dict.lookupOrDefault<scalar>("E", 9.8))
{}
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
(
const alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField& ptf,
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
alphatPhaseChangeWallFunctionFvPatchScalarField(ptf, p, iF, mapper),
Prt_(ptf.Prt_),
Cmu_(ptf.Cmu_),
kappa_(ptf.kappa_),
E_(ptf.E_)
{}
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
(
const alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField& awfpsf
)
:
alphatPhaseChangeWallFunctionFvPatchScalarField(awfpsf),
Prt_(awfpsf.Prt_),
Cmu_(awfpsf.Cmu_),
kappa_(awfpsf.kappa_),
E_(awfpsf.E_)
{}
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
(
const alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField& awfpsf,
const DimensionedField<scalar, volMesh>& iF
)
:
alphatPhaseChangeWallFunctionFvPatchScalarField(awfpsf, iF),
Prt_(awfpsf.Prt_),
Cmu_(awfpsf.Cmu_),
kappa_(awfpsf.kappa_),
E_(awfpsf.E_)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::updateCoeffs()
{
if (updated())
{
return;
}
operator==(calcAlphat(*this));
fixedValueFvPatchScalarField::updateCoeffs();
}
void alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::write
(
Ostream& os
) const
{
fvPatchField<scalar>::write(os);
os.writeKeyword("Prt") << Prt_ << token::END_STATEMENT << nl;
os.writeKeyword("Cmu") << Cmu_ << token::END_STATEMENT << nl;
os.writeKeyword("kappa") << kappa_ << token::END_STATEMENT << nl;
os.writeKeyword("E") << E_ << token::END_STATEMENT << nl;
dmdt_.writeEntry("dmdt", os);
writeEntry("value", os);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makePatchTypeField
(
fvPatchScalarField,
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace compressible
} // End namespace Foam
// ************************************************************************* //

232
applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseCompressibleTurbulenceModels/derivedFvPatchFields/alphatPhaseChangeJayatillekeWallFunction/alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField.H Executable file
View File

@ -0,0 +1,232 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2015 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::compressible::
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
Group
grpCmpWallFunctions
Description
This boundary condition provides a thermal wall function for turbulent
thermal diffusivity (usually\c alphat) based on the Jayatilleke model for
the Eulerian multiphase solvers.
\heading Patch usage
\table
Property | Description | Required | Default value
Prt | Turbulent Prandtl number | no | 0.85
Cmu | Model coefficient | no | 0.09
kappa | von Karman constant | no | 0.41
E | Model coefficient | no | 9.8
\endtable
Example of the boundary condition specification:
\verbatim
myPatch
{
type alphatPhaseChangeJayatillekeWallFunction;
Prt 0.85;
kappa 0.41;
E 9.8;
value uniform 0; // optional value entry
}
\endverbatim
SeeAlso
Foam::compressible::alphatPhaseChangeWallFunctionFvPatchScalarField
SourceFiles
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField.C
\*---------------------------------------------------------------------------*/
#ifndef compressiblealphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField_H
#define compressiblealphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField_H
#include "alphatPhaseChangeWallFunctionFvPatchScalarField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace compressible
{
/*---------------------------------------------------------------------------*\
Class alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField Declaration
\*---------------------------------------------------------------------------*/
class alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
:
public alphatPhaseChangeWallFunctionFvPatchScalarField
{
protected:
// Protected data
//- Turbulent Prandtl number
scalar Prt_;
//- Cmu coefficient
scalar Cmu_;
//- Von Karman constant
scalar kappa_;
//- E coefficient
scalar E_;
// Solution parameters
static scalar maxExp_;
static scalar tolerance_;
static label maxIters_;
// Protected Member Functions
//- Check the type of the patch
void checkType();
//- 'P' function
tmp<scalarField> Psmooth(const scalarField& Prat) const;
//- Calculate y+ at the edge of the thermal laminar sublayer
tmp<scalarField> yPlusTherm
(
const scalarField& P,
const scalarField& Prat
) const;
//- Update turbulent thermal diffusivity
tmp<scalarField> calcAlphat
(
const scalarField& prevAlphat
) const;
public:
//- Runtime type information
TypeName("compressible::alphatPhaseChangeJayatillekeWallFunction");
// Constructors
//- Construct from patch and internal field
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
(
const fvPatch&,
const DimensionedField<scalar, volMesh>&
);
//- Construct from patch, internal field and dictionary
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
(
const fvPatch&,
const DimensionedField<scalar, volMesh>&,
const dictionary&
);
//- Construct by mapping given
// alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
// onto a new patch
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
(
const alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField&,
const fvPatch&,
const DimensionedField<scalar, volMesh>&,
const fvPatchFieldMapper&
);
//- Construct as copy
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
(
const alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField&
);
//- Construct and return a clone
virtual tmp<fvPatchScalarField> clone() const
{
return tmp<fvPatchScalarField>
(
new alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
(
*this
)
);
}
//- Construct as copy setting internal field reference
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
(
const alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField&,
const DimensionedField<scalar, volMesh>&
);
//- Construct and return a clone setting internal field reference
virtual tmp<fvPatchScalarField> clone
(
const DimensionedField<scalar, volMesh>& iF
) const
{
return tmp<fvPatchScalarField>
(
new alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
(
*this,
iF
)
);
}
// Member functions
// Evaluation functions
//- Update the coefficients associated with the patch field
virtual void updateCoeffs();
// I-O
//- Write
virtual void write(Ostream&) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace compressible
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

385
applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseCompressibleTurbulenceModels/derivedFvPatchFields/alphatWallBoilingWallFunction/alphatWallBoilingWallFunctionFvPatchScalarField.C Executable file
View File

@ -0,0 +1,385 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2015 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 "alphatWallBoilingWallFunctionFvPatchScalarField.H"
#include "fvPatchFieldMapper.H"
#include "addToRunTimeSelectionTable.H"
#include "twoPhaseSystem.H"
#include "phaseSystem.H"
#include "ThermalPhaseChangePhaseSystem.H"
#include "MomentumTransferPhaseSystem.H"
#include "compressibleTurbulenceModel.H"
#include "ThermalDiffusivity.H"
#include "PhaseCompressibleTurbulenceModel.H"
#include "saturationModel.H"
#include "wallFvPatch.H"
#include "uniformDimensionedFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace compressible
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
alphatWallBoilingWallFunctionFvPatchScalarField::
alphatWallBoilingWallFunctionFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF
)
:
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField(p, iF),
relax_(0.5),
AbyV_(p.size(), 0.0),
alphatConv_(p.size(), 0.0)
{
AbyV_ = this->patch().magSf();
forAll(AbyV_,facei)
{
label faceCelli = this->patch().faceCells()[facei];
AbyV_[facei] /= iF.mesh().V()[faceCelli];
}
}
alphatWallBoilingWallFunctionFvPatchScalarField::
alphatWallBoilingWallFunctionFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField(p, iF, dict),
relax_(dict.lookupOrDefault<scalar>("relax", 0.5)),
AbyV_(p.size(), 0.0),
alphatConv_(p.size(), 0.0)
{
if (dict.found("alphatConv"))
{
alphatConv_ = scalarField("alphatConv", dict, p.size());
}
AbyV_ = this->patch().magSf();
forAll(AbyV_,facei)
{
label faceCelli = this->patch().faceCells()[facei];
AbyV_[facei] /= iF.mesh().V()[faceCelli];
}
}
alphatWallBoilingWallFunctionFvPatchScalarField::
alphatWallBoilingWallFunctionFvPatchScalarField
(
const alphatWallBoilingWallFunctionFvPatchScalarField& psf,
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
(
psf,
p,
iF,
mapper
),
relax_(psf.relax_),
AbyV_(psf.AbyV_),
alphatConv_(psf.alphatConv_, mapper)
{}
alphatWallBoilingWallFunctionFvPatchScalarField::
alphatWallBoilingWallFunctionFvPatchScalarField
(
const alphatWallBoilingWallFunctionFvPatchScalarField& psf
)
:
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField(psf),
relax_(psf.relax_),
AbyV_(psf.AbyV_),
alphatConv_(psf.alphatConv_)
{}
alphatWallBoilingWallFunctionFvPatchScalarField::
alphatWallBoilingWallFunctionFvPatchScalarField
(
const alphatWallBoilingWallFunctionFvPatchScalarField& psf,
const DimensionedField<scalar, volMesh>& iF
)
:
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField(psf, iF),
relax_(psf.relax_),
AbyV_(psf.AbyV_),
alphatConv_(psf.alphatConv_)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void alphatWallBoilingWallFunctionFvPatchScalarField::updateCoeffs()
{
if (updated())
{
return;
}
// Lookup the fluid model
const ThermalPhaseChangePhaseSystem<MomentumTransferPhaseSystem
<
twoPhaseSystem>
>&
fluid
= refCast
<
const ThermalPhaseChangePhaseSystem
<
MomentumTransferPhaseSystem<twoPhaseSystem>
>
>
(
db().lookupObject<phaseSystem>("phaseProperties")
);
const phaseModel& liquid
(
fluid.phase1().name() == dimensionedInternalField().group()
? fluid.phase1()
: fluid.phase2()
);
const phaseModel& vapor(fluid.otherPhase(liquid));
const label patchi = patch().index();
// Retrieve turbulence properties from model
const phaseCompressibleTurbulenceModel& turbModel = liquid.turbulence();
const tmp<scalarField> tnutw = turbModel.nut(patchi);
const scalar Cmu25(pow025(Cmu_));
const scalarField& y = turbModel.y()[patchi];
const tmp<scalarField> tmuw = turbModel.mu(patchi);
const scalarField& muw = tmuw();
const tmp<scalarField> talphaw = liquid.thermo().alpha(patchi);
const scalarField& alphaw = talphaw();
const tmp<volScalarField> tk = turbModel.k();
const volScalarField& k = tk();
const fvPatchScalarField& kw = k.boundaryField()[patchi];
const fvPatchVectorField& Uw = turbModel.U().boundaryField()[patchi];
const scalarField magUp(mag(Uw.patchInternalField() - Uw));
const scalarField magGradUw(mag(Uw.snGrad()));
const fvPatchScalarField& rhow = turbModel.rho().boundaryField()[patchi];
const fvPatchScalarField& hew =
liquid.thermo().he().boundaryField()[patchi];
const fvPatchScalarField& Tw =
liquid.thermo().T().boundaryField()[patchi];
const scalarField Tc(Tw.patchInternalField());
scalarField uTau(Cmu25*sqrt(kw));
scalarField yPlus(uTau*y/(muw/rhow));
scalarField Pr(muw/alphaw);
// Molecular-to-turbulent Prandtl number ratio
scalarField Prat(Pr/Prt_);
// Thermal sublayer thickness
scalarField P(this->Psmooth(Prat));
scalarField yPlusTherm(this->yPlusTherm(P, Prat));
const scalarField rhoc(rhow.patchInternalField());
tmp<volScalarField> trhoVapor = vapor.thermo().rho();
const volScalarField& rhoVapor = trhoVapor();
const fvPatchScalarField& rhoVaporw =
rhoVapor.boundaryField()[patchi];
const scalarField rhoVaporp(rhoVaporw.patchInternalField());
tmp<volScalarField> tCp = liquid.thermo().Cp();
const volScalarField& Cp = tCp();
const fvPatchScalarField& Cpw = Cp.boundaryField()[patchi];
// Saturation temperature
const tmp<volScalarField> tTsat =
fluid.saturation().Tsat(liquid.thermo().p());
const volScalarField& Tsat = tTsat();
const fvPatchScalarField& Tsatw(Tsat.boundaryField()[patchi]);
const scalarField Tsatc(Tsatw.patchInternalField());
// Gravitational acceleration
const uniformDimensionedVectorField& g =
db().lookupObject<uniformDimensionedVectorField>("g");
const fvPatchScalarField& pw =
liquid.thermo().p().boundaryField()[patchi];
const scalarField L
(
vapor.thermo().he(pw,Tsatc,patchi)-hew.patchInternalField()
);
// Liquid temperature at y+=250 is estimated from logarithmic
// thermal wall function (Koncar, Krepper & Egorov, 2005)
scalarField Tplus_y250(Prt_*(Foam::log(E_*250)/kappa_ + P));
scalarField Tplus(Prt_*(Foam::log(E_*yPlus)/kappa_ + P));
scalarField Tl(Tw - (Tplus_y250/Tplus)*(Tw - Tc));
Tl = max(Tc - 40, min(Tc, Tl));
// Nucleation site density:
// Reformulation of Lemmert & Chawla (Egorov & Menter, 2004)
const scalarField N
(
0.8*9.922e5*Foam::pow(max(0.0, (Tw - Tsatw)/10), 1.805)
);
// Bubble departure diameter:
// Tolubinski and Kostanchuk (1970)
const scalarField Tsub(max(0.0, Tsatw - Tl));
const scalarField Ddep
(
max(1e-6, min(0.0006*Foam::exp(-Tsub/45), 0.0014))
);
// Bubble departure frequency:
// Cole (1960)
const scalarField F
(
sqrt(4*mag(g).value()*(max(0.1, rhoc - rhoVaporp))/(3*Ddep*rhow))
);
// Area fractions:
// Del Valle & Kenning (1985)
const scalarField Ja(rhoc*Cpw*Tsub/(rhoVaporp*L));
const scalarField Al(4.8*Foam::exp(-Ja/80));
// Liquid phase fraction at the wall
const scalarField liquidw(liquid.boundaryField()[patchi]);
// Damp boiling at high void fractions.
const scalarField W(min(1.,liquidw/0.2));
const scalarField A2(W*min(M_PI*sqr(Ddep)*N*Al/4, 1.0));
const scalarField A1(max(1e-4, 1 - A2));
const scalarField A2E(W*min(M_PI*sqr(Ddep)*N*Al/4, 5.0));
// Wall evaporation heat flux [kg/s3 = J/m2s]
const scalarField Qe((1.0/6.0)*A2E*Ddep*rhoVaporw*F*L);
// Volumetric mass source in the near wall cell due to the wall boiling
dmdt_ = (1 - relax_)*dmdt_ + relax_*Qe*AbyV_/L;
// Volumetric source in the near wall cell due to the wall boiling
mDotL_ = dmdt_*L;
// Quenching heat transfer coefficient
const scalarField hQ
(
2*(alphaw*Cpw)*F*sqrt((0.8/F)/(M_PI*alphaw/rhow))
);
// Quenching heat flux
const scalarField Qq(A2*hQ*max(0.0, Tw - Tl));
// Convective heat flux
alphatConv_ = calcAlphat(alphatConv_);
//const scalarField Qc(A1*(alphatConv_ + alphaw)*hew.snGrad());
// Effective thermal diffusivity that corresponds to the calculated
// convective, quenching and evaporative heat fluxes
operator==
(
A1*alphatConv_ + (Qq + Qe)/max(liquidw*hew.snGrad(), 1e-16)
);
if(debug)
{
Info<< " L: " << gMin(L) << " - " << gMax(L) << endl;
Info<< " Tl: " << gMin(Tl) << " - " << gMax(Tl) << endl;
Info<< " N: " << gMin(N) << " - " << gMax(N) << endl;
Info<< " Ddep: " << gMin(Ddep) << " - " << gMax(Ddep) << endl;
Info<< " F: " << gMin(F) << " - " << gMax(F) << endl;
Info<< " Al: " << gMin(Al) << " - " << gMax(Al) << endl;
Info<< " A1: " << gMin(A1) << " - " << gMax(A1) << endl;
Info<< " A2: " << gMin(A2) << " - " << gMax(A2) << endl;
Info<< " A2E: " << gMin(A2E) << " - " << gMax(A2E) << endl;
Info<< " dmdtW: " << gMin(dmdt_) << " - " << gMax(dmdt_) << endl;
const scalarField Qc(A1*(alphatConv_ + alphaw)*hew.snGrad());
Info<< " Qc: " << gMin(Qc) << " - " << gMax(Qc) << endl;
Info<< " Qq: " << gMin(Qq) << " - " << gMax(Qq) << endl;
Info<< " Qe: " << gMin(Qe) << " - " << gMax(Qe) << endl;
const scalarField QEff(liquidw*(*this + alphaw)*hew.snGrad());
Info<< " QEff: " << gMin(QEff) << " - " << gMax(QEff) << endl;
Info<< " alphat: " << gMin(*this) << " - " << gMax(*this) << endl;
Info<< " alphatConv: " << gMin(alphatConv_)
<< " - " << gMax(alphatConv_) << endl;
}
fixedValueFvPatchScalarField::updateCoeffs();
}
void alphatWallBoilingWallFunctionFvPatchScalarField::write(Ostream& os) const
{
fvPatchField<scalar>::write(os);
os.writeKeyword("relax") << relax_ << token::END_STATEMENT << nl;
dmdt_.writeEntry("dmdt", os);
alphatConv_.writeEntry("alphatConv", os);
writeEntry("value", os);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makePatchTypeField
(
fvPatchScalarField,
alphatWallBoilingWallFunctionFvPatchScalarField
);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace compressible
} // End namespace Foam
// ************************************************************************* //

187
applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseCompressibleTurbulenceModels/derivedFvPatchFields/alphatWallBoilingWallFunction/alphatWallBoilingWallFunctionFvPatchScalarField.H Executable file
View File

@ -0,0 +1,187 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2015 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::compressible::alphatWallBoilingWallFunctionFvPatchScalarField
Group
grpCmpWallFunctions
Description
A thermal wall function for simulation of subcooled nucleate wall boiling.
Implements a version of the well-known RPI wall boiling model
(Kurul & Podowski, 1991). The model implementation is similar to the model
described by Peltola & Pättikangas (2012).
References:
\verbatim
"On the modeling of multidimensional effects in boiling channels"
Kurul, N., Podowski, M.Z.,
ANS Proceedings, National Heat Transfer Conference,
Minneapolis, Minnesota, USA, July 28-31, 1991,
ISBN: 0-89448-162-1, pp. 30-40
\endverbatim
\verbatim
"Development and validation of a boiling model for OpenFOAM
multiphase solver"
Peltola, J., Pättikangas, T.J.H.,
CFD4NRS-4 Conference Proceedings, paper 59,
Daejeon, Korea, September 10-12 2012
\endverbatim
SeeAlso
Foam::fixedValueFvPatchField
SourceFiles
alphatWallBoilingWallFunctionFvPatchScalarField.C
\*---------------------------------------------------------------------------*/
#ifndef compressiblealphatWallBoilingWallFunctionFvPatchScalarField_H
#define compressiblealphatWallBoilingWallFunctionFvPatchScalarField_H
#include "alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace compressible
{
/*---------------------------------------------------------------------------*\
Class alphatWallBoilingWallFunctionFvPatchScalarField Declaration
\*---------------------------------------------------------------------------*/
class alphatWallBoilingWallFunctionFvPatchScalarField
:
public alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField
{
// Private data
//- dmdt relaxationFactor
scalar relax_;
//- Patch face area by cell volume
scalarField AbyV_;
//- Convective turbulent thermal diffusivity
scalarField alphatConv_;
public:
//- Runtime type information
TypeName("compressible::alphatWallBoilingWallFunction");
// Constructors
//- Construct from patch and internal field
alphatWallBoilingWallFunctionFvPatchScalarField
(
const fvPatch&,
const DimensionedField<scalar, volMesh>&
);
//- Construct from patch, internal field and dictionary
alphatWallBoilingWallFunctionFvPatchScalarField
(
const fvPatch&,
const DimensionedField<scalar, volMesh>&,
const dictionary&
);
//- Construct by mapping given
// alphatWallBoilingWallFunctionFvPatchScalarField
// onto a new patch
alphatWallBoilingWallFunctionFvPatchScalarField
(
const alphatWallBoilingWallFunctionFvPatchScalarField&,
const fvPatch&,
const DimensionedField<scalar, volMesh>&,
const fvPatchFieldMapper&
);
//- Construct as copy
alphatWallBoilingWallFunctionFvPatchScalarField
(
const alphatWallBoilingWallFunctionFvPatchScalarField&
);
//- Construct and return a clone
virtual tmp<fvPatchScalarField> clone() const
{
return tmp<fvPatchScalarField>
(
new alphatWallBoilingWallFunctionFvPatchScalarField(*this)
);
}
//- Construct as copy setting internal field reference
alphatWallBoilingWallFunctionFvPatchScalarField
(
const alphatWallBoilingWallFunctionFvPatchScalarField&,
const DimensionedField<scalar, volMesh>&
);
//- Construct and return a clone setting internal field reference
virtual tmp<fvPatchScalarField> clone
(
const DimensionedField<scalar, volMesh>& iF
) const
{
return tmp<fvPatchScalarField>
(
new alphatWallBoilingWallFunctionFvPatchScalarField(*this, iF)
);
}
// Member functions
// Evaluation functions
//- Update the coefficients associated with the patch field
virtual void updateCoeffs();
// I-O
//- Write
virtual void write(Ostream&) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace compressible
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

3
src/TurbulenceModels/phaseCompressible/RAS/continuousGasKEpsilon/continuousGasKEpsilon.C
View File

@ -89,7 +89,8 @@ continuousGasKEpsilon<BasicTurbulenceModel>::continuousGasKEpsilon
{ {
if (type == typeName) if (type == typeName)
{ {
kEpsilon<BasicTurbulenceModel>::correctNut(); // Cannot correct nut yet: construction of the phases is not complete
// kEpsilon<BasicTurbulenceModel>::correctNut();
this->printCoeffs(type); this->printCoeffs(type);
} }
} }

53
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/T.gas Normal file
View File

@ -0,0 +1,53 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "5";
object T.gas;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 1 0 0 0];
internalField uniform 373.55;
boundaryField
{
inlet
{
type fixedValue;
value uniform 373.55;
}
outlet
{
type inletOutlet;
phi phi.gas;
inletValue uniform 373.55;
value uniform 373.55;
}
wall1
{
type zeroGradient;
}
wall2
{
type copiedFixedValue;
sourceFieldName T.liquid;
value uniform 373.55;
}
defaultFaces
{
type empty;
}
}
// ************************************************************************* //

55
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/T.liquid Normal file
View File

@ -0,0 +1,55 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "5";
object T.liquid;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 1 0 0 0];
internalField uniform 370;
boundaryField
{
inlet
{
type fixedValue;
value uniform 370;
}
outlet
{
type inletOutlet;
phi phi.liquid;
inletValue uniform 370;
value uniform 370;
}
wall1
{
type zeroGradient;
}
wall2
{
type fixedMultiPhaseHeatFlux;
relax 0.5;
q uniform 100000;
phase "liquid";
value uniform 370;
}
defaultFaces
{
type empty;
}
}
// ************************************************************************* //

1989
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/U.gas Normal file
View File

File diff suppressed because it is too large Load Diff

1989
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/U.liquid Normal file
View File

File diff suppressed because it is too large Load Diff

51
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/alpha.gas Normal file
View File

@ -0,0 +1,51 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "5";
object alpha.gas;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 0 0 0 0];
internalField uniform 0;
boundaryField
{
inlet
{
type fixedValue;
value uniform 0;
}
outlet
{
type inletOutlet;
phi phi.gas;
inletValue uniform 0;
value uniform 0;
}
wall1
{
type zeroGradient;
}
wall2
{
type zeroGradient;
}
defaultFaces
{
type empty;
}
}
// ************************************************************************* //

2038
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/alpha.liquid Normal file
View File

File diff suppressed because it is too large Load Diff

1996
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/alphat.gas Normal file
View File

File diff suppressed because it is too large Load Diff

2078
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/alphat.liquid Normal file
View File

File diff suppressed because it is too large Load Diff

2125
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/epsilon.gas Normal file
View File

File diff suppressed because it is too large Load Diff

2158
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/epsilon.liquid Normal file
View File

File diff suppressed because it is too large Load Diff

2119
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/k.gas Normal file
View File

File diff suppressed because it is too large Load Diff

2152
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/k.liquid Normal file
View File

File diff suppressed because it is too large Load Diff

1965
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/nut.gas Normal file
View File

File diff suppressed because it is too large Load Diff

2152
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/nut.liquid Normal file
View File

File diff suppressed because it is too large Load Diff

2117
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/p Normal file
View File

File diff suppressed because it is too large Load Diff

2150
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/p_rgh Normal file
View File

File diff suppressed because it is too large Load Diff

51
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/water.gas Normal file
View File

@ -0,0 +1,51 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "5";
object water.gas;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 0 0 0 0];
internalField uniform 1;
boundaryField
{
inlet
{
type fixedValue;
value uniform 1;
}
outlet
{
type inletOutlet;
phi phi.gas;
inletValue uniform 1;
value uniform 1;
}
wall1
{
type zeroGradient;
}
wall2
{
type zeroGradient;
}
defaultFaces
{
type empty;
}
}
// ************************************************************************* //

51
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/0/water.liquid Normal file
View File

@ -0,0 +1,51 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "5";
object water.liquid;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 0 0 0 0];
internalField uniform 1;
boundaryField
{
inlet
{
type fixedValue;
value uniform 1;
}
outlet
{
type inletOutlet;
phi phi.liquid;
inletValue uniform 1;
value uniform 1;
}
wall1
{
type zeroGradient;
}
wall2
{
type zeroGradient;
}
defaultFaces
{
type empty;
}
}
// ************************************************************************* //

41
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/constant/chemistryProperties.gas Normal file
View File

@ -0,0 +1,41 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object chemistryProperties.gas;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
chemistryType
{
chemistrySolver EulerImplicit;
chemistryThermo rho;
}
chemistry off;
initialChemicalTimeStep 1e-07;
EulerImplicitCoeffs
{
cTauChem 1;
equilibriumRateLimiter off;
}
odeCoeffs
{
solver Rosenbrock43;
absTol 1e-12;
relTol 0.01;
}
// ************************************************************************* //

35
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/constant/combustionProperties.gas Normal file
View File

@ -0,0 +1,35 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object combustionProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
combustionModel PaSR<rhoChemistryCombustion>;
active false;
laminarCoeffs
{}
noCombustionCoeffs
{}
PaSRCoeffs
{
Cmix 1.0;
turbulentReaction yes;
useReactionRate true;
}
// ************************************************************************* //

21
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/constant/g Normal file
View File

@ -0,0 +1,21 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class uniformDimensionedVectorField;
location "constant";
object g;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -2 0 0 0 0];
value ( 0 -9.81 0 );
// ************************************************************************* //

239
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/constant/phaseProperties Normal file
View File

@ -0,0 +1,239 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object phaseProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
type thermalPhaseChangeTwoPhaseSystem;
phases (gas liquid);
volatile "water";
massTransfer on;
gas
{
type multiComponentPhaseModel;
diameterModel isothermal;
constantCoeffs
{
d 0.00045;
}
isothermalCoeffs
{
d0 0.00045;
p0 1e5;
}
Sc 0.7;
residualAlpha 1e-4;
}
liquid
{
type multiComponentPhaseModel;
diameterModel constant;
constantCoeffs
{
d 0.00045;
}
Sc 0.7;
residualAlpha 1e-4;
}
blending
{
default
{
type linear;
continuousPhase liquid;
minFullyContinuousAlpha.gas 0.7;
minPartlyContinuousAlpha.gas 0.5;
minFullyContinuousAlpha.liquid 0.7;
minPartlyContinuousAlpha.liquid 0.5;
}
heatTransfer
{
type linear;
continuousPhase liquid;
minFullyContinuousAlpha.gas 1;
minPartlyContinuousAlpha.gas 0;
minFullyContinuousAlpha.liquid 1;
minPartlyContinuousAlpha.liquid 0;
}
massTransfer
{
type linear;
continuousPhase liquid;
minFullyContinuousAlpha.gas 1;
minPartlyContinuousAlpha.gas 0;
minFullyContinuousAlpha.liquid 1;
minPartlyContinuousAlpha.liquid 0;
}
}
surfaceTension
(
(gas and liquid)
{
type constant;
sigma 0.07;
}
);
saturationModel
{
type polynomial;
C<8>
(
308.0422
0.0015096
-1.61589e-8
1.114106e-13
-4.52216e-19
1.05192e-24
-1.2953e-30
6.5365e-37
);
};
aspectRatio
(
(gas in liquid)
{
type constant;
E0 1.0;
}
(liquid in gas)
{
type constant;
E0 1.0;
}
);
drag
(
(gas in liquid)
{
type SchillerNaumann;
residualRe 1e-3;
swarmCorrection
{
type none;
}
}
(liquid in gas)
{
type SchillerNaumann;
residualRe 1e-3;
swarmCorrection
{
type none;
}
}
);
virtualMass
(
(gas in liquid)
{
type constantCoefficient;
Cvm 0.5;
}
(liquid in gas)
{
type constantCoefficient;
Cvm 0.5;
}
);
interfaceComposition
();
heatTransfer.gas
(
(gas in liquid)
{
type spherical;
residualAlpha 1e-3;
}
(liquid in gas)
{
type RanzMarshall;
residualAlpha 1e-3;
}
);
heatTransfer.liquid
(
(gas in liquid)
{
type RanzMarshall;
residualAlpha 1e-3;
}
(liquid in gas)
{
type spherical;
residualAlpha 1e-3;
}
);
massTransfer.gas
();
massTransfer.liquid
();
lift
();
wallLubrication
(
(gas in liquid)
{
type Antal;
Cw1 -0.01;
Cw2 0.05;
Cwc 10.0;
Cwd 6.8;
p 1.7;
}
);
turbulentDispersion
(
(gas in liquid)
{
type Burns;
sigma 0.7;
Ctd 1.0;
residualAlpha 1e-3;
}
);
// Minimum allowable pressure
pMin 10000;
// ************************************************************************* //

68
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/constant/thermophysicalProperties.gas Normal file
View File

@ -0,0 +1,68 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object thermophysicalProperties.gas;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
thermoType
{
type heRhoThermo;
mixture multiComponentMixture;
transport const;
thermo hRefConst;
equationOfState perfectGas;
specie specie;
energy sensibleEnthalpy;
}
dpdt no;
species
(
water
);
inertSpecie water;
chemistryReader foamChemistryReader;
foamChemistryFile "$FOAM_CASE/constant/reactions.gas";
water
{
specie
{
nMoles 1;
molWeight 18.0153;
}
equationOfState
{
rho 1;
}
thermodynamics
{
Hf 0;
Cp 12078.4;
Tref 373.55;
Href 2675500;
}
transport
{
mu 1.2256e-5;
Pr 2.289;
}
}
// ************************************************************************* //

67
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/constant/thermophysicalProperties.liquid Normal file
View File

@ -0,0 +1,67 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object thermophysicalProperties.liquid;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
thermoType
{
type heRhoThermo;
mixture multiComponentMixture;
transport const;
thermo hRefConst;
equationOfState rhoConst;
specie specie;
energy sensibleEnthalpy;
}
dpdt no;
species
(
water
);
inertSpecie water;
"(mixture|H2O|water)"
{
specie
{
nMoles 1;
molWeight 18.0153;
}
equationOfState
{
R 3000;
rho0 959;
rho 959;
}
thermodynamics
{
Hf 0;
Cp 4195;
Tref 373.55;
Href 417500;
}
transport
{
mu 2.8291e-4;
Pr 2.289;
}
}
// ************************************************************************* //

28
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/constant/turbulenceProperties.gas Normal file
View File

@ -0,0 +1,28 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object turbulenceProperties.air;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
simulationType RAS;
RAS
{
RASModel continuousGasKEpsilon;
turbulence on;
printCoeffs on;
}
// ************************************************************************* //

28
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/constant/turbulenceProperties.liquid Normal file
View File

@ -0,0 +1,28 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object turbulenceProperties.water;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
simulationType RAS;
RAS
{
RASModel LaheyKEpsilon;
turbulence on;
printCoeffs on;
}
// ************************************************************************* //

80
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/system/blockMeshDict Normal file
View File

@ -0,0 +1,80 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object blockMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
convertToMeters 1;
vertices
(
(0 0 0)
(0.05 0 0)
(0.05 2 0)
(0 2 0)
(0 0 0.1)
(0.05 0 0.1)
(0.05 2 0.1)
(0 2 0.1)
);
blocks
(
hex (0 1 2 3 4 5 6 7) (25 75 1) simpleGrading (1 1 1)
);
boundary
(
inlet
{
type mappedPatch;
offset (0 0.1 0);
sampleRegion region0;
sampleMode nearestCell;
samplePatch none;
faces
(
(1 5 4 0)
);
}
outlet
{
type patch;
faces
(
(3 7 6 2)
);
}
wall1
{
type wall;
faces
(
(0 4 7 3)
);
}
wall2
{
type wall;
faces
(
(2 6 5 1)
);
}
);
// ************************************************************************* //

54
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/system/controlDict Normal file
View File

@ -0,0 +1,54 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object controlDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
application reactingTwoPhaseEulerFoam;
startFrom startTime;
startTime 0;
stopAt endTime;
endTime 2;
deltaT 1e-5;
writeControl adjustableRunTime;
writeInterval 0.1;
purgeWrite 0;
writeFormat ascii;
writePrecision 9;
writeCompression compressed;
timeFormat general;
timePrecision 6;
runTimeModifiable yes;
adjustTimeStep yes;
maxCo 0.05;
maxDeltaT 0.001;
// ************************************************************************* //

76
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/system/fvSchemes Normal file
View File

@ -0,0 +1,76 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object fvSchemes;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
ddtSchemes
{
default Euler;
}
gradSchemes
{
default Gauss linear;
}
divSchemes
{
default none;
"div\(phi,alpha.*\)" Gauss vanLeer;
"div\(phir,alpha.*\)" Gauss vanLeer;
"div\(alphaRhoPhi.*,U.*\)" Gauss limitedLinearV 1;
"div\(phi.*,U.*\)" Gauss limitedLinearV 1;
"div\(alphaRhoPhi.*,Yi\)" Gauss limitedLinear 1;
"div\(alphaRhoPhi.*,(h|e).*\)" Gauss limitedLinear 1;
"div\(alphaRhoPhi.*,K.*\)" Gauss limitedLinear 1;
"div\(alphaPhi.*,p\)" Gauss limitedLinear 1;
"div\(alphaRhoPhi.*,(k|epsilon).*\)" Gauss upwind;
"div\(phim,(k|epsilon)m\)" Gauss upwind;
"div\(\(\(\(alpha.*\*thermo:rho.*\)\*nuEff.*\)\*dev2\(T\(grad\(U.*\)\)\)\)\)" Gauss linear;
}
laplacianSchemes
{
default Gauss linear uncorrected;
}
interpolationSchemes
{
default linear;
}
snGradSchemes
{
default uncorrected;
}
fluxRequired
{
default no;
}
wallDist
{
method meshWave;
nRequired yes;
}
// ************************************************************************* //

112
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoiling/system/fvSolution Normal file
View File

@ -0,0 +1,112 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object fvSolution;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
solvers
{
"alpha.*"
{
nAlphaCorr 1;
nAlphaSubCycles 3;
}
p_rgh
{
solver GAMG;
smoother DIC;
nPreSweeps 0;
nPostSweeps 2;
nFinestSweeps 2;
cacheAgglomeration true;
nCellsInCoarsestLevel 10;
agglomerator faceAreaPair;
mergeLevels 1;
tolerance 1e-8;
relTol 0.1;
maxIter 100;
minIter 2;
}
p_rghFinal
{
$p_rgh;
relTol 0;
}
"U.*"
{
solver smoothSolver;
smoother symGaussSeidel;
tolerance 1e-6;
relTol 0;
minIter 1;
}
"(e|h).*"
{
solver smoothSolver;
smoother symGaussSeidel;
tolerance 1e-12;
relTol 0.001;
minIter 1;
maxIter 20;
}
"(k|epsilon|Theta).*"
{
solver smoothSolver;
smoother symGaussSeidel;
tolerance 1e-8;
relTol 0;
minIter 1;
}
Yi
{
solver smoothSolver;
smoother symGaussSeidel;
tolerance 1e-6;
relTol 0;
minIter 1;
residualAlpha 1e-8;
}
}
PIMPLE
{
nOuterCorrectors 3;
nCorrectors 1;
nNonOrthogonalCorrectors 0;
nEnergyCorrectors 3;
faceMomentum on;
}
relaxationFactors
{
fields
{
iDmdt 0.4;
}
equations
{
".*" 1;
"h.*" 0.4;
}
}
// ************************************************************************* //