zhyang-dev/openfoam
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of /home/dm4/OpenFOAM/OpenFOAM-dev

Browse Source
This commit is contained in:
mattijs
2013-08-02 16:50:14 +01:00
parent 0f091f25a0 82f8a3c5ad
commit 1fa5828f4e
102 changed files with 4764 additions and 366 deletions
Download Patch File Download Diff File Expand all files Collapse all files

398
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/phaseIncompressibleTurbulenceModels/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.C
View File

@ -129,7 +129,12 @@ Foam::kineticTheoryModel::kineticTheoryModel
U.mesh(),
dimensionedScalar("zero", dimensionSet(0, 2, -1, 0, 0), 0.0)
)
{}
{
if (type == typeName)
{
this->printCoeffs(type);
}
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
@ -140,6 +145,199 @@ Foam::kineticTheoryModel::~kineticTheoryModel()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool Foam::kineticTheoryModel::read()
{
if
(
eddyViscosity
<
RASModel<PhaseIncompressibleTurbulenceModel<phaseModel> >
>::read()
)
{
this->coeffDict().lookup("equilibrium") >> equilibrium_;
e_.readIfPresent(this->coeffDict());
alphaMax_.readIfPresent(this->coeffDict());
alphaMinFriction_.readIfPresent(this->coeffDict());
viscosityModel_->read();
conductivityModel_->read();
radialModel_->read();
granularPressureModel_->read();
frictionalStressModel_->read();
return true;
}
else
{
return false;
}
}
Foam::tmp<Foam::volScalarField> Foam::kineticTheoryModel::k() const
{
notImplemented("kineticTheoryModel::k()");
return nut_;
}
Foam::tmp<Foam::volScalarField> Foam::kineticTheoryModel::epsilon() const
{
notImplemented("kineticTheoryModel::epsilon()");
return nut_;
}
Foam::tmp<Foam::volSymmTensorField> Foam::kineticTheoryModel::R() const
{
return tmp<volSymmTensorField>
(
new volSymmTensorField
(
IOobject
(
IOobject::groupName("R", this->U_.group()),
this->runTime_.timeName(),
this->mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- (this->nut_)*dev(twoSymm(fvc::grad(this->U_)))
- (lambda_*fvc::div(this->phi_))*symmTensor::I
)
);
}
/*
Foam::tmp<Foam::volScalarField> Foam::kineticTheoryModel::pp() const
{
// Particle pressure coefficient
// Coefficient in front of Theta (Eq. 3.22, p. 45)
volScalarField PsCoeff
(
granularPressureModel_->granularPressureCoeff
(
alpha,
gs0,
rho,
e_
)
);
// Frictional pressure
volScalarField pf
(
frictionalStressModel_->frictionalPressure
(
alpha,
alphaMinFriction_,
alphaMax_
)
);
// Return total particle pressure
return PsCoeff*Theta_ + pf;
}
*/
Foam::tmp<Foam::volScalarField> Foam::kineticTheoryModel::pPrime() const
{
// Local references
const volScalarField& alpha = this->alpha_;
const volScalarField& rho = phase_.rho();
return
(
Theta_
*granularPressureModel_->granularPressureCoeffPrime
(
alpha,
radialModel_->g0(alpha, alphaMinFriction_, alphaMax_),
radialModel_->g0prime(alpha, alphaMinFriction_, alphaMax_),
rho,
e_
)
+ frictionalStressModel_->frictionalPressurePrime
(
alpha,
alphaMinFriction_,
alphaMax_
)
);
}
Foam::tmp<Foam::surfaceScalarField> Foam::kineticTheoryModel::pPrimef() const
{
// Local references
const volScalarField& alpha = this->alpha_;
const volScalarField& rho = phase_.rho();
return fvc::interpolate
(
Theta_
*granularPressureModel_->granularPressureCoeffPrime
(
alpha,
radialModel_->g0(alpha, alphaMinFriction_, alphaMax_),
radialModel_->g0prime(alpha, alphaMinFriction_, alphaMax_),
rho,
e_
)
+ frictionalStressModel_->frictionalPressurePrime
(
alpha,
alphaMinFriction_,
alphaMax_
)
);
}
Foam::tmp<Foam::volSymmTensorField> Foam::kineticTheoryModel::devRhoReff() const
{
return tmp<volSymmTensorField>
(
new volSymmTensorField
(
IOobject
(
IOobject::groupName("devRhoReff", this->U_.group()),
this->runTime_.timeName(),
this->mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- (this->rho_*this->nut_)
*dev(twoSymm(fvc::grad(this->U_)))
- ((this->rho_*lambda_)*fvc::div(this->phi_))*symmTensor::I
)
);
}
Foam::tmp<Foam::fvVectorMatrix> Foam::kineticTheoryModel::divDevRhoReff
(
volVectorField& U
) const
{
return
(
- fvm::laplacian(this->rho_*this->nut_, U)
- fvc::div
(
(this->rho_*this->nut_)*dev2(T(fvc::grad(U)))
+ ((this->rho_*lambda_)*fvc::div(this->phi_))
*dimensioned<symmTensor>("I", dimless, symmTensor::I)
)
);
}
void Foam::kineticTheoryModel::correct()
{
// Local references
@ -343,202 +541,4 @@ void Foam::kineticTheoryModel::correct()
}
}
/*
Foam::tmp<Foam::volScalarField> Foam::kineticTheoryModel::pp() const
{
// Particle pressure coefficient
// Coefficient in front of Theta (Eq. 3.22, p. 45)
volScalarField PsCoeff
(
granularPressureModel_->granularPressureCoeff
(
alpha,
gs0,
rho,
e_
)
);
// Frictional pressure
volScalarField pf
(
frictionalStressModel_->frictionalPressure
(
alpha,
alphaMinFriction_,
alphaMax_
)
);
// Return total particle pressure
return PsCoeff*Theta_ + pf;
}
*/
Foam::tmp<Foam::volScalarField> Foam::kineticTheoryModel::pPrime() const
{
// Local references
const volScalarField& alpha = this->alpha_;
const volScalarField& rho = phase_.rho();
return
(
Theta_
*granularPressureModel_->granularPressureCoeffPrime
(
alpha,
radialModel_->g0(alpha, alphaMinFriction_, alphaMax_),
radialModel_->g0prime(alpha, alphaMinFriction_, alphaMax_),
rho,
e_
)
+ frictionalStressModel_->frictionalPressurePrime
(
alpha,
alphaMinFriction_,
alphaMax_
)
);
}
Foam::tmp<Foam::surfaceScalarField> Foam::kineticTheoryModel::pPrimef() const
{
// Local references
const volScalarField& alpha = this->alpha_;
const volScalarField& rho = phase_.rho();
return fvc::interpolate
(
Theta_
*granularPressureModel_->granularPressureCoeffPrime
(
alpha,
radialModel_->g0(alpha, alphaMinFriction_, alphaMax_),
radialModel_->g0prime(alpha, alphaMinFriction_, alphaMax_),
rho,
e_
)
+ frictionalStressModel_->frictionalPressurePrime
(
alpha,
alphaMinFriction_,
alphaMax_
)
);
}
void Foam::kineticTheoryModel::correctNut()
{}
Foam::tmp<Foam::volScalarField> Foam::kineticTheoryModel::k() const
{
notImplemented("kineticTheoryModel::k()");
return nut_;
}
Foam::tmp<Foam::volScalarField> Foam::kineticTheoryModel::epsilon() const
{
notImplemented("kineticTheoryModel::epsilon()");
return nut_;
}
Foam::tmp<Foam::volSymmTensorField> Foam::kineticTheoryModel::R() const
{
return tmp<volSymmTensorField>
(
new volSymmTensorField
(
IOobject
(
IOobject::groupName("R", this->U_.group()),
this->runTime_.timeName(),
this->mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- (this->nut_)*dev(twoSymm(fvc::grad(this->U_)))
- (lambda_*fvc::div(this->phi_))*symmTensor::I
)
);
}
Foam::tmp<Foam::volSymmTensorField> Foam::kineticTheoryModel::devRhoReff() const
{
return tmp<volSymmTensorField>
(
new volSymmTensorField
(
IOobject
(
IOobject::groupName("devRhoReff", this->U_.group()),
this->runTime_.timeName(),
this->mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- (this->rho_*this->nut_)
*dev(twoSymm(fvc::grad(this->U_)))
- ((this->rho_*lambda_)*fvc::div(this->phi_))*symmTensor::I
)
);
}
Foam::tmp<Foam::fvVectorMatrix> Foam::kineticTheoryModel::divDevRhoReff
(
volVectorField& U
) const
{
return
(
- fvm::laplacian(this->rho_*this->nut_, U)
- fvc::div
(
(this->rho_*this->nut_)*dev2(T(fvc::grad(U)))
+ ((this->rho_*lambda_)*fvc::div(this->phi_))
*dimensioned<symmTensor>("I", dimless, symmTensor::I)
)
);
}
bool Foam::kineticTheoryModel::read()
{
if
(
eddyViscosity
<
RASModel<PhaseIncompressibleTurbulenceModel<phaseModel> >
>::read()
)
{
this->coeffDict().lookup("equilibrium") >> equilibrium_;
e_.readIfPresent(this->coeffDict());
alphaMax_.readIfPresent(this->coeffDict());
alphaMinFriction_.readIfPresent(this->coeffDict());
viscosityModel_->read();
conductivityModel_->read();
radialModel_->read();
granularPressureModel_->read();
frictionalStressModel_->read();
return true;
}
else
{
return false;
}
}
// ************************************************************************* //

27
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/phaseIncompressibleTurbulenceModels/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.H
View File

@ -25,6 +25,17 @@ Class
Foam::kineticTheoryModel
Description
Kinetic theory particle phase RAS model
Reference:
\verbatim
"Derivation, implementation, and validation of computer simulation
models for gas-solid fluidized beds",
B.G.M. van Wachem,
Ph.D. Thesis, Delft University of Technology, Amsterdam, 2000.
\endverbatim
There are no default model coefficients.
SourceFiles
kineticTheoryModel.C
@ -118,6 +129,9 @@ class kineticTheoryModel
// Private Member Functions
void correctNut()
{}
//- Disallow default bitwise copy construct
kineticTheoryModel(const kineticTheoryModel&);
@ -125,13 +139,6 @@ class kineticTheoryModel
void operator=(const kineticTheoryModel&);
protected:
// Protected member functions
virtual void correctNut();
public:
//- Runtime type information
@ -160,6 +167,9 @@ public:
// Member Functions
//- Re-read model coefficients if they have changed
virtual bool read();
//- Return the effective viscosity
virtual tmp<volScalarField> nuEff() const
{
@ -197,9 +207,6 @@ public:
//- Solve the kinetic theory equations and correct the viscosity
virtual void correct();
//- Re-read model coefficients if they have changed
virtual bool read();
};

48
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/phaseIncompressibleTurbulenceModels/phaseIncompressibleTurbulenceModels.C
View File

@ -182,7 +182,10 @@ namespace Foam
#include "LESModel.H"
#include "Smagorinsky.H"
#include "SmagorinskyZhang.H"
#include "kEqn.H"
#include "NicenoKEqn.H"
#include "continuousGasKEqn.H"
namespace Foam
{
@ -215,6 +218,21 @@ namespace Foam
);
}
namespace LESModels
{
typedef SmagorinskyZhang<incompressibleTransportTurbulenceModel>
incompressibleSmagorinskyZhang;
defineNamedTemplateTypeNameAndDebug(incompressibleSmagorinskyZhang, 0);
addToRunTimeSelectionTable
(
incompressibleLESModel,
incompressibleSmagorinskyZhang,
dictionary
);
}
namespace LESModels
{
typedef kEqn<incompressibleTransportTurbulenceModel>
@ -229,6 +247,36 @@ namespace Foam
dictionary
);
}
namespace LESModels
{
typedef NicenoKEqn<incompressibleTransportTurbulenceModel>
incompressibleNicenoKEqn;
defineNamedTemplateTypeNameAndDebug(incompressibleNicenoKEqn, 0);
addToRunTimeSelectionTable
(
incompressibleLESModel,
incompressibleNicenoKEqn,
dictionary
);
}
namespace LESModels
{
typedef continuousGasKEqn<incompressibleTransportTurbulenceModel>
incompressiblecontinuousGasKEqn;
defineNamedTemplateTypeNameAndDebug(incompressiblecontinuousGasKEqn, 0);
addToRunTimeSelectionTable
(
incompressibleLESModel,
incompressiblecontinuousGasKEqn,
dictionary
);
}
}

99
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/phaseIncompressibleTurbulenceModels/phasePressureModel/phasePressureModel.C
View File

@ -65,6 +65,11 @@ Foam::phasePressureModel::phasePressureModel
)
{
this->nut_ == dimensionedScalar("zero", this->nut_.dimensions(), 0.0);
if (type == typeName)
{
this->printCoeffs(type);
}
}
@ -76,35 +81,27 @@ Foam::phasePressureModel::~phasePressureModel()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::phasePressureModel::correct()
{}
void Foam::phasePressureModel::correctNut()
{}
Foam::tmp<Foam::volScalarField> Foam::phasePressureModel::pPrime() const
bool Foam::phasePressureModel::read()
{
return
g0_
*min
(
exp(preAlphaExp_*(this->alpha_ - alphaMax_)),
expMax_
);
}
if
(
eddyViscosity
<
RASModel<PhaseIncompressibleTurbulenceModel<phaseModel> >
>::read()
)
{
this->coeffDict().lookup("alphaMax") >> alphaMax_;
this->coeffDict().lookup("preAlphaExp") >> preAlphaExp_;
this->coeffDict().lookup("expMax") >> expMax_;
g0_.readIfPresent(this->coeffDict());
Foam::tmp<Foam::surfaceScalarField> Foam::phasePressureModel::pPrimef() const
{
return
g0_
*min
(
exp(preAlphaExp_*(fvc::interpolate(this->alpha_) - alphaMax_)),
expMax_
);
return true;
}
else
{
return false;
}
}
@ -148,6 +145,30 @@ Foam::tmp<Foam::volSymmTensorField> Foam::phasePressureModel::R() const
}
Foam::tmp<Foam::volScalarField> Foam::phasePressureModel::pPrime() const
{
return
g0_
*min
(
exp(preAlphaExp_*(this->alpha_ - alphaMax_)),
expMax_
);
}
Foam::tmp<Foam::surfaceScalarField> Foam::phasePressureModel::pPrimef() const
{
return
g0_
*min
(
exp(preAlphaExp_*(fvc::interpolate(this->alpha_) - alphaMax_)),
expMax_
);
}
Foam::tmp<Foam::volSymmTensorField> Foam::phasePressureModel::devRhoReff() const
{
return tmp<volSymmTensorField>
@ -190,28 +211,8 @@ Foam::tmp<Foam::fvVectorMatrix> Foam::phasePressureModel::divDevRhoReff
}
bool Foam::phasePressureModel::read()
{
if
(
eddyViscosity
<
RASModel<PhaseIncompressibleTurbulenceModel<phaseModel> >
>::read()
)
{
this->coeffDict().lookup("alphaMax") >> alphaMax_;
this->coeffDict().lookup("preAlphaExp") >> preAlphaExp_;
this->coeffDict().lookup("expMax") >> expMax_;
g0_.readIfPresent(this->coeffDict());
return true;
}
else
{
return false;
}
}
void Foam::phasePressureModel::correct()
{}
// ************************************************************************* //

34
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/phaseIncompressibleTurbulenceModels/phasePressureModel/phasePressureModel.H
View File

@ -25,6 +25,23 @@ Class
Foam::phasePressureModel
Description
Particle-particle phase-pressure RAS model
The derivative of the phase-pressure with respect to the phase-fraction
is evaluated as
g0*min(exp(preAlphaExp*(alpha - alphaMax)), expMax)
The default model coefficients correspond to the following:
\verbatim
phasePressureCoeffs
{
preAlphaExp 500;
expMax 1000;
alphaMax 0.62;
g0 1000;
}
\endverbatim
SourceFiles
phasePressureModel.C
@ -39,7 +56,6 @@ SourceFiles
#include "PhaseIncompressibleTurbulenceModel.H"
#include "phaseModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
@ -80,6 +96,9 @@ class phasePressureModel
// Private Member Functions
void correctNut()
{}
//- Disallow default bitwise copy construct
phasePressureModel(const phasePressureModel&);
@ -87,13 +106,6 @@ class phasePressureModel
void operator=(const phasePressureModel&);
protected:
// Protected member functions
virtual void correctNut();
public:
//- Runtime type information
@ -122,6 +134,9 @@ public:
// Member Functions
//- Re-read model coefficients if they have changed
virtual bool read();
//- Return the effective viscosity
virtual tmp<volScalarField> nuEff() const
{
@ -159,9 +174,6 @@ public:
//- Solve the kinetic theory equations and correct the viscosity
virtual void correct();
//- Re-read model coefficients if they have changed
virtual bool read();
};

2
src/TurbulenceModels/compressible/compressibleTurbulenceModel.H
View File

@ -96,7 +96,7 @@ public:
{}
// Member Functions
// Member functions
//- Return the effective stress tensor including the laminar stress
virtual tmp<volSymmTensorField> devRhoReff() const = 0;

237
src/TurbulenceModels/phaseIncompressible/LES/Niceno/NicenoKEqn.C Normal file
View File

@ -0,0 +1,237 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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 "NicenoKEqn.H"
#include "addToRunTimeSelectionTable.H"
#include "twoPhaseSystem.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace LESModels
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class BasicTurbulenceModel>
NicenoKEqn<BasicTurbulenceModel>::NicenoKEqn
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName,
const word& type
)
:
kEqn<BasicTurbulenceModel>
(
alpha,
rho,
U,
alphaPhi,
phi,
transport,
propertiesName,
type
),
gasTurbulencePtr_(NULL),
alphaInversion_
(
dimensioned<scalar>::lookupOrAddToDict
(
"alphaInversion",
this->coeffDict_,
0.3
)
),
Cp_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cp",
this->coeffDict_,
this->Ck_.value()
)
),
Cmub_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cmub",
this->coeffDict_,
0.6
)
)
{
if (type == typeName)
{
correctNut();
this->printCoeffs(type);
}
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class BasicTurbulenceModel>
bool NicenoKEqn<BasicTurbulenceModel>::read()
{
if (kEqn<BasicTurbulenceModel>::read())
{
alphaInversion_.readIfPresent(this->coeffDict());
Cp_.readIfPresent(this->coeffDict());
Cmub_.readIfPresent(this->coeffDict());
return true;
}
else
{
return false;
}
}
template<class BasicTurbulenceModel>
const PhaseIncompressibleTurbulenceModel
<
typename BasicTurbulenceModel::transportModel
>&
NicenoKEqn<BasicTurbulenceModel>::gasTurbulence() const
{
if (!gasTurbulencePtr_)
{
const volVectorField& U = this->U_;
const transportModel& liquid = this->transport();
const twoPhaseSystem& fluid = liquid.fluid();
const transportModel& gas = fluid.otherPhase(liquid);
gasTurbulencePtr_ =
&U.db()
.lookupObject<PhaseIncompressibleTurbulenceModel<transportModel> >
(
IOobject::groupName
(
turbulenceModel::propertiesName,
gas.name()
)
);
}
return *gasTurbulencePtr_;
}
template<class BasicTurbulenceModel>
void NicenoKEqn<BasicTurbulenceModel>::correctNut()
{
const PhaseIncompressibleTurbulenceModel<transportModel>& gasTurbulence =
this->gasTurbulence();
this->nut_ =
this->Ck_*sqrt(this->k_)*this->delta()
+ Cmub_*gasTurbulence.transport().d()*gasTurbulence.alpha()
*(mag(this->U_ - gasTurbulence.U()));
this->nut_.correctBoundaryConditions();
}
template<class BasicTurbulenceModel>
tmp<volScalarField> NicenoKEqn<BasicTurbulenceModel>::bubbleG() const
{
const PhaseIncompressibleTurbulenceModel<transportModel>& gasTurbulence =
this->gasTurbulence();
const transportModel& liquid = this->transport();
const twoPhaseSystem& fluid = liquid.fluid();
const transportModel& gas = fluid.otherPhase(liquid);
volScalarField magUr(mag(this->U_ - gasTurbulence.U()));
tmp<volScalarField> bubbleG
(
Cp_*gas*sqr(magUr)*fluid.drag(gas).K(magUr)/liquid.rho()
);
return bubbleG;
}
template<class BasicTurbulenceModel>
tmp<volScalarField>
NicenoKEqn<BasicTurbulenceModel>::phaseTransferCoeff() const
{
const volVectorField& U = this->U_;
const alphaField& alpha = this->alpha_;
const rhoField& rho = this->rho_;
const turbulenceModel& gasTurbulence = this->gasTurbulence();
return
(
max(alphaInversion_ - alpha, 0.0)
*rho
*min
(
this->Ce_*sqrt(gasTurbulence.k())/this->delta(),
1.0/U.time().deltaT()
)
);
}
template<class BasicTurbulenceModel>
tmp<fvScalarMatrix> NicenoKEqn<BasicTurbulenceModel>::kSource() const
{
const alphaField& alpha = this->alpha_;
const rhoField& rho = this->rho_;
const PhaseIncompressibleTurbulenceModel<transportModel>& gasTurbulence =
this->gasTurbulence();
const volScalarField phaseTransferCoeff(this->phaseTransferCoeff());
return
alpha*rho*bubbleG()
+ phaseTransferCoeff*gasTurbulence.k()
- fvm::Sp(phaseTransferCoeff, this->k_);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace LESModels
} // End namespace Foam
// ************************************************************************* //

177
src/TurbulenceModels/phaseIncompressible/LES/Niceno/NicenoKEqn.H Normal file
View File

@ -0,0 +1,177 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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::LESModels::NicenoKEqn
Group
grpLESTurbulence
Description
One-equation SGS model for the continuous phase in a two-phase system
including bubble-generated turbulence.
Reference:
\verbatim
"One-equation sub-grid scale (SGS) modelling for Euler-Euler
large eddy simulation (EELES) of dispersed bubbly flow"
B. Niceno,
M.T. Dhotre,
N.G. Dee
Chemical Engineering Science 63 (2008) pp. 3923-3931.
\endverbatim
The default model coefficients correspond to the following:
\verbatim
NicenoKEqnCoeffs
{
Ck 0.094;
Ce 1.048;
alphaInversion 0.3;
Cp Ck;
Cmub 0.6;
}
\endverbatim
SourceFiles
NicenoKEqn.C
\*---------------------------------------------------------------------------*/
#ifndef NicenoKEqn_H
#define NicenoKEqn_H
#include "kEqn.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace LESModels
{
/*---------------------------------------------------------------------------*\
Class NicenoKEqn Declaration
\*---------------------------------------------------------------------------*/
template<class BasicTurbulenceModel>
class NicenoKEqn
:
public kEqn<BasicTurbulenceModel>
{
// Private data
mutable const PhaseIncompressibleTurbulenceModel
<
typename BasicTurbulenceModel::transportModel
> *gasTurbulencePtr_;
// Private Member Functions
//- Return the turbulence model for the gas phase
const PhaseIncompressibleTurbulenceModel
<
typename BasicTurbulenceModel::transportModel
>&
gasTurbulence() const;
// Disallow default bitwise copy construct and assignment
NicenoKEqn(const NicenoKEqn&);
NicenoKEqn& operator=(const NicenoKEqn&);
protected:
// Protected data
// Model coefficients
dimensionedScalar alphaInversion_;
dimensionedScalar Cp_;
dimensionedScalar Cmub_;
// Protected Member Functions
virtual void correctNut();
tmp<volScalarField> bubbleG() const;
tmp<volScalarField> phaseTransferCoeff() const;
virtual tmp<fvScalarMatrix> kSource() const;
public:
typedef typename BasicTurbulenceModel::alphaField alphaField;
typedef typename BasicTurbulenceModel::rhoField rhoField;
typedef typename BasicTurbulenceModel::transportModel transportModel;
//- Runtime type information
TypeName("NicenoKEqn");
// Constructors
//- Construct from components
NicenoKEqn
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName = turbulenceModel::propertiesName,
const word& type = typeName
);
//- Destructor
virtual ~NicenoKEqn()
{}
// Member Functions
//- Read model coefficients if they have changed
virtual bool read();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace LESModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "NicenoKEqn.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

153
src/TurbulenceModels/phaseIncompressible/LES/SmagorinskyZhang/SmagorinskyZhang.C Normal file
View File

@ -0,0 +1,153 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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 "SmagorinskyZhang.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace LESModels
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class BasicTurbulenceModel>
SmagorinskyZhang<BasicTurbulenceModel>::SmagorinskyZhang
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName,
const word& type
)
:
Smagorinsky<BasicTurbulenceModel>
(
alpha,
rho,
U,
alphaPhi,
phi,
transport,
propertiesName,
type
),
gasTurbulencePtr_(NULL),
Cmub_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cmub",
this->coeffDict_,
0.6
)
)
{
if (type == typeName)
{
correctNut();
this->printCoeffs(type);
}
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class BasicTurbulenceModel>
bool SmagorinskyZhang<BasicTurbulenceModel>::read()
{
if (Smagorinsky<BasicTurbulenceModel>::read())
{
Cmub_.readIfPresent(this->coeffDict());
return true;
}
else
{
return false;
}
}
template<class BasicTurbulenceModel>
const PhaseIncompressibleTurbulenceModel
<
typename BasicTurbulenceModel::transportModel
>&
SmagorinskyZhang<BasicTurbulenceModel>::gasTurbulence() const
{
if (!gasTurbulencePtr_)
{
const volVectorField& U = this->U_;
const transportModel& liquid = this->transport();
const twoPhaseSystem& fluid = liquid.fluid();
const transportModel& gas = fluid.otherPhase(liquid);
gasTurbulencePtr_ =
&U.db()
.lookupObject<PhaseIncompressibleTurbulenceModel<transportModel> >
(
IOobject::groupName
(
turbulenceModel::propertiesName,
gas.name()
)
);
}
return *gasTurbulencePtr_;
}
template<class BasicTurbulenceModel>
void SmagorinskyZhang<BasicTurbulenceModel>::correctNut()
{
const PhaseIncompressibleTurbulenceModel<transportModel>& gasTurbulence =
this->gasTurbulence();
volScalarField k(this->k(fvc::grad(this->U_)));
this->nut_ =
this->Ck_*sqrt(k)*this->delta()
+ Cmub_*gasTurbulence.transport().d()*gasTurbulence.alpha()
*(mag(this->U_ - gasTurbulence.U()));
this->nut_.correctBoundaryConditions();
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace LESModels
} // End namespace Foam
// ************************************************************************* //

170
src/TurbulenceModels/phaseIncompressible/LES/SmagorinskyZhang/SmagorinskyZhang.H Normal file
View File

@ -0,0 +1,170 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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::LESModels::SmagorinskyZhang
Group
grpLESTurbulence
Description
The Smagorinsky SGS model including bubble-generated turbulence
Reference:
\verbatim
"Numerical simulation of the dynamic flow behavior in a bubble column:
A study of closures for turbulence and interface forces"
D. Zhang,
N.G. Deen,
J.A.M. Kuipers,
Chemical Engineering Science 61 (2006) pp 7593-7608.
\endverbatim
The default model coefficients correspond to the following:
\verbatim
SmagorinskyZhangCoeffs
{
Ck 0.094;
Ce 1.048;
Cmub 0.6;
}
\endverbatim
SourceFiles
SmagorinskyZhang.C
\*---------------------------------------------------------------------------*/
#ifndef SmagorinskyZhang_H
#define SmagorinskyZhang_H
#include "LESModel.H"
#include "eddyViscosity.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace LESModels
{
/*---------------------------------------------------------------------------*\
Class SmagorinskyZhang Declaration
\*---------------------------------------------------------------------------*/
template<class BasicTurbulenceModel>
class SmagorinskyZhang
:
public Smagorinsky<BasicTurbulenceModel>
{
// Private data
mutable const PhaseIncompressibleTurbulenceModel
<
typename BasicTurbulenceModel::transportModel
> *gasTurbulencePtr_;
// Private Member Functions
//- Return the turbulence model for the gas phase
const PhaseIncompressibleTurbulenceModel
<
typename BasicTurbulenceModel::transportModel
>&
gasTurbulence() const;
// Disallow default bitwise copy construct and assignment
SmagorinskyZhang(const SmagorinskyZhang&);
SmagorinskyZhang& operator=(const SmagorinskyZhang&);
protected:
// Protected data
// Model coefficients
dimensionedScalar Cmub_;
// Protected Member Functions
virtual void correctNut();
public:
typedef typename BasicTurbulenceModel::alphaField alphaField;
typedef typename BasicTurbulenceModel::rhoField rhoField;
typedef typename BasicTurbulenceModel::transportModel transportModel;
//- Runtime type information
TypeName("SmagorinskyZhang");
// Constructors
//- Construct from components
SmagorinskyZhang
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName = turbulenceModel::propertiesName,
const word& type = typeName
);
//- Destructor
virtual ~SmagorinskyZhang()
{}
// Member Functions
//- Read model coefficients if they have changed
virtual bool read();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace LESModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "SmagorinskyZhang.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

169
src/TurbulenceModels/phaseIncompressible/LES/continuousGasKEqn/continuousGasKEqn.C Normal file
View File

@ -0,0 +1,169 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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 "continuousGasKEqn.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace LESModels
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class BasicTurbulenceModel>
continuousGasKEqn<BasicTurbulenceModel>::continuousGasKEqn
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName,
const word& type
)
:
kEqn<BasicTurbulenceModel>
(
alpha,
rho,
U,
alphaPhi,
phi,
transport,
propertiesName,
type
),
liquidTurbulencePtr_(NULL),
alphaInversion_
(
dimensioned<scalar>::lookupOrAddToDict
(
"alphaInversion",
this->coeffDict_,
0.7
)
)
{
if (type == typeName)
{
kEqn<BasicTurbulenceModel>::correctNut();
this->printCoeffs(type);
}
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class BasicTurbulenceModel>
bool continuousGasKEqn<BasicTurbulenceModel>::read()
{
if (kEqn<BasicTurbulenceModel>::read())
{
alphaInversion_.readIfPresent(this->coeffDict());
return true;
}
else
{
return false;
}
}
template<class BasicTurbulenceModel>
const turbulenceModel&
continuousGasKEqn<BasicTurbulenceModel>::liquidTurbulence() const
{
if (!liquidTurbulencePtr_)
{
const volVectorField& U = this->U_;
const transportModel& gas = this->transport();
const twoPhaseSystem& fluid = gas.fluid();
const transportModel& liquid = fluid.otherPhase(gas);
liquidTurbulencePtr_ =
&U.db().lookupObject<turbulenceModel>
(
IOobject::groupName
(
turbulenceModel::propertiesName,
liquid.name()
)
);
}
return *liquidTurbulencePtr_;
}
template<class BasicTurbulenceModel>
tmp<volScalarField>
continuousGasKEqn<BasicTurbulenceModel>::phaseTransferCoeff() const
{
const volVectorField& U = this->U_;
const alphaField& alpha = this->alpha_;
const rhoField& rho = this->rho_;
const turbulenceModel& liquidTurbulence = this->liquidTurbulence();
return
(
max(alphaInversion_ - alpha, 0.0)
*rho
*min
(
this->Ce_*sqrt(liquidTurbulence.k())/this->delta(),
1.0/U.time().deltaT()
)
);
}
template<class BasicTurbulenceModel>
tmp<fvScalarMatrix>
continuousGasKEqn<BasicTurbulenceModel>::kSource() const
{
const turbulenceModel& liquidTurbulence = this->liquidTurbulence();
const volScalarField phaseTransferCoeff(this->phaseTransferCoeff());
return
phaseTransferCoeff*liquidTurbulence.k()
- fvm::Sp(phaseTransferCoeff, this->k_);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace LESModels
} // End namespace Foam
// ************************************************************************* //

162
src/TurbulenceModels/phaseIncompressible/LES/continuousGasKEqn/continuousGasKEqn.H Normal file
View File

@ -0,0 +1,162 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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::LESModels::continuousGasKEqn
Group
grpLESTurbulence
Description
One-equation SGS model for the gas-phase in a two-phase system
supporting phase-inversion.
In the limit that the gas-phase fraction approaches zero a contribution from
the other phase is blended into the k-equation up to the phase-fraction of
alphaInversion at which point phase-inversion is considered to have occurred
and the model reverts to the pure single-phase form.
This model is unpublished and is provided as a stable numerical framework
on which a more physical model may be built.
The default model coefficients correspond to the following:
\verbatim
continuousKEqnCoeffs
{
Ck 0.094;
Ce 1.048;
alphaInversion 0.7;
}
\endverbatim
SourceFiles
continuousGasKEqn.C
\*---------------------------------------------------------------------------*/
#ifndef continuousGasKEqn_H
#define continuousGasKEqn_H
#include "kEqn.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace LESModels
{
/*---------------------------------------------------------------------------*\
Class continuousGasKEqn Declaration
\*---------------------------------------------------------------------------*/
template<class BasicTurbulenceModel>
class continuousGasKEqn
:
public kEqn<BasicTurbulenceModel>
{
// Private data
mutable const turbulenceModel *liquidTurbulencePtr_;
// Private Member Functions
// Disallow default bitwise copy construct and assignment
continuousGasKEqn(const continuousGasKEqn&);
continuousGasKEqn& operator=(const continuousGasKEqn&);
protected:
// Protected data
// Model coefficients
dimensionedScalar alphaInversion_;
// Protected Member Functions
//- Return the turbulence model for the liquid phase
const turbulenceModel& liquidTurbulence() const;
tmp<volScalarField> phaseTransferCoeff() const;
virtual tmp<fvScalarMatrix> kSource() const;
public:
typedef typename BasicTurbulenceModel::alphaField alphaField;
typedef typename BasicTurbulenceModel::rhoField rhoField;
typedef typename BasicTurbulenceModel::transportModel transportModel;
//- Runtime type information
TypeName("continuousGasKEqn");
// Constructors
//- Construct from components
continuousGasKEqn
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName = turbulenceModel::propertiesName,
const word& type = typeName
);
//- Destructor
virtual ~continuousGasKEqn()
{}
// Member Functions
//- Read model coefficients if they have changed
virtual bool read();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace LESModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "continuousGasKEqn.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

50
src/TurbulenceModels/phaseIncompressible/RAS/LaheyKEpsilon/LaheyKEpsilon.H
View File

@ -28,6 +28,31 @@ Group
grpRASTurbulence
Description
Continuous-phase k-epsilon model including bubble-generated turbulence.
Reference:
\verbatim
"The simulation of multidimensional multiphase flows",
Lahey R.T.,
Nucl. Eng. & Design
2005 (235) pp.1043-1060.
\endverbatim
The default model coefficients correspond to the following:
\verbatim
LaheyKEpsilonCoeffs
{
Cmu 0.09;
C1 1.44;
C2 1.92;
C3 -0.33;
sigmak 1.0;
sigmaEps 1.3;
Cp 0.25;
Cmub 0.6;
alphaInversion 0.3;
}
\endverbatim
SourceFiles
LaheyKEpsilon.C
@ -63,6 +88,20 @@ class LaheyKEpsilon
> *gasTurbulencePtr_;
// Private Member Functions
//- Return the turbulence model for the gas phase
const PhaseIncompressibleTurbulenceModel
<
typename BasicTurbulenceModel::transportModel
>&
gasTurbulence() const;
// Disallow default bitwise copy construct and assignment
LaheyKEpsilon(const LaheyKEpsilon&);
LaheyKEpsilon& operator=(const LaheyKEpsilon&);
protected:
// Protected data
@ -74,7 +113,7 @@ protected:
dimensionedScalar Cmub_;
// Protected member functions
// Protected Member Functions
virtual void correctNut();
tmp<volScalarField> bubbleG() const;
@ -82,6 +121,7 @@ protected:
virtual tmp<fvScalarMatrix> kSource() const;
virtual tmp<fvScalarMatrix> epsilonSource() const;
public:
typedef typename BasicTurbulenceModel::alphaField alphaField;
@ -116,15 +156,11 @@ public:
// Member Functions
//- Return the turbulence model for the gas phase
const PhaseIncompressibleTurbulenceModel<transportModel>&
gasTurbulence() const;
//- Read model coefficients if they have changed
virtual bool read();
//- Solve the turbulence equations and correct the turbulence viscosity
virtual void correct();
//- Read RASProperties dictionary
virtual bool read();
};

40
src/TurbulenceModels/phaseIncompressible/RAS/continuousGasKEpsilon/continuousGasKEpsilon.H
View File

@ -28,6 +28,31 @@ Group
grpRASTurbulence
Description
k-epsilon model for the gas-phase in a two-phase system
supporting phase-inversion.
In the limit that the gas-phase fraction approaches zero a contribution from
the other phase is blended into the k and epsilon equations up to the
phase-fraction of alphaInversion at which point phase-inversion is
considered to have occurred and the model reverts to the pure single-phase
form.
This model is unpublished and is provided as a stable numerical framework
on which a more physical model may be built.
The default model coefficients correspond to the following:
\verbatim
continuousGasKEpsilonCoeffs
{
Cmu 0.09;
C1 1.44;
C2 1.92;
C3 -0.33;
sigmak 1.0;
sigmaEps 1.3;
alphaInversion 0.7;
}
\endverbatim
SourceFiles
continuousGasKEpsilon.C
@ -62,6 +87,13 @@ class continuousGasKEpsilon
volScalarField nutEff_;
// Private Member Functions
// Disallow default bitwise copy construct and assignment
continuousGasKEpsilon(const continuousGasKEpsilon&);
continuousGasKEpsilon& operator=(const continuousGasKEpsilon&);
protected:
// Protected data
@ -71,7 +103,7 @@ protected:
dimensionedScalar alphaInversion_;
// Protected member functions
// Protected Member Functions
virtual void correctNut();
tmp<volScalarField> phaseTransferCoeff() const;
@ -113,6 +145,9 @@ public:
// Member Functions
//- Re-read model coefficients if they have changed
virtual bool read();
//- Return the turbulence model for the liquid phase
const turbulenceModel& liquidTurbulence() const;
@ -124,9 +159,6 @@ public:
//- Return the Reynolds stress tensor
virtual tmp<volSymmTensorField> R() const;
//- Read RASProperties dictionary
virtual bool read();
};

7
src/TurbulenceModels/turbulenceModels/LES/LESModel/LESModel.H
View File

@ -168,6 +168,10 @@ public:
// Member Functions
//- Read model coefficients if they have changed
virtual bool read();
// Access
//- Const access to the coefficients dictionary
@ -216,9 +220,6 @@ public:
//- Solve the turbulence equations and correct the turbulence viscosity
virtual void correct();
//- Read LESProperties dictionary
virtual bool read();
};

23
src/TurbulenceModels/turbulenceModels/LES/Smagorinsky/Smagorinsky.C
View File

@ -59,21 +59,21 @@ Smagorinsky<BasicTurbulenceModel>::Smagorinsky
propertiesName
),
ck_
Ck_
(
dimensioned<scalar>::lookupOrAddToDict
(
"ck",
"Ck",
this->coeffDict_,
0.02
0.094
)
),
ce_
Ce_
(
dimensioned<scalar>::lookupOrAddToDict
(
"ce",
"Ce",
this->coeffDict_,
1.048
)
@ -94,8 +94,8 @@ bool Smagorinsky<BasicTurbulenceModel>::read()
{
if (eddyViscosity<LESModel<BasicTurbulenceModel> >::read())
{
ck_.readIfPresent(this->coeffDict());
ce_.readIfPresent(this->coeffDict());
Ck_.readIfPresent(this->coeffDict());
Ce_.readIfPresent(this->coeffDict());
return true;
}
@ -105,6 +105,7 @@ bool Smagorinsky<BasicTurbulenceModel>::read()
}
}
template<class BasicTurbulenceModel>
tmp<volScalarField> Smagorinsky<BasicTurbulenceModel>::k
(
@ -113,9 +114,9 @@ tmp<volScalarField> Smagorinsky<BasicTurbulenceModel>::k
{
volSymmTensorField D(symm(gradU));
volScalarField a(ce_/this->delta());
volScalarField a(Ce_/this->delta());
volScalarField b((2.0/3.0)*tr(D));
volScalarField c(2*ck_*this->delta()*(dev(D) && D));
volScalarField c(2*Ck_*this->delta()*(dev(D) && D));
return sqr((-b + sqrt(sqr(b) + 4*a*c))/(2*a));
}
@ -136,7 +137,7 @@ tmp<volScalarField> Smagorinsky<BasicTurbulenceModel>::epsilon() const
IOobject::NO_READ,
IOobject::NO_WRITE
),
ce_*k()*sqrt(k())/this->delta()
Ce_*k()*sqrt(k())/this->delta()
)
);
}
@ -147,7 +148,7 @@ void Smagorinsky<BasicTurbulenceModel>::correctNut()
{
volScalarField k(this->k(fvc::grad(this->U_)));
this->nut_ = ck_*this->delta()*sqrt(k);
this->nut_ = Ck_*this->delta()*sqrt(k);
this->nut_.correctBoundaryConditions();
}

43
src/TurbulenceModels/turbulenceModels/LES/Smagorinsky/Smagorinsky.H
View File

@ -28,7 +28,7 @@ Group
grpLESTurbulence
Description
The Smagorinsky Model.
The Smagorinsky SGS model.
Algebraic eddy viscosity SGS model founded on the assumption that
local equilibrium prevails.
@ -40,8 +40,17 @@ Description
where
D = symm(grad(U));
k from D:B + ce*k^3/2/delta = 0
nuSgs = ck*sqrt(k)*delta
k from D:B + Ce*k^3/2/delta = 0
nuSgs = Ck*sqrt(k)*delta
\endverbatim
The default model coefficients correspond to the following:
\verbatim
SmagorinskyCoeffs
{
Ck 0.094;
Ce 1.048;
}
\endverbatim
SourceFiles
@ -71,26 +80,22 @@ class Smagorinsky
:
public eddyViscosity<LESModel<BasicTurbulenceModel> >
{
protected:
// Protected data
dimensionedScalar ck_;
dimensionedScalar ce_;
// Private Member Functions
//- Update sub-grid scale fields
void updateSubGridScaleFields(const volTensorField& gradU);
// Disallow default bitwise copy construct and assignment
Smagorinsky(const Smagorinsky&);
Smagorinsky& operator=(const Smagorinsky&);
// Protected member functions
protected:
// Protected data
dimensionedScalar Ck_;
dimensionedScalar Ce_;
// Protected Member Functions
//- Return SGS kinetic energy
// calculated from the given velocity gradient
@ -133,6 +138,9 @@ public:
// Member Functions
//- Read model coefficients if they have changed
virtual bool read();
//- Return SGS kinetic energy
virtual tmp<volScalarField> k() const
{
@ -144,9 +152,6 @@ public:
//- Correct Eddy-Viscosity and related properties
virtual void correct();
//- Read model coefficients if they have changed
virtual bool read();
};

18
src/TurbulenceModels/turbulenceModels/LES/kEqn/kEqn.C
View File

@ -72,21 +72,21 @@ kEqn<BasicTurbulenceModel>::kEqn
this->mesh_
),
ck_
Ck_
(
dimensioned<scalar>::lookupOrAddToDict
(
"ck",
"Ck",
this->coeffDict_,
0.094
)
),
ce_
Ce_
(
dimensioned<scalar>::lookupOrAddToDict
(
"ce",
"Ce",
this->coeffDict_,
1.048
)
@ -107,8 +107,8 @@ bool kEqn<BasicTurbulenceModel>::read()
{
if (eddyViscosity<LESModel<BasicTurbulenceModel> >::read())
{
ck_.readIfPresent(this->coeffDict());
ce_.readIfPresent(this->coeffDict());
Ck_.readIfPresent(this->coeffDict());
Ce_.readIfPresent(this->coeffDict());
return true;
}
@ -134,7 +134,7 @@ tmp<volScalarField> kEqn<BasicTurbulenceModel>::epsilon() const
IOobject::NO_READ,
IOobject::NO_WRITE
),
ce_*k()*sqrt(k())/this->delta()
Ce_*k()*sqrt(k())/this->delta()
)
);
}
@ -143,7 +143,7 @@ tmp<volScalarField> kEqn<BasicTurbulenceModel>::epsilon() const
template<class BasicTurbulenceModel>
void kEqn<BasicTurbulenceModel>::correctNut()
{
this->nut_ = ck_*sqrt(k_)*this->delta();
this->nut_ = Ck_*sqrt(k_)*this->delta();
this->nut_.correctBoundaryConditions();
}
@ -196,7 +196,7 @@ void kEqn<BasicTurbulenceModel>::correct()
==
alpha*rho*G
- fvm::SuSp((2.0/3.0)*alpha*rho*divU, k_)
- fvm::Sp(ce_*alpha*rho*sqrt(k_)/this->delta(), k_)
- fvm::Sp(Ce_*alpha*rho*sqrt(k_)/this->delta(), k_)
+ kSource()
);

41
src/TurbulenceModels/turbulenceModels/LES/kEqn/kEqn.H
View File

@ -35,7 +35,7 @@ Description
\verbatim
d/dt(rho*k) + div(rho*U*k) - div(rho*nuEff*grad(k))
=
-rho*D:B - ce*rho*k^(3/2)/delta
-rho*D:B - Ce*rho*k^(3/2)/delta
and
@ -44,10 +44,19 @@ Description
where
D = symm(grad(U));
nuSgs = ck*sqrt(k)*delta
nuSgs = Ck*sqrt(k)*delta
nuEff = nuSgs + nu
\endverbatim
The default model coefficients correspond to the following:
\verbatim
NicenoKEqnCoeffs
{
Ck 0.094;
Ce 1.048;
}
\endverbatim
SourceFiles
kEqn.C
@ -75,6 +84,12 @@ class kEqn
:
public eddyViscosity<LESModel<BasicTurbulenceModel> >
{
// Private Member Functions
// Disallow default bitwise copy construct and assignment
kEqn(const kEqn&);
kEqn& operator=(const kEqn&);
protected:
@ -82,21 +97,11 @@ protected:
volScalarField k_;
dimensionedScalar ck_;
dimensionedScalar ce_;
dimensionedScalar Ck_;
dimensionedScalar Ce_;
// Private Member Functions
//- Update sub-grid scale fields
void updateSubGridScaleFields();
// Disallow default bitwise copy construct and assignment
kEqn(const kEqn&);
kEqn& operator=(const kEqn&);
// Protected member functions
// Protected Member Functions
virtual void correctNut();
virtual tmp<fvScalarMatrix> kSource() const;
@ -136,6 +141,9 @@ public:
// Member Functions
//- Read model coefficients if they have changed
virtual bool read();
//- Return SGS kinetic energy
virtual tmp<volScalarField> k() const
{
@ -156,9 +164,6 @@ public:
//- Correct Eddy-Viscosity and related properties
virtual void correct();
//- Read model coefficients if they have changed
virtual bool read();
};

7
src/TurbulenceModels/turbulenceModels/RAS/RASModel/RASModel.H
View File

@ -170,6 +170,10 @@ public:
// Member Functions
//- Read model coefficients if they have changed
virtual bool read();
// Access
//- Return the lower allowable limit for k (default: SMALL)
@ -236,9 +240,6 @@ public:
//- Solve the turbulence equations and correct the turbulence viscosity
virtual void correct();
//- Read RASProperties dictionary
virtual bool read();
};

14
src/TurbulenceModels/turbulenceModels/RAS/kEpsilon/kEpsilon.H
View File

@ -70,6 +70,12 @@ class kEpsilon
:
public eddyViscosity<RASModel<BasicTurbulenceModel> >
{
// Private Member Functions
// Disallow default bitwise copy construct and assignment
kEpsilon(const kEpsilon&);
kEpsilon& operator=(const kEpsilon&);
protected:
@ -90,7 +96,7 @@ protected:
volScalarField epsilon_;
// Protected member functions
// Protected Member Functions
virtual void correctNut();
virtual tmp<fvScalarMatrix> kSource() const;
@ -131,6 +137,9 @@ public:
// Member Functions
//- Re-read model coefficients if they have changed
virtual bool read();
//- Return the effective diffusivity for k
tmp<volScalarField> DkEff() const
{
@ -171,9 +180,6 @@ public:
//- Solve the turbulence equations and correct the turbulence viscosity
virtual void correct();
//- Re-read model coefficients if they have changed
virtual bool read();
};

8
src/TurbulenceModels/turbulenceModels/eddyViscosity/eddyViscosity.H
View File

@ -62,7 +62,7 @@ protected:
volScalarField nut_;
// Protected member functions
// Protected Member Functions
virtual void correctNut() = 0;
@ -97,6 +97,9 @@ public:
// Member Functions
//- Re-read model coefficients if they have changed
virtual bool read() = 0;
//- Return the turbulence viscosity
virtual tmp<volScalarField> nut() const
{
@ -123,9 +126,6 @@ public:
//- Solve the turbulence equations and correct the turbulence viscosity
virtual void correct() = 0;
//- Re-read model coefficients if they have changed
virtual bool read() = 0;
};

6
src/TurbulenceModels/turbulenceModels/turbulenceModel.H
View File

@ -114,6 +114,9 @@ public:
// Member Functions
//- Read model coefficients if they have changed
virtual bool read() = 0;
const Time& time() const
{
return runTime_;
@ -205,9 +208,6 @@ public:
//- Solve the turbulence equations and correct the turbulence viscosity
virtual void correct() = 0;
//- Read LESProperties or RASProperties dictionary
virtual bool read() = 0;
//- Default dummy write function
virtual bool writeData(Ostream&) const
{

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/0/T.air → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/0/T.air
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/0/T.water → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/0/T.water
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/0/Theta → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/0/Theta
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/0/U.air → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/0/U.air
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/0/U.water → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/0/U.water
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/0/alpha.air → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/0/alpha.air
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/0/alpha.air.org → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/0/alpha.air.org
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/0/epsilon.air → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/0/epsilon.air
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/0/epsilon.water → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/0/epsilon.water
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/0/k.air → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/0/k.air
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/0/k.water → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/0/k.water
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/0/nut.air → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/0/nut.air
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/0/nut.water → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/0/nut.water
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/0/p → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/0/p
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/constant/g → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/constant/g
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/constant/phaseProperties → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/constant/phaseProperties
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/constant/polyMesh/blockMeshDict → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/constant/polyMesh/blockMeshDict
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/constant/polyMesh/boundary → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/constant/polyMesh/boundary
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/constant/thermophysicalProperties.air → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/constant/thermophysicalProperties.air
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/constant/thermophysicalProperties.water → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/constant/thermophysicalProperties.water
View File

34
tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/constant/turbulenceProperties.air Normal file
View File

@ -0,0 +1,34 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object turbulenceProperties.air;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
simulationType LES;
LES
{
LESModel continuousGasKEqn; //Smagorinsky;
turbulence on;
printCoeffs on;
delta cubeRootVol;
cubeRootVolCoeffs
{
}
}
// ************************************************************************* //

34
tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/constant/turbulenceProperties.water Normal file
View File

@ -0,0 +1,34 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object turbulenceProperties.water;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
simulationType LES;
LES
{
LESModel NicenoKEqn; //SmagorinskyZhang;
turbulence on;
printCoeffs on;
delta cubeRootVol;
cubeRootVolCoeffs
{
}
}
// ************************************************************************* //

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/system/controlDict → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/system/controlDict
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/system/fvSchemes → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/system/fvSchemes
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/system/fvSolution → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/system/fvSolution
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/system/setFieldsDict → tutorials/multiphase/compressibleTwoPhaseEulerFoam/LES/bubbleColumn/system/setFieldsDict
View File

45
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/0/T.air Normal file
View File

@ -0,0 +1,45 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object Tair;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 1 0 0 0];
internalField uniform 300;
boundaryField
{
walls
{
type zeroGradient;
}
outlet
{
type inletOutlet;
phi phi.air;
inletValue $internalField;
value $internalField;
}
inlet
{
type fixedValue;
value $internalField;
}
frontAndBackPlanes
{
type empty;
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

45
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/0/T.water Normal file
View File

@ -0,0 +1,45 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object Twater;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 1 0 0 0];
internalField uniform 350;
boundaryField
{
walls
{
type zeroGradient;
}
outlet
{
type inletOutlet;
phi phi.water;
inletValue uniform 300;
value $internalField;
}
inlet
{
type fixedValue;
value $internalField;
}
frontAndBackPlanes
{
type empty;
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

47
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/0/Theta Normal file
View File

@ -0,0 +1,47 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object Theta;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [ 0 2 -2 0 0 0 0 ];
internalField uniform 0.0;
boundaryField
{
inlet
{
type fixedValue;
value uniform 1.0e-7;
}
outlet
{
type inletOutlet;
inletValue uniform 1.0e-7;
value uniform 1.0e-7;
}
walls
{
type zeroGradient;
}
defaultFaces
{
type empty;
}
}
// ************************************************************************* //

41
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/0/U.air Normal file
View File

@ -0,0 +1,41 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format binary;
class volVectorField;
object U.air;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField uniform (0 0.1 0);
boundaryField
{
inlet
{
type fixedValue;
value $internalField;
}
outlet
{
type pressureInletOutletVelocity;
phi phi.air;
value $internalField;
}
walls
{
type fixedValue;
value uniform (0 0 0);
}
}
// ************************************************************************* //

41
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/0/U.water Normal file
View File

@ -0,0 +1,41 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format binary;
class volVectorField;
object U.water;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField uniform (0 0 0);
boundaryField
{
inlet
{
type fixedValue;
value $internalField;
}
outlet
{
type pressureInletOutletVelocity;
phi phi.water;
value $internalField;
}
walls
{
type fixedValue;
value uniform (0 0 0);
}
}
// ************************************************************************* //

1926
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/0/alpha.air Normal file
View File

File diff suppressed because it is too large Load Diff

42
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/0/alpha.air.org Normal file
View File

@ -0,0 +1,42 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object alpha.air;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 0 0 0 0];
internalField uniform 0;
boundaryField
{
inlet
{
type fixedValue;
value uniform 0.5;
}
outlet
{
type inletOutlet;
phi phi.air;
inletValue uniform 1;
value uniform 1;
}
walls
{
type zeroGradient;
}
}
// ************************************************************************* //

49
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/0/epsilon.air Normal file
View File

@ -0,0 +1,49 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object epsilon;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -3 0 0 0 0];
internalField uniform 1.5e-4;
boundaryField
{
inlet
{
type fixedValue;
value $internalField;
}
outlet
{
type inletOutlet;
phi phi.air;
inletValue $internalField;
value $internalField;
}
walls
{
type epsilonWallFunction;
value $internalField;
}
defaultFaces
{
type empty;
}
}
// ************************************************************************* //

49
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/0/epsilon.water Normal file
View File

@ -0,0 +1,49 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object epsilon;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -3 0 0 0 0];
internalField uniform 1.5e-4;
boundaryField
{
inlet
{
type fixedValue;
value $internalField;
}
outlet
{
type inletOutlet;
phi phi.water;
inletValue $internalField;
value $internalField;
}
walls
{
type epsilonWallFunction;
value $internalField;
}
defaultFaces
{
type empty;
}
}
// ************************************************************************* //

49
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/0/k.air Normal file
View File

@ -0,0 +1,49 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object k;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -2 0 0 0 0];
internalField uniform 3.75e-5;
boundaryField
{
inlet
{
type fixedValue;
value $internalField;
}
outlet
{
type inletOutlet;
phi phi.air;
inletValue $internalField;
value $internalField;
}
walls
{
type kqRWallFunction;
value $internalField;
}
defaultFaces
{
type empty;
}
}
// ************************************************************************* //

49
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/0/k.water Normal file
View File

@ -0,0 +1,49 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object k;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -2 0 0 0 0];
internalField uniform 3.75e-5;
boundaryField
{
inlet
{
type fixedValue;
value $internalField;
}
outlet
{
type inletOutlet;
phi phi.water;
inletValue $internalField;
value $internalField;
}
walls
{
type kqRWallFunction;
value $internalField;
}
defaultFaces
{
type empty;
}
}
// ************************************************************************* //

47
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/0/nut.air Normal file
View File

@ -0,0 +1,47 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object k;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -1 0 0 0 0];
internalField uniform 1e-8;
boundaryField
{
inlet
{
type calculated;
value $internalField;
}
outlet
{
type calculated;
value $internalField;
}
walls
{
type nutkWallFunction;
value $internalField;
}
defaultFaces
{
type empty;
}
}
// ************************************************************************* //

47
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/0/nut.water Normal file
View File

@ -0,0 +1,47 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object k;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -1 0 0 0 0];
internalField uniform 1e-8;
boundaryField
{
inlet
{
type calculated;
value $internalField;
}
outlet
{
type calculated;
value $internalField;
}
walls
{
type nutkWallFunction;
value $internalField;
}
defaultFaces
{
type empty;
}
}
// ************************************************************************* //

40
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/0/p Normal file
View File

@ -0,0 +1,40 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object p;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [ 1 -1 -2 0 0 0 0 ];
internalField uniform 1e5;
boundaryField
{
inlet
{
type fixedFluxPressure;
value $internalField;
}
outlet
{
type fixedValue;
value $internalField;
}
walls
{
type fixedFluxPressure;
value $internalField;
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

22
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/constant/g Normal file
View File

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

70
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/constant/phaseProperties Normal file
View File

@ -0,0 +1,70 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object phaseProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
phases (air water);
air
{
diameterModel isothermal;
isothermalCoeffs
{
d0 3e-3;
p0 1e5;
}
}
water
{
diameterModel constant;
constantCoeffs
{
d 1e-4;
}
}
drag
{
air SchillerNaumann;
water SchillerNaumann;
}
heatTransfer
{
air RanzMarshall;
water RanzMarshall;
}
dispersedPhase both;
residualPhaseFraction 1e-3;
residualSlip 1e-2;
// Virtual-mass ceofficient
Cvm 0.5;
// Lift coefficient
Cl 0;
// Dispersed-phase turbulence coefficient
Ct 1;
// Minimum allowable pressure
pMin 10000;
// ************************************************************************* //

61
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/constant/polyMesh/blockMeshDict Normal file
View File

@ -0,0 +1,61 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object blockMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
convertToMeters 1;
vertices
(
(0 0 0)
(0.15 0 0)
(0.15 1 0)
(0 1 0)
(0 0 0.1)
(0.15 0 0.1)
(0.15 1 0.1)
(0 1 0.1)
);
blocks
(
hex (0 1 2 3 4 5 6 7) (25 75 1) simpleGrading (1 1 1)
);
edges
(
);
patches
(
patch inlet
(
(1 5 4 0)
)
patch outlet
(
(3 7 6 2)
)
wall walls
(
(0 4 7 3)
(2 6 5 1)
)
);
mergePatchPairs
(
);
// ************************************************************************* //

47
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/constant/polyMesh/boundary Normal file
View File

@ -0,0 +1,47 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class polyBoundaryMesh;
location "constant/polyMesh";
object boundary;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
4
(
inlet
{
type patch;
nFaces 25;
startFace 3650;
}
outlet
{
type patch;
nFaces 25;
startFace 3675;
}
walls
{
type wall;
nFaces 150;
startFace 3700;
}
defaultFaces
{
type empty;
inGroups 1(empty);
nFaces 3750;
startFace 3850;
}
)
// ************************************************************************* //

49
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/constant/thermophysicalProperties.air Normal file
View File

@ -0,0 +1,49 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object thermophysicalProperties.air;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
thermoType
{
type heRhoThermo;
mixture pureMixture;
transport const;
thermo hConst;
equationOfState perfectGas;
specie specie;
energy sensibleEnthalpy;
}
mixture
{
specie
{
nMoles 1;
molWeight 28.9;
}
thermodynamics
{
Cp 1007;
Hf 0;
}
transport
{
mu 1.84e-05;
Pr 0.7;
}
}
// ************************************************************************* //

54
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/constant/thermophysicalProperties.water Normal file
View File

@ -0,0 +1,54 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object thermophysicalProperties.water;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
thermoType
{
type heRhoThermo;
mixture pureMixture;
transport const;
thermo hConst;
equationOfState perfectFluid;
specie specie;
energy sensibleEnthalpy;
}
mixture
{
specie
{
nMoles 1;
molWeight 28.9;
}
equationOfState
{
R 3000;
rho0 1027;
}
thermodynamics
{
Cp 4195;
Hf 0;
}
transport
{
mu 3.645e-4;
Pr 2.289;
}
}
// ************************************************************************* //

1
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/constant/turbulenceProperties.air → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/constant/turbulenceProperties.air
View File

@ -22,7 +22,6 @@ RAS
RASModel continuousGasKEpsilon;
turbulence on;
printCoeffs on;
}

6
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/bubbleColumn/constant/turbulenceProperties.water → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/constant/turbulenceProperties.water
View File

@ -22,13 +22,7 @@ RAS
RASModel LaheyKEpsilon;
turbulence on;
printCoeffs on;
LaheyKEpsilonCoeffs
{
//Cmub 0;
}
}
// ************************************************************************* //

95
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/system/controlDict Normal file
View File

@ -0,0 +1,95 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object controlDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
application compressibleTwoPhaseEulerFoam;
startFrom startTime;
startTime 0;
stopAt endTime;
endTime 100;
deltaT 0.005;
writeControl runTime;
writeInterval 1;
purgeWrite 0;
writeFormat ascii;
writePrecision 6;
writeCompression uncompressed;
timeFormat general;
timePrecision 6;
runTimeModifiable yes;
adjustTimeStep no;
maxCo 0.5;
maxDeltaT 1;
functions
{
fieldAverage1
{
type fieldAverage;
functionObjectLibs ( "libfieldFunctionObjects.so" );
outputControl outputTime;
fields
(
U.air
{
mean on;
prime2Mean off;
base time;
}
U.water
{
mean on;
prime2Mean off;
base time;
}
alpha.air
{
mean on;
prime2Mean off;
base time;
}
p
{
mean on;
prime2Mean off;
base time;
}
);
}
}
// ************************************************************************* //

69
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/system/fvSchemes Normal file
View File

@ -0,0 +1,69 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object fvSchemes;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
ddtSchemes
{
default Euler;
}
gradSchemes
{
default Gauss linear;
}
divSchemes
{
default none;
div(phi,alpha.air) Gauss vanLeer;
div(phir,alpha.air) Gauss vanLeer;
"div\(alphaPhi.*,U.*\)" Gauss limitedLinearV 1;
"div\(phi.*,U.*\)" Gauss limitedLinearV 1;
"div\(phi.*,.*rho.*\)" Gauss linear;
"div\(alphaPhi.*,(h|e).*\)" Gauss limitedLinear 1;
"div\(alphaPhi.*,(K.*|p)\)" Gauss limitedLinear 1;
"div\(alphaPhi.*,(k|epsilon).*\)" Gauss limitedLinear 1;
"div\(\(\(alpha.*nuEff.*\)*dev2\(T\(grad\(U.*\)\)\)\)\)" Gauss linear;
}
laplacianSchemes
{
default Gauss linear uncorrected;
}
interpolationSchemes
{
default linear;
}
snGradSchemes
{
default uncorrected;
}
fluxRequired
{
default no;
p ;
}
// ************************************************************************* //

92
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/system/fvSolution Normal file
View File

@ -0,0 +1,92 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object fvSolution;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
solvers
{
alpha.air
{
nAlphaCorr 1;
nAlphaSubCycles 2;
}
p
{
solver GAMG;
smoother DIC;
nPreSweeps 0;
nPostSweeps 2;
nFinestSweeps 2;
cacheAgglomeration true;
nCellsInCoarsestLevel 10;
agglomerator faceAreaPair;
mergeLevels 1;
tolerance 1e-08;
relTol 0.01;
}
pFinal
{
$p;
tolerance 1e-08;
relTol 0;
}
"U.*"
{
solver PBiCG;
preconditioner DILU;
tolerance 1e-7;
relTol 0;
}
"h.*"
{
solver PBiCG;
preconditioner DILU;
tolerance 1e-7;
relTol 0;
}
"(k|epsilon|Theta).*"
{
solver PBiCG;
preconditioner DILU;
tolerance 1e-7;
relTol 0;
}
}
PIMPLE
{
nOuterCorrectors 1;
nCorrectors 2;
nNonOrthogonalCorrectors 0;
}
relaxationFactors
{
fields
{
}
equations
{
".*" 1;
}
}
// ************************************************************************* //

36
tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/bubbleColumn/system/setFieldsDict Normal file
View File

@ -0,0 +1,36 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object setFieldsDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
defaultFieldValues
(
volScalarFieldValue alpha.air 1
);
regions
(
boxToCell
{
box (0 0 -0.1) (0.15 0.701 0.1);
fieldValues
(
volScalarFieldValue alpha.air 0
);
}
);
// ************************************************************************* //

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/0/T.air → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/0/T.air
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/0/T.particles → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/0/T.particles
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/0/Theta.particles → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/0/Theta.particles
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/0/U.air → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/0/U.air
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/0/U.particles → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/0/U.particles
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/0/alpha.air → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/0/alpha.air
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/0/alpha.air.org → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/0/alpha.air.org
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/0/alpha.particles → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/0/alpha.particles
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/0/alpha.particles.org → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/0/alpha.particles.org
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/0/epsilon.air → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/0/epsilon.air
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/0/k.air → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/0/k.air
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/0/nut.air → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/0/nut.air
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/0/nut.particles → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/0/nut.particles
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/0/p → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/0/p
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/constant/g → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/constant/g
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/constant/phaseProperties → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/constant/phaseProperties
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/constant/polyMesh/blockMeshDict → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/constant/polyMesh/blockMeshDict
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/constant/polyMesh/boundary → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/constant/polyMesh/boundary
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/constant/thermophysicalProperties.air → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/constant/thermophysicalProperties.air
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/constant/thermophysicalProperties.particles → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/constant/thermophysicalProperties.particles
View File

4
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/constant/turbulenceProperties.air → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/constant/turbulenceProperties.air
View File

@ -21,7 +21,8 @@ RAS
{
RASModel kEpsilon;
turbulence on;
turbulence on;
printCoeffs on;
}
LES
@ -29,7 +30,6 @@ LES
LESModel Smagorinsky;
turbulence on;
printCoeffs on;
delta cubeRootVol;

3
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/constant/turbulenceProperties.particles → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/constant/turbulenceProperties.particles
View File

@ -21,7 +21,8 @@ RAS
{
RASModel kineticTheory;
turbulence on;
turbulence on;
printCoeffs on;
kineticTheoryCoeffs
{

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/system/controlDict → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/system/controlDict
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/system/fvSchemes → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/system/fvSchemes
View File

0
tutorials/multiphase/compressibleTwoPhaseEulerFoam/ras/fluidisedBed/system/fvSolution → tutorials/multiphase/compressibleTwoPhaseEulerFoam/RAS/fluidisedBed/system/fvSolution
View File

Some files were not shown because too many files have changed in this diff Show More