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: Adding MPPIC sub-models to Kinematic cloud

Browse Source
This commit is contained in:
Sergio Ferraris
2020-08-28 08:32:11 -07:00
committed by Andrew Heather
parent f7dc0d8edb
commit d7b1a666b5
18 changed files with 626 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.C
View File

@ -38,6 +38,12 @@ License
#include "SurfaceFilmModel.H"
#include "profiling.H"
#include "PackingModel.H"
#include "ParticleStressModel.H"
#include "DampingModel.H"
#include "IsotropyModel.H"
#include "TimeScaleModel.H"
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
template<class CloudType>
@ -79,6 +85,33 @@ void Foam::KinematicCloud<CloudType>::setModels()
).ptr()
);
packingModel_.reset
(
PackingModel<KinematicCloud<CloudType>>::New
(
subModelProperties_,
*this
).ptr()
);
dampingModel_.reset
(
DampingModel<KinematicCloud<CloudType>>::New
(
subModelProperties_,
*this
).ptr()
);
isotropyModel_.reset
(
IsotropyModel<KinematicCloud<CloudType>>::New
(
subModelProperties_,
*this
).ptr()
);
UIntegrator_.reset
(
integrationScheme::New
@ -210,7 +243,6 @@ void Foam::KinematicCloud<CloudType>::evolveCloud
injectors_.inject(cloud, td);
// Assume that motion will update the cellOccupancy as necessary
// before it is required.
cloud.motion(cloud, td);
@ -264,6 +296,15 @@ void Foam::KinematicCloud<CloudType>::postEvolve
true
);
}
if (this->dampingModel().active())
{
this->dampingModel().cacheFields(false);
}
if (this->packingModel().active())
{
this->packingModel().cacheFields(false);
}
}
@ -285,6 +326,10 @@ void Foam::KinematicCloud<CloudType>::cloudReset(KinematicCloud<CloudType>& c)
stochasticCollisionModel_.reset(c.stochasticCollisionModel_.ptr());
surfaceFilmModel_.reset(c.surfaceFilmModel_.ptr());
packingModel_.reset(c.packingModel_.ptr());
dampingModel_.reset(c.dampingModel_.ptr());
isotropyModel_.reset(c.isotropyModel_.ptr());
UIntegrator_.reset(c.UIntegrator_.ptr());
}
@ -375,6 +420,11 @@ Foam::KinematicCloud<CloudType>::KinematicCloud
patchInteractionModel_(nullptr),
stochasticCollisionModel_(nullptr),
surfaceFilmModel_(nullptr),
packingModel_(nullptr),
dampingModel_(nullptr),
isotropyModel_(nullptr),
UIntegrator_(nullptr),
UTrans_
(
@ -458,6 +508,11 @@ Foam::KinematicCloud<CloudType>::KinematicCloud
patchInteractionModel_(c.patchInteractionModel_->clone()),
stochasticCollisionModel_(c.stochasticCollisionModel_->clone()),
surfaceFilmModel_(c.surfaceFilmModel_->clone()),
packingModel_(c.packingModel_->clone()),
dampingModel_(c.dampingModel_->clone()),
isotropyModel_(c.isotropyModel_->clone()),
UIntegrator_(c.UIntegrator_->clone()),
UTrans_
(
@ -549,6 +604,11 @@ Foam::KinematicCloud<CloudType>::KinematicCloud
patchInteractionModel_(nullptr),
stochasticCollisionModel_(nullptr),
surfaceFilmModel_(nullptr),
packingModel_(nullptr),
dampingModel_(nullptr),
isotropyModel_(nullptr),
UIntegrator_(nullptr),
UTrans_(nullptr),
UCoeff_(nullptr)
@ -687,11 +747,28 @@ void Foam::KinematicCloud<CloudType>::preEvolve
this->dispersion().cacheFields(true);
forces_.cacheFields(true);
updateCellOccupancy();
pAmbient_ = constProps_.dict().template
getOrDefault<scalar>("pAmbient", pAmbient_);
if (this->dampingModel().active() || this->packingModel().active())
{
const_cast<typename parcelType::trackingData&>(td).updateAverages(*this);
}
if (this->dampingModel().active())
{
DebugVar("dampingModel")
this->dampingModel().cacheFields(true);
}
if (this->packingModel().active())
{
DebugVar("packingModel")
this->packingModel().cacheFields(true);
}
updateCellOccupancy();
functions_.preEvolve(td);
}
@ -702,7 +779,6 @@ void Foam::KinematicCloud<CloudType>::evolve()
if (solution_.canEvolve())
{
typename parcelType::trackingData td(*this);
solve(*this, td);
}
}
@ -719,6 +795,12 @@ void Foam::KinematicCloud<CloudType>::motion
td.part() = parcelType::trackingData::tpLinearTrack;
CloudType::move(cloud, td, solution_.trackTime());
if (isotropyModel_->active())
{
td.updateAverages(cloud);
isotropyModel_->calculate();
}
updateCellOccupancy();
}
@ -749,15 +831,15 @@ void Foam::KinematicCloud<CloudType>::patchData
// just inside the domain rather than that of the wall itself.
if (U_.boundaryField()[patchi].fixesValue())
{
const vector Uw1 = U_.boundaryField()[patchi][patchFacei];
const vector Uw1(U_.boundaryField()[patchi][patchFacei]);
const vector& Uw0 =
U_.oldTime().boundaryField()[patchi][patchFacei];
const scalar f = p.currentTimeFraction();
const vector Uw = Uw0 + f*(Uw1 - Uw0);
const vector Uw(Uw0 + f*(Uw1 - Uw0));
const tensor nnw = nw*nw;
const tensor nnw(nw*nw);
Up = (nnw & Up) + Uw - (nnw & Uw);
}

