Removed redundant code

This commit is contained in:
Henry
2015-03-06 22:43:39 +00:00
parent 8599a55d40
commit 83e70c33b0
15 changed files with 0 additions and 1513 deletions

View File

@ -1,10 +0,0 @@
PARCELS=parcels
DERIVEDPARCELS=$(PARCELS)/derived
KINEMATICCOLLIDINGPARCEL=$(DERIVEDPARCELS)/basicKinematicCollidingParcel
$(KINEMATICCOLLIDINGPARCEL)/makeBasicKinematicCollidingParcelSubmodels.C
KINEMATICMPPICPARCEL=$(DERIVEDPARCELS)/basicKinematicMPPICParcel
$(KINEMATICMPPICPARCEL)/makeBasicKinematicMPPICParcelSubmodels.C
LIB = $(FOAM_LIBBIN)/liblagrangianTurbulentSubModels

View File

@ -1,48 +0,0 @@
EXE_INC = \
-I$(LIB_SRC)/lagrangian/basic/lnInclude \
-I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
-I$(LIB_SRC)/lagrangian/distributionModels/lnInclude \
-I$(LIB_SRC)/transportModels/compressible/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/properties/liquidProperties/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/properties/liquidMixtureProperties/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/properties/solidProperties/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/properties/solidMixtureProperties/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/SLGThermo/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/radiation/lnInclude \
-I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
-I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
-I$(LIB_SRC)/transportModels \
-I$(LIB_SRC)/regionModels/regionModel/lnInclude \
-I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
-I$(LIB_SRC)/dynamicFvMesh/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude
LIB_LIBS = \
-llagrangian \
-llagrangianIntermediate \
-ldistributionModels \
-lspecie \
-lcompressibleTransportModels \
-lfluidThermophysicalModels \
-lliquidProperties \
-lliquidMixtureProperties \
-lsolidProperties \
-lsolidMixtureProperties \
-lreactionThermophysicalModels \
-lSLGThermo \
-lradiationModels \
-lturbulenceModels \
-lincompressibleTurbulenceModels \
-lcompressibleTurbulenceModels \
-lincompressibleTransportModels \
-lregionModels \
-lsurfaceFilmModels \
-ldynamicFvMesh \
-lsampling \
-lfiniteVolume \
-lmeshTools

View File

@ -1,37 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2014 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 "basicKinematicCollidingCloud.H"
#include "makeParcelTurbulenceDispersionModels.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
makeParcelTurbulenceDispersionModels(basicKinematicCollidingCloud);
}
// ************************************************************************* //

View File

@ -1,37 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2014 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 "basicKinematicMPPICCloud.H"
#include "makeParcelTurbulenceDispersionModels.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
makeParcelTurbulenceDispersionModels(basicKinematicMPPICCloud);
}
// ************************************************************************* //

View File

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

View File

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

View File

