int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
#if defined(version30)
pisoControl piso(mesh);
#include "createTimeControls.H"
#endif
#include "createFields.H"
#include "createFvOptions.H"
#include "initContinuityErrs.H"
// create cfdemCloud
#include "readGravitationalAcceleration.H"
#include "checkImCoupleM.H"
#if defined(anisotropicRotation)
cfdemCloudRotation particleCloud(mesh);
#elif defined(superquadrics_flag)
cfdemCloudRotationSuperquadric particleCloud(mesh);
#else
cfdemCloud particleCloud(mesh);
#endif
#include "checkModelType.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime.loop())
{
Info<< "Time = " << runTime.timeName() << nl << endl;
#if defined(version30)
#include "readTimeControls.H"
#include "CourantNo.H"
#include "setDeltaT.H"
#else
#include "readPISOControls.H"
#include "CourantNo.H"
#endif
// do particle stuff
particleCloud.clockM().start(1,"Global");
particleCloud.clockM().start(2,"Coupling");
bool hasEvolved = particleCloud.evolve(voidfraction,Us,U);
if(hasEvolved)
{
particleCloud.smoothingM().smoothenAbsolutField(particleCloud.forceM(0).impParticleForces());
}
Ksl = particleCloud.momCoupleM(particleCloud.registryM().getProperty("implicitCouple_index")).impMomSource();
Ksl.correctBoundaryConditions();
surfaceScalarField voidfractionf = fvc::interpolate(voidfraction);
phi = voidfractionf*phiByVoidfraction;
//Force Checks
#include "forceCheckIm.H"
#include "solverDebugInfo.H"
particleCloud.clockM().stop("Coupling");
particleCloud.clockM().start(26,"Flow");
if(particleCloud.solveFlow())
{
// Pressure-velocity PISO corrector
{
// Momentum predictor
fvVectorMatrix UEqn
(
fvm::ddt(voidfraction,U) - fvm::Sp(fvc::ddt(voidfraction),U)
+ fvm::div(phi,U) - fvm::Sp(fvc::div(phi),U)
// + turbulence->divDevReff(U)
+ particleCloud.divVoidfractionTau(U, voidfraction)
==
- fvm::Sp(Ksl/rho,U)
+ fvOptions(U)
);
UEqn.relax();
fvOptions.constrain(UEqn);
#if defined(version30)
if (piso.momentumPredictor())
#else
if (momentumPredictor)
#endif
{
if (modelType=="B" || modelType=="Bfull")
solve(UEqn == - fvc::grad(p) + Ksl/rho*Us);
else
solve(UEqn == - voidfraction*fvc::grad(p) + Ksl/rho*Us);
fvOptions.correct(U);
}
// --- PISO loop
#if defined(version30)
while (piso.correct())
#else
for (int corr=0; corr<nCorr; corr++)
#endif
{
volScalarField rUA = 1.0/UEqn.A();
surfaceScalarField rUAf("(1|A(U))", fvc::interpolate(rUA));
volScalarField rUAvoidfraction("(voidfraction2|A(U))",rUA*voidfraction);
surfaceScalarField rUAfvoidfraction("(voidfraction2|A(U)F)", fvc::interpolate(rUAvoidfraction));
U = rUA*UEqn.H();
#ifdef version23
phi = ( fvc::interpolate(U) & mesh.Sf() )
+ rUAfvoidfraction*fvc::ddtCorr(U, phiByVoidfraction);
#else
phi = ( fvc::interpolate(U) & mesh.Sf() )
+ fvc::ddtPhiCorr(rUAvoidfraction, U, phiByVoidfraction);
#endif
surfaceScalarField phiS(fvc::interpolate(Us) & mesh.Sf());
phi += rUAf*(fvc::interpolate(Ksl/rho) * phiS);
if (modelType=="A")
rUAvoidfraction = volScalarField("(voidfraction2|A(U))",rUA*voidfraction*voidfraction);
// Update the fixedFluxPressure BCs to ensure flux consistency
#include "fixedFluxPressureHandling.H"
// Non-orthogonal pressure corrector loop
#if defined(version30)
while (piso.correctNonOrthogonal())
#else
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
#endif
{
// Pressure corrector
fvScalarMatrix pEqn
(
fvm::laplacian(rUAvoidfraction, p) == fvc::div(voidfractionf*phi) + particleCloud.ddtVoidfraction()
);
pEqn.setReference(pRefCell, pRefValue);
#if defined(version30)
pEqn.solve(mesh.solver(p.select(piso.finalInnerIter())));
if (piso.finalNonOrthogonalIter())
{
phiByVoidfraction = phi - pEqn.flux()/voidfractionf;
}
#else
if( corr == nCorr-1 && nonOrth == nNonOrthCorr )
#if defined(versionExt32)
pEqn.solve(mesh.solutionDict().solver("pFinal"));
#else
pEqn.solve(mesh.solver("pFinal"));
#endif
else
pEqn.solve();
if (nonOrth == nNonOrthCorr)
{
phiByVoidfraction = phi - pEqn.flux()/voidfractionf;
}
#endif
} // end non-orthogonal corrector loop
phi = voidfractionf*phiByVoidfraction;
#include "continuityErrorPhiPU.H"
if (modelType=="B" || modelType=="Bfull")
U -= rUA*fvc::grad(p) - Ksl/rho*Us*rUA;
else
U -= voidfraction*rUA*fvc::grad(p) - Ksl/rho*Us*rUA;
U.correctBoundaryConditions();
fvOptions.correct(U);
} // end piso loop
}
void kEpsilonSources::correct()
{
RASModel::correct();
if (!turbulence_)
{
return;
}
volScalarField G(GName(), nut_*2*magSqr(symm(fvc::grad(U_))));
// Update epsilon and G at the wall
epsilon_.boundaryField().updateCoeffs();
// Dissipation equation
tmp<fvScalarMatrix> epsEqn
(
fvm::ddt(epsilon_)
+ fvm::div(phi_, epsilon_)
- fvm::laplacian(DepsilonEff(), epsilon_)
==
C1_*G*epsilon_/k_
- fvm::Sp(C2_*epsilon_/k_, epsilon_)
+ fvOptions(epsilon_)
);
epsEqn().relax();
fvOptions.constrain(epsEqn());
epsEqn().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn);
fvOptions.correct(epsilon_);
bound(epsilon_, epsilonMin_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(k_)
+ fvm::div(phi_, k_)
- fvm::laplacian(DkEff(), k_)
==
G
- fvm::Sp(epsilon_/k_, k_)
+ fvOptions(k_)
);
kEqn().relax();
fvOptions.constrain(kEqn());
solve(kEqn);
fvOptions.correct(k_);
bound(k_, kMin_);
// Re-calculate viscosity
nut_ = Cmu_*sqr(k_)/epsilon_;
nut_.correctBoundaryConditions();
}
void dynamicKEqn<BasicTurbulenceModel>::correct()
{
if (!this->turbulence_)
{
return;
}
// Local references
const alphaField& alpha = this->alpha_;
const rhoField& rho = this->rho_;
const surfaceScalarField& alphaRhoPhi = this->alphaRhoPhi_;
const volVectorField& U = this->U_;
volScalarField& nut = this->nut_;
fv::options& fvOptions(fv::options::New(this->mesh_));
LESeddyViscosity<BasicTurbulenceModel>::correct();
volScalarField divU(fvc::div(fvc::absolute(this->phi(), U)));
tmp<volTensorField> tgradU(fvc::grad(U));
const volSymmTensorField D(dev(symm(tgradU())));
const volScalarField G(this->GName(), 2.0*nut*(tgradU() && D));
tgradU.clear();
volScalarField KK(0.5*(filter_(magSqr(U)) - magSqr(filter_(U))));
KK.max(dimensionedScalar("small", KK.dimensions(), SMALL));
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(alpha, rho, k_)
+ fvm::div(alphaRhoPhi, k_)
- fvm::laplacian(alpha*rho*DkEff(), k_)
==
alpha*rho*G
- fvm::SuSp((2.0/3.0)*alpha*rho*divU, k_)
- fvm::Sp(Ce(D, KK)*alpha*rho*sqrt(k_)/this->delta(), k_)
+ kSource()
+ fvOptions(alpha, rho, k_)
);
kEqn.ref().relax();
fvOptions.constrain(kEqn.ref());
solve(kEqn);
fvOptions.correct(k_);
bound(k_, this->kMin_);
correctNut(D, KK);
}
void DeardorffDiffStress<BasicTurbulenceModel>::correct()
{
if (!this->turbulence_)
{
return;
}
// Local references
const alphaField& alpha = this->alpha_;
const rhoField& rho = this->rho_;
const surfaceScalarField& alphaRhoPhi = this->alphaRhoPhi_;
const volVectorField& U = this->U_;
volSymmTensorField& R = this->R_;
fv::options& fvOptions(fv::options::New(this->mesh_));
ReynoldsStress<LESModel<BasicTurbulenceModel>>::correct();
tmp<volTensorField> tgradU(fvc::grad(U));
const volTensorField& gradU = tgradU();
volSymmTensorField D(symm(gradU));
volSymmTensorField P(-twoSymm(R & gradU));
volScalarField k(this->k());
tmp<fvSymmTensorMatrix> REqn
(
fvm::ddt(alpha, rho, R)
+ fvm::div(alphaRhoPhi, R)
- fvm::laplacian(I*this->nu() + Cs_*(k/this->epsilon())*R, R)
+ fvm::Sp(Cm_*alpha*rho*sqrt(k)/this->delta(), R)
==
alpha*rho*P
+ (4.0/5.0)*alpha*rho*k*D
- ((2.0/3.0)*(1.0 - Cm_/this->Ce_)*I)*(alpha*rho*this->epsilon())
+ fvOptions(alpha, rho, R)
);
REqn.ref().relax();
fvOptions.constrain(REqn.ref());
REqn.ref().solve();
fvOptions.correct(R);
this->boundNormalStress(R);
correctNut();
}
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
#include "readGravitationalAcceleration.H"
#include "createFields.H"
#include "createMRFZones.H"
#include "createFvOptions.H"
#include "initContinuityErrs.H"
#include "readTimeControls.H"
#include "CourantNos.H"
#include "setInitialDeltaT.H"
pimpleControl pimple(mesh);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime.run())
{
#include "readTimeControls.H"
#include "CourantNos.H"
#include "setDeltaT.H"
runTime++;
Info<< "Time = " << runTime.timeName() << nl << endl;
// --- Pressure-velocity PIMPLE corrector loop
while (pimple.loop())
{
fluid.solve();
fluid.correct();
volScalarField contErr1
(
fvc::ddt(alpha1, rho1) + fvc::div(alphaRhoPhi1)
- (fvOptions(alpha1, rho1)&rho1)
);
volScalarField contErr2
(
fvc::ddt(alpha2, rho2) + fvc::div(alphaRhoPhi2)
- (fvOptions(alpha2, rho2)&rho2)
);
#include "UEqns.H"
//~ #include "EEqns.H"
thermo1.correct();
thermo2.correct();
// --- Pressure corrector loop
while (pimple.correct())
{
#include "pEqn.H"
}
#include "DDtU.H"
if (pimple.turbCorr())
{
fluid.correctTurbulence();
}
}
#include "write.H"
Info<< "ExecutionTime = "
<< runTime.elapsedCpuTime()
<< " s\n\n" << endl;
}
Info<< "End\n" << endl;
return 0;
}
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
#include "readGravitationalAcceleration.H"
#include "createFields.H"
#include "createMRFZones.H"
#include "createFvOptions.H"
#include "initContinuityErrs.H"
#include "readTimeControls.H"
#include "CourantNos.H"
#include "setInitialDeltaT.H"
//for testing only with a constant interpahse mass transfer term
dimensionedScalar gamma_LV
("gamma_LV",
dimensionSet (1,-3,-1,0,0,0,0),
scalar(0.000));
dimensionedScalar gamma_VL
("gamma_LV",
dimensionSet (1,-3,-1,0,0,0,0),
scalar(0.000));
// pipeline dimension
dimensionedScalar Dh
("Dh",
dimensionSet (0,1,0,0,0,0,0),
scalar(0.233));
// initial wall temperature
dimensionedScalar TwallInit
("TwallInit",
dimensionSet (0,0,0,1,0,0,0),
scalar(289.43));
// friction factor
scalar frictionFactor = 0.005;
//my volScalarField declaration
#include "myVolScalar.H"
//quasi-one-dimensional flow setup
#include "changeArea.H"
//load refprop thermodynamic library
#include "refpropLibLoading.H"
//initialise the wall temperature
Twall = TwallInit;
//dummy vector
vector unity(1,0,0);
//start of the loop
pimpleControl pimple(mesh);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime.run())
{
#include "readTimeControls.H"
#include "CourantNos.H"
#include "setDeltaT.H"
// interface mass and heat transfer
#include "massAndEnergyTransfer.H"
// update boundary conditions (NSCBC)
#include "NSCBCpuncture.H"
// update wall flux (heat transfer to the vapour phase from the wall)
#include "transportProperties.H"
// runtime time output
runTime++;
Info<< "Time = " << runTime.timeName() << nl << endl;
// --- Pressure-velocity PIMPLE corrector loop
while (pimple.loop())
{
fluid.solve();
fluid.correct();
// interface mass and heat transfer
//#include "massAndEnergyTransfer.H"
// update boundary conditions
p.boundaryField()[patchID] == p_ghost_update2;
U1.boundaryField()[patchID] == vector(U_ghost_update2,0,0);
U2.boundaryField()[patchID] == vector(U_ghost_update2,0,0);
//thermo1.T().boundaryField()[patchID] == T_ghost_update;
//thermo2.T().boundaryField()[patchID] == T_ghost_update;
//alpha1.boundaryField()[patchID] == alpha1_ghost_update;
//alpha2.boundaryField()[patchID] == 1.0 - alpha1_ghost_update;
U_bulk = mag(alpha1*U1+alpha2*U2);
rho_bulk = alpha1*rho1+alpha2*rho2;
psi_bulk =1.0/(alpha1/thermo1.psi()+alpha2/thermo2.psi());
volScalarField contErr1
(
fvc::ddt(alpha1, rho1) + fvc::div(alphaRhoPhi1)
- (fvOptions(alpha1, rho1)&rho1) // fvOptions are the runtime semi-implicit source term
+ alpha1*rho1*mag(U1)*areaSource
- gammaV
);
volScalarField contErr2
(
fvc::ddt(alpha2, rho2) + fvc::div(alphaRhoPhi2)
- (fvOptions(alpha2, rho2)&rho2)
+ alpha2*rho2*mag(U2)*areaSource
- gammaL
);
// update friction source term
Fv = - scalar(2)*frictionFactor*alpha1*rho1*mag(U1)*mag(U1)/Dh;
Fl = - scalar(2)*frictionFactor*alpha2*rho2*mag(U2)*mag(U2)/Dh;
#include "UEqns.H"
// update friction source term for energy balance
U_bulk = mag(alpha1*U1+alpha2*U2);
FvU_bulk = U_bulk*Fv;
FlU_bulk = U_bulk*Fl;
#include "EEqns.H"
// --- Pressure corrector loop
while (pimple.correct())
{
#include "pEqn.H"
}
#include "DDtU.H"
if (pimple.turbCorr())
{
fluid.correctTurbulence();
}
}
#include "write.H"
//const volScalarField& test = alpha1_.db().lookupObject<volScalarField>("flowAreaGrad");
//loop over all cells:
//forAll(mesh.C(), cellI)
//{
//Info << "******* CellID: " << cellI << "*******"<< endl;
//Getting list of all faces of current cell
//const labelList& faces = mesh.cells()[cellI];
//loop over all faces of current cell
//forAll( faces, faceI )
//{
//if (mesh.isInternalFace(faces[faceI]))
//{
//Info << "internal faceI: " << faceI << " mesh.Sf()[faceI]: " << -mesh.Sf()[faceI] << " mesh.magSf()[faceI]: " << mesh.magSf()[faceI] << endl;
//}
//else
//{
//Info << "boundary faceI: " << faceI << " mesh.Sf()[faceI]: " << -mesh.Sf()[faceI] << " mesh.magSf()[faceI]: " << mesh.magSf()[faceI] << endl;
//}
//} //move on to next face
//Info << " " << endl;
//}//move on to next cell
Info<< "ExecutionTime = "
<< runTime.elapsedCpuTime()
<< " s\n\n" << endl;
}
Info<< "End\n" << endl;
return 0;
}
void LRR<BasicTurbulenceModel>::correct()
{
if (!this->turbulence_)
{
return;
}
// Local references
const alphaField& alpha = this->alpha_;
const rhoField& rho = this->rho_;
const surfaceScalarField& alphaRhoPhi = this->alphaRhoPhi_;
const volVectorField& U = this->U_;
volSymmTensorField& R = this->R_;
fv::options& fvOptions(fv::options::New(this->mesh_));
ReynoldsStress<RASModel<BasicTurbulenceModel>>::correct();
tmp<volTensorField> tgradU(fvc::grad(U));
const volTensorField& gradU = tgradU();
volSymmTensorField P(-twoSymm(R & gradU));
volScalarField G(this->GName(), 0.5*mag(tr(P)));
// Update epsilon and G at the wall
epsilon_.boundaryFieldRef().updateCoeffs();
// Dissipation equation
tmp<fvScalarMatrix> epsEqn
(
fvm::ddt(alpha, rho, epsilon_)
+ fvm::div(alphaRhoPhi, epsilon_)
- fvm::laplacian(alpha*rho*DepsilonEff(), epsilon_)
==
Ceps1_*alpha*rho*G*epsilon_/k_
- fvm::Sp(Ceps2_*alpha*rho*epsilon_/k_, epsilon_)
+ fvOptions(alpha, rho, epsilon_)
);
epsEqn.ref().relax();
fvOptions.constrain(epsEqn.ref());
epsEqn.ref().boundaryManipulate(epsilon_.boundaryFieldRef());
solve(epsEqn);
fvOptions.correct(epsilon_);
bound(epsilon_, this->epsilonMin_);
// Correct the trace of the tensorial production to be consistent
// with the near-wall generation from the wall-functions
const fvPatchList& patches = this->mesh_.boundary();
forAll(patches, patchi)
{
const fvPatch& curPatch = patches[patchi];
if (isA<wallFvPatch>(curPatch))
{
forAll(curPatch, facei)
{
label celli = curPatch.faceCells()[facei];
P[celli] *= min
(
G[celli]/(0.5*mag(tr(P[celli])) + SMALL),
1.0
);
}
}
}
}
}
}
// Reynolds stress equation
tmp<fvSymmTensorMatrix> REqn
(
fvm::ddt(alpha, rho, R)
+ fvm::div(alphaRhoPhi, R)
- fvm::laplacian(alpha*rho*DREff(), R)
+ fvm::Sp(C1_*alpha*rho*epsilon_/k_, R)
==
alpha*rho*P
- (2.0/3.0*(1 - C1_)*I)*alpha*rho*epsilon_
- C2_*alpha*rho*dev(P)
+ fvOptions(alpha, rho, R)
);
// Optionally add wall-refection term
if (wallReflection_)
{
const volVectorField& n_(wallDist::New(this->mesh_).n());
const volScalarField& y_(wallDist::New(this->mesh_).y());
const volSymmTensorField reflect
(
Cref1_*R - ((Cref2_*C2_)*(k_/epsilon_))*dev(P)
);
REqn.ref() +=
((3*pow(Cmu_, 0.75)/kappa_)*(alpha*rho*sqrt(k_)/y_))
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createDynamicFvMesh.H"
pimpleControl pimple(mesh);
#include "createFields.H"
#include "createMRF.H"
#include "createTimeControls.H"
#include "createFvOptions.H"
bool checkMeshCourantNo =
readBool(pimple.dict().lookup("checkMeshCourantNo"));
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "initContinuityErrs.H"
#include "readCourantType.H"
dimensionedScalar v_zero("v_zero", dimVolume/dimTime, 0.0);
Info<< "\nStarting time loop\n" << endl;
#include "createSurfaceFields.H"
#include "markBadQualityCells.H"
surfaceScalarField meshPhi
(
"volMeshPhi",
phiv_pos * 0.0
);
surfaceScalarField rel_phiv_pos
(
"rel_phiv_pos",
phiv_pos - meshPhi
);
surfaceScalarField rel_phiv_neg
(
"rel_phiv_neg",
phiv_neg - meshPhi
);
#include "initKappaFieldDyM.H"
while (runTime.run())
{
#include "acousticCourantNo.H"
#include "compressibleCourantNo.H"
#include "readTimeControls.H"
#include "setDeltaT.H"
runTime++;
psi.oldTime();
rho.oldTime();
p.oldTime();
U.oldTime();
h.oldTime();
Info<< "Time = " << runTime.timeName() << nl << endl;
// --- Move mesh and update fluxes
{
// Do any mesh changes
mesh.update();
if (mesh.changing())
{
meshPhi = fvc::meshPhi(rho,U)();
if (runTime.timeIndex() > 1)
{
surfaceScalarField amNew = min(min(phiv_pos - meshPhi - cSf_pos, phiv_neg - meshPhi - cSf_neg), v_zero);
phiNeg += kappa*(amNew - am)*p_neg*psi_neg;
phiPos += (1.0 - kappa)*(amNew - am)*p_neg*psi_neg;
}
else
{
phiNeg -= meshPhi * fvc::interpolate(rho);
}
phi = phiPos + phiNeg;
if (checkMeshCourantNo)
{
#include "customMeshCourantNo.H"
}
#include "markBadQualityCells.H"
}
}
// --- Solve density
{
fvScalarMatrix rhoEqn
(
fvm::ddt(rho) + fvc::div(phi)
==
fvOptions(rho)
);
fvOptions.constrain(rhoEqn);
rhoEqn.solve();
fvOptions.correct(rho);
Info<< "rho max/min : " << max(rho).value()
<< " / " << min(rho).value() << endl;
}
// --- Solve momentum
#include "UEqn.H"
// --- Solve energy
#include "hEqn.H"
// --- Solve pressure (PISO)
{
while (pimple.correct())
{
#include "pEqnDyM.H"
}
#include "updateKappa.H"
}
// --- Solve turbulence
turbulence->correct();
Ek = 0.5*magSqr(U);
EkChange = fvc::ddt(rho,Ek) + fvc::div(phiPos,Ek) + fvc::div(phiNeg,Ek);
dpdt = fvc::ddt(p) - fvc::div(meshPhi, p);
runTime.write();
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
void v2f<BasicTurbulenceModel>::correct()
{
if (!this->turbulence_)
{
return;
}
// Local references
const alphaField& alpha = this->alpha_;
const rhoField& rho = this->rho_;
const surfaceScalarField& alphaRhoPhi = this->alphaRhoPhi_;
const volVectorField& U = this->U_;
volScalarField& nut = this->nut_;
fv::options& fvOptions(fv::options::New(this->mesh_));
eddyViscosity<RASModel<BasicTurbulenceModel>>::correct();
volScalarField divU(fvc::div(fvc::absolute(this->phi(), U)));
// Use N=6 so that f=0 at walls
const dimensionedScalar N("N", dimless, 6.0);
const volTensorField gradU(fvc::grad(U));
const volScalarField S2(2*magSqr(dev(symm(gradU))));
const volScalarField G(this->GName(), nut*S2);
const volScalarField Ts(this->Ts());
const volScalarField L2(type() + ":L2", sqr(Ls()));
const volScalarField v2fAlpha
(
type() + ":alpha",
1.0/Ts*((C1_ - N)*v2_ - 2.0/3.0*k_*(C1_ - 1.0))
);
const volScalarField Ceps1
(
"Ceps1",
1.4*(1.0 + 0.05*min(sqrt(k_/v2_), scalar(100.0)))
);
// Update epsilon (and possibly G) at the wall
epsilon_.boundaryFieldRef().updateCoeffs();
// Dissipation equation
tmp<fvScalarMatrix> epsEqn
(
fvm::ddt(alpha, rho, epsilon_)
+ fvm::div(alphaRhoPhi, epsilon_)
- fvm::laplacian(alpha*rho*DepsilonEff(), epsilon_)
==
Ceps1*alpha*rho*G/Ts
- fvm::SuSp(((2.0/3.0)*Ceps1 + Ceps3_)*alpha*rho*divU, epsilon_)
- fvm::Sp(Ceps2_*alpha*rho/Ts, epsilon_)
+ fvOptions(alpha, rho, epsilon_)
);
epsEqn.ref().relax();
fvOptions.constrain(epsEqn.ref());
epsEqn.ref().boundaryManipulate(epsilon_.boundaryFieldRef());
solve(epsEqn);
fvOptions.correct(epsilon_);
bound(epsilon_, this->epsilonMin_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(alpha, rho, k_)
+ fvm::div(alphaRhoPhi, k_)
- fvm::laplacian(alpha*rho*DkEff(), k_)
==
alpha*rho*G
- fvm::SuSp((2.0/3.0)*alpha*rho*divU, k_)
- fvm::Sp(alpha*rho*epsilon_/k_, k_)
+ fvOptions(alpha, rho, k_)
);
kEqn.ref().relax();
fvOptions.constrain(kEqn.ref());
solve(kEqn);
fvOptions.correct(k_);
bound(k_, this->kMin_);
// Relaxation function equation
tmp<fvScalarMatrix> fEqn
(
- fvm::laplacian(f_)
==
- fvm::Sp(1.0/L2, f_)
- 1.0/L2/k_*(v2fAlpha - C2_*G)
);
fEqn.ref().relax();
fvOptions.constrain(fEqn.ref());
solve(fEqn);
fvOptions.correct(f_);
bound(f_, fMin_);
// Turbulence stress normal to streamlines equation
tmp<fvScalarMatrix> v2Eqn
(
fvm::ddt(alpha, rho, v2_)
+ fvm::div(alphaRhoPhi, v2_)
- fvm::laplacian(alpha*rho*DkEff(), v2_)
==
alpha*rho*min(k_*f_, C2_*G - v2fAlpha)
- fvm::Sp(N*alpha*rho*epsilon_/k_, v2_)
+ fvOptions(alpha, rho, v2_)
);
v2Eqn.ref().relax();
fvOptions.constrain(v2Eqn.ref());
solve(v2Eqn);
fvOptions.correct(v2_);
bound(v2_, v2Min_);
correctNut();
}
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
#include "createFields.H"
#include "createFvOptions.H"
#include "initContinuityErrs.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime.loop())
{
Info<< "Time = " << runTime.timeName() << nl << endl;
#include "readPISOControls.H"
#include "CourantNo.H"
// Pressure-velocity PISO corrector
{
// Momentum predictor
fvVectorMatrix UEqn
(
fvm::ddt(U)
+ fvm::div(phi, U)
+ turbulence->divDevReff(U)
);
UEqn.relax();
if (momentumPredictor)
{
solve(UEqn == -fvc::grad(p));
}
// --- PISO loop
for (int corr=0; corr<nCorr; corr++)
{
volScalarField rAU(1.0/UEqn.A());
volVectorField HbyA("HbyA", U);
HbyA = rAU*UEqn.H();
surfaceScalarField phiHbyA
(
"phiHbyA",
(fvc::interpolate(HbyA) & mesh.Sf())
+ fvc::interpolate(rAU)*fvc::ddtCorr(U, phi)
);
adjustPhi(phiHbyA, U, p);
// Non-orthogonal pressure corrector loop
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
// Pressure corrector
fvScalarMatrix pEqn
(
fvm::laplacian(rAU, p) == fvc::div(phiHbyA)
);
pEqn.setReference(pRefCell, pRefValue);
if
(
corr == nCorr-1
&& nonOrth == nNonOrthCorr
)
{
pEqn.solve(mesh.solver("pFinal"));
}
else
{
pEqn.solve();
}
if (nonOrth == nNonOrthCorr)
{
phi = phiHbyA - pEqn.flux();
}
}
#include "continuityErrs.H"
U = HbyA - rAU*fvc::grad(p);
U.correctBoundaryConditions();
}
}
turbulence->correct();
/*tmp<fvScalarMatrix> sEqn
(
fvm::ddt(s)
+ fvm::div(phi, s)
- fvm::laplacian(Ds, s)
);
sources.constrain(sEqn());
solve(sEqn() == sources(s));*/
tmp<fv::convectionScheme<scalar> > mvConvection
(
fv::convectionScheme<scalar>::New
(
mesh,
fields,
phi,
mesh.divScheme("div(phi,si_h)")
)
);
volScalarField kappaEff
(
"kappaEff",
turbulence->nu()/Pr + turbulence->nut()/Prt
);
forAll(s, i)
{
volScalarField& si = s[i];
tmp<fvScalarMatrix> siEqn
(
fvm::ddt(si)
+ mvConvection->fvmDiv(phi, si)
- fvm::laplacian(kappaEff, si)
== fvOptions(si)
);
fvOptions.constrain(siEqn());
solve(siEqn(),mesh.solver("si"));
fvOptions.correct(si);
}
//create scalar Fields u*s for averaging
forAll(us, i)
{
us[i]=U*s[i];
}
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createDynamicFvMesh.H"
#include "createFields.H"
#include "initContinuityErrs.H"
#if defined(version22)
#include "createFvOptions.H"
#endif
// create cfdemCloud
#include "readGravitationalAcceleration.H"
cfdemCloudIB particleCloud(mesh);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime.loop())
{
Info<< "Time = " << runTime.timeName() << nl << endl;
//=== dyM ===================
interFace = mag(mesh.lookupObject<volScalarField>("voidfractionNext"));
mesh.update(); //dyM
#include "readPISOControls.H"
#include "CourantNo.H"
// do particle stuff
Info << "- evolve()" << endl;
particleCloud.evolve();
// Pressure-velocity PISO corrector
{
// Momentum predictor
fvVectorMatrix UEqn
(
fvm::ddt(voidfraction,U)
+ fvm::div(phi, U)
+ turbulence->divDevReff(U)
#if defined(version22)
==
fvOptions(U)
#endif
);
UEqn.relax();
#if defined(version22)
fvOptions.constrain(UEqn);
#endif
if (momentumPredictor)
{
solve(UEqn == -fvc::grad(p));
}
// --- PISO loop
for (int corr=0; corr<nCorr; corr++)
{
volScalarField rUA = 1.0/UEqn.A();
U = rUA*UEqn.H();
#ifdef version23
phi = (fvc::interpolate(U) & mesh.Sf()); // there is a new version in 23x
#else
phi = (fvc::interpolate(U) & mesh.Sf())
+ fvc::ddtPhiCorr(rUA, U, phi);
#endif
adjustPhi(phi, U, p);
#if defined(version22)
fvOptions.relativeFlux(phi);
#endif
// Non-orthogonal pressure corrector loop
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
// Pressure corrector
fvScalarMatrix pEqn
(
fvm::laplacian(rUA, p) == fvc::div(phi) + particleCloud.ddtVoidfraction()
);
pEqn.setReference(pRefCell, pRefValue);
if
(
corr == nCorr-1
&& nonOrth == nNonOrthCorr
)
{
pEqn.solve(mesh.solver("pFinal"));
}
else
{
pEqn.solve();
}
if (nonOrth == nNonOrthCorr)
{
phi -= pEqn.flux();
}
}
#include "continuityErrs.H"
U -= rUA*fvc::grad(p);
U.correctBoundaryConditions();
}
}
turbulence->correct();
Info << "particleCloud.calcVelocityCorrection() " << endl;
volScalarField voidfractionNext=mesh.lookupObject<volScalarField>("voidfractionNext");
particleCloud.calcVelocityCorrection(p,U,phiIB,voidfractionNext);
#if defined(version22)
fvOptions.correct(U);
#endif
runTime.write();
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
int main(int argc, char *argv[])
{
argList::noParallel();
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
#include "createFields.H"
#include "createFvOptions.H"
#include "interrogateWallPatches.H"
turbulence->validate();
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime.loop())
{
Info<< "Time = " << runTime.timeName() << nl << endl;
fvVectorMatrix divR(turbulence->divDevReff(U));
divR.source() = flowMask & divR.source();
fvVectorMatrix UEqn
(
divR == gradP + fvOptions(U)
);
UEqn.relax();
fvOptions.constrain(UEqn);
UEqn.solve();
fvOptions.correct(U);
// Correct driving force for a constant volume flow rate
dimensionedVector UbarStar = flowMask & U.weightedAverage(mesh.V());
U += (Ubar - UbarStar);
gradP += (Ubar - UbarStar)/(1.0/UEqn.A())().weightedAverage(mesh.V());
laminarTransport.correct();
turbulence->correct();
Info<< "Uncorrected Ubar = " << (flowDirection & UbarStar.value())
<< ", pressure gradient = " << (flowDirection & gradP.value())
<< endl;
#include "evaluateNearWall.H"
if (runTime.writeTime())
{
#include "makeGraphs.H"
}
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
#if defined(version30)
pisoControl piso(mesh);
#include "createTimeControls.H"
#endif
#include "createFields.H"
#include "initContinuityErrs.H"
#include "createFvOptions.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
int flag;
MPI_Initialized(&flag);
if (!flag)
{
int argc = 0;
char **argv = NULL;
MPI_Init(&argc,&argv);
}
int proc_name;
MPI_Comm_rank(MPI_COMM_WORLD,&proc_name);
# include "c3po_modifications_1.H"
Info<< "\nStarting time loop\n" << endl;
while (runTime.loop())
{
Info<< "Time = " << runTime.timeName() << nl << endl;
#if defined(version30)
#include "readTimeControls.H"
#include "CourantNo.H"
#include "setDeltaT.H"
#else
#include "readPISOControls.H"
#include "CourantNo.H"
#endif
// Pressure-velocity PISO corrector
{
// Momentum predictor
fvVectorMatrix UEqn
(
fvm::ddt(U)
+ fvm::div(phi, U)
+ turbulence->divDevReff(U)
- fvOptions(U)
);
UEqn.relax();
#if defined(version30)
if (piso.momentumPredictor())
#else
if (momentumPredictor)
#endif
{
solve(UEqn == -fvc::grad(p));
}
// --- PISO loop
#if defined(version30)
while (piso.correct())
#else
int nCorrSoph = nCorr + 5 * pow((1-particleCloud.dataExchangeM().timeStepFraction()),1);
for (int corr=0; corr<nCorrSoph; corr++)
#endif
{
volScalarField rAU(1.0/UEqn.A());
volVectorField HbyA("HbyA", U);
HbyA = rAU*UEqn.H();
surfaceScalarField phiHbyA
(
"phiHbyA",
(fvc::interpolate(HbyA) & mesh.Sf())
+ fvc::interpolate(rAU)*fvc::ddtCorr(U, phi)
);
adjustPhi(phiHbyA, U, p);
// Non-orthogonal pressure corrector loop
#if defined(version30)
while (piso.correctNonOrthogonal())
#else
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
#endif
{
// Pressure corrector
fvScalarMatrix pEqn
(
fvm::laplacian(rAU, p) == fvc::div(phiHbyA)
);
pEqn.setReference(pRefCell, pRefValue);
#if defined(version30)
pEqn.solve(mesh.solver(p.select(piso.finalInnerIter())));
#else
if( corr == nCorr-1 && nonOrth == nNonOrthCorr )
pEqn.solve(mesh.solver("pFinal"));
else
pEqn.solve();
#endif
}
#include "continuityErrs.H"
U = HbyA - rAU*fvc::grad(p);
U.correctBoundaryConditions();
}
}
turbulence->correct();
//In this example CPPPO is called when OF writes data to disk
if(runTime.write())
{
# include "c3po_modifications_2.H"
runTime.write();
}
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
# include "c3po_modifications_3.H"
Info<< "End\n" << endl;
return 0;
}
void Foam::solveLaplacianPDE::solve()
{
if(active_) {
const fvMesh& mesh = refCast<const fvMesh>(obr_);
dictionary sol=mesh.solutionDict().subDict(fieldName_+"LaplacianPDE");
FieldValueExpressionDriver &driver=driver_();
int nCorr=sol.lookupOrDefault<int>("nCorrectors", 0);
if(
nCorr==0
&&
steady_
) {
WarningIn("Foam::solveTransportPDE::solve()")
<< name_ << " is steady. It is recommended to have in "
<< sol.name() << " a nCorrectors>0"
<< endl;
}
for (int corr=0; corr<=nCorr; corr++) {
driver.clearVariables();
driver.parse(lambdaExpression_);
if(!driver.resultIsTyp<volScalarField>()) {
FatalErrorIn("Foam::solveLaplacianPDE::solve()")
<< lambdaExpression_ << " does not evaluate to a scalar"
<< endl
<< exit(FatalError);
}
volScalarField lambdaField(driver.getResult<volScalarField>());
lambdaField.dimensions().reset(lambdaDimension_);
driver.parse(sourceExpression_);
if(!driver.resultIsTyp<volScalarField>()) {
FatalErrorIn("Foam::solveLaplacianPDE::solve()")
<< sourceExpression_ << " does not evaluate to a scalar"
<< endl
<< exit(FatalError);
}
volScalarField sourceField(driver.getResult<volScalarField>());
sourceField.dimensions().reset(sourceDimension_);
volScalarField &f=theField();
fvMatrix<scalar> eq(
-fvm::laplacian(lambdaField,f,"laplacian(lambda,"+f.name()+")")
==
sourceField
);
autoPtr<volScalarField> rhoField;
if(needsRhoField()) {
driver.parse(rhoExpression_);
if(!driver.resultIsTyp<volScalarField>()) {
FatalErrorIn("Foam::solveLaplacianPDE::solve()")
<< rhoExpression_ << " does not evaluate to a scalar"
<< endl
<< exit(FatalError);
}
rhoField.set(
new volScalarField(
driver.getResult<volScalarField>()
)
);
rhoField().dimensions().reset(rhoDimension_);
}
#ifdef FOAM_HAS_FVOPTIONS
if(needsRhoField()) {
eq-=fvOptions()(rhoField(),f);
}
#endif
if(!steady_) {
fvMatrix<scalar> ddtMatrix(fvm::ddt(f));
if(
!ddtMatrix.diagonal()
&&
!ddtMatrix.symmetric()
&&
!ddtMatrix.asymmetric()
) {
// Adding would fail
} else {
eq+=rhoField()*ddtMatrix;
}
}
if(sourceImplicitExpression_!="") {
driver.parse(sourceImplicitExpression_);
if(!driver.resultIsTyp<volScalarField>()) {
FatalErrorIn("Foam::solveLaplacianPDE::solve()")
<< sourceImplicitExpression_ << " does not evaluate to a scalar"
<< endl
<< exit(FatalError);
}
volScalarField sourceImplicitField(driver.getResult<volScalarField>());
sourceImplicitField.dimensions().reset(sourceImplicitDimension_);
if(sourceImplicitUseSuSp_) {
eq-=fvm::SuSp(sourceImplicitField,f);
} else {
eq-=fvm::Sp(sourceImplicitField,f);
}
}
if(doRelax(corr==nCorr)) {
eq.relax();
}
#ifdef FOAM_HAS_FVOPTIONS
fvOptions().constrain(eq);
#endif
int nNonOrthCorr=sol.lookupOrDefault<int>("nNonOrthogonalCorrectors", 0);
bool converged=true;
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
volScalarField fallback(
"fallback"+f.name(),
f
);
#ifdef FOAM_LDUMATRIX_SOLVERPERFORMANCE
lduMatrix::solverPerformance perf=eq.solve();
#elif defined(FOAM_LDUSOLVERPERFORMANCE)
lduSolverPerformance perf=eq.solve();
#else
solverPerformance perf=eq.solve();
#endif
if(
!perf.converged()
&&
restoreNonConvergedSteady()
) {
WarningIn("Foam::solveTransportPDE::solve()")
<< "Solution for " << f.name()
<< " not converged. Restoring"
<< endl;
f=fallback;
converged=false;
break;
}
}
#ifdef FOAM_HAS_FVOPTIONS
fvOptions().correct(f);
#endif
if(!converged) {
break;
}
}
}
}