55
src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.H
View File

@ -95,6 +95,15 @@ class SurfaceFilmModel;
template<class CloudType>
class StochasticCollisionModel;
template<class CloudType>
class PackingModel;
template<class CloudType>
class DampingModel;
template<class CloudType>
class IsotropyModel;
/*---------------------------------------------------------------------------*\
Class KinematicCloud Declaration
@ -129,7 +138,7 @@ public:
private:
// Private data
// Private Data
//- Cloud copy pointer
autoPtr<KinematicCloud<CloudType>> cloudCopyPtr_;
@ -146,7 +155,7 @@ private:
protected:
// Protected data
// Protected Data
//- References to the mesh and time databases
const fvMesh& mesh_;
@ -225,6 +234,18 @@ protected:
autoPtr<SurfaceFilmModel<KinematicCloud<CloudType>>>
surfaceFilmModel_;
//- Packing model
autoPtr<PackingModel<KinematicCloud<CloudType>>>
packingModel_;
//- Damping model
autoPtr<DampingModel<KinematicCloud<CloudType>>>
dampingModel_;
//- Exchange model
autoPtr<IsotropyModel<KinematicCloud<CloudType>>>
isotropyModel_;
// Reference to the particle integration schemes
@ -464,6 +485,31 @@ public:
surfaceFilm();
//- Return const access to the packing model
inline const PackingModel<KinematicCloud<CloudType>>&
packingModel() const;
//- Return a reference to the packing model
inline PackingModel<KinematicCloud<CloudType>>&
packingModel();
//- Return const access to the damping model
inline const DampingModel<KinematicCloud<CloudType>>&
dampingModel() const;
//- Return a reference to the damping model
inline DampingModel<KinematicCloud<CloudType>>&
dampingModel();
//- Return const access to the isotropy model
inline const IsotropyModel<KinematicCloud<CloudType>>&
isotropyModel() const;
//- Return a reference to the isotropy model
inline IsotropyModel<KinematicCloud<CloudType>>&
isotropyModel();
// Integration schemes
//-Return reference to velocity integration
@ -590,7 +636,10 @@ public:
void scaleSources();
//- Pre-evolve
void preEvolve(const typename parcelType::trackingData& td);
void preEvolve
(
const typename parcelType::trackingData& td
);
//- Evolve the cloud
void evolve();

48
src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloudI.H
View File

@ -255,6 +255,54 @@ Foam::KinematicCloud<CloudType>::surfaceFilm()
}
template<class CloudType>
inline const Foam::PackingModel<Foam::KinematicCloud<CloudType>>&
Foam::KinematicCloud<CloudType>::packingModel() const
{
return *packingModel_;
}
template<class CloudType>
inline Foam::PackingModel<Foam::KinematicCloud<CloudType>>&
Foam::KinematicCloud<CloudType>::packingModel()
{
return *packingModel_;
}
template<class CloudType>
inline const Foam::DampingModel<Foam::KinematicCloud<CloudType>>&
Foam::KinematicCloud<CloudType>::dampingModel() const
{
return *dampingModel_;
}
template<class CloudType>
inline Foam::DampingModel<Foam::KinematicCloud<CloudType>>&
Foam::KinematicCloud<CloudType>::dampingModel()
{
return *dampingModel_;
}
template<class CloudType>
inline const Foam::IsotropyModel<Foam::KinematicCloud<CloudType>>&
Foam::KinematicCloud<CloudType>::isotropyModel() const
{
return *isotropyModel_;
}
template<class CloudType>
inline Foam::IsotropyModel<Foam::KinematicCloud<CloudType>>&
Foam::KinematicCloud<CloudType>::isotropyModel()
{
return *isotropyModel_;
}
template<class CloudType>
inline const Foam::integrationScheme&
Foam::KinematicCloud<CloudType>::UIntegrator() const

35
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcel.C
View File

@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2017 OpenFOAM Foundation
Copyright (C) 2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -90,6 +91,28 @@ void Foam::KinematicParcel<ParcelType>::calcDispersion
}
template<class ParcelType>
template<class TrackCloudType>
void Foam::KinematicParcel<ParcelType>::calcUCorrection
(
TrackCloudType& cloud,
trackingData& td,
const scalar dt
)
{
typename TrackCloudType::parcelType& p =
static_cast<typename TrackCloudType::parcelType&>(*this);
this->UCorrect_ = Zero;
this->UCorrect_ =
cloud.dampingModel().velocityCorrection(p, dt);
this->UCorrect_ +=
cloud.packingModel().velocityCorrection(p, dt);
}
template<class ParcelType>
template<class TrackCloudType>
void Foam::KinematicParcel<ParcelType>::cellValueSourceCorrection
@ -141,6 +164,7 @@ void Foam::KinematicParcel<ParcelType>::calc
this->U_ =
calcVelocity(cloud, td, dt, Re, td.muc(), mass0, Su, dUTrans, Spu);
this->U_ += this->UCorrect_;
// Accumulate carrier phase source terms
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -249,7 +273,8 @@ Foam::KinematicParcel<ParcelType>::KinematicParcel
rho_(p.rho_),
age_(p.age_),
tTurb_(p.tTurb_),
UTurb_(p.UTurb_)
UTurb_(p.UTurb_),
UCorrect_(p.UCorrect_)
{}
@ -270,7 +295,8 @@ Foam::KinematicParcel<ParcelType>::KinematicParcel
rho_(p.rho_),
age_(p.age_),
tTurb_(p.tTurb_),
UTurb_(p.UTurb_)
UTurb_(p.UTurb_),
UCorrect_(p.UCorrect_)
{}
@ -335,6 +361,7 @@ bool Foam::KinematicParcel<ParcelType>::move
const scalar dt = (p.stepFraction() - sfrac)*trackTime;
// Avoid problems with extremely small timesteps
if (dt > ROOTVSMALL)
{
@ -348,6 +375,8 @@ bool Foam::KinematicParcel<ParcelType>::move
p.cellValueSourceCorrection(cloud, ttd, dt);
}
p.calcUCorrection(cloud, ttd, dt);
p.calc(cloud, ttd, dt);
}
@ -362,7 +391,7 @@ bool Foam::KinematicParcel<ParcelType>::move
if (p.active() && p.onFace() && ttd.keepParticle)
{
p.hitFace(s, cloud, ttd);
p.hitFace(f*s - d, cloud, ttd);
}
}

72
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcel.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2017 OpenFOAM Foundation
Copyright (C) 2016-2019 OpenCFD Ltd.
Copyright (C) 2016-2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -55,8 +55,8 @@ SourceFiles
#include "autoPtr.H"
#include "interpolation.H"
#include "demandDrivenEntry.H"
// #include "ParticleForceList.H" // TODO
#include "labelFieldIOField.H"
#include "vectorFieldIOField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -66,6 +66,9 @@ namespace Foam
template<class ParcelType>
class KinematicParcel;
template<class Type>
class AveragingMethod;
// Forward declaration of friend functions
template<class ParcelType>
@ -84,11 +87,12 @@ class KinematicParcel
:
public ParcelType
{
// Private data
// Private Data
//- Number of particle tracking attempts before we assume that it stalls
static label maxTrackAttempts;
public:
//- Size in bytes of the fields
@ -100,7 +104,7 @@ public:
{
protected:
// Protected data
// Protected Data
//- Constant properties dictionary
const dictionary dict_;
@ -108,7 +112,7 @@ public:
private:
// Private data
// Private Data
//- Parcel type id - used for post-processing to flag the type
//- of parcels issued by this cloud
@ -138,7 +142,7 @@ public:
constantProperties(const dictionary& parentDict);
// Member functions
// Member Functions
//- Return const access to the constant properties dictionary
inline const dictionary& dict() const;
@ -173,7 +177,7 @@ public:
private:
// Private data
// Private Data
// Interpolators for continuous phase fields
@ -199,6 +203,30 @@ public:
scalar muc_;
// MPPIC Averages
//- Volume average
autoPtr<AveragingMethod<scalar>> volumeAverage_;
//- Radius average [ volume^(1/3) ]
autoPtr<AveragingMethod<scalar>> radiusAverage_;
//- Density average
autoPtr<AveragingMethod<scalar>> rhoAverage_;
//- Velocity average
autoPtr<AveragingMethod<vector>> uAverage_;
//- Magnitude velocity squared average
autoPtr<AveragingMethod<scalar>> uSqrAverage_;
//- Frequency average
autoPtr<AveragingMethod<scalar>> frequencyAverage_;
//- Mass average
autoPtr<AveragingMethod<scalar>> massAverage_;
//- Local gravitational or other body-force acceleration
const vector& g_;
@ -220,7 +248,7 @@ public:
);
// Member functions
// Member Functions
//- Return const access to the interpolator for continuous
//- phase density field
@ -260,12 +288,17 @@ public:
//- Return access to the part of the tracking operation taking place
inline trackPart& part();
//- Update the MPPIC averages
template<class TrackCloudType>
inline void updateAverages(const TrackCloudType& cloud);
};
protected:
// Protected data
// Protected Data
// Parcel properties
@ -300,6 +333,9 @@ protected:
//- Turbulent velocity fluctuation [m/s]
vector UTurb_;
//- Velocity correction due to collisions MPPIC [m/s]
vector UCorrect_;
// Protected Member Functions
@ -340,6 +376,7 @@ public:
+ " age"
+ " tTurb"
+ " (UTurbx UTurby UTurbz)"
+ " (UCorrectx UCorrecty UCorrectz)"
);
@ -465,6 +502,9 @@ public:
//- Return const access to turbulent velocity fluctuation
inline const vector& UTurb() const;
//- Return const access to correction velocity
inline const vector& UCorrect() const;
// Edit
@ -498,6 +538,9 @@ public:
//- Return access to turbulent velocity fluctuation
inline vector& UTurb();
//- Return access to correction velocity
inline vector& UCorrect();
// Helper functions
@ -611,6 +654,15 @@ public:
const scalar dt
);
//- Correct U following MP-PIC sub-models
template<class TrackCloudType>
void calcUCorrection
(
TrackCloudType& cloud,
trackingData& td,
const scalar dt
);
// Tracking

16
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcelI.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2017 OpenFOAM Foundation
Copyright (C) 2016 OpenCFD Ltd.
Copyright (C) 2016-2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -304,6 +304,20 @@ inline Foam::vector& Foam::KinematicParcel<ParcelType>::U()
}
template<class ParcelType>
inline const Foam::vector& Foam::KinematicParcel<ParcelType>::UCorrect() const
{
return UCorrect_;
}
template<class ParcelType>
inline Foam::vector& Foam::KinematicParcel<ParcelType>::UCorrect()
{
return UCorrect_;
}
template<class ParcelType>
inline Foam::scalar& Foam::KinematicParcel<ParcelType>::rho()
{

28
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcelIO.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2017 OpenFOAM Foundation
Copyright (C) 2016-2019 OpenCFD Ltd.
Copyright (C) 2016-2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -67,7 +67,8 @@ Foam::KinematicParcel<ParcelType>::KinematicParcel
rho_(0.0),
age_(0.0),
tTurb_(0.0),
UTurb_(Zero)
UTurb_(Zero),
UCorrect_(Zero)
{
if (readFields)
{
@ -82,7 +83,8 @@ Foam::KinematicParcel<ParcelType>::KinematicParcel
>> rho_
>> age_
>> tTurb_
>> UTurb_;
>> UTurb_
>> UCorrect_;
}
else if (!is.checkLabelSize<>() || !is.checkScalarSize<>())
{
@ -100,6 +102,7 @@ Foam::KinematicParcel<ParcelType>::KinematicParcel
readRawScalar(is, &age_);
readRawScalar(is, &tTurb_);
readRawScalar(is, UTurb_.data(), vector::nComponents);
readRawScalar(is, UCorrect_.data(), vector::nComponents);
is.endRawRead();
}
@ -191,6 +194,13 @@ void Foam::KinematicParcel<ParcelType>::readFields(CloudType& c)
);
c.checkFieldIOobject(c, UTurb);
IOField<vector> UCorrect
(
c.fieldIOobject("UCorrect", IOobject::MUST_READ),
valid
);
c.checkFieldIOobject(c, UCorrect);
label i = 0;
for (KinematicParcel<ParcelType>& p : c)
@ -205,6 +215,7 @@ void Foam::KinematicParcel<ParcelType>::readFields(CloudType& c)
p.age_ = age[i];
p.tTurb_ = tTurb[i];
p.UTurb_ = UTurb[i];
p.UCorrect_ = UCorrect[i];
++i;
}
@ -234,6 +245,7 @@ void Foam::KinematicParcel<ParcelType>::writeFields(const CloudType& c)
IOField<scalar> age(c.fieldIOobject("age", IOobject::NO_READ), np);
IOField<scalar> tTurb(c.fieldIOobject("tTurb", IOobject::NO_READ), np);
IOField<vector> UTurb(c.fieldIOobject("UTurb", IOobject::NO_READ), np);
IOField<vector> UCorrect(c.fieldIOobject("UCorrect", IOobject::NO_READ), np);
label i = 0;
@ -249,6 +261,7 @@ void Foam::KinematicParcel<ParcelType>::writeFields(const CloudType& c)
age[i] = p.age();
tTurb[i] = p.tTurb();
UTurb[i] = p.UTurb();
UCorrect[i] = p.UCorrect();
++i;
}
@ -263,6 +276,7 @@ void Foam::KinematicParcel<ParcelType>::writeFields(const CloudType& c)
age.write(valid);
tTurb.write(valid);
UTurb.write(valid);
UCorrect.write(valid);
}
@ -291,6 +305,7 @@ void Foam::KinematicParcel<ParcelType>::writeProperties
writeProp("age", age_);
writeProp("tTurb", tTurb_);
writeProp("UTurb", UTurb_);
writeProp("UCorrect", UCorrect_);
#undef writeProp
}
@ -318,6 +333,7 @@ void Foam::KinematicParcel<ParcelType>::readObjects
const auto& age = cloud::lookupIOField<scalar>("age", obr);
const auto& tTurb = cloud::lookupIOField<scalar>("tTurb", obr);
const auto& UTurb = cloud::lookupIOField<vector>("UTurb", obr);
const auto& UCorrect = cloud::lookupIOField<vector>("UCorrect", obr);
label i = 0;
@ -333,6 +349,7 @@ void Foam::KinematicParcel<ParcelType>::readObjects
p.age_ = age[i];
p.tTurb_ = tTurb[i];
p.UTurb_ = UTurb[i];
p.UCorrect_ = UCorrect[i];
++i;
}
@ -361,6 +378,7 @@ void Foam::KinematicParcel<ParcelType>::writeObjects
auto& age = cloud::createIOField<scalar>("age", np, obr);
auto& tTurb = cloud::createIOField<scalar>("tTurb", np, obr);
auto&& UTurb = cloud::createIOField<vector>("UTurb", np, obr);
auto&& UCorrect = cloud::createIOField<vector>("UCorrect", np, obr);
label i = 0;
@ -376,6 +394,7 @@ void Foam::KinematicParcel<ParcelType>::writeObjects
age[i] = p.age();
tTurb[i] = p.tTurb();
UTurb[i] = p.UTurb();
UCorrect[i] = p.UCorrect();
++i;
}
@ -403,7 +422,8 @@ Foam::Ostream& Foam::operator<<
<< token::SPACE << p.rho()
<< token::SPACE << p.age()
<< token::SPACE << p.tTurb()
<< token::SPACE << p.UTurb();
<< token::SPACE << p.UTurb()
<< token::SPACE << p.UCorrect();
}
else
{

208
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcelTrackingDataI.H
View File

@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2017 OpenFOAM Foundation
Copyright (C) 2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -25,6 +26,10 @@ License
\*---------------------------------------------------------------------------*/
#include "AveragingMethod.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class ParcelType>
template<class TrackCloudType>
inline Foam::KinematicParcel<ParcelType>::trackingData::trackingData
@ -61,6 +66,106 @@ inline Foam::KinematicParcel<ParcelType>::trackingData::trackingData
rhoc_(Zero),
Uc_(Zero),
muc_(Zero),
volumeAverage_
(
AveragingMethod<scalar>::New
(
IOobject
(
cloud.name() + ":volumeAverage",
cloud.db().time().timeName(),
cloud.mesh()
),
cloud.solution().dict(),
cloud.mesh()
)
),
radiusAverage_
(
AveragingMethod<scalar>::New
(
IOobject
(
cloud.name() + ":radiusAverage",
cloud.db().time().timeName(),
cloud.mesh()
),
cloud.solution().dict(),
cloud.mesh()
)
),
rhoAverage_
(
AveragingMethod<scalar>::New
(
IOobject
(
cloud.name() + ":rhoAverage",
cloud.db().time().timeName(),
cloud.mesh()
),
cloud.solution().dict(),
cloud.mesh()
)
),
uAverage_
(
AveragingMethod<vector>::New
(
IOobject
(
cloud.name() + ":uAverage",
cloud.db().time().timeName(),
cloud.mesh()
),
cloud.solution().dict(),
cloud.mesh()
)
),
uSqrAverage_
(
AveragingMethod<scalar>::New
(
IOobject
(
cloud.name() + ":uSqrAverage",
cloud.db().time().timeName(),
cloud.mesh()
),
cloud.solution().dict(),
cloud.mesh()
)
),
frequencyAverage_
(
AveragingMethod<scalar>::New
(
IOobject
(
cloud.name() + ":frequencyAverage",
cloud.db().time().timeName(),
cloud.mesh()
),
cloud.solution().dict(),
cloud.mesh()
)
),
massAverage_
(
AveragingMethod<scalar>::New
(
IOobject
(
cloud.name() + ":massAverage",
cloud.db().time().timeName(),
cloud.mesh()
),
cloud.solution().dict(),
cloud.mesh()
)
),
g_(cloud.g().value()),
part_(part)
{}
@ -158,4 +263,107 @@ Foam::KinematicParcel<ParcelType>::trackingData::part()
}
template<class ParcelType>
template<class TrackCloudType>
inline void Foam::KinematicParcel<ParcelType>::trackingData::
updateAverages
(
const TrackCloudType& cloud
)
{
// zero the sums
volumeAverage_() = 0;
radiusAverage_() = 0;
rhoAverage_() = 0;
uAverage_() = Zero;
uSqrAverage_() = 0;
frequencyAverage_() = 0;
massAverage_() = 0;
// temporary weights
autoPtr<AveragingMethod<scalar>> weightAveragePtr
(
AveragingMethod<scalar>::New
(
IOobject
(
cloud.name() + ":weightAverage",
cloud.db().time().timeName(),
cloud.mesh()
),
cloud.solution().dict(),
cloud.mesh()
)
);
AveragingMethod<scalar>& weightAverage = weightAveragePtr();
// averaging sums
for (const typename TrackCloudType::parcelType& p : cloud)
{
const tetIndices tetIs = p.currentTetIndices();
const scalar m = p.nParticle()*p.mass();
volumeAverage_->add(p.coordinates(), tetIs, p.nParticle()*p.volume());
rhoAverage_->add(p.coordinates(), tetIs, m*p.rho());
uAverage_->add(p.coordinates(), tetIs, m*p.U());
massAverage_->add(p.coordinates(), tetIs, m);
}
volumeAverage_->average();
massAverage_->average();
rhoAverage_->average(*massAverage_);
uAverage_->average(*massAverage_);
// squared velocity deviation
for (const typename TrackCloudType::parcelType& p : cloud)
{
const tetIndices tetIs = p.currentTetIndices();
const vector u = uAverage_->interpolate(p.coordinates(), tetIs);
uSqrAverage_->add
(
p.coordinates(),
tetIs,
p.nParticle()*p.mass()*magSqr(p.U() - u)
);
}
uSqrAverage_->average(*massAverage_);
// sauter mean radius
radiusAverage_() = volumeAverage_();
weightAverage = 0;
for (const typename TrackCloudType::parcelType& p : cloud)
{
const tetIndices tetIs = p.currentTetIndices();
weightAverage.add
(
p.coordinates(),
tetIs,
p.nParticle()*pow(p.volume(), 2.0/3.0)
);
}
weightAverage.average();
radiusAverage_->average(weightAverage);
// collision frequency
weightAverage = 0;
for (const typename TrackCloudType::parcelType& p : cloud)
{
const tetIndices tetIs = p.currentTetIndices();
const scalar a = volumeAverage_->interpolate(p.coordinates(), tetIs);
const scalar r = radiusAverage_->interpolate(p.coordinates(), tetIs);
const vector u = uAverage_->interpolate(p.coordinates(), tetIs);
const scalar f = 0.75*a/pow3(r)*sqr(0.5*p.d() + r)*mag(p.U() - u);
frequencyAverage_->add(p.coordinates(), tetIs, p.nParticle()*f*f);
weightAverage.add(p.coordinates(), tetIs, p.nParticle()*f);
}
frequencyAverage_->average(weightAverage);
}
// ************************************************************************* //

