research/OpenFOAM-2.4.x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'master' of github.com:OpenFOAM/OpenFOAM-2.3.x

Browse source
This commit is contained in:
sergio 2014-03-04 09:38:14 +00:00
commit 3a74e7de52
167 changed files with 2025 additions and 803 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
applications/solvers/heatTransfer/buoyantPimpleFoam/pEqn.H
View file

@ -17,7 +17,7 @@
(
"phiHbyA",
(
(fvc::interpolate(rho*U) & mesh.Sf())
(fvc::interpolate(rho*HbyA) & mesh.Sf())
+ rAUf*fvc::ddtCorr(rho, U, phi)
)
+ phig

6
applications/solvers/multiphase/cavitatingFoam/CourantNo.H
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -37,7 +37,7 @@ if (mesh.nInternalFaces())
{
scalarField sumPhi
(
fvc::surfaceSum(mag(phiv))().internalField()
fvc::surfaceSum(mag(phi))().internalField()
);
CoNum = 0.5*gMax(sumPhi/mesh.V().field())*runTime.deltaTValue();
@ -54,7 +54,7 @@ if (mesh.nInternalFaces())
)*runTime.deltaTValue();
}
Info<< "phiv Courant Number mean: " << meanCoNum
Info<< "phi Courant Number mean: " << meanCoNum
<< " max: " << CoNum
<< " acoustic max: " << acousticCoNum
<< endl;

2
applications/solvers/multiphase/cavitatingFoam/UEqn.H
View file

@ -1,7 +1,7 @@
fvVectorMatrix UEqn
(
fvm::ddt(rho, U)
+ fvm::div(phi, U)
+ fvm::div(rhoPhi, U)
+ turbulence->divDevRhoReff(rho, U)
);

8
applications/solvers/multiphase/cavitatingFoam/cavitatingDyMFoam/cavitatingDyMFoam.C
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2012-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -56,7 +56,7 @@ int main(int argc, char *argv[])
#include "createFields.H"
#include "createUf.H"
#include "createPcorrTypes.H"
#include "compressibleCourantNo.H"
#include "CourantNo.H"
#include "setInitialDeltaT.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -86,12 +86,12 @@ int main(int argc, char *argv[])
if (correctPhi)
{
// Calculate absolute flux from the mapped surface velocity
phiv = mesh.Sf() & Uf;
phi = mesh.Sf() & Uf;
#include "correctPhi.H"
// Make the flux relative to the mesh motion
fvc::makeRelative(phiv, U);
fvc::makeRelative(phi, U);
}
}

8
applications/solvers/multiphase/cavitatingFoam/cavitatingDyMFoam/correctPhi.H
View file

@ -14,7 +14,7 @@ if (mesh.changing())
{
U.boundaryField()[patchI].evaluate();
phiv.boundaryField()[patchI] =
phi.boundaryField()[patchI] =
U.boundaryField()[patchI]
& mesh.Sf().boundaryField()[patchI];
}
@ -37,21 +37,21 @@ if (mesh.changing())
pcorrTypes
);
surfaceScalarField rhof(fvc::interpolate(rho, "div(phiv,rho)"));
surfaceScalarField rhof(fvc::interpolate(rho, "div(phi,rho)"));
dimensionedScalar rAUf("rAUf", dimTime, 1.0);
while (pimple.correctNonOrthogonal())
{
fvScalarMatrix pcorrEqn
(
fvm::laplacian(rAUf, pcorr) == fvc::ddt(rho) + fvc::div(phiv*rhof)
fvm::laplacian(rAUf, pcorr) == fvc::ddt(rho) + fvc::div(phi*rhof)
);
pcorrEqn.solve();
if (pimple.finalNonOrthogonalIter())
{
phiv -= pcorrEqn.flux()/rhof;
phi -= pcorrEqn.flux()/rhof;
}
}
}

12
applications/solvers/multiphase/cavitatingFoam/cavitatingDyMFoam/pEqn.H
View file

@ -17,13 +17,13 @@
volVectorField HbyA("HbyA", U);
HbyA = rAU*UEqn.H();
phiv = (fvc::interpolate(HbyA) & mesh.Sf())
phi = (fvc::interpolate(HbyA) & mesh.Sf())
+ rhorAUf*fvc::ddtCorr(U, Uf);
fvc::makeRelative(phiv, U);
fvc::makeRelative(phi, U);
surfaceScalarField phiGradp(rhorAUf*mesh.magSf()*fvc::snGrad(p));
phiv -= phiGradp/rhof;
phi -= phiGradp/rhof;
volScalarField rho0(rho - psi*p);
@ -33,7 +33,7 @@
(
fvc::ddt(rho)
+ psi*correction(fvm::ddt(p))
+ fvc::div(phiv, rho)
+ fvc::div(phi, rho)
+ fvc::div(phiGradp)
- fvm::laplacian(rhorAUf, p)
);
@ -42,7 +42,7 @@
if (pimple.finalNonOrthogonalIter())
{
phiv += (phiGradp + pEqn.flux())/rhof;
phi += (phiGradp + pEqn.flux())/rhof;
}
}
@ -85,6 +85,6 @@
{
Uf = fvc::interpolate(U);
surfaceVectorField n(mesh.Sf()/mesh.magSf());
Uf += n*(phiv/mesh.magSf() - (n & Uf));
Uf += n*(phi/mesh.magSf() - (n & Uf));
}
}

4
applications/solvers/multiphase/cavitatingFoam/cavitatingFoam.C
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -50,7 +50,7 @@ int main(int argc, char *argv[])
#include "readControls.H"
#include "createFields.H"
#include "initContinuityErrs.H"
#include "compressibleCourantNo.H"
#include "CourantNo.H"
#include "setInitialDeltaT.H"
pimpleControl pimple(mesh);

21
applications/solvers/multiphase/cavitatingFoam/createFields.H
View file

