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: Migrated stochastic collision models from spray to kinematic clouds, refactored and added models

Browse Source
This commit is contained in:
andy
2013-05-03 11:33:17 +01:00
parent 794a870587
commit a1f3c95f9c
27 changed files with 803 additions and 922 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/lagrangian/intermediate/Make/files
View File

@ -25,7 +25,7 @@ $(KINEMATICCOLLIDINGPARCEL)/makeBasicKinematicCollidingParcelSubmodels.C
/* thermo parcel sub-models */
THERMOPARCEL=$(DERIVEDPARCELS)/fluidThermoParcel
THERMOPARCEL=$(DERIVEDPARCELS)/basicThermoParcel
$(THERMOPARCEL)/defineBasicThermoParcel.C
$(THERMOPARCEL)/makeBasicThermoParcelSubmodels.C

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

@ -31,6 +31,7 @@ License
#include "InjectionModelList.H"
#include "DispersionModel.H"
#include "PatchInteractionModel.H"
#include "StochasticCollisionModel.H"
#include "SurfaceFilmModel.H"
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
@ -56,6 +57,15 @@ void Foam::KinematicCloud<CloudType>::setModels()
).ptr()
);
stochasticCollisionModel_.reset
(
StochasticCollisionModel<KinematicCloud<CloudType> >::New
(
subModelProperties_,
*this
).ptr()
);
surfaceFilmModel_.reset
(
SurfaceFilmModel<KinematicCloud<CloudType> >::New
@ -181,7 +191,6 @@ void Foam::KinematicCloud<CloudType>::evolveCloud(TrackData& td)
if (preInjectionSize != this->size())
{
updateCellOccupancy();
preInjectionSize = this->size();
}
@ -191,6 +200,8 @@ void Foam::KinematicCloud<CloudType>::evolveCloud(TrackData& td)
// Assume that motion will update the cellOccupancy as necessary
// before it is required.
td.cloud().motion(td);
stochasticCollision().update(solution_.trackTime());
}
else
{
@ -249,6 +260,7 @@ void Foam::KinematicCloud<CloudType>::cloudReset(KinematicCloud<CloudType>& c)
dispersionModel_.reset(c.dispersionModel_.ptr());
patchInteractionModel_.reset(c.patchInteractionModel_.ptr());
stochasticCollisionModel_.reset(c.stochasticCollisionModel_.ptr());
surfaceFilmModel_.reset(c.surfaceFilmModel_.ptr());
UIntegrator_.reset(c.UIntegrator_.ptr());
@ -338,6 +350,7 @@ Foam::KinematicCloud<CloudType>::KinematicCloud
),
dispersionModel_(NULL),
patchInteractionModel_(NULL),
stochasticCollisionModel_(NULL),
surfaceFilmModel_(NULL),
UIntegrator_(NULL),
UTrans_
@ -418,6 +431,7 @@ Foam::KinematicCloud<CloudType>::KinematicCloud
injectors_(c.injectors_),
dispersionModel_(c.dispersionModel_->clone()),
patchInteractionModel_(c.patchInteractionModel_->clone()),
stochasticCollisionModel_(c.stochasticCollisionModel_->clone()),
surfaceFilmModel_(c.surfaceFilmModel_->clone()),
UIntegrator_(c.UIntegrator_->clone()),
UTrans_
@ -507,6 +521,7 @@ Foam::KinematicCloud<CloudType>::KinematicCloud
injectors_(*this),
dispersionModel_(NULL),
patchInteractionModel_(NULL),
stochasticCollisionModel_(NULL),
surfaceFilmModel_(NULL),
UIntegrator_(NULL),
UTrans_(NULL),

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