12
src/lagrangian/intermediate/parcels/derived/basicHeterogeneousReactingParcel/makeBasicHeterogeneousReactingParcelSubmodels.C
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2018 OpenCFD Ltd.
Copyright (C) 2018-2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -45,6 +45,11 @@ License
#include "makeReactingMultiphaseParcelCompositionModels.H"
#include "makeReactingParcelPhaseChangeModels.H"
// MPPIC sub-models
#include "makeMPPICParcelDampingModels.H"
#include "makeMPPICParcelIsotropyModels.H"
#include "makeMPPICParcelPackingModels.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeParcelCloudFunctionObjects(basicHeterogeneousReactingCloud);
@ -68,4 +73,9 @@ makeHeterogeneousReactingParcelHeterogeneousReactingModels
basicHeterogeneousReactingCloud
);
// MPPIC sub-models
makeMPPICParcelDampingModels(basicHeterogeneousReactingCloud);
makeMPPICParcelIsotropyModels(basicHeterogeneousReactingCloud);
makeMPPICParcelPackingModels(basicHeterogeneousReactingCloud);
// ************************************************************************* //

10
src/lagrangian/intermediate/parcels/derived/basicKinematicCollidingParcel/makeBasicKinematicCollidingParcelSubmodels.C
View File

@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2015 OpenFOAM Foundation
Copyright (C) 2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -38,6 +39,11 @@ License
#include "makeParcelStochasticCollisionModels.H"
#include "makeParcelSurfaceFilmModels.H"
// MPPIC sub-models
#include "makeMPPICParcelDampingModels.H"
#include "makeMPPICParcelIsotropyModels.H"
#include "makeMPPICParcelPackingModels.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeParcelCloudFunctionObjects(basicKinematicCollidingCloud);
@ -51,5 +57,9 @@ makeParcelPatchInteractionModels(basicKinematicCollidingCloud);
makeParcelStochasticCollisionModels(basicKinematicCollidingCloud);
makeParcelSurfaceFilmModels(basicKinematicCollidingCloud);
// MPPIC sub-models
makeMPPICParcelDampingModels(basicKinematicCollidingCloud);
makeMPPICParcelIsotropyModels(basicKinematicCollidingCloud);
makeMPPICParcelPackingModels(basicKinematicCollidingCloud);
// ************************************************************************* //