@ -39,12 +39,25 @@
mesh
);
#include "createPhiv.H"
#include "compressibleCreatePhi.H"
#include "createPhi.H"
// Mass flux (corrected by rhoEqn.H)
surfaceScalarField rhoPhi
(
IOobject
(
"rhoPhi",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
fvc::interpolate(rho)*phi
);
Info<< "Reading transportProperties\n" << endl;
incompressibleTwoPhaseMixture twoPhaseProperties(U, phiv);
incompressibleTwoPhaseMixture twoPhaseProperties(U, phi);
volScalarField& alphav(twoPhaseProperties.alpha1());
alphav.oldTime();
@ -72,5 +85,5 @@
// Create incompressible turbulence model
autoPtr<incompressible::turbulenceModel> turbulence
(
incompressible::turbulenceModel::New(U, phiv, twoPhaseProperties)
incompressible::turbulenceModel::New(U, phi, twoPhaseProperties)
);

10
applications/solvers/multiphase/cavitatingFoam/pEqn.H
View file

@ -17,12 +17,12 @@
volVectorField HbyA("HbyA", U);
HbyA = rAU*UEqn.H();
phiv = (fvc::interpolate(HbyA) & mesh.Sf())
+ rhorAUf*fvc::ddtCorr(U, phiv);
phi = (fvc::interpolate(HbyA) & mesh.Sf())
+ rhorAUf*fvc::ddtCorr(U, phi);
surfaceScalarField phiGradp(rhorAUf*mesh.magSf()*fvc::snGrad(p));
phiv -= phiGradp/rhof;
phi -= phiGradp/rhof;
while (pimple.correctNonOrthogonal())
{
@ -30,7 +30,7 @@
(
fvm::ddt(psi, p)
- (rhol0 + (psil - psiv)*pSat)*fvc::ddt(alphav) - pSat*fvc::ddt(psi)
+ fvc::div(phiv, rho)
+ fvc::div(phi, rho)
+ fvc::div(phiGradp)
- fvm::laplacian(rhorAUf, p)
);
@ -39,7 +39,7 @@
if (pimple.finalNonOrthogonalIter())
{
phiv += (phiGradp + pEqn.flux())/rhof;
phi += (phiGradp + pEqn.flux())/rhof;
}
}

4
applications/solvers/multiphase/cavitatingFoam/rhoEqn.H
View file

@ -2,12 +2,12 @@
fvScalarMatrix rhoEqn
(
fvm::ddt(rho)
+ fvm::div(phiv, rho)
+ fvm::div(phi, rho)
);
rhoEqn.solve();
phi = rhoEqn.flux();
rhoPhi = rhoEqn.flux();
Info<< "max-min rho: " << max(rho).value()
<< " " << min(rho).value() << endl;

9
applications/solvers/multiphase/driftFluxFoam/Allwclean Executable file
View file

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

9
applications/solvers/multiphase/driftFluxFoam/Allwmake Executable file
View file

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

12
applications/solvers/multiphase/driftFluxFoam/Make/options
View file

@ -2,10 +2,18 @@ EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude \
-I$(LIB_SRC)/fvOptions/lnInclude
-I$(LIB_SRC)/fvOptions/lnInclude \
-I$(LIB_SRC)/transportModels \
-I$(LIB_SRC)/transportModels/twoPhaseMixture/lnInclude \
-I$(LIB_SRC)/transportModels/incompressible/lnInclude \
-I$(LIB_SRC)/transportModels/interfaceProperties/lnInclude \
-I./relativeVelocityModels/lnInclude
EXE_LIBS = \
-lfiniteVolume \
-lmeshTools \
-lsampling \
-lfvOptions
-lfvOptions \
-lincompressibleTransportModels \
-ldriftFluxTransportModels \
-ldriftFluxRelativeVelocityModels

6
applications/solvers/multiphase/driftFluxFoam/UEqn.H
View file

@ -4,11 +4,7 @@
(
fvm::ddt(rho, U)
+ fvm::div(rhoPhi, U)
+ fvc::div
(
(alpha/(scalar(1.001) - alpha))*((rhoc*rhod)/rho)*Vdj*Vdj,
"div(phiVdj,Vdj)"
)
+ fvc::div(uRelModel.tau(), "div(phiUkm,Ukm)")
- fvm::laplacian(muEff, U)
- fvc::div(muEff*dev2(T(fvc::grad(U))))
==

4
applications/solvers/multiphase/driftFluxFoam/alphaControls.H
View file

@ -1,4 +0,0 @@
const dictionary& alphaControls = mesh.solverDict(alpha.name());
label nAlphaCorr(readLabel(alphaControls.lookup("nAlphaCorr")));
label nAlphaSubCycles(readLabel(alphaControls.lookup("nAlphaSubCycles")));

102
applications/solvers/multiphase/driftFluxFoam/alphaEqn.H
View file

@ -2,30 +2,118 @@
word alphaScheme("div(phi,alpha)");
word alpharScheme("div(phirb,alpha)");
if (MULESCorr)
{
fvScalarMatrix alpha1Eqn
(
#ifdef LTSSOLVE
fv::localEulerDdtScheme<scalar>(mesh, rDeltaT.name()).fvmDdt(alpha1)
#else
fv::EulerDdtScheme<scalar>(mesh).fvmDdt(alpha1)
#endif
+ fv::gaussConvectionScheme<scalar>
(
mesh,
phi,
upwind<scalar>(mesh, phi)
).fvmDiv(phi, alpha1)
- fv::gaussLaplacianScheme<scalar, scalar>
(
mesh,
linear<scalar>(mesh),
fv::uncorrectedSnGrad<scalar>(mesh)
).fvmLaplacian(fvc::interpolate(mut/rho), 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());
phiAlpha = tphiAlphaUD();
if (alphaApplyPrevCorr && tphiAlphaCorr0.valid())
{
Info<< "Applying the previous iteration correction flux" << endl;
#ifdef LTSSOLVE
MULES::LTScorrect(alpha1, phiAlpha, tphiAlphaCorr0(), 1, 0);
#else
MULES::correct(alpha1, phiAlpha, tphiAlphaCorr0(), 1, 0);
#endif
phiAlpha += tphiAlphaCorr0();
}
// Cache the upwind-flux
tphiAlphaCorr0 = tphiAlphaUD;
}
for (int aCorr=0; aCorr<nAlphaCorr; aCorr++)
{
phiAlpha =
tmp<surfaceScalarField> tphiAlphaUn
(
fvc::flux
(
phi,
alpha,
alpha1,
alphaScheme
)
+ fvc::flux
(
phir,
alpha,
alpha1,
alpharScheme
)
);
MULES::explicitSolve(alpha, phi, phiAlpha, 1, 0);
if (MULESCorr)
{
tmp<surfaceScalarField> tphiAlphaCorr(tphiAlphaUn() - phiAlpha);
volScalarField alpha10(alpha1);
#ifdef LTSSOLVE
MULES::LTScorrect(alpha1, tphiAlphaUn(), tphiAlphaCorr(), 1, 0);
#else
MULES::correct(alpha1, tphiAlphaUn(), tphiAlphaCorr(), 1, 0);
#endif
// Under-relax the correction for all but the 1st corrector
if (aCorr == 0)
{
phiAlpha += tphiAlphaCorr();
}
else
{
alpha1 = 0.5*alpha1 + 0.5*alpha10;
phiAlpha += 0.5*tphiAlphaCorr();
}
}
else
{
phiAlpha = tphiAlphaUn;
#ifdef LTSSOLVE
MULES::explicitLTSSolve(alpha1, phi, phiAlpha, 1, 0);
#else
MULES::explicitSolve(alpha1, phi, phiAlpha, 1, 0);
#endif
}
}
if (alphaApplyPrevCorr && MULESCorr)
{
tphiAlphaCorr0 = phiAlpha - tphiAlphaCorr0;
}
alpha2 = 1.0 - alpha1;
Info<< "Phase-1 volume fraction = "
<< alpha.weightedAverage(mesh.Vsc()).value()
<< " Min(alpha) = " << min(alpha).value()
<< " Max(alpha) = " << max(alpha).value()
<< alpha1.weightedAverage(mesh.Vsc()).value()
<< " Min(alpha1) = " << min(alpha1).value()
<< " Max(alpha1) = " << max(alpha1).value()
<< endl;
}

32
applications/solvers/multiphase/driftFluxFoam/alphaEqnSubCycle.H
View file

@ -13,7 +13,7 @@
surfaceScalarField phir
(
rhoc*(mesh.Sf() & fvc::interpolate(Vdj/rho))
mesh.Sf() & fvc::interpolate(uRelModel.Udm())
);
if (nAlphaSubCycles > 1)
@ -33,7 +33,7 @@
for
(
subCycle<volScalarField> alphaSubCycle(alpha, nAlphaSubCycles);
subCycle<volScalarField> alphaSubCycle(alpha1, nAlphaSubCycles);
!(++alphaSubCycle).end();
)
{
@ -50,24 +50,26 @@
// Apply the diffusion term separately to allow implicit solution
// and boundedness of the explicit advection
if (!MULESCorr)
{
fvScalarMatrix alphaEqn
fvScalarMatrix alpha1Eqn
(
fvm::ddt(alpha) - fvc::ddt(alpha)
- fvm::laplacian(mut/rho, alpha)
fvm::ddt(alpha1) - fvc::ddt(alpha1)
- fvm::laplacian(mut/rho, alpha1)
);
alphaEqn.solve();
alpha1Eqn.solve(mesh.solver("alpha1Diffusion"));
phiAlpha += alphaEqn.flux();
phiAlpha += alpha1Eqn.flux();
alpha2 = 1.0 - alpha1;
Info<< "Phase-1 volume fraction = "
<< alpha1.weightedAverage(mesh.Vsc()).value()
<< " Min(alpha1) = " << min(alpha1).value()
<< " Max(alpha1) = " << max(alpha1).value()
<< endl;
}
Info<< "Phase-1 volume fraction = "
<< alpha.weightedAverage(mesh.Vsc()).value()
<< " Min(alpha) = " << min(alpha).value()
<< " Max(alpha) = " << max(alpha).value()
<< endl;
rhoPhi = phiAlpha*(rhod - rhoc) + phi*rhoc;
rho == alpha*rhod + (scalar(1) - alpha)*rhoc;
rhoPhi = phiAlpha*(rho1 - rho2) + phi*rho2;
rho == alpha1*rho1 + alpha2*rho2;
}

20
applications/solvers/multiphase/driftFluxFoam/calcVdj.H
View file

@ -1,20 +0,0 @@
if (VdjModel == "general")
{
Vdj = V0*
(
exp(-a*max(alpha - alphaMin, scalar(0)))
- exp(-a1*max(alpha - alphaMin, scalar(0)))
);
}
else if (VdjModel == "simple")
{
Vdj = V0*pow(10.0, -a*max(alpha, scalar(0)));
}
else
{
FatalErrorIn(args.executable())
<< "Unknown VdjModel : " << VdjModel
<< abort(FatalError);
}
Vdj.correctBoundaryConditions();

39
applications/solvers/multiphase/driftFluxFoam/correctViscosity.H
View file

@ -1,39 +0,0 @@
{
mul = muc +
plasticViscosity
(
plasticViscosityCoeff,
plasticViscosityExponent,
alpha
);
if (BinghamPlastic)
{
volScalarField tauy = yieldStress
(
yieldStressCoeff,
yieldStressExponent,
yieldStressOffset,
alpha
);
mul =
tauy/
(
mag(fvc::grad(U))
+ 1.0e-4*
(
tauy
+ dimensionedScalar
(
"deltaTauy",
tauy.dimensions(),
1.0e-15
)
)/mul
)
+ mul;
}
mul = min(mul, muMax);
}

136
applications/solvers/multiphase/driftFluxFoam/createFields.H
View file

@ -12,20 +12,6 @@
mesh
);
Info<< "Reading field alpha\n" << endl;
volScalarField alpha
(
IOobject
(
"alpha",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
@ -43,7 +29,17 @@
#include "createPhi.H"
// Transport
// ~~~~~~~~~
Info<< "Reading transportProperties\n" << endl;
incompressibleTwoPhaseMixture twoPhaseProperties(U, phi);
volScalarField& alpha1(twoPhaseProperties.alpha1());
volScalarField& alpha2(twoPhaseProperties.alpha2());
const dimensionedScalar& rho1 = twoPhaseProperties.rho1();
const dimensionedScalar& rho2 = twoPhaseProperties.rho2();
IOdictionary transportProperties
(
@ -57,41 +53,7 @@
)
);
dimensionedScalar rhoc(transportProperties.lookup("rhoc"));
dimensionedScalar rhod(transportProperties.lookup("rhod"));
dimensionedScalar muc(transportProperties.lookup("muc"));
dimensionedScalar muMax(transportProperties.lookup("muMax"));
dimensionedScalar plasticViscosityCoeff
(
transportProperties.lookup("plasticViscosityCoeff")
);
dimensionedScalar plasticViscosityExponent
(
transportProperties.lookup("plasticViscosityExponent")
);
dimensionedScalar yieldStressCoeff
(
transportProperties.lookup("yieldStressCoeff")
);
dimensionedScalar yieldStressExponent
(
transportProperties.lookup("yieldStressExponent")
);
dimensionedScalar yieldStressOffset
(
transportProperties.lookup("yieldStressOffset")
);
Switch BinghamPlastic(transportProperties.lookup("BinghamPlastic"));
// Mixture density
volScalarField rho
(
IOobject
@ -102,7 +64,7 @@
IOobject::NO_READ,
IOobject::NO_WRITE
),
alpha*rhod + (scalar(1) - alpha)*rhoc
alpha1*rho1 + alpha2*rho2
);
rho.oldTime();
@ -120,63 +82,24 @@
fvc::interpolate(rho)*phi
);
Info<< "Calculating field mul\n" << endl;
volScalarField mul
// Relative Velocity
// ~~~~~~~~~~~~~~~~~
autoPtr<relativeVelocityModel> uRelModelPtr
(
IOobject
relativeVelocityModel::New
(
"mul",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
muc
+ plasticViscosity
(
plasticViscosityCoeff,
plasticViscosityExponent,
alpha
transportProperties,
twoPhaseProperties
)
);
Info<< "Initialising field Vdj\n" << endl;
volVectorField Vdj
(
IOobject
(
"Vdj",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh,
dimensionedVector("0.0", U.dimensions(), vector::zero),
U.boundaryField().types()
);
relativeVelocityModel& uRelModel(uRelModelPtr());
Info<< "Selecting Drift-Flux model " << endl;
const word VdjModel(transportProperties.lookup("VdjModel"));
Info<< tab << VdjModel << " selected\n" << endl;
const dictionary& VdjModelCoeffs
(
transportProperties.subDict(VdjModel + "Coeffs")
);
dimensionedVector V0(VdjModelCoeffs.lookup("V0"));
dimensionedScalar a(VdjModelCoeffs.lookup("a"));
dimensionedScalar a1(VdjModelCoeffs.lookup("a1"));
dimensionedScalar alphaMin(VdjModelCoeffs.lookup("alphaMin"));
// Turbulence
// ~~~~~~~~~~
IOdictionary RASProperties
(
@ -283,7 +206,6 @@
<< "wallFunctionCoeffs" << wallFunctionDict << endl;
}
nearWallDist y(mesh);
Info<< "Reading field k\n" << endl;
@ -328,7 +250,6 @@
Cmu*rho*sqr(k)/epsilon
);
Info<< "Calculating field muEff\n" << endl;
volScalarField muEff
(
@ -340,10 +261,13 @@
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mut + mul
mut + twoPhaseProperties.mu()
);
// Pressure
// ~~~~~~~~
Info<< "Calculating field (g.h)f\n" << endl;
volScalarField gh("gh", g & mesh.C());
surfaceScalarField ghf("gh", g & mesh.Cf());
@ -382,3 +306,9 @@
);
p_rgh = p - rho*gh;
}
// MULES Correction
// ~~~~~~~~~~~~~~~~
tmp<surfaceScalarField> tphiAlphaCorr0;