@ -39,6 +39,7 @@ Description
- dispersion model
- injection model
- patch interaction model
- stochastic collision model
- surface film model
SourceFiles
@ -84,6 +85,9 @@ class PatchInteractionModel;
template<class CloudType>
class SurfaceFilmModel;
template<class CloudType>
class StochasticCollisionModel;
/*---------------------------------------------------------------------------*\
Class KinematicCloud Declaration
@ -203,6 +207,10 @@ protected:
autoPtr<PatchInteractionModel<KinematicCloud<CloudType> > >
patchInteractionModel_;
//- Stochastic collision model
autoPtr<StochasticCollisionModel<KinematicCloud<CloudType> > >
stochasticCollisionModel_;
//- Surface film model
autoPtr<SurfaceFilmModel<KinematicCloud<CloudType> > >
surfaceFilmModel_;
@ -416,6 +424,15 @@ public:
inline PatchInteractionModel<KinematicCloud<CloudType> >&
patchInteraction();
//- Return const-access to the stochastic collision model
inline const
StochasticCollisionModel<KinematicCloud<CloudType> >&
stochasticCollision() const;
//- Return reference to the stochastic collision model
inline StochasticCollisionModel<KinematicCloud<CloudType> >&
stochasticCollision();
//- Return const-access to the surface film model
inline const SurfaceFilmModel<KinematicCloud<CloudType> >&
surfaceFilm() const;
@ -482,6 +499,9 @@ public:
// Fields
//- Volume swept rate of parcels per cell
inline const tmp<volScalarField> vDotSweep() const;
//- Return the particle volume fraction field
// Note: for particles belonging to this cloud only
inline const tmp<volScalarField> theta() const;

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

@ -204,6 +204,22 @@ Foam::KinematicCloud<CloudType>::patchInteraction()
}
template<class CloudType>
inline const Foam::StochasticCollisionModel<Foam::KinematicCloud<CloudType> >&
Foam::KinematicCloud<CloudType>::stochasticCollision() const
{
return stochasticCollisionModel_();
}
template<class CloudType>
inline Foam::StochasticCollisionModel<Foam::KinematicCloud<CloudType> >&
Foam::KinematicCloud<CloudType>::stochasticCollision()
{
return stochasticCollisionModel_();
}
template<class CloudType>
inline const Foam::SurfaceFilmModel<Foam::KinematicCloud<CloudType> >&
Foam::KinematicCloud<CloudType>::surfaceFilm() const
@ -571,6 +587,45 @@ Foam::KinematicCloud<CloudType>::SU(volVectorField& U) const
}
template<class CloudType>
inline const Foam::tmp<Foam::volScalarField>
Foam::KinematicCloud<CloudType>::vDotSweep() const
{
tmp<volScalarField> tvDotSweep
(
new volScalarField
(
IOobject
(
this->name() + ":vDotSweep",
this->db().time().timeName(),
this->db(),
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
mesh_,
dimensionedScalar("zero", dimless/dimTime, 0.0),
zeroGradientFvPatchScalarField::typeName
)
);
volScalarField& vDotSweep = tvDotSweep();
forAllConstIter(typename KinematicCloud<CloudType>, *this, iter)
{
const parcelType& p = iter();
const label cellI = p.cell();
vDotSweep[cellI] += p.nParticle()*p.areaP()*mag(p.U() - U_[cellI]);
}
vDotSweep.internalField() /= mesh_.V();
vDotSweep.correctBoundaryConditions();
return vDotSweep;
}
template<class CloudType>
inline const Foam::tmp<Foam::volScalarField>
Foam::KinematicCloud<CloudType>::theta() const

5
src/lagrangian/intermediate/clouds/baseClasses/kinematicCloud/kinematicCloud.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -100,6 +100,9 @@ public:
// Fields
//- Volume swept rate of parcels per cell
virtual const tmp<volScalarField> vDotSweep() const = 0;
//- Return the particle volume fraction field
// Note: for particles belonging to this cloud only
virtual const tmp<volScalarField> theta() const = 0;

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -520,8 +520,7 @@ public:
// Helper functions
//- Return the index of the face to be used in the interpolation
// routine
//- Return the index of the face used in the interpolation routine
inline label faceInterpolation() const;
//- Cell owner mass

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -33,6 +33,7 @@ License
#include "makeParcelInjectionModels.H"
#include "makeParcelCollisionModels.H"
#include "makeParcelPatchInteractionModels.H"
#include "makeParcelStochasticCollisionModels.H"
#include "makeParcelSurfaceFilmModels.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -47,6 +48,7 @@ namespace Foam
makeParcelInjectionModels(basicKinematicCollidingCloud);
makeParcelCollisionModels(basicKinematicCollidingCloud);
makeParcelPatchInteractionModels(basicKinematicCollidingCloud);
makeParcelStochasticCollisionModels(basicKinematicCollidingCloud);
makeParcelSurfaceFilmModels(basicKinematicCollidingCloud);
}

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -32,6 +32,7 @@ License
#include "makeParcelDispersionModels.H"
#include "makeParcelInjectionModels.H"
#include "makeParcelPatchInteractionModels.H"
#include "makeParcelStochasticCollisionModels.H"
#include "makeParcelSurfaceFilmModels.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -45,6 +46,7 @@ namespace Foam
makeParcelDispersionModels(basicKinematicCloud);
makeParcelInjectionModels(basicKinematicCloud);
makeParcelPatchInteractionModels(basicKinematicCloud);
makeParcelStochasticCollisionModels(basicKinematicCloud);
makeParcelSurfaceFilmModels(basicKinematicCloud);
}

45
src/lagrangian/intermediate/parcels/include/makeParcelStochasticCollisionModels.H Normal file
View File

@ -0,0 +1,45 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#ifndef makeParcelStochasticCollisionModels_H
#define makeParcelStochasticCollisionModels_H
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "NoStochasticCollision.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define makeParcelStochasticCollisionModels(CloudType) \
\
makeStochasticCollisionModel(CloudType); \
makeStochasticCollisionModelType(NoStochasticCollision, CloudType);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

47
src/lagrangian/intermediate/parcels/include/makeReactingMultiphaseParcelStochasticCollisionModels.H Normal file
View File

@ -0,0 +1,47 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#ifndef makeReactingMultiphaseParcelStochasticCollisionModels_H
#define makeReactingMultiphaseParcelStochasticCollisionModels_H
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "NoStochasticCollision.H"
#include "SuppressionCollision.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define makeReactingMultiphaseParcelStochasticCollisionModels(CloudType) \
\
makeStochasticCollisionModel(CloudType); \
makeStochasticCollisionModelType(NoStochasticCollision, CloudType); \
makeStochasticCollisionModelType(SuppressionCollision, CloudType);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

44
src/lagrangian/spray/submodels/StochasticCollision/NoStochasticCollision/NoStochasticCollision.C → src/lagrangian/intermediate/submodels/Kinematic/StochasticCollision/NoStochasticCollision/NoStochasticCollision.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,6 +25,15 @@ License
#include "NoStochasticCollision.H"
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
template<class CloudType>
void Foam::NoStochasticCollision<CloudType>::collide(const scalar)
{
// do nothing
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CloudType>
@ -64,37 +73,4 @@ bool Foam::NoStochasticCollision<CloudType>::active() const
}
template<class CloudType>
bool Foam::NoStochasticCollision<CloudType>::update
(
const scalar dt,
cachedRandom& rndGen,
vector& pos1,
scalar& m1,
scalar& d1,
scalar& N1,
vector& U,
scalar& rho1,
scalar& T1,
scalarField& Y1,
const scalar sigma1,
const label celli,
const scalar voli,
vector& pos2,
scalar& m2,
scalar& d2,
scalar& N2,
vector& U2,
scalar& rho2,
scalar& T2,
scalarField& Y2,
const scalar sigma2,
const label cellj,
const scalar volj
) const
{
return false;
}
// ************************************************************************* //

40
src/lagrangian/spray/submodels/StochasticCollision/NoStochasticCollision/NoStochasticCollision.H → src/lagrangian/intermediate/submodels/Kinematic/StochasticCollision/NoStochasticCollision/NoStochasticCollision.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -39,7 +39,7 @@ Description
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class NoStochasticCollision Declaration
Class NoStochasticCollision Declaration
\*---------------------------------------------------------------------------*/
template<class CloudType>
@ -47,6 +47,14 @@ class NoStochasticCollision
:
public StochasticCollisionModel<CloudType>
{
protected:
// Protected Member Functions
//- Update the model
virtual void collide(const scalar dt);
public:
//- Runtime type information
@ -79,34 +87,6 @@ public:
//- Flag to indicate whether model activates collision model
virtual bool active() const;
virtual bool update
(
const scalar dt,
cachedRandom& rndGen,
vector& pos1,
scalar& m1,
scalar& d1,
scalar& N1,
vector& U,
scalar& rho1,
scalar& T1,
scalarField& Y1,
const scalar sigma1,
const label celli,
const scalar voli,
vector& pos2,
scalar& m2,
scalar& d2,
scalar& N2,
vector& U2,
scalar& rho2,
scalar& T2,
scalarField& Y2,
const scalar sigma2,
const label cellj,
const scalar volj
) const;
};