7
src/lagrangian/intermediate/parcels/derived/basicKinematicMPPICParcel/makeBasicKinematicMPPICParcelSubmodels.C
View File

@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2013-2015 OpenFOAM Foundation
Copyright (C) 2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -56,9 +57,15 @@ makeParcelStochasticCollisionModels(basicKinematicMPPICCloud);
makeParcelSurfaceFilmModels(basicKinematicMPPICCloud);
// MPPIC sub-models
// WIP: These models are defined in Kinematic and MPPIC clouds temporarily
makeMPPICParcelDampingModels(basicKinematicMPPICCloud);
makeMPPICCloudParcelDampingModels(basicKinematicMPPICCloud);
makeMPPICParcelIsotropyModels(basicKinematicMPPICCloud);
makeMPPICCloudParcelIsotropyModels(basicKinematicMPPICCloud);
makeMPPICParcelPackingModels(basicKinematicMPPICCloud);
makeMPPICCloudParcelPackingModels(basicKinematicMPPICCloud);
// ************************************************************************* //

11
src/lagrangian/intermediate/parcels/derived/basicKinematicParcel/makeBasicKinematicParcelSubmodels.C
View File

@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2015 OpenFOAM Foundation
Copyright (C) 2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -37,6 +38,11 @@ License
#include "makeParcelStochasticCollisionModels.H"
#include "makeParcelSurfaceFilmModels.H"
// MPPIC sub-models
#include "makeMPPICParcelDampingModels.H"
#include "makeMPPICParcelIsotropyModels.H"
#include "makeMPPICParcelPackingModels.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeParcelCloudFunctionObjects(basicKinematicCloud);
@ -49,5 +55,10 @@ makeParcelPatchInteractionModels(basicKinematicCloud);
makeParcelStochasticCollisionModels(basicKinematicCloud);
makeParcelSurfaceFilmModels(basicKinematicCloud);
// MPPIC sub-models
makeMPPICParcelDampingModels(basicKinematicCloud);
makeMPPICParcelIsotropyModels(basicKinematicCloud);
makeMPPICParcelPackingModels(basicKinematicCloud);
// ************************************************************************* //