12
applications/solvers/multiphase/driftFluxFoam/driftFluxFoam.C
View file

@ -36,15 +36,17 @@ Description
#include "fvCFD.H"
#include "CMULES.H"
#include "subCycle.H"
#include "incompressibleTwoPhaseMixture.H"
#include "relativeVelocityModel.H"
#include "nearWallDist.H"
#include "wallFvPatch.H"
#include "bound.H"
#include "Switch.H"
#include "plasticViscosity.H"
#include "yieldStress.H"
#include "pimpleControl.H"
#include "fvIOoptionList.H"
#include "fixedFluxPressureFvPatchScalarField.H"
#include "gaussLaplacianScheme.H"
#include "uncorrectedSnGrad.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -80,9 +82,11 @@ int main(int argc, char *argv[])
{
#include "alphaControls.H"
#include "calcVdj.H"
uRelModel.update();
#include "alphaEqnSubCycle.H"
#include "correctViscosity.H"
twoPhaseProperties.correct();
#include "UEqn.H"

4
applications/solvers/multiphase/driftFluxFoam/kEpsilon.H
View file

@ -21,6 +21,8 @@ if (turbulence)
Cmu*k/sigmak*(g & fvc::grad(rho))/(epsilon + epsilonMin)
);
volScalarField muc(twoPhaseProperties.nuModel2().nu()*rho2);
#include "wallFunctions.H"
// Dissipation equation
@ -75,4 +77,4 @@ if (turbulence)
#include "wallViscosity.H"
}
muEff = mut + mul;
muEff = mut + twoPhaseProperties.mu();

21
applications/solvers/multiphase/driftFluxFoam/plasticViscosity.H
View file

@ -1,21 +0,0 @@
volScalarField plasticViscosity
(
const dimensionedScalar& plasticViscosityCoeff,
const dimensionedScalar& plasticViscosityExponent,
const volScalarField& Alpha
)
{
tmp<volScalarField> tfld
(
plasticViscosityCoeff*
(
pow
(
10.0,
plasticViscosityExponent*Alpha + SMALL
) - scalar(1)
)
);
return tfld();
}

5
applications/solvers/multiphase/driftFluxFoam/relativeVelocityModels/Make/files Normal file
View file

@ -0,0 +1,5 @@
relativeVelocityModel/relativeVelocityModel.C
simple/simple.C
general/general.C
LIB = $(FOAM_LIBBIN)/libdriftFluxRelativeVelocityModels

10
applications/solvers/multiphase/driftFluxFoam/relativeVelocityModels/Make/options Normal file
View file

@ -0,0 +1,10 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/transportModels \
-I$(LIB_SRC)/transportModels/twoPhaseMixture/lnInclude \
-I$(LIB_SRC)/transportModels/incompressible/lnInclude \
-I$(LIB_SRC)/transportModels/interfaceProperties/lnInclude
LIB_LIBS = \
-lfiniteVolume \
-lincompressibleTransportModels

55
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/noDrag/noDrag.C → applications/solvers/multiphase/driftFluxFoam/relativeVelocityModels/general/general.C
View file

@ -23,68 +23,55 @@ License
\*---------------------------------------------------------------------------*/
#include "noDrag.H"
#include "phasePair.H"
#include "general.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace dragModels
namespace relativeVelocityModels
{
defineTypeNameAndDebug(noDrag, 0);
addToRunTimeSelectionTable(dragModel, noDrag, dictionary);
defineTypeNameAndDebug(general, 0);
addToRunTimeSelectionTable(relativeVelocityModel, general, dictionary);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::dragModels::noDrag::noDrag
Foam::relativeVelocityModels::general::general
(
const dictionary& dict,
const phasePair& pair,
const bool registerObject
const incompressibleTwoPhaseMixture& mixture
)
:
dragModel(pair, registerObject)
relativeVelocityModel(dict, mixture),
a_(dict.lookup("a")),
a1_(dict.lookup("a1")),
V0_(dict.lookup("V0")),
residualAlpha_(dict.lookup("residualAlpha"))
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::dragModels::noDrag::~noDrag()
Foam::relativeVelocityModels::general::~general()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField> Foam::dragModels::noDrag::CdRe() const
Foam::tmp<Foam::volVectorField>
Foam::relativeVelocityModels::general::Ur() const
{
const fvMesh& mesh(this->pair_.phase1().mesh());
return
tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"Cd",
mesh.time().timeName(),
mesh
),
mesh,
dimensionedScalar("Cd", dimless, 0)
)
);
}
Foam::tmp<Foam::volScalarField> Foam::dragModels::noDrag::K() const
{
return CdRe()*dimensionedScalar("zero", dimensionSet(1, -3, -1, 0, 0), 0);
V0_
*(
exp(-a_*max(alphaD_ - residualAlpha_, scalar(0)))
- exp(-a1_*max(alphaD_ - residualAlpha_, scalar(0)))
)
/max(alphaC_, residualAlpha_);
}

53
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/heatTransferModels/noHeatTransfer/noHeatTransfer.H → applications/solvers/multiphase/driftFluxFoam/relativeVelocityModels/general/general.H
View file