@ -1,201 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "DispersionRASModel.H"
#include "demandDrivenData.H"
#include "turbulentFluidThermoModel.H"
// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
template<class CloudType>
Foam::tmp<Foam::volScalarField>
Foam::DispersionRASModel<CloudType>::kModel() const
{
const objectRegistry& obr = this->owner().mesh();
const word turbName =
IOobject::groupName
(
turbulenceModel::propertiesName,
this->owner().U().group()
);
if (obr.foundObject<turbulenceModel>(turbName))
{
const turbulenceModel& model =
obr.lookupObject<turbulenceModel>(turbName);
return model.k();
}
else
{
FatalErrorIn
(
"Foam::tmp<Foam::volScalarField>"
"Foam::DispersionRASModel<CloudType>::kModel() const"
)
<< "Turbulence model not found in mesh database" << nl
<< "Database objects include: " << obr.sortedToc()
<< abort(FatalError);
return tmp<volScalarField>(NULL);
}
}
template<class CloudType>
Foam::tmp<Foam::volScalarField>
Foam::DispersionRASModel<CloudType>::epsilonModel() const
{
const objectRegistry& obr = this->owner().mesh();
const word turbName =
IOobject::groupName
(
turbulenceModel::propertiesName,
this->owner().U().group()
);
if (obr.foundObject<turbulenceModel>(turbName))
{
const turbulenceModel& model =
obr.lookupObject<turbulenceModel>(turbName);
return model.epsilon();
}
else
{
FatalErrorIn
(
"Foam::tmp<Foam::volScalarField>"
"Foam::DispersionRASModel<CloudType>::epsilonModel() const"
)
<< "Turbulence model not found in mesh database" << nl
<< "Database objects include: " << obr.sortedToc()
<< abort(FatalError);
return tmp<volScalarField>(NULL);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CloudType>
Foam::DispersionRASModel<CloudType>::DispersionRASModel
(
const dictionary&,
CloudType& owner
)
:
DispersionModel<CloudType>(owner),
kPtr_(NULL),
ownK_(false),
epsilonPtr_(NULL),
ownEpsilon_(false)
{}
template<class CloudType>
Foam::DispersionRASModel<CloudType>::DispersionRASModel
(
const DispersionRASModel<CloudType>& dm
)
:
DispersionModel<CloudType>(dm),
kPtr_(dm.kPtr_),
ownK_(dm.ownK_),
epsilonPtr_(dm.epsilonPtr_),
ownEpsilon_(dm.ownEpsilon_)
{
dm.ownK_ = false;
dm.ownEpsilon_ = false;
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class CloudType>
Foam::DispersionRASModel<CloudType>::~DispersionRASModel()
{
cacheFields(false);
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class CloudType>
void Foam::DispersionRASModel<CloudType>::cacheFields(const bool store)
{
if (store)
{
tmp<volScalarField> tk = this->kModel();
if (tk.isTmp())
{
kPtr_ = tk.ptr();
ownK_ = true;
}
else
{
kPtr_ = tk.operator->();
ownK_ = false;
}
tmp<volScalarField> tepsilon = this->epsilonModel();
if (tepsilon.isTmp())
{
epsilonPtr_ = tepsilon.ptr();
ownEpsilon_ = true;
}
else
{
epsilonPtr_ = tepsilon.operator->();
ownEpsilon_ = false;
}
}
else
{
if (ownK_ && kPtr_)
{
deleteDemandDrivenData(kPtr_);
ownK_ = false;
}
if (ownEpsilon_ && epsilonPtr_)
{
deleteDemandDrivenData(epsilonPtr_);
ownEpsilon_ = false;
}
}
}
template<class CloudType>
void Foam::DispersionRASModel<CloudType>::write(Ostream& os) const
{
DispersionModel<CloudType>::write(os);
os.writeKeyword("ownK") << ownK_ << token::END_STATEMENT << endl;
os.writeKeyword("ownEpsilon") << ownEpsilon_ << token::END_STATEMENT
<< endl;
}
// ************************************************************************* //

View File

@ -1,135 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::DispersionRASModel
Description
Base class for particle dispersion models based on RAS turbulence.
\*---------------------------------------------------------------------------*/
#ifndef DispersionRASModel_H
#define DispersionRASModel_H
#include "DispersionModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class DispersionRASModel Declaration
\*---------------------------------------------------------------------------*/
template<class CloudType>
class DispersionRASModel
:
public DispersionModel<CloudType>
{
protected:
// Protected data
// Locally cached turbulence fields
//- Turbulence k
const volScalarField* kPtr_;
//- Take ownership of the k field
mutable bool ownK_;
//- Turbulence epsilon
const volScalarField* epsilonPtr_;
//- Take ownership of the epsilon field
mutable bool ownEpsilon_;
// Protected Functions
//- Return the k field from the turbulence model
tmp<volScalarField> kModel() const;
//- Return the epsilon field from the turbulence model
tmp<volScalarField> epsilonModel() const;
public:
//- Runtime type information
TypeName("dispersionRASModel");
// Constructors
//- Construct from components
DispersionRASModel(const dictionary& dict, CloudType& owner);
//- Construct copy
DispersionRASModel(const DispersionRASModel<CloudType>& dm);
//- Construct and return a clone
virtual autoPtr<DispersionModel<CloudType> > clone() const
{
return autoPtr<DispersionModel<CloudType> >
(
new DispersionRASModel<CloudType>(*this)
);
}
//- Destructor
virtual ~DispersionRASModel();
// Member Functions
//- Cache carrier fields
virtual void cacheFields(const bool store);
// I-O
//- Write
virtual void write(Ostream& os) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "DispersionRASModel.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

View File

@ -1,169 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "GradientDispersionRAS.H"
#include "demandDrivenData.H"
#include "fvcGrad.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CloudType>
Foam::GradientDispersionRAS<CloudType>::GradientDispersionRAS
(
const dictionary& dict,
CloudType& owner
)
:
DispersionRASModel<CloudType>(dict, owner),
gradkPtr_(NULL),
ownGradK_(false)
{}
template<class CloudType>
Foam::GradientDispersionRAS<CloudType>::GradientDispersionRAS
(
const GradientDispersionRAS<CloudType>& dm
)
:
DispersionRASModel<CloudType>(dm),
gradkPtr_(dm.gradkPtr_),
ownGradK_(dm.ownGradK_)
{
dm.ownGradK_ = false;
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class CloudType>
Foam::GradientDispersionRAS<CloudType>::~GradientDispersionRAS()
{
cacheFields(false);
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class CloudType>
void Foam::GradientDispersionRAS<CloudType>::cacheFields(const bool store)
{
DispersionRASModel<CloudType>::cacheFields(store);
if (store)
{
gradkPtr_ = fvc::grad(*this->kPtr_).ptr();
ownGradK_ = true;
}
else
{
if (ownGradK_)
{
deleteDemandDrivenData(gradkPtr_);
gradkPtr_ = NULL;
ownGradK_ = false;
}
}
}
template<class CloudType>
Foam::vector Foam::GradientDispersionRAS<CloudType>::update
(
const scalar dt,
const label cellI,
const vector& U,
const vector& Uc,
vector& UTurb,
scalar& tTurb
)
{
cachedRandom& rnd = this->owner().rndGen();
const scalar cps = 0.16432;
const scalar k = this->kPtr_->internalField()[cellI];
const scalar epsilon =
this->epsilonPtr_->internalField()[cellI] + ROOTVSMALL;
const vector& gradk = this->gradkPtr_->internalField()[cellI];
const scalar UrelMag = mag(U - Uc - UTurb);
const scalar tTurbLoc =
min(k/epsilon, cps*pow(k, 1.5)/epsilon/(UrelMag + SMALL));
// Parcel is perturbed by the turbulence
if (dt < tTurbLoc)
{
tTurb += dt;
if (tTurb > tTurbLoc)
{
tTurb = 0.0;
scalar sigma = sqrt(2.0*k/3.0);
vector dir = -gradk/(mag(gradk) + SMALL);
// Numerical Recipes... Ch. 7. Random Numbers...
scalar x1 = 0.0;
scalar x2 = 0.0;
scalar rsq = 10.0;
while ((rsq > 1.0) || (rsq == 0.0))
{
x1 = 2.0*rnd.sample01<scalar>() - 1.0;
x2 = 2.0*rnd.sample01<scalar>() - 1.0;
rsq = x1*x1 + x2*x2;
}
scalar fac = sqrt(-2.0*log(rsq)/rsq);
// In 2D calculations the -grad(k) is always
// away from the axis of symmetry
// This creates a 'hole' in the spray and to
// prevent this we let x1 be both negative/positive
if (this->owner().mesh().nSolutionD() == 2)
{
fac *= x1;
}
else
{
fac *= mag(x1);
}
UTurb = sigma*fac*dir;
}
}
else
{
tTurb = GREAT;
UTurb = vector::zero;
}
return Uc + UTurb;
}
// ************************************************************************* //

View File

@ -1,126 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::GradientDispersionRAS
Description
The velocity is perturbed in the direction of -grad(k), with a
Gaussian random number distribution with variance sigma.
where sigma is defined below
\*---------------------------------------------------------------------------*/
#ifndef GradientDispersionRAS_H
#define GradientDispersionRAS_H
#include "DispersionRASModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class GradientDispersionRAS Declaration
\*---------------------------------------------------------------------------*/
template<class CloudType>
class GradientDispersionRAS
:
public DispersionRASModel<CloudType>
{
protected:
// Protected data
// Locally cached turbulence fields
//- Gradient of k
const volVectorField* gradkPtr_;
//- Take ownership of the grad(k)
bool ownGradK_;
public:
//- Runtime type information
TypeName("gradientDispersionRAS");
// Constructors
//- Construct from components
GradientDispersionRAS(const dictionary& dict, CloudType& owner);
//- Construct copy
GradientDispersionRAS(const GradientDispersionRAS<CloudType>& dm);
//- Construct and return a clone
virtual autoPtr<DispersionModel<CloudType> > clone() const
{
return autoPtr<DispersionModel<CloudType> >
(
new GradientDispersionRAS<CloudType>(*this)
);
}
//- Destructor
virtual ~GradientDispersionRAS();
// Member Functions
//- Cache carrier fields
virtual void cacheFields(const bool store);
//- Update (disperse particles)
virtual vector update
(
const scalar dt,
const label cellI,
const vector& U,
const vector& Uc,
vector& UTurb,
scalar& tTurb
);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "GradientDispersionRAS.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

View File

@ -1,127 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "StochasticDispersionRAS.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CloudType>
Foam::StochasticDispersionRAS<CloudType>::StochasticDispersionRAS
(
const dictionary& dict,
CloudType& owner
)
:
DispersionRASModel<CloudType>(dict, owner)
{}
template<class CloudType>
Foam::StochasticDispersionRAS<CloudType>::StochasticDispersionRAS
(
const StochasticDispersionRAS<CloudType>& dm
)
:
DispersionRASModel<CloudType>(dm)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class CloudType>
Foam::StochasticDispersionRAS<CloudType>::~StochasticDispersionRAS()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class CloudType>
Foam::vector Foam::StochasticDispersionRAS<CloudType>::update
(
const scalar dt,
const label cellI,
const vector& U,
const vector& Uc,
vector& UTurb,
scalar& tTurb
)
{
cachedRandom& rnd = this->owner().rndGen();
const scalar cps = 0.16432;
const scalar k = this->kPtr_->internalField()[cellI];
const scalar epsilon =
this->epsilonPtr_->internalField()[cellI] + ROOTVSMALL;
const scalar UrelMag = mag(U - Uc - UTurb);
const scalar tTurbLoc =
min(k/epsilon, cps*pow(k, 1.5)/epsilon/(UrelMag + SMALL));
// Parcel is perturbed by the turbulence
if (dt < tTurbLoc)
{
tTurb += dt;
if (tTurb > tTurbLoc)
{
tTurb = 0.0;
scalar sigma = sqrt(2.0*k/3.0);
vector dir = 2.0*rnd.sample01<vector>() - vector::one;
dir /= mag(dir) + SMALL;
// Numerical Recipes... Ch. 7. Random Numbers...
scalar x1 = 0.0;
scalar x2 = 0.0;
scalar rsq = 10.0;
while ((rsq > 1.0) || (rsq == 0.0))
{
x1 = 2.0*rnd.sample01<scalar>() - 1.0;
x2 = 2.0*rnd.sample01<scalar>() - 1.0;
rsq = x1*x1 + x2*x2;
}
scalar fac = sqrt(-2.0*log(rsq)/rsq);
fac *= mag(x1);
UTurb = sigma*fac*dir;
}
}
else
{
tTurb = GREAT;
UTurb = vector::zero;
}
return Uc + UTurb;
}
// ************************************************************************* //

View File

@ -1,110 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::StochasticDispersionRAS
Description
The velocity is perturbed in random direction, with a
Gaussian random number distribution with variance sigma.
where sigma is defined below
\*---------------------------------------------------------------------------*/
#ifndef StochasticDispersionRAS_H
#define StochasticDispersionRAS_H
#include "DispersionRASModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class StochasticDispersionRAS Declaration
\*---------------------------------------------------------------------------*/
template<class CloudType>
class StochasticDispersionRAS
:
public DispersionRASModel<CloudType>
{
public:
//- Runtime type information
TypeName("stochasticDispersionRAS");
// Constructors
//- Construct from components
StochasticDispersionRAS(const dictionary& dict, CloudType& owner);
//- Construct copy
StochasticDispersionRAS(const StochasticDispersionRAS<CloudType>& dm);
//- Construct and return a clone
virtual autoPtr<DispersionModel<CloudType> > clone() const
{
return autoPtr<DispersionModel<CloudType> >
(
new StochasticDispersionRAS<CloudType>(*this)
);
}
//- Destructor
virtual ~StochasticDispersionRAS();
// Member Functions
//- Update (disperse particles)
virtual vector update
(
const scalar dt,
const label cellI,
const vector& U,
const vector& Uc,
vector& UTurb,
scalar& tTurb
);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "StochasticDispersionRAS.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

View File

@ -1,214 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "BrownianMotionForce.H"
#include "mathematicalConstants.H"
#include "demandDrivenData.H"
#include "incompressible/turbulenceModel/turbulenceModel.H"
#include "compressible/turbulenceModel/turbulenceModel.H"
using namespace Foam::constant;
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
template<class CloudType>
Foam::scalar Foam::BrownianMotionForce<CloudType>::erfInv(const scalar y) const
{
const scalar a = 0.147;
scalar k = 2.0/(mathematical::pi*a) + 0.5*log(1.0 - y*y);
scalar h = log(1.0 - y*y)/a;
scalar x = sqrt(-k + sqrt(k*k - h));
if (y < 0.0)
{
return -x;
}
else
{
return x;
}
}
template<class CloudType>
Foam::tmp<Foam::volScalarField>
Foam::BrownianMotionForce<CloudType>::kModel() const
{
const objectRegistry& obr = this->owner().mesh();
const word turbName = "turbulenceModel";
if (obr.foundObject<compressible::turbulenceModel>(turbName))
{
const compressible::turbulenceModel& model =
obr.lookupObject<compressible::turbulenceModel>(turbName);
return model.k();
}
else if (obr.foundObject<incompressible::turbulenceModel>(turbName))
{
const incompressible::turbulenceModel& model =
obr.lookupObject<incompressible::turbulenceModel>(turbName);
return model.k();
}
else
{
FatalErrorIn
(
"Foam::tmp<Foam::volScalarField>"
"Foam::BrownianMotionForce<CloudType>::kModel() const"
)
<< "Turbulence model not found in mesh database" << nl
<< "Database objects include: " << obr.sortedToc()
<< abort(FatalError);
return tmp<volScalarField>(NULL);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CloudType>
Foam::BrownianMotionForce<CloudType>::BrownianMotionForce
(
CloudType& owner,
const fvMesh& mesh,
const dictionary& dict
)
:
ParticleForce<CloudType>(owner, mesh, dict, typeName, true),
rndGen_(owner.rndGen()),
lambda_(readScalar(this->coeffs().lookup("lambda"))),
turbulence_(readBool(this->coeffs().lookup("turbulence"))),
kPtr_(NULL),
ownK_(false)
{}
template<class CloudType>
Foam::BrownianMotionForce<CloudType>::BrownianMotionForce
(
const BrownianMotionForce& bmf
)
:
ParticleForce<CloudType>(bmf),
rndGen_(bmf.rndGen_),
lambda_(bmf.lambda_),
turbulence_(bmf.turbulence_),
kPtr_(NULL),
ownK_(false)
{}
// * * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * //
template<class CloudType>
Foam::BrownianMotionForce<CloudType>::~BrownianMotionForce()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class CloudType>
void Foam::BrownianMotionForce<CloudType>::cacheFields(const bool store)
{
if (turbulence_)
{
if (store)
{
tmp<volScalarField> tk = kModel();
if (tk.isTmp())
{
kPtr_ = tk.ptr();
ownK_ = true;
}
else
{
kPtr_ = tk.operator->();
ownK_ = false;
}
}
else
{
if (ownK_ && kPtr_)
{
deleteDemandDrivenData(kPtr_);
ownK_ = false;
}
}
}
}
template<class CloudType>
Foam::forceSuSp Foam::BrownianMotionForce<CloudType>::calcCoupled
(
const typename CloudType::parcelType& p,
const scalar dt,
const scalar mass,
const scalar Re,
const scalar muc
) const
{
forceSuSp value(vector::zero, 0.0);
const scalar dp = p.d();
const scalar Tc = p.Tc();
const scalar eta = rndGen_.sample01<scalar>();
const scalar alpha = 2.0*lambda_/dp;
const scalar cc = 1.0 + alpha*(1.257 + 0.4*exp(-1.1/alpha));
const scalar sigma = physicoChemical::sigma.value();
scalar f = 0.0;
if (turbulence_)
{
const label cellI = p.cell();
const volScalarField& k = *kPtr_;
const scalar kc = k[cellI];
const scalar Dp = sigma*Tc*cc/(3*mathematical::pi*muc*dp);
f = eta/mass*sqrt(2.0*sqr(kc)*sqr(Tc)/(Dp*dt));
}
else
{
const scalar rhoRatio = p.rho()/p.rhoc();
const scalar s0 =
216*muc*sigma*Tc/(sqr(mathematical::pi)*pow5(dp)*(rhoRatio)*cc);
f = eta*sqrt(mathematical::pi*s0/dt);
}
const scalar sqrt2 = sqrt(2.0);
for (label i = 0; i < 3; i++)
{
const scalar x = rndGen_.sample01<scalar>();
const scalar eta = sqrt2*erfInv(2*x - 1.0);
value.Su()[i] = mass*f*eta;
}
return value;
}
// ************************************************************************* //

View File

@ -1,160 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::BrownianMotionForce
Description
Calculates particle Brownian motion force
SourceFiles
BrownianMotionForceI.H
BrownianMotionForce.C
\*---------------------------------------------------------------------------*/
#ifndef BrownianMotionForce_H
#define BrownianMotionForce_H
#include "ParticleForce.H"
#include "cachedRandom.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class BrownianMotionForce Declaration
\*---------------------------------------------------------------------------*/
template<class CloudType>
class BrownianMotionForce
:
public ParticleForce<CloudType>
{
// Private data
//- Reference to the cloud random number generator
cachedRandom& rndGen_;
//- Molecular free path length [m]
const scalar lambda_;
//- Turbulence flag
bool turbulence_;
//- Pointer to the turbulence kinetic energy field
const volScalarField* kPtr_;
//- Flag that indicates ownership of turbulence k field
bool ownK_;
// Private Member Functions
//- Inverse erf for Gaussian distribution
scalar erfInv(const scalar y) const;
//- Return the k field from the turbulence model
tmp<volScalarField> kModel() const;
public:
//- Runtime type information
TypeName("BrownianMotion");
// Constructors
//- Construct from mesh
BrownianMotionForce
(
CloudType& owner,
const fvMesh& mesh,
const dictionary& dict
);
//- Construct copy
BrownianMotionForce(const BrownianMotionForce& bmf);
//- Construct and return a clone
virtual autoPtr<ParticleForce<CloudType> > clone() const
{
return autoPtr<ParticleForce<CloudType> >
(
new BrownianMotionForce<CloudType>(*this)
);
}
//- Destructor
virtual ~BrownianMotionForce();
// Member Functions
// Access
//- Return const access to the molecular free path length [m]
inline scalar lambda() const;
//- Return const access to the turbulence flag
inline bool turbulence() const;
// Evaluation
//- Cache fields
virtual void cacheFields(const bool store);
//- Calculate the non-coupled force
virtual forceSuSp calcCoupled
(
const typename CloudType::parcelType& p,
const scalar dt,
const scalar mass,
const scalar Re,
const scalar muc
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "BrownianMotionForceI.H"
#ifdef NoRepository
#include "BrownianMotionForce.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

View File

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