79
src/lagrangian/spray/submodels/StochasticCollision/StochasticCollisionModel/StochasticCollisionModel.C → src/lagrangian/intermediate/submodels/Kinematic/StochasticCollision/StochasticCollisionModel/StochasticCollisionModel.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,6 +25,18 @@ License
#include "StochasticCollisionModel.H"
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
template<class CloudType>
void Foam::StochasticCollisionModel<CloudType>::collide(const scalar dt)
{
notImplemented
(
"void Foam::NoStochasticCollision<CloudType>::collide(const scalar)"
);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CloudType>
@ -69,66 +81,12 @@ Foam::StochasticCollisionModel<CloudType>::~StochasticCollisionModel()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class CloudType>
bool Foam::StochasticCollisionModel<CloudType>::update
(
const scalar dt,
cachedRandom& rndGen,
vector& pos1,
scalar& m1,
scalar& d1,
scalar& N1,
vector& U1,
scalar& rho1,
scalar& T1,
scalarField& Y1,
const scalar sigma1,
const label celli,
const scalar voli,
vector& pos2,
scalar& m2,
scalar& d2,
scalar& N2,
vector& U2,
scalar& rho2,
scalar& T2,
scalarField& Y2,
const scalar sigma2,
const label cellj,
const scalar volj
) const
void Foam::StochasticCollisionModel<CloudType>::update(const scalar dt)
{
notImplemented
(
"bool Foam::StochasticCollisionModel<CloudType>::update"
"("
"const scalar, "
"cachedRandom&, "
"vector&, "
"scalar&, "
"scalar&, "
"scalar&, "
"vector&, "
"scalar&, "
"scalar&, "
"scalarField&, "
"const scalar, "
"const label, "
"const scalar, "
"vector&, "
"scalar&, "
"scalar&, "
"scalar&, "
"vector&, "
"scalar&, "
"scalar&, "
"scalarField&, "
"const scalar, "
"const label, "
"const scalar"
") const"
);
return false;
if (this->active())
{
this->collide(dt);
}
}
@ -137,4 +95,3 @@ bool Foam::StochasticCollisionModel<CloudType>::update
#include "StochasticCollisionModelNew.C"
// ************************************************************************* //

53
src/lagrangian/spray/submodels/StochasticCollision/StochasticCollisionModel/StochasticCollisionModel.H → src/lagrangian/intermediate/submodels/Kinematic/StochasticCollision/StochasticCollisionModel/StochasticCollisionModel.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -55,6 +55,12 @@ class StochasticCollisionModel
:
public SubModelBase<CloudType>
{
protected:
//- Main collision routine
virtual void collide(const scalar dt);
public:
//- Runtime type information
@ -114,33 +120,8 @@ public:
// Member Functions
virtual bool update
(
const scalar dt,
cachedRandom& rndGen,
vector& pos1,
scalar& m1,
scalar& d1,
scalar& N1,
vector& U1,
scalar& rho1,
scalar& T1,
scalarField& Y1,
const scalar sigma1,
const label celli,
const scalar voli,
vector& pos2,
scalar& m2,
scalar& d2,
scalar& N2,
vector& U2,
scalar& rho2,
scalar& T2,
scalarField& Y2,
const scalar sigma2,
const label cellj,
const scalar volj
) const;
//- Update the model
void update(const scalar dt);
};
@ -152,27 +133,27 @@ public:
#define makeStochasticCollisionModel(CloudType) \
\
typedef CloudType::sprayCloudType sprayCloudType; \
typedef CloudType::kinematicCloudType kinematicCloudType; \
defineNamedTemplateTypeNameAndDebug \
( \
StochasticCollisionModel<sprayCloudType>, \
StochasticCollisionModel<kinematicCloudType>, \
0 \
); \
defineTemplateRunTimeSelectionTable \
( \
StochasticCollisionModel<sprayCloudType>, \
StochasticCollisionModel<kinematicCloudType>, \
dictionary \
);
#define makeStochasticCollisionModelType(SS, CloudType) \
\
typedef CloudType::sprayCloudType sprayCloudType; \
defineNamedTemplateTypeNameAndDebug(SS<sprayCloudType>, 0); \
typedef CloudType::kinematicCloudType kinematicCloudType; \
defineNamedTemplateTypeNameAndDebug(SS<kinematicCloudType>, 0); \
\
StochasticCollisionModel<sprayCloudType>:: \
adddictionaryConstructorToTable<SS<sprayCloudType> > \
add##SS##CloudType##sprayCloudType##ConstructorToTable_;
StochasticCollisionModel<kinematicCloudType>:: \
adddictionaryConstructorToTable<SS<kinematicCloudType> > \
add##SS##CloudType##kinematicCloudType##ConstructorToTable_;

8
src/lagrangian/spray/submodels/StochasticCollision/StochasticCollisionModel/StochasticCollisionModelNew.C → src/lagrangian/intermediate/submodels/Kinematic/StochasticCollision/StochasticCollisionModel/StochasticCollisionModelNew.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -37,7 +37,7 @@ Foam::StochasticCollisionModel<CloudType>::New
{
word modelType(dict.lookup("stochasticCollisionModel"));
Info<< "Selecting StochasticCollisionModel " << modelType << endl;
Info<< "Selecting stochastic collision model " << modelType << endl;
typename dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(modelType);
@ -51,9 +51,9 @@ Foam::StochasticCollisionModel<CloudType>::New
"const dictionary&, "
"CloudType&"
")"
) << "Unknown StochasticCollisionModelType type "
) << "Unknown model type type "
<< modelType << ", constructor not in hash table" << nl << nl
<< " Valid StochasticCollisionModel types are:" << nl
<< " Valid model types are:" << nl
<< dictionaryConstructorTablePtr_->sortedToc() << exit(FatalError);
}

91
src/lagrangian/intermediate/submodels/ReactingMultiphase/StochasticCollision/SuppressionCollision/SuppressionCollision.C Normal file
View File

