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

reactingMultiphaseEulerFoam: Added referencePhase option

Browse Source 
In multiphase systems it is only necessary to solve for all but one of the
moving phases.  The new referencePhase option allows the user to specify which
of the moving phases should not be solved, e.g. in constant/phaseProperties of the
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed tutorial case with

phases (particles air);

referencePhase air;

the particles phase is solved for and the air phase fraction and fluxes obtained
from the particles phase which provides equivalent behaviour to
reactingTwoPhaseEulerFoam and is more efficient than solving for both phases.
This commit is contained in:
Henry Weller
2020-02-05 16:49:22 +00:00
parent 5f79067082
commit d1170cd177
30 changed files with 1621 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/phaseSystem/phaseSystem.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2020 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -185,19 +185,19 @@ Foam::phaseSystem::phaseSystem
phaseModel& phase = phaseModels_[phasei];
if (!phase.stationary())
{
movingPhaseModels_.set(movingPhasei ++, &phase);
movingPhaseModels_.set(movingPhasei++, &phase);
}
if (phase.stationary())
{
stationaryPhaseModels_.set(stationaryPhasei ++, &phase);
stationaryPhaseModels_.set(stationaryPhasei++, &phase);
}
if (!phase.isothermal())
{
anisothermalPhaseModels_.set(anisothermalPhasei ++, &phase);
anisothermalPhaseModels_.set(anisothermalPhasei++, &phase);
}
if (!phase.pure())
{
multiComponentPhaseModels_.set(multiComponentPhasei ++, &phase);
multiComponentPhaseModels_.set(multiComponentPhasei++, &phase);
}
}

172
applications/solvers/multiphase/reactingEulerFoam/reactingMultiphaseEulerFoam/multiphaseSystem/multiphaseSystem.C
View File

@ -354,10 +354,52 @@ void Foam::multiphaseSystem::solve
{
const dictionary& alphaControls = mesh_.solverDict("alpha");
label nAlphaSubCycles(alphaControls.lookup<label>("nAlphaSubCycles"));
label nAlphaCorr(alphaControls.lookup<label>("nAlphaCorr"));
const label nAlphaSubCycles(alphaControls.lookup<label>("nAlphaSubCycles"));
const label nAlphaCorr(alphaControls.lookup<label>("nAlphaCorr"));
bool LTS = fv::localEulerDdt::enabled(mesh_);
const bool LTS = fv::localEulerDdt::enabled(mesh_);
// Optional reference phase which is not solved for
// but obtained from the sum of the other phases
phaseModel* referencePhasePtr = nullptr;
// The phases which are solved
// i.e. the moving phases less the optional reference phase
phaseModelPartialList solvePhases;
if (found("referencePhase"))
{
referencePhasePtr = &phases()[lookup<word>("referencePhase")];
const phaseModel& referencePhase = *referencePhasePtr;
solvePhases.setSize(movingPhases().size() - 1);
label solvePhasesi = 0;
forAll(movingPhases(), movingPhasei)
{
if (movingPhases()[movingPhasei] != referencePhase)
{
solvePhases.set(solvePhasesi++, &movingPhases()[movingPhasei]);
}
}
}
else
{
solvePhases = movingPhases();
}
// The phases included in the flux sum limit
// which is all moving phases if the number of solved phases is > 1
// otherwise it is just the solved phases
// as the flux sum limit is not needed in this case
phaseModelPartialList fluxPhases;
if (solvePhases.size() == 1)
{
fluxPhases = solvePhases;
}
else
{
fluxPhases = movingPhases();
}
forAll(phases(), phasei)
{
@ -369,9 +411,9 @@ void Foam::multiphaseSystem::solve
{
const PtrList<surfaceScalarField> DByAfs(this->DByAfs(rAUs, rAUfs));
forAll(phases(), phasei)
forAll(solvePhases, solvePhasei)
{
phaseModel& phase = phases()[phasei];
phaseModel& phase = phases()[solvePhasei];
volScalarField& alpha = phase;
alphaPhiDbyA0s.set
@ -394,7 +436,6 @@ void Foam::multiphaseSystem::solve
}
List<volScalarField*> alphaPtrs(phases().size());
forAll(phases(), phasei)
{
alphaPtrs[phasei] = &phases()[phasei];
@ -429,40 +470,47 @@ void Foam::multiphaseSystem::solve
// Generate face-alphas
PtrList<surfaceScalarField> alphafs(phases().size());
forAll(phases(), phasei)
if (solvePhases.size() > 1)
{
phaseModel& phase = phases()[phasei];
alphafs.set
(
phasei,
new surfaceScalarField
forAll(phases(), phasei)
{
phaseModel& phase = phases()[phasei];
alphafs.set
(
IOobject::groupName("alphaf", phase.name()),
upwind<scalar>(mesh_, phi_).interpolate(phase)
)
);
phasei,
new surfaceScalarField
(
IOobject::groupName("alphaf", phase.name()),
upwind<scalar>(mesh_, phi_).interpolate(phase)
)
);
}
}
// Create correction fluxes
PtrList<surfaceScalarField> alphaPhiCorrs(phases().size());
forAll(stationaryPhases(), stationaryPhasei)
{
phaseModel& phase = stationaryPhases()[stationaryPhasei];
alphaPhiCorrs.set
(
phase.index(),
new surfaceScalarField
if (solvePhases.size() > 1)
{
forAll(stationaryPhases(), stationaryPhasei)
{
phaseModel& phase = stationaryPhases()[stationaryPhasei];
alphaPhiCorrs.set
(
IOobject::groupName("alphaPhiCorr", phase.name()),
- upwind<scalar>(mesh_, phi_).flux(phase)
)
);
phase.index(),
new surfaceScalarField
(
IOobject::groupName("alphaPhiCorr", phase.name()),
- upwind<scalar>(mesh_, phi_).flux(phase)
)
);
}
}
forAll(movingPhases(), movingPhasei)
forAll(fluxPhases, fluxPhasei)
{
phaseModel& phase = movingPhases()[movingPhasei];
phaseModel& phase = fluxPhases[fluxPhasei];
volScalarField& alpha = phase;
alphaPhiCorrs.set
@ -477,9 +525,9 @@ void Foam::multiphaseSystem::solve
surfaceScalarField& alphaPhiCorr = alphaPhiCorrs[phase.index()];
forAll(phases(), phasei)
forAll(movingPhases(), movingPhasej)
{
phaseModel& phase2 = phases()[phasei];
phaseModel& phase2 = movingPhases()[movingPhasej];
volScalarField& alpha2 = phase2;
if (&phase2 == &phase) continue;
@ -540,21 +588,23 @@ void Foam::multiphaseSystem::solve
);
}
// Limit the flux sums, fixing those of the stationary phases
labelHashSet fixedAlphaPhiCorrs;
forAll(stationaryPhases(), stationaryPhasei)
if (solvePhases.size() > 1)
{
fixedAlphaPhiCorrs.insert
(
stationaryPhases()[stationaryPhasei].index()
);
// Limit the flux sums, fixing those of the stationary phases
labelHashSet fixedAlphaPhiCorrs;
forAll(stationaryPhases(), stationaryPhasei)
{
fixedAlphaPhiCorrs.insert
(
stationaryPhases()[stationaryPhasei].index()
);
}
MULES::limitSum(alphafs, alphaPhiCorrs, fixedAlphaPhiCorrs);
}
MULES::limitSum(alphafs, alphaPhiCorrs, fixedAlphaPhiCorrs);
// Solve for the moving phase alphas
forAll(movingPhases(), movingPhasei)
forAll(solvePhases, solvePhasei)
{
phaseModel& phase = movingPhases()[movingPhasei];
phaseModel& phase = solvePhases[solvePhasei];
volScalarField& alpha = phase;
surfaceScalarField& alphaPhi = alphaPhiCorrs[phase.index()];
@ -658,9 +708,9 @@ void Foam::multiphaseSystem::solve
this->DByAfs(rAUs, rAUfs)
);
forAll(phases(), phasei)
forAll(solvePhases, solvePhasei)
{
phaseModel& phase = phases()[phasei];
phaseModel& phase = solvePhases[solvePhasei];
volScalarField& alpha = phase;
const surfaceScalarField alphaDbyA
@ -682,6 +732,19 @@ void Foam::multiphaseSystem::solve
}
}
if (referencePhasePtr)
{
phaseModel& referencePhase = *referencePhasePtr;
volScalarField& referenceAlpha = referencePhase;
referenceAlpha == alphaVoid;
forAll(solvePhases, solvePhasei)
{
referenceAlpha -= solvePhases[solvePhasei];
}
}
// Report the phase fractions and the phase fraction sum
forAll(phases(), phasei)
{
@ -735,9 +798,9 @@ void Foam::multiphaseSystem::solve
}
}
forAll(movingPhases(), movingPhasei)
forAll(solvePhases, solvePhasei)
{
phaseModel& phase = movingPhases()[movingPhasei];
phaseModel& phase = solvePhases[solvePhasei];
phase.alphaRhoPhiRef() =
fvc::interpolate(phase.rho())*phase.alphaPhi();
@ -745,6 +808,23 @@ void Foam::multiphaseSystem::solve
phase.maxMin(0, 1);
}
if (referencePhasePtr)
{
phaseModel& referencePhase = *referencePhasePtr;
referencePhase.alphaPhiRef() = phi_;
forAll(solvePhases, solvePhasei)
{
phaseModel& phase = solvePhases[solvePhasei];
referencePhase.alphaPhiRef() -= phase.alphaPhi();
}
referencePhase.correctInflowOutflow(referencePhase.alphaPhiRef());
referencePhase.alphaRhoPhiRef() =
fvc::interpolate(referencePhase.rho())*referencePhase.alphaPhi();
}
calcAlphas();
}

