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

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

Browse Source
This commit is contained in:
mattijs
2012-06-22 16:43:01 +01:00
parent c6c9819249 0cc2df494f
commit 3a3bd93242
105 changed files with 275 additions and 5479 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
applications/solvers/lagrangian/reactingParcelFoam/Make/options
View File

@ -1,6 +1,7 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I${LIB_SRC}/meshTools/lnInclude \
-I${LIB_SRC}/sampling/lnInclude \
-I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
-I$(LIB_SRC)/lagrangian/basic/lnInclude \
-I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
@ -20,12 +21,14 @@ EXE_INC = \
-I$(LIB_SRC)/regionModels/regionModel/lnInclude \
-I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
-I$(LIB_SRC)/combustionModels/lnInclude \
-I$(LIB_SRC)/fieldSources/lnInclude \
-I$(FOAM_SOLVERS)/combustion/reactingFoam
EXE_LIBS = \
-lfiniteVolume \
-lmeshTools \
-lsampling \
-lcompressibleTurbulenceModel \
-lcompressibleRASModels \
-lcompressibleLESModels \
@ -45,4 +48,5 @@ EXE_LIBS = \
-lODE \
-lregionModels \
-lsurfaceFilmModels \
-lfieldSources \
-lcombustionModels

4
applications/solvers/lagrangian/reactingParcelFoam/UEqn.H
View File

@ -10,8 +10,10 @@
UEqn.relax();
sources.constrain(UEqn);
if (pimple.momentumPredictor())
{
solve(UEqn == -fvc::grad(p));
solve(UEqn == -fvc::grad(p) + sources(rho, U));
K = 0.5*magSqr(U);
}

6
applications/solvers/lagrangian/reactingParcelFoam/YEqn.H
View File

@ -5,7 +5,7 @@ tmp<fv::convectionScheme<scalar> > mvConvection
mesh,
fields,
phi,
mesh.divScheme("div(phi,Yi_h)")
mesh.divScheme("div(phi,Yi_hs)")
)
);
@ -30,9 +30,13 @@ tmp<fv::convectionScheme<scalar> > mvConvection
==
parcels.SYi(i, Yi)
+ combustion->R(Yi)
+ sources(rho, Yi)
);
YiEqn.relax();
sources.constrain(YiEqn);
YiEqn.solve(mesh.solver("Yi"));
Yi.max(0.0);

3
applications/solvers/lagrangian/reactingParcelFoam/createFields.H
View File

@ -97,3 +97,6 @@
mesh,
dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
);
Info<< "Creating sources\n" << endl;
IObasicSourceList sources(mesh);

9
applications/solvers/lagrangian/reactingParcelFoam/hsEqn.H
View File

@ -1,5 +1,5 @@
{
fvScalarMatrix hEqn
fvScalarMatrix hsEqn
(
fvm::ddt(rho, hs)
+ mvConvection->fvmDiv(phi, hs)
@ -10,11 +10,14 @@
+ parcels.Sh(hs)
+ radiation->Sh(thermo)
+ combustion->Sh()
+ sources(rho, hs)
);
hEqn.relax();
hsEqn.relax();
hEqn.solve();
sources.constrain(hsEqn);
hsEqn.solve();
thermo.correct();

5
applications/solvers/lagrangian/reactingParcelFoam/pEqn.H
View File

@ -2,7 +2,7 @@ rho = thermo.rho();
volScalarField rAU(1.0/UEqn.A());
volVectorField HbyA("HbyA", U);
HbyA = rAU*UEqn.H();
HbyA = rAU*(UEqn == sources(rho, U))().H();
if (pimple.transonic())
{
@ -25,6 +25,7 @@ if (pimple.transonic())
- fvm::laplacian(rho*rAU, p)
==
parcels.Srho()
+ sources(psi, p, rho.name())
);
pEqn.solve(mesh.solver(p.select(pimple.finalInnerIter())));
@ -56,6 +57,7 @@ else
- fvm::laplacian(rho*rAU, p)
==
parcels.Srho()
+ sources(psi, p, rho.name())
);
pEqn.solve(mesh.solver(p.select(pimple.finalInnerIter())));
@ -72,6 +74,7 @@ else
U = HbyA - rAU*fvc::grad(p);
U.correctBoundaryConditions();
sources.correct(U);
K = 0.5*magSqr(U);
dpdt = fvc::ddt(p);

1
applications/solvers/lagrangian/reactingParcelFoam/reactingParcelFoam.C
View File

@ -37,6 +37,7 @@ Description
#include "radiationModel.H"
#include "SLGThermo.H"
#include "pimpleControl.H"
#include "IObasicSourceList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

9
applications/solvers/lagrangian/reactingParcelFoam/rhoEqn.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -30,13 +30,18 @@ Description
\*---------------------------------------------------------------------------*/
{
solve
fvScalarMatrix rhoEqn
(
fvm::ddt(rho)
+ fvc::div(phi)
==
parcels.Srho(rho)
+ sources(rho)
);
sources.constrain(rhoEqn);
rhoEqn.solve();
}
// ************************************************************************* //

4
applications/solvers/lagrangian/sprayFoam/Make/options
View File

@ -2,6 +2,7 @@ EXE_INC = \
-I$(FOAM_SOLVERS)/lagrangian/reactingParcelFoam \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I${LIB_SRC}/meshTools/lnInclude \
-I${LIB_SRC}/sampling/lnInclude \
-I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
-I$(LIB_SRC)/lagrangian/basic/lnInclude \
-I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
@ -21,12 +22,14 @@ EXE_INC = \
-I$(LIB_SRC)/ODE/lnInclude \
-I$(LIB_SRC)/regionModels/regionModel/lnInclude \
-I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
-I$(LIB_SRC)/fieldSources/lnInclude \
-I$(LIB_SRC)/combustionModels/lnInclude
EXE_LIBS = \
-lfiniteVolume \
-lmeshTools \
-lsampling \
-lcompressibleTurbulenceModel \
-lcompressibleRASModels \
-lcompressibleLESModels \
@ -47,4 +50,5 @@ EXE_LIBS = \
-lODE \
-lregionModels \
-lsurfaceFilmModels \
-lfieldSources \
-lcombustionModels

4
applications/solvers/lagrangian/sprayFoam/sprayEngineFoam/Make/options
View File

@ -3,6 +3,7 @@ EXE_INC = \
-I$(FOAM_SOLVERS)/lagrangian/reactingParcelFoam \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I${LIB_SRC}/meshTools/lnInclude \
-I${LIB_SRC}/sampling/lnInclude \
-I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
-I$(LIB_SRC)/lagrangian/basic/lnInclude \
-I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
@ -23,12 +24,14 @@ EXE_INC = \
-I$(LIB_SRC)/engine/lnInclude \
-I$(LIB_SRC)/regionModels/regionModel/lnInclude \
-I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
-I$(LIB_SRC)/fieldSources/lnInclude \
-I$(LIB_SRC)/combustionModels/lnInclude
EXE_LIBS = \
-lfiniteVolume \
-lmeshTools \
-lsampling \
-lcompressibleTurbulenceModel \
-lcompressibleRASModels \
-lcompressibleLESModels \
@ -50,4 +53,5 @@ EXE_LIBS = \
-lengine \
-lregionModels \
-lsurfaceFilmModels \
-lfieldSources \
-lcombustionModels

5
applications/solvers/lagrangian/sprayFoam/sprayEngineFoam/pEqn.H
View File

@ -2,7 +2,7 @@ rho = thermo.rho();
volScalarField rAU(1.0/UEqn.A());
volVectorField HbyA("HbyA", U);
HbyA = rAU*UEqn.H();
HbyA = rAU*(UEqn == sources(rho, U))().H();
if (pimple.transonic())
{
@ -25,6 +25,7 @@ if (pimple.transonic())
- fvm::laplacian(rho*rAU, p)
==
parcels.Srho()
+ sources(psi, p, rho.name())
);
pEqn.solve(mesh.solver(p.select(pimple.finalInnerIter())));
@ -56,6 +57,7 @@ else
- fvm::laplacian(rho*rAU, p)
==
parcels.Srho()
+ sources(psi, p, rho.name())
);
pEqn.solve(mesh.solver(p.select(pimple.finalInnerIter())));
@ -72,6 +74,7 @@ else
U = HbyA - rAU*fvc::grad(p);
U.correctBoundaryConditions();
sources.correct(U);
K = 0.5*magSqr(U);
dpdt = fvc::ddt(p);

1
applications/solvers/lagrangian/sprayFoam/sprayEngineFoam/sprayEngineFoam.C
View File

@ -39,6 +39,7 @@ Description
#include "radiationModel.H"
#include "SLGThermo.H"
#include "pimpleControl.H"
#include "IObasicSourceList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

1
applications/solvers/lagrangian/sprayFoam/sprayFoam.C
View File

@ -37,6 +37,7 @@ Description
#include "radiationModel.H"
#include "SLGThermo.H"
#include "pimpleControl.H"
#include "IObasicSourceList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

7
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/alphaEqn.H
View File