@ -22,68 +22,81 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::heatTransferModels::noHeatTransfer
Foam::general
Description
General relative velocity model
SourceFiles
noHeatTransfer.C
general.C
\*---------------------------------------------------------------------------*/
#ifndef noHeatTransfer_H
#define noHeatTransfer_H
#ifndef general_H
#define general_H
#include "heatTransferModel.H"
#include "relativeVelocityModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class phasePair;
namespace heatTransferModels
namespace relativeVelocityModels
{
/*---------------------------------------------------------------------------*\
Class noHeatTransfer Declaration
Class general Declaration
\*---------------------------------------------------------------------------*/
class noHeatTransfer
class general
:
public heatTransferModel
public relativeVelocityModel
{
// Private data
//- a coefficient
dimensionedScalar a_;
//- a1 coefficient
dimensionedScalar a1_;
//- Drift velocity
dimensionedVector V0_;
//- Residual phase fraction
dimensionedScalar residualAlpha_;
public:
//- Runtime type information
TypeName("none");
TypeName("general");
// Constructors
//- Construct from a dictionary and a phase pair
noHeatTransfer
//- Construct from components
general
(
const dictionary& dict,
const phasePair& pair
const incompressibleTwoPhaseMixture& mixture
);
//- Destructor
virtual ~noHeatTransfer();
~general();
// Member Functions
//- The heat transfer function K used in the enthalpy equation
tmp<volScalarField> K() const;
//- Relative velocity
virtual tmp<volVectorField> Ur() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace heatTransferModels
} // End namespace relativeVelocityModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

175
applications/solvers/multiphase/driftFluxFoam/relativeVelocityModels/relativeVelocityModel/relativeVelocityModel.C Normal file
View file

@ -0,0 +1,175 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "relativeVelocityModel.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(relativeVelocityModel, 0);
defineRunTimeSelectionTable(relativeVelocityModel, dictionary);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::relativeVelocityModel::relativeVelocityModel
(
const dictionary& dict,
const incompressibleTwoPhaseMixture& mixture
)
:
mixture_(mixture),
continuousPhaseName_(dict.lookup("continuousPhase")),
alphaC_
(
mixture.phase1Name() == continuousPhaseName_
? mixture.alpha1()
: mixture.alpha2()
),
alphaD_
(
mixture.phase1Name() == continuousPhaseName_
? mixture.alpha2()
: mixture.alpha1()
),
rhoC_
(
mixture.phase1Name() == continuousPhaseName_
? mixture.rho1()
: mixture.rho2()
),
rhoD_
(
mixture.phase1Name() == continuousPhaseName_
? mixture.rho2()
: mixture.rho1()
),
Udm_
(
IOobject
(
"Udm",
alphaC_.time().timeName(),
alphaC_.mesh()
),
alphaC_.mesh(),
dimensionedVector("Udm", dimVelocity, vector::zero),
mixture.U().boundaryField().types()
),
tau_
(
IOobject
(
"Udm",
alphaC_.time().timeName(),
alphaC_.mesh()
),
alphaC_.mesh(),
dimensionedSymmTensor
(
"Udm",
sqr(dimVelocity)*dimDensity,
symmTensor::zero
)
)
{}
// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::relativeVelocityModel> Foam::relativeVelocityModel::New
(
const dictionary& dict,
const incompressibleTwoPhaseMixture& mixture
)
{
word modelType(dict.lookup(typeName));
Info<< "Selecting relative velocity model " << modelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(modelType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn
(
"relativeVelocityModel::New"
"("
"const dictionary&"
")"
) << "Unknown time scale model type " << modelType
<< ", constructor not in hash table" << nl << nl
<< " Valid time scale model types are:" << nl
<< dictionaryConstructorTablePtr_->sortedToc()
<< abort(FatalError);
}
return
autoPtr<relativeVelocityModel>
(
cstrIter()
(
dict.subDict(modelType + "Coeffs"),
mixture
)
);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::relativeVelocityModel::~relativeVelocityModel()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
void Foam::relativeVelocityModel::update()
{
tmp<volVectorField> URel(Ur());
tmp<volScalarField> betaC(alphaC_*rhoC_);
tmp<volScalarField> betaD(alphaD_*rhoD_);
tmp<volScalarField> rhoM(betaC() + betaD());
tmp<volVectorField> Udm = URel()*betaC()/rhoM;
tmp<volVectorField> Ucm = Udm() - URel;
Udm_ = Udm();
tau_ = betaD*sqr(Udm) + betaC*sqr(Ucm);
}
// ************************************************************************* //

158
applications/solvers/multiphase/driftFluxFoam/relativeVelocityModels/relativeVelocityModel/relativeVelocityModel.H Normal file
View file

@ -0,0 +1,158 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::relativeVelocityModel
Description
SourceFiles
relativeVelocityModel.C
\*---------------------------------------------------------------------------*/
#ifndef relativeVelocityModel_H
#define relativeVelocityModel_H
#include "fvCFD.H"
#include "dictionary.H"
#include "incompressibleTwoPhaseMixture.H"
#include "runTimeSelectionTables.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class relativeVelocityModel Declaration
\*---------------------------------------------------------------------------*/
class relativeVelocityModel
{
// Private Member Functions
//- Disallow default bitwise copy construct
relativeVelocityModel(const relativeVelocityModel&);
//- Disallow default bitwise assignment
void operator=(const relativeVelocityModel&);
protected:
// Protected data
//- Mixture properties
const incompressibleTwoPhaseMixture& mixture_;
//- Name of the continuous phase
const word continuousPhaseName_;
//- Continuous phase fraction
const volScalarField& alphaC_;
//- Dispersed phase fraction
const volScalarField& alphaD_;
//- Continuous density
const dimensionedScalar& rhoC_;
//- Dispersed density
const dimensionedScalar& rhoD_;
//- Dispersed diffusion velocity
volVectorField Udm_;
//- Stress
volSymmTensorField tau_;
public:
//- Runtime type information
TypeName("relativeVelocityModel");
//- Declare runtime constructor selection table
declareRunTimeSelectionTable
(
autoPtr,
relativeVelocityModel,
dictionary,
(const dictionary& dict, const incompressibleTwoPhaseMixture& mixture),
(dict, mixture)
);
// Constructors
//- Construct from components
relativeVelocityModel
(
const dictionary& dict,
const incompressibleTwoPhaseMixture& mixture
);
// Selector
static autoPtr<relativeVelocityModel> New
(
const dictionary& dict,
const incompressibleTwoPhaseMixture& mixture
);
//- Destructor
virtual ~relativeVelocityModel();
// Member Functions
//- Calculate the relative velocity of the dispersed phase
virtual tmp<volVectorField> Ur() const = 0;
//- Return the diffusion velocity of the dispersed phase
const volVectorField& Udm() const
{
return Udm_;
}
//- Return the stress tensor due to the phase transport
const volSymmTensorField& tau() const
{
return tau_;
}
//- Update the stored diffusion velocity and stress
void update();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

47
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/heatTransferModels/noHeatTransfer/noHeatTransfer.C → applications/solvers/multiphase/driftFluxFoam/relativeVelocityModels/simple/simple.C
View file

@ -23,64 +23,51 @@ License
\*---------------------------------------------------------------------------*/
#include "noHeatTransfer.H"
#include "phasePair.H"
#include "simple.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace heatTransferModels
namespace relativeVelocityModels
{
defineTypeNameAndDebug(noHeatTransfer, 0);
addToRunTimeSelectionTable(heatTransferModel, noHeatTransfer, dictionary);
defineTypeNameAndDebug(simple, 0);
addToRunTimeSelectionTable(relativeVelocityModel, simple, dictionary);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::heatTransferModels::noHeatTransfer::noHeatTransfer
Foam::relativeVelocityModels::simple::simple
(
const dictionary& dict,
const phasePair& pair
const incompressibleTwoPhaseMixture& mixture
)
:
heatTransferModel(dict, pair)
relativeVelocityModel(dict, mixture),
a_(dict.lookup("a")),
V0_(dict.lookup("V0")),
residualAlpha_(dict.lookup("residualAlpha"))
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::heatTransferModels::noHeatTransfer::~noHeatTransfer()
Foam::relativeVelocityModels::simple::~simple()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::heatTransferModels::noHeatTransfer::K() const
Foam::tmp<Foam::volVectorField>
Foam::relativeVelocityModels::simple::Ur() const
{
const fvMesh& mesh(this->pair_.phase1().mesh());
return
tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"zero",
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
dimensionedScalar("zero", dimensionSet(1, -1, -3, -1, 0), 0)
)
);
V0_
*pow(scalar(10), -a_*max(alphaD_, scalar(0)))
/max(alphaC_, residualAlpha_);
}

54
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/noDrag/noDrag.H → applications/solvers/multiphase/driftFluxFoam/relativeVelocityModels/simple/simple.H
View file

@ -22,72 +22,78 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::dragModels::noDrag
Foam::simple
Description
Simple relative velocity model
SourceFiles
noDrag.C
simple.C
\*---------------------------------------------------------------------------*/
#ifndef noDrag_H
#define noDrag_H
#ifndef simple_H
#define simple_H
#include "dragModel.H"
#include "relativeVelocityModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class phasePair;
namespace dragModels
namespace relativeVelocityModels
{
/*---------------------------------------------------------------------------*\
Class noDrag Declaration
Class simple Declaration
\*---------------------------------------------------------------------------*/
class noDrag
class simple
:
public dragModel
public relativeVelocityModel
{
// Private data
//- a coefficient
dimensionedScalar a_;
//- Drift velocity
dimensionedVector V0_;
//- Residual phase fraction
dimensionedScalar residualAlpha_;
public:
//- Runtime type information
TypeName("none");
TypeName("simple");
// Constructors
//- Construct from a dictionary and a phase pair
noDrag
//- Construct from components
simple
(
const dictionary& dict,
const phasePair& pair,
const bool registerObject
const incompressibleTwoPhaseMixture& mixture
);
//- Destructor
virtual ~noDrag();
~simple();
// Member Functions
//- Drag coefficient
virtual tmp<volScalarField> CdRe() const;
//- The drag function used in the momentum equation
virtual tmp<volScalarField> K() const;
//- Relative velocity
virtual tmp<volVectorField> Ur() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace dragModels
} // End namespace relativeVelocityModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

131
applications/solvers/multiphase/driftFluxFoam/viscosityModels/BinghamPlastic/BinghamPlastic.C Normal file
View file

@ -0,0 +1,131 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "BinghamPlastic.H"
#include "addToRunTimeSelectionTable.H"
#include "surfaceFields.H"
#include "fvc.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace viscosityModels
{
defineTypeNameAndDebug(BinghamPlastic, 0);
addToRunTimeSelectionTable
(
viscosityModel,
BinghamPlastic,
dictionary
);
}
}
// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::viscosityModels::BinghamPlastic::correctionNu
(
const dimensionedScalar& rhoc,
const dimensionedScalar& rhop,
const volScalarField& nuc
) const
{
volScalarField
tauy
(
yieldStressCoeff_
*(
pow
(
scalar(10),
yieldStressExponent_
*(max(alpha_, scalar(0)) + yieldStressOffset_)
)
- pow
(
scalar(10),
yieldStressExponent_*yieldStressOffset_
)
)
);
volScalarField
nup
(
plastic::correctionNu(rhoc, rhop, nuc)
);
dimensionedScalar tauySmall("tauySmall", tauy.dimensions(), SMALL);
return
tauy
/(
mag(fvc::grad(U_))
+ 1.0e-4*(tauy + tauySmall)/(nup + (rhoc/rhop)*nuc)
)
+ nup;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::viscosityModels::BinghamPlastic::BinghamPlastic
(
const word& name,
const dictionary& viscosityProperties,
const volVectorField& U,
const surfaceScalarField& phi
)
:
plastic(name, viscosityProperties, U, phi, typeName),
yieldStressCoeff_(plasticCoeffs_.lookup("yieldStressCoeff")),
yieldStressExponent_(plasticCoeffs_.lookup("yieldStressExponent")),
yieldStressOffset_(plasticCoeffs_.lookup("yieldStressOffset")),
U_(U)
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
bool Foam::viscosityModels::BinghamPlastic::read
(
const dictionary& viscosityProperties
)
{
plastic::read(viscosityProperties);
plasticCoeffs_.lookup("yieldStressCoeff") >> yieldStressCoeff_;
plasticCoeffs_.lookup("yieldStressExponent") >> yieldStressExponent_;
plasticCoeffs_.lookup("yieldStressOffset") >> yieldStressOffset_;
return true;
}
// ************************************************************************* //

122
applications/solvers/multiphase/driftFluxFoam/viscosityModels/BinghamPlastic/BinghamPlastic.H Normal file
View file

@ -0,0 +1,122 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::viscosityModels::BinghamPlastic
Description
Viscosity correction model for Bingham plastics.
SourceFiles
BinghamPlastic.C
\*---------------------------------------------------------------------------*/
#ifndef BinghamPlastic_H
#define BinghamPlastic_H
#include "plastic.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace viscosityModels
{
/*---------------------------------------------------------------------------*\
Class BinghamPlastic Declaration
\*---------------------------------------------------------------------------*/
class BinghamPlastic
:
public plastic
{
protected:
// Protected data
//- Yield stress coefficient
dimensionedScalar yieldStressCoeff_;
//- Yield stress exponent
dimensionedScalar yieldStressExponent_;
//- Yield stress offset
dimensionedScalar yieldStressOffset_;
//- Velocity
const volVectorField& U_;
// Protected Member Functions
//- Calculate and return the laminar viscosity correction
virtual tmp<volScalarField> correctionNu
(
const dimensionedScalar& rhoc,
const dimensionedScalar& rhop,
const volScalarField& nuc
) const;
public:
//- Runtime type information
TypeName("BinghamPlastic");
// Constructors
//- Construct from components
BinghamPlastic
(
const word& name,
const dictionary& viscosityProperties,
const volVectorField& U,
const surfaceScalarField& phi
);
//- Destructor
~BinghamPlastic()
{}
// Member Functions
//- Read transportProperties dictionary
bool read(const dictionary& viscosityProperties);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace viscosityModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

4
applications/solvers/multiphase/driftFluxFoam/viscosityModels/Make/files Normal file
View file

@ -0,0 +1,4 @@
plastic/plastic.C
BinghamPlastic/BinghamPlastic.C
LIB = $(FOAM_LIBBIN)/libdriftFluxTransportModels

10
applications/solvers/multiphase/driftFluxFoam/viscosityModels/Make/options Normal file
View file

@ -0,0 +1,10 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/transportModels \
-I$(LIB_SRC)/transportModels/twoPhaseMixture/lnInclude \
-I$(LIB_SRC)/transportModels/incompressible/lnInclude
LIB_LIBS = \
-ltwoPhaseMixture \
-lincompressibleTransportModels \
-lfiniteVolume

200
applications/solvers/multiphase/driftFluxFoam/viscosityModels/plastic/plastic.C Normal file
View file

@ -0,0 +1,200 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "plastic.H"
#include "addToRunTimeSelectionTable.H"
#include "surfaceFields.H"
#include "incompressibleTwoPhaseMixture.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace viscosityModels
{
defineTypeNameAndDebug(plastic, 0);
addToRunTimeSelectionTable
(
viscosityModel,
plastic,
dictionary
);
}
}
// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
Foam::tmp<Foam::volScalarField>
Foam::viscosityModels::plastic::calcNu() const
{
const incompressibleTwoPhaseMixture& twoPhaseProperties =
alpha_.mesh().lookupObject<incompressibleTwoPhaseMixture>
(
"transportProperties"
);
bool isThisIsPhase1(&twoPhaseProperties.nuModel1() == this);
dimensionedScalar
rhoc
(
isThisIsPhase1
? twoPhaseProperties.rho2()
: twoPhaseProperties.rho1()
);
dimensionedScalar
rhop
(
isThisIsPhase1
? twoPhaseProperties.rho1()
: twoPhaseProperties.rho2()
);
volScalarField
nuc
(
(
isThisIsPhase1
? twoPhaseProperties.nuModel2()
: twoPhaseProperties.nuModel1()
).nu()
);
volScalarField
nup
(
correctionNu(rhoc, rhop, nuc)
);
return
max
(
nuMin_,
min
(
nuMax_,
(
nup + (rhoc/rhop)*nuc*alpha_
)
)
)
/max(alpha_, SMALL);
}
Foam::tmp<Foam::volScalarField>
Foam::viscosityModels::plastic::correctionNu
(
const dimensionedScalar& rhoc,
const dimensionedScalar& rhop,
const volScalarField& nuc
) const
{
return
plasticViscosityCoeff_
*(
pow
(
scalar(10),
plasticViscosityExponent_*alpha_
) - scalar(1)
);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::viscosityModels::plastic::plastic
(
const word& name,
const dictionary& viscosityProperties,
const volVectorField& U,
const surfaceScalarField& phi,
const word modelName
)
:
viscosityModel(name, viscosityProperties, U, phi),
plasticCoeffs_(viscosityProperties.subDict(modelName + "Coeffs")),
plasticViscosityCoeff_
(
plasticCoeffs_.lookup("plasticViscosityCoeff")
),
plasticViscosityExponent_
(
plasticCoeffs_.lookup("plasticViscosityExponent")
),
nuMin_(plasticCoeffs_.lookup("nuMin")),
nuMax_(plasticCoeffs_.lookup("nuMax")),
alpha_
(
U.mesh().lookupObject<volScalarField>
(
IOobject::groupName
(
viscosityProperties.lookupOrDefault<word>("alpha", "alpha"),
viscosityProperties.dictName()
)
)
),
nu_
(
IOobject
(
name,
U_.time().timeName(),
U_.db(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
U_.mesh(),
dimensionedScalar("nu", dimViscosity, 0)
)
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
bool Foam::viscosityModels::plastic::read
(
const dictionary& viscosityProperties
)
{
viscosityModel::read(viscosityProperties);
plasticCoeffs_ = viscosityProperties.subDict(typeName + "Coeffs");
plasticCoeffs_.lookup("k") >> plasticViscosityCoeff_;
plasticCoeffs_.lookup("n") >> plasticViscosityExponent_;
plasticCoeffs_.lookup("nuMin") >> nuMin_;
plasticCoeffs_.lookup("nuMax") >> nuMax_;
return true;
}
// ************************************************************************* //

158
applications/solvers/multiphase/driftFluxFoam/viscosityModels/plastic/plastic.H Normal file
View file

@ -0,0 +1,158 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::viscosityModels::plastic
Description
Viscosity correction model for a generic power-law plastic.
SourceFiles
plastic.C
\*---------------------------------------------------------------------------*/
#ifndef plastic_H
#define plastic_H
#include "viscosityModel.H"
#include "dimensionedScalar.H"
#include "volFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class incompressibleTwoPhaseMixture;
namespace viscosityModels
{
/*---------------------------------------------------------------------------*\
Class plastic Declaration
\*---------------------------------------------------------------------------*/
class plastic
:
public viscosityModel
{
protected:
// Protected data
//- Dictionary
dictionary plasticCoeffs_;
//- Plastic viscosity coefficient
dimensionedScalar plasticViscosityCoeff_;
//- Plastic viscosity exponent
dimensionedScalar plasticViscosityExponent_;
//- Minimum viscosity
dimensionedScalar nuMin_;
//- Maximum viscosity
dimensionedScalar nuMax_;
//- Plastic phase fraction
const volScalarField& alpha_;
//- Viscosity
volScalarField nu_;
// Protected Member Functions
//- Calculate and return the laminar viscosity
virtual tmp<volScalarField> calcNu() const;
//- Calculate and return the laminar viscosity correction
virtual tmp<volScalarField> correctionNu
(
const dimensionedScalar& rhoc,
const dimensionedScalar& rhop,
const volScalarField& nuc
) const;
public:
//- Runtime type information
TypeName("plastic");
// Constructors
//- Construct from components
plastic
(
const word& name,
const dictionary& viscosityProperties,
const volVectorField& U,
const surfaceScalarField& phi,
const word modelName=typeName
);
//- Destructor
~plastic()
{}
// Member Functions
//- Return the laminar viscosity
tmp<volScalarField> nu() const
{
return nu_;
}
//- Return the laminar viscosity for patch
tmp<scalarField> nu(const label patchi) const
{
return nu_.boundaryField()[patchi];
}
//- Correct the laminar viscosity
void correct()
{
nu_ = calcNu();
}
//- Read transportProperties dictionary
bool read(const dictionary& viscosityProperties);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace viscosityModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

4
applications/solvers/multiphase/driftFluxFoam/wallFunctions.H
View file

@ -4,7 +4,6 @@
const scalar Cmu25 = ::pow(Cmu.value(), 0.25);
const scalar Cmu75 = ::pow(Cmu.value(), 0.75);
const scalar kappa_ = kappa.value();
const scalar muc_ = muc.value();
const fvPatchList& patches = mesh.boundary();
@ -34,6 +33,7 @@
if (isA<wallFvPatch>(curPatch))
{
const scalarField& mutw = mut.boundaryField()[patchi];
const scalarField& mucw = muc.boundaryField()[patchi];
scalarField magFaceGradU
(
@ -55,7 +55,7 @@
/(kappa_*y[patchi][facei]);
G[faceCelli] +=
(mutw[facei] + muc_)
(mutw[facei] + mucw[facei])
*magFaceGradU[facei]
*Cmu25*::sqrt(k[faceCelli])
/(kappa_*y[patchi][facei]);

7
applications/solvers/multiphase/driftFluxFoam/wallViscosity.H
View file

@ -2,8 +2,6 @@
const scalar Cmu25 = ::pow(Cmu.value(), 0.25);
const scalar kappa_ = kappa.value();
const scalar E_ = E.value();
const scalar muc_ = muc.value();
const scalar nuc_ = muc_/rhoc.value();
const fvPatchList& patches = mesh.boundary();
@ -14,6 +12,7 @@
if (isA<wallFvPatch>(curPatch))
{
scalarField& mutw = mut.boundaryField()[patchi];
const scalarField& mucw = muc.boundaryField()[patchi];
forAll(curPatch, facei)
{
@ -21,12 +20,12 @@
scalar yPlus =
Cmu25*y[patchi][facei]*::sqrt(k[faceCelli])
/nuc_;
/(mucw[facei]/rho2.value());
if (yPlus > 11.6)
{
mutw[facei] =
muc_*(yPlus*kappa_/::log(E_*yPlus) - 1);
mucw[facei]*(yPlus*kappa_/::log(E_*yPlus) - 1);
}
else
{

27
applications/solvers/multiphase/driftFluxFoam/yieldStress.H
View file

@ -1,27 +0,0 @@
volScalarField yieldStress
(
const dimensionedScalar& yieldStressCoeff,
const dimensionedScalar& yieldStressExponent,
const dimensionedScalar& yieldStressOffset,
const volScalarField& alpha
)
{
tmp<volScalarField> tfld
(
yieldStressCoeff*
(
pow
(
10.0,
yieldStressExponent*(max(alpha, scalar(0)) + yieldStressOffset)
)
- pow
(
10.0,
yieldStressExponent*yieldStressOffset
)
)
);
return tfld();
}

2
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/Make/files
View file

@ -1,6 +1,5 @@
dragModels/dragModel/dragModel.C
dragModels/dragModel/newDragModel.C
dragModels/noDrag/noDrag.C
dragModels/segregated/segregated.C
dragModels/Ergun/Ergun.C
dragModels/Gibilaro/Gibilaro.C
@ -25,7 +24,6 @@ liftModels/TomiyamaLift/TomiyamaLift.C
heatTransferModels/heatTransferModel/heatTransferModel.C
heatTransferModels/heatTransferModel/newHeatTransferModel.C
heatTransferModels/noHeatTransfer/noHeatTransfer.C
heatTransferModels/RanzMarshall/RanzMarshall.C
virtualMassModels/virtualMassModel/virtualMassModel.C

12
applications/solvers/multiphase/twoPhaseEulerFoam/phaseIncompressibleTurbulenceModels/kineticTheoryModels/frictionalStressModel/JohnsonJackson/JohnsonJacksonFrictionalStress.C
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -127,10 +127,12 @@ bool Foam::kineticTheoryModels::frictionalStressModels::JohnsonJackson::read()
{
coeffDict_ <<= dict_.subDict(typeName + "Coeffs");
Fr_.readIfPresent(coeffDict_);
eta_.readIfPresent(coeffDict_);
p_.readIfPresent(coeffDict_);
phi_.readIfPresent(coeffDict_);
Fr_.read(coeffDict_);
eta_.read(coeffDict_);
p_.read(coeffDict_);
phi_.read(coeffDict_);
phi_ *= constant::mathematical::pi/180.0;
return true;
}

9
applications/solvers/multiphase/twoPhaseEulerFoam/phaseIncompressibleTurbulenceModels/kineticTheoryModels/frictionalStressModel/Schaeffer/SchaefferFrictionalStress.C
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -57,7 +57,9 @@ Foam::kineticTheoryModels::frictionalStressModels::Schaeffer::Schaeffer
frictionalStressModel(dict),
coeffDict_(dict.subDict(typeName + "Coeffs")),
phi_("phi", dimless, coeffDict_.lookup("phi"))
{}
{
phi_ *= constant::mathematical::pi/180.0;
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
@ -158,7 +160,8 @@ bool Foam::kineticTheoryModels::frictionalStressModels::Schaeffer::read()
{
coeffDict_ <<= dict_.subDict(typeName + "Coeffs");
phi_.readIfPresent(coeffDict_);
phi_.read(coeffDict_);
phi_ *= constant::mathematical::pi/180.0;
return true;
}

2
applications/utilities/miscellaneous/foamHelp/helpTypes/Make/options
View file

@ -1,7 +1,7 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude
EXE_LIBS = \
LIB_LIBS = \
-lfiniteVolume \
-lincompressibleTurbulenceModel \
-lcompressibleTurbulenceModel \

23
applications/utilities/parallelProcessing/decomposePar/domainDecomposition.H
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -130,7 +130,7 @@ class domainDecomposition
//- Append single element to list
static void append(labelList&, const label);
//- Add face to interProcessor patch.
//- Add face to inter-processor patch
void addInterProcFace
(
const label facei,
@ -141,6 +141,19 @@ class domainDecomposition
List<DynamicList<DynamicList<label> > >&
) const;
//- Generate sub patch info for processor cyclics
template <class BinaryOp>
void processInterCyclics
(
const polyBoundaryMesh& patches,
List<DynamicList<DynamicList<label> > >& interPatchFaces,
List<Map<label> >& procNbrToInterPatch,
List<labelListList>& subPatchIDs,
List<labelListList>& subPatchStarts,
bool owner,
BinaryOp bop
) const;
public:
@ -187,6 +200,12 @@ public:
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "domainDecompositionTemplates.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif

163
applications/utilities/parallelProcessing/decomposePar/domainDecompositionMesh.C
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -32,9 +32,7 @@ Description
#include "domainDecomposition.H"
#include "IOstreams.H"
#include "SLPtrList.H"
#include "boolList.H"
#include "primitiveMesh.H"
#include "cyclicPolyPatch.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
@ -209,10 +207,11 @@ void Foam::domainDecomposition::decomposeMesh()
// Done internal bits of the new mesh and the ordinary patches.
// Per processor, from neighbour processor to the interprocessorpatch that
// communicates with that neighbour.
// Per processor, from neighbour processor to the inter-processor patch
// that communicates with that neighbour
List<Map<label> > procNbrToInterPatch(nProcs_);
// Per processor the faces per interprocessorpatch.
// Per processor the faces per inter-processor patch
List<DynamicList<DynamicList<label> > > interPatchFaces(nProcs_);
// Processor boundaries from internal faces
@ -248,95 +247,73 @@ void Foam::domainDecomposition::decomposeMesh()
subPatchStarts[procI].setSize(nInterfaces, labelList(1, label(0)));
}
// Processor boundaries from split cyclics
forAll(patches, patchi)
{
if (isA<cyclicPolyPatch>(patches[patchi]))
{
const cyclicPolyPatch& pp = refCast<const cyclicPolyPatch>
(
patches[patchi]
);
// cyclic: check opposite side on this processor
const labelUList& patchFaceCells = pp.faceCells();
const labelUList& nbrPatchFaceCells =
pp.neighbPatch().faceCells();
// Special handling needed for the case that multiple processor cyclic
// patches are created on each local processor domain, e.g. if a 3x3 case
// is decomposed using the decomposition:
//
// | 1 | 0 | 2 |
// cyclic left | 2 | 0 | 1 | cyclic right
// | 2 | 0 | 1 |
//
// - processors 1 and 2 will both have pieces of both cyclic left- and
// right sub-patches present
// - the interface patch faces are stored in a single list, where each
// sub-patch is referenced into the list using a patch start index and
// size
// - if the patches are in order (in the boundary file) of left, right
// - processor 1 will send: left, right
// - processor 1 will need to receive in reverse order: right, left
// - similarly for processor 2
// - the sub-patches are therefore generated in 4 passes of the patch lists
// 1. add faces from owner patch where local proc i < nbr proc i
// 2. add faces from nbr patch where local proc i < nbr proc i
// 3. add faces from owner patch where local proc i > nbr proc i
// 4. add faces from nbr patch where local proc i > nbr proc i
// Store old sizes. Used to detect which inter-proc patches
// have been added to.
labelListList oldInterfaceSizes(nProcs_);
forAll(oldInterfaceSizes, procI)
{
labelList& curOldSizes = oldInterfaceSizes[procI];
processInterCyclics
(
patches,
interPatchFaces,
procNbrToInterPatch,
subPatchIDs,
subPatchStarts,
true,
lessOp<label>()
);
curOldSizes.setSize(interPatchFaces[procI].size());
forAll(curOldSizes, interI)
{
curOldSizes[interI] =
interPatchFaces[procI][interI].size();
}
}
processInterCyclics
(
patches,
interPatchFaces,
procNbrToInterPatch,
subPatchIDs,
subPatchStarts,
false,
lessOp<label>()
);
// Add faces with different owner and neighbour processors
forAll(patchFaceCells, facei)
{
const label ownerProc = cellToProc_[patchFaceCells[facei]];
const label nbrProc = cellToProc_[nbrPatchFaceCells[facei]];
if (ownerProc != nbrProc)
{
// inter - processor patch face found.
addInterProcFace
(
pp.start()+facei,
ownerProc,
nbrProc,
procNbrToInterPatch,
interPatchFaces
);
}
}
processInterCyclics
(
patches,
interPatchFaces,
procNbrToInterPatch,
subPatchIDs,
subPatchStarts,
false,
greaterOp<label>()
);
// 1. Check if any faces added to existing interfaces
forAll(oldInterfaceSizes, procI)
{
const labelList& curOldSizes = oldInterfaceSizes[procI];
forAll(curOldSizes, interI)
{
label oldSz = curOldSizes[interI];
if (interPatchFaces[procI][interI].size() > oldSz)
{
// Added faces to this interface. Add an entry
append(subPatchIDs[procI][interI], patchi);
append(subPatchStarts[procI][interI], oldSz);
}
}
}
// 2. Any new interfaces
forAll(subPatchIDs, procI)
{
label nIntfcs = interPatchFaces[procI].size();
subPatchIDs[procI].setSize(nIntfcs, labelList(1, patchi));
subPatchStarts[procI].setSize(nIntfcs, labelList(1, label(0)));
}
}
}
// Shrink processor patch face addressing
forAll(interPatchFaces, procI)
{
DynamicList<DynamicList<label> >& curInterPatchFaces =
interPatchFaces[procI];
forAll(curInterPatchFaces, i)
{
curInterPatchFaces[i].shrink();
}
curInterPatchFaces.shrink();
}
processInterCyclics
(
patches,
interPatchFaces,
procNbrToInterPatch,
subPatchIDs,
subPatchStarts,
true,
greaterOp<label>()
);
// Sort inter-proc patch by neighbour
@ -356,18 +333,18 @@ void Foam::domainDecomposition::decomposeMesh()
// Get sorted neighbour processors
const Map<label>& curNbrToInterPatch = procNbrToInterPatch[procI];
labelList nbrs = curNbrToInterPatch.toc();
sortedOrder(nbrs, order);
DynamicList<DynamicList<label> >& curInterPatchFaces =
interPatchFaces[procI];
forAll(order, i)
forAll(nbrs, i)
{
const label nbrProc = nbrs[i];
const label interPatch = curNbrToInterPatch[nbrProc];
procNeighbourProcessors_[procI][i] =
nbrProc;
procNeighbourProcessors_[procI][i] = nbrProc;
procProcessorPatchSize_[procI][i] =
curInterPatchFaces[interPatch].size();
procProcessorPatchStartIndex_[procI][i] =

125
applications/utilities/parallelProcessing/decomposePar/domainDecompositionTemplates.C Normal file
View file

@ -0,0 +1,125 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "cyclicPolyPatch.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template <class BinaryOp>
void Foam::domainDecomposition::processInterCyclics
(
const polyBoundaryMesh& patches,
List<DynamicList<DynamicList<label> > >& interPatchFaces,
List<Map<label> >& procNbrToInterPatch,
List<labelListList>& subPatchIDs,
List<labelListList>& subPatchStarts,
bool owner,
BinaryOp bop
) const
{
// Processor boundaries from split cyclics
forAll(patches, patchi)
{
if (isA<cyclicPolyPatch>(patches[patchi]))
{
const cyclicPolyPatch& pp = refCast<const cyclicPolyPatch>
(
patches[patchi]
);
if (pp.owner() != owner)
{
continue;
}
// cyclic: check opposite side on this processor
const labelUList& patchFaceCells = pp.faceCells();
const labelUList& nbrPatchFaceCells =
pp.neighbPatch().faceCells();
// Store old sizes. Used to detect which inter-proc patches
// have been added to.
labelListList oldInterfaceSizes(nProcs_);
forAll(oldInterfaceSizes, procI)
{
labelList& curOldSizes = oldInterfaceSizes[procI];
curOldSizes.setSize(interPatchFaces[procI].size());
forAll(curOldSizes, interI)
{
curOldSizes[interI] =
interPatchFaces[procI][interI].size();
}
}
// Add faces with different owner and neighbour processors
forAll(patchFaceCells, facei)
{
const label ownerProc = cellToProc_[patchFaceCells[facei]];
const label nbrProc = cellToProc_[nbrPatchFaceCells[facei]];
if (bop(ownerProc, nbrProc))
{
// inter - processor patch face found.
addInterProcFace
(
pp.start()+facei,
ownerProc,
nbrProc,
procNbrToInterPatch,
interPatchFaces
);
}
}
// 1. Check if any faces added to existing interfaces
forAll(oldInterfaceSizes, procI)
{
const labelList& curOldSizes = oldInterfaceSizes[procI];
forAll(curOldSizes, interI)
{
label oldSz = curOldSizes[interI];
if (interPatchFaces[procI][interI].size() > oldSz)
{
// Added faces to this interface. Add an entry
append(subPatchIDs[procI][interI], patchi);
append(subPatchStarts[procI][interI], oldSz);
}
}
}
// 2. Any new interfaces
forAll(subPatchIDs, procI)
{
label nIntfcs = interPatchFaces[procI].size();
subPatchIDs[procI].setSize(nIntfcs, labelList(1, patchi));
subPatchStarts[procI].setSize(nIntfcs, labelList(1, label(0)));
}
}
}
}
// ************************************************************************* //

9
src/OpenFOAM/dimensionedTypes/dimensionedType/dimensionedType.C
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -245,6 +245,13 @@ void Foam::dimensioned<Type>::replace
}
template<class Type>
void Foam::dimensioned<Type>::read(const dictionary& dict)
{
dict.lookup(name_) >> value_;
}
template<class Type>
bool Foam::dimensioned<Type>::readIfPresent(const dictionary& dict)
{

12
src/OpenFOAM/dimensionedTypes/dimensionedType/dimensionedType.H
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -159,21 +159,25 @@ public:
//- Return transpose.
dimensioned<Type> T() const;
//- Update the value of dimensioned<Type>
void read(const dictionary&);
//- Update the value of dimensioned<Type> if found in the dictionary.
bool readIfPresent(const dictionary&);
// I/O
//- Read using provided units. Only used during startup.
//- Read value from stream and units from dictionary
Istream& read(Istream& is, const dictionary&);
//- Read using provided units
//- Read value from stream and units from table
Istream& read(Istream& is, const HashTable<dimensionedScalar>&);
//- Read using system units
//- Read value from stream and units from system table
Istream& read(Istream& is);
// Member operators
//- Return a component as a dimensioned<cmptType>

7
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -56,10 +56,11 @@ Foam::processorPolyPatch::processorPolyPatch
const polyBoundaryMesh& bm,
const int myProcNo,
const int neighbProcNo,
const transformType transform
const transformType transform,
const word& patchType
)
:
coupledPolyPatch(name, size, start, index, bm, typeName, transform),
coupledPolyPatch(name, size, start, index, bm, patchType, transform),
myProcNo_(myProcNo),
neighbProcNo_(neighbProcNo),
neighbFaceCentres_(),

5
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.H
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -136,7 +136,8 @@ public:
const polyBoundaryMesh& bm,
const int myProcNo,
const int neighbProcNo,
const transformType transform = UNKNOWN // transformation type
const transformType transform = UNKNOWN, // transformation type
const word& patchType = typeName
);
//- Construct from dictionary

6
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
View file

@ -49,7 +49,8 @@ Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
const int myProcNo,
const int neighbProcNo,
const word& referPatchName,
const transformType transform
const transformType transform,
const word& patchType
)
:
processorPolyPatch
@ -61,7 +62,8 @@ Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
bm,
myProcNo,
neighbProcNo,
transform
transform,
patchType
),
referPatchName_(referPatchName),
tag_(-1),

3
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
View file

@ -122,7 +122,8 @@ public:
const int myProcNo,
const int neighbProcNo,
const word& referPatchName,
const transformType transform = UNKNOWN
const transformType transform = UNKNOWN,
const word& patchType = typeName
);
//- Construct from dictionary

14
src/OpenFOAM/meshes/polyMesh/polyPatches/polyPatch/polyPatch.H
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -316,6 +316,16 @@ public:
//- Return a list of all the constraint patch types
static wordList constraintTypes();
//- Extract face cell data
template<class T>
const UIndirectList<T> patchInternalList
(
const UList<T>& internalValues
) const
{
return UIndirectList<T>(internalValues, faceCells());
}
//- Slice list to patch
template<class T>
const typename List<T>::subList patchSlice(const UList<T>& l) const
@ -343,7 +353,7 @@ public:
//- Return face normals
const vectorField::subField faceAreas() const;
//- Return face neighbour cell centres
//- Return face cell centres
tmp<vectorField> faceCellCentres() const;

36
src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclicAMI/jumpCyclicAMIFvPatchField.C
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2012-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -99,10 +99,21 @@ Foam::jumpCyclicAMIFvPatchField<Type>::patchNeighbourField() const
this->cyclicAMIPatch().cyclicAMIPatch().neighbPatch().faceCells();
Field<Type> pnf(iField, nbrFaceCells);
tmp<Field<Type> > tpnf
(
new Field<Type>(this->cyclicAMIPatch().interpolate(pnf))
);
tmp<Field<Type> > tpnf;
if (this->cyclicAMIPatch().applyLowWeightCorrection())
{
tpnf =
this->cyclicAMIPatch().interpolate
(
pnf,
this->patchInternalField()()
);
}
else
{
tpnf = this->cyclicAMIPatch().interpolate(pnf);
}
if (this->doTransform())
{
@ -157,7 +168,20 @@ void Foam::jumpCyclicAMIFvPatchField<Type>::updateInterfaceMatrix
Field<Type> pnf(psiInternal, nbrFaceCells);
pnf = this->cyclicAMIPatch().interpolate(pnf);
if (this->cyclicAMIPatch().applyLowWeightCorrection())
{
pnf =
this->cyclicAMIPatch().interpolate
(
pnf,
this->patchInternalField()()
);
}
else
{
pnf = this->cyclicAMIPatch().interpolate(pnf);
}
// only apply jump to original field
if (&psiInternal == &this->internalField())

15
src/finiteVolume/fields/fvPatchFields/derived/fixedJumpAMI/fixedJumpAMIFvPatchField.C
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2012-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -123,7 +123,18 @@ Foam::tmp<Foam::Field<Type> > Foam::fixedJumpAMIFvPatchField<Type>::jump() const
this->neighbourPatchField()
);
return this->cyclicAMIPatch().interpolate(nbrPatch.jump());
if (this->cyclicAMIPatch().applyLowWeightCorrection())
{
return this->cyclicAMIPatch().interpolate
(
nbrPatch.jump(),
Field<Type>(this->size(), pTraits<Type>::zero)
);
}
else
{
return this->cyclicAMIPatch().interpolate(nbrPatch.jump());
}
}
}

48
src/finiteVolume/fvMesh/fvPatches/constraint/cyclicAMI/cyclicAMIFvPatch.C
View file

@ -53,14 +53,22 @@ void Foam::cyclicAMIFvPatch::makeWeights(scalarField& w) const
const scalarField deltas(nf() & fvPatch::delta());
const scalarField nbrDeltas
(
interpolate
(
nbrPatch.nf() & nbrPatch.fvPatch::delta(),
scalarField(this->size(), 1.0)
)
);
tmp<scalarField> tnbrDeltas;
if (applyLowWeightCorrection())
{
tnbrDeltas =
interpolate
(
nbrPatch.nf() & nbrPatch.fvPatch::delta(),
scalarField(this->size(), 1.0)
);
}
else
{
tnbrDeltas = interpolate(nbrPatch.nf() & nbrPatch.fvPatch::delta());
}
const scalarField& nbrDeltas = tnbrDeltas();
forAll(deltas, faceI)
{
@ -86,14 +94,22 @@ Foam::tmp<Foam::vectorField> Foam::cyclicAMIFvPatch::delta() const
{
const vectorField patchD(fvPatch::delta());
const vectorField nbrPatchD
(
interpolate
(
nbrPatch.fvPatch::delta(),
vectorField(this->size(), vector::zero)
)
);
tmp<vectorField> tnbrPatchD;
if (applyLowWeightCorrection())
{
tnbrPatchD =
interpolate
(
nbrPatch.fvPatch::delta(),
vectorField(this->size(), vector::zero)
);
}
else
{
tnbrPatchD = interpolate(nbrPatch.fvPatch::delta());
}
const vectorField& nbrPatchD = tnbrPatchD();
tmp<vectorField> tpdv(new vectorField(patchD.size()));
vectorField& pdv = tpdv();

12
src/finiteVolume/fvMesh/fvPatches/constraint/cyclicAMI/cyclicAMIFvPatch.H
View file

@ -120,6 +120,13 @@ public:
return cyclicAMIPolyPatch_.AMI();
}
//- Return true if applying the low weight correction
virtual bool applyLowWeightCorrection() const
{
return cyclicAMIPolyPatch_.applyLowWeightCorrection();
}
//- Are the cyclic planes parallel
virtual bool parallel() const
{
@ -154,11 +161,6 @@ public:
//- Return delta (P to N) vectors across coupled patch
virtual tmp<vectorField> delta() const;
bool applyLowWeightCorrection() const
{
return cyclicAMIPolyPatch_.applyLowWeightCorrection();
}
template<class Type>
tmp<Field<Type> > interpolate
(

12
src/finiteVolume/fvMesh/fvPatches/constraint/wedge/wedgeFvPatch.C
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -39,7 +39,6 @@ addToRunTimeSelectionTable(fvPatch, wedgeFvPatch, polyPatch);
// * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * * * * * //
//- Construct from polyPatch
wedgeFvPatch::wedgeFvPatch(const polyPatch& patch, const fvBoundaryMesh& bm)
:
fvPatch(patch, bm),
@ -47,6 +46,15 @@ wedgeFvPatch::wedgeFvPatch(const polyPatch& patch, const fvBoundaryMesh& bm)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::vectorField> Foam::wedgeFvPatch::delta() const
{
const vectorField nHat(nf());
return nHat*(nHat & (Cf() - Cn()));
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam

5
src/finiteVolume/fvMesh/fvPatches/constraint/wedge/wedgeFvPatch.H
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -83,6 +83,9 @@ public:
{
return wedgePolyPatch_.cellT();
}
//- Return cell-centre to face normal vector
virtual tmp<vectorField> delta() const;
};

4
src/meshTools/AMIInterpolation/GAMG/interfaces/cyclicAMIGAMGInterface/cyclicAMIGAMGInterface.H
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -111,7 +111,7 @@ public:
//- Cyclic interface functions
//- Return neigbour processor number
//- Return neighbour processor number
virtual label neighbPatchID() const
{
return fineCyclicAMIInterface_.neighbPatchID();

17
src/meshTools/algorithms/MeshWave/FaceCellWave.C
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -746,7 +746,20 @@ void Foam::FaceCellWave<Type, TrackingData>::handleAMICyclicPatches()
// Transfer sendInfo to cycPatch
combine<Type, TrackingData> cmb(*this, cycPatch);
cycPatch.interpolate(sendInfo, cmb, receiveInfo);
if (cycPatch.applyLowWeightCorrection())
{
List<Type> defVals
(
cycPatch.patchInternalList(allCellInfo_)
);
cycPatch.interpolate(sendInfo, cmb, receiveInfo, defVals);
}
else
{
cycPatch.interpolate(sendInfo, cmb, receiveInfo);
}
}
// Apply transform to received data for non-parallel planes

3
src/postProcessing/functionObjects/cloud/cloudInfo/cloudInfo.C
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2012-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -43,6 +43,7 @@ void Foam::cloudInfo::writeFileHeader(const label i)
writeCommented(file(), "Time");
writeTabbed(file(), "nParcels");
writeTabbed(file(), "mass");
file() << endl;
}

6
src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.C
View file

@ -188,11 +188,7 @@ void Foam::fieldValues::faceSource::setPatchFaces()
const polyPatch& pp = mesh().boundaryMesh()[patchId];
label nFaces = pp.size();
if (isA<cyclicPolyPatch>(pp))
{
nFaces /= 2;
}
else if (isA<emptyPolyPatch>(pp))
if (isA<emptyPolyPatch>(pp))
{
nFaces = 0;
}

1
src/postProcessing/functionObjects/utilities/DESModelRegions/DESModelRegions.C
View file

@ -47,6 +47,7 @@ void Foam::DESModelRegions::writeFileHeader(const label i)
writeCommented(file(), "Time");
writeTabbed(file(), "LES");
writeTabbed(file(), "RAS");
file() << endl;
}

1
src/postProcessing/functionObjects/utilities/wallShearStress/wallShearStress.C
View file

@ -48,6 +48,7 @@ void Foam::wallShearStress::writeFileHeader(const label i)
writeTabbed(file(), "patch");
writeTabbed(file(), "min");
writeTabbed(file(), "max");
file() << endl;
}

1
src/postProcessing/functionObjects/utilities/yPlusLES/yPlusLES.C
View file

@ -50,6 +50,7 @@ void Foam::yPlusLES::writeFileHeader(const label i)
writeTabbed(file(), "min");
writeTabbed(file(), "max");
writeTabbed(file(), "average");
file() << endl;
}

1
src/postProcessing/functionObjects/utilities/yPlusRAS/yPlusRAS.C
View file

@ -51,6 +51,7 @@ void Foam::yPlusRAS::writeFileHeader(const label i)
writeTabbed(file(), "min");
writeTabbed(file(), "max");
writeTabbed(file(), "average");
file() << endl;
}

9
src/transportModels/incompressible/incompressibleTwoPhaseMixture/incompressibleTwoPhaseMixture.C
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -28,6 +28,13 @@ License
#include "surfaceFields.H"
#include "fvc.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(incompressibleTwoPhaseMixture, 0);
}
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //

11
src/transportModels/incompressible/incompressibleTwoPhaseMixture/incompressibleTwoPhaseMixture.H
View file

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -80,6 +80,9 @@ protected:
public:
TypeName("incompressibleTwoPhaseMixture");
// Constructors
//- Construct from components
@ -121,6 +124,12 @@ public:
return rho2_;
};
//- Return const-access to the mixture velocity
const volVectorField& U() const
{
return U_;
}
//- Return the dynamic laminar viscosity
tmp<volScalarField> mu() const;

2
tutorials/multiphase/cavitatingFoam/les/throttle/0/U
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle/0/alpha.vapour
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle/0/k
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle/0/nuSgs
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

3
tutorials/multiphase/cavitatingFoam/les/throttle/0/p
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
@ -24,7 +24,6 @@ boundaryField
{
type totalPressure;
U U;
phi phiv;
rho rho;
psi none;
gamma 1;

2
tutorials/multiphase/cavitatingFoam/les/throttle/0/rho
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle/constant/LESProperties
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle/constant/polyMesh/blockMeshDict
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle/constant/thermodynamicProperties
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle/constant/transportProperties
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle/constant/turbulenceProperties
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle/system/controlDict
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

8
tutorials/multiphase/cavitatingFoam/les/throttle/system/fvSchemes
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
@ -28,9 +28,9 @@ interpolationSchemes
divSchemes
{
default none;
div(phiv,rho) Gauss vanLeer;
div(phi,U) Gauss LUST grad(U);
div(phiv,k) Gauss LUST grad(k);
div(phi,rho) Gauss vanLeer;
div(rhoPhi,U) Gauss LUST grad(U);
div(phi,k) Gauss LUST grad(k);
div((muEff*dev(T(grad(U))))) Gauss linear;
}

10
tutorials/multiphase/cavitatingFoam/les/throttle/system/fvSolution
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
@ -78,5 +78,13 @@ PIMPLE
nNonOrthogonalCorrectors 0;
}
relaxationFactors
{
equations
{
".*" 1;
}
}
// ************************************************************************* //

2
tutorials/multiphase/cavitatingFoam/les/throttle/system/refineMeshDict
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle/system/topoSetDict.1
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle/system/topoSetDict.2
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle/system/topoSetDict.3
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle3D/0.org/U
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle3D/0.org/alpha.vapour
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle3D/0.org/k
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle3D/0.org/nuSgs
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

3
tutorials/multiphase/cavitatingFoam/les/throttle3D/0.org/p
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
@ -24,7 +24,6 @@ boundaryField
{
type totalPressure;
U U;
phi phiv;
rho rho;
psi none;
gamma 1;

2
tutorials/multiphase/cavitatingFoam/les/throttle3D/0.org/rho
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle3D/constant/LESProperties
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle3D/constant/polyMesh/blockMeshDict
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle3D/constant/thermodynamicProperties
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle3D/constant/transportProperties
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle3D/constant/turbulenceProperties
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

2
tutorials/multiphase/cavitatingFoam/les/throttle3D/system/controlDict
View file

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / O peration | Version: 2.3.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/

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