zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

drop thermalDissipation (effective, equilibrium or otherwise) from turbulenceModels

Browse Source 
- keeps sources in sync for the 1.6 release and it'll get fiddled with
  for the 1.7 release anyhow
This commit is contained in:
Mark Olesen
2009-07-16 08:27:40 +02:00
parent 75080ab867
commit 7ae5e62f39
24 changed files with 0 additions and 1007 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
src/turbulenceModels/compressible/LES/LESModel/LESModel.C
View File

@ -76,7 +76,6 @@ LESModel::LESModel
)
),
turbulence_(true), // TODO: turbulence_(lookup("turbulence")),
printCoeffs_(lookupOrDefault<Switch>("printCoeffs", false)),
coeffDict_(subDictPtr(type + "Coeffs")),
@ -181,56 +180,6 @@ autoPtr<LESModel> LESModel::New
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
tmp<volScalarField> LESModel::thermalDissipation() const
{
tmp<volTensorField> tgradU = fvc::grad(this->U());
return tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"thermalDissipation",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- (
( this->mu()*dev(twoSymm(tgradU())) ) && tgradU()
)
- this->rho() * this->epsilon()
)
);
}
tmp<volScalarField> LESModel::thermalDissipationEquilibrium() const
{
tmp<volTensorField> tgradU = fvc::grad(this->U());
return tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"thermalDissipationEquilibrium",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- (
this->muEff()*dev(twoSymm(tgradU()))
- ((2.0/3.0)*I) * this->rho() * this->k()
) && tgradU()
)
);
}
void LESModel::correct(const tmp<volTensorField>&)
{
delta_().correct();

10
src/turbulenceModels/compressible/LES/LESModel/LESModel.H
View File

@ -80,7 +80,6 @@ protected:
// Protected data
Switch turbulence_;
Switch printCoeffs_;
dictionary coeffDict_;
@ -293,15 +292,6 @@ public:
}
//- The source for the enthalpy equation resulting from
// viscous and turbulent dissipation
virtual tmp<volScalarField> thermalDissipation() const;
//- The source for the enthalpy equation resulting from
// the effective viscous dissipation
// (ie, when turbulent production and dissipation are in equilibrium)
virtual tmp<volScalarField> thermalDissipationEquilibrium() const;
//- Correct Eddy-Viscosity and related properties.
// This calls correct(const tmp<volTensorField>& gradU) by supplying
// gradU calculated locally.

50
src/turbulenceModels/compressible/RAS/RASModel/RASModel.C
View File