48
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/0/T.air Normal file
View File

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

44
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/0/T.particles Normal file
View File

@ -0,0 +1,44 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object T.particles;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 1 0 0 0];
internalField uniform 600;
boundaryField
{
inlet
{
type zeroGradient;
}
outlet
{
type zeroGradient;
}
walls
{
type zeroGradient;
}
frontAndBackPlanes
{
type empty;
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

50
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/0/Theta.particles Normal file
View File

@ -0,0 +1,50 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object Theta.particles;
}
// ************************************************************************* //
dimensions [0 2 -2 0 0 0 0];
internalField uniform 0;
referenceLevel 1e-4;
boundaryField
{
inlet
{
type fixedValue;
value uniform 1e-4;
}
outlet
{
type zeroGradient;
}
walls
{
type JohnsonJacksonParticleTheta;
restitutionCoefficient 0.8;
specularityCoefficient 0.01;
value uniform 1e-4;
}
frontAndBackPlanes
{
type empty;
}
}
// ************************************************************************* //

49
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/0/U.air Normal file
View File

@ -0,0 +1,49 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volVectorField;
object U.air;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField uniform (0 0.25 0);
boundaryField
{
inlet
{
type interstitialInletVelocity;
inletVelocity uniform (0 0.25 0);
alpha alpha.air;
value $internalField;
}
outlet
{
type pressureInletOutletVelocity;
phi phi.air;
value $internalField;
}
walls
{
type noSlip;
}
frontAndBackPlanes
{
type empty;
}
}
// ************************************************************************* //

48
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/0/U.particles Normal file
View File

@ -0,0 +1,48 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volVectorField;
object U.particles;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField uniform (0 0 0);
boundaryField
{
inlet
{
type fixedValue;
value uniform (0 0 0);
}
outlet
{
type fixedValue;
value uniform (0 0 0);
}
walls
{
type JohnsonJacksonParticleSlip;
specularityCoefficient 0.01;
value uniform (0 0 0);
}
frontAndBackPlanes
{
type empty;
}
}
// ************************************************************************* //

44
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/0/alpha.air.orig Normal file
View File

@ -0,0 +1,44 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object alpha.air;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 0 0 0 0];
internalField uniform 0;
boundaryField
{
inlet
{
type zeroGradient;
}
outlet
{
type zeroGradient;
}
walls
{
type zeroGradient;
}
frontAndBackPlanes
{
type empty;
}
}
// ************************************************************************* //

44
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/0/alpha.particles.orig Normal file
View File

@ -0,0 +1,44 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object alpha.particles;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 0 0 0 0];
internalField uniform 0;
boundaryField
{
inlet
{
type zeroGradient;
}
outlet
{
type zeroGradient;
}
walls
{
type zeroGradient;
}
frontAndBackPlanes
{
type empty;
}
}
// ************************************************************************* //

48
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/0/alphat.air Normal file
View File

@ -0,0 +1,48 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object alphat.air;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [1 -1 -1 0 0 0 0];
internalField uniform 0;
boundaryField
{
inlet
{
type calculated;
value $internalField;
}
outlet
{
type calculated;
value $internalField;
}
walls
{
type compressible::alphatWallFunction;
Prt 0.85;
value $internalField;
}
defaultFaces
{
type empty;
}
}
// ************************************************************************* //

47
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/0/alphat.particles Normal file
View File

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

49
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/0/epsilon.air Normal file
View File

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

49
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/0/k.air Normal file
View File

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

47
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/0/nut.air Normal file
View File

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

47
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/0/nut.particles Normal file
View File

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

47
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/0/p Normal file
View File

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

48
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/0/p_rgh Normal file
View File

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

13
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/Allrun Executable file
View File

@ -0,0 +1,13 @@
#!/bin/sh
cd ${0%/*} || exit 1 # Run from this directory
# Source tutorial run functions
. $WM_PROJECT_DIR/bin/tools/RunFunctions
runApplication blockMesh
runApplication setFields
runApplication decomposePar
runParallel $(getApplication)
runApplication reconstructPar
#------------------------------------------------------------------------------

22
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/constant/g Normal file
View File

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

121
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/constant/phaseProperties Normal file
View File

@ -0,0 +1,121 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object phaseProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
type basicMultiphaseSystem;
phases (particles air);
referencePhase air;
particles
{
type purePhaseModel;
diameterModel constant;
constantCoeffs
{
d 3e-4;
}
alphaMax 0.62;
residualAlpha 1e-6;
}
air
{
type purePhaseModel;
diameterModel constant;
constantCoeffs
{
d 1;
}
residualAlpha 0;
}
blending
{
default
{
type none;
continuousPhase air;
}
}
surfaceTension
(
(air and particles)
{
type constant;
sigma 0;
}
);
aspectRatio
();
interfaceCompression
();
drag
(
(particles in air)
{
type GidaspowErgunWenYu;
residualRe 1e-3;
swarmCorrection
{
type none;
}
}
);
virtualMass
(
);
heatTransfer
(
(particles in air)
{
type RanzMarshall;
residualAlpha 1e-4;
}
);
phaseTransfer
(
);
lift
(
);
wallLubrication
(
);
turbulentDispersion
(
);
// Minimum allowable pressure
pMin 10000;
// ************************************************************************* //

48
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/constant/thermophysicalProperties.air Normal file
View File

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

52
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/constant/thermophysicalProperties.particles Normal file
View File

@ -0,0 +1,52 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object thermophysicalProperties.particles;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
thermoType
{
type heRhoThermo;
mixture pureMixture;
transport const;
thermo hConst;
equationOfState rhoConst;
specie specie;
energy sensibleInternalEnergy;
}
mixture
{
specie
{
molWeight 100;
}
equationOfState
{
rho 2500;
}
thermodynamics
{
Cp 6000;
Hf 0;
}
transport
{
mu 0;
Pr 1;
}
}
// ************************************************************************* //

44
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/constant/turbulenceProperties.air Normal file
View File

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

62
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/constant/turbulenceProperties.particles Normal file
View File

@ -0,0 +1,62 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object turbulenceProperties.particles;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
simulationType RAS;
RAS
{
RASModel kineticTheory;
turbulence on;
printCoeffs on;
kineticTheoryCoeffs
{
equilibrium off;
e 0.8;
alphaMax 0.62;
alphaMinFriction 0.5;
residualAlpha 1e-4;
viscosityModel Gidaspow;
conductivityModel Gidaspow;
granularPressureModel Lun;
frictionalStressModel JohnsonJacksonSchaeffer;
radialModel SinclairJackson;
JohnsonJacksonSchaefferCoeffs
{
Fr 0.05;
eta 2;
p 5;
phi 28.5;
alphaDeltaMin 0.01;
}
}
phasePressureCoeffs
{
preAlphaExp 500;
expMax 1000;
alphaMax 0.62;
g0 1000;
}
}
// ************************************************************************* //

66
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/system/blockMeshDict Normal file
View File

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

95
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/system/controlDict Normal file
View File

@ -0,0 +1,95 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object controlDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
application reactingMultiphaseEulerFoam;
startFrom startTime;
startTime 0;
stopAt endTime;
endTime 2;
deltaT 2e-4;
writeControl adjustableRunTime;
writeInterval 0.01;
purgeWrite 0;
writeFormat binary;
writePrecision 6;
writeCompression off;
timeFormat general;
timePrecision 6;
runTimeModifiable on;
adjustTimeStep yes;
maxCo 2;
maxDeltaT 0.01;
functions
{
fieldAverage1
{
type fieldAverage;
libs ("libfieldFunctionObjects.so");
writeControl writeTime;
fields
(
U.particles
{
mean on;
prime2Mean off;
base time;
}
U.air
{
mean on;
prime2Mean off;
base time;
}
alpha.particles
{
mean on;
prime2Mean off;
base time;
}
p
{
mean on;
prime2Mean off;
base time;
}
);
}
}
// ************************************************************************* //

41
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/system/decomposeParDict Normal file
View File

@ -0,0 +1,41 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object decomposeParDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
numberOfSubdomains 4;
/*
Main methods are:
1) Geometric: "simple"; "hierarchical", with ordered sorting, e.g. xyz, yxz
2) Scotch: "scotch", when running in serial; "ptscotch", running in parallel
*/
method hierarchical;
simpleCoeffs
{
n (1 4 1); // total must match numberOfSubdomains
delta 0.001;
}
hierarchicalCoeffs
{
n (1 4 1); // total must match numberOfSubdomains
delta 0.001;
order xyz;
}
// ************************************************************************* //

74
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/system/fvSchemes Normal file
View File

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

105
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/system/fvSolution Normal file
View File

@ -0,0 +1,105 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object fvSolution;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
solvers
{
"alpha.*"
{
nAlphaCorr 1;
nAlphaSubCycles 3;
implicitPhasePressure yes;
extremaCoeff 1;
solver PBiCGStab;
preconditioner DIC;
tolerance 1e-9;
relTol 0;
minIter 1;
}
p_rgh
{
solver GAMG;
smoother DIC;
tolerance 1e-8;
relTol 0.01;
}
p_rghFinal
{
$p_rgh;
relTol 0;
}
"U.*"
{
solver smoothSolver;
smoother symGaussSeidel;
tolerance 1e-5;
relTol 0;
minIter 1;
}
"(h|e).*"
{
solver smoothSolver;
smoother symGaussSeidel;
tolerance 1e-6;
relTol 0;
minIter 1;
maxIter 10;
}
"Theta.*"
{
solver PBiCGStab;
preconditioner DILU;
tolerance 1e-6;
relTol 0;
minIter 1;
}
"(k|epsilon).*"
{
solver PBiCGStab;
preconditioner DILU;
tolerance 1e-5;
relTol 0;
minIter 1;
}
}
PIMPLE
{
nOuterCorrectors 3;
nCorrectors 2;
nNonOrthogonalCorrectors 0;
faceMomentum no;
}
relaxationFactors
{
equations
{
".*" 1;
}
}
// ************************************************************************* //

38
tutorials/multiphase/reactingMultiphaseEulerFoam/RAS/fluidisedBed/system/setFieldsDict Normal file
View File

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