@ -68,10 +68,11 @@ surfaceScalarField alphaPhi2("alphaPhi2", phi2);
if (g0.value() > 0.0)
{
ppMagf = rAU1f*fvc::interpolate
ppMagf =
fvc::interpolate((1.0/rho1)*rAU1)
*fvc::interpolate
(
(1.0/(rho1*(alpha1 + scalar(0.0001))))
*g0*min(exp(preAlphaExp*(alpha1 - alphaMax)), expMax)
g0*min(exp(preAlphaExp*(alpha1 - alphaMax)), expMax)
);
alpha1Eqn -= fvm::laplacian

4
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/createFields.H
View File

@ -333,11 +333,11 @@
drag1
);
surfaceScalarField rAU1f
volScalarField rAU1
(
IOobject
(
"rAU1f",
"rAU1",
runTime.timeName(),
mesh,
IOobject::NO_READ,

1
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/kineticTheoryModels/Make/files
View File

@ -16,7 +16,6 @@ conductivityModel/HrenyaSinclair/HrenyaSinclairConductivity.C
radialModel/radialModel/radialModel.C
radialModel/radialModel/newRadialModel.C
radialModel/CarnahanStarling/CarnahanStarlingRadial.C
radialModel/Gidaspow/GidaspowRadial.C
radialModel/LunSavage/LunSavageRadial.C
radialModel/SinclairJackson/SinclairJacksonRadial.C

17
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/kineticTheoryModels/radialModel/CarnahanStarling/CarnahanStarlingRadial.C
View File

@ -69,30 +69,29 @@ Foam::kineticTheoryModels::radialModels::CarnahanStarling::~CarnahanStarling()
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::CarnahanStarling::g0
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const
{
return
1.0/(1.0 - alpha1)
+ 3.0*alpha1/(2.0*sqr(1.0 - alpha1))
+ sqr(alpha1)/(2.0*pow(1.0 - alpha1, 3));
1.0/(1.0 - alpha)
+ 3.0*alpha/(2.0*sqr(1.0 - alpha))
+ sqr(alpha)/(2.0*pow(1.0 - alpha, 3));
}
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::CarnahanStarling::g0prime
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const
{
return
- alpha1/sqr(1.0 - alpha1)
+ (3.0*(1.0 - alpha1) + 6.0*sqr(alpha1))/(2.0*(1.0 - alpha1))
+ (2.0*alpha1*(1.0 - alpha1) + 3.0*pow(alpha1, 3))
/(2.0*pow(1.0 - alpha1, 4));
2.5/sqr(1.0 - alpha)
+ 4.0*alpha/pow(1.0 - alpha, 3.0)
+ 1.5*sqr(alpha)/pow(1.0 - alpha, 4.0);
}

4
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/kineticTheoryModels/radialModel/CarnahanStarling/CarnahanStarlingRadial.H
View File

@ -75,13 +75,13 @@ public:
tmp<volScalarField> g0
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const;
tmp<volScalarField> g0prime
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const;
};

93
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/kineticTheoryModels/radialModel/Gidaspow/GidaspowRadial.C
View File

@ -1,93 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "GidaspowRadial.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace radialModels
{
defineTypeNameAndDebug(Gidaspow, 0);
addToRunTimeSelectionTable
(
radialModel,
Gidaspow,
dictionary
);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::radialModels::Gidaspow::Gidaspow
(
const dictionary& dict
)
:
radialModel(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::radialModels::Gidaspow::~Gidaspow()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::Gidaspow::g0
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const
{
return 0.6/(1.0 - pow(alpha1/alphaMax, 1.0/3.0));
}
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::Gidaspow::g0prime
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const
{
return
(-1.0/5.0)*pow(alpha1/alphaMax, -2.0/3.0)
/(alphaMax*sqr(1.0 - pow(alpha1/alphaMax, 1.0/3.0)));
}
// ************************************************************************* //

99
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/kineticTheoryModels/radialModel/Gidaspow/GidaspowRadial.H
View File

@ -1,99 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::kineticTheoryModels::radialModels::Gidaspow
Description
SourceFiles
GidaspowRadial.C
\*---------------------------------------------------------------------------*/
#ifndef Gidaspow_H
#define Gidaspow_H
#include "radialModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace radialModels
{
/*---------------------------------------------------------------------------*\
Class Gidaspow Declaration
\*---------------------------------------------------------------------------*/
class Gidaspow
:
public radialModel
{
public:
//- Runtime type information
TypeName("Gidaspow");
// Constructors
//- Construct from components
Gidaspow(const dictionary& dict);
//- Destructor
virtual ~Gidaspow();
// Member Functions
tmp<volScalarField> g0
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const;
tmp<volScalarField> g0prime
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace radialModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

8
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/kineticTheoryModels/radialModel/LunSavage/LunSavageRadial.C
View File

@ -69,23 +69,23 @@ Foam::kineticTheoryModels::radialModels::LunSavage::~LunSavage()
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::LunSavage::g0
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const
{
return pow(1.0 - alpha1/alphaMax, -2.5*alphaMax);
return pow(1.0 - alpha/alphaMax, -2.5*alphaMax);
}
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::LunSavage::g0prime
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const
{
return 2.5*alphaMax*alpha1*pow(1.0 - alpha1, -1.0 - 2.5*alphaMax);
return 2.5*pow(1.0 - alpha/alphaMax, -1.0 - 2.5*alphaMax);
}

4
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/kineticTheoryModels/radialModel/LunSavage/LunSavageRadial.H
View File

@ -74,13 +74,13 @@ public:
tmp<volScalarField> g0
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const;
tmp<volScalarField> g0prime
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const;
};

10
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/kineticTheoryModels/radialModel/SinclairJackson/SinclairJacksonRadial.C
View File

@ -69,24 +69,24 @@ Foam::kineticTheoryModels::radialModels::SinclairJackson::~SinclairJackson()
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::SinclairJackson::g0
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const
{
return 1.0/(1.0 - pow(alpha1/alphaMax, 1.0/3.0));
return 1.0/(1.0 - pow(alpha/alphaMax, 1.0/3.0));
}
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::SinclairJackson::g0prime
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const
{
return
(-1.0/3.0)*pow(alpha1/alphaMax, -2.0/3.0)
/(alphaMax*sqr(1.0 - pow(alpha1/alphaMax, 1.0/3.0)));
(1.0/3.0)*pow(max(alpha, 1.0e-6)/alphaMax, -2.0/3.0)
/(alphaMax*sqr(1.0 - pow(alpha/alphaMax, 1.0/3.0)));
}

4
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/kineticTheoryModels/radialModel/SinclairJackson/SinclairJacksonRadial.H
View File

@ -74,13 +74,13 @@ public:
tmp<volScalarField> g0
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const;
tmp<volScalarField> g0prime
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const;
};

4
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/kineticTheoryModels/radialModel/radialModel/radialModel.H
View File

@ -107,14 +107,14 @@ public:
//- Radial distribution function
virtual tmp<volScalarField> g0
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const = 0;
//- Derivative of the radial distribution function
virtual tmp<volScalarField> g0prime
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const = 0;
};

15
applications/solvers/multiphase/compressibleTwoPhaseEulerFoam/pEqn.H
View File

@ -10,7 +10,7 @@
surfaceScalarField alpha1f(fvc::interpolate(alpha1));
surfaceScalarField alpha2f(scalar(1) - alpha1f);
volScalarField rAU1(1.0/U1Eqn.A());
rAU1 = 1.0/U1Eqn.A();
volScalarField rAU2(1.0/U2Eqn.A());
surfaceScalarField rAlphaAU1f(fvc::interpolate(alpha1*rAU1));
@ -30,6 +30,19 @@
+ fvc::interpolate((1.0/rho1)*rAU1*dragCoeff)*phi2
+ rAlphaAU1f*(g & mesh.Sf())
);
if (g0.value() > 0.0)
{
phiHbyA1 -= ppMagf*fvc::snGrad(alpha1)*mesh.magSf();
}
if (kineticTheory.on())
{
phiHbyA1 -=
fvc::interpolate((1.0/rho1)*rAU1)
*fvc::snGrad(kineticTheory.pa())*mesh.magSf();
}
mrfZones.relativeFlux(phiHbyA1);
surfaceScalarField phiHbyA2

1
applications/solvers/multiphase/multiphaseEulerFoam/Allwclean
View File

@ -5,7 +5,6 @@ set -x
wclean libso phaseModel
wclean libso multiphaseSystem
wclean libso interfacialModels
wclean libso kineticTheoryModels
wclean
# ----------------------------------------------------------------- end-of-file

1
applications/solvers/multiphase/multiphaseEulerFoam/Allwmake
View File

@ -5,7 +5,6 @@ set -x
wmake libso phaseModel
wmake libso interfacialModels
wmake libso multiphaseSystem
wmake libso kineticTheoryModels
wmake
# ----------------------------------------------------------------- end-of-file

2
applications/solvers/multiphase/multiphaseEulerFoam/Make/options
View File

@ -2,7 +2,6 @@ EXE_INC = \
-IphaseModel/lnInclude \
-ImultiphaseSystem/lnInclude \
-ImultiphaseFixedFluxPressure \
/*-IkineticTheoryModels/lnInclude*/ \
-IinterfacialModels/lnInclude \
-I$(LIB_SRC)/transportModels \
-I$(LIB_SRC)/transportModels/incompressible/lnInclude \
@ -20,6 +19,5 @@ EXE_LIBS = \
-linterfaceProperties \
-lincompressibleTransportModels \
-lcompressibleMultiphaseEulerianInterfacialModels \
/*-lcompressibleKineticTheoryModel*/ \
-lincompressibleLESModels \
-lfiniteVolume

33
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/Make/files
View File

@ -1,33 +0,0 @@
kineticTheoryModel/kineticTheoryModel.C
viscosityModel/viscosityModel/viscosityModel.C
viscosityModel/viscosityModel/newViscosityModel.C
viscosityModel/Gidaspow/GidaspowViscosity.C
viscosityModel/Syamlal/SyamlalViscosity.C
viscosityModel/HrenyaSinclair/HrenyaSinclairViscosity.C
viscosityModel/none/noneViscosity.C
conductivityModel/conductivityModel/conductivityModel.C
conductivityModel/conductivityModel/newConductivityModel.C
conductivityModel/Gidaspow/GidaspowConductivity.C
conductivityModel/Syamlal/SyamlalConductivity.C
conductivityModel/HrenyaSinclair/HrenyaSinclairConductivity.C
radialModel/radialModel/radialModel.C
radialModel/radialModel/newRadialModel.C
radialModel/CarnahanStarling/CarnahanStarlingRadial.C
radialModel/Gidaspow/GidaspowRadial.C
radialModel/LunSavage/LunSavageRadial.C
radialModel/SinclairJackson/SinclairJacksonRadial.C
granularPressureModel/granularPressureModel/granularPressureModel.C
granularPressureModel/granularPressureModel/newGranularPressureModel.C
granularPressureModel/Lun/LunPressure.C
granularPressureModel/SyamlalRogersOBrien/SyamlalRogersOBrienPressure.C
frictionalStressModel/frictionalStressModel/frictionalStressModel.C
frictionalStressModel/frictionalStressModel/newFrictionalStressModel.C
frictionalStressModel/JohnsonJackson/JohnsonJacksonFrictionalStress.C
frictionalStressModel/Schaeffer/SchaefferFrictionalStress.C
LIB = $(FOAM_LIBBIN)/libcompressibleMultiphaseKineticTheoryModel

5
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/Make/options
View File

@ -1,5 +0,0 @@
EXE_INC = \
-I$(LIB_SRC)/foam/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I../phaseModel/lnInclude \
-I../interfacialModels/lnInclude

93
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/conductivityModel/Gidaspow/GidaspowConductivity.C
View File

@ -1,93 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "GidaspowConductivity.H"
#include "mathematicalConstants.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace conductivityModels
{
defineTypeNameAndDebug(Gidaspow, 0);
addToRunTimeSelectionTable
(
conductivityModel,
Gidaspow,
dictionary
);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::conductivityModels::Gidaspow::Gidaspow
(
const dictionary& dict
)
:
conductivityModel(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::conductivityModels::Gidaspow::~Gidaspow()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::conductivityModels::Gidaspow::kappa
(
const volScalarField& alpha1,
const volScalarField& Theta,
const volScalarField& g0,
const dimensionedScalar& rho1,
const volScalarField& da,
const dimensionedScalar& e
) const
{
const scalar sqrtPi = sqrt(constant::mathematical::pi);
return rho1*da*sqrt(Theta)*
(
2.0*sqr(alpha1)*g0*(1.0 + e)/sqrtPi
+ (9.0/8.0)*sqrtPi*g0*0.5*(1.0 + e)*sqr(alpha1)
+ (15.0/16.0)*sqrtPi*alpha1
+ (25.0/64.0)*sqrtPi/((1.0 + e)*g0)
);
}
// ************************************************************************* //

97
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/conductivityModel/Gidaspow/GidaspowConductivity.H
View File

@ -1,97 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::kineticTheoryModels::conductivityModels::Gidaspow
Description
SourceFiles
Gidaspow.C
\*---------------------------------------------------------------------------*/
#ifndef Gidaspow_H
#define Gidaspow_H
#include "conductivityModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace conductivityModels
{
/*---------------------------------------------------------------------------*\
Class Gidaspow Declaration
\*---------------------------------------------------------------------------*/
class Gidaspow
:
public conductivityModel
{
public:
//- Runtime type information
TypeName("Gidaspow");
// Constructors
//- Construct from components
Gidaspow(const dictionary& dict);
//- Destructor
virtual ~Gidaspow();
// Member Functions
tmp<volScalarField> kappa
(
const volScalarField& alpha1,
const volScalarField& Theta,
const volScalarField& g0,
const dimensionedScalar& rho1,
const volScalarField& da,
const dimensionedScalar& e
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace conductivityModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

104
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/conductivityModel/HrenyaSinclair/HrenyaSinclairConductivity.C
View File

@ -1,104 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "HrenyaSinclairConductivity.H"
#include "mathematicalConstants.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace conductivityModels
{
defineTypeNameAndDebug(HrenyaSinclair, 0);
addToRunTimeSelectionTable
(
conductivityModel,
HrenyaSinclair,
dictionary
);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::conductivityModels::HrenyaSinclair::HrenyaSinclair
(
const dictionary& dict
)
:
conductivityModel(dict),
coeffsDict_(dict.subDict(typeName + "Coeffs")),
L_(coeffsDict_.lookup("L"))
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::conductivityModels::HrenyaSinclair::
~HrenyaSinclair()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::conductivityModels::HrenyaSinclair::kappa
(
const volScalarField& alpha1,
const volScalarField& Theta,
const volScalarField& g0,
const dimensionedScalar& rho1,
const volScalarField& da,
const dimensionedScalar& e
) const
{
const scalar sqrtPi = sqrt(constant::mathematical::pi);
volScalarField lamda
(
scalar(1) + da/(6.0*sqrt(2.0)*(alpha1 + scalar(1.0e-5)))/L_
);
return rho1*da*sqrt(Theta)*
(
2.0*sqr(alpha1)*g0*(1.0 + e)/sqrtPi
+ (9.0/8.0)*sqrtPi*0.25*sqr(1.0 + e)*(2.0*e - 1.0)*sqr(alpha1)
/(49.0/16.0 - 33.0*e/16.0)
+ (15.0/16.0)*sqrtPi*alpha1*(0.5*sqr(e) + 0.25*e - 0.75 + lamda)
/((49.0/16.0 - 33.0*e/16.0)*lamda)
+ (25.0/64.0)*sqrtPi
/((1.0 + e)*(49.0/16.0 - 33.0*e/16.0)*lamda*g0)
);
}
// ************************************************************************* //

102
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/conductivityModel/HrenyaSinclair/HrenyaSinclairConductivity.H
View File

@ -1,102 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::kineticTheoryModels::conductivityModels::HrenyaSinclair
Description
SourceFiles
HrenyaSinclair.C
\*---------------------------------------------------------------------------*/
#ifndef HrenyaSinclair_H
#define HrenyaSinclair_H
#include "conductivityModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace conductivityModels
{
/*---------------------------------------------------------------------------*\
Class HrenyaSinclair Declaration
\*---------------------------------------------------------------------------*/
class HrenyaSinclair
:
public conductivityModel
{
dictionary coeffsDict_;
//- characteristic length of geometry
dimensionedScalar L_;
public:
//- Runtime type information
TypeName("HrenyaSinclair");
// Constructors
//- Construct from components
HrenyaSinclair(const dictionary& dict);
//- Destructor
virtual ~HrenyaSinclair();
// Member Functions
tmp<volScalarField> kappa
(
const volScalarField& alpha1,
const volScalarField& Theta,
const volScalarField& g0,
const dimensionedScalar& rho1,
const volScalarField& da,
const dimensionedScalar& e
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace conductivityModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

93
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/conductivityModel/Syamlal/SyamlalConductivity.C
View File

@ -1,93 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "SyamlalConductivity.H"
#include "mathematicalConstants.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace conductivityModels
{
defineTypeNameAndDebug(Syamlal, 0);
addToRunTimeSelectionTable
(
conductivityModel,
Syamlal,
dictionary
);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::conductivityModels::Syamlal::Syamlal
(
const dictionary& dict
)
:
conductivityModel(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::conductivityModels::Syamlal::~Syamlal()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::conductivityModels::Syamlal::kappa
(
const volScalarField& alpha1,
const volScalarField& Theta,
const volScalarField& g0,
const dimensionedScalar& rho1,
const volScalarField& da,
const dimensionedScalar& e
) const
{
const scalar sqrtPi = sqrt(constant::mathematical::pi);
return rho1*da*sqrt(Theta)*
(
2.0*sqr(alpha1)*g0*(1.0 + e)/sqrtPi
+ (9.0/8.0)*sqrtPi*g0*0.25*sqr(1.0 + e)*(2.0*e - 1.0)*sqr(alpha1)
/(49.0/16.0 - 33.0*e/16.0)
+ (15.0/32.0)*sqrtPi*alpha1/(49.0/16.0 - 33.0*e/16.0)
);
}
// ************************************************************************* //

97
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/conductivityModel/Syamlal/SyamlalConductivity.H
View File

@ -1,97 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::kineticTheoryModels::conductivityModels::Syamlal
Description
SourceFiles
Syamlal.C
\*---------------------------------------------------------------------------*/
#ifndef Syamlal_H
#define Syamlal_H
#include "conductivityModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace conductivityModels
{
/*---------------------------------------------------------------------------*\
Class Syamlal Declaration
\*---------------------------------------------------------------------------*/
class Syamlal
:
public conductivityModel
{
public:
//- Runtime type information
TypeName("Syamlal");
// Constructors
//- Construct from components
Syamlal(const dictionary& dict);
//- Destructor
virtual ~Syamlal();
// Member Functions
tmp<volScalarField> kappa
(
const volScalarField& alpha1,
const volScalarField& Theta,
const volScalarField& g0,
const dimensionedScalar& rho1,
const volScalarField& da,
const dimensionedScalar& e
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace conductivityModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

58
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/conductivityModel/conductivityModel/conductivityModel.C
View File

@ -1,58 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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 "conductivityModel.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
defineTypeNameAndDebug(conductivityModel, 0);
defineRunTimeSelectionTable(conductivityModel, dictionary);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::conductivityModel::conductivityModel
(
const dictionary& dict
)
:
dict_(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::conductivityModel::~conductivityModel()
{}
// ************************************************************************* //

128
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/conductivityModel/conductivityModel/conductivityModel.H
View File

@ -1,128 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::kineticTheoryModels::conductivityModel
SourceFiles
conductivityModel.C
\*---------------------------------------------------------------------------*/
#ifndef conductivityModel_H
#define conductivityModel_H
#include "dictionary.H"
#include "volFields.H"
#include "dimensionedTypes.H"
#include "runTimeSelectionTables.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
/*---------------------------------------------------------------------------*\
Class conductivityModel Declaration
\*---------------------------------------------------------------------------*/
class conductivityModel
{
// Private member functions
//- Disallow default bitwise copy construct
conductivityModel(const conductivityModel&);
//- Disallow default bitwise assignment
void operator=(const conductivityModel&);
protected:
// Protected data
const dictionary& dict_;
public:
//- Runtime type information
TypeName("conductivityModel");
// Declare runtime constructor selection table
declareRunTimeSelectionTable
(
autoPtr,
conductivityModel,
dictionary,
(
const dictionary& dict
),
(dict)
);
// Constructors
//- Construct from components
conductivityModel(const dictionary& dict);
// Selectors
static autoPtr<conductivityModel> New
(
const dictionary& dict
);
//- Destructor
virtual ~conductivityModel();
// Member Functions
virtual tmp<volScalarField> kappa
(
const volScalarField& alpha1,
const volScalarField& Theta,
const volScalarField& g0,
const dimensionedScalar& rho1,
const volScalarField& da,
const dimensionedScalar& e
) const = 0;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

59
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/conductivityModel/conductivityModel/newConductivityModel.C
View File

@ -1,59 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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 "conductivityModel.H"
// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::kineticTheoryModels::conductivityModel>
Foam::kineticTheoryModels::conductivityModel::New
(
const dictionary& dict
)
{
word conductivityModelType(dict.lookup("conductivityModel"));
Info<< "Selecting conductivityModel "
<< conductivityModelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(conductivityModelType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalError
<< "conductivityModel::New(const dictionary&) : " << endl
<< " unknown conductivityModelType type "
<< conductivityModelType
<< ", constructor not in hash table" << endl << endl
<< " Valid conductivityModelType types are :" << endl;
Info<< dictionaryConstructorTablePtr_->sortedToc() << abort(FatalError);
}
return autoPtr<conductivityModel>(cstrIter()(dict));
}
// ************************************************************************* //

125
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/frictionalStressModel/JohnsonJackson/JohnsonJacksonFrictionalStress.C
View File

@ -1,125 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "JohnsonJacksonFrictionalStress.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace frictionalStressModels
{
defineTypeNameAndDebug(JohnsonJackson, 0);
addToRunTimeSelectionTable
(
frictionalStressModel,
JohnsonJackson,
dictionary
);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::frictionalStressModels::JohnsonJackson::
JohnsonJackson
(
const dictionary& dict
)
:
frictionalStressModel(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::frictionalStressModels::JohnsonJackson::
~JohnsonJackson()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::frictionalStressModels::JohnsonJackson::
frictionalPressure
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMinFriction,
const dimensionedScalar& alphaMax,
const dimensionedScalar& Fr,
const dimensionedScalar& eta,
const dimensionedScalar& p
) const
{
return
Fr*pow(max(alpha1 - alphaMinFriction, scalar(0)), eta)
/pow(max(alphaMax - alpha1, scalar(5.0e-2)), p);
}
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::frictionalStressModels::JohnsonJackson::
frictionalPressurePrime
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMinFriction,
const dimensionedScalar& alphaMax,
const dimensionedScalar& Fr,
const dimensionedScalar& eta,
const dimensionedScalar& p
) const
{
return Fr*
(
eta*pow(max(alpha1 - alphaMinFriction, scalar(0)), eta - 1.0)
*(alphaMax-alpha1)
+ p*pow(max(alpha1 - alphaMinFriction, scalar(0)), eta)
)/pow(max(alphaMax - alpha1, scalar(5.0e-2)), p + 1.0);
}
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::frictionalStressModels::JohnsonJackson::muf
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax,
const volScalarField& pf,
const volSymmTensorField& D,
const dimensionedScalar& phi
) const
{
return dimensionedScalar("0.5", dimTime, 0.5)*pf*sin(phi);
}
// ************************************************************************* //

116
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/frictionalStressModel/JohnsonJackson/JohnsonJacksonFrictionalStress.H
View File

@ -1,116 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::kineticTheoryModels::frictionalStressModels::JohnsonJackson
Description
SourceFiles
JohnsonJacksonFrictionalStress.C
\*---------------------------------------------------------------------------*/
#ifndef JohnsonJackson_H
#define JohnsonJackson_H
#include "frictionalStressModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace frictionalStressModels
{
/*---------------------------------------------------------------------------*\
Class JohnsonJackson Declaration
\*---------------------------------------------------------------------------*/
class JohnsonJackson
:
public frictionalStressModel
{
public:
//- Runtime type information
TypeName("JohnsonJackson");
// Constructors
//- Construct from components
JohnsonJackson(const dictionary& dict);
//- Destructor
virtual ~JohnsonJackson();
// Member functions
virtual tmp<volScalarField> frictionalPressure
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMinFriction,
const dimensionedScalar& alphaMax,
const dimensionedScalar& Fr,
const dimensionedScalar& eta,
const dimensionedScalar& p
) const;
virtual tmp<volScalarField> frictionalPressurePrime
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMinFriction,
const dimensionedScalar& alphaMax,
const dimensionedScalar& Fr,
const dimensionedScalar& eta,
const dimensionedScalar& p
) const;
virtual tmp<volScalarField> muf
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax,
const volScalarField& pf,
const volSymmTensorField& D,
const dimensionedScalar& phi
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace frictionalStressModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

158
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/frictionalStressModel/Schaeffer/SchaefferFrictionalStress.C
View File

@ -1,158 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "SchaefferFrictionalStress.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace frictionalStressModels
{
defineTypeNameAndDebug(Schaeffer, 0);
addToRunTimeSelectionTable
(
frictionalStressModel,
Schaeffer,
dictionary
);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::frictionalStressModels::Schaeffer::Schaeffer
(
const dictionary& dict
)
:
frictionalStressModel(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::frictionalStressModels::Schaeffer::~Schaeffer()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::frictionalStressModels::Schaeffer::
frictionalPressure
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMinFriction,
const dimensionedScalar& alphaMax,
const dimensionedScalar& Fr,
const dimensionedScalar& eta,
const dimensionedScalar& p
) const
{
return
dimensionedScalar("1e24", dimensionSet(1, -1, -2, 0, 0), 1e24)
*pow(Foam::max(alpha1 - alphaMinFriction, scalar(0)), 10.0);
}
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::frictionalStressModels::Schaeffer::
frictionalPressurePrime
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMinFriction,
const dimensionedScalar& alphaMax,
const dimensionedScalar& Fr,
const dimensionedScalar& eta,
const dimensionedScalar& p
) const
{
return
dimensionedScalar("1e25", dimensionSet(1, -1, -2, 0, 0), 1e25)
*pow(Foam::max(alpha1 - alphaMinFriction, scalar(0)), 9.0);
}
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::frictionalStressModels::Schaeffer::muf
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax,
const volScalarField& pf,
const volSymmTensorField& D,
const dimensionedScalar& phi
) const
{
const scalar I2Dsmall = 1.0e-15;
// Creating muf assuming it should be 0 on the boundary which may not be
// true
tmp<volScalarField> tmuf
(
new volScalarField
(
IOobject
(
"muf",
alpha1.mesh().time().timeName(),
alpha1.mesh()
),
alpha1.mesh(),
dimensionedScalar("muf", dimensionSet(1, -1, -1, 0, 0), 0.0)
)
);
volScalarField& muff = tmuf();
forAll (D, celli)
{
if (alpha1[celli] > alphaMax.value() - 5e-2)
{
muff[celli] =
0.5*pf[celli]*sin(phi.value())
/(
sqrt(1.0/6.0*(sqr(D[celli].xx() - D[celli].yy())
+ sqr(D[celli].yy() - D[celli].zz())
+ sqr(D[celli].zz() - D[celli].xx()))
+ sqr(D[celli].xy()) + sqr(D[celli].xz())
+ sqr(D[celli].yz())) + I2Dsmall
);
}
}
muff.correctBoundaryConditions();
return tmuf;
}
// ************************************************************************* //

116
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/frictionalStressModel/Schaeffer/SchaefferFrictionalStress.H
View File

@ -1,116 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::kineticTheoryModels::frictionalStressModels::Schaeffer
Description
SourceFiles
SchaefferFrictionalStress.C
\*---------------------------------------------------------------------------*/
#ifndef Schaeffer_H
#define Schaeffer_H
#include "frictionalStressModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace frictionalStressModels
{
/*---------------------------------------------------------------------------*\
Class Schaeffer Declaration
\*---------------------------------------------------------------------------*/
class Schaeffer
:
public frictionalStressModel
{
public:
//- Runtime type information
TypeName("Schaeffer");
// Constructors
//- Construct from components
Schaeffer(const dictionary& dict);
//- Destructor
virtual ~Schaeffer();
// Member functions
virtual tmp<volScalarField> frictionalPressure
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMinFriction,
const dimensionedScalar& alphaMax,
const dimensionedScalar& Fr,
const dimensionedScalar& eta,
const dimensionedScalar& p
) const;
virtual tmp<volScalarField> frictionalPressurePrime
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMinFriction,
const dimensionedScalar& alphaMax,
const dimensionedScalar& Fr,
const dimensionedScalar& n,
const dimensionedScalar& p
) const;
virtual tmp<volScalarField> muf
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax,
const volScalarField& pf,
const volSymmTensorField& D,
const dimensionedScalar& phi
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace frictionalStressModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

58
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/frictionalStressModel/frictionalStressModel/frictionalStressModel.C
View File

@ -1,58 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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 "frictionalStressModel.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
defineTypeNameAndDebug(frictionalStressModel, 0);
defineRunTimeSelectionTable(frictionalStressModel, dictionary);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::frictionalStressModel::frictionalStressModel
(
const dictionary& dict
)
:
dict_(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::frictionalStressModel::~frictionalStressModel()
{}
// ************************************************************************* //

147
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/frictionalStressModel/frictionalStressModel/frictionalStressModel.H
View File

@ -1,147 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::kineticTheoryModels::frictionalStressModel
SourceFiles
frictionalStressModel.C
\*---------------------------------------------------------------------------*/
#ifndef frictionalStressModel_H
#define frictionalStressModel_H
#include "dictionary.H"
#include "volFields.H"
#include "dimensionedTypes.H"
#include "runTimeSelectionTables.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
/*---------------------------------------------------------------------------*\
Class frictionalStressModel Declaration
\*---------------------------------------------------------------------------*/
class frictionalStressModel
{
// Private member functions
//- Disallow default bitwise copy construct
frictionalStressModel(const frictionalStressModel&);
//- Disallow default bitwise assignment
void operator=(const frictionalStressModel&);
protected:
// Protected data
const dictionary& dict_;
public:
//- Runtime type information
TypeName("frictionalStressModel");
// Declare runtime constructor selection table
declareRunTimeSelectionTable
(
autoPtr,
frictionalStressModel,
dictionary,
(
const dictionary& dict
),
(dict)
);
// Constructors
//- Construct from components
frictionalStressModel(const dictionary& dict);
// Selectors
static autoPtr<frictionalStressModel> New
(
const dictionary& dict
);
//- Destructor
virtual ~frictionalStressModel();
// Member Functions
virtual tmp<volScalarField> frictionalPressure
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMinFriction,
const dimensionedScalar& alphaMax,
const dimensionedScalar& Fr,
const dimensionedScalar& eta,
const dimensionedScalar& p
) const = 0;
virtual tmp<volScalarField> frictionalPressurePrime
(
const volScalarField& alpha1f,
const dimensionedScalar& alphaMinFriction,
const dimensionedScalar& alphaMax,
const dimensionedScalar& Fr,
const dimensionedScalar& eta,
const dimensionedScalar& p
) const = 0;
virtual tmp<volScalarField> muf
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax,
const volScalarField& pf,
const volSymmTensorField& D,
const dimensionedScalar& phi
) const = 0;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

60
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/frictionalStressModel/frictionalStressModel/newFrictionalStressModel.C
View File

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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 "frictionalStressModel.H"
// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::kineticTheoryModels::frictionalStressModel>
Foam::kineticTheoryModels::frictionalStressModel::New
(
const dictionary& dict
)
{
word frictionalStressModelType(dict.lookup("frictionalStressModel"));
Info<< "Selecting frictionalStressModel "
<< frictionalStressModelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(frictionalStressModelType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalError
<< "frictionalStressModel::New(const dictionary&) : " << endl
<< " unknown frictionalStressModelType type "
<< frictionalStressModelType
<< ", constructor not in hash table" << endl << endl
<< " Valid frictionalStressModelType types are :" << endl;
Info<< dictionaryConstructorTablePtr_->sortedToc()
<< abort(FatalError);
}
return autoPtr<frictionalStressModel>(cstrIter()(dict));
}
// ************************************************************************* //

98
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/granularPressureModel/Lun/LunPressure.C
View File

@ -1,98 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "LunPressure.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace granularPressureModels
{
defineTypeNameAndDebug(Lun, 0);
addToRunTimeSelectionTable
(
granularPressureModel,
Lun,
dictionary
);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::granularPressureModels::Lun::Lun
(
const dictionary& dict
)
:
granularPressureModel(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::granularPressureModels::Lun::~Lun()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::granularPressureModels::Lun::granularPressureCoeff
(
const volScalarField& alpha1,
const volScalarField& g0,
const dimensionedScalar& rho1,
const dimensionedScalar& e
) const
{
return rho1*alpha1*(1.0 + 2.0*(1.0 + e)*alpha1*g0);
}
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::granularPressureModels::Lun::
granularPressureCoeffPrime
(
const volScalarField& alpha1,
const volScalarField& g0,
const volScalarField& g0prime,
const dimensionedScalar& rho1,
const dimensionedScalar& e
) const
{
return rho1*(1.0 + alpha1*(1.0 + e)*(4.0*g0 + 2.0*g0prime*alpha1));
}
// ************************************************************************* //

104
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/granularPressureModel/Lun/LunPressure.H
View File

@ -1,104 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::Lun
Description
SourceFiles
LunPressure.C
\*---------------------------------------------------------------------------*/
#ifndef Lun_H
#define Lun_H
#include "granularPressureModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace granularPressureModels
{
/*---------------------------------------------------------------------------*\
Class Lun Declaration
\*---------------------------------------------------------------------------*/
class Lun
:
public granularPressureModel
{
public:
//- Runtime type information
TypeName("Lun");
// Constructors
//- Construct from components
Lun(const dictionary& dict);
//- Destructor
virtual ~Lun();
// Member Functions
tmp<volScalarField> granularPressureCoeff
(
const volScalarField& alpha1,
const volScalarField& g0,
const dimensionedScalar& rho1,
const dimensionedScalar& e
) const;
tmp<volScalarField> granularPressureCoeffPrime
(
const volScalarField& alpha1,
const volScalarField& g0,
const volScalarField& g0prime,
const dimensionedScalar& rho1,
const dimensionedScalar& e
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace granularPressureModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

101
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/granularPressureModel/SyamlalRogersOBrien/SyamlalRogersOBrienPressure.C
View File

@ -1,101 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "SyamlalRogersOBrienPressure.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace granularPressureModels
{
defineTypeNameAndDebug(SyamlalRogersOBrien, 0);
addToRunTimeSelectionTable
(
granularPressureModel,
SyamlalRogersOBrien,
dictionary
);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::granularPressureModels::SyamlalRogersOBrien::
SyamlalRogersOBrien
(
const dictionary& dict
)
:
granularPressureModel(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::granularPressureModels::SyamlalRogersOBrien::
~SyamlalRogersOBrien()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::granularPressureModels::SyamlalRogersOBrien::
granularPressureCoeff
(
const volScalarField& alpha1,
const volScalarField& g0,
const dimensionedScalar& rho1,
const dimensionedScalar& e
) const
{
return 2.0*rho1*(1.0 + e)*sqr(alpha1)*g0;
}
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::granularPressureModels::SyamlalRogersOBrien::
granularPressureCoeffPrime
(
const volScalarField& alpha1,
const volScalarField& g0,
const volScalarField& g0prime,
const dimensionedScalar& rho1,
const dimensionedScalar& e
) const
{
return rho1*alpha1*(1.0 + e)*(4.0*g0 + 2.0*g0prime*alpha1);
}
// ************************************************************************* //

104
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/granularPressureModel/SyamlalRogersOBrien/SyamlalRogersOBrienPressure.H
View File

@ -1,104 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::SyamlalRogersOBrien
Description
SourceFiles
SyamlalRogersOBrienPressure.C
\*---------------------------------------------------------------------------*/
#ifndef SyamlalRogersOBrien_H
#define SyamlalRogersOBrien_H
#include "granularPressureModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace granularPressureModels
{
/*---------------------------------------------------------------------------*\
Class SyamlalRogersOBrien Declaration
\*---------------------------------------------------------------------------*/
class SyamlalRogersOBrien
:
public granularPressureModel
{
public:
//- Runtime type information
TypeName("SyamlalRogersOBrien");
// Constructors
//- Construct from components
SyamlalRogersOBrien(const dictionary& dict);
//- Destructor
virtual ~SyamlalRogersOBrien();
// Member Functions
tmp<volScalarField> granularPressureCoeff
(
const volScalarField& alpha1,
const volScalarField& g0,
const dimensionedScalar& rho1,
const dimensionedScalar& e
) const;
tmp<volScalarField> granularPressureCoeffPrime
(
const volScalarField& alpha1,
const volScalarField& g0,
const volScalarField& g0prime,
const dimensionedScalar& rho1,
const dimensionedScalar& e
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace granularPressureModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

58
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/granularPressureModel/granularPressureModel/granularPressureModel.C
View File

@ -1,58 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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 "granularPressureModel.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
defineTypeNameAndDebug(granularPressureModel, 0);
defineRunTimeSelectionTable(granularPressureModel, dictionary);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::granularPressureModel::granularPressureModel
(
const dictionary& dict
)
:
dict_(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::granularPressureModel::~granularPressureModel()
{}
// ************************************************************************* //

137
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/granularPressureModel/granularPressureModel/granularPressureModel.H
View File

@ -1,137 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::kineticTheoryModels::granularPressureModel
SourceFiles
granularPressureModel.C
\*---------------------------------------------------------------------------*/
#ifndef granularPressureModel_H
#define granularPressureModel_H
#include "dictionary.H"
#include "volFields.H"
#include "dimensionedTypes.H"
#include "runTimeSelectionTables.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
/*---------------------------------------------------------------------------*\
Class granularPressureModel Declaration
\*---------------------------------------------------------------------------*/
class granularPressureModel
{
// Private member functions
//- Disallow default bitwise copy construct
granularPressureModel(const granularPressureModel&);
//- Disallow default bitwise assignment
void operator=(const granularPressureModel&);
protected:
// Protected data
const dictionary& dict_;
public:
//- Runtime type information
TypeName("granularPressureModel");
// Declare runtime constructor selection table
declareRunTimeSelectionTable
(
autoPtr,
granularPressureModel,
dictionary,
(
const dictionary& dict
),
(dict)
);
// Constructors
//- Construct from components
granularPressureModel(const dictionary& dict);
// Selectors
static autoPtr<granularPressureModel> New
(
const dictionary& dict
);
//- Destructor
virtual ~granularPressureModel();
// Member Functions
//- Granular pressure coefficient
virtual tmp<volScalarField> granularPressureCoeff
(
const volScalarField& alpha1,
const volScalarField& g0,
const dimensionedScalar& rho1,
const dimensionedScalar& e
) const = 0;
//- Derivative of the granular pressure coefficient
virtual tmp<volScalarField> granularPressureCoeffPrime
(
const volScalarField& alpha1,
const volScalarField& g0,
const volScalarField& g0prime,
const dimensionedScalar& rho1,
const dimensionedScalar& e
) const = 0;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

60
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/granularPressureModel/granularPressureModel/newGranularPressureModel.C
View File

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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 "granularPressureModel.H"
// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::kineticTheoryModels::granularPressureModel>
Foam::kineticTheoryModels::granularPressureModel::New
(
const dictionary& dict
)
{
word granularPressureModelType(dict.lookup("granularPressureModel"));
Info<< "Selecting granularPressureModel "
<< granularPressureModelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(granularPressureModelType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalError
<< "granularPressureModel::New(const dictionary&) : " << endl
<< " unknown granularPressureModelType type "
<< granularPressureModelType
<< ", constructor not in hash table" << endl << endl
<< " Valid granularPressureModelType types are :" << endl;
Info<< dictionaryConstructorTablePtr_->sortedToc()
<< abort(FatalError);
}
return autoPtr<granularPressureModel>(cstrIter()(dict));
}
// ************************************************************************* //

390
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.C
View File

@ -1,390 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "kineticTheoryModel.H"
#include "surfaceInterpolate.H"
#include "mathematicalConstants.H"
#include "fvCFD.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModel::kineticTheoryModel
(
const Foam::phaseModel& phase1,
const Foam::volVectorField& U2,
const Foam::volScalarField& alpha1,
const Foam::dragModel& drag1
)
:
phase1_(phase1),
U1_(phase1.U()),
U2_(U2),
alpha1_(alpha1),
phi1_(phase1.phi()),
drag1_(drag1),
rho1_(phase1.rho()),
nu1_(phase1.nu()),
kineticTheoryProperties_
(
IOobject
(
"kineticTheoryProperties",
U1_.time().constant(),
U1_.mesh(),
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
kineticTheory_(kineticTheoryProperties_.lookup("kineticTheory")),
equilibrium_(kineticTheoryProperties_.lookup("equilibrium")),
viscosityModel_
(
kineticTheoryModels::viscosityModel::New
(
kineticTheoryProperties_
)
),
conductivityModel_
(
kineticTheoryModels::conductivityModel::New
(
kineticTheoryProperties_
)
),
radialModel_
(
kineticTheoryModels::radialModel::New
(
kineticTheoryProperties_
)
),
granularPressureModel_
(
kineticTheoryModels::granularPressureModel::New
(
kineticTheoryProperties_
)
),
frictionalStressModel_
(
kineticTheoryModels::frictionalStressModel::New
(
kineticTheoryProperties_
)
),
e_(kineticTheoryProperties_.lookup("e")),
alphaMax_(kineticTheoryProperties_.lookup("alphaMax")),
alphaMinFriction_(kineticTheoryProperties_.lookup("alphaMinFriction")),
Fr_(kineticTheoryProperties_.lookup("Fr")),
eta_(kineticTheoryProperties_.lookup("eta")),
p_(kineticTheoryProperties_.lookup("p")),
phi_(dimensionedScalar(kineticTheoryProperties_.lookup("phi"))*M_PI/180.0),
Theta_
(
IOobject
(
"Theta",
U1_.time().timeName(),
U1_.mesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
U1_.mesh()
),
mu1_
(
IOobject
(
"mu1",
U1_.time().timeName(),
U1_.mesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
U1_.mesh(),
dimensionedScalar("zero", dimensionSet(1, -1, -1, 0, 0), 0.0)
),
lambda_
(
IOobject
(
"lambda",
U1_.time().timeName(),
U1_.mesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
U1_.mesh(),
dimensionedScalar("zero", dimensionSet(1, -1, -1, 0, 0), 0.0)
),
pa_
(
IOobject
(
"pa",
U1_.time().timeName(),
U1_.mesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
U1_.mesh(),
dimensionedScalar("zero", dimensionSet(1, -1, -2, 0, 0), 0.0)
),
kappa_
(
IOobject
(
"kappa",
U1_.time().timeName(),
U1_.mesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
U1_.mesh(),
dimensionedScalar("zero", dimensionSet(1, -1, -1, 0, 0), 0.0)
),
gs0_
(
IOobject
(
"gs0",
U1_.time().timeName(),
U1_.mesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
U1_.mesh(),
dimensionedScalar("zero", dimensionSet(0, 0, 0, 0, 0), 1.0)
)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModel::~kineticTheoryModel()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::kineticTheoryModel::solve(const volTensorField& gradU1t)
{
if (!kineticTheory_)
{
return;
}
const scalar sqrtPi = sqrt(constant::mathematical::pi);
volScalarField da_(phase1_.d());
surfaceScalarField phi(1.5*rho1_*phi1_*fvc::interpolate(alpha1_));
volTensorField dU(gradU1t.T()); //fvc::grad(U1_);
volSymmTensorField D(symm(dU));
// NB, drag = K*alpha1*alpha2,
// (the alpha1 and alpha2 has been extracted from the drag function for
// numerical reasons)
volScalarField Ur(mag(U1_ - U2_));
volScalarField alpha2Prim(alpha1_*(1.0 - alpha1_)*drag1_.K(Ur));
// Calculating the radial distribution function (solid volume fraction is
// limited close to the packing limit, but this needs improvements)
// The solution is higly unstable close to the packing limit.
gs0_ = radialModel_->g0
(
min(max(alpha1_, scalar(1e-6)), alphaMax_ - 0.01),
alphaMax_
);
// particle pressure - coefficient in front of Theta (Eq. 3.22, p. 45)
volScalarField PsCoeff
(
granularPressureModel_->granularPressureCoeff
(
alpha1_,
gs0_,
rho1_,
e_
)
);
// 'thermal' conductivity (Table 3.3, p. 49)
kappa_ = conductivityModel_->kappa(alpha1_, Theta_, gs0_, rho1_, da_, e_);
// particle viscosity (Table 3.2, p.47)
mu1_ = viscosityModel_->mu1(alpha1_, Theta_, gs0_, rho1_, da_, e_);
dimensionedScalar Tsmall
(
"small",
dimensionSet(0 , 2 ,-2 ,0 , 0, 0, 0),
1.0e-6
);
dimensionedScalar TsmallSqrt = sqrt(Tsmall);
volScalarField ThetaSqrt(sqrt(Theta_));
// dissipation (Eq. 3.24, p.50)
volScalarField gammaCoeff
(
12.0*(1.0 - sqr(e_))*sqr(alpha1_)*rho1_*gs0_*(1.0/da_)*ThetaSqrt/sqrtPi
);
// Eq. 3.25, p. 50 Js = J1 - J2
volScalarField J1(3.0*alpha2Prim);
volScalarField J2
(
0.25*sqr(alpha2Prim)*da_*sqr(Ur)
/(max(alpha1_, scalar(1e-6))*rho1_*sqrtPi*(ThetaSqrt + TsmallSqrt))
);
// bulk viscosity p. 45 (Lun et al. 1984).
lambda_ = (4.0/3.0)*sqr(alpha1_)*rho1_*da_*gs0_*(1.0+e_)*ThetaSqrt/sqrtPi;
// stress tensor, Definitions, Table 3.1, p. 43
volSymmTensorField tau(2.0*mu1_*D + (lambda_ - (2.0/3.0)*mu1_)*tr(D)*I);
if (!equilibrium_)
{
// construct the granular temperature equation (Eq. 3.20, p. 44)
// NB. note that there are two typos in Eq. 3.20
// no grad infront of Ps
// wrong sign infront of laplacian
fvScalarMatrix ThetaEqn
(
fvm::ddt(1.5*alpha1_*rho1_, Theta_)
+ fvm::div(phi, Theta_, "div(phi,Theta)")
==
fvm::SuSp(-((PsCoeff*I) && dU), Theta_)
+ (tau && dU)
+ fvm::laplacian(kappa_, Theta_, "laplacian(kappa,Theta)")
+ fvm::Sp(-gammaCoeff, Theta_)
+ fvm::Sp(-J1, Theta_)
+ fvm::Sp(J2/(Theta_ + Tsmall), Theta_)
);
ThetaEqn.relax();
ThetaEqn.solve();
}
else
{
// equilibrium => dissipation == production
// Eq. 4.14, p.82
volScalarField K1(2.0*(1.0 + e_)*rho1_*gs0_);
volScalarField K3
(
0.5*da_*rho1_*
(
(sqrtPi/(3.0*(3.0-e_)))
*(1.0 + 0.4*(1.0 + e_)*(3.0*e_ - 1.0)*alpha1_*gs0_)
+1.6*alpha1_*gs0_*(1.0 + e_)/sqrtPi
)
);
volScalarField K2
(
4.0*da_*rho1_*(1.0 + e_)*alpha1_*gs0_/(3.0*sqrtPi) - 2.0*K3/3.0
);
volScalarField K4(12.0*(1.0 - sqr(e_))*rho1_*gs0_/(da_*sqrtPi));
volScalarField trD(tr(D));
volScalarField tr2D(sqr(trD));
volScalarField trD2(tr(D & D));
volScalarField t1(K1*alpha1_ + rho1_);
volScalarField l1(-t1*trD);
volScalarField l2(sqr(t1)*tr2D);
volScalarField l3
(
4.0
*K4
*max(alpha1_, scalar(1e-6))
*(2.0*K3*trD2 + K2*tr2D)
);
Theta_ = sqr((l1 + sqrt(l2 + l3))/(2.0*(alpha1_ + 1.0e-4)*K4));
}
Theta_.max(1.0e-15);
Theta_.min(1.0e+3);
volScalarField pf
(
frictionalStressModel_->frictionalPressure
(
alpha1_,
alphaMinFriction_,
alphaMax_,
Fr_,
eta_,
p_
)
);
PsCoeff += pf/(Theta_+Tsmall);
PsCoeff.min(1.0e+10);
PsCoeff.max(-1.0e+10);
// update particle pressure
pa_ = PsCoeff*Theta_;
// frictional shear stress, Eq. 3.30, p. 52
volScalarField muf
(
frictionalStressModel_->muf
(
alpha1_,
alphaMax_,
pf,
D,
phi_
)
);
// add frictional stress
mu1_ += muf;
mu1_.min(1.0e+2);
mu1_.max(0.0);
Info<< "kinTheory: max(Theta) = " << max(Theta_).value() << endl;
volScalarField ktn(mu1_/rho1_);
Info<< "kinTheory: min(nu1) = " << min(ktn).value()
<< ", max(nu1) = " << max(ktn).value() << endl;
Info<< "kinTheory: min(pa) = " << min(pa_).value()
<< ", max(pa) = " << max(pa_).value() << endl;
}
// ************************************************************************* //

197
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.H
View File

@ -1,197 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::kineticTheoryModel
Description
SourceFiles
kineticTheoryModel.C
\*---------------------------------------------------------------------------*/
#ifndef kineticTheoryModel_H
#define kineticTheoryModel_H
#include "dragModel.H"
#include "phaseModel.H"
#include "autoPtr.H"
#include "viscosityModel.H"
#include "conductivityModel.H"
#include "radialModel.H"
#include "granularPressureModel.H"
#include "frictionalStressModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class kineticTheoryModel Declaration
\*---------------------------------------------------------------------------*/
class kineticTheoryModel
{
// Private data
const phaseModel& phase1_;
const volVectorField& U1_;
const volVectorField& U2_;
const volScalarField& alpha1_;
const surfaceScalarField& phi1_;
const dragModel& drag1_;
const dimensionedScalar& rho1_;
const dimensionedScalar& nu1_;
//- dictionary holding the modeling info
IOdictionary kineticTheoryProperties_;
//- use kinetic theory or not.
Switch kineticTheory_;
//- use generation == dissipation
Switch equilibrium_;
autoPtr<kineticTheoryModels::viscosityModel> viscosityModel_;
autoPtr<kineticTheoryModels::conductivityModel> conductivityModel_;
autoPtr<kineticTheoryModels::radialModel> radialModel_;
autoPtr<kineticTheoryModels::granularPressureModel>
granularPressureModel_;
autoPtr<kineticTheoryModels::frictionalStressModel>
frictionalStressModel_;
//- coefficient of restitution
const dimensionedScalar e_;
//- maximum packing
const dimensionedScalar alphaMax_;
//- min value for which the frictional stresses are zero
const dimensionedScalar alphaMinFriction_;
//- material constant for frictional normal stress
const dimensionedScalar Fr_;
//- material constant for frictional normal stress
const dimensionedScalar eta_;
//- material constant for frictional normal stress
const dimensionedScalar p_;
//- angle of internal friction
const dimensionedScalar phi_;
//- The granular energy/temperature
volScalarField Theta_;
//- The granular viscosity
volScalarField mu1_;
//- The granular bulk viscosity
volScalarField lambda_;
//- The granular pressure
volScalarField pa_;
//- The granular temperature conductivity
volScalarField kappa_;
//- The radial distribution function
volScalarField gs0_;
// Private Member Functions
//- Disallow default bitwise copy construct
kineticTheoryModel(const kineticTheoryModel&);
//- Disallow default bitwise assignment
void operator=(const kineticTheoryModel&);
public:
// Constructors
//- Construct from components
kineticTheoryModel
(
const phaseModel& phase1,
const volVectorField& U2,
const volScalarField& alpha1,
const dragModel& drag1
);
//- Destructor
virtual ~kineticTheoryModel();
// Member Functions
void solve(const volTensorField& gradU1t);
bool on() const
{
return kineticTheory_;
}
const volScalarField& mu1() const
{
return mu1_;
}
const volScalarField& pa() const
{
return pa_;
}
const volScalarField& lambda() const
{
return lambda_;
}
const volScalarField& kappa() const
{
return kappa_;
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

99
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/radialModel/CarnahanStarling/CarnahanStarlingRadial.C
View File

@ -1,99 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "CarnahanStarlingRadial.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace radialModels
{
defineTypeNameAndDebug(CarnahanStarling, 0);
addToRunTimeSelectionTable
(
radialModel,
CarnahanStarling,
dictionary
);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::radialModels::CarnahanStarling::CarnahanStarling
(
const dictionary& dict
)
:
radialModel(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::radialModels::CarnahanStarling::~CarnahanStarling()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::CarnahanStarling::g0
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const
{
return
1.0/(1.0 - alpha1)
+ 3.0*alpha1/(2.0*sqr(1.0 - alpha1))
+ sqr(alpha1)/(2.0*pow(1.0 - alpha1, 3));
}
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::CarnahanStarling::g0prime
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const
{
return
- alpha1/sqr(1.0 - alpha1)
+ (3.0*(1.0 - alpha1) + 6.0*sqr(alpha1))/(2.0*(1.0 - alpha1))
+ (2.0*alpha1*(1.0 - alpha1) + 3.0*pow(alpha1, 3))
/(2.0*pow(1.0 - alpha1, 4));
}
// ************************************************************************* //

100
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/radialModel/CarnahanStarling/CarnahanStarlingRadial.H
View File

@ -1,100 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::kineticTheoryModels::radialModels::CarnahanStarling
Description
SourceFiles
CarnahanStarlingRadial.C
\*---------------------------------------------------------------------------*/
#ifndef CarnahanStarling_H
#define CarnahanStarling_H
#include "radialModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace radialModels
{
/*---------------------------------------------------------------------------*\
Class CarnahanStarling Declaration
\*---------------------------------------------------------------------------*/
class CarnahanStarling
:
public radialModel
{
public:
//- Runtime type information
TypeName("CarnahanStarling");
// Constructors
//- Construct from components
CarnahanStarling(const dictionary& dict);
//- Destructor
virtual ~CarnahanStarling();
// Member Functions
tmp<volScalarField> g0
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const;
tmp<volScalarField> g0prime
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace radialModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

93
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/radialModel/Gidaspow/GidaspowRadial.C
View File

@ -1,93 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "GidaspowRadial.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace radialModels
{
defineTypeNameAndDebug(Gidaspow, 0);
addToRunTimeSelectionTable
(
radialModel,
Gidaspow,
dictionary
);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::radialModels::Gidaspow::Gidaspow
(
const dictionary& dict
)
:
radialModel(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::radialModels::Gidaspow::~Gidaspow()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::Gidaspow::g0
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const
{
return 0.6/(1.0 - pow(alpha1/alphaMax, 1.0/3.0));
}
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::Gidaspow::g0prime
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const
{
return
(-1.0/5.0)*pow(alpha1/alphaMax, -2.0/3.0)
/(alphaMax*sqr(1.0 - pow(alpha1/alphaMax, 1.0/3.0)));
}
// ************************************************************************* //

99
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/radialModel/Gidaspow/GidaspowRadial.H
View File

@ -1,99 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::kineticTheoryModels::radialModels::Gidaspow
Description
SourceFiles
GidaspowRadial.C
\*---------------------------------------------------------------------------*/
#ifndef Gidaspow_H
#define Gidaspow_H
#include "radialModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace radialModels
{
/*---------------------------------------------------------------------------*\
Class Gidaspow Declaration
\*---------------------------------------------------------------------------*/
class Gidaspow
:
public radialModel
{
public:
//- Runtime type information
TypeName("Gidaspow");
// Constructors
//- Construct from components
Gidaspow(const dictionary& dict);
//- Destructor
virtual ~Gidaspow();
// Member Functions
tmp<volScalarField> g0
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const;
tmp<volScalarField> g0prime
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace radialModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

92
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/radialModel/LunSavage/LunSavageRadial.C
View File

@ -1,92 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "LunSavageRadial.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace radialModels
{
defineTypeNameAndDebug(LunSavage, 0);
addToRunTimeSelectionTable
(
radialModel,
LunSavage,
dictionary
);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::radialModels::LunSavage::LunSavage
(
const dictionary& dict
)
:
radialModel(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::radialModels::LunSavage::~LunSavage()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::LunSavage::g0
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const
{
return pow(1.0 - alpha1/alphaMax, -2.5*alphaMax);
}
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::LunSavage::g0prime
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const
{
return 2.5*alphaMax*alpha1*pow(1.0 - alpha1, -1.0 - 2.5*alphaMax);
}
// ************************************************************************* //

99
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/radialModel/LunSavage/LunSavageRadial.H
View File

@ -1,99 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::kineticTheoryModels::radialModels::LunSavage
Description
SourceFiles
LunSavage.C
\*---------------------------------------------------------------------------*/
#ifndef LunSavage_H
#define LunSavage_H
#include "radialModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace radialModels
{
/*---------------------------------------------------------------------------*\
Class LunSavage Declaration
\*---------------------------------------------------------------------------*/
class LunSavage
:
public radialModel
{
public:
//- Runtime type information
TypeName("LunSavage");
// Constructors
//- Construct from components
LunSavage(const dictionary& dict);
//- Destructor
virtual ~LunSavage();
// Member Functions
tmp<volScalarField> g0
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const;
tmp<volScalarField> g0prime
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace radialModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

93
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/radialModel/SinclairJackson/SinclairJacksonRadial.C
View File

@ -1,93 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "SinclairJacksonRadial.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace radialModels
{
defineTypeNameAndDebug(SinclairJackson, 0);
addToRunTimeSelectionTable
(
radialModel,
SinclairJackson,
dictionary
);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::radialModels::SinclairJackson::SinclairJackson
(
const dictionary& dict
)
:
radialModel(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::radialModels::SinclairJackson::~SinclairJackson()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::SinclairJackson::g0
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const
{
return 1.0/(1.0 - pow(alpha1/alphaMax, 1.0/3.0));
}
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::SinclairJackson::g0prime
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const
{
return
(-1.0/3.0)*pow(alpha1/alphaMax, -2.0/3.0)
/(alphaMax*sqr(1.0 - pow(alpha1/alphaMax, 1.0/3.0)));
}
// ************************************************************************* //

99
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/radialModel/SinclairJackson/SinclairJacksonRadial.H
View File

@ -1,99 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::SinclairJackson
Description
SourceFiles
SinclairJacksonRadial.C
\*---------------------------------------------------------------------------*/
#ifndef SinclairJackson_H
#define SinclairJackson_H
#include "radialModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace radialModels
{
/*---------------------------------------------------------------------------*\
Class SinclairJackson Declaration
\*---------------------------------------------------------------------------*/
class SinclairJackson
:
public radialModel
{
public:
//- Runtime type information
TypeName("SinclairJackson");
// Constructors
//- Construct from components
SinclairJackson(const dictionary& dict);
//- Destructor
virtual ~SinclairJackson();
// Member Functions
tmp<volScalarField> g0
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const;
tmp<volScalarField> g0prime
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace radialModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

60
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/radialModel/radialModel/newRadialModel.C
View File

@ -1,60 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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 "radialModel.H"
// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::kineticTheoryModels::radialModel>
Foam::kineticTheoryModels::radialModel::New
(
const dictionary& dict
)
{
word radialModelType(dict.lookup("radialModel"));
Info<< "Selecting radialModel "
<< radialModelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(radialModelType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalError
<< "radialModel::New(const dictionary&) : " << endl
<< " unknown radialModelType type "
<< radialModelType
<< ", constructor not in hash table" << endl << endl
<< " Valid radialModelType types are :" << endl;
Info<< dictionaryConstructorTablePtr_->sortedToc()
<< abort(FatalError);
}
return autoPtr<radialModel>(cstrIter()(dict));
}
// ************************************************************************* //

58
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/radialModel/radialModel/radialModel.C
View File

@ -1,58 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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 "radialModel.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
defineTypeNameAndDebug(radialModel, 0);
defineRunTimeSelectionTable(radialModel, dictionary);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::radialModel::radialModel
(
const dictionary& dict
)
:
dict_(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::radialModel::~radialModel()
{}
// ************************************************************************* //

132
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/radialModel/radialModel/radialModel.H
View File

@ -1,132 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::kineticTheoryModels::radialModel
SourceFiles
radialModel.C
\*---------------------------------------------------------------------------*/
#ifndef radialModel_H
#define radialModel_H
#include "dictionary.H"
#include "volFields.H"
#include "dimensionedTypes.H"
#include "runTimeSelectionTables.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
/*---------------------------------------------------------------------------*\
Class radialModel Declaration
\*---------------------------------------------------------------------------*/
class radialModel
{
// Private member functions
//- Disallow default bitwise copy construct
radialModel(const radialModel&);
//- Disallow default bitwise assignment
void operator=(const radialModel&);
protected:
// Protected data
const dictionary& dict_;
public:
//- Runtime type information
TypeName("radialModel");
// Declare runtime constructor selection table
declareRunTimeSelectionTable
(
autoPtr,
radialModel,
dictionary,
(
const dictionary& dict
),
(dict)
);
// Constructors
//- Construct from components
radialModel(const dictionary& dict);
// Selectors
static autoPtr<radialModel> New
(
const dictionary& dict
);
//- Destructor
virtual ~radialModel();
// Member Functions
//- Radial distribution function
virtual tmp<volScalarField> g0
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const = 0;
//- Derivative of the radial distribution function
virtual tmp<volScalarField> g0prime
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const = 0;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

87
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/viscosityModel/Gidaspow/GidaspowViscosity.C
View File

@ -1,87 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "GidaspowViscosity.H"
#include "mathematicalConstants.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace viscosityModels
{
defineTypeNameAndDebug(Gidaspow, 0);
addToRunTimeSelectionTable(viscosityModel, Gidaspow, dictionary);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::viscosityModels::Gidaspow::Gidaspow
(
const dictionary& dict
)
:
viscosityModel(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::viscosityModels::Gidaspow::~Gidaspow()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::viscosityModels::Gidaspow::mu1
(
const volScalarField& alpha1,
const volScalarField& Theta,
const volScalarField& g0,
const dimensionedScalar& rho1,
const volScalarField& da,
const dimensionedScalar& e
) const
{
const scalar sqrtPi = sqrt(constant::mathematical::pi);
return rho1*da*sqrt(Theta)*
(
(4.0/5.0)*sqr(alpha1)*g0*(1.0 + e)/sqrtPi
+ (1.0/15.0)*sqrtPi*g0*(1.0 + e)*sqr(alpha1)
+ (1.0/6.0)*sqrtPi*alpha1
+ (10.0/96.0)*sqrtPi/((1.0 + e)*g0)
);
}
// ************************************************************************* //

96
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/viscosityModel/Gidaspow/GidaspowViscosity.H
View File

@ -1,96 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::kineticTheoryModels::viscosityModels::Gidaspow
Description
SourceFiles
GidaspowViscosity.C
\*---------------------------------------------------------------------------*/
#ifndef Gidaspow_H
#define Gidaspow_H
#include "viscosityModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace viscosityModels
{
/*---------------------------------------------------------------------------*\
Class Gidaspow Declaration
\*---------------------------------------------------------------------------*/
class Gidaspow
:
public viscosityModel
{
public:
//- Runtime type information
TypeName("Gidaspow");
// Constructors
//- Construct from components
Gidaspow(const dictionary& dict);
//- Destructor
virtual ~Gidaspow();
// Member functions
tmp<volScalarField> mu1
(
const volScalarField& alpha1,
const volScalarField& Theta,
const volScalarField& g0,
const dimensionedScalar& rho1,
const volScalarField& da,
const dimensionedScalar& e
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace viscosityModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

101
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/viscosityModel/HrenyaSinclair/HrenyaSinclairViscosity.C
View File

@ -1,101 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "HrenyaSinclairViscosity.H"
#include "mathematicalConstants.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace viscosityModels
{
defineTypeNameAndDebug(HrenyaSinclair, 0);
addToRunTimeSelectionTable
(
viscosityModel,
HrenyaSinclair,
dictionary
);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::viscosityModels::HrenyaSinclair::HrenyaSinclair
(
const dictionary& dict
)
:
viscosityModel(dict),
coeffsDict_(dict.subDict(typeName + "Coeffs")),
L_(coeffsDict_.lookup("L"))
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::viscosityModels::HrenyaSinclair::~HrenyaSinclair()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::viscosityModels::HrenyaSinclair::mu1
(
const volScalarField& alpha1,
const volScalarField& Theta,
const volScalarField& g0,
const dimensionedScalar& rho1,
const volScalarField& da,
const dimensionedScalar& e
) const
{
const scalar sqrtPi = sqrt(constant::mathematical::pi);
volScalarField lamda
(
scalar(1) + da/(6.0*sqrt(2.0)*(alpha1 + scalar(1.0e-5)))/L_
);
return rho1*da*sqrt(Theta)*
(
(4.0/5.0)*sqr(alpha1)*g0*(1.0 + e)/sqrtPi
+ (1.0/15.0)*sqrtPi*g0*(1.0 + e)*(3.0*e - 1)*sqr(alpha1)/(3.0-e)
+ (1.0/6.0)*sqrtPi*alpha1*(0.5*lamda + 0.25*(3.0*e - 1.0))
/(0.5*(3.0 - e)*lamda)
+ (10/96.0)*sqrtPi/((1.0 + e)*0.5*(3.0 - e)*g0*lamda)
);
}
// ************************************************************************* //

104
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/viscosityModel/HrenyaSinclair/HrenyaSinclairViscosity.H
View File

@ -1,104 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::kineticTheoryModels::viscosityModels::HrenyaSinclair
Description
SourceFiles
HrenyaSinclairViscosity.C
\*---------------------------------------------------------------------------*/
#ifndef HrenyaSinclair_H
#define HrenyaSinclair_H
#include "viscosityModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace viscosityModels
{
/*---------------------------------------------------------------------------*\
Class HrenyaSinclair Declaration
\*---------------------------------------------------------------------------*/
class HrenyaSinclair
:
public viscosityModel
{
// Private data
dictionary coeffsDict_;
//- characteristic length of geometry
dimensionedScalar L_;
public:
//- Runtime type information
TypeName("HrenyaSinclair");
// Constructors
//- Construct from components
HrenyaSinclair(const dictionary& dict);
//- Destructor
virtual ~HrenyaSinclair();
// Member functions
tmp<volScalarField> mu1
(
const volScalarField& alpha1,
const volScalarField& Theta,
const volScalarField& g0,
const dimensionedScalar& rho1,
const volScalarField& da,
const dimensionedScalar& e
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace viscosityModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

86
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/viscosityModel/Syamlal/SyamlalViscosity.C
View File

@ -1,86 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "SyamlalViscosity.H"
#include "mathematicalConstants.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace viscosityModels
{
defineTypeNameAndDebug(Syamlal, 0);
addToRunTimeSelectionTable(viscosityModel, Syamlal, dictionary);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::viscosityModels::Syamlal::Syamlal
(
const dictionary& dict
)
:
viscosityModel(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::viscosityModels::Syamlal::~Syamlal()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::viscosityModels::Syamlal::mu1
(
const volScalarField& alpha1,
const volScalarField& Theta,
const volScalarField& g0,
const dimensionedScalar& rho1,
const volScalarField& da,
const dimensionedScalar& e
) const
{
const scalar sqrtPi = sqrt(constant::mathematical::pi);
return rho1*da*sqrt(Theta)*
(
(4.0/5.0)*sqr(alpha1)*g0*(1.0 + e)/sqrtPi
+ (1.0/15.0)*sqrtPi*g0*(1.0 + e)*(3.0*e - 1.0)*sqr(alpha1)/(3.0 - e)
+ (1.0/6.0)*alpha1*sqrtPi/(3.0 - e)
);
}
// ************************************************************************* //

97
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/viscosityModel/Syamlal/SyamlalViscosity.H
View File

@ -1,97 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::kineticTheoryModels::viscosityModels::Syamlal
Description
SourceFiles
SyamlalViscosity.C
\*---------------------------------------------------------------------------*/
#ifndef Syamlal_H
#define Syamlal_H
#include "viscosityModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
namespace viscosityModels
{
/*---------------------------------------------------------------------------*\
Class Syamlal Declaration
\*---------------------------------------------------------------------------*/
class Syamlal
:
public viscosityModel
{
public:
//- Runtime type information
TypeName("Syamlal");
// Constructors
//- Construct from components
Syamlal(const dictionary& dict);
//- Destructor
virtual ~Syamlal();
// Member functions
tmp<volScalarField> mu1
(
const volScalarField& alpha1,
const volScalarField& Theta,
const volScalarField& g0,
const dimensionedScalar& rho1,
const volScalarField& da,
const dimensionedScalar& e
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace viscosityModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

75
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/viscosityModel/none/noneViscosity.C
View File

@ -1,75 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "noneViscosity.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
defineTypeNameAndDebug(noneViscosity, 0);
addToRunTimeSelectionTable(viscosityModel, noneViscosity, dictionary);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::noneViscosity::noneViscosity(const dictionary& dict)
:
viscosityModel(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::noneViscosity::~noneViscosity()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField> Foam::kineticTheoryModels::noneViscosity::mu1
(
const volScalarField& alpha1,
const volScalarField& Theta,
const volScalarField& g0,
const dimensionedScalar& rho1,
const volScalarField& da,
const dimensionedScalar& e
) const
{
return dimensionedScalar
(
"0",
dimensionSet(1, -1, -1, 0, 0, 0, 0),
0.0
)*alpha1;
}
// ************************************************************************* //

94
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/viscosityModel/none/noneViscosity.H
View File

@ -1,94 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::noneViscosity
Description
SourceFiles
noneViscosity.C
\*---------------------------------------------------------------------------*/
#ifndef noneViscosity_H
#define noneViscosity_H
#include "viscosityModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
/*---------------------------------------------------------------------------*\
Class noneViscosity Declaration
\*---------------------------------------------------------------------------*/
class noneViscosity
:
public viscosityModel
{
public:
//- Runtime type information
TypeName("none");
// Constructors
//- Construct from components
noneViscosity(const dictionary& dict);
//- Destructor
virtual ~noneViscosity();
// Member functions
tmp<volScalarField> mu1
(
const volScalarField& alpha1,
const volScalarField& Theta,
const volScalarField& g0,
const dimensionedScalar& rho1,
const volScalarField& da,
const dimensionedScalar& e
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

59
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/viscosityModel/viscosityModel/newViscosityModel.C
View File

@ -1,59 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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 "viscosityModel.H"
// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::kineticTheoryModels::viscosityModel>
Foam::kineticTheoryModels::viscosityModel::New
(
const dictionary& dict
)
{
word viscosityModelType(dict.lookup("viscosityModel"));
Info<< "Selecting viscosityModel "
<< viscosityModelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(viscosityModelType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalError
<< "viscosityModel::New(const dictionary&) : " << endl
<< " unknown viscosityModelType type "
<< viscosityModelType
<< ", constructor not in hash table" << endl << endl
<< " Valid viscosityModelType types are :" << endl;
Info<< dictionaryConstructorTablePtr_->sortedToc() << abort(FatalError);
}
return autoPtr<viscosityModel>(cstrIter()(dict));
}
// ************************************************************************* //

57
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/viscosityModel/viscosityModel/viscosityModel.C
View File

@ -1,57 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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 "viscosityModel.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
defineTypeNameAndDebug(viscosityModel, 0);
defineRunTimeSelectionTable(viscosityModel, dictionary);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::viscosityModel::viscosityModel
(
const dictionary& dict
)
:
dict_(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::kineticTheoryModels::viscosityModel::~viscosityModel()
{}
// ************************************************************************* //

130
applications/solvers/multiphase/multiphaseEulerFoam/kineticTheoryModels/viscosityModel/viscosityModel/viscosityModel.H
View File

@ -1,130 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::viscosityModel
Description
SourceFiles
viscosityModel.C
\*---------------------------------------------------------------------------*/
#ifndef viscosityModel_H
#define viscosityModel_H
#include "dictionary.H"
#include "volFields.H"
#include "dimensionedTypes.H"
#include "runTimeSelectionTables.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
/*---------------------------------------------------------------------------*\
Class viscosityModel Declaration
\*---------------------------------------------------------------------------*/
class viscosityModel
{
// Private member functions
//- Disallow default bitwise copy construct
viscosityModel(const viscosityModel&);
//- Disallow default bitwise assignment
void operator=(const viscosityModel&);
protected:
// Protected data
const dictionary& dict_;
public:
//- Runtime type information
TypeName("viscosityModel");
// Declare runtime constructor selection table
declareRunTimeSelectionTable
(
autoPtr,
viscosityModel,
dictionary,
(
const dictionary& dict
),
(dict)
);
// Constructors
//- Construct from components
viscosityModel(const dictionary& dict);
// Selectors
static autoPtr<viscosityModel> New
(
const dictionary& dict
);
//- Destructor
virtual ~viscosityModel();
// Member Functions
virtual tmp<volScalarField> mu1
(
const volScalarField& alpha1,
const volScalarField& Theta,
const volScalarField& g0,
const dimensionedScalar& rho1,
const volScalarField& da,
const dimensionedScalar& e
) const = 0;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

75
applications/solvers/multiphase/multiphaseEulerFoam/multiphaseSystem/multiphaseSystem.C
View File

@ -58,8 +58,6 @@ void Foam::multiphaseSystem::calcAlphas()
void Foam::multiphaseSystem::solveAlphas()
{
surfaceScalarField phic(mag(phi_/mesh_.magSf()));
PtrList<surfaceScalarField> phiAlphaCorrs(phases_.size());
int phasei = 0;
@ -94,6 +92,11 @@ void Foam::multiphaseSystem::solveAlphas()
if (&phase2 == &phase1) continue;
surfaceScalarField phic
(
(mag(phi_) + mag(phase1.phi() - phase2.phi()))/mesh_.magSf()
);
surfaceScalarField phir
(
(phase1.phi() - phase2.phi())
@ -186,32 +189,6 @@ void Foam::multiphaseSystem::solveAlphas()
}
Foam::dimensionedScalar Foam::multiphaseSystem::sigma
(
const phaseModel& phase1,
const phaseModel& phase2
) const
{
scalarCoeffTable::const_iterator sigma
(
sigmas_.find(interfacePair(phase1, phase2))
);
if (sigma == sigmas_.end())
{
FatalErrorIn
(
"multiphaseSystem::sigma(const phaseModel& phase1,"
"const phaseModel& phase2) const"
) << "Cannot find interface " << interfacePair(phase1, phase2)
<< " in list of sigma values"
<< exit(FatalError);
}
return dimensionedScalar("sigma", dimSigma_, sigma());
}
Foam::scalar Foam::multiphaseSystem::cAlpha
(
const phaseModel& phase1,
@ -263,10 +240,10 @@ Foam::dimensionedScalar Foam::multiphaseSystem::Cvm
FatalErrorIn
(
"multiphaseSystem::sigma"
"multiphaseSystem::Cvm"
"(const phaseModel& phase1, const phaseModel& phase2) const"
) << "Cannot find interface " << interfacePair(phase1, phase2)
<< " in list of sigma values"
<< " in list of Cvm values"
<< exit(FatalError);
return Cvm()*phase2.rho();
@ -729,43 +706,46 @@ Foam::tmp<Foam::volScalarField> Foam::multiphaseSystem::dragCoeff
}
Foam::tmp<Foam::surfaceScalarField>
Foam::multiphaseSystem::surfaceTensionForce() const
Foam::tmp<Foam::surfaceScalarField> Foam::multiphaseSystem::surfaceTension
(
const phaseModel& phase1
) const
{
tmp<surfaceScalarField> tstf
tmp<surfaceScalarField> tSurfaceTension
(
new surfaceScalarField
(
IOobject
(
"surfaceTensionForce",
"surfaceTension",
mesh_.time().timeName(),
mesh_
),
mesh_,
dimensionedScalar
(
"surfaceTensionForce",
"surfaceTension",
dimensionSet(1, -2, -2, 0, 0),
0.0
0
)
)
);
surfaceScalarField& stf = tstf();
forAllConstIter(PtrDictionary<phaseModel>, phases_, iter1)
forAllConstIter(PtrDictionary<phaseModel>, phases_, iter)
{
const phaseModel& phase1 = iter1();
const phaseModel& phase2 = iter();
PtrDictionary<phaseModel>::const_iterator iter2 = iter1;
++iter2;
for (; iter2 != phases_.end(); ++iter2)
if (&phase2 != &phase1)
{
const phaseModel& phase2 = iter2();
scalarCoeffTable::const_iterator sigma
(
sigmas_.find(interfacePair(phase1, phase2))
);
stf += sigma(phase1, phase2)
if (sigma != sigmas_.end())
{
tSurfaceTension() +=
dimensionedScalar("sigma", dimSigma_, sigma())
*fvc::interpolate(K(phase1, phase2))*
(
fvc::interpolate(phase2)*fvc::snGrad(phase1)
@ -773,8 +753,9 @@ Foam::multiphaseSystem::surfaceTensionForce() const
);
}
}
}
return tstf;
return tSurfaceTension;
}

10
applications/solvers/multiphase/multiphaseEulerFoam/multiphaseSystem/multiphaseSystem.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -196,12 +196,6 @@ private:
void solveAlphas();
dimensionedScalar sigma
(
const phaseModel& phase1,
const phaseModel& phase2
) const;
scalar cAlpha
(
const phaseModel& phase1,
@ -299,7 +293,7 @@ public:
const dragCoeffFields& dragCoeffs
) const;
tmp<surfaceScalarField> surfaceTensionForce() const;
tmp<surfaceScalarField> surfaceTension(const phaseModel& phase) const;
//- Indicator of the proximity of the interface
// Field values are 1 near and 0 away for the interface.

6
applications/solvers/multiphase/multiphaseEulerFoam/pEqn.H
View File

@ -74,7 +74,11 @@
(
(fvc::interpolate(HbyAs[phasei]) & mesh.Sf())
+ fvc::ddtPhiCorr(rAUs[phasei], alpha, phase.U(), phase.phi())
+ rAlphaAUfs[phasei]*(g & mesh.Sf())
+ rAlphaAUfs[phasei]
*(
fluid.surfaceTension(phase)*mesh.magSf()/phase.rho()
+ (g & mesh.Sf())
)
);
mrfZones.relativeFlux(phiHbyAs[phasei]);

1
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/Make/files
View File

@ -16,7 +16,6 @@ conductivityModel/HrenyaSinclair/HrenyaSinclairConductivity.C
radialModel/radialModel/radialModel.C
radialModel/radialModel/newRadialModel.C
radialModel/CarnahanStarling/CarnahanStarlingRadial.C
radialModel/Gidaspow/GidaspowRadial.C
radialModel/LunSavage/LunSavageRadial.C
radialModel/SinclairJackson/SinclairJacksonRadial.C

2
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.C
View File

@ -79,7 +79,7 @@ Foam::kineticTheoryModel::kineticTheoryModel
),
radialModel_
(
radialModel::New
kineticTheoryModels::radialModel::New
(
kineticTheoryProperties_
)

2
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.H
View File

@ -81,7 +81,7 @@ class kineticTheoryModel
autoPtr<conductivityModel> conductivityModel_;
autoPtr<radialModel> radialModel_;
autoPtr<kineticTheoryModels::radialModel> radialModel_;
autoPtr<granularPressureModel> granularPressureModel_;

40
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/CarnahanStarling/CarnahanStarlingRadial.C
View File

@ -30,20 +30,29 @@ License
namespace Foam
{
defineTypeNameAndDebug(CarnahanStarlingRadial, 0);
namespace kineticTheoryModels
{
namespace radialModels
{
defineTypeNameAndDebug(CarnahanStarling, 0);
addToRunTimeSelectionTable
(
radialModel,
CarnahanStarlingRadial,
CarnahanStarling,
dictionary
);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::CarnahanStarlingRadial::CarnahanStarlingRadial(const dictionary& dict)
Foam::kineticTheoryModels::radialModels::CarnahanStarling::CarnahanStarling
(
const dictionary& dict
)
:
radialModel(dict)
{}
@ -51,37 +60,38 @@ Foam::CarnahanStarlingRadial::CarnahanStarlingRadial(const dictionary& dict)
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::CarnahanStarlingRadial::~CarnahanStarlingRadial()
Foam::kineticTheoryModels::radialModels::CarnahanStarling::~CarnahanStarling()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField> Foam::CarnahanStarlingRadial::g0
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::CarnahanStarling::g0
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const
{
return
1.0/(1.0 - alpha1)
+ 3.0*alpha1/(2.0*sqr(1.0 - alpha1))
+ sqr(alpha1)/(2.0*pow(1.0 - alpha1, 3));
1.0/(1.0 - alpha)
+ 3.0*alpha/(2.0*sqr(1.0 - alpha))
+ sqr(alpha)/(2.0*pow(1.0 - alpha, 3));
}
Foam::tmp<Foam::volScalarField> Foam::CarnahanStarlingRadial::g0prime
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::CarnahanStarling::g0prime
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const
{
return
- alpha1/sqr(1.0 - alpha1)
+ (3.0*(1.0 - alpha1) + 6.0*sqr(alpha1))/(2.0*(1.0 - alpha1))
+ (2.0*alpha1*(1.0 - alpha1) + 3.0*pow(alpha1, 3))
/(2.0*pow(1.0 - alpha1, 4));
2.5/sqr(1.0 - alpha)
+ 4.0*alpha/pow(1.0 - alpha, 3.0)
+ 1.5*sqr(alpha)/pow(1.0 - alpha, 4.0);
}

24
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/CarnahanStarling/CarnahanStarlingRadial.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::CarnahanStarlingRadial
Foam::kineticTheoryModels::radialModels::CarnahanStarling
Description
@ -31,8 +31,8 @@ SourceFiles
\*---------------------------------------------------------------------------*/
#ifndef CarnahanStarlingRadial_H
#define CarnahanStarlingRadial_H
#ifndef CarnahanStarling_H
#define CarnahanStarling_H
#include "radialModel.H"
@ -40,12 +40,16 @@ SourceFiles
namespace Foam
{
namespace kineticTheoryModels
{
namespace radialModels
{
/*---------------------------------------------------------------------------*\
Class CarnahanStarlingradial Declaration
Class CarnahanStarling Declaration
\*---------------------------------------------------------------------------*/
class CarnahanStarlingRadial
class CarnahanStarling
:
public radialModel
{
@ -59,11 +63,11 @@ public:
// Constructors
//- Construct from components
CarnahanStarlingRadial(const dictionary& dict);
CarnahanStarling(const dictionary& dict);
//- Destructor
virtual ~CarnahanStarlingRadial();
virtual ~CarnahanStarling();
// Member Functions
@ -71,13 +75,13 @@ public:
tmp<volScalarField> g0
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const;
tmp<volScalarField> g0prime
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const;
};
@ -85,6 +89,8 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace radialModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

82
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/Gidaspow/GidaspowRadial.C
View File

@ -1,82 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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 "GidaspowRadial.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(GidaspowRadial, 0);
addToRunTimeSelectionTable
(
radialModel,
GidaspowRadial,
dictionary
);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::GidaspowRadial::GidaspowRadial(const dictionary& dict)
:
radialModel(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::GidaspowRadial::~GidaspowRadial()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField> Foam::GidaspowRadial::g0
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const
{
return 0.6/(1.0 - pow(alpha1/alphaMax, 1.0/3.0));
}
Foam::tmp<Foam::volScalarField> Foam::GidaspowRadial::g0prime
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const
{
return
(-1.0/5.0)*pow(alpha1/alphaMax, -2.0/3.0)
/(alphaMax*sqr(1.0 - pow(alpha1/alphaMax, 1.0/3.0)));
}
// ************************************************************************* //

93
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/Gidaspow/GidaspowRadial.H
View File

@ -1,93 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 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::GidaspowRadial
Description
SourceFiles
GidaspowRadial.C
\*---------------------------------------------------------------------------*/
#ifndef GidaspowRadial_H
#define GidaspowRadial_H
#include "radialModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class Gidaspowradial Declaration
\*---------------------------------------------------------------------------*/
class GidaspowRadial
:
public radialModel
{
public:
//- Runtime type information
TypeName("Gidaspow");
// Constructors
//- Construct from components
GidaspowRadial(const dictionary& dict);
//- Destructor
virtual ~GidaspowRadial();
// Member Functions
tmp<volScalarField> g0
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const;
tmp<volScalarField> g0prime
(
const volScalarField& alpha1,
const dimensionedScalar& alphaMax
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

31
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/LunSavage/LunSavageRadial.C
View File

@ -30,20 +30,29 @@ License
namespace Foam
{
defineTypeNameAndDebug(LunSavageRadial, 0);
namespace kineticTheoryModels
{
namespace radialModels
{
defineTypeNameAndDebug(LunSavage, 0);
addToRunTimeSelectionTable
(
radialModel,
LunSavageRadial,
LunSavage,
dictionary
);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::LunSavageRadial::LunSavageRadial(const dictionary& dict)
Foam::kineticTheoryModels::radialModels::LunSavage::LunSavage
(
const dictionary& dict
)
:
radialModel(dict)
{}
@ -51,30 +60,32 @@ Foam::LunSavageRadial::LunSavageRadial(const dictionary& dict)
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::LunSavageRadial::~LunSavageRadial()
Foam::kineticTheoryModels::radialModels::LunSavage::~LunSavage()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField> Foam::LunSavageRadial::g0
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::LunSavage::g0
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const
{
return pow(1.0 - alpha1/alphaMax, -2.5*alphaMax);
return pow(1.0 - alpha/alphaMax, -2.5*alphaMax);
}
Foam::tmp<Foam::volScalarField> Foam::LunSavageRadial::g0prime
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::LunSavage::g0prime
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const
{
return 2.5*alphaMax*alpha1*pow(1.0 - alpha1, -1.0 - 2.5*alphaMax);
return 2.5*pow(1.0 - alpha/alphaMax, -1.0 - 2.5*alphaMax);
}

26
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/LunSavage/LunSavageRadial.H
View File

@ -22,17 +22,17 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::LunSavageRadial
Foam::kineticTheoryModels::radialModels::LunSavage
Description
SourceFiles
LunSavageRadial.C
LunSavage.C
\*---------------------------------------------------------------------------*/
#ifndef LunSavageRadial_H
#define LunSavageRadial_H
#ifndef LunSavage_H
#define LunSavage_H
#include "radialModel.H"
@ -40,12 +40,16 @@ SourceFiles
namespace Foam
{
namespace kineticTheoryModels
{
namespace radialModels
{
/*---------------------------------------------------------------------------*\
Class LunSavageradial Declaration
Class LunSavage Declaration
\*---------------------------------------------------------------------------*/
class LunSavageRadial
class LunSavage
:
public radialModel
{
@ -59,24 +63,24 @@ public:
// Constructors
//- Construct from components
LunSavageRadial(const dictionary& dict);
LunSavage(const dictionary& dict);
//- Destructor
virtual ~LunSavageRadial();
virtual ~LunSavage();
// Member Functions
tmp<volScalarField> g0
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const;
tmp<volScalarField> g0prime
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const;
};
@ -84,6 +88,8 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace radialModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

33
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/SinclairJackson/SinclairJacksonRadial.C
View File

@ -30,20 +30,29 @@ License
namespace Foam
{
defineTypeNameAndDebug(SinclairJacksonRadial, 0);
namespace kineticTheoryModels
{
namespace radialModels
{
defineTypeNameAndDebug(SinclairJackson, 0);
addToRunTimeSelectionTable
(
radialModel,
SinclairJacksonRadial,
SinclairJackson,
dictionary
);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::SinclairJacksonRadial::SinclairJacksonRadial(const dictionary& dict)
Foam::kineticTheoryModels::radialModels::SinclairJackson::SinclairJackson
(
const dictionary& dict
)
:
radialModel(dict)
{}
@ -51,31 +60,33 @@ Foam::SinclairJacksonRadial::SinclairJacksonRadial(const dictionary& dict)
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::SinclairJacksonRadial::~SinclairJacksonRadial()
Foam::kineticTheoryModels::radialModels::SinclairJackson::~SinclairJackson()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField> Foam::SinclairJacksonRadial::g0
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::SinclairJackson::g0
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const
{
return 1.0/(1.0 - pow(alpha1/alphaMax, 1.0/3.0));
return 1.0/(1.0 - pow(alpha/alphaMax, 1.0/3.0));
}
Foam::tmp<Foam::volScalarField> Foam::SinclairJacksonRadial::g0prime
Foam::tmp<Foam::volScalarField>
Foam::kineticTheoryModels::radialModels::SinclairJackson::g0prime
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const
{
return
(-1.0/3.0)*pow(alpha1/alphaMax, -2.0/3.0)
/(alphaMax*sqr(1.0 - pow(alpha1/alphaMax, 1.0/3.0)));
(1.0/3.0)*pow(max(alpha, 1.0e-6)/alphaMax, -2.0/3.0)
/(alphaMax*sqr(1.0 - pow(alpha/alphaMax, 1.0/3.0)));
}

24
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/SinclairJackson/SinclairJacksonRadial.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::SinclairJacksonRadial
Foam::SinclairJackson
Description
@ -31,8 +31,8 @@ SourceFiles
\*---------------------------------------------------------------------------*/
#ifndef SinclairJacksonRadial_H
#define SinclairJacksonRadial_H
#ifndef SinclairJackson_H
#define SinclairJackson_H
#include "radialModel.H"
@ -40,12 +40,16 @@ SourceFiles
namespace Foam
{
namespace kineticTheoryModels
{
namespace radialModels
{
/*---------------------------------------------------------------------------*\
Class SinclairJacksonradial Declaration
Class SinclairJackson Declaration
\*---------------------------------------------------------------------------*/
class SinclairJacksonRadial
class SinclairJackson
:
public radialModel
{
@ -59,24 +63,24 @@ public:
// Constructors
//- Construct from components
SinclairJacksonRadial(const dictionary& dict);
SinclairJackson(const dictionary& dict);
//- Destructor
virtual ~SinclairJacksonRadial();
virtual ~SinclairJackson();
// Member Functions
tmp<volScalarField> g0
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const;
tmp<volScalarField> g0prime
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const;
};
@ -84,6 +88,8 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace radialModels
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

5
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/radialModel/newRadialModel.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -27,7 +27,8 @@ License
// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::radialModel> Foam::radialModel::New
Foam::autoPtr<Foam::kineticTheoryModels::radialModel>
Foam::kineticTheoryModels::radialModel::New
(
const dictionary& dict
)

9
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/radialModel/radialModel.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -28,16 +28,19 @@ License
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace kineticTheoryModels
{
defineTypeNameAndDebug(radialModel, 0);
defineRunTimeSelectionTable(radialModel, dictionary);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::radialModel::radialModel
Foam::kineticTheoryModels::radialModel::radialModel
(
const dictionary& dict
)
@ -48,7 +51,7 @@ Foam::radialModel::radialModel
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::radialModel::~radialModel()
Foam::kineticTheoryModels::radialModel::~radialModel()
{}

9
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/radialModel/radialModel.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::radialModel
Foam::kineticTheoryModels::radialModel
SourceFiles
radialModel.C
@ -41,6 +41,8 @@ SourceFiles
namespace Foam
{
namespace kineticTheoryModels
{
/*---------------------------------------------------------------------------*\
Class radialModel Declaration
@ -105,14 +107,14 @@ public:
//- Radial distribution function
virtual tmp<volScalarField> g0
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const = 0;
//- Derivative of the radial distribution function
virtual tmp<volScalarField> g0prime
(
const volScalarField& alpha1,
const volScalarField& alpha,
const dimensionedScalar& alphaMax
) const = 0;
};
@ -120,6 +122,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace kineticTheoryModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

9
src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutURoughWallFunction/nutURoughWallFunctionFvPatchScalarField.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -114,13 +114,6 @@ tmp<scalarField> nutURoughWallFunctionFvPatchScalarField::calcYPlus
scalar yPlusLast = 0.0;
scalar dKsPlusdYPlus = roughnessHeight_/y[facei];
// Enforce the roughnessHeight to be less than the distance to
// the first cell centre
if (dKsPlusdYPlus > 1)
{
dKsPlusdYPlus = 1;
}
// Additional tuning parameter - nominally = 1
dKsPlusdYPlus *= roughnessFactor_;

4
tutorials/lagrangian/reactingParcelFoam/evaporationTest/system/fvSchemes
View File

@ -32,12 +32,11 @@ divSchemes
div(phi,U) Gauss upwind;
div(phid,p) Gauss upwind;
div(phi,K) Gauss linear;
div(phi,h) Gauss upwind;
div(phi,k) Gauss upwind;
div(phi,epsilon) Gauss upwind;
div(U) Gauss linear;
div((muEff*dev2(T(grad(U))))) Gauss linear;
div(phi,Yi_h) Gauss upwind;
div(phi,Yi_hs) Gauss upwind;
}
laplacianSchemes
@ -49,7 +48,6 @@ laplacianSchemes
laplacian(DepsilonEff,epsilon) Gauss linear corrected;
laplacian(DREff,R) Gauss linear corrected;
laplacian((rho*(1|A(U))),p) Gauss linear corrected;
laplacian(alphaEff,h) Gauss linear corrected;
}
interpolationSchemes

3
tutorials/lagrangian/sprayFoam/aachenBomb/system/fvSchemes
View File

@ -32,12 +32,11 @@ divSchemes
div(phi,U) Gauss upwind;
div(phid,p) Gauss upwind;
div(phi,K) Gauss linear;
div(phi,h) Gauss upwind;
div(phi,k) Gauss upwind;
div(phi,epsilon) Gauss upwind;
div(U) Gauss linear;
div((muEff*dev2(T(grad(U))))) Gauss linear;
div(phi,Yi_h) Gauss upwind;
div(phi,Yi_hs) Gauss upwind;
}
laplacianSchemes

2
tutorials/multiphase/compressibleTwoPhaseEulerFoam/bubbleColumn/constant/kineticTheoryProperties
View File

@ -41,7 +41,7 @@ granularPressureModel Lun;
frictionalStressModel JohnsonJackson;
radialModel Gidaspow;
radialModel SinclairJackson;
HrenyaSinclairCoeffs
{

2
tutorials/multiphase/compressibleTwoPhaseEulerFoam/fluidisedBed/constant/kineticTheoryProperties
View File

@ -41,7 +41,7 @@ granularPressureModel Lun;
frictionalStressModel JohnsonJackson;
radialModel Gidaspow;
radialModel SinclairJackson;
HrenyaSinclairCoeffs
{

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