@ -0,0 +1,91 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "SuppressionCollision.H"
#include "kinematicCloud.H"
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
template<class CloudType>
void Foam::SuppressionCollision<CloudType>::collide(const scalar dt)
{
const kinematicCloud& sc =
this->owner().mesh().template
lookupObject<kinematicCloud>(suppressionCloud_);
volScalarField vDotSweep(sc.vDotSweep());
volScalarField P(type() + ":p", 1.0 - exp(-vDotSweep*dt));
forAllIter(typename CloudType, this->owner(), iter)
{
typename CloudType::parcelType& p = iter();
label cellI = p.cell();
scalar xx = this->owner().rndGen().template sample01<scalar>();
if (xx < P[cellI])
{
p.canCombust() = -1;
p.typeId() = max(p.typeId(), suppressedParcelType_);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CloudType>
Foam::SuppressionCollision<CloudType>::SuppressionCollision
(
const dictionary& dict,
CloudType& owner
)
:
StochasticCollisionModel<CloudType>(owner),
suppressionCloud_(dict.lookup("suppressionCloud")),
suppressedParcelType_(dict.lookupOrDefault("suppressedParcelType", -1))
{}
template<class CloudType>
Foam::SuppressionCollision<CloudType>::SuppressionCollision
(
const SuppressionCollision<CloudType>& cm
)
:
StochasticCollisionModel<CloudType>(cm),
suppressionCloud_(cm.suppressionCloud_),
suppressedParcelType_(cm.suppressedParcelType_)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class CloudType>
Foam::SuppressionCollision<CloudType>::~SuppressionCollision()
{}
// ************************************************************************* //

111
src/lagrangian/intermediate/submodels/ReactingMultiphase/StochasticCollision/SuppressionCollision/SuppressionCollision.H Normal file
View File

@ -0,0 +1,111 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::SuppressionCollision
Description
Inter-cloud collision model, whereby the \c canReact flag can be used
to inhibit devolatilisation and surface reactions
\*---------------------------------------------------------------------------*/
#ifndef SuppressionCollision_H
#define SuppressionCollision_H
#include "StochasticCollisionModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class SuppressionCollision Declaration
\*---------------------------------------------------------------------------*/
template<class CloudType>
class SuppressionCollision
:
public StochasticCollisionModel<CloudType>
{
protected:
// Protected data
//- Name of cloud used for suppression
const word suppressionCloud_;
//- Suppressed parcel type - optional
const label suppressedParcelType_;
// Protected Member Functions
//- Update the model
virtual void collide(const scalar dt);
public:
//- Runtime type information
TypeName("suppressionCollision");
// Constructors
//- Construct from dictionary
SuppressionCollision(const dictionary& dict, CloudType& owner);
//- Construct copy
SuppressionCollision(const SuppressionCollision<CloudType>& cm);
//- Construct and return a clone
virtual autoPtr<StochasticCollisionModel<CloudType> > clone() const
{
return autoPtr<StochasticCollisionModel<CloudType> >
(
new SuppressionCollision<CloudType>(*this)
);
}
//- Destructor
virtual ~SuppressionCollision();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "SuppressionCollision.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

146
src/lagrangian/spray/clouds/Templates/SprayCloud/SprayCloud.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -26,7 +26,6 @@ License
#include "SprayCloud.H"
#include "AtomizationModel.H"
#include "BreakupModel.H"
#include "StochasticCollisionModel.H"
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
@ -50,15 +49,6 @@ void Foam::SprayCloud<CloudType>::setModels()
*this
).ptr()
);
stochasticCollisionModel_.reset
(
StochasticCollisionModel<SprayCloud<CloudType> >::New
(
this->subModelProperties(),
*this
).ptr()
);
}
@ -72,7 +62,6 @@ void Foam::SprayCloud<CloudType>::cloudReset
atomizationModel_.reset(c.atomizationModel_.ptr());
breakupModel_.reset(c.breakupModel_.ptr());
stochasticCollisionModel_.reset(c.stochasticCollisionModel_.ptr());
}
@ -94,8 +83,7 @@ Foam::SprayCloud<CloudType>::SprayCloud
cloudCopyPtr_(NULL),
averageParcelMass_(0.0),
atomizationModel_(NULL),
breakupModel_(NULL),
stochasticCollisionModel_(NULL)
breakupModel_(NULL)
{
if (this->solution().active())
{
@ -130,8 +118,7 @@ Foam::SprayCloud<CloudType>::SprayCloud
cloudCopyPtr_(NULL),
averageParcelMass_(c.averageParcelMass_),
atomizationModel_(c.atomizationModel_->clone()),
breakupModel_(c.breakupModel_->clone()),
stochasticCollisionModel_(c.stochasticCollisionModel_->clone())
breakupModel_(c.breakupModel_->clone())
{}
@ -148,8 +135,7 @@ Foam::SprayCloud<CloudType>::SprayCloud
cloudCopyPtr_(NULL),
averageParcelMass_(0.0),
atomizationModel_(NULL),
breakupModel_(NULL),
stochasticCollisionModel_(NULL)
breakupModel_(NULL)
{}
@ -179,6 +165,8 @@ void Foam::SprayCloud<CloudType>::setParcelThermoProperties
// override rho and Cp from constantProperties
parcel.Cp() = liqMix.Cp(parcel.pc(), parcel.T(), X);
parcel.rho() = liqMix.rho(parcel.pc(), parcel.T(), X);
parcel.sigma() = liqMix.sigma(parcel.pc(), parcel.T(), X);
parcel.mu() = liqMix.mu(parcel.pc(), parcel.T(), X);
}
@ -237,128 +225,6 @@ void Foam::SprayCloud<CloudType>::evolve()
}
template<class CloudType>
template<class TrackData>
void Foam::SprayCloud<CloudType>::motion(TrackData& td)
{
const scalar dt = this->solution().trackTime();
td.part() = TrackData::tpLinearTrack;
CloudType::move(td, dt);
this->updateCellOccupancy();
if (stochasticCollision().active())
{
const liquidMixtureProperties& liqMix = this->composition().liquids();
label i = 0;
forAllIter(typename SprayCloud<CloudType>, *this, iter)
{
label j = 0;
forAllIter(typename SprayCloud<CloudType>, *this, jter)
{
if (j > i)
{
parcelType& p = iter();
scalar Vi = this->mesh().V()[p.cell()];
scalarField X1(liqMix.X(p.Y()));
scalar sigma1 = liqMix.sigma(p.pc(), p.T(), X1);
scalar mp = p.mass()*p.nParticle();
parcelType& q = jter();
scalar Vj = this->mesh().V()[q.cell()];
scalarField X2(liqMix.X(q.Y()));
scalar sigma2 = liqMix.sigma(q.pc(), q.T(), X2);
scalar mq = q.mass()*q.nParticle();
bool updateProperties = stochasticCollision().update
(
dt,
this->rndGen(),
p.position(),
mp,
p.d(),
p.nParticle(),
p.U(),
p.rho(),
p.T(),
p.Y(),
sigma1,
p.cell(),
Vi,
q.position(),
mq,
q.d(),
q.nParticle(),
q.U(),
q.rho(),
q.T(),
q.Y(),
sigma2,
q.cell(),
Vj
);
// for coalescence we need to update the density and
// the diameter cause of the temp/conc/mass-change
if (updateProperties)
{
if (mp > VSMALL)
{
scalarField Xp(liqMix.X(p.Y()));
p.rho() = liqMix.rho(p.pc(), p.T(), Xp);
p.Cp() = liqMix.Cp(p.pc(), p.T(), Xp);
p.d() =
cbrt
(
6.0*mp
/(
p.nParticle()
*p.rho()
*constant::mathematical::pi
)
);
}
if (mq > VSMALL)
{
scalarField Xq(liqMix.X(q.Y()));
q.rho() = liqMix.rho(q.pc(), q.T(), Xq);
q.Cp() = liqMix.Cp(q.pc(), q.T(), Xq);
q.d() =
cbrt
(
6.0*mq
/(
q.nParticle()
*q.rho()
*constant::mathematical::pi
)
);
}
}
}
j++;
}
i++;
}
// remove coalesced parcels that fall below minimum mass threshold
forAllIter(typename SprayCloud<CloudType>, *this, iter)
{
parcelType& p = iter();
scalar mass = p.nParticle()*p.mass();
if (mass < td.cloud().constProps().minParticleMass())
{
this->deleteParticle(p);
}
}
}
}
template<class CloudType>
void Foam::SprayCloud<CloudType>::info()
{

26
src/lagrangian/spray/clouds/Templates/SprayCloud/SprayCloud.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -27,6 +27,10 @@ Class
Description
Templated base class for spray cloud
- sub-models:
- atomization model
- break-up model
\*---------------------------------------------------------------------------*/
#ifndef SprayCloud_H
@ -46,9 +50,6 @@ class AtomizationModel;
template<class CloudType>
class BreakupModel;
template<class CloudType>
class StochasticCollisionModel;
/*---------------------------------------------------------------------------*\
Class SprayCloud Declaration
\*---------------------------------------------------------------------------*/
@ -106,10 +107,6 @@ protected:
//- Break-up model
autoPtr<BreakupModel<SprayCloud<CloudType> > > breakupModel_;
//- Collision model
autoPtr<StochasticCollisionModel<SprayCloud<CloudType> > >
stochasticCollisionModel_;
// Protected Member Functions
@ -202,14 +199,6 @@ public:
//- Return reference to the breakup model
inline BreakupModel<SprayCloud<CloudType> >& breakup();
//- Return const-access to the breakup model
inline const StochasticCollisionModel<SprayCloud<CloudType> >&
stochasticCollision() const;
//- Return reference to the breakup model
inline StochasticCollisionModel<SprayCloud<CloudType> >&
stochasticCollision();
// Cloud evolution functions
@ -236,10 +225,6 @@ public:
//- Evolve the spray (inject, move)
void evolve();
//- Particle motion
template<class TrackData>
void motion(TrackData& td);
// I-O
@ -249,7 +234,6 @@ public:
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam

18
src/lagrangian/spray/clouds/Templates/SprayCloud/SprayCloudI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -65,22 +65,6 @@ Foam::SprayCloud<CloudType>::breakup()
}
template<class CloudType>
inline const Foam::StochasticCollisionModel<Foam::SprayCloud<CloudType> >&
Foam::SprayCloud<CloudType>::stochasticCollision() const
{
return stochasticCollisionModel_;
}
template<class CloudType>
inline Foam::StochasticCollisionModel<Foam::SprayCloud<CloudType> >&
Foam::SprayCloud<CloudType>::stochasticCollision()
{
return stochasticCollisionModel_();
}
template<class CloudType>
inline Foam::scalar Foam::SprayCloud<CloudType>::averageParcelMass() const
{

2
src/lagrangian/spray/parcels/Templates/SprayParcel/SprayParcel.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License

6
src/lagrangian/spray/parcels/derived/basicSprayParcel/makeBasicSprayParcelSubmodels.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -32,6 +32,7 @@ License
#include "makeParcelDispersionModels.H"
#include "makeSprayParcelInjectionModels.H" // Spray variant
#include "makeParcelPatchInteractionModels.H"
#include "makeSprayParcelStochasticCollisionModels.H" // Spray variant
// Thermodynamic
#include "makeParcelHeatTransferModels.H"
@ -44,7 +45,6 @@ License
// Spray
#include "makeSprayParcelAtomizationModels.H"
#include "makeSprayParcelBreakupModels.H"
#include "makeSprayParcelCollisionModels.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -57,6 +57,7 @@ namespace Foam
makeParcelDispersionModels(basicSprayCloud);
makeSprayParcelInjectionModels(basicSprayCloud);
makeParcelPatchInteractionModels(basicSprayCloud);
makeSprayParcelStochasticCollisionModels(basicSprayCloud);
// Thermo sub-models
makeParcelHeatTransferModels(basicSprayCloud);
@ -69,7 +70,6 @@ namespace Foam
// Spray sub-models
makeSprayParcelAtomizationModels(basicSprayCloud);
makeSprayParcelBreakupModels(basicSprayCloud);
makeSprayParcelCollisionModels(basicSprayCloud);
};

8
src/lagrangian/spray/parcels/include/makeSprayParcelCollisionModels.H → src/lagrangian/spray/parcels/include/makeSprayParcelStochasticCollisionModels.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -23,8 +23,8 @@ License
\*---------------------------------------------------------------------------*/
#ifndef makeSprayParcelCollisionModels_H
#define makeSprayParcelCollisionModels_H
#ifndef makeSprayParcelStochasticCollisionModels_H
#define makeSprayParcelStochasticCollisionModels_H
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -34,7 +34,7 @@ License
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define makeSprayParcelCollisionModels(CloudType) \
#define makeSprayParcelStochasticCollisionModels(CloudType) \
\
makeStochasticCollisionModel(CloudType); \
makeStochasticCollisionModelType(NoStochasticCollision, CloudType); \

355
src/lagrangian/spray/submodels/StochasticCollision/ORourkeCollision/ORourkeCollision.C
View File

@ -24,150 +24,120 @@ License
\*---------------------------------------------------------------------------*/
#include "ORourkeCollision.H"
#include "mathematicalConstants.H"
#include "SLGThermo.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
using namespace Foam::constant::mathematical;
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
template<class CloudType>
Foam::ORourkeCollision<CloudType>::ORourkeCollision
(
const dictionary& dict,
CloudType& owner
)
:
StochasticCollisionModel<CloudType>(dict, owner, typeName),
coalescence_(this->coeffDict().lookup("coalescence"))
{}
void Foam::ORourkeCollision<CloudType>::collide(const scalar dt)
{
label i = 0;
forAllIter(typename CloudType, this->owner(), iter1)
{
label j = 0;
forAllIter(typename CloudType, this->owner(), iter2)
{
if (j > i)
{
parcelType& p1 = iter1();
parcelType& p2 = iter2();
scalar m1 = p1.nParticle()*p1.mass();
scalar m2 = p2.nParticle()*p2.mass();
bool massChanged = collideParcels(dt, p1, p2, m1, m2);
if (massChanged)
{
if (m1 > ROOTVSMALL)
{
const scalarField X(liquids_.X(p1.Y()));
p1.rho() = liquids_.rho(p1.pc(), p1.T(), X);
p1.Cp() = liquids_.Cp(p1.pc(), p1.T(), X);
p1.sigma() = liquids_.sigma(p1.pc(), p1.T(), X);
p1.mu() = liquids_.mu(p1.pc(), p1.T(), X);
p1.d() = cbrt(6.0*m1/(p1.nParticle()*p1.rho()*pi));
}
if (m2 > ROOTVSMALL)
{
const scalarField X(liquids_.X(p2.Y()));
p2.rho() = liquids_.rho(p2.pc(), p2.T(), X);
p2.Cp() = liquids_.Cp(p2.pc(), p2.T(), X);
p2.sigma() = liquids_.sigma(p2.pc(), p2.T(), X);
p2.mu() = liquids_.mu(p2.pc(), p2.T(), X);
p2.d() = cbrt(6.0*m2/(p2.nParticle()*p2.rho()*pi));
}
}
}
j++;
}
i++;
}
// remove coalesced parcels that fall below minimum mass threshold
forAllIter(typename CloudType, this->owner(), iter)
{
parcelType& p = iter();
scalar mass = p.nParticle()*p.mass();
if (mass < this->owner().constProps().minParticleMass())
{
this->owner().deleteParticle(p);
}
}
}
template<class CloudType>
Foam::ORourkeCollision<CloudType>::ORourkeCollision
(
const ORourkeCollision<CloudType>& cm
)
:
StochasticCollisionModel<CloudType>(cm),
coalescence_(cm.coalescence_)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class CloudType>
Foam::ORourkeCollision<CloudType>::~ORourkeCollision()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class CloudType>
bool Foam::ORourkeCollision<CloudType>::update
bool Foam::ORourkeCollision<CloudType>::collideParcels
(
const scalar dt,
cachedRandom& rndGen,
vector& pos1,
parcelType& p1,
parcelType& p2,
scalar& m1,
scalar& d1,
scalar& N1,
vector& U1,
scalar& rho1,
scalar& T1,
scalarField& Y1,
const scalar sigma1,
const label celli,
const scalar voli,
vector& pos2,
scalar& m2,
scalar& d2,
scalar& N2,
vector& U2,
scalar& rho2,
scalar& T2,
scalarField& Y2,
const scalar sigma2,
const label cellj,
const scalar volj
) const
scalar& m2
)
{
const label cell1 = p1.cell();
const label cell2 = p2.cell();
// check if parcels belong to same cell
if ((celli != cellj) || (m1 < VSMALL) || (m2 < VSMALL))
if ((cell1 != cell2) || (m1 < ROOTVSMALL) || (m2 < ROOTVSMALL))
{
return false;
}
bool coalescence = false;
scalar magVrel = mag(U1-U2);
const scalar Vc = this->owner().mesh().V()[cell1];
const scalar d1 = p1.d();
const scalar d2 = p2.d();
scalar magUrel = mag(p1.U() - p2.U());
scalar sumD = d1 + d2;
scalar nu0 = 0.25*constant::mathematical::pi*sumD*sumD*magVrel*dt/volj;
scalar nMin = min(N1, N2);
scalar nu0 = 0.25*constant::mathematical::pi*sqr(sumD)*magUrel*dt/Vc;
scalar nMin = min(p1.nParticle(), p2.nParticle());
scalar nu = nMin*nu0;
scalar collProb = exp(-nu);
scalar xx = rndGen.sample01<scalar>();
scalar xx = this->owner().rndGen().template sample01<scalar>();
// collision occurs
if (xx > collProb)
{
if (d1 > d2)
{
coalescence = collideSorted
(
dt,
rndGen,
pos1,
m1,
d1,
N1,
U1,
rho1,
T1,
Y1,
sigma1,
celli,
voli,
pos2,
m2,
d2,
N2,
U2,
rho2,
T2,
Y2,
sigma2,
cellj,
volj
);
coalescence = collideSorted(dt, p1, p2, m1, m2);
}
else
{
coalescence = collideSorted
(
dt,
rndGen,
pos2,
m2,
d2,
N2,
U2,
rho2,
T2,
Y2,
sigma2,
cellj,
volj,
pos1,
m1,
d1,
N1,
U1,
rho1,
T1,
Y1,
sigma1,
celli,
voli
);
coalescence = collideSorted(dt, p2, p1, m2, m1);
}
}
return coalescence;
}
@ -176,85 +146,81 @@ template<class CloudType>
bool Foam::ORourkeCollision<CloudType>::collideSorted
(
const scalar dt,
cachedRandom& rndGen,
vector& pos1,
parcelType& p1,
parcelType& p2,
scalar& m1,
scalar& d1,
scalar& N1,
vector& U1,
scalar& rho1,
scalar& T1,
scalarField& Y1,
const scalar sigma1,
const label celli,
const scalar voli,
vector& pos2,
scalar& m2,
scalar& d2,
scalar& N2,
vector& U2,
scalar& rho2,
scalar& T2,
scalarField& Y2,
const scalar sigma2,
const label cellj,
const scalar volj
) const
scalar& m2
)
{
bool coalescence = false;
vector vRel = U1 - U2;
scalar magVRel = mag(vRel);
const scalar sigma1 = p1.sigma();
const scalar sigma2 = p2.sigma();
scalar mdMin = m2/N2;
const scalar d1 = p1.d();
const scalar d2 = p2.d();
const scalar T1 = p1.T();
const scalar T2 = p2.T();
const scalar rho1 = p1.rho();
const scalar rho2 = p2.rho();
const vector& U1 = p1.U();
const vector& U2 = p2.U();
const label& nP1 = p1.nParticle();
const label& nP2 = p2.nParticle();
vector URel = U1 - U2;
scalar magURel = mag(URel);
scalar mTot = m1 + m2;
scalar gamma = d1/max(d2, 1.0e-12);
scalar f = gamma*gamma*gamma + 2.7*gamma - 2.4*gamma*gamma;
scalar gamma = d1/max(ROOTVSMALL, d2);
scalar f = pow3(gamma) + 2.7*gamma - 2.4*sqr(gamma);
vector momMax = m1*U1;
vector momMin = m2*U2;
// mass-averaged temperature
scalar Tave = (T1*m1 + T2*m2)/mTot;
// use mass-averaged temperature to calculate We number
scalar Tm = (T1*m1 + T2*m2)/mTot;
// interpolate to find average surface tension
scalar sigmaAve = sigma1 + (sigma2 - sigma1)*(Tave - T1)/(T2 - T1);
// interpolate the averaged surface tension
scalar sigma = sigma1 + (sigma2 - sigma1)*(Tm - T1)/(T2 - T1);
sigma = max(1.0e-6, sigma);
scalar Vtot = m1/rho1 + m2/rho2;
scalar rho = mTot/Vtot;
scalar rhoAve = mTot/Vtot;
scalar dMean = sqrt(d1*d2);
scalar WeColl = max(1.0e-12, 0.5*rho*magVRel*magVRel*dMean/sigma);
scalar dAve = sqrt(d1*d2);
scalar WeColl = 0.5*rhoAve*sqr(magURel)*dAve/max(ROOTVSMALL, sigmaAve);
scalar coalesceProb = min(1.0, 2.4*f/WeColl);
scalar coalesceProb = min(1.0, 2.4*f/max(ROOTVSMALL, WeColl));
scalar prob = rndGen.sample01<scalar>();
scalar prob = this->owner().rndGen().template sample01<scalar>();
// Coalescence
if (prob < coalesceProb && coalescence_)
{
coalescence = true;
// How 'many' of the droplets coalesce
scalar nProb = prob*N2/N1;
// Conservation of mass, momentum and energy
scalar m2Org = m2;
scalar dm = N1*nProb*mdMin;
m2 -= dm;
scalar V2 = constant::mathematical::pi*pow3(d2)/6.0;
N2 = m2/(rho2*V2);
// number of the droplets that coalesce
scalar nProb = prob*nP2/nP1;
// conservation of mass, momentum and energy
scalar m1Org = m1;
scalar m2Org = m2;
scalar dm = nP1*nProb*m2/scalar(nP2);
m1 += dm;
T1 = (Tm*mTot - m2*T2)/m1;
m2 -= dm;
U1 =(momMax + (1.0 - m2/m2Org)*momMin)/m1;
p1.T() = (Tave*mTot - m2*T2)/m1;
// update the liquid mass fractions
Y1 = (m1Org*Y1 + dm*Y2)/m1;
p1.U() = (m1*U1 + (1.0 - m2/m2Org)*m2*U2)/m1;
p1.Y() = (m1Org*p1.Y() + dm*p2.Y())/m1;
p2.nParticle() = m2/(rho2*p2.volume());
}
// Grazing collision (no coalescence)
else
@ -271,28 +237,65 @@ bool Foam::ORourkeCollision<CloudType>::collideSorted
// and these parcels should have coalesced
gf = max(0.0, gf);
// gf -> 1 => v1p -> p1().U() ...
// gf -> 0 => v1p -> momentum/(m1+m2)
// gf -> 1 => v1p -> U1 ...
// gf -> 0 => v1p -> momentum/mTot
vector mr = m1*U1 + m2*U2;
vector v1p = (mr + m2*gf*vRel)/(m1+m2);
vector v2p = (mr - m1*gf*vRel)/(m1+m2);
vector v1p = (mr + m2*gf*URel)/mTot;
vector v2p = (mr - m1*gf*URel)/mTot;
if (N1 < N2)
if (nP1 < nP2)
{
U1 = v1p;
U2 = (N1*v2p + (N2-N1)*U2)/N2;
p1.U() = v1p;
p2.U() = (nP1*v2p + (nP2 - nP1)*U2)/nP2;
}
else
{
U1 = (N2*v1p + (N1-N2)*U1)/N1;
U2 = v2p;
p1.U() = (nP2*v1p + (nP1 - nP2)*U1)/nP1;
p2.U() = v2p;
}
}
return coalescence;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CloudType>
Foam::ORourkeCollision<CloudType>::ORourkeCollision
(
const dictionary& dict,
CloudType& owner,
const word& modelName
)
:
StochasticCollisionModel<CloudType>(dict, owner, modelName),
liquids_
(
owner.db().template lookupObject<SLGThermo>("SLGThermo").liquids()
),
coalescence_(this->coeffDict().lookup("coalescence"))
{}
template<class CloudType>
Foam::ORourkeCollision<CloudType>::ORourkeCollision
(
const ORourkeCollision<CloudType>& cm
)
:
StochasticCollisionModel<CloudType>(cm),
liquids_(cm.liquids_),
coalescence_(cm.coalescence_)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class CloudType>
Foam::ORourkeCollision<CloudType>::~ORourkeCollision()
{}
// ************************************************************************* //

113
src/lagrangian/spray/submodels/StochasticCollision/ORourkeCollision/ORourkeCollision.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -34,13 +34,14 @@ Description
#define ORourkeCollision_H
#include "StochasticCollisionModel.H"
#include "liquidMixtureProperties.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class ORourkeCollision Declaration
Class ORourkeCollision Declaration
\*---------------------------------------------------------------------------*/
template<class CloudType>
@ -48,10 +49,44 @@ class ORourkeCollision
:
public StochasticCollisionModel<CloudType>
{
private:
protected:
// Protected Data
//- Convenience typedef to the cloud's parcel type
typedef typename CloudType::parcelType parcelType;
const liquidMixtureProperties& liquids_;
//- Coalescence activation switch
Switch coalescence_;
// Protected Member Functions
//- Main collision routine
virtual void collide(const scalar dt);
//- Collide parcels and return true if mass has changed
virtual bool collideParcels
(
const scalar dt,
parcelType& p1,
parcelType& p2,
scalar& m1,
scalar& m2
);
// 1 is the larger drop and 2 is the smaller
virtual bool collideSorted
(
const scalar dt,
parcelType& p1,
parcelType& p2,
scalar& m1,
scalar& m2
);
dictionary coeffsDict_;
Switch coalescence_;
public:
@ -62,7 +97,12 @@ public:
// Constructors
//- Construct from dictionary
ORourkeCollision(const dictionary& dict, CloudType& cloud);
ORourkeCollision
(
const dictionary& dict,
CloudType& cloud,
const word& modelName = typeName
);
//- Construct copy
ORourkeCollision(const ORourkeCollision<CloudType>& cm);
@ -79,67 +119,6 @@ public:
//- Destructor
virtual ~ORourkeCollision();
// Member Functions
virtual bool update
(
const scalar dt,
cachedRandom& rndGen,
vector& pos1,
scalar& m1,
scalar& d1,
scalar& N1,
vector& U,
scalar& rho1,
scalar& T1,
scalarField& Y1,
const scalar sigma1,
const label celli,
const scalar voli,
vector& pos2,
scalar& m2,
scalar& d2,
scalar& N2,
vector& U2,
scalar& rho2,
scalar& T2,
scalarField& Y2,
const scalar sigma2,
const label cellj,
const scalar volj
) const;
// 1 is the larger drop and 2 is the smaller
bool collideSorted
(
const scalar dt,
cachedRandom& rndGen,
vector& pos1,
scalar& m1,
scalar& d1,
scalar& N1,
vector& U,
scalar& rho1,
scalar& T1,
scalarField& Y1,
const scalar sigma1,
const label celli,
const scalar voli,
vector& pos2,
scalar& m2,
scalar& d2,
scalar& N2,
vector& U2,
scalar& rho2,
scalar& T2,
scalarField& Y2,
const scalar sigma2,
const label cellj,
const scalar volj
) const;
};