@ -191,56 +191,6 @@ autoPtr<RASModel> RASModel::New
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
tmp<volScalarField> RASModel::thermalDissipation() const
{
tmp<volTensorField> tgradU = fvc::grad(this->U());
return tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"thermalDissipation",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- (
( this->mu()*dev(twoSymm(tgradU())) ) && tgradU()
)
- this->rho() * this->epsilon()
)
);
}
tmp<volScalarField> RASModel::thermalDissipationEquilibrium() const
{
tmp<volTensorField> tgradU = fvc::grad(this->U());
return tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"thermalDissipationEquilibrium",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- (
this->muEff()*dev(twoSymm(tgradU()))
- ((2.0/3.0)*I) * this->rho() * this->k()
) && tgradU()
)
);
}
scalar RASModel::yPlusLam(const scalar kappa, const scalar E) const
{
scalar ypl = 11.0;

9
src/turbulenceModels/compressible/RAS/RASModel/RASModel.H
View File

@ -345,15 +345,6 @@ public:
//- Return the source term for the momentum equation
virtual tmp<fvVectorMatrix> divDevRhoReff(volVectorField& U) const = 0;
//- The source for the enthalpy equation resulting from
// viscous and turbulent dissipation
virtual tmp<volScalarField> thermalDissipation() const;
//- The source for the enthalpy equation resulting from
// the effective viscous dissipation
// (ie, when turbulent production and dissipation are in equilibrium)
virtual tmp<volScalarField> thermalDissipationEquilibrium() const;
//- Return yPlus for the given patch
virtual tmp<scalarField> yPlus(const label patchI) const;

44
src/turbulenceModels/compressible/RAS/laminar/laminar.C
View File

@ -177,50 +177,6 @@ tmp<fvVectorMatrix> laminar::divDevRhoReff(volVectorField& U) const
}
tmp<volScalarField> laminar::thermalDissipation() const
{
tmp<volTensorField> tgradU = fvc::grad(this->U());
return tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"thermalDissipation",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- ( this->mu()*dev(twoSymm(tgradU())) ) && tgradU()
)
);
}
tmp<volScalarField> laminar::thermalDissipationEquilibrium() const
{
tmp<volTensorField> tgradU = fvc::grad(this->U());
return tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"thermalDissipationEquilibrium",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- ( this->mu()*dev(twoSymm(tgradU())) ) && tgradU()
)
);
}
bool laminar::read()
{
return RASModel::read();

9
src/turbulenceModels/compressible/RAS/laminar/laminar.H
View File

@ -112,15 +112,6 @@ public:
//- Return the source term for the momentum equation
virtual tmp<fvVectorMatrix> divDevRhoReff(volVectorField& U) const;
//- The source for the enthalpy equation resulting from
// viscous and turbulent dissipation
virtual tmp<volScalarField> thermalDissipation() const;
//- The source for the enthalpy equation resulting from
// the effective viscous dissipation
// (ie, when turbulent production and dissipation are in equilibrium)
virtual tmp<volScalarField> thermalDissipationEquilibrium() const;
//- Correct the laminar viscosity
virtual void correct();

1
src/turbulenceModels/compressible/turbulenceModel/Make/files
View File

@ -1,5 +1,4 @@
turbulenceModel.C
laminar/laminar.C
dissipationSelector/dissipationSelector.C
LIB = $(FOAM_LIBBIN)/libcompressibleTurbulenceModel

111
src/turbulenceModels/compressible/turbulenceModel/dissipationSelector/dissipationSelector.C
View File

@ -1,111 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "dissipationSelector.H"
#include "dictionary.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace compressible
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
template<>
const char* NamedEnum<dissipationSelector::treatment, 3>::names[] =
{
"none",
"cascade",
"equilibrium"
};
const NamedEnum<dissipationSelector::treatment, 3>
dissipationSelector::typeNames;
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
dissipationSelector::dissipationSelector
(
const turbulenceModel& turbModel,
const treatment treatmentType
)
:
turbModel_(turbModel),
treatment_(treatmentType)
{}
dissipationSelector::dissipationSelector
(
const turbulenceModel& turbModel,
const dictionary& dict
)
:
turbModel_(turbModel),
treatment_(none)
{
word modelType;
if (dict.readIfPresent<word>("dissipation", modelType))
{
treatment_ = typeNames[modelType];
}
}
tmp<volScalarField>
dissipationSelector::dissipation() const
{
if (treatment_ == cascade)
{
return turbModel_.thermalDissipation();
}
else if (treatment_ == equilibrium)
{
return turbModel_.thermalDissipationEquilibrium();
}
else
{
// a bit wasteful, but we'll avoid it with 'enabled' query anyhow
tmp<volScalarField> tField = turbModel_.thermalDissipation();
tField() = 0.0;
return tField;
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace compressible
} // End namespace Foam
// ************************************************************************* //

158
src/turbulenceModels/compressible/turbulenceModel/dissipationSelector/dissipationSelector.H
View File

@ -1,158 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::compressible::dissipationSelector
Description
Simplistic runtime selectable handling of thermal dissipation
Example use:
@code
dissipationSelector thermalDissipation(turbulence, dictionary);
fvScalarMatrix hEqn ( ... );
if (thermalDissipation.enabled())
{
hEqn += thermalDissipation.dissipation();
}
@endcode
SourceFiles
dissipationSelector.C
\*---------------------------------------------------------------------------*/
#ifndef compressibledissipationSelector_H
#define compressibledissipationSelector_H
#include "NamedEnum.H"
#include "dictionary.H"
#include "compressible/turbulenceModel/turbulenceModel.H"
#include "volFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace compressible
{
/*---------------------------------------------------------------------------*\
Class dissipationSelector Declaration
\*---------------------------------------------------------------------------*/
class dissipationSelector
{
public:
//- Type of treatment
enum treatment
{
none,
cascade,
equilibrium
};
static const NamedEnum<treatment, 3> typeNames;
protected:
// Protected data
const turbulenceModel& turbModel_;
//- Type of treatment
treatment treatment_;
public:
// Declare name of the class and its debug switch
ClassName("dissipationSelector");
// Constructors
//- Construct given treatment type
dissipationSelector
(
const turbulenceModel&,
const treatment = none
);
//- Construct given treatment type
dissipationSelector
(
const turbulenceModel&,
const dictionary&
);
// Member functions
//- Get the treatment type
treatment treatmentType() const
{
return treatment_;
}
//- Set the treatment type, return old value
treatment treatmentType(const treatment val)
{
treatment old = treatment_;
treatment_ = val;
return old;
}
//- Set the treatment type, return old value
const char* name() const
{
return typeNames[treatment_];
}
//- Set the treatment type, return old value
bool enabled() const
{
return treatment_ != none;
}
tmp<volScalarField> dissipation() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace compressible
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

44
src/turbulenceModels/compressible/turbulenceModel/laminar/laminar.C
View File

@ -195,50 +195,6 @@ tmp<fvVectorMatrix> laminar::divDevRhoReff(volVectorField& U) const
}
tmp<volScalarField> laminar::thermalDissipation() const
{
tmp<volTensorField> tgradU = fvc::grad(this->U());
return tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"thermalDissipation",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- ( this->mu()*dev(twoSymm(tgradU())) ) && tgradU()
)
);
}
tmp<volScalarField> laminar::thermalDissipationEquilibrium() const
{
tmp<volTensorField> tgradU = fvc::grad(this->U());
return tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"thermalDissipationEquilibrium",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- ( this->mu()*dev(twoSymm(tgradU())) ) && tgradU()
)
);
}
bool laminar::read()
{
return true;

9
src/turbulenceModels/compressible/turbulenceModel/laminar/laminar.H
View File

@ -122,15 +122,6 @@ public:
//- Return the source term for the momentum equation
virtual tmp<fvVectorMatrix> divDevRhoReff(volVectorField& U) const;
//- The source for the enthalpy equation resulting from
// viscous and turbulent dissipation
virtual tmp<volScalarField> thermalDissipation() const;
//- The source for the enthalpy equation resulting from
// the effective viscous dissipation
// (ie, when turbulent production and dissipation are in equilibrium)
virtual tmp<volScalarField> thermalDissipationEquilibrium() const;
//- Correct the laminar viscosity
virtual void correct();

9
src/turbulenceModels/compressible/turbulenceModel/turbulenceModel.H
View File

@ -210,15 +210,6 @@ public:
//- Return the source term for the momentum equation
virtual tmp<fvVectorMatrix> divDevRhoReff(volVectorField& U) const = 0;
//- The source for the enthalpy equation resulting from
// viscous and turbulent dissipation
virtual tmp<volScalarField> thermalDissipation() const = 0;
//- The source for the enthalpy equation resulting from
// the effective viscous dissipation
// (ie, when turbulent production and dissipation are in equilibrium)
virtual tmp<volScalarField> thermalDissipationEquilibrium() const = 0;
//- Solve the turbulence equations and correct the turbulence viscosity
virtual void correct() = 0;

50
src/turbulenceModels/incompressible/LES/LESModel/LESModel.C
View File

@ -139,56 +139,6 @@ autoPtr<LESModel> LESModel::New
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
tmp<volScalarField> LESModel::thermalDissipation() const
{
tmp<volTensorField> tgradU = fvc::grad(this->U());
return tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"thermalDissipation",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- (
( this->nu()*dev(twoSymm(tgradU())) ) && tgradU()
)
- this->epsilon()
)
);
}
tmp<volScalarField> LESModel::thermalDissipationEquilibrium() const
{
tmp<volTensorField> tgradU = fvc::grad(this->U());
return tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"thermalDissipationEquilibrium",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- (
this->nuEff()*dev(twoSymm(tgradU()))
- ((2.0/3.0)*I) * this->k()
) && tgradU()
)
);
}
void LESModel::correct(const tmp<volTensorField>&)
{
turbulenceModel::correct();

9
src/turbulenceModels/incompressible/LES/LESModel/LESModel.H
View File

@ -241,15 +241,6 @@ public:
}
//- The source for the enthalpy equation resulting from
// viscous and turbulent dissipation
virtual tmp<volScalarField> thermalDissipation() const;
//- The source for the enthalpy equation resulting from
// the effective viscous dissipation
// (ie, when turbulent production and dissipation are in equilibrium)
virtual tmp<volScalarField> thermalDissipationEquilibrium() const;
//- Correct Eddy-Viscosity and related properties.
// This calls correct(const tmp<volTensorField>& gradU) by supplying
// gradU calculated locally.

49
src/turbulenceModels/incompressible/RAS/RASModel/RASModel.C
View File

@ -176,55 +176,6 @@ autoPtr<RASModel> RASModel::New
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
tmp<volScalarField> RASModel::thermalDissipation() const
{
tmp<volTensorField> tgradU = fvc::grad(this->U());
return tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"thermalDissipation",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- (
( this->nu()*dev(twoSymm(tgradU())) ) && tgradU()
)
- this->epsilon()
)
);
}
tmp<volScalarField> RASModel::thermalDissipationEquilibrium() const
{
tmp<volTensorField> tgradU = fvc::grad(this->U());
return tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"thermalDissipationEquilibrium",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- (
this->nuEff()*dev(twoSymm(tgradU()))
- ((2.0/3.0)*I) * this->k()
) && tgradU()
)
);
}
scalar RASModel::yPlusLam(const scalar kappa, const scalar E) const
{

9
src/turbulenceModels/incompressible/RAS/RASModel/RASModel.H
View File

@ -326,15 +326,6 @@ public:
//- Return the source term for the momentum equation
virtual tmp<fvVectorMatrix> divDevReff(volVectorField& U) const = 0;
//- The source for the enthalpy equation resulting from
// viscous and turbulent dissipation
virtual tmp<volScalarField> thermalDissipation() const;
//- The source for the enthalpy equation resulting from
// the effective viscous dissipation
// (ie, when turbulent production and dissipation are in equilibrium)
virtual tmp<volScalarField> thermalDissipationEquilibrium() const;
//- Return yPlus for the given patch
virtual tmp<scalarField> yPlus(const label patchI) const;

44
src/turbulenceModels/incompressible/RAS/laminar/laminar.C
View File

@ -176,50 +176,6 @@ tmp<fvVectorMatrix> laminar::divDevReff(volVectorField& U) const
}
tmp<volScalarField> laminar::thermalDissipation() const
{
tmp<volTensorField> tgradU = fvc::grad(this->U());
return tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"thermalDissipation",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- ( this->nu()*dev(twoSymm(tgradU())) ) && tgradU()
)
);
}
tmp<volScalarField> laminar::thermalDissipationEquilibrium() const
{
tmp<volTensorField> tgradU = fvc::grad(this->U());
return tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"thermalDissipationEquilibrium",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- ( this->nu()*dev(twoSymm(tgradU())) ) && tgradU()
)
);
}
bool laminar::read()
{
return RASModel::read();

9
src/turbulenceModels/incompressible/RAS/laminar/laminar.H
View File

@ -104,15 +104,6 @@ public:
//- Return the source term for the momentum equation
virtual tmp<fvVectorMatrix> divDevReff(volVectorField& U) const;
//- The source for the enthalpy equation resulting from
// viscous and turbulent dissipation
virtual tmp<volScalarField> thermalDissipation() const;
//- The source for the enthalpy equation resulting from
// the effective viscous dissipation
// (ie, when turbulent production and dissipation are in equilibrium)
virtual tmp<volScalarField> thermalDissipationEquilibrium() const;
//- Correct the laminar viscosity
virtual void correct();

1
src/turbulenceModels/incompressible/turbulenceModel/Make/files
View File

@ -1,5 +1,4 @@
turbulenceModel.C
laminar/laminar.C
dissipationSelector/dissipationSelector.C
LIB = $(FOAM_LIBBIN)/libincompressibleTurbulenceModel

111
src/turbulenceModels/incompressible/turbulenceModel/dissipationSelector/dissipationSelector.C
View File

@ -1,111 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "dissipationSelector.H"
#include "dictionary.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace incompressible
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
template<>
const char* NamedEnum<dissipationSelector::treatment, 3>::names[] =
{
"none",
"cascade",
"equilibrium"
};
const NamedEnum<dissipationSelector::treatment, 3>
dissipationSelector::typeNames;
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
dissipationSelector::dissipationSelector
(
const turbulenceModel& turbModel,
const treatment treatmentType
)
:
turbModel_(turbModel),
treatment_(treatmentType)
{}
dissipationSelector::dissipationSelector
(
const turbulenceModel& turbModel,
const dictionary& dict
)
:
turbModel_(turbModel),
treatment_(none)
{
word modelType;
if (dict.readIfPresent<word>("dissipation", modelType))
{
treatment_ = typeNames[modelType];
}
}
tmp<volScalarField>
dissipationSelector::dissipation() const
{
if (treatment_ == cascade)
{
return turbModel_.thermalDissipation();
}
else if (treatment_ == equilibrium)
{
return turbModel_.thermalDissipationEquilibrium();
}
else
{
// a bit wasteful, but we'll avoid it with 'enabled' query anyhow
tmp<volScalarField> tField = turbModel_.thermalDissipation();
tField() = 0.0;
return tField;
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace incompressible
} // End namespace Foam
// ************************************************************************* //

158
src/turbulenceModels/incompressible/turbulenceModel/dissipationSelector/dissipationSelector.H
View File

@ -1,158 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::incompressible::dissipationSelector
Description
Simplistic runtime selectable handling of thermal dissipation
Example use:
@code
dissipationSelector thermalDissipation(turbulence, dictionary);
fvScalarMatrix hEqn ( ... );
if (thermalDissipation.enabled())
{
hEqn += thermalDissipation.dissipation();
}
@endcode
SourceFiles
dissipationSelector.C
\*---------------------------------------------------------------------------*/
#ifndef dissipationSelector_H
#define dissipationSelector_H
#include "NamedEnum.H"
#include "dictionary.H"
#include "incompressible/turbulenceModel/turbulenceModel.H"
#include "volFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace incompressible
{
/*---------------------------------------------------------------------------*\
Class dissipationSelector Declaration
\*---------------------------------------------------------------------------*/
class dissipationSelector
{
public:
//- Type of treatment
enum treatment
{
none,
cascade,
equilibrium
};
static const NamedEnum<treatment, 3> typeNames;
protected:
// Protected data
const turbulenceModel& turbModel_;
//- Type of treatment
treatment treatment_;
public:
// Declare name of the class and its debug switch
ClassName("dissipationSelector");
// Constructors
//- Construct given treatment type
dissipationSelector
(
const turbulenceModel&,
const treatment = none
);
//- Construct given treatment type
dissipationSelector
(
const turbulenceModel&,
const dictionary&
);
// Member functions
//- Get the treatment type
treatment treatmentType() const
{
return treatment_;
}
//- Set the treatment type, return old value
treatment treatmentType(const treatment val)
{
treatment old = treatment_;
treatment_ = val;
return old;
}
//- Set the treatment type, return old value
const char* name() const
{
return typeNames[treatment_];
}
//- Set the treatment type, return old value
bool enabled() const
{
return treatment_ != none;
}
tmp<volScalarField> dissipation() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace incompressible
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

44
src/turbulenceModels/incompressible/turbulenceModel/laminar/laminar.C
View File

@ -199,50 +199,6 @@ tmp<fvVectorMatrix> laminar::divDevReff(volVectorField& U) const
}
tmp<volScalarField> laminar::thermalDissipation() const
{
tmp<volTensorField> tgradU = fvc::grad(this->U());
return tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"thermalDissipation",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- ( this->nu()*dev(twoSymm(tgradU())) ) && tgradU()
)
);
}
tmp<volScalarField> laminar::thermalDissipationEquilibrium() const
{
tmp<volTensorField> tgradU = fvc::grad(this->U());
return tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"thermalDissipationEquilibrium",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
- ( this->nu()*dev(twoSymm(tgradU())) ) && tgradU()
)
);
}
bool laminar::read()
{
return true;

9
src/turbulenceModels/incompressible/turbulenceModel/laminar/laminar.H
View File

@ -110,15 +110,6 @@ public:
//- Return the source term for the momentum equation
virtual tmp<fvVectorMatrix> divDevReff(volVectorField& U) const;
//- The source for the enthalpy equation resulting from
// viscous and turbulent dissipation
virtual tmp<volScalarField> thermalDissipation() const;
//- The source for the enthalpy equation resulting from
// the effective viscous dissipation
// (ie, when turbulent production and dissipation are in equilibrium)
virtual tmp<volScalarField> thermalDissipationEquilibrium() const;
//- Correct the laminar viscosity
virtual void correct();

9
src/turbulenceModels/incompressible/turbulenceModel/turbulenceModel.H
View File

@ -190,15 +190,6 @@ public:
//- Return the source term for the momentum equation
virtual tmp<fvVectorMatrix> divDevReff(volVectorField& U) const = 0;
//- The source for the enthalpy equation resulting from
// viscous and turbulent dissipation
virtual tmp<volScalarField> thermalDissipation() const = 0;
//- The source for the enthalpy equation resulting from
// the effective viscous dissipation
// (ie, when turbulent production and dissipation are in equilibrium)
virtual tmp<volScalarField> thermalDissipationEquilibrium() const = 0;
//- Solve the turbulence equations and correct the turbulence viscosity
virtual void correct() = 0;