Merge branch 'feature-MPPICInterFoam' into 'develop'

Feature mppic inter foam

New MPPICInterFoam solver. Add MPPIC cloud to a VOF approach. Particles volume are considered into transport Eq fluxes.
    Solves for 2 incompressible, isothermal immiscible fluids using a VOF
    (volume of fluid) phase-fraction based interface capturing approach.
    The momentum and other fluid properties are of the "mixture" and a single
    momentum equation is solved.

Solver:
/applications/solvers/multiphase/MPPICInterFoam
Tutorial:
/tutorials/multiphase/MPPICInterFoam/twoPhasePachuka

See merge request !41
This commit is contained in:
Andrew Heather
2016-06-08 14:04:49 +01:00
38 changed files with 3168 additions and 2 deletions

View File

@ -0,0 +1,8 @@
#!/bin/sh
cd ${0%/*} || exit 1 # run from this directory
set -x
wclean libso CompressibleTwoPhaseMixtureTurbulenceModels
wclean
# ----------------------------------------------------------------- end-of-file

View File

@ -0,0 +1,8 @@
#!/bin/sh
cd ${0%/*} || exit 1 # run from this directory
set -x
wmake libso CompressibleTwoPhaseMixtureTurbulenceModels
wmake
# ----------------------------------------------------------------- end-of-file

View File

@ -0,0 +1,64 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 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 "PhaseCompressibleTurbulenceModel.H"
#include "immiscibleIncompressibleTwoPhaseMixture.H"
#include "addToRunTimeSelectionTable.H"
#include "makeTurbulenceModel.H"
#include "laminar.H"
#include "turbulentTransportModel.H"
#include "LESModel.H"
makeBaseTurbulenceModel
(
volScalarField,
volScalarField,
compressibleTurbulenceModel,
PhaseCompressibleTurbulenceModel,
immiscibleIncompressibleTwoPhaseMixture
);
#define makeRASModel(Type) \
makeTemplatedTurbulenceModel \
(immiscibleIncompressibleTwoPhaseMixturePhaseCompressibleTurbulenceModel, RAS, Type)
#define makeLESModel(Type) \
makeTemplatedTurbulenceModel \
(immiscibleIncompressibleTwoPhaseMixturePhaseCompressibleTurbulenceModel, LES, Type)
#include "kEpsilon.H"
makeRASModel(kEpsilon);
#include "Smagorinsky.H"
makeLESModel(Smagorinsky);
#include "kEqn.H"
makeLESModel(kEqn);
#include "kOmega.H"
makeRASModel(kOmega);
// ************************************************************************* //

View File

@ -0,0 +1,3 @@
CompressibleTwoPhaseMixtureTurbulenceModels.C
LIB = $(FOAM_LIBBIN)/libCompressibleTwoPhaseMixtureTurbulenceModels

View File

@ -0,0 +1,15 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/transportModels/compressible/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
-I$(LIB_SRC)/transportModels \
-I$(LIB_SRC)/transportModels/immiscibleIncompressibleTwoPhaseMixture/lnInclude \
-I$(LIB_SRC)/transportModels/twoPhaseMixture/lnInclude \
-I$(LIB_SRC)/transportModels/incompressible/lnInclude \
-I$(LIB_SRC)/transportModels/interfaceProperties/lnInclude \
-I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
-I$(LIB_SRC)/TurbulenceModels/incompressible/lnInclude \
-I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
-I$(LIB_SRC)/TurbulenceModels/phaseCompressible/lnInclude \
-I$(LIB_SRC)/TurbulenceModels/phaseIncompressible/lnInclude

View File

@ -0,0 +1,167 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 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/>.
Application
MPPICInterFoam
Description
Solver for 2 incompressible, isothermal immiscible fluids using a VOF
(volume of fluid) phase-fraction based interface capturing approach.
The momentum and other fluid properties are of the "mixture" and a single
momentum equation is solved.
It includes MRF and MPPIC clouds
Turbulence modelling is generic, i.e. laminar, RAS or LES may be selected.
\*---------------------------------------------------------------------------*/
#include "fvCFD.H"
#include "CMULES.H"
#include "subCycle.H"
#include "immiscibleIncompressibleTwoPhaseMixture.H"
#include "PhaseCompressibleTurbulenceModel.H"
#include "pimpleControl.H"
#include "fvOptions.H"
#include "CorrectPhi.H"
#include "fixedFluxPressureFvPatchScalarField.H"
#include "basicKinematicMPPICCloud.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
pimpleControl pimple(mesh);
#include "createTimeControls.H"
#include "initContinuityErrs.H"
#include "createFields.H"
#include "createMRF.H"
#include "createFvOptions.H"
#include "correctPhi.H"
turbulence->validate();
#include "readTimeControls.H"
#include "CourantNo.H"
#include "setInitialDeltaT.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime.run())
{
#include "readTimeControls.H"
#include "CourantNo.H"
#include "alphaCourantNo.H"
#include "setDeltaT.H"
runTime++;
Info<< "Time = " << runTime.timeName() << nl << endl;
Info<< "Evolving " << kinematicCloud.name() << endl;
kinematicCloud.evolve();
// Update continuous phase volume fraction field
alphac = max(1.0 - kinematicCloud.theta(), alphacMin);
alphac.correctBoundaryConditions();
Info<< "Continous phase-1 volume fraction = "
<< alphac.weightedAverage(mesh.Vsc()).value()
<< " Min(alphac) = " << min(alphac).value()
<< " Max(alphac) = " << max(alphac).value()
<< endl;
alphacf = fvc::interpolate(alphac);
alphaRhoPhic = alphacf*rhoPhi;
alphaPhic = alphacf*phi;
alphacRho = alphac*rho;
fvVectorMatrix cloudSU(kinematicCloud.SU(U));
volVectorField cloudVolSUSu
(
IOobject
(
"cloudVolSUSu",
runTime.timeName(),
mesh
),
mesh,
dimensionedVector
(
"0",
cloudSU.dimensions()/dimVolume,
vector::zero
),
zeroGradientFvPatchVectorField::typeName
);
cloudVolSUSu.internalField() = -cloudSU.source()/mesh.V();
cloudVolSUSu.correctBoundaryConditions();
cloudSU.source() = vector::zero;
// --- Pressure-velocity PIMPLE corrector loop
while (pimple.loop())
{
#include "alphaControls.H"
#include "alphaEqnSubCycle.H"
#include "UEqn.H"
// --- Pressure corrector loop
while (pimple.correct())
{
#include "pEqn.H"
}
if (pimple.turbCorr())
{
turbulence->correct();
}
}
runTime.write();
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
// ************************************************************************* //

View File

@ -0,0 +1,3 @@
MPPICInterFoam.C
EXE = $(FOAM_APPBIN)/MPPICInterFoam

View File

@ -0,0 +1,42 @@
interFoamPath = $(FOAM_SOLVERS)/multiphase/interFoam
EXE_INC = \
-I./IncompressibleTwoPhaseMixtureTurbulenceModels/lnInclude \
-I$(interFoamPath) \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/fvOptions/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude \
-I$(LIB_SRC)/lagrangian/basic/lnInclude \
-I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/radiation/lnInclude \
-I$(LIB_SRC)/transportModels \
-I$(LIB_SRC)/transportModels/immiscibleIncompressibleTwoPhaseMixture/lnInclude \
-I$(LIB_SRC)/transportModels/twoPhaseMixture/lnInclude \
-I$(LIB_SRC)/transportModels/incompressible/lnInclude \
-I$(LIB_SRC)/transportModels/interfaceProperties/lnInclude \
-I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
-I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
-I$(LIB_SRC)/TurbulenceModels/phaseCompressible/lnInclude \
-I$(LIB_SRC)/regionModels/regionModel/lnInclude \
-I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude
EXE_LIBS = \
-lfiniteVolume \
-lmeshTools \
-llagrangian \
-llagrangianIntermediate \
-lthermophysicalFunctions \
-lspecie \
-lincompressibleTransportModels \
-limmiscibleIncompressibleTwoPhaseMixture \
-lturbulenceModels \
-lsampling \
-lregionModels \
-lsurfaceFilmModels \
-lfvOptions \
-lCompressibleTwoPhaseMixtureTurbulenceModels

View File

@ -0,0 +1,50 @@
MRF.correctBoundaryVelocity(U);
fvVectorMatrix UEqn
(
fvm::ddt(alphacRho, U)
+ MRF.DDt(alphacRho, U)
- fvm::Sp(fvc::ddt(rho) + fvc::div(rhoPhi), U)
+ fvm::div(rhoPhi, U)
+ turbulence->divDevRhoReff(U)
==
fvOptions(rho, U)
+ cloudSU
);
UEqn.relax();
fvOptions.constrain(UEqn);
volScalarField rAUc(1.0/UEqn.A());
surfaceScalarField rAUcf(fvc::interpolate(rAUc));
surfaceScalarField phicForces
(
(fvc::interpolate(rAUc*cloudVolSUSu) & mesh.Sf())
);
if (pimple.momentumPredictor())
{
solve
(
UEqn
==
fvc::reconstruct
(
phicForces/rAUcf
+
(
fvc::interpolate
(
mixture.sigmaK()
)*fvc::snGrad(alpha1)
- ghf*fvc::snGrad(rho)
- fvc::snGrad(p_rgh)
) * mesh.magSf()
)
);
fvOptions.correct(U);
}

View File

@ -0,0 +1,163 @@
{
word alphaScheme("div(phi,alpha)");
word alpharScheme("div(phirb,alpha)");
// Standard face-flux compression coefficient
surfaceScalarField phic
(
mixture.cAlpha()*mag(alphaPhic/mesh.magSf())
);
// Add the optional isotropic compression contribution
if (icAlpha > 0)
{
phic *= (1.0 - icAlpha);
phic += (mixture.cAlpha()*icAlpha)*fvc::interpolate(mag(U));
}
// Do not compress interface at non-coupled boundary faces
// (inlets, outlets etc.)
forAll(phic.boundaryField(), patchi)
{
fvsPatchScalarField& phicp = phic.boundaryField()[patchi];
if (!phicp.coupled())
{
phicp == 0;
}
}
tmp<surfaceScalarField> tphiAlpha;
if (MULESCorr)
{
fvScalarMatrix alpha1Eqn
(
fv::EulerDdtScheme<scalar>(mesh).fvmDdt(alphac, alpha1)
+ fv::gaussConvectionScheme<scalar>
(
mesh,
alphaPhic,
upwind<scalar>(mesh, alphaPhic)
).fvmDiv(alphaPhic, alpha1)
- fvm::Sp(fvc::ddt(alphac) + fvc::div(alphaPhic), alpha1)
);
alpha1Eqn.solve();
Info<< "Phase-1 volume fraction = "
<< alpha1.weightedAverage(mesh.Vsc()).value()
<< " Min(alpha1) = " << min(alpha1).value()
<< " Max(alpha1) = " << max(alpha1).value()
<< endl;
tmp<surfaceScalarField> tphiAlphaUD(alpha1Eqn.flux());
alphaPhi = tphiAlphaUD();
if (alphaApplyPrevCorr && tphiAlphaCorr0.valid())
{
Info<< "Applying the previous iteration compression flux" << endl;
MULES::correct
(
alphac,
alpha1,
alphaPhi,
tphiAlphaCorr0.ref(),
zeroField(), zeroField(),
1, 0
);
alphaPhi += tphiAlphaCorr0();
}
// Cache the upwind-flux
tphiAlphaCorr0 = tphiAlphaUD;
alpha2 = 1.0 - alpha1;
mixture.correct();
}
for (int aCorr=0; aCorr<nAlphaCorr; aCorr++)
{
surfaceScalarField phir(phic*mixture.nHatf());
tmp<surfaceScalarField> tphiAlphaUn
(
fvc::flux
(
alphaPhic,
alpha1,
alphaScheme
)
+ fvc::flux
(
-fvc::flux(-phir, alpha2, alpharScheme),
alpha1,
alpharScheme
)
);
if (MULESCorr)
{
tmp<surfaceScalarField> tphiAlphaCorr(tphiAlphaUn() - alphaPhi);
volScalarField alpha10("alpha10", alpha1);
//MULES::correct(alpha1, tphiAlphaUn(), tphiAlphaCorr(), 1, 0);
MULES::correct
(
alphac,
alpha1,
tphiAlphaUn(),
tphiAlphaCorr.ref(),
zeroField(), zeroField(),
1, 0
);
// Under-relax the correction for all but the 1st corrector
if (aCorr == 0)
{
alphaPhi += tphiAlphaCorr();
}
else
{
alpha1 = 0.5*alpha1 + 0.5*alpha10;
alphaPhi += 0.5*tphiAlphaCorr();
}
}
else
{
alphaPhi = tphiAlphaUn;
MULES::explicitSolve
(
alphac,
alpha1,
alphaPhic,
alphaPhi,
zeroField(), zeroField(),
1, 0
);
}
alpha2 = 1.0 - alpha1;
mixture.correct();
}
rhoPhi = alphaPhi*(rho1 - rho2) + alphaPhic*rho2;
if (alphaApplyPrevCorr && MULESCorr)
{
tphiAlphaCorr0 = alphaPhi - tphiAlphaCorr0;
}
Info<< "Phase-1 volume fraction = "
<< alpha1.weightedAverage(mesh.Vsc()).value()
<< " Min(alpha1) = " << min(alpha1).value()
<< " Max(alpha1) = " << max(alpha1).value()
<< endl;
}

View File

@ -0,0 +1,34 @@
if (nAlphaSubCycles > 1)
{
dimensionedScalar totalDeltaT = runTime.deltaT();
surfaceScalarField rhoPhiSum
(
IOobject
(
"rhoPhiSum",
runTime.timeName(),
mesh
),
mesh,
dimensionedScalar("0", rhoPhi.dimensions(), 0)
);
for
(
subCycle<volScalarField> alphaSubCycle(alpha1, nAlphaSubCycles);
!(++alphaSubCycle).end();
)
{
#include "alphaEqn.H"
rhoPhiSum += (runTime.deltaT()/totalDeltaT)*rhoPhi;
}
rhoPhi = rhoPhiSum;
}
else
{
#include "alphaEqn.H"
}
rho == alpha1*rho1 + alpha2*rho2;
mu = mixture.mu();

View File

@ -0,0 +1,48 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Global
continuityErrs
Description
Calculates and prints the continuity errors.
\*---------------------------------------------------------------------------*/
{
volScalarField contErr(fvc::ddt(alphac) + fvc::div(alphacf*phi));
scalar sumLocalContErr = runTime.deltaTValue()*
mag(contErr)().weightedAverage(mesh.V()).value();
scalar globalContErr = runTime.deltaTValue()*
contErr.weightedAverage(mesh.V()).value();
cumulativeContErr += globalContErr;
Info<< "time step continuity errors : sum local = " << sumLocalContErr
<< ", global = " << globalContErr
<< ", cumulative = " << cumulativeContErr
<< endl;
}
// ************************************************************************* //

View File

@ -0,0 +1,11 @@
CorrectPhi
(
U,
phi,
p_rgh,
dimensionedScalar("rAUf", dimTime/rho.dimensions(), 1),
geometricZeroField(),
pimple
);
#include "continuityErrs.H"

View File

@ -0,0 +1,219 @@
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
#include "createPhi.H"
Info<< "Reading transportProperties\n" << endl;
immiscibleIncompressibleTwoPhaseMixture mixture(U, phi);
volScalarField& alpha1(mixture.alpha1());
volScalarField& alpha2(mixture.alpha2());
const dimensionedScalar& rho1 = mixture.rho1();
const dimensionedScalar& rho2 = mixture.rho2();
// Need to store rho for ddt(rho, U)
volScalarField rho
(
IOobject
(
"rho",
runTime.timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
alpha1*rho1 + alpha2*rho2
);
rho.oldTime();
// Need to store mu as incompressibleTwoPhaseMixture does not store it
volScalarField mu
(
IOobject
(
"mu",
runTime.timeName(),
mesh,
IOobject::READ_IF_PRESENT
),
mixture.mu(),
calculatedFvPatchScalarField::typeName
);
// Mass flux
surfaceScalarField rhoPhi
(
IOobject
(
"rhoPhi",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
fvc::interpolate(rho)*phi
);
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
volScalarField p
(
IOobject
(
"p",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
p_rgh + rho*gh
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
p,
p_rgh,
mesh.solutionDict().subDict("PIMPLE"),
pRefCell,
pRefValue
);
if (p_rgh.needReference())
{
p += dimensionedScalar
(
"p",
p.dimensions(),
pRefValue - getRefCellValue(p, pRefCell)
);
p_rgh = p - rho*gh;
}
mesh.setFluxRequired(p_rgh.name());
mesh.setFluxRequired(alpha1.name());
// MULES flux from previous time-step
surfaceScalarField alphaPhi
(
IOobject
(
"alphaPhi",
runTime.timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
phi*fvc::interpolate(alpha1)
);
tmp<surfaceScalarField> tphiAlphaCorr0;
// alphac must be constructed before the cloud
// so that the drag-models can find it
volScalarField alphac
(
IOobject
(
"alphac",
runTime.timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
mesh,
dimensionedScalar("0", dimless, 0),
zeroGradientFvPatchScalarField::typeName
);
alphac.oldTime();
volScalarField alphacRho(alphac*rho);
alphacRho.oldTime();
Info<< "Constructing kinematicCloud " << endl;
basicKinematicMPPICCloud kinematicCloud
(
"kinematicCloud",
rho,
U,
mu,
g
);
// Particle fraction upper limit
scalar alphacMin
(
1.0
- readScalar
(
kinematicCloud.particleProperties().subDict("constantProperties")
.lookup("alphaMax")
)
);
// Update alphac from the particle locations
alphac = max(1.0 - kinematicCloud.theta(), alphacMin);
alphac.correctBoundaryConditions();
surfaceScalarField alphacf("alphacf", fvc::interpolate(alphac));
// Phase mass flux
surfaceScalarField alphaRhoPhic("alphaRhoPhic", alphacf*rhoPhi);
// Volumetric phase flux
surfaceScalarField alphaPhic("alphaPhic", alphacf*phi);
autoPtr
<
PhaseCompressibleTurbulenceModel
<
immiscibleIncompressibleTwoPhaseMixture
>
>turbulence
(
PhaseCompressibleTurbulenceModel
<
immiscibleIncompressibleTwoPhaseMixture
>::New
(
alphac,
rho,
U,
alphaRhoPhic,
rhoPhi,
mixture
)
);

View File

@ -0,0 +1,73 @@
{
volVectorField HbyA(constrainHbyA(rAUc*UEqn.H(), U, p_rgh));
surfaceScalarField phiHbyA
(
"phiHbyA",
fvc::flux(HbyA)
+ alphacf*fvc::interpolate(rho*rAUc)*fvc::ddtCorr(U, phi)
);
MRF.makeRelative(phiHbyA);
adjustPhi(phiHbyA, U, p_rgh);
surfaceScalarField phig
(
phicForces +
(
fvc::interpolate(mixture.sigmaK())*fvc::snGrad(alpha1)
- ghf*fvc::snGrad(rho)
)*rAUcf*mesh.magSf()
);
phiHbyA += phig;
// Update the pressure BCs to ensure flux consistency
constrainPressure(p_rgh, U, phiHbyA, rAUcf, MRF);
while (pimple.correctNonOrthogonal())
{
surfaceScalarField Dp("Dp", alphacf*rAUcf);
fvScalarMatrix p_rghEqn
(
fvm::laplacian(Dp, p_rgh)
==
fvc::ddt(alphac) + fvc::div(alphacf*phiHbyA)
);
p_rghEqn.setReference(pRefCell, getRefCellValue(p_rgh, pRefCell));
p_rghEqn.solve(mesh.solver(p_rgh.select(pimple.finalInnerIter())));
if (pimple.finalNonOrthogonalIter())
{
phi = phiHbyA - p_rghEqn.flux()/alphacf;
p_rgh.relax();
U =
HbyA
+ rAUc*fvc::reconstruct((phig - p_rghEqn.flux()/alphacf)/rAUcf);
U.correctBoundaryConditions();
fvOptions.correct(U);
}
}
#include "continuityErrs.H"
p == p_rgh + rho*gh;
if (p_rgh.needReference())
{
p += dimensionedScalar
(
"p",
p.dimensions(),
pRefValue - getRefCellValue(p, pRefCell)
);
p_rgh = p - rho*gh;
}
}

View File

@ -43,6 +43,7 @@ License
#include "PressureGradientForce.H" #include "PressureGradientForce.H"
#include "SRFForce.H" #include "SRFForce.H"
#include "VirtualMassForce.H" #include "VirtualMassForce.H"
#include "InterfaceForce.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -61,8 +62,8 @@ License
makeParticleForceModelType(ParamagneticForce, CloudType); \ makeParticleForceModelType(ParamagneticForce, CloudType); \
makeParticleForceModelType(PressureGradientForce, CloudType); \ makeParticleForceModelType(PressureGradientForce, CloudType); \
makeParticleForceModelType(SRFForce, CloudType); \ makeParticleForceModelType(SRFForce, CloudType); \
makeParticleForceModelType(VirtualMassForce, CloudType); makeParticleForceModelType(VirtualMassForce, CloudType); \
makeParticleForceModelType(InterfaceForce, CloudType);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

View File

@ -0,0 +1,146 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 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 "InterfaceForce.H"
#include "fvcGrad.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CloudType>
Foam::InterfaceForce<CloudType>::InterfaceForce
(
CloudType& owner,
const fvMesh& mesh,
const dictionary& dict
)
:
ParticleForce<CloudType>(owner, mesh, dict, typeName, true),
alpaName_
(
this->coeffs().template lookup("alphaName")
),
C_
(
readScalar(this->coeffs().lookup("C"))
),
gradInterForceInterpPtr_(NULL)
{}
template<class CloudType>
Foam::InterfaceForce<CloudType>::InterfaceForce
(
const InterfaceForce& pf
)
:
ParticleForce<CloudType>(pf),
alpaName_(pf.alpaName_),
C_(pf.C_),
gradInterForceInterpPtr_(pf.gradInterForceInterpPtr_)
{}
// * * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * //
template<class CloudType>
Foam::InterfaceForce<CloudType>::~InterfaceForce()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class CloudType>
void Foam::InterfaceForce<CloudType>::cacheFields(const bool store)
{
static word fName("gradAlpha");
bool fieldExists =
this->mesh().template foundObject<volVectorField>(fName);
if (store)
{
if (!fieldExists)
{
const volScalarField& alpha = this->mesh().template
lookupObject<volScalarField>(alpaName_);
volVectorField* gradInterForcePtr =
new volVectorField(fName, fvc::grad(alpha*(1-alpha)));
gradInterForcePtr->store();
}
const volVectorField& gradInterForce = this->mesh().template
lookupObject<volVectorField>(fName);
gradInterForceInterpPtr_.reset
(
interpolation<vector>::New
(
this->owner().solution().interpolationSchemes(),
gradInterForce
).ptr()
);
}
else
{
gradInterForceInterpPtr_.clear();
if (fieldExists)
{
const volVectorField& gradInterForce = this->mesh().template
lookupObject<volVectorField>(fName);
const_cast<volVectorField&>(gradInterForce).checkOut();
}
}
}
template<class CloudType>
Foam::forceSuSp Foam::InterfaceForce<CloudType>::calcNonCoupled
(
const typename CloudType::parcelType& p,
const scalar dt,
const scalar mass,
const scalar Re,
const scalar muc
) const
{
forceSuSp value(vector::zero, 0.0);
const interpolation<vector>& gradInterForceInterp =
gradInterForceInterpPtr_();
value.Su()=
C_
*mass
*gradInterForceInterp.interpolate(p.position(), p.currentTetIndices());
return value;
}
// ************************************************************************* //

View File

@ -0,0 +1,134 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 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::InterfaceForce
Description
Vector force apply to particles to avoid the crossing of particles from
one phase to the other. The magnitude is calculated as C*mass*grad(alpha)
SourceFiles
InterfaceForce.C
\*---------------------------------------------------------------------------*/
#ifndef InterfaceForce_H
#define InterfaceForce_H
#include "ParticleForce.H"
#include "interpolation.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class fvMesh;
/*---------------------------------------------------------------------------*\
Class InterfaceForce Declaration
\*---------------------------------------------------------------------------*/
template<class CloudType>
class InterfaceForce
:
public ParticleForce<CloudType>
{
// Private data
//- Name of VOF field
const word alpaName_;
//- Model constant
const scalar C_;
//- gradInterForce interpolator
autoPtr<interpolation<vector> > gradInterForceInterpPtr_;
public:
//- Runtime type information
TypeName("interface");
// Constructors
//- Construct from mesh
InterfaceForce
(
CloudType& owner,
const fvMesh& mesh,
const dictionary& dict
);
//- Construct copy
InterfaceForce(const InterfaceForce& gf);
//- Construct and return a clone
virtual autoPtr<ParticleForce<CloudType> > clone() const
{
return autoPtr<ParticleForce<CloudType> >
(
new InterfaceForce<CloudType>(*this)
);
}
//- Destructor
virtual ~InterfaceForce();
// Evaluation
//- Cache fields
virtual void cacheFields(const bool store);
//- Calculate the non-coupled force
virtual forceSuSp calcNonCoupled
(
const typename CloudType::parcelType& p,
const scalar dt,
const scalar mass,
const scalar Re,
const scalar muc
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "InterfaceForce.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

View File

@ -0,0 +1,52 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format binary;
class volVectorField;
object Uair;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField uniform (0 0 0);
boundaryField
{
inlet
{
type uniformFixedValue;
uniformValue table
(
(0 (0 0 0.1))
(1 (0 0 0.1))
(4 (0 0 0.3))
(14 (0 0 0.5))
);
}
outlet
{
type pressureInletOutletVelocity;
value $internalField;
inletValue $internalField;
}
walls
{
type fixedValue;
value uniform (0 0 0);
}
base
{
type fixedValue;
value uniform (0 0 0);
}
}
// ************************************************************************* //

View File

@ -0,0 +1,56 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object alpha.water;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 0 0 0 0];
internalField uniform 1;
boundaryField
{
inlet
{
type uniformFixedValue;
uniformValue table
(
(0 1)
(1 1)
(1.01 0)
(14 0)
);
}
outlet
{
type inletOutlet;
inletValue uniform 0;
value uniform 0;
}
walls
{
type zeroGradient;
}
base
{
type zeroGradient;
}
defaultFaces
{
type empty;
}
}
// ************************************************************************* //

View File

@ -0,0 +1,48 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object epsilon;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -3 0 0 0 0];
internalField uniform 0.1;
boundaryField
{
inlet
{
type fixedValue;
value $internalField;
}
outlet
{
type inletOutlet;
inletValue $internalField;
value $internalField;
}
walls
{
type epsilonWallFunction;
value $internalField;
}
base
{
type epsilonWallFunction;
value $internalField;
}
}
// ************************************************************************* //

View File

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

View File

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

View File

@ -0,0 +1,46 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object p_rgh;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [ 1 -1 -2 0 0 0 0 ];
internalField uniform 0;
boundaryField
{
inlet
{
type fixedFluxPressure;
value uniform 0;
}
outlet
{
type prghTotalPressure;
p0 uniform 0;
value uniform 0;
}
walls
{
type fixedFluxPressure;
value uniform 0;
}
base
{
type fixedFluxPressure;
value uniform 0;
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

View File

@ -0,0 +1,12 @@
#!/bin/sh
cd ${0%/*} || exit 1 # Run from this directory
# Source tutorial clean functions
. $WM_PROJECT_DIR/bin/tools/CleanFunctions
cleanCase
rm system/blockMeshDict
rm 0/alpha.water
# ----------------------------------------------------------------- end-of-file

View File

@ -0,0 +1,36 @@
#!/bin/sh
cd ${0%/*} || exit 1 # Run from this directory
# Source tutorial run functions
. $WM_PROJECT_DIR/bin/tools/RunFunctions
# Set application name
application=`getApplication`
# create the underlying block mesh
m4 system/pachuka.m4 > system/blockMeshDict
runApplication blockMesh
cp 0/alpha.water.org 0/alpha.water
# create faceSet for burner inlet and faceZone for coupled wall
runApplication topoSet
# create burner inlet
runApplication createPatch -overwrite
# Set alpha.water
runApplication setFields
# Decompose mesh
decomposePar > log.decomposePar 2>&1
# Run
runParallel `getApplication`
# Reconstruct case
runApplication reconstructPar
# ----------------------------------------------------------------- end-of-file

View File

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

View File

@ -0,0 +1,205 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object particleProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
solution
{
active true;
coupled true;
transient yes;
cellValueSourceCorrection no;
maxCo 0.3;
interpolationSchemes
{
rho cell;
U cellPoint;
mu cell;
gradAlpha cellPoint;
}
averagingMethod dual;
integrationSchemes
{
U Euler;
}
sourceTerms
{
schemes
{
U semiImplicit 0.8;
}
}
}
constantProperties
{
rho0 1200;
alphaMax 0.9;
}
subModels
{
particleForces
{
WenYuDrag
{
alphac alphac;
}
gravity;
interface
{
C -10;
alphaName alpha.water;
}
}
injectionModels
{
model1
{
type patchInjection;
massTotal 140e-3;
SOI 0;
parcelBasisType fixed;//mass;
nParticle 1;
patchName inlet;
duration 1;
parcelsPerSecond 1e5;
U0 (0 0 0.1);
flowRateProfile constant 1;
sizeDistribution
{
type normal;
normalDistribution
{
expectation 550e-6;
variance 50e-6;
minValue 400e-6;
maxValue 800e-6;
}
}
}
}
dispersionModel none;
patchInteractionModel localInteraction;
localInteractionCoeffs
{
patches
(
walls
{
type rebound;
e 0.95;
mu 0.09;
}
base
{
type rebound;
e 0.95;
mu 0.09;
}
inlet
{
type escape;
}
outlet
{
type escape;
}
);
}
heatTransferModel none;
surfaceFilmModel none;
packingModel implicit;
explicitCoeffs
{
particleStressModel
{
type HarrisCrighton;
alphaPacked 0.6;
pSolid 10.0;
beta 2.0;
eps 1.0e-7;
}
correctionLimitingMethod
{
type absolute;
e 0.9;
}
}
implicitCoeffs
{
alphaMin 0.001;
rhoMin 1.0;
applyGravity false;
applyLimiting false;
particleStressModel
{
type HarrisCrighton;
alphaPacked 0.9;
pSolid 5.0;
beta 2.0;
eps 1.0e-2;
}
}
dampingModel relaxation;
relaxationCoeffs
{
timeScaleModel
{
type nonEquilibrium;
alphaPacked 0.7;
e 0.8;
}
}
isotropyModel stochastic;
stochasticCoeffs
{
timeScaleModel
{
type isotropic;
alphaPacked 0.7;
e 0.8;
}
}
stochasticCollisionModel none;
radiation off;
}
cloudFunctions
{}
// ************************************************************************* //

View File

@ -0,0 +1,67 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object transportProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
phases (water air);
water
{
transportModel Newtonian;
nu nu [ 0 2 -1 0 0 0 0 ] 1e-06;
rho rho [ 1 -3 0 0 0 0 0 ] 1000;
CrossPowerLawCoeffs
{
nu0 nu0 [ 0 2 -1 0 0 0 0 ] 1e-06;
nuInf nuInf [ 0 2 -1 0 0 0 0 ] 1e-06;
m m [ 0 0 1 0 0 0 0 ] 1;
n n [ 0 0 0 0 0 0 0 ] 0;
}
BirdCarreauCoeffs
{
nu0 nu0 [ 0 2 -1 0 0 0 0 ] 0.0142515;
nuInf nuInf [ 0 2 -1 0 0 0 0 ] 1e-06;
k k [ 0 0 1 0 0 0 0 ] 99.6;
n n [ 0 0 0 0 0 0 0 ] 0.1003;
}
}
air
{
transportModel Newtonian;
nu nu [ 0 2 -1 0 0 0 0 ] 1.48e-05;
rho rho [ 1 -3 0 0 0 0 0 ] 1;
CrossPowerLawCoeffs
{
nu0 nu0 [ 0 2 -1 0 0 0 0 ] 1e-06;
nuInf nuInf [ 0 2 -1 0 0 0 0 ] 1e-06;
m m [ 0 0 1 0 0 0 0 ] 1;
n n [ 0 0 0 0 0 0 0 ] 0;
}
BirdCarreauCoeffs
{
nu0 nu0 [ 0 2 -1 0 0 0 0 ] 0.0142515;
nuInf nuInf [ 0 2 -1 0 0 0 0 ] 1e-06;
k k [ 0 0 1 0 0 0 0 ] 99.6;
n n [ 0 0 0 0 0 0 0 ] 0.1003;
}
}
sigma sigma [ 1 0 -2 0 0 0 0 ] 0.07;
// ************************************************************************* //

View File

@ -0,0 +1,26 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object turbulenceProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
simulationType RAS;
RAS
{
RASModel kEpsilon;
turbulence on;
printCoeffs on;
}
// ************************************************************************* //

View File

@ -0,0 +1,67 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object controlDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
application MPPICInterFoam;
startFrom startTime;
startTime 0;
stopAt endTime;
endTime 14.0;
deltaT 0.001;
writeControl adjustableRunTime;
writeInterval 0.2;
purgeWrite 0;
writeFormat ascii;
writePrecision 6;
writeCompression uncompressed;
timeFormat general;
timePrecision 6;
runTimeModifiable yes;
adjustTimeStep yes;
maxCo 1.0;
maxAlphaCo 1.0;
maxDeltaT 0.05;
functions
{
minMax
{
type fieldMinMax;
functionObjectLibs ("libfieldFunctionObjects.so");
outputControl timeStep; //outputTime;
fields (U);
}
}
// ************************************************************************* //

View File

@ -0,0 +1,41 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object createPatchDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
pointSync false;
// Patches to create.
patches
(
{
// Name of new patch
name inlet;
// Type of new patch
patchInfo
{
type patch;
}
// How to construct: either from 'patches' or 'set'
constructFrom set;
// If constructFrom = set : name of faceSet
set inlet;
}
);
// ************************************************************************* //

View File

@ -0,0 +1,30 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object decomposeParDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
numberOfSubdomains 4;
method hierarchical;
hierarchicalCoeffs
{
n (1 1 4);
delta 0.001;
order xyz;
}
// ************************************************************************* //

View File

@ -0,0 +1,64 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ 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(rhoPhi,U) Gauss upwind;
div(phi,alpha) Gauss vanLeer;
div(phirb,alpha) Gauss linear;
div(alphaRhoPhic,k) Gauss upwind;
div(alphaRhoPhic,epsilon) Gauss upwind;
div((((alphac*rho)*nuEff)*dev2(T(grad(U))))) Gauss linear;
div(phiGByA,kinematicCloud:alpha) Gauss linear;
}
laplacianSchemes
{
default Gauss linear corrected;
}
interpolationSchemes
{
default linear;
}
snGradSchemes
{
default corrected;
}
fluxRequired
{
default no;
p_rgh;
pcorr;
alpha.water;
}
// ************************************************************************* //

View File

@ -0,0 +1,95 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object fvSolution;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
solvers
{
"alpha.water.*"
{
nAlphaCorr 2;
nAlphaSubCycles 2;
cAlpha 1;
MULESCorr yes;
nLimiterIter 2;
solver smoothSolver;
smoother symGaussSeidel;
tolerance 1e-7;
relTol 0;
maxIter 100;
}
pcorr
{
solver PCG;
preconditioner DIC;
tolerance 1e-5;
relTol 0;
}
p_rgh
{
solver PCG;
preconditioner DIC;
tolerance 1e-07;
relTol 0.05;
}
p_rghFinal
{
$p_rgh;
relTol 0;
}
"(U|k|epsilon).*"
{
solver smoothSolver;
smoother symGaussSeidel;
tolerance 1e-06;
relTol 0;
}
kinematicCloud:alpha
{
solver GAMG;
tolerance 1e-06;
relTol 0.1;
smoother GaussSeidel;
cacheAgglomeration true;
nCellsInCoarsestLevel 10;
agglomerator faceAreaPair;
mergeLevels 1;
}
}
PIMPLE
{
momentumPredictor no;
nOuterCorrectors 1;
nCorrectors 3;
nNonOrthogonalCorrectors 0;
}
relaxationFactors
{
equations
{
".*" 1;
}
}
// ************************************************************************* //

View File

@ -0,0 +1,936 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object blockMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
convertToMeters 0.001;
changecom(//)changequote([,])
define(calc, [esyscmd(perl -e 'printf ($1)')])
define(VCOUNT, 0)
define(vlabel, [[// ]Vertex $1 = VCOUNT define($1, VCOUNT)define([VCOUNT], incr(VCOUNT))])
define(Dt, 220)
define(DdDt, 0.33)
define(HtDt, 3)
define(PI, 3.14159265)
define(Dd, calc(Dt * DdDt))
define(Ht, calc(HtDt * Dt))
define(psB, calc(Ht/10.0))
define(psH, calc(psB * 1.5))
define(Hl, calc(Ht-psH-psB))
define(Hl2, calc((Hl/2.0)+psB))
define(Hl3, calc(Hl+psB))
define(eDd, calc(Dt/100))
define(Rd, calc(Dd/2))
define(Rd2, calc(Dd/4))
define(Rd3, calc(Rd + eDd))
define(Rt, calc(Dt/2))
define(qRt, calc(Rt * 0.75))
define(cx, calc(Rd2*cos((PI/180)*45)))
define(cy, calc(Rd2*sin((PI/180)*45)))
define(ccx, calc(Rd*cos((PI/180)*45)))
define(ccy, calc(Rd*sin((PI/180)*45)))
define(ecx, calc(Rd3*cos((PI/180)*45)))
define(ecy, calc(Rd3*sin((PI/180)*45)))
define(tcx, calc(Rt*cos((PI/180)*45)))
define(tcy, calc(Rt*sin((PI/180)*45)))
define(qcx, calc(Rt*0.75*cos((PI/180)*45)))
define(qcy, calc(Rt*0.75*sin((PI/180)*45)))
define(NPS, 7) //square section
define(NPS1, 25)
define(NPS2, 5) //vertical in the lower cylinder
define(NPS3, 10) //vertical in the upper cylindre
define(NPD, 8) //square section to perimeter
define(NPC, 1) //center
define(NPE, 8) //external
vertices
(
( -cx -cy 0.0)
( cx -cy 0.0)
( cx cy 0.0)
( -cx cy 0.0)
( -cx -cy psB)
( cx -cy psB)
( cx cy psB)
( -cx cy psB)
( ccx -ccy 0.0)
( ccx ccy 0.0)
( ccx -ccy psB)
( ccx ccy psB)
( -ccx -ccy 0.0)
( -ccx ccy 0.0)
( -ccx -ccy psB)
( -ccx ccy psB)
( ecx -ecy 0.0) //16
( ecx ecy 0.0)
( ecx -ecy psB)
( ecx ecy psB)
( -ecx -ecy 0.0)
( -ecx ecy 0.0)
( -ecx -ecy psB)
( -ecx ecy psB)
( qcx -qcy 0.0) //24
( qcx qcy 0.0)
( qcx -qcy psB)
( qcx qcy psB)
( -qcx -qcy 0.0)
( -qcx qcy 0.0)
( -qcx -qcy psB)
( -qcx qcy psB)
( tcx -tcy 0.0) //32
( tcx tcy 0.0)
( tcx -tcy psB)
( tcx tcy psB)
( -tcx -tcy 0.0)
( -tcx tcy 0.0)
( -tcx -tcy psB)
( -tcx tcy psB)
( qcx -qcy Hl2) //40
( qcx qcy Hl2)
( -qcx -qcy Hl2)
( -qcx qcy Hl2)
( tcx -tcy Hl2) //44
( tcx tcy Hl2)
( -tcx -tcy Hl2)
( -tcx tcy Hl2)
( ecx -ecy Hl2) //48
( ecx ecy Hl2)
( -ecx -ecy Hl2)
( -ecx ecy Hl2)
( -cx -cy Hl2) //52
( cx -cy Hl2)
( cx cy Hl2)
( -cx cy Hl2)
( ccx -ccy Hl2) //56
( ccx ccy Hl2)
( -ccx -ccy Hl2)
( -ccx ccy Hl2)
( -cx -cy Hl3) //60
( cx -cy Hl3)
( cx cy Hl3)
( -cx cy Hl3)
( ccx -ccy Hl3) //64
( ccx ccy Hl3)
( -ccx -ccy Hl3)
( -ccx ccy Hl3)
( qcx -qcy Hl3) //68
( qcx qcy Hl3)
( -qcx -qcy Hl3)
( -qcx qcy Hl3)
( ecx -ecy Hl3) //72
( ecx ecy Hl3)
( -ecx -ecy Hl3)
( -ecx ecy Hl3)
( tcx -tcy Hl3) //76
( tcx tcy Hl3)
( -tcx -tcy Hl3)
( -tcx tcy Hl3)
( -cx -cy Ht) //80
( cx -cy Ht)
( cx cy Ht)
( -cx cy Ht)
( ccx -ccy Ht) //84
( ccx ccy Ht)
( -ccx -ccy Ht)
( -ccx ccy Ht)
( qcx -qcy Ht) //88
( qcx qcy Ht)
( -qcx -qcy Ht)
( -qcx qcy Ht)
( ecx -ecy Ht) //92
( ecx ecy Ht)
( -ecx -ecy Ht)
( -ecx ecy Ht)
( tcx -tcy Ht) //96
( tcx tcy Ht)
( -tcx -tcy Ht)
( -tcx tcy Ht)
);
blocks
(
hex
(
0 1 2 3
4 5 6 7
)
(NPS NPS NPS2)
simpleGrading (1 1 1)
//quartier est
hex
(
1 8 9 2
5 10 11 6
)
(NPD NPS NPS2)
simpleGrading (0.9 1 1)
//quartier ouest
hex
(
3 13 12 0
7 15 14 4
)
(NPD NPS NPS2)
simpleGrading (0.9 1 1)
//quartier sud
hex
(
0 12 8 1
4 14 10 5
)
(NPD NPS NPS2)
simpleGrading (0.9 1 1)
//quartier nord
hex
(
2 9 13 3
6 11 15 7
)
(NPD NPS NPS2)
simpleGrading (0.9 1 1)
// **************************************
// Fabrication couronne inférieure 4 et 5
//ceinture est
hex
(
8 16 17 9
10 18 19 11
)
(NPC NPS NPS2)
simpleGrading (1 1 1)
//ceinture ouest
hex
(
13 21 20 12
15 23 22 14
)
(NPC NPS NPS2)
simpleGrading (1 1 1)
//ceinture sud
hex
(
12 20 16 8
14 22 18 10
)
(NPC NPS NPS2)
simpleGrading (1 1 1)
//ceinture nord
hex
(
9 17 21 13
11 19 23 15
)
(NPC NPS NPS2)
simpleGrading (1 1 1)
// Couronne inférieure externe
//mi-couronne est
hex
(
16 24 25 17
18 26 27 19
)
(NPE NPS NPS2)
simpleGrading (1.1 1 1)
//mi-couronne ouest
hex
(
21 29 28 20
23 31 30 22
)
(NPE NPS NPS2)
simpleGrading (1.1 1 1)
//mi-couronne sud
hex
(
20 28 24 16
22 30 26 18
)
(NPE NPS NPS2)
simpleGrading (1.1 1 1)
//mi-couronne nord
hex
(
17 25 29 21
19 27 31 23
)
(NPE NPS NPS2)
simpleGrading (1.1 1 1)
//mi-couronne est2
hex
(
24 32 33 25
26 34 35 27
)
(NPE NPS NPS2)
simpleGrading (0.9 1 1)
//mi-couronne ouest2
hex
(
29 37 36 28
31 39 38 30
)
(NPE NPS NPS2)
simpleGrading (0.9 1 1)
//mi-couronne sud2
hex
(
28 36 32 24
30 38 34 26
)
(NPE NPS NPS2)
simpleGrading (0.9 1 1)
//mi-couronne nord2
hex
(
25 33 37 29
27 35 39 31
)
(NPE NPS NPS2)
simpleGrading (0.9 1 1)
// LongBas
//est
hex
(
18 26 27 19
48 40 41 49
)
(NPE NPS NPS1)
simpleGrading (1.1 1 1)
//ouest
hex
(
23 31 30 22
51 43 42 50
)
(NPE NPS NPS1)
simpleGrading (1.1 1 1)
//sud
hex
(
22 30 26 18
50 42 40 48
)
(NPE NPS NPS1)
simpleGrading (1.1 1 1)
//Nord
hex
(
19 27 31 23
49 41 43 51
)
(NPE NPS NPS1)
simpleGrading (1.1 1 1)
//square
hex
(
4 5 6 7
52 53 54 55
)
(NPS NPS NPS1)
simpleGrading (1 1 1)
// est-in
hex
(
5 10 11 6
53 56 57 54
)
(NPD NPS NPS1)
simpleGrading (0.9 1 1)
// ouest-in
hex
(
7 15 14 4
55 59 58 52
)
(NPD NPS NPS1)
simpleGrading (0.9 1 1)
// sud-in
hex
(
4 14 10 5
52 58 56 53
)
(NPD NPS NPS1)
simpleGrading (0.9 1 1)
// nord-in
hex
(
6 11 15 7
54 57 59 55
)
(NPD NPS NPS1)
simpleGrading (0.9 1 1)
// Couronne exterieure longue
// est
hex
(
26 34 35 27
40 44 45 41
)
(NPE NPS NPS1)
simpleGrading (0.9 1 1)
// ouest
hex
(
31 39 38 30
43 47 46 42
)
(NPE NPS NPS1)
simpleGrading (0.9 1 1)
// sud
hex
(
30 38 34 26
42 46 44 40
)
(NPE NPS NPS1)
simpleGrading (0.9 1 1)
// nord
hex
(
27 35 39 31
41 45 47 43
)
(NPE NPS NPS1)
simpleGrading (0.9 1 1)
// longHaut
//square
hex
(
52 53 54 55
60 61 62 63
)
(NPS NPS NPS1)
simpleGrading (1 1 1)
// est-in
hex
(
53 56 57 54
61 64 65 62
)
(NPD NPS NPS1)
simpleGrading (0.9 1 1)
// ouest-in
hex
(
55 59 58 52
63 67 66 60
)
(NPD NPS NPS1)
simpleGrading (0.9 1 1)
// sud-in
hex
(
52 58 56 53
60 66 64 61
)
(NPD NPS NPS1)
simpleGrading (0.9 1 1)
// nord-in
hex
(
54 57 59 55
62 65 67 63
)
(NPD NPS NPS1)
simpleGrading (0.9 1 1)
//est
hex
(
48 40 41 49
72 68 69 73
)
(NPE NPS NPS1)
simpleGrading (1.1 1 1)
//ouest
hex
(
51 43 42 50
75 71 70 74
)
(NPE NPS NPS1)
simpleGrading (1.1 1 1)
//sud
hex
(
50 42 40 48
74 70 68 72
)
(NPE NPS NPS1)
simpleGrading (1.1 1 1)
//Nord
hex
(
49 41 43 51
73 69 71 75
)
(NPE NPS NPS1)
simpleGrading (1.1 1 1)
// couronne externe haute
// est
hex
(
40 44 45 41
68 76 77 69
)
(NPE NPS NPS1)
simpleGrading (0.9 1 1)
// ouest
hex
(
43 47 46 42
71 79 78 70
)
(NPE NPS NPS1)
simpleGrading (0.9 1 1)
// sud
hex
(
42 46 44 40
70 78 76 68
)
(NPE NPS NPS1)
simpleGrading (0.9 1 1)
// nord
hex
(
41 45 47 43
69 77 79 71
)
(NPE NPS NPS1)
simpleGrading (0.9 1 1)
// Bloc supérieur
//square
hex
(
60 61 62 63
80 81 82 83
)
(NPS NPS NPS3)
simpleGrading (1 1 1)
// est-in
hex
(
61 64 65 62
81 84 85 82
)
(NPD NPS NPS3)
simpleGrading (0.9 1 1)
// ouest-in
hex
(
63 67 66 60
83 87 86 80
)
(NPD NPS NPS3)
simpleGrading (0.9 1 1)
// sud-in
hex
(
60 66 64 61
80 86 84 81
)
(NPD NPS NPS3)
simpleGrading (0.9 1 1)
// nord-in
hex
(
62 65 67 63
82 85 87 83
)
(NPD NPS NPS3)
simpleGrading (0.9 1 1)
// Fabrication couronne supérieure 6 et 7
//ceinture est
hex
(
64 72 73 65
84 92 93 85
)
(NPC NPS NPS3)
simpleGrading (1 1 1)
//ceinture ouest
hex
(
67 75 74 66
87 95 94 86
)
(NPC NPS NPS3)
simpleGrading (1 1 1)
//ceinture sud
hex
(
66 74 72 64
86 94 92 84
)
(NPC NPS NPS3)
simpleGrading (1 1 1)
//ceinture nord
hex
(
65 73 75 67
85 93 95 87
)
(NPC NPS NPS3)
simpleGrading (1 1 1)
//est
hex
(
72 68 69 73
92 88 89 93
)
(NPE NPS NPS3)
simpleGrading (1.1 1 1)
//ouest
hex
(
75 71 70 74
95 91 90 94
)
(NPE NPS NPS3)
simpleGrading (1.1 1 1)
//sud
hex
(
74 70 68 72
94 90 88 92
)
(NPE NPS NPS3)
simpleGrading (1.1 1 1)
//Nord
hex
(
73 69 71 75
93 89 91 95
)
(NPE NPS NPS3)
simpleGrading (1.1 1 1)
// couronne externe
// est
hex
(
68 76 77 69
88 96 97 89
)
(NPE NPS NPS3)
simpleGrading (0.9 1 1)
// ouest
hex
(
71 79 78 70
91 99 98 90
)
(NPE NPS NPS3)
simpleGrading (0.9 1 1)
// sud
hex
(
70 78 76 68
90 98 96 88
)
(NPE NPS NPS3)
simpleGrading (0.9 1 1)
// nord
hex
(
69 77 79 71
89 97 99 91
)
(NPE NPS NPS3)
simpleGrading (0.9 1 1)
);
edges
(
arc 8 9 (Rd 0.0 0.0)
arc 10 11 (Rd 0.0 psB)
arc 13 12 (-Rd 0.0 0.0)
arc 15 14 (-Rd 0.0 psB)
arc 12 8 (0.0 -Rd 0.0)
arc 14 10 (0.0 -Rd psB)
arc 9 13 (0.0 Rd 0.0)
arc 11 15 (0.0 Rd psB)
arc 16 17 (Rd3 0.0 0.0)
arc 18 19 (Rd3 0.0 psB)
arc 21 20 (-Rd3 0.0 0.0)
arc 23 22 (-Rd3 0.0 psB)
arc 20 16 (0.0 -Rd3 0.0)
arc 22 18 (0.0 -Rd3 psB)
arc 17 21 (0.0 Rd3 0.0)
arc 19 23 (0.0 Rd3 psB)
arc 24 25 (qRt 0.0 0.0)
arc 26 27 (qRt 0.0 psB)
arc 28 29 (-qRt 0.0 0.0)
arc 30 31 (-qRt 0.0 psB)
arc 28 24 (0.0 -qRt 0.0)
arc 30 26 (0.0 -qRt psB)
arc 25 29 (0.0 qRt 0.0)
arc 27 31 (0.0 qRt psB)
arc 32 33 (Rt 0.0 0.0)
arc 34 35 (Rt 0.0 psB)
arc 37 36 (-Rt 0.0 0.0)
arc 39 38 (-Rt 0.0 psB)
arc 36 32 (0.0 -Rt 0.0)
arc 38 34 (0.0 -Rt psB)
arc 33 37 (0.0 Rt 0.0)
arc 35 39 (0.0 Rt psB)
arc 48 49 (Rd3 0.0 Hl2)
arc 40 41 (qRt 0.0 Hl2)
arc 51 50 (-Rd3 0.0 Hl2)
arc 43 42 (-qRt 0.0 Hl2)
arc 42 40 (0.0 -qRt Hl2)
arc 50 48 (0.0 -Rd3 Hl2)
arc 41 43 (0.0 qRt Hl2)
arc 49 51 (0.0 Rd3 Hl2)
arc 56 57 (Rd 0.0 Hl2)
arc 58 59 (-Rd 0.0 Hl2)
arc 58 56 (0.0 -Rd Hl2)
arc 57 59 (0.0 Rd Hl2)
arc 44 45 (Rt 0.0 Hl2)
arc 46 47 (-Rt 0.0 Hl2)
arc 46 44 (0.0 -Rt Hl2)
arc 45 47 (0.0 Rt Hl2)
arc 64 65 (Rd 0.0 Hl3)
arc 67 66 (-Rd 0.0 Hl3)
arc 64 66 (0.0 -Rd Hl3)
arc 65 67 (0.0 Rd Hl3)
arc 72 73 (Rd3 0.0 Hl3)
arc 68 69 (qRt 0.0 Hl3)
arc 70 71 (-qRt 0.0 Hl3)
arc 74 75 (-Rd3 0.0 Hl3)
arc 72 74 (0.0 -Rd3 Hl3)
arc 68 70 (0.0 -qRt Hl3)
arc 73 75 (0.0 Rd3 Hl3)
arc 69 71 (0.0 qRt Hl3)
arc 68 69 (qRt 0.0 Hl3)
arc 76 77 (Rt 0.0 Hl3)
arc 78 79 (-Rt 0.0 Hl3)
arc 76 78 (0.0 -Rt Hl3)
arc 77 79 (0.0 Rt Hl3)
arc 84 85 (Rd 0.0 Ht)
arc 86 87 (-Rd 0.0 Ht)
arc 84 86 (0.0 -Rd Ht)
arc 85 87 (0.0 Rd Ht)
arc 92 93 (Rd3 0.0 Ht)
arc 94 95 (-Rd3 0.0 Ht)
arc 94 92 (0.0 -Rd3 Ht)
arc 93 95 (0.0 Rd3 Ht)
arc 88 89 (qRt 0.0 Ht)
arc 90 91 (-qRt 0.0 Ht)
arc 88 90 (0.0 -qRt Ht)
arc 89 91 (0.0 qRt Ht)
arc 96 97 (Rt 0.0 Ht)
arc 98 99 (-Rt 0.0 Ht)
arc 98 96 (0.0 -Rt Ht)
arc 97 99 (0.0 Rt Ht)
);
defaultPatch
{
name walls;
type wall;
}
boundary
(
base
{
type wall;
faces
(
(0 1 2 3)
(1 8 9 2)
(2 9 13 3)
(3 13 12 0)
(0 12 8 1)
);
}
outlet
{
type patch;
faces
(
(80 81 82 83)
(81 84 85 82)
(83 87 86 80)
(80 86 84 81)
(82 85 87 83)
(84 92 93 85)
(87 95 94 86)
(86 94 92 84)
(85 93 95 87)
(92 88 89 93)
(95 91 90 94)
(94 90 88 92)
(93 89 91 95)
(88 96 97 89)
(91 99 98 90)
(90 98 96 88)
(89 97 99 91)
);
}
);

View File

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

View File

@ -0,0 +1,43 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: plus |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object topoSetDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
actions
(
{
name inlet;
type faceSet;
action new;
source boxToFace;
sourceInfo
{
box (-0.01 -0.01 -0.03)(0.01 0.01 0.001);
}
}
{
name inletZone;
type faceZoneSet;
action new;
source setToFaceZone;
sourceInfo
{
faceSet inlet;
}
}
);
// ************************************************************************* //