9
src/lagrangian/intermediate/parcels/derived/basicReactingMultiphaseParcel/makeBasicReactingMultiphaseParcelSubmodels.C
View File

@ -49,6 +49,11 @@ License
#include "makeReactingMultiphaseParcelDevolatilisationModels.H"
#include "makeReactingMultiphaseParcelSurfaceReactionModels.H"
// MPPIC sub-models
#include "makeMPPICParcelDampingModels.H"
#include "makeMPPICParcelIsotropyModels.H"
#include "makeMPPICParcelPackingModels.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeParcelCloudFunctionObjects(basicReactingMultiphaseCloud);
@ -84,5 +89,9 @@ makeReactingMultiphaseParcelSurfaceReactionModels
basicReactingMultiphaseCloud
);
// MPPIC sub-models
makeMPPICParcelDampingModels(basicReactingMultiphaseCloud);
makeMPPICParcelIsotropyModels(basicReactingMultiphaseCloud);
makeMPPICParcelPackingModels(basicReactingMultiphaseCloud);
// ************************************************************************* //

10
src/lagrangian/intermediate/parcels/derived/basicReactingParcel/makeBasicReactingParcelSubmodels.C
View File

@ -45,6 +45,11 @@ License
#include "makeReactingParcelCompositionModels.H"
#include "makeReactingParcelPhaseChangeModels.H"
// MPPIC sub-models
#include "makeMPPICParcelDampingModels.H"
#include "makeMPPICParcelIsotropyModels.H"
#include "makeMPPICParcelPackingModels.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeParcelCloudFunctionObjects(basicReactingCloud);
@ -64,5 +69,10 @@ makeParcelHeatTransferModels(basicReactingCloud);
makeReactingParcelCompositionModels(basicReactingCloud);
makeReactingParcelPhaseChangeModels(basicReactingCloud);
// MPPIC sub-models
makeMPPICParcelDampingModels(basicReactingCloud);
makeMPPICParcelIsotropyModels(basicReactingCloud);
makeMPPICParcelPackingModels(basicReactingCloud);
// ************************************************************************* //