323
src/lagrangian/spray/submodels/StochasticCollision/TrajectoryCollision/TrajectoryCollision.C
View File

@ -25,187 +25,96 @@ License
#include "TrajectoryCollision.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
template<class CloudType>
Foam::TrajectoryCollision<CloudType>::TrajectoryCollision
(
const dictionary& dict,
CloudType& owner
)
:
StochasticCollisionModel<CloudType>(dict, owner, typeName),
cSpace_(readScalar(this->coeffDict().lookup("cSpace"))),
cTime_(readScalar(this->coeffDict().lookup("cTime"))),
coalescence_(this->coeffDict().lookup("coalescence"))
{}
void Foam::TrajectoryCollision<CloudType>::collide(const scalar dt)
{
ORourkeCollision<CloudType>::collide(dt);
}
template<class CloudType>
Foam::TrajectoryCollision<CloudType>::TrajectoryCollision
(
const TrajectoryCollision<CloudType>& cm
)
:
StochasticCollisionModel<CloudType>(cm),
cSpace_(cm.cSpace_),
cTime_(cm.cTime_),
coalescence_(cm.coalescence_)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class CloudType>
Foam::TrajectoryCollision<CloudType>::~TrajectoryCollision()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class CloudType>
bool Foam::TrajectoryCollision<CloudType>::update
bool Foam::TrajectoryCollision<CloudType>::collideParcels
(
const scalar dt,
cachedRandom& rndGen,
vector& pos1,
parcelType& p1,
parcelType& p2,
scalar& m1,
scalar& d1,
scalar& N1,
vector& U1,
scalar& rho1,
scalar& T1,
scalarField& Y1,
const scalar sigma1,
const label celli,
const scalar voli,
vector& pos2,
scalar& m2,
scalar& d2,
scalar& N2,
vector& U2,
scalar& rho2,
scalar& T2,
scalarField& Y2,
const scalar sigma2,
const label cellj,
const scalar volj
) const
scalar& m2
)
{
bool coalescence = false;
vector vRel = U1 - U2;
const vector& pos1 = p1.position();
const vector& pos2 = p2.position();
vector p = pos2 - pos1;
scalar dist = mag(p);
const vector& U1 = p1.U();
const vector& U2 = p2.U();
scalar vAlign = vRel & (p/(dist + SMALL));
vector URel = U1 - U2;
vector d = pos2 - pos1;
scalar magd = mag(d);
scalar vAlign = URel & (d/(magd + ROOTVSMALL));
if (vAlign > 0)
{
const scalar d1 = p1.d();
const scalar d2 = p2.d();
scalar sumD = d1 + d2;
if (vAlign*dt > dist - 0.5*sumD)
if (vAlign*dt > magd - 0.5*sumD)
{
scalar v1Mag = mag(U1);
scalar v2Mag = mag(U2);
vector nv1 = U1/v1Mag;
vector nv2 = U2/v2Mag;
scalar magU1 = mag(U1) + ROOTVSMALL;
scalar magU2 = mag(U2) + ROOTVSMALL;
vector n1 = U1/magU1;
vector n2 = U2/magU2;
scalar v1v2 = nv1 & nv2;
scalar v1p = nv1 & p;
scalar v2p = nv2 & p;
scalar n1n2 = n1 & n2;
scalar n1d = n1 & d;
scalar n2d = n2 & d;
scalar det = 1.0 - v1v2*v1v2;
scalar det = 1.0 - sqr(n1n2);
scalar alpha = 1.0e+20;
scalar beta = 1.0e+20;
scalar alpha = GREAT;
scalar beta = GREAT;
if (mag(det) > 1.0e-4)
{
beta = -(v2p - v1v2*v1p)/det;
alpha = v1p + v1v2*beta;
beta = -(n2d - n1n2*n1d)/det;
alpha = n1d + n1n2*beta;
}
alpha /= v1Mag*dt;
beta /= v2Mag*dt;
alpha /= magU1*dt;
beta /= magU2*dt;
// is collision possible within this timestep
if ((alpha>0) && (alpha<1.0) && (beta>0) && (beta<1.0))
if ((alpha > 0) && (alpha < 1.0) && (beta > 0) && (beta < 1.0))
{
vector p1c = pos1 + alpha*U1*dt;
vector p2c = pos2 + beta*U2*dt;
scalar closestDist = mag(p1c-p2c);
scalar closestDist = mag(p1c - p2c);
scalar collProb =
pow(0.5*sumD/max(0.5*sumD, closestDist), cSpace_)
* exp(-cTime_*mag(alpha-beta));
*exp(-cTime_*mag(alpha - beta));
scalar xx = rndGen.sample01<scalar>();
scalar xx = this->owner().rndGen().template sample01<scalar>();
// collision occur
if ((xx < collProb) && (m1 > VSMALL) && (m2 > VSMALL))
// collision occurs
if (xx > collProb)
{
if (d1 > d2)
{
coalescence = collideSorted
(
dt,
rndGen,
pos1,
m1,
d1,
N1,
U1,
rho1,
T1,
Y1,
sigma1,
celli,
voli,
pos2,
m2,
d2,
N2,
U2,
rho2,
T2,
Y2,
sigma2,
cellj,
volj
);
coalescence = this->collideSorted(dt, p1, p2, m1, m2);
}
else
{
coalescence = collideSorted
(
dt,
rndGen,
pos2,
m2,
d2,
N2,
U2,
rho2,
T2,
Y2,
sigma2,
cellj,
volj,
pos1,
m1,
d1,
N1,
U1,
rho1,
T1,
Y1,
sigma1,
celli,
voli
);
coalescence = this->collideSorted(dt, p2, p1, m2, m1);
}
}
}
@ -216,128 +125,38 @@ bool Foam::TrajectoryCollision<CloudType>::update
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CloudType>
bool Foam::TrajectoryCollision<CloudType>::collideSorted
Foam::TrajectoryCollision<CloudType>::TrajectoryCollision
(
const scalar dt,
cachedRandom& rndGen,
vector& pos1,
scalar& m1,
scalar& d1,
scalar& N1,
vector& U1,
scalar& rho1,
scalar& T1,
scalarField& Y1,
const scalar sigma1,
const label celli,
const scalar voli,
vector& pos2,
scalar& m2,
scalar& d2,
scalar& N2,
vector& U2,
scalar& rho2,
scalar& T2,
scalarField& Y2,
const scalar sigma2,
const label cellj,
const scalar volj
) const
{
bool coalescence = false;
const dictionary& dict,
CloudType& owner
)
:
ORourkeCollision<CloudType>(dict, owner, typeName),
cSpace_(readScalar(this->coeffDict().lookup("cSpace"))),
cTime_(readScalar(this->coeffDict().lookup("cTime")))
{}
vector vRel = U1 - U2;
scalar mdMin = m2/N2;
template<class CloudType>
Foam::TrajectoryCollision<CloudType>::TrajectoryCollision
(
const TrajectoryCollision<CloudType>& cm
)
:
ORourkeCollision<CloudType>(cm),
cSpace_(cm.cSpace_),
cTime_(cm.cTime_)
{}
scalar mTot = m1 + m2;
scalar gamma = d1/max(d2, 1.0e-12);
scalar f = gamma*gamma*gamma + 2.7*gamma - 2.4*gamma*gamma;
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
vector momMax = m1*U1;
vector momMin = m2*U2;
// use mass-averaged temperature to calculate We number
scalar Tm = (T1*m1 + T2*m2)/mTot;
// and mass averaged fractions ...
//scalarField Yav((m1*Y1 + m2*Y2)/mTot;
// interpolate the averaged surface tension
scalar sigma = sigma1 + (sigma2 - sigma1)*(Tm - T1)/(T2 - T1);
sigma = max(1.0e-6, sigma);
scalar Vtot = m1/rho1 + m2/rho2;
scalar rho = mTot/Vtot;
scalar dMean = sqrt(d1*d2);
scalar WeColl = max(1.0e-12, 0.5*rho*magSqr(vRel)*dMean/sigma);
scalar coalesceProb = min(1.0, 2.4*f/WeColl);
scalar prob = rndGen.sample01<scalar>();
// Coalescence
if ( prob < coalesceProb && coalescence_)
{
coalescence = true;
// How 'many' of the droplets coalesce
scalar nProb = prob*N2/N1;
// Conservation of mass, momentum and energy
scalar m2Org = m2;
scalar dm = N1*nProb*mdMin;
m2 -= dm;
scalar V2 = constant::mathematical::pi*pow3(d2)/6.0;
N2 = m2/(rho2*V2);
scalar m1Org = m1;
m1 += dm;
T1 = (Tm*mTot - m2*T2)/m1;
U1 =(momMax + (1.0 - m2/m2Org)*momMin)/m1;
// update the liquid mass fractions
Y1 = (m1Org*Y1 + dm*Y2)/m1;
}
// Grazing collision (no coalescence)
else
{
scalar gf = sqrt(prob) - sqrt(coalesceProb);
scalar denom = 1.0 - sqrt(coalesceProb);
if (denom < 1.0e-5)
{
denom = 1.0;
}
gf /= denom;
// if gf negative, this means that coalescence is turned off
// and these parcels should have coalesced
gf = max(0.0, gf);
// gf -> 1 => v1p -> p1().U() ...
// gf -> 0 => v1p -> momentum/(m1 + m2)
vector mr = m1*U1 + m2*U2;
vector v1p = (mr + m2*gf*vRel)/(m1 + m2);
vector v2p = (mr - m1*gf*vRel)/(m1 + m2);
if (N1 < N2)
{
U1 = v1p;
U2 = (N1*v2p + (N2 - N1)*U2)/N2;
}
else
{
U1 = (N2*v1p + (N1 - N2)*U1)/N1;
U2 = v2p;
}
}
return coalescence;
}
template<class CloudType>
Foam::TrajectoryCollision<CloudType>::~TrajectoryCollision()
{}
// ************************************************************************* //

98
src/lagrangian/spray/submodels/StochasticCollision/TrajectoryCollision/TrajectoryCollision.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,35 +25,57 @@ Class
Foam::TrajectoryCollision
Description
Trajectory collision model by N. Nordin.
Trajectory collision model by N. Nordin, based on O'Rourke's collision
model
\*---------------------------------------------------------------------------*/
#ifndef TrajectoryCollision_H
#define TrajectoryCollision_H
#include "StochasticCollisionModel.H"
#include "ORourkeCollision.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class TrajectoryCollision Declaration
Class TrajectoryCollision Declaration
\*---------------------------------------------------------------------------*/
template<class CloudType>
class TrajectoryCollision
:
public StochasticCollisionModel<CloudType>
public ORourkeCollision<CloudType>
{
private:
protected:
// Private data
// Protected Data
//- Convenience typedef to the cloud's parcel type
typedef typename CloudType::parcelType parcelType;
//- Space coefficient
scalar cSpace_;
//- Time coefficient
scalar cTime_;
Switch coalescence_;
// Protected Member Functions
//- Main collision routine
virtual void collide(const scalar dt);
//- Collide parcels and return true if mass has changed
virtual bool collideParcels
(
const scalar dt,
parcelType& p1,
parcelType& p2,
scalar& m1,
scalar& m2
);
public:
@ -82,66 +104,6 @@ public:
//- Destructor
virtual ~TrajectoryCollision();
// Member Functions
virtual bool update
(
const scalar dt,
cachedRandom& rndGen,
vector& pos1,
scalar& m1,
scalar& d1,
scalar& N1,
vector& U,
scalar& rho1,
scalar& T1,
scalarField& Y1,
const scalar sigma1,
const label celli,
const scalar voli,
vector& pos2,
scalar& m2,
scalar& d2,
scalar& N2,
vector& U2,
scalar& rho2,
scalar& T2,
scalarField& Y2,
const scalar sigma2,
const label cellj,
const scalar volj
) const;
// 1 is the larger drop and 2 is the smaller
bool collideSorted
(
const scalar dt,
cachedRandom& rndGen,
vector& pos1,
scalar& m1,
scalar& d1,
scalar& N1,
vector& U,
scalar& rho1,
scalar& T1,
scalarField& Y1,
const scalar sigma1,
const label celli,
const scalar voli,
vector& pos2,
scalar& m2,
scalar& d2,
scalar& N2,
vector& U2,
scalar& rho2,
scalar& T2,
scalarField& Y2,
const scalar sigma2,
const label cellj,
const scalar volj
) const;
};