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

Merge branch 'feature-lagrangian-additions' into 'develop'

Browse Source 
Lagrangian modelling updates/new features

See merge request Development/openfoam!521
This commit is contained in:
Andrew Heather
2021-12-15 10:46:57 +00:00
parent 0e7920efc3 c4cc33b748
commit ae708e67b5
41 changed files with 2259 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/lagrangian/intermediate/parcels/include/makeParcelCloudFunctionObjects.H
View File

@ -31,6 +31,7 @@ License
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "FaceInteraction.H"
#include "FacePostProcessing.H" #include "FacePostProcessing.H"
#include "ParticleCollector.H" #include "ParticleCollector.H"
#include "ParticleErosion.H" #include "ParticleErosion.H"
@ -50,6 +51,7 @@ License
\ \
makeCloudFunctionObject(CloudType); \ makeCloudFunctionObject(CloudType); \
\ \
makeCloudFunctionObjectType(FaceInteraction, CloudType); \
makeCloudFunctionObjectType(FacePostProcessing, CloudType); \ makeCloudFunctionObjectType(FacePostProcessing, CloudType); \
makeCloudFunctionObjectType(ParticleCollector, CloudType); \ makeCloudFunctionObjectType(ParticleCollector, CloudType); \
makeCloudFunctionObjectType(ParticleErosion, CloudType); \ makeCloudFunctionObjectType(ParticleErosion, CloudType); \

2
src/lagrangian/intermediate/parcels/include/makeReactingParcelCloudFunctionObjects.H
View File

@ -31,6 +31,7 @@ License
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "FaceInteraction.H"
#include "FacePostProcessing.H" #include "FacePostProcessing.H"
#include "ParticleCollector.H" #include "ParticleCollector.H"
#include "ParticleErosion.H" #include "ParticleErosion.H"
@ -53,6 +54,7 @@ License
\ \
makeCloudFunctionObject(CloudType); \ makeCloudFunctionObject(CloudType); \
\ \
makeCloudFunctionObjectType(FaceInteraction, CloudType); \
makeCloudFunctionObjectType(FacePostProcessing, CloudType); \ makeCloudFunctionObjectType(FacePostProcessing, CloudType); \
makeCloudFunctionObjectType(ParticleCollector, CloudType); \ makeCloudFunctionObjectType(ParticleCollector, CloudType); \
makeCloudFunctionObjectType(ParticleErosion, CloudType); \ makeCloudFunctionObjectType(ParticleErosion, CloudType); \

2
src/lagrangian/intermediate/parcels/include/makeThermoParcelCloudFunctionObjects.H
View File

@ -30,6 +30,7 @@ License
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "FaceInteraction.H"
#include "FacePostProcessing.H" #include "FacePostProcessing.H"
#include "ParticleCollector.H" #include "ParticleCollector.H"
#include "ParticleErosion.H" #include "ParticleErosion.H"
@ -51,6 +52,7 @@ License
\ \
makeCloudFunctionObject(CloudType); \ makeCloudFunctionObject(CloudType); \
\ \
makeCloudFunctionObjectType(FaceInteraction, CloudType); \
makeCloudFunctionObjectType(FacePostProcessing, CloudType); \ makeCloudFunctionObjectType(FacePostProcessing, CloudType); \
makeCloudFunctionObjectType(ParticleCollector, CloudType); \ makeCloudFunctionObjectType(ParticleCollector, CloudType); \
makeCloudFunctionObjectType(ParticleErosion, CloudType); \ makeCloudFunctionObjectType(ParticleErosion, CloudType); \

329
src/lagrangian/intermediate/submodels/CloudFunctionObjects/FaceInteraction/FaceInteraction.C Normal file
View File

@ -0,0 +1,329 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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 "FaceInteraction.H"
#include "faceZoneMesh.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
template<class CloudType>
const Foam::Enum<typename Foam::FaceInteraction<CloudType>::interactionType>
Foam::FaceInteraction<CloudType>::interactionTypeNames_
({
{ interactionType::STICK, "stick" },
{ interactionType::ESCAPE, "escape" },
{ interactionType::REBOUND, "rebound" },
});
// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
template<class CloudType>
bool Foam::FaceInteraction<CloudType>::processParticle
(
const parcelType& p,
const label localZonei
)
{
if (!faceZoneBBs_[localZonei].contains(p.position()))
{
// Quick reject if the particle is not in the face zone bound box
return false;
}
if ((p.d() > dMax_) || (p.d() < dMin_))
{
return false;
}
return true;
}
template<class CloudType>
void Foam::FaceInteraction<CloudType>::write()
{
const fvMesh& mesh = this->owner().mesh();
const faceZoneMesh& fzm = mesh.faceZones();
Info<< type() << " output:" << nl;
// Retrieve any stored data
const label nZones = faceZoneIDs_.size();
labelList npe0(nZones, Zero);
labelList nps0(nZones, Zero);
labelList npr0(nZones, Zero);
this->getModelProperty("nEscape", npe0);
this->getModelProperty("nStick", nps0);
this->getModelProperty("nRebound", npr0);
// Accumulate current data
labelList npe(returnReduce(nEscapeParticles_, sumOp<labelList>()));
labelList nps(returnReduce(nStickParticles_, sumOp<labelList>()));
labelList npr(returnReduce(nReboundParticles_, sumOp<labelList>()));
forAll(npe, i)
{
npe[i] = npe[i] + npe0[i];
nps[i] = nps[i] + nps0[i];
npr[i] = npr[i] + npr0[i];
}
// Write to log/file
forAll(faceZoneIDs_, i)
{
const label zonei = faceZoneIDs_[i];
Info<< " Zone : " << fzm[zonei].name() << nl
<< " Escape : " << npe[i] << nl
<< " Stick : " << nps[i] << nl
<< " Rebound : " << npr[i] << nl;
if (this->writeToFile())
{
auto& os = filePtrs_[i];
writeCurrentTime(os);
// Note - writing as scalar for better formatting
os << tab << scalar(npe[i])
<< tab << scalar(nps[i])
<< tab << scalar(npr[i])
<< endl;
}
}
Info<< endl;
// Set restart data
this->setModelProperty("nEscape", npe);
this->setModelProperty("nStick", nps);
this->setModelProperty("nRebound", npr);
nEscapeParticles_ = Zero;
nStickParticles_ = Zero;
nReboundParticles_ = Zero;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CloudType>
Foam::FaceInteraction<CloudType>::FaceInteraction
(
const dictionary& dict,
CloudType& owner,
const word& modelName
)
:
CloudFunctionObject<CloudType>(dict, owner, modelName, typeName),
functionObjects::writeFile
(
owner,
this->localPath(),
typeName,
this->coeffDict()
),
faceZoneIDs_(),
faceZoneBBs_(),
faceZoneInteraction_(),
filePtrs_(),
nEscapeParticles_(),
nStickParticles_(),
nReboundParticles_(),
dMin_(this->coeffDict().getOrDefault("dMin", -GREAT)),
dMax_(this->coeffDict().getOrDefault("dMax", GREAT))
{
const List<Tuple2<word, word>> nameAndInteraction
(
this->coeffDict().lookup("faceZones")
);
filePtrs_.setSize(nameAndInteraction.size());
faceZoneBBs_.setSize(nameAndInteraction.size());
faceZoneInteraction_.setSize(nameAndInteraction.size());
DynamicList<label> zoneIDs;
const faceZoneMesh& fzm = owner.mesh().faceZones();
const auto& faces = this->owner().mesh().faces();
const auto& points = this->owner().mesh().points();
label nZone = 0;
for (const auto& zoneInfo : nameAndInteraction)
{
const word& zoneName = zoneInfo.first();
const label zonei = fzm.findZoneID(zoneName);
if (zonei != -1)
{
zoneIDs.append(zonei);
const faceZone& fz = fzm[zonei];
const label nFaces = returnReduce(fz.size(), sumOp<label>());
Info<< " " << zoneName << " faces: " << nFaces << nl;
// Cache the particle action for this faceZone
faceZoneInteraction_[nZone] =
interactionTypeNames_[zoneInfo.second()];
// Cache faceZone bound box
auto& bb = faceZoneBBs_[nZone];
for (const label facei : fz)
{
for (const label fpi : faces[facei])
{
bb.add(points[fpi]);
}
}
reduce(bb.min(), minOp<point>());
reduce(bb.max(), maxOp<point>());
bb.inflate(0.05);
// Create output file for zone
if (this->writeToFile())
{
filePtrs_.set
(
nZone,
this->createFile(modelName + '_' + zoneName)
);
writeHeaderValue(filePtrs_[nZone], "Source", type());
writeHeaderValue(filePtrs_[nZone], "Face zone", zoneName);
writeHeaderValue(filePtrs_[nZone], "Faces", nFaces);
writeCommented(filePtrs_[nZone], "Time");
writeTabbed(filePtrs_[nZone], "Escape");
writeTabbed(filePtrs_[nZone], "Stick");
writeTabbed(filePtrs_[nZone], "Rebound");
filePtrs_[nZone] << nl;
}
++nZone;
}
else
{
WarningInFunction
<< "Unable to find faceZone " << zoneName
<< " - removing" << endl;
}
}
faceZoneIDs_.transfer(zoneIDs);
filePtrs_.setSize(nZone);
faceZoneBBs_.setSize(nZone);
faceZoneInteraction_.setSize(nZone);
nEscapeParticles_.setSize(nZone, Zero);
nStickParticles_.setSize(nZone, Zero);
nReboundParticles_.setSize(nZone, Zero);
}
template<class CloudType>
Foam::FaceInteraction<CloudType>::FaceInteraction
(
const FaceInteraction<CloudType>& pfi
)
:
CloudFunctionObject<CloudType>(pfi),
functionObjects::writeFile(pfi),
faceZoneIDs_(pfi.faceZoneIDs_),
faceZoneBBs_(pfi.faceZoneBBs_),
filePtrs_(),
nEscapeParticles_(pfi.nEscapeParticles_),
nStickParticles_(pfi.nStickParticles_),
nReboundParticles_(pfi.nReboundParticles_),
dMin_(pfi.dMin_),
dMax_(pfi.dMax_)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class CloudType>
void Foam::FaceInteraction<CloudType>::postFace
(
const parcelType& p,
bool& keepParticle
)
{
const auto& fzm = this->owner().mesh().faceZones();
forAll(faceZoneIDs_, i)
{
if (!processParticle(p, i))
{
continue;
}
const label zonei = faceZoneIDs_[i];
const label localFacei = fzm[zonei].find(p.face());
if (localFacei != -1)
{
const label facei = fzm[zonei][localFacei];
switch (faceZoneInteraction_[i])
{
case interactionType::ESCAPE:
{
keepParticle = false;
++nEscapeParticles_[i];
break;
}
case interactionType::STICK:
{
auto& pRef = const_cast<parcelType&>(p);
pRef.active(false);
pRef.U() = Zero;
++nStickParticles_[i];
break;
}
case interactionType::REBOUND:
{
const face& f = this->owner().mesh().faces()[facei];
const auto n = f.unitNormal(this->owner().mesh().points());
auto& pRef = const_cast<parcelType&>(p);
pRef.U() -= 2*n*(pRef.U() & n);
++nReboundParticles_[i];
break;
}
default:
{
FatalErrorInFunction
<< "Unhandled enumeration "
<< interactionTypeNames_[faceZoneInteraction_[i]]
<< abort(FatalError);
}
}
}
}
}
// ************************************************************************* //

203
src/lagrangian/intermediate/submodels/CloudFunctionObjects/FaceInteraction/FaceInteraction.H Normal file
View File

@ -0,0 +1,203 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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::FaceInteraction
Group
grpLagrangianIntermediateFunctionObjects
Description
Face zone-based particle interactions.
\verbatim
faceInteraction1
{
type faceInteraction;
// List of (faceZone interactionType)
faceZones
(
(faceZone1 stick)
(faceZone2 escape)
(faceZone3 rebound)
);
// Optional limiting to diameter range
dMin 0;
dMax 1;
writeToFile yes; // default = yes
}
\endverbatim
File written per faceZone as:
postProcessing/lagrangian/cloudName/modelName/time/modelName_faceZone.dat
SourceFiles
FaceInteraction.C
\*---------------------------------------------------------------------------*/
#ifndef FaceInteraction_H
#define FaceInteraction_H
#include "CloudFunctionObject.H"
#include "Enum.H"
#include "boundBox.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class FaceInteraction Declaration
\*---------------------------------------------------------------------------*/
template<class CloudType>
class FaceInteraction
:
public CloudFunctionObject<CloudType>,
public functionObjects::writeFile
{
public:
// Public Data Types
//- Convenience typedef for parcel type
typedef typename CloudType::parcelType parcelType;
//- Enumeration defining the interaction types
enum class interactionType
{
ESCAPE, //!< particles escape/are removed
STICK, //!< particles stick to the faceZone faces
REBOUND //!< particles rebound from the faceZone faces
};
//- Names for the interaction types
static const Enum<interactionType> interactionTypeNames_;
private:
// Private Data
//- Face zone IDs
labelList faceZoneIDs_;
//- Face zone bounding boxes
List<boundBox> faceZoneBBs_;
//- Face zone particle interaction type
List<interactionType> faceZoneInteraction_;
//- File per zone
PtrList<OFstream> filePtrs_;
//- Number of escape particles per zone
labelList nEscapeParticles_;
//- Number of stick particles per zone
labelList nStickParticles_;
//- Number of rebound particles per zone
labelList nReboundParticles_;
//- Minimum diameter threshold
scalar dMin_;
//- Maximum diameter threshold
scalar dMax_;
protected:
// Protected Member Functions
//- Return true if this particle will be assessed
bool processParticle(const parcelType& p, const label localZonei);
//- Write post-processing info
void write();
public:
//- Runtime type information
TypeName("faceInteraction");
// Constructors
//- Construct from dictionary
FaceInteraction
(
const dictionary& dict,
CloudType& owner,
const word& modelName
);
//- Construct copy
FaceInteraction(const FaceInteraction<CloudType>& ppm);
//- Construct and return a clone
virtual autoPtr<CloudFunctionObject<CloudType>> clone() const
{
return autoPtr<CloudFunctionObject<CloudType>>
(
new FaceInteraction<CloudType>(*this)
);
}
//- Destructor
virtual ~FaceInteraction() = default;
// Member Functions
//- Post-face hook
virtual void postFace(const parcelType& p, bool& keepParticle);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "FaceInteraction.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

189
src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.C
View File

@ -43,7 +43,6 @@ Foam::ConeNozzleInjection<CloudType>::injectionMethodNames
({ ({
{ injectionMethod::imPoint, "point" }, { injectionMethod::imPoint, "point" },
{ injectionMethod::imDisc, "disc" }, { injectionMethod::imDisc, "disc" },
{ injectionMethod::imMovingPoint, "movingPoint" },
}); });
template<class CloudType> template<class CloudType>
@ -62,37 +61,52 @@ Foam::ConeNozzleInjection<CloudType>::flowTypeNames
// * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * * //
template<class CloudType> template<class CloudType>
void Foam::ConeNozzleInjection<CloudType>::setInjectionMethod() void Foam::ConeNozzleInjection<CloudType>::setInjectionGeometry()
{ {
switch (injectionMethod_) const auto& mesh = this->owner().mesh();
// Position
positionVsTime_.reset
(
Function1<vector>::New("position", this->coeffDict(), &mesh)
);
positionVsTime_->userTimeToTime(this->owner().time());
if (positionVsTime_->constant())
{ {
case injectionMethod::imPoint: position_ = positionVsTime_->value(0);
case injectionMethod::imDisc: }
// Direction
directionVsTime_.reset
(
Function1<vector>::New("direction", this->coeffDict(), &mesh)
);
directionVsTime_->userTimeToTime(this->owner().time());
if (directionVsTime_->constant())
{
direction_ = directionVsTime_->value(0);
direction_.normalise();
Random& rndGen = this->owner().rndGen();
// Determine direction vectors tangential to direction
vector tangent = Zero;
scalar magTangent = 0.0;
while(magTangent < SMALL)
{ {
this->coeffDict().readEntry("position", position_); vector v = rndGen.globalSample01<vector>();
break;
} tangent = v - (v & direction_)*direction_;
case injectionMethod::imMovingPoint: magTangent = mag(tangent);
{
positionVsTime_.reset
(
Function1<vector>::New
(
"position",
this->coeffDict(),
&this->owner().mesh()
)
);
positionVsTime_->userTimeToTime(this->owner().time());
break;
}
default:
{
FatalErrorInFunction
<< "Unhandled injection method "
<< injectionMethodNames[injectionMethod_]
<< exit(FatalError);
} }
tanVec1_ = tangent/magTangent;
tanVec2_ = direction_^tanVec1_;
} }
} }
@ -170,7 +184,8 @@ Foam::ConeNozzleInjection<CloudType>::ConeNozzleInjection
injectorCell_(-1), injectorCell_(-1),
tetFacei_(-1), tetFacei_(-1),
tetPti_(-1), tetPti_(-1),
direction_(this->coeffDict().lookup("direction")), directionVsTime_(nullptr),
direction_(Zero),
parcelsPerSecond_(this->coeffDict().getScalar("parcelsPerSecond")), parcelsPerSecond_(this->coeffDict().getScalar("parcelsPerSecond")),
flowRateProfile_ flowRateProfile_
( (
@ -231,29 +246,10 @@ Foam::ConeNozzleInjection<CloudType>::ConeNozzleInjection
thetaInner_->userTimeToTime(time); thetaInner_->userTimeToTime(time);
thetaOuter_->userTimeToTime(time); thetaOuter_->userTimeToTime(time);
setInjectionMethod(); setInjectionGeometry();
setFlowType(); setFlowType();
Random& rndGen = this->owner().rndGen();
// Normalise direction vector
direction_.normalise();
// Determine direction vectors tangential to direction
vector tangent = Zero;
scalar magTangent = 0.0;
while(magTangent < SMALL)
{
vector v = rndGen.globalSample01<vector>();
tangent = v - (v & direction_)*direction_;
magTangent = mag(tangent);
}
tanVec1_ = tangent/magTangent;
tanVec2_ = direction_^tanVec1_;
// Set total volume to inject // Set total volume to inject
this->volumeTotal_ = flowRateProfile_->integrate(0.0, duration_); this->volumeTotal_ = flowRateProfile_->integrate(0.0, duration_);
@ -279,6 +275,7 @@ Foam::ConeNozzleInjection<CloudType>::ConeNozzleInjection
injectorCell_(im.injectorCell_), injectorCell_(im.injectorCell_),
tetFacei_(im.tetFacei_), tetFacei_(im.tetFacei_),
tetPti_(im.tetPti_), tetPti_(im.tetPti_),
directionVsTime_(im.directionVsTime_.clone()),
direction_(im.direction_), direction_(im.direction_),
parcelsPerSecond_(im.parcelsPerSecond_), parcelsPerSecond_(im.parcelsPerSecond_),
flowRateProfile_(im.flowRateProfile_.clone()), flowRateProfile_(im.flowRateProfile_.clone()),
@ -294,37 +291,23 @@ Foam::ConeNozzleInjection<CloudType>::ConeNozzleInjection
{} {}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class CloudType>
Foam::ConeNozzleInjection<CloudType>::~ConeNozzleInjection()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class CloudType> template<class CloudType>
void Foam::ConeNozzleInjection<CloudType>::updateMesh() void Foam::ConeNozzleInjection<CloudType>::updateMesh()
{ {
// Set/cache the injector cell info for static methods // Set/cache the injector cell info for static methods
if (positionVsTime_->constant())
switch (injectionMethod_)
{ {
case injectionMethod::imPoint: position_ = positionVsTime_->value(0);
{
this->findCellAtPosition this->findCellAtPosition
( (
injectorCell_, injectorCell_,
tetFacei_, tetFacei_,
tetPti_, tetPti_,
position_ position_
); );
break;
}
default:
{
// Do nothing for the other methods
}
} }
} }
@ -381,6 +364,28 @@ void Foam::ConeNozzleInjection<CloudType>::setPositionAndCell
) )
{ {
Random& rndGen = this->owner().rndGen(); Random& rndGen = this->owner().rndGen();
const scalar t = time - this->SOI_;
if (!directionVsTime_->constant())
{
direction_ = directionVsTime_->value(t);
direction_.normalise();
// Determine direction vectors tangential to direction
vector tangent = Zero;
scalar magTangent = 0.0;
while(magTangent < SMALL)
{
vector v = rndGen.globalSample01<vector>();
tangent = v - (v & direction_)*direction_;
magTangent = mag(tangent);
}
tanVec1_ = tangent/magTangent;
tanVec2_ = direction_^tanVec1_;
}
scalar beta = mathematical::twoPi*rndGen.globalSample01<scalar>(); scalar beta = mathematical::twoPi*rndGen.globalSample01<scalar>();
normal_ = tanVec1_*cos(beta) + tanVec2_*sin(beta); normal_ = tanVec1_*cos(beta) + tanVec2_*sin(beta);
@ -389,25 +394,25 @@ void Foam::ConeNozzleInjection<CloudType>::setPositionAndCell
{ {
case injectionMethod::imPoint: case injectionMethod::imPoint:
{ {
position = position_; if (positionVsTime_->constant())
cellOwner = injectorCell_; {
tetFacei = tetFacei_; position = position_;
tetPti = tetPti_; cellOwner = injectorCell_;
tetFacei = tetFacei_;
break; tetPti = tetPti_;
} }
case injectionMethod::imMovingPoint: else
{ {
position = positionVsTime_->value(time - this->SOI_); position = positionVsTime_->value(t);
this->findCellAtPosition
(
cellOwner,
tetFacei,
tetPti,
position
);
this->findCellAtPosition
(
cellOwner,
tetFacei,
tetPti,
position
);
}
break; break;
} }
case injectionMethod::imDisc: case injectionMethod::imDisc:
@ -416,7 +421,7 @@ void Foam::ConeNozzleInjection<CloudType>::setPositionAndCell
scalar dr = outerDiameter_ - innerDiameter_; scalar dr = outerDiameter_ - innerDiameter_;
scalar r = 0.5*(innerDiameter_ + frac*dr); scalar r = 0.5*(innerDiameter_ + frac*dr);
position = position_ + r*normal_; position = positionVsTime_->value(t) + r*normal_;
this->findCellAtPosition this->findCellAtPosition
( (

20
src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.H
View File

@ -97,8 +97,7 @@ public:
enum class injectionMethod enum class injectionMethod
{ {
imPoint, imPoint,
imDisc, imDisc
imMovingPoint
}; };
static const Enum<injectionMethod> injectionMethodNames; static const Enum<injectionMethod> injectionMethodNames;
@ -136,19 +135,22 @@ private:
//- Position relative to SOI [] //- Position relative to SOI []
autoPtr<Function1<vector>> positionVsTime_; autoPtr<Function1<vector>> positionVsTime_;
//- Injector position [m] //- Static injector - position [m]
vector position_; vector position_;
//- Cell containing injector position [] //- Static injector - cell containing injector position []
label injectorCell_; label injectorCell_;
//- Index of tet face for injector cell //- Static injector - index of tet face for injector cell
label tetFacei_; label tetFacei_;
//- Index of tet point for injector cell //- Static injector - index of tet point for injector cell
label tetPti_; label tetPti_;
//- Injector direction [] //- Injector direction []
autoPtr<Function1<vector>> directionVsTime_;
//- Cached direction vector
vector direction_; vector direction_;
//- Number of parcels to introduce per second [] //- Number of parcels to introduce per second []
@ -193,8 +195,8 @@ private:
// Private Member Functions // Private Member Functions
//- Set the injection type //- Set the injection position and direction
void setInjectionMethod(); void setInjectionGeometry();
//- Set the injection flow type //- Set the injection flow type
void setFlowType(); void setFlowType();
@ -230,7 +232,7 @@ public:
//- Destructor //- Destructor
virtual ~ConeNozzleInjection(); virtual ~ConeNozzleInjection() = default;
// Member Functions // Member Functions

123
src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/PatchInjection/PatchInjection.C
View File

@ -29,6 +29,17 @@ License
#include "PatchInjection.H" #include "PatchInjection.H"
#include "distributionModel.H" #include "distributionModel.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
template<class CloudType>
const Foam::Enum<typename Foam::PatchInjection<CloudType>::velocityType>
Foam::PatchInjection<CloudType>::velocityTypeNames_
({
{ vtFixedValue, "fixedValue" },
{ vtPatchValue, "patchValue" },
{ vtZeroGradient, "zeroGradient" },
});
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CloudType> template<class CloudType>
@ -46,7 +57,21 @@ Foam::PatchInjection<CloudType>::PatchInjection
( (
this->coeffDict().getScalar("parcelsPerSecond") this->coeffDict().getScalar("parcelsPerSecond")
), ),
U0_(this->coeffDict().lookup("U0")), velocityType_
(
velocityTypeNames_.getOrDefault
(
"velocityType",
this->coeffDict(),
vtFixedValue
)
),
U0_
(
velocityType_ == vtFixedValue
? this->coeffDict().template get<vector>("U0")
: Zero
),
flowRateProfile_ flowRateProfile_
( (
Function1<scalar>::New Function1<scalar>::New
@ -63,7 +88,9 @@ Foam::PatchInjection<CloudType>::PatchInjection
this->coeffDict().subDict("sizeDistribution"), this->coeffDict().subDict("sizeDistribution"),
owner.rndGen() owner.rndGen()
) )
) ),
currentParceli_(-1),
currentFacei_(-1)
{ {
// Convert from user time to reduce the number of time conversion calls // Convert from user time to reduce the number of time conversion calls
const Time& time = owner.db().time(); const Time& time = owner.db().time();
@ -87,16 +114,12 @@ Foam::PatchInjection<CloudType>::PatchInjection
patchInjectionBase(im), patchInjectionBase(im),
duration_(im.duration_), duration_(im.duration_),
parcelsPerSecond_(im.parcelsPerSecond_), parcelsPerSecond_(im.parcelsPerSecond_),
velocityType_(im.velocityType_),
U0_(im.U0_), U0_(im.U0_),
flowRateProfile_(im.flowRateProfile_.clone()), flowRateProfile_(im.flowRateProfile_.clone()),
sizeDistribution_(im.sizeDistribution_.clone()) sizeDistribution_(im.sizeDistribution_.clone()),
{} currentParceli_(im.currentParceli_),
currentFacei_(im.currentFacei_)
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class CloudType>
Foam::PatchInjection<CloudType>::~PatchInjection()
{} {}
@ -167,16 +190,18 @@ Foam::scalar Foam::PatchInjection<CloudType>::volumeToInject
template<class CloudType> template<class CloudType>
void Foam::PatchInjection<CloudType>::setPositionAndCell void Foam::PatchInjection<CloudType>::setPositionAndCell
( (
const label, const label parcelI,
const label, const label nParcels,
const scalar, const scalar time,
vector& position, vector& position,
label& cellOwner, label& cellOwner,
label& tetFacei, label& tetFacei,
label& tetPti label& tetPti
) )
{ {
patchInjectionBase::setPositionAndCell currentParceli_ = parcelI;
currentFacei_ = patchInjectionBase::setPositionAndCell
( (
this->owner().mesh(), this->owner().mesh(),
this->owner().rndGen(), this->owner().rndGen(),
@ -191,16 +216,74 @@ void Foam::PatchInjection<CloudType>::setPositionAndCell
template<class CloudType> template<class CloudType>
void Foam::PatchInjection<CloudType>::setProperties void Foam::PatchInjection<CloudType>::setProperties
( (
const label, const label parcelI,
const label, const label nParcels,
const scalar, const scalar time,
typename CloudType::parcelType& parcel typename CloudType::parcelType& parcel
) )
{ {
// set particle velocity // Set particle velocity
parcel.U() = U0_; switch (velocityType_)
{
case vtFixedValue:
{
parcel.U() = U0_;
break;
}
case vtPatchValue:
{
if (parcelI != currentParceli_)
{
WarningInFunction
<< "Synchronisation problem: "
<< "attempting to set injected parcel " << parcelI
<< " properties using cached parcel " << currentParceli_
<< " properties" << endl;
}
// set particle diameter const label patchFacei = currentFacei_;
if (patchFacei < 0)
{
FatalErrorInFunction
<< "Unable to set parcel velocity using patch value "
<< "due to missing face index: patchFacei=" << patchFacei
<< abort(FatalError);
}
const volVectorField& U = this->owner().U();
const label patchi = this->patchId_;
parcel.U() = U.boundaryField()[patchi][patchFacei];
break;
}
case vtZeroGradient:
{
const label celli = parcel.cell();
if (celli < 0)
{
FatalErrorInFunction
<< "Unable to set parcel velocity using zeroGradient "
<< "due to missing cell index"
<< abort(FatalError);
}
const volVectorField& U = this->owner().U();
parcel.U() = U[celli];
break;
}
default:
{
FatalErrorInFunction
<< "Unhandled velocityType "
<< velocityTypeNames_[velocityType_]
<< ". Available options are:"
<< velocityTypeNames_.sortedToc()
<< abort(FatalError);
}
}
// Set particle diameter
parcel.d() = sizeDistribution_->sample(); parcel.d() = sizeDistribution_->sample();
} }

30
src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/PatchInjection/PatchInjection.H
View File

@ -72,6 +72,24 @@ class PatchInjection
public InjectionModel<CloudType>, public InjectionModel<CloudType>,
public patchInjectionBase public patchInjectionBase
{ {
public:
// Public Data Types
//- Velocity type enumeration
enum velocityType
{
vtFixedValue, //!< User supplied fixed value
vtPatchValue, //!< Patch face values
vtZeroGradient //!< Patch internal cell values
};
//- Velocity type names
static const Enum<velocityType> velocityTypeNames_;
private:
// Private data // Private data
//- Injection duration [s] //- Injection duration [s]
@ -80,7 +98,11 @@ class PatchInjection
//- Number of parcels to introduce per second [] //- Number of parcels to introduce per second []
const label parcelsPerSecond_; const label parcelsPerSecond_;
//- Velocity type
const velocityType velocityType_;
//- Initial parcel velocity [m/s] //- Initial parcel velocity [m/s]
// Note: Only used for vtFixedValue
const vector U0_; const vector U0_;
//- Flow rate profile relative to SOI [] //- Flow rate profile relative to SOI []
@ -89,6 +111,12 @@ class PatchInjection
//- Parcel size distribution model //- Parcel size distribution model
const autoPtr<distributionModel> sizeDistribution_; const autoPtr<distributionModel> sizeDistribution_;
//- Current parcel being processed
label currentParceli_;
//- Current face being processed
label currentFacei_;
public: public:
@ -120,7 +148,7 @@ public:
//- Destructor //- Destructor
virtual ~PatchInjection(); virtual ~PatchInjection() = default;
// Member Functions // Member Functions

12
src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/PatchInjection/patchInjectionBase.C
View File

@ -144,7 +144,7 @@ void Foam::patchInjectionBase::updateMesh(const polyMesh& mesh)
} }
void Foam::patchInjectionBase::setPositionAndCell Foam::label Foam::patchInjectionBase::setPositionAndCell
( (
const fvMesh& mesh, const fvMesh& mesh,
const scalar fraction01, const scalar fraction01,
@ -155,6 +155,8 @@ void Foam::patchInjectionBase::setPositionAndCell
label& tetPti label& tetPti
) )
{ {
label facei = -1;
if (cellOwners_.size() > 0) if (cellOwners_.size() > 0)
{ {
// Determine which processor to inject from // Determine which processor to inject from
@ -177,7 +179,7 @@ void Foam::patchInjectionBase::setPositionAndCell
} }
// Set cellOwner // Set cellOwner
label facei = triToFace_[trii]; facei = triToFace_[trii];
cellOwner = cellOwners_[facei]; cellOwner = cellOwners_[facei];
// Find random point in triangle // Find random point in triangle
@ -261,10 +263,12 @@ void Foam::patchInjectionBase::setPositionAndCell
// Dummy position // Dummy position
position = pTraits<vector>::max; position = pTraits<vector>::max;
} }
return facei;
} }
void Foam::patchInjectionBase::setPositionAndCell Foam::label Foam::patchInjectionBase::setPositionAndCell
( (
const fvMesh& mesh, const fvMesh& mesh,
Random& rnd, Random& rnd,
@ -276,7 +280,7 @@ void Foam::patchInjectionBase::setPositionAndCell
{ {
scalar fraction01 = rnd.globalSample01<scalar>(); scalar fraction01 = rnd.globalSample01<scalar>();
setPositionAndCell return setPositionAndCell
( (
mesh, mesh,
fraction01, fraction01,

6
src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/PatchInjection/patchInjectionBase.H
View File

@ -118,7 +118,8 @@ public:
//- Set the injection position and owner cell, tetFace and tetPt //- Set the injection position and owner cell, tetFace and tetPt
// Supply the fraction used to determine the location on the patch // Supply the fraction used to determine the location on the patch
void setPositionAndCell // Returns the seed patch face index
label setPositionAndCell
( (
const fvMesh& mesh, const fvMesh& mesh,
const scalar fraction01, const scalar fraction01,
@ -130,7 +131,8 @@ public:
); );
//- Set the injection position and owner cell, tetFace and tetPt //- Set the injection position and owner cell, tetFace and tetPt
virtual void setPositionAndCell // Returns the seed patch face index
virtual label setPositionAndCell
( (
const fvMesh& mesh, const fvMesh& mesh,
Random& rnd, Random& rnd,

56
tutorials/lagrangian/kinematicParcelFoam/spinningDisk/0/U Normal file
View File

@ -0,0 +1,56 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volVectorField;
object U;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField uniform (0.1 0 0);
boundaryField
{
inlet
{
type fixedValue;
value $internalField;
}
outlet
{
type inletOutlet;
inletValue uniform (0 0 0);
value uniform (0 0 0);
}
cylinder
{
type rotatingWallVelocity;
origin (0 0 0);
axis (0 0 1);
omega 1;
}
walls
{
type noSlip;
}
frontAndBack
{
type empty;
}
}
// ************************************************************************* //

46
tutorials/lagrangian/kinematicParcelFoam/spinningDisk/0/p Normal file
View File

@ -0,0 +1,46 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object p;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -2 0 0 0 0];
internalField uniform 0;
boundaryField
{
inlet
{
type zeroGradient;
}
outlet
{
type fixedValue;
value uniform 0;
}
"(walls|cylinder)"
{
type zeroGradient;
}
frontAndBack
{
type empty;
}
}
// ************************************************************************* //

21
tutorials/lagrangian/kinematicParcelFoam/spinningDisk/constant/g Normal file
View File

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

108
tutorials/lagrangian/kinematicParcelFoam/spinningDisk/constant/kinematicCloudProperties Normal file
View File

@ -0,0 +1,108 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1912 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object kinematicCloudProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
solution
{
active true;
coupled yes;
transient yes;
cellValueSourceCorrection no;
maxCo 0.3;
sourceTerms
{
schemes
{
U semiImplicit 1;
}
}
interpolationSchemes
{
rho cell;
U cellPoint;
muc cell;
p cell;
}
integrationSchemes
{
U Euler;
}
}
constantProperties
{
rho0 1000;
}
subModels
{
particleForces
{
sphereDrag;
gravity;
}
injectionModels
{
model1
{
type patchInjection;
massTotal 1;
SOI 0;
parcelBasisType mass;
patch cylinder;
duration 10;
parcelsPerSecond 100;
velocityType patchValue;
//velocityType zeroGradient;
//U0 (-10 0 0);
flowRateProfile constant 1;
sizeDistribution
{
type normal;
normalDistribution
{
expectation 1e-3;
variance 1e-4;
minValue 1e-5;
maxValue 2e-3;
}
}
}
}
dispersionModel none;
patchInteractionModel standardWallInteraction;
stochasticCollisionModel none;
surfaceFilmModel none;
standardWallInteractionCoeffs
{
type rebound;
}
}
cloudFunctions
{}
// ************************************************************************* //

24
tutorials/lagrangian/kinematicParcelFoam/spinningDisk/constant/transportProperties Normal file
View File

@ -0,0 +1,24 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object transportProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
transportModel Newtonian;
nu 1e-05;
rhoInf 1.2;
// ************************************************************************* //

20
tutorials/lagrangian/kinematicParcelFoam/spinningDisk/constant/turbulenceProperties Normal file
View File

@ -0,0 +1,20 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object turbulenceProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
simulationType laminar;
// ************************************************************************* //

114
tutorials/lagrangian/kinematicParcelFoam/spinningDisk/system/blockMeshDict Normal file
View File

@ -0,0 +1,114 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object blockMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
scale 1;
r 1;
a #eval{1./sqrt(2)*$r};
b #eval{3*$r};
n 16;
vertices
(
(-$b -$b 0) // 0
( $b -$b 0) // 1
(-$a -$a 0) // 2
( $a -$a 0) // 3
(-$a $a 0) // 4
( $a $a 0) // 5
(-$b $b 0) // 6
( $b $b 0) // 7
(-$b -$b 1) // 8
( $b -$b 1) // 9
(-$a -$a 1) // 10
( $a -$a 1) // 11
(-$a $a 1) // 12
( $a $a 1) // 13
(-$b $b 1) // 14
( $b $b 1) // 15
);
blocks
(
hex (0 1 3 2 8 9 11 10) ($n $n 1) simpleGrading (1 1 1)
hex (1 7 5 3 9 15 13 11) ($n $n 1) simpleGrading (1 1 1)
hex (7 6 4 5 15 14 12 13) ($n $n 1) simpleGrading (1 1 1)
hex (6 0 2 4 14 8 10 12) ($n $n 1) simpleGrading (1 1 1)
);
edges
(
arc 2 3 origin (0 0 0)
arc 3 5 origin (0 0 0)
arc 5 4 origin (0 0 0)
arc 4 2 origin (0 0 0)
arc 10 11 origin (0 0 1)
arc 11 13 origin (0 0 1)
arc 13 12 origin (0 0 1)
arc 12 10 origin (0 0 1)
);
boundary
(
walls
{
type wall;
faces
(
(0 2)
(2 2)
);
}
cylinder
{
type wall;
faces
(
(0 3)
(1 3)
(2 3)
(3 3)
);
}
outlet
{
type patch;
faces
(
(1 2)
);
}
inlet
{
type patch;
faces
(
(3 2)
);
}
);
defaultPatch
{
type empty;
name frontAndBack;
}
// ************************************************************************* //

54
tutorials/lagrangian/kinematicParcelFoam/spinningDisk/system/controlDict Normal file
View File

@ -0,0 +1,54 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object controlDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
application kinematicParcelFoam;
startFrom startTime;
startTime 0;
stopAt endTime;
endTime 10;
deltaT 0.005;
writeControl adjustable;
writeInterval 0.25;
purgeWrite 0;
writeFormat binary;
writePrecision 6;
writeCompression off;
timeFormat general;
timePrecision 6;
runTimeModifiable yes;
adjustTimeStep yes;
maxCo 0.9;
maxDeltaT 0.1;
// ************************************************************************* //

27
tutorials/lagrangian/kinematicParcelFoam/spinningDisk/system/decomposeParDict Normal file
View File

@ -0,0 +1,27 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object decomposeParDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
numberOfSubdomains 4;
method hierarchical;
coeffs
{
n ( 2 2 1 );
}
// ************************************************************************* //

54
tutorials/lagrangian/kinematicParcelFoam/spinningDisk/system/fvSchemes Normal file
View File

@ -0,0 +1,54 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object fvSchemes;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
ddtSchemes
{
default Euler;
}
gradSchemes
{
default Gauss linear;
grad(p) Gauss linear;
grad(U) Gauss linear;
}
divSchemes
{
default none;
div(phi,U) Gauss upwind;
div((nuEff*dev2(T(grad(U))))) Gauss linear;
}
laplacianSchemes
{
default Gauss linear corrected;
}
interpolationSchemes
{
default linear;
}
snGradSchemes
{
default corrected;
}
// ************************************************************************* //

60
tutorials/lagrangian/kinematicParcelFoam/spinningDisk/system/fvSolution Normal file
View File

@ -0,0 +1,60 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object fvSolution;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
solvers
{
p
{
solver PBiCGStab;
tolerance 0;
relTol 0.1;
smoother GaussSeidel;
preconditioner DIC;
}
pFinal
{
$p;
tolerance 1e-06;
relTol 0;
}
U
{
solver smoothSolver;
smoother GaussSeidel;
tolerance 1e-05;
relTol 0.01;
}
UFinal
{
$U;
tolerance 1e-06;
relTol 0;
}
}
PIMPLE
{
momentumPredictor yes;
nOuterCorrectors 1;
nCorrectors 2;
nNonOrthogonalCorrectors 0;
}
// ************************************************************************* //

53
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/0/G Normal file
View File

@ -0,0 +1,53 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object G;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [1 0 -3 0 0 0 0];
internalField uniform 0;
boundaryField
{
back
{
type symmetryPlane;
}
front
{
type symmetryPlane;
}
walls
{
type MarshakRadiation;
emissivityMode lookup;
emissivity uniform 1.0;
value uniform 0;
}
outlet
{
type zeroGradient;
}
inlet
{
type MarshakRadiation;
emissivityMode lookup;
emissivity uniform 1.0;
value uniform 0;
}
}
// ************************************************************************* //

31
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/0/H2O Normal file
View File

@ -0,0 +1,31 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object H2O;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 0 0 0 0];
internalField uniform 0.01;
boundaryField
{
walls
{
type zeroGradient;
}
}
// ************************************************************************* //

31
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/0/T Normal file
View File

@ -0,0 +1,31 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object T;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 1 0 0 0];
internalField uniform 293.0;
boundaryField
{
walls
{
type zeroGradient;
}
}
// ************************************************************************* //

31
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/0/U Normal file
View File

@ -0,0 +1,31 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volVectorField;
location "0";
object U;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField uniform (0 0 0);
boundaryField
{
walls
{
type noSlip;
}
}
// ************************************************************************* //

31
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/0/air Normal file
View File

@ -0,0 +1,31 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object air;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 0 0 0 0];
internalField uniform 0.99;
boundaryField
{
walls
{
type zeroGradient;
}
}
// ************************************************************************* //

32
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/0/p Normal file
View File

@ -0,0 +1,32 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object p;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [1 -1 -2 0 0 0 0];
internalField uniform 100000;
boundaryField
{
walls
{
type calculated;
value $internalField;
}
}
// ************************************************************************* //

31
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/0/p_rgh Normal file
View File

@ -0,0 +1,31 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object p_rgh;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [1 -1 -2 0 0 0 0];
internalField uniform 100000;
boundaryField
{
walls
{
type fixedFluxPressure;
}
}
// ************************************************************************* //

27
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/constant/chemistryProperties Normal file
View File

@ -0,0 +1,27 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object chemistryProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
chemistryType
{
solver noChemistrySolver;
}
chemistry off;
initialChemicalTimeStep 1e-7;
// ************************************************************************* //

21
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/constant/combustionProperties Normal file
View File

@ -0,0 +1,21 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object combustionProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
combustionModel none;
// ************************************************************************* //

22
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/constant/g Normal file
View File

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

194
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/constant/reactingCloud1Properties Normal file
View File

@ -0,0 +1,194 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object reactingCloud1Properties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
solution
{
active true;
coupled false;
transient yes;
cellValueSourceCorrection off;
maxCo 0.3;
sourceTerms
{
schemes
{
rho explicit 1;
U explicit 1;
Yi explicit 1;
h explicit 1;
radiation explicit 1;
}
}
interpolationSchemes
{
rho cell;
U cellPoint;
thermo:mu cell;
T cell;
Cp cell;
kappa cell;
p cell;
}
integrationSchemes
{
U Euler;
T Euler;
}
}
constantProperties
{
rho0 1000;
T0 293;
Cp0 4100;
volumeUpdateMethod constantRho;
}
subModels
{
particleForces
{
sphereDrag;
gravity;
}
injectionModels
{
model1
{
type coneNozzleInjection;
massTotal 0.0001;
parcelBasisType mass;
SOI 0;
injectionMethod point;
flowType constantVelocity;
UMag 20;
outerDiameter 0.001;
innerDiameter 0;
duration 2;
parcelsPerSecond 2000;
flowRateProfile constant 1;
thetaInner constant 0;
thetaOuter constant 10;
position table
(
( 0 (0.1 0.5 0.5))
(0.2 (0.5 0.9 0.5))
(0.4 (0.9 0.5 0.5))
(0.6 (0.5 0.1 0.5))
(0.8 (0.5 0.5 0.9))
(1.0 (0.5 0.9 0.5))
(1.2 (0.5 0.5 0.1))
(1.4 (0.5 0.1 0.5))
(1.6 (0.1 0.5 0.5))
(1.8 (0.5 0.5 0.9))
(2.0 (0.9 0.5 0.5))
(2.2 (0.5 0.5 0.1))
);
direction table
(
( 0 ( 1 0 0))
(0.2 ( 0 -1 0))
(0.4 (-1 0 0))
(0.6 ( 0 1 0))
(0.8 ( 0 0 -1))
(1.0 ( 0 -1 0))
(1.2 ( 0 0 1))
(1.4 ( 0 1 0))
(1.6 ( 1 0 0))
(1.8 ( 0 0 -1))
(2.0 (-1 0 0))
(2.2 ( 0 0 1))
);
sizeDistribution
{
type uniform;
uniformDistribution
{
minValue 100e-06;
maxValue 100e-06;
}
}
}
}
dispersionModel none;
patchInteractionModel standardWallInteraction;
heatTransferModel none;
compositionModel singleMixtureFraction;
phaseChangeModel none;
devolatilisationModel none;
surfaceReactionModel none;
stochasticCollisionModel none;
surfaceFilmModel none;
radiation off;
standardWallInteractionCoeffs
{
type rebound;
}
singleMixtureFractionCoeffs
{
phases
(
gas
{
}
liquid
{
H2O 1;
}
solid
{
}
);
YGasTot0 0;
YLiquidTot0 1;
YSolidTot0 0;
}
}
cloudFunctions
{}
// ************************************************************************* //

8
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/constant/reactions Normal file
View File

@ -0,0 +1,8 @@
species
(
air
H2O
);
reactions
{}

111
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/constant/thermo.incompressiblePoly Normal file
View File

@ -0,0 +1,111 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object thermo.incompressiblePoly;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
N2
{
specie
{
molWeight 28.0134;
}
equationOfState
{
rhoCoeffs<8> ( 3.8936 -0.016463 3.2101e-05 -2.9174e-08 9.9889e-12 0 0 0 );
}
thermodynamics
{
Hf 0;
Sf 0;
CpCoeffs<8> ( 979.08 0.41787 -0.0011761 1.6742e-06 -7.2559e-10 0 0 0 );
}
transport
{
muCoeffs<8> ( 1.5068e-06 6.1598e-08 -1.8188e-11 0 0 0 0 0 );
kappaCoeffs<8> ( 0.0031494 8.4997e-05 -1.2621e-08 0 0 0 0 0 );
}
}
O2
{
specie
{
molWeight 31.9988;
}
equationOfState
{
rhoCoeffs<8> ( 4.4475 -0.018805 3.6667e-05 -3.3323e-08 1.141e-11 0 0 0 );
}
thermodynamics
{
Hf 0;
Sf 0;
CpCoeffs<8> ( 834.84 0.29297 -0.00014959 3.4143e-07 -2.2786e-10 0 0 0 );
}
transport
{
muCoeffs<8> ( 1.5068e-06 6.1598e-08 -1.8188e-11 0 0 0 0 0 );
kappaCoeffs<8> ( 0.00016082 8.5301e-05 -1.4998e-08 0 0 0 0 0 );
}
}
H2O
{
specie
{
molWeight 18.0153;
}
equationOfState
{
rhoCoeffs<8> ( 2.5039 -0.010587 2.0643e-05 -1.8761e-08 6.4237e-12 0 0 0 );
}
thermodynamics
{
Hf -13423000;
Sf 10482;
CpCoeffs<8> ( 1563.1 1.604 -0.0029334 3.2168e-06 -1.1571e-09 0 0 0 );
}
transport
{
muCoeffs<8> ( 1.5068e-06 6.1598e-08 -1.8188e-11 0 0 0 0 0 );
kappaCoeffs<8> ( 0.0037972 0.00015336 -1.1859e-08 0 0 0 0 0 );
}
}
air
{
specie
{
molWeight 28.85;
}
equationOfState
{
rhoCoeffs<8> ( 4.0097 -0.016954 3.3057e-05 -3.0042e-08 1.0286e-11 0 0 0 );
}
thermodynamics
{
Hf 0;
Sf 0;
CpCoeffs<8> ( 948.76 0.39171 -0.00095999 1.393e-06 -6.2029e-10 0 0 0 );
}
transport
{
muCoeffs<8> ( 1.5061e-06 6.16e-08 -1.819e-11 0 0 0 0 0 );
kappaCoeffs<8> ( 0.0025219 8.506e-05 -1.312e-08 0 0 0 0 0 );
}
}
// ************************************************************************* //

48
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/constant/thermophysicalProperties Normal file
View File

@ -0,0 +1,48 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object thermophysicalProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
thermoType
{
type heRhoThermo;
mixture reactingMixture;
transport polynomial;
thermo hPolynomial;
energy sensibleEnthalpy;
equationOfState icoPolynomial;
specie specie;
}
dpdt no;
chemistryReader foamChemistryReader;
foamChemistryFile "<constant>/reactions";
foamChemistryThermoFile "<constant>/thermo.incompressiblePoly";
inertSpecie air;
liquids
{
H2O;
}
solids
{}
// ************************************************************************* //

20
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/constant/turbulenceProperties Normal file
View File

@ -0,0 +1,20 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object turbulenceProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
simulationType laminar;
// ************************************************************************* //

61
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/system/blockMeshDict Normal file
View File

@ -0,0 +1,61 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object blockMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
scale 1;
vertices
(
(0 0 0)
(1 0 0)
(1 1 0)
(0 1 0)
(0 0 1)
(1 0 1)
(1 1 1)
(0 1 1)
);
blocks
(
hex (0 1 2 3 4 5 6 7) (10 10 10) simpleGrading (1 1 1)
);
edges
(
);
boundary
(
walls
{
type wall;
faces
(
(3 7 6 2)
(1 5 4 0)
(0 4 7 3)
(2 6 5 1)
(0 3 2 1)
(4 5 6 7)
);
}
);
mergePatchPairs
(
);
// ************************************************************************* //

55
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/system/controlDict Normal file
View File

@ -0,0 +1,55 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object controlDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
application reactingParcelFoam;
startFrom startTime;
startTime 0;
stopAt endTime;
endTime 3;
deltaT 1e-3;
writeControl adjustable;
writeInterval 0.05;
purgeWrite 0;
writeFormat ascii;
writePrecision 10;
writeCompression off;
timeFormat general;
timePrecision 6;
runTimeModifiable true;
adjustTimeStep yes;
maxCo 5;
maxDeltaT 1e-3;
// ************************************************************************* //

49
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/system/fvSchemes Normal file
View File

@ -0,0 +1,49 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object fvSchemes;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
ddtSchemes
{
default Euler;
}
gradSchemes
{
default none;
}
divSchemes
{
default none;
}
laplacianSchemes
{
default none;
}
interpolationSchemes
{
default none;
}
snGradSchemes
{
default none;
}
// ************************************************************************* //

29
tutorials/lagrangian/reactingParcelFoam/movingInjectorBox/system/fvSolution Normal file
View File

@ -0,0 +1,29 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2106 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object fvSolution;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
solvers
{}
PIMPLE
{
solvePrimaryRegion no;
}
relaxationFactors
{}
// ************************************************************************* //