12
src/lagrangian/intermediate/parcels/derived/basicThermoParcel/makeBasicThermoParcelSubmodels.C
View File

@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2015 OpenFOAM Foundation
Copyright (C) 2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -40,6 +41,11 @@ License
// Thermodynamic
#include "makeParcelHeatTransferModels.H"
// MPPIC sub-models
#include "makeMPPICParcelDampingModels.H"
#include "makeMPPICParcelIsotropyModels.H"
#include "makeMPPICParcelPackingModels.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeParcelCloudFunctionObjects(basicThermoCloud);
@ -56,4 +62,10 @@ makeParcelSurfaceFilmModels(basicThermoCloud);
makeParcelHeatTransferModels(basicThermoCloud);
// MPPIC sub-models
makeMPPICParcelDampingModels(basicThermoCloud);
makeMPPICParcelIsotropyModels(basicThermoCloud);
makeMPPICParcelPackingModels(basicThermoCloud);
// ************************************************************************* //

8
src/lagrangian/intermediate/parcels/include/makeMPPICParcelDampingModels.H
View File

@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2013-2016 OpenFOAM Foundation
Copyright (C) 2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -44,6 +45,13 @@ License
makeDampingModelType(Relaxation, CloudType);
#define makeMPPICCloudParcelDampingModels(CloudType) \
\
makeDampingModelMPPIC(CloudType); \
\
makeDampingModelTypeMPPIC(NoDamping, CloudType); \
makeDampingModelTypeMPPIC(Relaxation, CloudType);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif

8
src/lagrangian/intermediate/parcels/include/makeMPPICParcelIsotropyModels.H
View File

@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2013-2016 OpenFOAM Foundation
Copyright (C) 2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -43,6 +44,13 @@ License
makeIsotropyModelType(Stochastic, CloudType);
#define makeMPPICCloudParcelIsotropyModels(CloudType) \
\
makeIsotropyModelMPPIC(CloudType); \
\
makeIsotropyModelTypeMPPIC(NoIsotropy, CloudType); \
makeIsotropyModelTypeMPPIC(Stochastic, CloudType);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif

10
src/lagrangian/intermediate/parcels/include/makeMPPICParcelPackingModels.H
View File

@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2013-2016 OpenFOAM Foundation
Copyright (C) 2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -44,6 +45,15 @@ License
makePackingModelType(Explicit, CloudType); \
makePackingModelType(Implicit, CloudType);
#define makeMPPICCloudParcelPackingModels(CloudType) \
\
makePackingModelMPPIC(CloudType); \
\
makePackingModelTypeMPPIC(NoPacking, CloudType); \
makePackingModelTypeMPPIC(Explicit, CloudType); \
makePackingModelTypeMPPIC(Implicit, CloudType);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif