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

ENH: liquidFilm subModels: add injection models

Browse Source 
ENH: Several additions to thinFilm models

1) Changing the faSolution entry nonOrthoCorr to nFilmCorr entry.
   This entry specify the number of iterations on the film thickness
   Eq which does not correct for laplacian non-orthogonality.

2) Changing laminar turbulent model for the skin friction exerted by
   the flow to the film.

3) Adding optional relaxation factors for source terms coming from
   the added mass of the lagragian particles into the film such as
   rhoSp, pnSp and Usp. Similarly the film pressure (pf) can  be
   relaxed in the inner loops.

4) Adding optional entries to curvatureSepration injection model.
   minimum (fThreshold) force and minimum curvature (minInvR1) for
   separation were added to have more control on determining the
   points of film separation

ENH: ThermoSurfaceFilm in lagragian to search for finiteArea film models
This commit is contained in:
sergio
2021-07-13 13:12:38 +01:00
committed by Sergio Ferraris
parent b62306ddc5
commit e30cbfc6db
27 changed files with 2117 additions and 284 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/Allwmake
View File

@ -83,14 +83,18 @@ wmake $targetType ODE
thermophysicalModels/Allwmake $targetType $* thermophysicalModels/Allwmake $targetType $*
TurbulenceModels/Allwmake $targetType $* TurbulenceModels/Allwmake $targetType $*
wmake $targetType combustionModels wmake $targetType combustionModels
wmakeLnInclude -u regionFaModels
wmakeLnInclude -u faOptions
regionModels/Allwmake $targetType $* regionModels/Allwmake $targetType $*
lagrangian/Allwmake $targetType $*
wmake $targetType fvOptions wmake $targetType fvOptions
wmake $targetType faOptions wmake $targetType faOptions
wmake $targetType fvMotionSolver wmake $targetType fvMotionSolver
wmake $targetType regionFaModels wmake $targetType regionFaModels
lagrangian/Allwmake $targetType $*
wmake $targetType overset wmake $targetType overset
# snappyHexMesh uses overset voxelMesh # snappyHexMesh uses overset voxelMesh

3
src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/InjectionModel/InjectionModel.C
View File

@ -5,8 +5,7 @@
\\ / A nd | www.openfoam.com \\ / A nd | www.openfoam.com
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2017 OpenFOAM Foundation Copyright (C) 2020 OpenCFD Ltd.
Copyright (C) 2016-2020 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.

87
src/lagrangian/intermediate/submodels/Kinematic/SurfaceFilmModel/SurfaceFilmModel/SurfaceFilmModel.C
View File

@ -41,13 +41,16 @@ Foam::SurfaceFilmModel<CloudType>::SurfaceFilmModel(CloudType& owner)
CloudSubModelBase<CloudType>(owner), CloudSubModelBase<CloudType>(owner),
g_(owner.g()), g_(owner.g()),
ejectedParcelType_(0), ejectedParcelType_(0),
injectionOffset_(1.1),
minDiameter_(0),
massParcelPatch_(0), massParcelPatch_(0),
diameterParcelPatch_(0), diameterParcelPatch_(0),
UFilmPatch_(0), UFilmPatch_(0),
rhoFilmPatch_(0), rhoFilmPatch_(0),
deltaFilmPatch_(0), deltaFilmPatch_(0),
nParcelsTransferred_(0), nParcelsTransferred_(0),
nParcelsInjected_(0) nParcelsInjected_(0),
totalMassTransferred_(0)
{} {}
@ -63,7 +66,15 @@ Foam::SurfaceFilmModel<CloudType>::SurfaceFilmModel
g_(owner.g()), g_(owner.g()),
ejectedParcelType_ ejectedParcelType_
( (
this->coeffDict().getOrDefault("ejectedParcelType", -1) this->coeffDict().template getOrDefault<label>("ejectedParcelType", -1)
),
injectionOffset_
(
this->coeffDict().template getOrDefault<scalar>("injectionOffset", 1.1)
),
minDiameter_
(
this->coeffDict().template getOrDefault<scalar>("minDiameter", -1)
), ),
massParcelPatch_(0), massParcelPatch_(0),
diameterParcelPatch_(0), diameterParcelPatch_(0),
@ -71,7 +82,8 @@ Foam::SurfaceFilmModel<CloudType>::SurfaceFilmModel
rhoFilmPatch_(0), rhoFilmPatch_(0),
deltaFilmPatch_(owner.mesh().boundary().size()), deltaFilmPatch_(owner.mesh().boundary().size()),
nParcelsTransferred_(0), nParcelsTransferred_(0),
nParcelsInjected_(0) nParcelsInjected_(0),
totalMassTransferred_()
{} {}
@ -84,13 +96,16 @@ Foam::SurfaceFilmModel<CloudType>::SurfaceFilmModel
CloudSubModelBase<CloudType>(sfm), CloudSubModelBase<CloudType>(sfm),
g_(sfm.g_), g_(sfm.g_),
ejectedParcelType_(sfm.ejectedParcelType_), ejectedParcelType_(sfm.ejectedParcelType_),
injectionOffset_(sfm.injectionOffset_),
minDiameter_(sfm.minDiameter_),
massParcelPatch_(sfm.massParcelPatch_), massParcelPatch_(sfm.massParcelPatch_),
diameterParcelPatch_(sfm.diameterParcelPatch_), diameterParcelPatch_(sfm.diameterParcelPatch_),
UFilmPatch_(sfm.UFilmPatch_), UFilmPatch_(sfm.UFilmPatch_),
rhoFilmPatch_(sfm.rhoFilmPatch_), rhoFilmPatch_(sfm.rhoFilmPatch_),
deltaFilmPatch_(sfm.deltaFilmPatch_), deltaFilmPatch_(sfm.deltaFilmPatch_),
nParcelsTransferred_(sfm.nParcelsTransferred_), nParcelsTransferred_(sfm.nParcelsTransferred_),
nParcelsInjected_(sfm.nParcelsInjected_) nParcelsInjected_(sfm.nParcelsInjected_),
totalMassTransferred_(sfm.totalMassTransferred_)
{} {}
@ -130,7 +145,7 @@ void Foam::SurfaceFilmModel<CloudType>::injectParticles
diameterParcelPatch_[j], diameterParcelPatch_[j],
deltaFilmPatch_[primaryPatchi][j] deltaFilmPatch_[primaryPatchi][j]
); );
const point pos = Cf[j] - 1.1*offset*Sf[j]/magSf[j]; const point pos = Cf[j] - injectionOffset_*offset*Sf[j]/magSf[j];
// Create a new parcel // Create a new parcel
parcelType* pPtr = parcelType* pPtr =
@ -144,7 +159,6 @@ void Foam::SurfaceFilmModel<CloudType>::injectParticles
if (pPtr->nParticle() > 0.001) if (pPtr->nParticle() > 0.001)
{ {
// Check new parcel properties // Check new parcel properties
// cloud.checkParcelProperties(*pPtr, 0.0, true);
cloud.checkParcelProperties(*pPtr, 0.0, false); cloud.checkParcelProperties(*pPtr, 0.0, false);
// Add the new parcel to the cloud // Add the new parcel to the cloud
@ -215,7 +229,7 @@ void Foam::SurfaceFilmModel<CloudType>::inject(TrackCloudType& cloud)
>(names[i]); >(names[i]);
// Check that it is a type areaFilm // Check that it is a type areaFilm
if (regionFa && isA<areaFilm>(*regionFa)) if (regionFa && isA<areaFilm>(*regionFa) && regionFa->active())
{ {
areaFilm& film = areaFilm& film =
const_cast<areaFilm&>(refCast<const areaFilm>(*regionFa)); const_cast<areaFilm&>(refCast<const areaFilm>(*regionFa));
@ -227,6 +241,22 @@ void Foam::SurfaceFilmModel<CloudType>::inject(TrackCloudType& cloud)
cacheFilmFields(patchId, film); cacheFilmFields(patchId, film);
injectParticles(patchId, injectorCellsPatch, cloud); injectParticles(patchId, injectorCellsPatch, cloud);
forAll(injectorCellsPatch, facei)
{
if (diameterParcelPatch_[facei] > 0)
{
film.addSources
(
patchId,
facei,
-massParcelPatch_[facei], // mass
Zero, // tangential momentum
Zero, // impingement
Zero // energy
);
}
}
} }
} }
} }
@ -266,22 +296,26 @@ void Foam::SurfaceFilmModel<CloudType>::cacheFilmFields
const regionModels::areaSurfaceFilmModels::liquidFilmBase& filmModel const regionModels::areaSurfaceFilmModels::liquidFilmBase& filmModel
) )
{ {
// WIP: the finite area film does not support splashing so far
//massParcelPatch_ = filmModel.cloudMassTrans().boundaryField()[filmPatchi];
//filmModel.toPrimary(filmPatchi, massParcelPatch_);
massParcelPatch_.setSize(filmModel.Uf().size(), Zero);
diameterParcelPatch_.setSize(filmModel.Uf().size(), Zero);
// filmModel.cloudDiameterTrans().boundaryField()[filmPatchi];
//filmModel.toPrimary(filmPatchi, diameterParcelPatch_, maxEqOp<scalar>());
const volSurfaceMapping& map = filmModel.region().vsm(); const volSurfaceMapping& map = filmModel.region().vsm();
UFilmPatch_.setSize(filmModel.Uf().size(), Zero); massParcelPatch_.setSize(filmModel.Uf().size(), Zero);
const scalarField& massParcelPatch =
filmModel.cloudMassTrans().boundaryField()[filmPatchi];
map.mapToField(massParcelPatch, massParcelPatch_);
const scalarField& diameterParcelPatch =
filmModel.cloudDiameterTrans().boundaryField()[filmPatchi];
diameterParcelPatch_.setSize(filmModel.Uf().size(), Zero);
map.mapToField(diameterParcelPatch, diameterParcelPatch_);
UFilmPatch_.setSize(filmModel.Uf().size(), vector::zero);
map.mapToField(filmModel.Uf(), UFilmPatch_); map.mapToField(filmModel.Uf(), UFilmPatch_);
//filmModel.toPrimary(filmPatchi, UFilmPatch_);
rhoFilmPatch_.setSize(UFilmPatch_.size(), Zero); rhoFilmPatch_.setSize(UFilmPatch_.size(), Zero);
map.mapToField(filmModel.rho(), rhoFilmPatch_); map.mapToField(filmModel.rho(), rhoFilmPatch_);
//filmModel.toPrimary(filmPatchi, rhoFilmPatch_);
deltaFilmPatch_[filmPatchi].setSize(UFilmPatch_.size(), Zero); deltaFilmPatch_[filmPatchi].setSize(UFilmPatch_.size(), Zero);
map.mapToField(filmModel.h(), deltaFilmPatch_[filmPatchi]); map.mapToField(filmModel.h(), deltaFilmPatch_[filmPatchi]);
@ -303,6 +337,14 @@ void Foam::SurfaceFilmModel<CloudType>::setParcelProperties
p.nParticle() = massParcelPatch_[filmFacei]/p.rho()/vol; p.nParticle() = massParcelPatch_[filmFacei]/p.rho()/vol;
if (minDiameter_ != -1)
{
if (p.d() < minDiameter_)
{
p.nParticle() = 0;
}
}
if (ejectedParcelType_ >= 0) if (ejectedParcelType_ >= 0)
{ {
p.typeId() = ejectedParcelType_; p.typeId() = ejectedParcelType_;
@ -319,22 +361,33 @@ void Foam::SurfaceFilmModel<CloudType>::info(Ostream& os)
label nInject0 = label nInject0 =
this->template getModelProperty<label>("nParcelsInjected"); this->template getModelProperty<label>("nParcelsInjected");
scalar massTransferred0 =
this->template getModelProperty<scalar>("massTransferred");
label nTransTotal = label nTransTotal =
nTrans0 + returnReduce(nParcelsTransferred_, sumOp<label>()); nTrans0 + returnReduce(nParcelsTransferred_, sumOp<label>());
label nInjectTotal = label nInjectTotal =
nInject0 + returnReduce(nParcelsInjected_, sumOp<label>()); nInject0 + returnReduce(nParcelsInjected_, sumOp<label>());
scalar massTransferredTotal =
massTransferred0 + returnReduce(totalMassTransferred_, sumOp<scalar>());
os << " Surface film:" << nl os << " Surface film:" << nl
<< " - parcels absorbed = " << nTransTotal << nl << " - parcels absorbed = " << nTransTotal << nl
<< " - mass absorbed = " << massTransferredTotal << nl
<< " - parcels ejected = " << nInjectTotal << endl; << " - parcels ejected = " << nInjectTotal << endl;
if (this->writeTime()) if (this->writeTime())
{ {
this->setModelProperty("nParcelsTransferred", nTransTotal); this->setModelProperty("nParcelsTransferred", nTransTotal);
this->setModelProperty("nParcelsInjected", nInjectTotal); this->setModelProperty("nParcelsInjected", nInjectTotal);
this->setModelProperty("massTransferred", massTransferredTotal);
nParcelsTransferred_ = 0; nParcelsTransferred_ = 0;
nParcelsInjected_ = 0; nParcelsInjected_ = 0;
totalMassTransferred_ = 0;
} }
} }

26
src/lagrangian/intermediate/submodels/Kinematic/SurfaceFilmModel/SurfaceFilmModel/SurfaceFilmModel.H
View File

@ -6,6 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2017 OpenFOAM Foundation Copyright (C) 2011-2017 OpenFOAM Foundation
Copyright (C) 2020 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -46,6 +47,7 @@ SourceFiles
#include "runTimeSelectionTables.H" #include "runTimeSelectionTables.H"
#include "CloudSubModelBase.H" #include "CloudSubModelBase.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam namespace Foam
@ -96,14 +98,20 @@ protected:
// type // type
label ejectedParcelType_; label ejectedParcelType_;
//- Injection offset position
scalar injectionOffset_;
//- Minimum diameter particle injection
scalar minDiameter_;
// Cached injector fields per film patch // Cached injector fields per film patch
//- Parcel mass / patch face //- Parcel mass / patch face
scalarList massParcelPatch_; scalarField massParcelPatch_;
//- Parcel diameter / patch face //- Parcel diameter / patch face
scalarList diameterParcelPatch_; scalarField diameterParcelPatch_;
//- Film velocity / patch face //- Film velocity / patch face
Field<vector> UFilmPatch_; Field<vector> UFilmPatch_;
@ -124,6 +132,12 @@ protected:
label nParcelsInjected_; label nParcelsInjected_;
// Total mass info
//- Total mass transferred to the film
scalar totalMassTransferred_;
// Protected functions // Protected functions
//- Cache the film fields in preparation for injection //- Cache the film fields in preparation for injection
@ -138,7 +152,7 @@ protected:
virtual void cacheFilmFields virtual void cacheFilmFields
( (
const label primaryPatchi, const label primaryPatchi,
const regionModels::areaSurfaceFilmModels::liquidFilmBase& const areaFilm&
); );
//- Inject particles in cloud //- Inject particles in cloud
@ -232,6 +246,12 @@ public:
// the film model // the film model
inline label& nParcelsInjected(); inline label& nParcelsInjected();
//- Return non-const total mass transferred
inline scalar& totalMassTransferred();
//- Return consr access to mass transferred
inline scalar totalMassTransferred() const;
// Member Functions // Member Functions

13
src/lagrangian/intermediate/submodels/Kinematic/SurfaceFilmModel/SurfaceFilmModel/SurfaceFilmModelI.H
View File

@ -63,5 +63,18 @@ Foam::label Foam::SurfaceFilmModel<CloudType>::nParcelsInjected() const
return nParcelsInjected_; return nParcelsInjected_;
} }
template<class CloudType>
Foam::scalar& Foam::SurfaceFilmModel<CloudType>::totalMassTransferred()
{
return totalMassTransferred_;
}
template<class CloudType>
Foam::scalar Foam::SurfaceFilmModel<CloudType>::totalMassTransferred() const
{
return totalMassTransferred_;
}
// ************************************************************************* // // ************************************************************************* //

252
src/lagrangian/intermediate/submodels/Thermodynamic/SurfaceFilmModel/ThermoSurfaceFilm/ThermoSurfaceFilm.C
View File

@ -131,57 +131,51 @@ Foam::vector Foam::ThermoSurfaceFilm<CloudType>::splashDirection
template<class CloudType> template<class CloudType>
void Foam::ThermoSurfaceFilm<CloudType>::absorbInteraction void Foam::ThermoSurfaceFilm<CloudType>::init()
(
const parcelType& p,
const polyPatch& pp,
const label facei,
const scalar mass,
bool& keepParticle
)
{ {
if (debug) const fvMesh& mesh = this->owner().mesh();
{
Info<< "Parcel " << p.origId() << " absorbInteraction" << endl;
}
// Patch face normal // set up filmModel pointer
const vector& nf = pp.faceNormals()[facei]; filmModel_ =
const_cast<regionFilm*>
// Patch velocity
const vector& Up = this->owner().U().boundaryField()[pp.index()][facei];
// Relative parcel velocity
const vector Urel = p.U() - Up;
// Parcel normal velocity
const vector Un = nf*(Urel & nf);
// Parcel tangential velocity
const vector Ut = Urel - Un;
if (filmModel_)
{
filmModel_->addSources
( (
pp.index(), mesh.time().objectRegistry::template findObject
facei, <
mass, // mass regionFilm
mass*Ut, // tangential momentum >
mass*mag(Un), // impingement pressure (
mass*p.hs() // energy "surfaceFilmProperties"
)
); );
this->nParcelsTransferred()++; // set up areaFilms
const wordList names =
mesh.time().objectRegistry::template
sortedNames<regionModels::regionFaModel>();
keepParticle = false; forAll(names, i)
{
const regionModels::regionFaModel* regionFa =
mesh.time().objectRegistry::template findObject
<
regionModels::regionFaModel
>(names[i]);
if (regionFa && isA<areaFilm>(*regionFa))
{
areaFilm& film =
const_cast<areaFilm&>(refCast<const areaFilm>(*regionFa));
areaFilms_.append(&film);
}
} }
} }
template<class CloudType> template<class CloudType>
template<class filmType>
void Foam::ThermoSurfaceFilm<CloudType>::absorbInteraction void Foam::ThermoSurfaceFilm<CloudType>::absorbInteraction
( (
areaFilm& filmModel, filmType& film,
const parcelType& p, const parcelType& p,
const polyPatch& pp, const polyPatch& pp,
const label facei, const label facei,
@ -189,7 +183,6 @@ void Foam::ThermoSurfaceFilm<CloudType>::absorbInteraction
bool& keepParticle bool& keepParticle
) )
{ {
if (debug) if (debug)
{ {
Info<< "Parcel " << p.origId() << " absorbInteraction" << endl; Info<< "Parcel " << p.origId() << " absorbInteraction" << endl;
@ -209,21 +202,22 @@ void Foam::ThermoSurfaceFilm<CloudType>::absorbInteraction
// Parcel tangential velocity // Parcel tangential velocity
const vector Ut = Urel - Un; const vector Ut = Urel - Un;
DebugVar(mass)
filmModel.addSources film.addSources
( (
pp.index(), pp.index(),
facei, facei,
mass, // mass mass, // mass
mass*Ut, // tangential momentum mass*Ut, // tangential momentum
mass*mag(Un), // impingement pressure mass*mag(Un), // impingement pressure
mass*p.hs() // energy mass*p.hs() // energy
); );
this->nParcelsTransferred()++; this->nParcelsTransferred()++;
keepParticle = false; this->totalMassTransferred() += mass;
keepParticle = false;
} }
@ -258,9 +252,10 @@ void Foam::ThermoSurfaceFilm<CloudType>::bounceInteraction
template<class CloudType> template<class CloudType>
template<class filmType>
void Foam::ThermoSurfaceFilm<CloudType>::drySplashInteraction void Foam::ThermoSurfaceFilm<CloudType>::drySplashInteraction
( (
//regionModels::surfaceFilmModels::surfaceFilmRegionModel& filmModel, filmType& filmModel,
const parcelType& p, const parcelType& p,
const polyPatch& pp, const polyPatch& pp,
const label facei, const label facei,
@ -301,22 +296,24 @@ void Foam::ThermoSurfaceFilm<CloudType>::drySplashInteraction
if (We < Wec) // Adhesion - assume absorb if (We < Wec) // Adhesion - assume absorb
{ {
absorbInteraction(p, pp, facei, m, keepParticle); absorbInteraction<filmType>
(filmModel, p, pp, facei, m, keepParticle);
} }
else // Splash else // Splash
{ {
// Ratio of incident mass to splashing mass // Ratio of incident mass to splashing mass
const scalar mRatio = 0.2 + 0.6*rndGen_.sample01<scalar>(); const scalar mRatio = 0.2 + 0.6*rndGen_.sample01<scalar>();
splashInteraction splashInteraction<filmType>
(p, pp, facei, mRatio, We, Wec, sigma, keepParticle); (filmModel, p, pp, facei, mRatio, We, Wec, sigma, keepParticle);
} }
} }
template<class CloudType> template<class CloudType>
template<class filmType>
void Foam::ThermoSurfaceFilm<CloudType>::wetSplashInteraction void Foam::ThermoSurfaceFilm<CloudType>::wetSplashInteraction
( (
//regionModels::surfaceFilmModels::surfaceFilmRegionModel& filmModel, filmType& filmModel,
parcelType& p, parcelType& p,
const polyPatch& pp, const polyPatch& pp,
const label facei, const label facei,
@ -359,7 +356,8 @@ void Foam::ThermoSurfaceFilm<CloudType>::wetSplashInteraction
if (We < 2) // Adhesion - assume absorb if (We < 2) // Adhesion - assume absorb
{ {
absorbInteraction(p, pp, facei, m, keepParticle); absorbInteraction<filmType>
(filmModel, p, pp, facei, m, keepParticle);
} }
else if ((We >= 2) && (We < 20)) // Bounce else if ((We >= 2) && (We < 20)) // Bounce
{ {
@ -377,23 +375,25 @@ void Foam::ThermoSurfaceFilm<CloudType>::wetSplashInteraction
} }
else if ((We >= 20) && (We < Wec)) // Spread - assume absorb else if ((We >= 20) && (We < Wec)) // Spread - assume absorb
{ {
absorbInteraction(p, pp, facei, m, keepParticle); absorbInteraction<filmType>
(filmModel, p, pp, facei, m, keepParticle);
} }
else // Splash else // Splash
{ {
// Ratio of incident mass to splashing mass // Ratio of incident mass to splashing mass
// splash mass can be > incident mass due to film entrainment // splash mass can be > incident mass due to film entrainment
const scalar mRatio = 0.2 + 0.9*rndGen_.sample01<scalar>(); const scalar mRatio = 0.2 + 0.9*rndGen_.sample01<scalar>();
splashInteraction splashInteraction<filmType>
(p, pp, facei, mRatio, We, Wec, sigma, keepParticle); (filmModel, p, pp, facei, mRatio, We, Wec, sigma, keepParticle);
} }
} }
template<class CloudType> template<class CloudType>
template<class filmType>
void Foam::ThermoSurfaceFilm<CloudType>::splashInteraction void Foam::ThermoSurfaceFilm<CloudType>::splashInteraction
( (
//regionModels::surfaceFilmModels::surfaceFilmRegionModel& filmModel, filmType& filmModel,
const parcelType& p, const parcelType& p,
const polyPatch& pp, const polyPatch& pp,
const label facei, const label facei,
@ -466,7 +466,8 @@ void Foam::ThermoSurfaceFilm<CloudType>::splashInteraction
// Switch to absorb if insufficient energy for splash // Switch to absorb if insufficient energy for splash
if (EKs <= 0) if (EKs <= 0)
{ {
absorbInteraction(p, pp, facei, m, keepParticle); absorbInteraction<filmType>
(filmModel, p, pp, facei, m, keepParticle);
return; return;
} }
@ -521,7 +522,8 @@ void Foam::ThermoSurfaceFilm<CloudType>::splashInteraction
// Transfer remaining part of parcel to film 0 - splashMass can be -ve // Transfer remaining part of parcel to film 0 - splashMass can be -ve
// if entraining from the film // if entraining from the film
const scalar mDash = m - mSplash; const scalar mDash = m - mSplash;
absorbInteraction(p, pp, facei, mDash, keepParticle); absorbInteraction<filmType>
(filmModel, p, pp, facei, mDash, keepParticle);
} }
@ -541,6 +543,7 @@ Foam::ThermoSurfaceFilm<CloudType>::ThermoSurfaceFilm
owner.db().objectRegistry::template lookupObject<SLGThermo>("SLGThermo") owner.db().objectRegistry::template lookupObject<SLGThermo>("SLGThermo")
), ),
filmModel_(nullptr), filmModel_(nullptr),
areaFilms_(0),
TFilmPatch_(0), TFilmPatch_(0),
CpFilmPatch_(0), CpFilmPatch_(0),
interactionType_ interactionType_
@ -570,17 +573,7 @@ Foam::ThermoSurfaceFilm<CloudType>::ThermoSurfaceFilm
this->coeffDict().readEntry("Cf", Cf_); this->coeffDict().readEntry("Cf", Cf_);
} }
filmModel_ = init();
const_cast<regionModels::surfaceFilmModels::surfaceFilmRegionModel*>
(
this->owner().mesh().time().objectRegistry::template findObject
<
regionModels::surfaceFilmModels::surfaceFilmRegionModel
>
(
"surfaceFilmProperties"
)
);
} }
@ -594,6 +587,7 @@ Foam::ThermoSurfaceFilm<CloudType>::ThermoSurfaceFilm
rndGen_(sfm.rndGen_), rndGen_(sfm.rndGen_),
thermo_(sfm.thermo_), thermo_(sfm.thermo_),
filmModel_(nullptr), filmModel_(nullptr),
areaFilms_(0),
TFilmPatch_(sfm.TFilmPatch_), TFilmPatch_(sfm.TFilmPatch_),
CpFilmPatch_(sfm.CpFilmPatch_), CpFilmPatch_(sfm.CpFilmPatch_),
interactionType_(sfm.interactionType_), interactionType_(sfm.interactionType_),
@ -605,17 +599,7 @@ Foam::ThermoSurfaceFilm<CloudType>::ThermoSurfaceFilm
Cf_(sfm.Cf_), Cf_(sfm.Cf_),
nParcelsSplashed_(sfm.nParcelsSplashed_) nParcelsSplashed_(sfm.nParcelsSplashed_)
{ {
filmModel_ = init();
const_cast<regionModels::surfaceFilmModels::surfaceFilmRegionModel*>
(
this->owner().mesh().time().objectRegistry::template findObject
<
regionModels::surfaceFilmModels::surfaceFilmRegionModel
>
(
"surfaceFilmProperties"
)
);
} }
@ -636,10 +620,10 @@ bool Foam::ThermoSurfaceFilm<CloudType>::transferParcel
bool& keepParticle bool& keepParticle
) )
{ {
const fvMesh& mesh = this->owner().mesh();
const label patchi = pp.index(); const label patchi = pp.index();
bool bInteraction(false);
// Check the singleLayer film models // Check the singleLayer film models
if (filmModel_ && filmModel_->isRegionPatch(patchi)) if (filmModel_ && filmModel_->isRegionPatch(patchi))
{ {
@ -656,7 +640,9 @@ bool Foam::ThermoSurfaceFilm<CloudType>::transferParcel
case itAbsorb: case itAbsorb:
{ {
const scalar m = p.nParticle()*p.mass(); const scalar m = p.nParticle()*p.mass();
absorbInteraction(p, pp, facei, m, keepParticle);
absorbInteraction<regionFilm>
(*filmModel_, p, pp, facei, m, keepParticle);
break; break;
} }
@ -666,11 +652,13 @@ bool Foam::ThermoSurfaceFilm<CloudType>::transferParcel
if (dry) if (dry)
{ {
drySplashInteraction(p, pp, facei, keepParticle); drySplashInteraction<regionFilm>
(*filmModel_, p, pp, facei, keepParticle);
} }
else else
{ {
wetSplashInteraction( p, pp, facei, keepParticle); wetSplashInteraction<regionFilm>
(*filmModel_, p, pp, facei, keepParticle);
} }
break; break;
@ -684,59 +672,66 @@ bool Foam::ThermoSurfaceFilm<CloudType>::transferParcel
} }
// Transfer parcel/parcel interactions complete // Transfer parcel/parcel interactions complete
return true; bInteraction = true;
} }
else
for (areaFilm& film : areaFilms_)
{ {
if (patchi == film.patchID())
// Check the finite area films
wordList names =
mesh.time().objectRegistry::template
sortedNames<regionModels::regionFaModel>();
forAll(names, i)
{ {
const regionModels::regionFaModel* regionFa = const label facei = pp.whichFace(p.face());
mesh.time().objectRegistry::template findObject
<
regionModels::regionFaModel
>(names[i]);
// Check that regionFa is a areaFilm switch (interactionType_)
if (regionFa && isA<areaFilm>(*regionFa))
{ {
areaFilm& film = // It only supports absorp model
const_cast<areaFilm&>(refCast<const areaFilm>(*regionFa)); case itAbsorb:
const label facei = pp.whichFace(p.face());
switch (interactionType_)
{ {
// It only supports absorp model const scalar m = p.nParticle()*p.mass();
case itAbsorb:
{ absorbInteraction<areaFilm>
const scalar m = p.nParticle()*p.mass(); (
absorbInteraction film, p, pp, facei, m, keepParticle
( );
film, p, pp, facei, m, keepParticle break;
); }
break; case itBounce:
} {
default: bounceInteraction(p, pp, facei, keepParticle);
{
FatalErrorInFunction break;
<< "Unknown interaction type enumeration" }
<< abort(FatalError); case itSplashBai:
} {
bool dry = film.h()[facei] < deltaWet_;
if (dry)
{
drySplashInteraction<areaFilm>
(film, p, pp, facei, keepParticle);
}
else
{
wetSplashInteraction<areaFilm>
(film, p, pp, facei, keepParticle);
}
break;
}
default:
{
FatalErrorInFunction
<< "Unknown interaction type enumeration"
<< abort(FatalError);
} }
// Transfer parcel/parcel interactions complete
return true;
} }
// Transfer parcel/parcel interactions complete
bInteraction = true;
} }
} }
// Parcel not interacting with film // Parcel not interacting with film
return false; return bInteraction;
} }
@ -779,7 +774,8 @@ void Foam::ThermoSurfaceFilm<CloudType>::cacheFilmFields
TFilmPatch_.setSize(filmModel.Tf().size(), Zero); TFilmPatch_.setSize(filmModel.Tf().size(), Zero);
map.mapToField(filmModel.Tf(), TFilmPatch_); map.mapToField(filmModel.Tf(), TFilmPatch_);
//map.mapToField(filmModel.Cp(), CpFilmPatch_); CpFilmPatch_.setSize(filmModel.Tf().size(), Zero);
map.mapToField(filmModel.Cp(), CpFilmPatch_);
} }

34
src/lagrangian/intermediate/submodels/Thermodynamic/SurfaceFilmModel/ThermoSurfaceFilm/ThermoSurfaceFilm.H
View File

@ -55,6 +55,7 @@ SourceFiles
#define ThermoSurfaceFilm_H #define ThermoSurfaceFilm_H
#include "SurfaceFilmModel.H" #include "SurfaceFilmModel.H"
#include "UPtrList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -121,6 +122,9 @@ protected:
typedef typename typedef typename
regionModels::areaSurfaceFilmModels::liquidFilmBase areaFilm; regionModels::areaSurfaceFilmModels::liquidFilmBase areaFilm;
typedef typename
regionModels::surfaceFilmModels::surfaceFilmRegionModel regionFilm;
//- Reference to the cloud random number generator //- Reference to the cloud random number generator
Random& rndGen_; Random& rndGen_;
@ -128,8 +132,10 @@ protected:
const SLGThermo& thermo_; const SLGThermo& thermo_;
//- Pointer to filmModel //- Pointer to filmModel
regionModels::surfaceFilmModels::surfaceFilmRegionModel* filmModel_; regionFilm* filmModel_;
//- UPointers to area films
UPtrList<areaFilm> areaFilms_;
// Cached injector fields per film patch // Cached injector fields per film patch
@ -189,24 +195,17 @@ protected:
const vector& nf const vector& nf
) const; ) const;
//- Init films pointers
void init();
// Interaction models // Interaction models
//- Absorb parcel into film //- Absorb parcel into film
template<class filmType>
void absorbInteraction void absorbInteraction
( (
//regionModels::surfaceFilmModels::surfaceFilmRegionModel&, filmType&,
const parcelType& p,
const polyPatch& pp,
const label facei,
const scalar mass,
bool& keepParticle
);
//- Absorb parcel into area film
void absorbInteraction
(
areaFilm&,
const parcelType& p, const parcelType& p,
const polyPatch& pp, const polyPatch& pp,
const label facei, const label facei,
@ -224,9 +223,10 @@ protected:
) const; ) const;
//- Parcel interaction with dry surface //- Parcel interaction with dry surface
template<class filmType>
void drySplashInteraction void drySplashInteraction
( (
//regionModels::surfaceFilmModels::surfaceFilmRegionModel&, filmType&,
const parcelType& p, const parcelType& p,
const polyPatch& pp, const polyPatch& pp,
const label facei, const label facei,
@ -234,9 +234,10 @@ protected:
); );
//- Parcel interaction with wetted surface //- Parcel interaction with wetted surface
template<class filmType>
void wetSplashInteraction void wetSplashInteraction
( (
//regionModels::surfaceFilmModels::surfaceFilmRegionModel&, filmType&,
parcelType& p, parcelType& p,
const polyPatch& pp, const polyPatch& pp,
const label facei, const label facei,
@ -244,9 +245,10 @@ protected:
); );
//- Bai parcel splash interaction model //- Bai parcel splash interaction model
template<class filmType>
void splashInteraction void splashInteraction
( (
//regionModels::surfaceFilmModels::surfaceFilmRegionModel&, filmType&,
const parcelType& p, const parcelType& p,
const polyPatch& pp, const polyPatch& pp,
const label facei, const label facei,

16
src/regionFaModels/Make/files
View File

@ -15,9 +15,25 @@ derivedFvPatchFields/vibrationShell/vibrationShellFvPatchScalarField.C
liquidFilm/liquidFilmBase.C liquidFilm/liquidFilmBase.C
liquidFilm/liquidFilmBaseNew.C liquidFilm/liquidFilmBaseNew.C
/* Sub-Model */
liquidFilm/subModels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModel.C liquidFilm/subModels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModel.C
liquidFilm/subModels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModelNew.C liquidFilm/subModels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModelNew.C
liquidFilm/subModels/kinematic/filmTurbulenceModel/laminar/laminar.C liquidFilm/subModels/kinematic/filmTurbulenceModel/laminar/laminar.C
liquidFilm/subModels/kinematic/injectionModel/injectionModelList/injectionModelList.C
liquidFilm/subModels/kinematic/injectionModel/injectionModel/injectionModel.C
liquidFilm/subModels/kinematic/injectionModel/injectionModel/injectionModelNew.C
liquidFilm/subModels/kinematic/injectionModel/curvatureSeparation/curvatureSeparation.C
liquidFilm/subModels/filmSubModelBase.C
liquidFilm/liquidFilmBase.C
liquidFilm/liquidFilmBaseNew.C
liquidFilm/liquidFilmModel/liquidFilmModel.C liquidFilm/liquidFilmModel/liquidFilmModel.C
liquidFilm/kinematicThinFilm/kinematicThinFilm.C liquidFilm/kinematicThinFilm/kinematicThinFilm.C
derivedFvPatchFields/filmShell/velocityFilmShellFvPatchVectorField.C derivedFvPatchFields/filmShell/velocityFilmShellFvPatchVectorField.C

179
src/regionFaModels/liquidFilm/liquidFilmBase.C
View File

@ -28,7 +28,6 @@ License
#include "liquidFilmBase.H" #include "liquidFilmBase.H"
#include "faMesh.H" #include "faMesh.H"
#include "faCFD.H" #include "faCFD.H"
#include "uniformDimensionedFields.H"
#include "gravityMeshObject.H" #include "gravityMeshObject.H"
#include "movingWallVelocityFvPatchVectorField.H" #include "movingWallVelocityFvPatchVectorField.H"
#include "turbulentFluidThermoModel.H" #include "turbulentFluidThermoModel.H"
@ -60,11 +59,11 @@ bool liquidFilmBase::read(const dictionary& dict)
regionFaModel::read(dict); regionFaModel::read(dict);
if (active_) if (active_)
{ {
const dictionary& solution = this->solution().subDict("PISO"); const dictionary& solution = this->solution().subDict("PIMPLE");
solution.readEntry("momentumPredictor", momentumPredictor_); solution.readEntry("momentumPredictor", momentumPredictor_);
solution.readIfPresent("nOuterCorr", nOuterCorr_); solution.readEntry("nOuterCorr", nOuterCorr_);
solution.readEntry("nCorr", nCorr_); solution.readEntry("nCorr", nCorr_);
solution.readEntry("nNonOrthCorr", nNonOrthCorr_); solution.readEntry("nFilmCorr", nFilmCorr_);
} }
return true; return true;
} }
@ -73,28 +72,24 @@ bool liquidFilmBase::read(const dictionary& dict)
scalar liquidFilmBase::CourantNumber() const scalar liquidFilmBase::CourantNumber() const
{ {
scalar CoNum = 0.0; scalar CoNum = 0.0;
scalar meanCoNum = 0.0;
scalar velMag = 0.0; scalar velMag = 0.0;
if (regionMesh().nInternalEdges()) edgeScalarField SfUfbyDelta
{ (
edgeScalarField SfUfbyDelta regionMesh().edgeInterpolation::deltaCoeffs()*mag(phif_)
( );
regionMesh().edgeInterpolation::deltaCoeffs()*mag(phif_)
);
CoNum = max(SfUfbyDelta/regionMesh().magLe()) CoNum = max(SfUfbyDelta/regionMesh().magLe())
.value()*time().deltaT().value(); .value()*time().deltaT().value();
meanCoNum = (sum(SfUfbyDelta)/sum(regionMesh().magLe())) velMag = max(mag(phif_)/regionMesh().magLe()).value();
.value()*time().deltaT().value();
velMag = max(mag(phif_)/regionMesh().magLe()).value(); reduce(CoNum, maxOp<scalar>());
} reduce(velMag, maxOp<scalar>());
Info<< "Film Courant Number mean: " << meanCoNum Info<< "Film Courant Number: "
<< " max: " << CoNum << " max: " << CoNum
<< " Film velocity magnitude: " << velMag << endl; << " Film velocity magnitude: (h)" << velMag << endl;
return CoNum; return CoNum;
} }
@ -114,19 +109,21 @@ liquidFilmBase::liquidFilmBase
momentumPredictor_ momentumPredictor_
( (
this->solution().subDict("PISO").lookup("momentumPredictor") this->solution().subDict("PIMPLE").get<bool>("momentumPredictor")
), ),
nOuterCorr_ nOuterCorr_
( (
this->solution().subDict("PISO").lookupOrDefault("nOuterCorr", 1) this->solution().subDict("PIMPLE").get<label>("nOuterCorr")
), ),
nCorr_(this->solution().subDict("PISO").get<label>("nCorr")), nCorr_(this->solution().subDict("PIMPLE").get<label>("nCorr")),
nNonOrthCorr_ nFilmCorr_
( (
this->solution().subDict("PISO").get<label>("nNonOrthCorr") this->solution().subDict("PIMPLE").get<label>("nFilmCorr")
), ),
h0_("h0", dimLength, SMALL), h0_("h0", dimLength, 1e-7, dict),
deltaWet_("deltaWet", dimLength, 1e-4, dict),
UName_(dict.get<word>("U")), UName_(dict.get<word>("U")),
@ -211,18 +208,6 @@ liquidFilmBase::liquidFilmBase
fac::interpolate(h_*Uf_) & regionMesh().Le() fac::interpolate(h_*Uf_) & regionMesh().Le()
), ),
Tf_
(
IOobject
(
"Tf_" + regionName_,
primaryMesh().time().timeName(),
primaryMesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
regionMesh()
),
gn_ gn_
( (
@ -238,6 +223,8 @@ liquidFilmBase::liquidFilmBase
dimensionedScalar(dimAcceleration, Zero) dimensionedScalar(dimAcceleration, Zero)
), ),
g_(meshObjects::gravity::New(primaryMesh().time())),
massSource_ massSource_
( (
IOobject IOobject
@ -294,10 +281,9 @@ liquidFilmBase::liquidFilmBase
faOptions_(Foam::fa::options::New(p)) faOptions_(Foam::fa::options::New(p))
{ {
const uniformDimensionedVectorField& g =meshObjects::gravity::New(time()); const areaVectorField& ns = regionMesh().faceAreaNormals();
gn_ = (g & regionMesh().faceAreaNormals());
gn_ = g_ & ns;
if (!faOptions_.optionList::size()) if (!faOptions_.optionList::size())
{ {
@ -407,37 +393,7 @@ Foam::tmp<Foam::areaVectorField> liquidFilmBase::Up() const
); );
areaVectorField& Up = tUp.ref(); areaVectorField& Up = tUp.ref();
/*
typedef compressible::turbulenceModel cmpTurbModelType;
typedef incompressible::turbulenceModel incmpTurbModelType;
word turbName
(
IOobject::groupName
(
turbulenceModel::propertiesName,
Up_.internalField().group()
)
);
scalarField nu(patch_.size(), Zero);
if (primaryMesh().foundObject<cmpTurbModelType>(turbName))
{
const cmpTurbModelType& turbModel =
primaryMesh().lookupObject<cmpTurbModelType>(turbName);
//const basicThermo& thermo = turbModel.transport();
nu = turbModel.nu(patchi);
}
if (primaryMesh().foundObject<incmpTurbModelType>(turbName))
{
const incmpTurbModelType& turbModel =
primaryMesh().lookupObject<incmpTurbModelType>(turbName);
nu = turbModel.nu(patchi);
}
*/
scalarField hp(patch_.size(), Zero); scalarField hp(patch_.size(), Zero);
// map areas h to hp on primary // map areas h to hp on primary
@ -481,7 +437,10 @@ tmp<areaScalarField> liquidFilmBase::pg() const
const volScalarField& pp = const volScalarField& pp =
primaryMesh().lookupObject<volScalarField>(pName_); primaryMesh().lookupObject<volScalarField>(pName_);
const volScalarField::Boundary& pw = pp.boundaryField(); volScalarField::Boundary& pw =
const_cast<volScalarField::Boundary&>(pp.boundaryField());
//pw -= pRef_;
pfg.primitiveFieldRef() = vsmPtr_->mapInternalToSurface<scalar>(pw)(); pfg.primitiveFieldRef() = vsmPtr_->mapInternalToSurface<scalar>(pw)();
} }
@ -490,6 +449,30 @@ tmp<areaScalarField> liquidFilmBase::pg() const
} }
tmp<areaScalarField> liquidFilmBase::alpha() const
{
tmp<areaScalarField> talpha
(
new areaScalarField
(
IOobject
(
"talpha",
primaryMesh().time().timeName(),
primaryMesh()
),
regionMesh(),
dimensionedScalar(dimless, Zero)
)
);
areaScalarField& alpha = talpha.ref();
alpha = pos0(h_ - deltaWet_);
return talpha;
}
void liquidFilmBase::addSources void liquidFilmBase::addSources
( (
const label patchi, const label patchi,
@ -507,46 +490,65 @@ void liquidFilmBase::addSources
momentumSource_.boundaryFieldRef()[patchi][facei] += momentumSource; momentumSource_.boundaryFieldRef()[patchi][facei] += momentumSource;
addedMassTotal_ += massSource;
if (debug)
{
InfoInFunction
<< "\nSurface film: " << type() << ": adding to film source:" << nl
<< " mass = " << massSource << nl
<< " momentum = " << momentumSource << nl
<< " pressure = " << pressureSource << endl;
}
} }
void liquidFilmBase::preEvolveRegion()
{
regionFaModel::preEvolveRegion();
}
void liquidFilmBase::postEvolveRegion()
{
if (debug && primaryMesh().time().writeTime())
{
massSource_.write();
pnSource_.write();
momentumSource_.write();
}
massSource_.boundaryFieldRef() = Zero;
pnSource_.boundaryFieldRef() = Zero;
momentumSource_.boundaryFieldRef() = Zero;
regionFaModel::postEvolveRegion();
}
Foam::fa::options& liquidFilmBase::faOptions() Foam::fa::options& liquidFilmBase::faOptions()
{ {
return faOptions_; return faOptions_;
} }
const areaVectorField& liquidFilmBase::Uf() const const areaVectorField& liquidFilmBase::Uf() const
{ {
return Uf_; return Uf_;
} }
const areaScalarField& liquidFilmBase::Tf() const
{
return Tf_;
}
const areaScalarField& liquidFilmBase::gn() const const areaScalarField& liquidFilmBase::gn() const
{ {
return gn_; return gn_;
} }
const uniformDimensionedVectorField& liquidFilmBase::g() const
{
return g_;
}
const areaScalarField& liquidFilmBase::h() const const areaScalarField& liquidFilmBase::h() const
{ {
return h_; return h_;
} }
const edgeScalarField& liquidFilmBase::phif() const
{
return phif_;
}
const edgeScalarField& liquidFilmBase::phi2s() const
{
return phi2s_;
}
const dimensionedScalar& liquidFilmBase::h0() const const dimensionedScalar& liquidFilmBase::h0() const
{ {
return h0_; return h0_;
@ -557,6 +559,7 @@ const regionFaModel& liquidFilmBase::region() const
return *this; return *this;
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace areaSurfaceFilmModels } // End namespace areaSurfaceFilmModels

70
src/regionFaModels/liquidFilm/liquidFilmBase.H
View File

@ -41,10 +41,10 @@ SourceFiles
#include "autoPtr.H" #include "autoPtr.H"
#include "areaFieldsFwd.H" #include "areaFieldsFwd.H"
#include "volFieldsFwd.H" #include "volFieldsFwd.H"
#include "uniformDimensionedFields.H"
#include "regionFaModel.H" #include "regionFaModel.H"
#include "faOptions.H" #include "faOptions.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam namespace Foam
@ -54,7 +54,6 @@ namespace regionModels
namespace areaSurfaceFilmModels namespace areaSurfaceFilmModels
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Class liquidFilmBase Declaration Class liquidFilmBase Declaration
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
@ -92,15 +91,19 @@ protected:
//- Number of PISO-like correctors //- Number of PISO-like correctors
label nCorr_; label nCorr_;
//- Number of non-orthogonal correctors //- Number of film thickness correctors
label nNonOrthCorr_; label nFilmCorr_;
//- Cumulative continuity error //- Cumulative continuity error
scalar cumulativeContErr_; scalar cumulativeContErr_;
//- Small delta //- Smallest numerical thickness
dimensionedScalar h0_; dimensionedScalar h0_;
//- Delta wet for sub-models
dimensionedScalar deltaWet_;
//- Name of the velocity field //- Name of the velocity field
word UName_; word UName_;
@ -131,14 +134,14 @@ protected:
//- Film height flux //- Film height flux
edgeScalarField phi2s_; edgeScalarField phi2s_;
//- Film temperature
areaScalarField Tf_;
//- Normal gravity field //- Normal gravity field
areaScalarField gn_; areaScalarField gn_;
//- Gravity
uniformDimensionedVectorField g_;
// Mass exchanage fields
// Mass exchanage fields from the primary region (lagragian)
//- Mass //- Mass
volScalarField massSource_; volScalarField massSource_;
@ -156,10 +159,12 @@ protected:
scalar addedMassTotal_; scalar addedMassTotal_;
//- Pointer to faOptions //- Pointer to faOptions
Foam::fa::options& faOptions_; Foam::fa::options& faOptions_;
// Protected Member Functions // Protected Member Functions
//- Read control parameters from dictionary //- Read control parameters from dictionary
@ -235,6 +240,10 @@ public:
//- Map primary static pressure //- Map primary static pressure
tmp<areaScalarField> pg() const; tmp<areaScalarField> pg() const;
//- Wet indicator using h0
tmp<areaScalarField> alpha() const;
// Access functions // Access functions
//- Return faOptions //- Return faOptions
@ -243,15 +252,22 @@ public:
//- Access const reference Uf //- Access const reference Uf
const areaVectorField& Uf() const; const areaVectorField& Uf() const;
//- Access const reference Tf
const areaScalarField& Tf() const;
//- Access const reference gn //- Access const reference gn
const areaScalarField& gn() const; const areaScalarField& gn() const;
//- Gravity
const uniformDimensionedVectorField& g() const;
//- Access const reference h //- Access const reference h
const areaScalarField& h() const; const areaScalarField& h() const;
//- Access to momentum flux
const edgeScalarField& phif() const;
//- Access continuity flux
const edgeScalarField& phi2s() const;
//- Return h0 //- Return h0
const dimensionedScalar& h0() const; const dimensionedScalar& h0() const;
@ -259,6 +275,28 @@ public:
const regionFaModel& region() const; const regionFaModel& region() const;
// Transfer fields - to the primary region (lagragian injection)
//- Return mass transfer source - Eulerian phase only
//virtual tmp<volScalarField> primaryMassTrans() const = 0;
//- Return the film mass available for transfer to cloud
virtual const volScalarField& cloudMassTrans() const = 0;
//- Return the parcel diameters originating from film to cloud
virtual const volScalarField& cloudDiameterTrans() const = 0;
// Evolution
//- Pre-evolve film
virtual void preEvolveRegion();
//- Post-evolve film
virtual void postEvolveRegion();
// Thermo variables // Thermo variables
//- Access const reference mu //- Access const reference mu
@ -270,11 +308,16 @@ public:
//- Access const reference sigma //- Access const reference sigma
virtual const areaScalarField& sigma() const = 0; virtual const areaScalarField& sigma() const = 0;
//- Access const reference Tf
virtual const areaScalarField& Tf() const = 0;
//- Access const reference Cp
virtual const areaScalarField& Cp() const = 0;
// External hook to add sources and mass exchange variables // External hook to add sources and mass exchange variables
//- Add sources //- Add sources
virtual void addSources virtual void addSources
( (
@ -285,7 +328,6 @@ public:
const scalar pressureSource, // [kg.m/s] (normal momentum) const scalar pressureSource, // [kg.m/s] (normal momentum)
const scalar energySource = 0 // [J] const scalar energySource = 0 // [J]
); );
}; };

143
src/regionFaModels/liquidFilm/liquidFilmModel/liquidFilmModel.C
View File

@ -31,6 +31,7 @@ License
#include "gravityMeshObject.H" #include "gravityMeshObject.H"
#include "volFields.H" #include "volFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam namespace Foam
@ -61,6 +62,7 @@ void liquidFilmModel::correctThermoFields()
rho_[faceI] = thermo_.rho(pRef_, Tf_[faceI], X); rho_[faceI] = thermo_.rho(pRef_, Tf_[faceI], X);
mu_[faceI] = thermo_.mu(pRef_, Tf_[faceI], X); mu_[faceI] = thermo_.mu(pRef_, Tf_[faceI], X);
sigma_[faceI] = thermo_.sigma(pRef_, Tf_[faceI], X); sigma_[faceI] = thermo_.sigma(pRef_, Tf_[faceI], X);
Cp_[faceI] = thermo_.Cp(pRef_, Tf_[faceI], X);
} }
forAll (regionMesh().boundary(), patchI) forAll (regionMesh().boundary(), patchI)
@ -70,14 +72,19 @@ void liquidFilmModel::correctThermoFields()
scalarField& patchRho = rho_.boundaryFieldRef()[patchI]; scalarField& patchRho = rho_.boundaryFieldRef()[patchI];
scalarField& patchmu = mu_.boundaryFieldRef()[patchI]; scalarField& patchmu = mu_.boundaryFieldRef()[patchI];
scalarField& patchsigma = sigma_.boundaryFieldRef()[patchI]; scalarField& patchsigma = sigma_.boundaryFieldRef()[patchI];
scalarField& patchCp = Cp_.boundaryFieldRef()[patchI];
forAll(patchRho, edgeI) forAll(patchRho, edgeI)
{ {
patchRho[edgeI] = thermo_.rho(pRef_, patchTf[edgeI], X); patchRho[edgeI] = thermo_.rho(pRef_, patchTf[edgeI], X);
patchmu[edgeI] = thermo_.mu(pRef_, patchTf[edgeI], X); patchmu[edgeI] = thermo_.mu(pRef_, patchTf[edgeI], X);
patchsigma[edgeI] = thermo_.sigma(pRef_, patchTf[edgeI], X); patchsigma[edgeI] = thermo_.sigma(pRef_, patchTf[edgeI], X);
patchCp[edgeI] = thermo_.Cp(pRef_, patchTf[edgeI], X);
} }
} }
//Initialize pf_
pf_ = rho_*gn_*h_ - sigma_*fac::laplacian(h_);
} }
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
@ -119,6 +126,32 @@ liquidFilmModel::liquidFilmModel
regionMesh(), regionMesh(),
dimensionedScalar(dimViscosity, Zero) dimensionedScalar(dimViscosity, Zero)
), ),
Tf_
(
IOobject
(
"Tf_" + regionName_,
primaryMesh().time().timeName(),
primaryMesh(),
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
regionMesh(),
dimensionedScalar(dimTemperature, Zero)
),
Cp_
(
IOobject
(
"Cp_" + regionName_,
primaryMesh().time().timeName(),
primaryMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
regionMesh(),
dimensionedScalar(dimEnergy/dimTemperature, Zero)
),
sigma_ sigma_
( (
IOobject IOobject
@ -151,7 +184,9 @@ liquidFilmModel::liquidFilmModel
( (
"rhoSp", "rhoSp",
primaryMesh().time().timeName(), primaryMesh().time().timeName(),
primaryMesh() primaryMesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
), ),
regionMesh(), regionMesh(),
dimensionedScalar(dimVelocity, Zero) dimensionedScalar(dimVelocity, Zero)
@ -178,8 +213,49 @@ liquidFilmModel::liquidFilmModel
regionMesh(), regionMesh(),
dimensionedScalar(dimPressure, Zero) dimensionedScalar(dimPressure, Zero)
), ),
turbulence_(filmTurbulenceModel::New(*this, dict)) cloudMassTrans_
(
IOobject
(
"cloudMassTrans",
primaryMesh().time().timeName(),
primaryMesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
primaryMesh(),
dimensionedScalar(dimMass, Zero),
calculatedFvPatchField<scalar>::typeName
),
cloudDiameterTrans_
(
IOobject
(
"cloudDiameterTrans",
primaryMesh().time().timeName(),
primaryMesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
primaryMesh(),
dimensionedScalar(dimLength, Zero),
calculatedFvPatchField<scalar>::typeName
),
turbulence_(filmTurbulenceModel::New(*this, dict)),
availableMass_(regionMesh().faces().size(), Zero),
injection_(*this, dict),
forces_(*this, dict)
{ {
if (dict.found("T0"))
{
Tf_ = dimensionedScalar("T0", dimTemperature, dict);
}
correctThermoFields(); correctThermoFields();
} }
@ -208,8 +284,39 @@ const areaScalarField& liquidFilmModel::sigma() const
return sigma_; return sigma_;
} }
const areaScalarField& liquidFilmModel::Tf() const
{
return Tf_;
}
const areaScalarField& liquidFilmModel::Cp() const
{
return Cp_;
}
const volScalarField& liquidFilmModel::cloudMassTrans() const
{
return cloudMassTrans_;
}
const volScalarField& liquidFilmModel::cloudDiameterTrans() const
{
return cloudDiameterTrans_;
}
void liquidFilmModel::preEvolveRegion() void liquidFilmModel::preEvolveRegion()
{ {
liquidFilmBase::preEvolveRegion();
cloudMassTrans_ == dimensionedScalar(dimMass, Zero);
cloudDiameterTrans_ == dimensionedScalar(dimLength, Zero);
const scalar deltaT = primaryMesh().time().deltaTValue(); const scalar deltaT = primaryMesh().time().deltaTValue();
const scalarField rAreaDeltaT = 1/deltaT/regionMesh().S().field(); const scalarField rAreaDeltaT = 1/deltaT/regionMesh().S().field();
@ -219,6 +326,7 @@ void liquidFilmModel::preEvolveRegion()
// [kg.m/s] // [kg.m/s]
USp_.primitiveFieldRef() = USp_.primitiveFieldRef() =
vsm().mapToSurface(momentumSource_.boundaryField()[patchID()]); vsm().mapToSurface(momentumSource_.boundaryField()[patchID()]);
pnSp_.primitiveFieldRef() = pnSp_.primitiveFieldRef() =
vsm().mapToSurface(pnSource_.boundaryField()[patchID()]); vsm().mapToSurface(pnSource_.boundaryField()[patchID()]);
@ -227,13 +335,38 @@ void liquidFilmModel::preEvolveRegion()
rhoSp_.primitiveFieldRef() *= rAreaDeltaT/rho_; rhoSp_.primitiveFieldRef() *= rAreaDeltaT/rho_;
USp_.primitiveFieldRef() *= rAreaDeltaT/rho_; USp_.primitiveFieldRef() *= rAreaDeltaT/rho_;
pnSp_.primitiveFieldRef() *= rAreaDeltaT/rho_; pnSp_.primitiveFieldRef() *= rAreaDeltaT/rho_;
rhoSp_.relax();
pnSp_.relax();
USp_.relax();
} }
void liquidFilmModel::postEvolveRegion() void liquidFilmModel::postEvolveRegion()
{ {
massSource_ == dimensionedScalar(massSource_.dimensions(), Zero); availableMass_ = (h() - h0_)*rho()*regionMesh().S();
momentumSource_ == dimensionedVector(momentumSource_.dimensions(), Zero); injection_.correct(availableMass_, cloudMassTrans_, cloudDiameterTrans_);
pnSource_ == dimensionedScalar(pnSource_.dimensions(), Zero); liquidFilmBase::postEvolveRegion();
}
void liquidFilmModel::info()
{
Info<< "\nSurface film: " << type() << " on patch: " << patchID() << endl;
const DimensionedField<scalar, areaMesh>& sf = regionMesh().S();
Info<< indent << "min/max(mag(Uf)) = " << gMin(mag(Uf_.field())) << ", "
<< gMax(mag(Uf_.field())) << nl
<< indent << "min/max(delta) = " << gMin(h_.field()) << ", " << gMax(h_.field()) << nl
<< indent << "coverage = "
<< gSum(alpha()().field()*mag(sf.field()))/gSum(mag(sf.field())) << nl
<< indent << "total mass = "
<< gSum(availableMass_) << nl;
Info<< indent << CourantNumber() << endl;
injection_.info(Info);
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

55
src/regionFaModels/liquidFilm/liquidFilmModel/liquidFilmModel.H
View File

@ -42,8 +42,16 @@ SourceFiles
#include "volFieldsFwd.H" #include "volFieldsFwd.H"
#include "liquidFilmBase.H" #include "liquidFilmBase.H"
#include "faMesh.H" #include "faMesh.H"
#include "filmTurbulenceModel.H" #include "filmTurbulenceModel.H"
#include "liquidMixtureProperties.H" #include "liquidMixtureProperties.H"
#include "injectionModelList.H"
#include "faCFD.H"
//#include "transferModelList.H"
#include "forceList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -54,6 +62,7 @@ namespace regionModels
namespace areaSurfaceFilmModels namespace areaSurfaceFilmModels
{ {
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Class liquidFilmModel Declaration Class liquidFilmModel Declaration
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
@ -94,6 +103,12 @@ protected:
//- Dynamic viscosity [Pa.s] //- Dynamic viscosity [Pa.s]
areaScalarField mu_; areaScalarField mu_;
//- Film temperature
areaScalarField Tf_;
//- Film Heat capacity
areaScalarField Cp_;
//- Surface tension [m/s2] //- Surface tension [m/s2]
areaScalarField sigma_; areaScalarField sigma_;
@ -112,6 +127,15 @@ protected:
areaScalarField pnSp_; areaScalarField pnSp_;
// Transfer fields
//- Film mass for transfer to cloud
volScalarField cloudMassTrans_;
//- Parcel diameters originating from film to cloud
volScalarField cloudDiameterTrans_;
// General properties // General properties
@ -120,6 +144,21 @@ protected:
autoPtr<filmTurbulenceModel> turbulence_; autoPtr<filmTurbulenceModel> turbulence_;
// Sub-models
//- Available mass for transfer via sub-models
scalarField availableMass_;
//- Cloud injection
injectionModelList injection_;
//- Transfer with the continuous phase
//transferModelList transfer_;
//- List of film forces
forceList forces_;
// Protected member functions // Protected member functions
@ -169,6 +208,20 @@ public:
//- Access const reference sigma //- Access const reference sigma
const areaScalarField& sigma() const; const areaScalarField& sigma() const;
//- Access const reference Tf
const areaScalarField& Tf() const;
//- Access const reference Cp
const areaScalarField& Cp() const;
// Transfer fields - to the primary region (lagragian injection)
//- Return the film mass available for transfer to cloud
virtual const volScalarField& cloudMassTrans() const;
//- Return the parcel diameters originating from film to cloud
virtual const volScalarField& cloudDiameterTrans() const;
// Evolution // Evolution
@ -185,7 +238,7 @@ public:
// I-O // I-O
//- Provide some feedback //- Provide some feedback
//virtual void info(); virtual void info();
}; };

110
src/regionFaModels/liquidFilm/subModels/filmSubModelBase.C Normal file
View File

@ -0,0 +1,110 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "filmSubModelBase.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace regionModels
{
namespace areaSurfaceFilmModels
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
filmSubModelBase::filmSubModelBase(liquidFilmBase& film)
:
subModelBase(film.outputProperties()),
filmModel_(film)
{}
filmSubModelBase::filmSubModelBase
(
liquidFilmBase& film,
const dictionary& dict,
const word& baseName,
const word& modelType,
const word& dictExt
)
:
subModelBase
(
film.outputProperties(),
dict,
baseName,
modelType,
dictExt
),
filmModel_(film)
{}
filmSubModelBase::filmSubModelBase
(
const word& modelName,
liquidFilmBase& film,
const dictionary& dict,
const word& baseName,
const word& modelType
)
:
subModelBase
(
modelName,
film.outputProperties(),
dict,
baseName,
modelType
),
filmModel_(film)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
filmSubModelBase::~filmSubModelBase()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
bool filmSubModelBase::writeTime() const
{
return active() && filmModel_.time().writeTime();
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace areaSurfaceFilmModels
} // End namespace regionModels
} // End namespace Foam
// ************************************************************************* //

139
src/regionFaModels/liquidFilm/subModels/filmSubModelBase.H Normal file
View File

@ -0,0 +1,139 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::regionModels::surfaceFilmModels::filmSubModelBase
Description
Base class for surface film sub-models
SourceFiles
filmSubModelBaseI.H
filmSubModelBase.C
\*---------------------------------------------------------------------------*/
#ifndef filmSubModelBase_H
#define filmSubModelBase_H
#include "liquidFilmBase.H"
#include "subModelBase.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace regionModels
{
namespace areaSurfaceFilmModels
{
/*---------------------------------------------------------------------------*\
Class filmSubModelBase Declaration
\*---------------------------------------------------------------------------*/
class filmSubModelBase
:
public subModelBase
{
protected:
// Protected Data
//- Reference to the film surface film model
liquidFilmBase& filmModel_;
public:
// Constructors
//- Construct null
filmSubModelBase(liquidFilmBase& film);
//- Construct from film film without name
filmSubModelBase
(
liquidFilmBase& film,
const dictionary& dict,
const word& baseName,
const word& modelType,
const word& dictExt = "Coeffs"
);
//- Construct from film film with name
filmSubModelBase
(
const word& modelName,
liquidFilmBase& film,
const dictionary& dict,
const word& baseName,
const word& modelType
);
//- Destructor
virtual ~filmSubModelBase();
// Member Functions
// Access
//- Flag to indicate when to write a property
virtual bool writeTime() const;
//- Return const access to the film surface film model
inline const liquidFilmBase& film() const;
//- Return the reference to the film surface film model
inline liquidFilmBase& film();
template<class FilmType>
inline const FilmType& filmType() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace areaSurfaceFilmModels
} // End namespace regionModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "filmSubModelBaseI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "filmSubModelBaseTemplates.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

57
src/regionFaModels/liquidFilm/subModels/filmSubModelBaseI.H Normal file
View File

@ -0,0 +1,57 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace regionModels
{
namespace areaSurfaceFilmModels
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
inline const liquidFilmBase& filmSubModelBase::film() const
{
return filmModel_;
}
inline liquidFilmBase& filmSubModelBase::film()
{
return filmModel_;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace areaSurfaceFilmModels
} // End namespace regionModels
} // End namespace Foam
// ************************************************************************* //

58
src/regionFaModels/liquidFilm/subModels/filmSubModelBaseTemplates.C Normal file
View File

@ -0,0 +1,58 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
namespace Foam
{
namespace regionModels
{
namespace areaSurfaceFilmModels
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class FilmType>
const FilmType& filmSubModelBase::filmType() const
{
if (!isA<FilmType>(filmModel_))
{
FatalErrorInFunction
<< "Model " << this->modelType() << " requested film type "
<< FilmType::typeName << " but film is type " << filmModel_.type()
<< abort(FatalError);
}
return refCast<const FilmType>(filmModel_);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace areaSurfaceFilmModels
} // End namespace regionModels
} // End namespace Foam
// ************************************************************************* //

4
src/regionFaModels/liquidFilm/subModels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModel.C
View File

@ -106,7 +106,7 @@ tmp<areaScalarField> filmTurbulenceModel::Cw() const
const scalarField& mu = film_.mu().primitiveField(); const scalarField& mu = film_.mu().primitiveField();
const scalarField& h = film_.h().primitiveField(); const scalarField& h = film_.h().primitiveField();
const scalar h0 = film_.h0().value(); const scalar h0 = film_.h0().value();
Cw.primitiveFieldRef() = mu/((1.0/3.0)*(h + h0)); Cw.primitiveFieldRef() = 3*mu/(h + h0);
Cw.min(5000.0); Cw.min(5000.0);
break; break;
} }
@ -141,7 +141,7 @@ tmp<areaScalarField> filmTurbulenceModel::Cw() const
const scalar h0 = film_.h0().value(); const scalar h0 = film_.h0().value();
Cw.primitiveFieldRef() = Cw.primitiveFieldRef() =
sqr(n)*mag(g.value())*mag(Uf)/cbrt(h+ h0); sqr(n)*mag(g.value())*mag(Uf)/cbrt(h+h0);
break; break;
} }
default: default:

4
src/regionFaModels/liquidFilm/subModels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModel.H
View File

@ -35,8 +35,8 @@ SourceFiles
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef filmTurbulenceModel_H #ifndef regionFaModels_filmTurbulenceModel_H
#define filmTurbulenceModel_H #define regionFaModels_filmTurbulenceModel_H
#include "areaFieldsFwd.H" #include "areaFieldsFwd.H"
#include "runTimeSelectionTables.H" #include "runTimeSelectionTables.H"

4
src/regionFaModels/liquidFilm/subModels/kinematic/filmTurbulenceModel/laminar/laminar.C
View File

@ -96,13 +96,13 @@ tmp<faVectorMatrix> laminar::Su(areaVectorField& U) const
tmp<areaVectorField> Up = film_.Up(); tmp<areaVectorField> Up = film_.Up();
// employ simple coeff-based model // employ simple coeff-based model
areaScalarField Cs("Cs", Cf_*mag(Up() - U)); const dimensionedScalar Cf("Cf", dimVelocity, Cf_);
tmp<areaScalarField> wf = Cw(); tmp<areaScalarField> wf = Cw();
return return
( (
- fam::Sp(Cs, U) + Cs*Up() // surface contribution - fam::Sp(Cf, U) + Cf*Up() // surface contribution
- fam::Sp(wf(), U) + wf()*Uw() // wall contribution - fam::Sp(wf(), U) + wf()*Uw() // wall contribution
); );
} }

6
src/regionFaModels/liquidFilm/subModels/kinematic/filmTurbulenceModel/laminar/laminar.H
View File

@ -34,10 +34,10 @@ SourceFiles
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#ifndef laminar_H #ifndef regionFaModels_surfaceFilmModels_laminar_H
#define laminar_H #define regionFaModels_surfaceFilmModels_laminar_H
#include "filmTurbulenceModel.H" #include "liquidFilm/subModels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModel.H"
#include "faCFD.H" #include "faCFD.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

324
src/regionFaModels/liquidFilm/subModels/kinematic/injectionModel/curvatureSeparation/curvatureSeparation.C Normal file
View File

@ -0,0 +1,324 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2017 OpenFOAM Foundation
Copyright (C) 2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "curvatureSeparation.H"
#include "addToRunTimeSelectionTable.H"
#include "Time.H"
#include "stringListOps.H"
#include "cyclicPolyPatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace regionModels
{
namespace areaSurfaceFilmModels
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(curvatureSeparation, 0);
addToRunTimeSelectionTable
(
injectionModel,
curvatureSeparation,
dictionary
);
// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
tmp<areaScalarField> curvatureSeparation::calcInvR1
(
const areaVectorField& U,
const scalarField& calcCosAngle
) const
{
const dimensionedScalar smallU(dimVelocity, ROOTVSMALL);
const areaVectorField UHat(U/(mag(U) + smallU));
tmp<areaScalarField> tinvR1
(
new areaScalarField("invR1", UHat & (UHat & -gradNHat_))
);
scalarField& invR1 = tinvR1.ref().primitiveFieldRef();
// apply defined patch radii
const scalar rMin = 1e-6;
const scalar definedInvR1 = 1.0/max(rMin, definedPatchRadii_);
if (definedPatchRadii_ > 0)
{
invR1 = definedInvR1;
}
// filter out large radii
const scalar rMax = 1e6;
forAll(invR1, i)
{
if ((mag(invR1[i]) < 1/rMax))
{
invR1[i] = -1.0;
}
}
return tinvR1;
}
tmp<scalarField> curvatureSeparation::calcCosAngle
(
const edgeScalarField& phi
) const
{
const areaVectorField& U = film().Uf();
const dimensionedScalar smallU(dimVelocity, ROOTVSMALL);
const areaVectorField UHat(U/(mag(U) + smallU));
const faMesh& mesh = film().regionMesh();
const labelUList& own = mesh.edgeOwner();
const labelUList& nbr = mesh.edgeNeighbour();
scalarField phiMax(mesh.nFaces(), -GREAT);
scalarField cosAngle(UHat.size(), Zero);
const scalarField invR1(calcInvR1(U, cosAngle));
forAll(nbr, edgei)
{
const label cellO = own[edgei];
const label cellN = nbr[edgei];
if (phi[edgei] > phiMax[cellO])
{
phiMax[cellO] = phi[edgei];
cosAngle[cellO] = -gHat_ & UHat[cellN];
}
if (-phi[edgei] > phiMax[cellN])
{
phiMax[cellN] = -phi[edgei];
cosAngle[cellN] = -gHat_ & UHat[cellO];
}
}
cosAngle *= pos(invR1);
// checks
if (debug && mesh.time().writeTime())
{
areaScalarField volCosAngle
(
IOobject
(
"cosAngle",
film().primaryMesh().time().timeName(),
film().primaryMesh(),
IOobject::NO_READ
),
film().regionMesh(),
dimensionedScalar(dimless, Zero)
);
volCosAngle.primitiveFieldRef() = cosAngle;
volCosAngle.correctBoundaryConditions();
volCosAngle.write();
}
return max(min(cosAngle, scalar(1)), scalar(-1));
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
curvatureSeparation::curvatureSeparation
(
liquidFilmBase& film,
const dictionary& dict
)
:
injectionModel(type(), film, dict),
gradNHat_(fac::grad(film.regionMesh().faceAreaNormals())),
deltaByR1Min_(coeffDict_.getOrDefault<scalar>("deltaByR1Min", 0)),
definedPatchRadii_
(
coeffDict_.getOrDefault<scalar>("definedPatchRadii", 0)
),
magG_(mag(film.g().value())),
gHat_(Zero),
fThreshold_
(
coeffDict_.getOrDefault<scalar>("fThreshold", 1e-8)
),
minInvR1_
(
coeffDict_.getOrDefault<scalar>("minInvR1", 5)
)
{
if (magG_ < ROOTVSMALL)
{
FatalErrorInFunction
<< "Acceleration due to gravity must be non-zero"
<< exit(FatalError);
}
gHat_ = film.g().value()/magG_;
}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
void curvatureSeparation::correct
(
scalarField& availableMass,
scalarField& massToInject,
scalarField& diameterToInject
)
{
const faMesh& mesh = film().regionMesh();
const areaScalarField& delta = film().h();
const areaVectorField& U = film().Uf();
const edgeScalarField& phi = film().phi2s();
const areaScalarField& rho = film().rho();
const scalarField magSqrU(magSqr(film().Uf()));
const areaScalarField& sigma = film().sigma();
const scalarField cosAngle(calcCosAngle(phi));
const scalarField invR1(calcInvR1(U, cosAngle));
// calculate force balance
scalarField Fnet(mesh.nFaces(), Zero);
scalarField separated(mesh.nFaces(), Zero);
forAll(invR1, i)
{
if ((invR1[i] > minInvR1_) && (delta[i]*invR1[i] > deltaByR1Min_))
{
const scalar R1 = 1.0/(invR1[i] + ROOTVSMALL);
const scalar R2 = R1 + delta[i];
// inertial force
const scalar Fi = -delta[i]*rho[i]*magSqrU[i]*72.0/60.0*invR1[i];
// body force
const scalar Fb =
- 0.5*rho[i]*magG_*invR1[i]*(sqr(R1) - sqr(R2))*cosAngle[i];
// surface force
const scalar Fs = sigma[i]/R2;
Fnet[i] = Fi + Fb + Fs;
if (Fnet[i] + fThreshold_ < 0)
{
separated[i] = 1.0;
}
}
}
// inject all available mass
massToInject = separated*availableMass;
diameterToInject = separated*delta;
availableMass -= separated*availableMass;
addToInjectedMass(sum(massToInject));
if (debug && mesh.time().writeTime())
{
areaScalarField volFnet
(
IOobject
(
"Fnet",
film().primaryMesh().time().timeName(),
film().primaryMesh(),
IOobject::NO_READ
),
mesh,
dimensionedScalar(dimForce, Zero)
);
volFnet.primitiveFieldRef() = Fnet;
volFnet.write();
areaScalarField areaSeparated
(
IOobject
(
"separated",
film().primaryMesh().time().timeName(),
film().primaryMesh(),
IOobject::NO_READ
),
mesh,
dimensionedScalar(dimMass, Zero)
);
areaSeparated.primitiveFieldRef() = separated;
areaSeparated.write();
areaScalarField areaMassToInject
(
IOobject
(
"massToInject",
film().primaryMesh().time().timeName(),
film().primaryMesh(),
IOobject::NO_READ
),
mesh,
dimensionedScalar(dimMass, Zero)
);
areaMassToInject.primitiveFieldRef() = massToInject;
areaMassToInject.write();
areaScalarField areaInvR1
(
IOobject
(
"InvR1",
film().primaryMesh().time().timeName(),
film().primaryMesh(),
IOobject::NO_READ
),
mesh,
dimensionedScalar(inv(dimLength), Zero)
);
areaInvR1.primitiveFieldRef() = invR1;
areaInvR1.write();
}
injectionModel::correct();
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace areaSurfaceFilmModels
} // End namespace regionModels
} // End namespace Foam
// ************************************************************************* //

167
src/regionFaModels/liquidFilm/subModels/kinematic/injectionModel/curvatureSeparation/curvatureSeparation.H Normal file
View File

@ -0,0 +1,167 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2017 OpenFOAM Foundation
Copyright (C) 2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::regionModels::areaSurfaceFilmModels::curvatureSeparation
Description
Curvature film separation model
Assesses film curvature via the mesh geometry and calculates a force
balance of the form:
F_sum = F_inertial + F_body + F_surface
If F_sum < 0, the film separates. Similarly, if F_sum > 0 the film will
remain attached.
Based on description given by
Owen and D. J. Ryley. The flow of thin liquid films around corners.
International Journal of Multiphase Flow, 11(1):51-62, 1985.
SourceFiles
curvatureSeparation.C
\*---------------------------------------------------------------------------*/
#ifndef curvatureSeparation_H
#define curvatureSeparation_H
#include "injectionModel.H"
#include "faCFD.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace regionModels
{
namespace areaSurfaceFilmModels
{
/*---------------------------------------------------------------------------*\
Class curvatureSeparation Declaration
\*---------------------------------------------------------------------------*/
class curvatureSeparation
:
public injectionModel
{
// Private Member Functions
//- No copy construct
curvatureSeparation(const curvatureSeparation&) = delete;
//- No copy assignment
void operator=(const curvatureSeparation&) = delete;
protected:
// Protected Data
//- Gradient of surface normals
areaTensorField gradNHat_;
//- Minimum gravity driven film thickness (non-dimensionalised delta/R1)
scalar deltaByR1Min_;
//- List of radii for patches - if patch not defined, radius
//- calculated based on mesh geometry
scalar definedPatchRadii_;
//- Magnitude of gravity vector
scalar magG_;
//- Direction of gravity vector
vector gHat_;
//- Threshold force for separation
scalar fThreshold_;
//- Minimum inv R1 for separation
scalar minInvR1_;
// Protected Member Functions
//- Calculate local (inverse) radius of curvature
tmp<areaScalarField> calcInvR1
(
const areaVectorField& U,
const scalarField& calcCosAngle
) const;
//- Calculate the cosine of the angle between gravity vector and
//- cell out flow direction
tmp<scalarField> calcCosAngle(const edgeScalarField& phi) const;
public:
//- Runtime type information
TypeName("curvatureSeparation");
// Constructors
//- Construct from surface film model
curvatureSeparation
(
liquidFilmBase& film,
const dictionary& dict
);
//- Destructor
virtual ~curvatureSeparation() = default;
// Member Functions
// Evolution
//- Correct
virtual void correct
(
scalarField& availableMass,
scalarField& massToInject,
scalarField& diameterToInject
);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace areaSurfaceFilmModels
} // End namespace regionModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

106
src/regionFaModels/liquidFilm/subModels/kinematic/injectionModel/injectionModel/injectionModel.C Normal file
View File

@ -0,0 +1,106 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "injectionModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace regionModels
{
namespace areaSurfaceFilmModels
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(injectionModel, 0);
defineRunTimeSelectionTable(injectionModel, dictionary);
// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
void injectionModel::addToInjectedMass(const scalar dMass)
{
injectedMass_ += dMass;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
injectionModel::injectionModel(liquidFilmBase& film)
:
filmSubModelBase(film),
injectedMass_(0.0)
{}
injectionModel::injectionModel
(
const word& modelType,
liquidFilmBase& film,
const dictionary& dict
)
:
filmSubModelBase(film, dict, typeName, modelType),
injectedMass_(0.0)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
injectionModel::~injectionModel()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
void injectionModel::correct()
{
if (writeTime())
{
scalar injectedMass0 = getModelProperty<scalar>("injectedMass");
injectedMass0 += returnReduce(injectedMass_, sumOp<scalar>());
setModelProperty<scalar>("injectedMass", injectedMass0);
injectedMass_ = 0.0;
}
}
scalar injectionModel::injectedMassTotal() const
{
const scalar injectedMass0 = getModelProperty<scalar>("injectedMass");
return injectedMass0 + returnReduce(injectedMass_, sumOp<scalar>());
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace areaSurfaceFilmModels
} // End namespace regionModels
} // End namespace Foam
// ************************************************************************* //

169
src/regionFaModels/liquidFilm/subModels/kinematic/injectionModel/injectionModel/injectionModel.H Normal file
View File

@ -0,0 +1,169 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::regionModels::areaSurfaceFilmModels::injectionModel
Description
Base class for film injection models, handling mass transfer from the
film.
SourceFiles
injectionModel.C
injectionModelNew.C
\*---------------------------------------------------------------------------*/
#ifndef injectionModel_H
#define injectionModel_H
#include "filmSubModelBase.H"
#include "runTimeSelectionTables.H"
#include "scalarField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace regionModels
{
namespace areaSurfaceFilmModels
{
/*---------------------------------------------------------------------------*\
Class injectionModel Declaration
\*---------------------------------------------------------------------------*/
class injectionModel
:
public filmSubModelBase
{
// Private Data
//- Injected mass
scalar injectedMass_;
// Private Member Functions
//- No copy construct
injectionModel(const injectionModel&) = delete;
//- No copy assignment
void operator=(const injectionModel&) = delete;
protected:
// Protected Member Functions
//- Add to injected mass
void addToInjectedMass(const scalar dMass);
//- Correct
void correct();
public:
//- Runtime type information
TypeName("injectionModel");
// Declare runtime constructor selection table
declareRunTimeSelectionTable
(
autoPtr,
injectionModel,
dictionary,
(
liquidFilmBase& film,
const dictionary& dict
),
(film, dict)
);
// Constructors
//- Construct null
injectionModel(liquidFilmBase& film);
//- Construct from type name, dictionary and surface film model
injectionModel
(
const word& modelType,
liquidFilmBase& film,
const dictionary& dict
);
// Selectors
//- Return a reference to the selected injection model
static autoPtr<injectionModel> New
(
liquidFilmBase& film,
const dictionary& dict,
const word& mdoelType
);
//- Destructor
virtual ~injectionModel();
// Member Functions
//- Correct
virtual void correct
(
scalarField& availableMass,
scalarField& massToInject,
scalarField& diameterToInject
) = 0;
//- Return the total mass injected
virtual scalar injectedMassTotal() const;
//- Accumulate the total mass injected for the patches into the
//- scalarField provided
virtual void patchInjectedMassTotals(scalar& patchMasses) const
{}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace areaSurfaceFilmModels
} // End namespace regionModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

73
src/regionFaModels/liquidFilm/subModels/kinematic/injectionModel/injectionModel/injectionModelNew.C Normal file
View File

@ -0,0 +1,73 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "injectionModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace regionModels
{
namespace areaSurfaceFilmModels
{
// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
autoPtr<injectionModel> injectionModel::New
(
liquidFilmBase& model,
const dictionary& dict,
const word& modelType
)
{
Info<< " " << modelType << endl;
auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
if (!cstrIter.found())
{
FatalIOErrorInLookup
(
dict,
"injectionModel",
modelType,
*dictionaryConstructorTablePtr_
) << exit(FatalIOError);
}
return autoPtr<injectionModel>(cstrIter()(model, dict));
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace areaSurfaceFilmModels
} // End namespace regionModels
} // End namespace Foam
// ************************************************************************* //

169
src/regionFaModels/liquidFilm/subModels/kinematic/injectionModel/injectionModelList/injectionModelList.C Normal file
View File

@ -0,0 +1,169 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "injectionModelList.H"
#include "volFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace regionModels
{
namespace areaSurfaceFilmModels
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
injectionModelList::injectionModelList(liquidFilmBase& film)
:
PtrList<injectionModel>(),
filmSubModelBase(film)
{}
injectionModelList::injectionModelList
(
liquidFilmBase& film,
const dictionary& dict
)
:
PtrList<injectionModel>(),
filmSubModelBase
(
"injectionModelList",
film,
dict,
"injectionModelList",
"injectionModelList"
),
massInjected_(Zero)
{
const wordList activeModels(dict.lookup("injectionModels"));
wordHashSet models(activeModels);
Info<< " Selecting film injection models" << endl;
if (models.size())
{
this->setSize(models.size());
label i = 0;
for (const word& model : models)
{
set(i, injectionModel::New(film, dict, model));
i++;
}
}
else
{
Info<< " none" << endl;
}
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
injectionModelList::~injectionModelList()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void injectionModelList::correct
(
scalarField& availableMass,
volScalarField& massToInject,
volScalarField& diameterToInject
)
{
const label patchi = film().patchID();
// Correct models that accumulate mass and diameter transfers
forAll(*this, i)
{
injectionModel& im = operator[](i);
im.correct
(
availableMass,
massToInject.boundaryFieldRef()[patchi],
diameterToInject.boundaryFieldRef()[patchi]
);
}
massInjected_ += gSum(massToInject.boundaryField()[patchi]);
}
void injectionModelList::info(Ostream& os)
{
const polyBoundaryMesh& pbm = film().primaryMesh().boundaryMesh();
scalar injectedMass = 0;
scalar patchInjectedMasses = 0;
forAll(*this, i)
{
const injectionModel& im = operator[](i);
injectedMass += im.injectedMassTotal();
im.patchInjectedMassTotals(patchInjectedMasses);
}
os << indent << "injected mass = " << injectedMass << nl;
const label patchi = film().patchID();
if (mag(patchInjectedMasses) > VSMALL)
{
os << indent << indent << "from patch " << pbm[patchi].name()
<< " = " << patchInjectedMasses << nl;
}
scalar mass0(Zero);
this->getBaseProperty("massInjected", mass0);
scalar mass(massInjected_);
mass += mass0;
Info<< indent << " - patch: " << pbm[patchi].name() << " "
<< mass << endl;
if (film().primaryMesh().time().writeTime())
{
setBaseProperty("massInjected", mass);
massInjected_ = 0.0;
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace areaSurfaceFilmModels
} // End namespace regionModels
} // End namespace Foam
// ************************************************************************* //

127
src/regionFaModels/liquidFilm/subModels/kinematic/injectionModel/injectionModelList/injectionModelList.H Normal file
View File

@ -0,0 +1,127 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::regionModels::surfaceFilmModels::injectionModelList
Description
List container for film injection models
SourceFiles
injectionModelList.C
\*---------------------------------------------------------------------------*/
#ifndef injectionModelList_H
#define injectionModelList_H
#include "PtrList.H"
#include "injectionModel.H"
#include "filmSubModelBase.H"
#include "scalarField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace regionModels
{
namespace areaSurfaceFilmModels
{
/*---------------------------------------------------------------------------*\
Class injectionModelList Declaration
\*---------------------------------------------------------------------------*/
class injectionModelList
:
public PtrList<injectionModel>,
public filmSubModelBase
{
// Private Data
//- List of mass injected per patch
scalar massInjected_;
// Private Member Functions
//- No copy construct
injectionModelList(const injectionModelList&) = delete;
//- No copy assignment
void operator=(const injectionModelList&) = delete;
public:
// Constructors
//- Construct null
injectionModelList(liquidFilmBase& film);
//- Construct from type name, dictionary and surface film model
injectionModelList
(
liquidFilmBase& film,
const dictionary& dict
);
//- Destructor
virtual ~injectionModelList();
// Member Functions
// Evolution
//- Correct
virtual void correct
(
scalarField& availableMass,
volScalarField& massToInject,
volScalarField& diameterToInject
);
// I-O
//- Provide some info
virtual void info(Ostream& os);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace areaSurfaceFilmModels
} // End namespace regionModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //