void Foam::MULES::explicitSolve
(
const RhoType& rho,
volScalarField& psi,
const surfaceScalarField& phi,
surfaceScalarField& phiPsi,
const SpType& Sp,
const SuType& Su,
const scalar psiMax,
const scalar psiMin
)
{
psi.correctBoundaryConditions();
limit(rho, psi, phi, phiPsi, Sp, Su, psiMax, psiMin, 3, false);
explicitSolve(rho, psi, phiPsi, Sp, Su);
}
Foam::tmp<Foam::volScalarField>
Foam::populationBalanceSubModels::growthModels::constantGrowth::Kg
(
const volScalarField& abscissa
) const
{
dimensionedScalar oneAbs
(
"oneAbs",
dimVolume/sqr(abscissa.dimensions()),
1.0
);
return Cg_*pos(-abscissa + maxAbscissa_)
*pos(abscissa - minAbscissa_)*oneAbs;
}
tmp<GeometricField<Type, fvPatchField, volMesh> >
d2dt2
(
const volScalarField& rho,
const GeometricField<Type, fvPatchField, volMesh>& vf
)
{
return fv::d2dt2Scheme<Type>::New
(
vf.mesh(),
vf.mesh().schemesDict().ddtScheme
(
"d2dt2(" + rho.name() + ',' + vf.name() + ')'
)
)().fvcD2dt2(rho, vf);
}
void Foam::functionObjects::yPlus::calcYPlus
(
const turbulenceModel& turbModel,
volScalarField& yPlus
)
{
volScalarField::Boundary d = nearWallDist(mesh_).y();
const volScalarField::Boundary nutBf =
turbModel.nut()().boundaryField();
const volScalarField::Boundary nuEffBf =
turbModel.nuEff()().boundaryField();
const volScalarField::Boundary nuBf =
turbModel.nu()().boundaryField();
const fvPatchList& patches = mesh_.boundary();
volScalarField::Boundary& yPlusBf = yPlus.boundaryFieldRef();
forAll(patches, patchi)
{
const fvPatch& patch = patches[patchi];
if (isA<nutWallFunctionFvPatchScalarField>(nutBf[patchi]))
{
const nutWallFunctionFvPatchScalarField& nutPf =
dynamic_cast<const nutWallFunctionFvPatchScalarField&>
(
nutBf[patchi]
);
yPlusBf[patchi] = nutPf.yPlus();
}
else if (isA<wallFvPatch>(patch))
{
yPlusBf[patchi] =
d[patchi]
*sqrt
(
nuEffBf[patchi]
*mag(turbModel.U().boundaryField()[patchi].snGrad())
)/nuBf[patchi];
}
}
}
void dense::setScalarAverage
(
volScalarField& field,
double**& value,
double**& weight,
volScalarField& weightField,
double**const& mask
) const
{
label cellI;
scalar valueScal;
scalar weightP;
for(int index=0; index< particleCloud_.numberOfParticles(); index++)
{
if(mask[index][0])
{
for(int subCell=0;subCell<particleCloud_.voidFractionM().cellsPerParticle()[index][0];subCell++)
{
//Info << "subCell=" << subCell << endl;
cellI = particleCloud_.cellIDs()[index][subCell];
if (cellI >= 0)
{
valueScal = value[index][0];
weightP = weight[index][0];
// first entry in this cell
if(weightField[cellI] == 0)
{
field[cellI] = valueScal;
weightField[cellI] = weightP;
}
else
{
field[cellI] = (field[cellI]*weightField[cellI]+valueScal*weightP)/(weightField[cellI]+weightP);
weightField[cellI] += weightP;
}
}
}
}
}
// correct cell values to patches
field.correctBoundaryConditions();
}
void Foam::compressibleTwoPhaseMixtureThermo::heBoundaryCorrection(volScalarField& h)
{
volScalarField::GeometricBoundaryField& hbf = h.boundaryField();
forAll(hbf, patchi)
{
if (isA<gradientEnergyFvPatchScalarField>(hbf[patchi]))
{
refCast<gradientEnergyFvPatchScalarField>(hbf[patchi]).gradient()
= hbf[patchi].fvPatchField::snGrad();
}
else if (isA<mixedEnergyFvPatchScalarField>(hbf[patchi]))
{
refCast<mixedEnergyFvPatchScalarField>(hbf[patchi]).refGrad()
= hbf[patchi].fvPatchField::snGrad();
}
}
}
tmp<fvMatrix<Type> >
steadyStateDdtScheme<Type>::fvmDdt
(
const volScalarField& rho,
const GeometricField<Type, fvPatchField, volMesh>& vf
)
{
tmp<fvMatrix<Type> > tfvm
(
new fvMatrix<Type>
(
vf,
rho.dimensions()*vf.dimensions()*dimVol/dimTime
)
);
return tfvm;
}
void Foam::fv::limitTemperature::correct(volScalarField& he)
{
const basicThermo& thermo =
mesh_.lookupObject<basicThermo>(basicThermo::dictName);
scalarField Tmin(cells_.size(), Tmin_);
scalarField Tmax(cells_.size(), Tmax_);
scalarField heMin(thermo.he(thermo.p(), Tmin, cells_));
scalarField heMax(thermo.he(thermo.p(), Tmax, cells_));
scalarField& hec = he.internalField();
forAll(cells_, i)
{
label cellI = cells_[i];
hec[cellI]= max(min(hec[cellI], heMax[i]), heMin[i]);
}
void Foam::basicThermo::hBoundaryCorrection(volScalarField& h)
{
volScalarField::GeometricBoundaryField& hbf = h.boundaryField();
forAll(hbf, patchi)
{
if (isA<gradientEnthalpyFvPatchScalarField>(hbf[patchi]))
{
refCast<gradientEnthalpyFvPatchScalarField>(hbf[patchi]).gradient()
= hbf[patchi].fvPatchField::snGrad();
}
else if (isA<mixedEnthalpyFvPatchScalarField>(hbf[patchi]))
{
refCast<mixedEnthalpyFvPatchScalarField>(hbf[patchi]).refGrad()
= hbf[patchi].fvPatchField::snGrad();
}
}
}
void Foam::basicThermo::eBoundaryCorrection(volScalarField& e)
{
volScalarField::GeometricBoundaryField& ebf = e.boundaryField();
forAll(ebf, patchi)
{
if (isA<gradientInternalEnergyFvPatchScalarField>(ebf[patchi]))
{
refCast<gradientInternalEnergyFvPatchScalarField>(ebf[patchi])
.gradient() = ebf[patchi].fvPatchField::snGrad();
}
else if (isA<mixedInternalEnergyFvPatchScalarField>(ebf[patchi]))
{
refCast<mixedInternalEnergyFvPatchScalarField>(ebf[patchi])
.refGrad() = ebf[patchi].fvPatchField::snGrad();
}
}
}
Foam::scalar Foam::power::rho(const volScalarField& p) const
{
if (p.dimensions() == dimPressure)
{
return 1.0;
}
else
{
if (rhoName_ != "rhoInf")
{
FatalErrorIn("power::rho(const volScalarField& p)")
<< "Dynamic pressure is expected but kinematic is provided."
<< exit(FatalError);
}
return rhoRef_;
}
}
Foam::phaseModel::phaseModel
(
const word& phaseName,
const volScalarField& p,
const volScalarField& T
)
:
volScalarField
(
IOobject
(
IOobject::groupName("alpha", phaseName),
p.mesh().time().timeName(),
p.mesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
p.mesh()
),
name_(phaseName),
p_(p),
T_(T),
thermo_(NULL),
dgdt_
(
IOobject
(
IOobject::groupName("dgdt", phaseName),
p.mesh().time().timeName(),
p.mesh(),
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
p.mesh(),
dimensionedScalar("0", dimless/dimTime, 0)
)
{
{
volScalarField Tp(IOobject::groupName("T", phaseName), T);
Tp.write();
}
thermo_ = rhoThermo::New(p.mesh(), phaseName);
thermo_->validate(phaseName, "e");
correct();
}
wordList mixtureKEpsilon<BasicTurbulenceModel>::epsilonBoundaryTypes
(
const volScalarField& epsilon
) const
{
const volScalarField::GeometricBoundaryField& ebf = epsilon.boundaryField();
wordList ebt = ebf.types();
forAll(ebf, patchi)
{
if (isA<fixedValueFvPatchScalarField>(ebf[patchi]))
{
ebt[patchi] = fixedValueFvPatchScalarField::typeName;
}
}
return ebt;
}
void Foam::heThermo<BasicThermo, MixtureType>::
heBoundaryCorrection(volScalarField& h)
{
volScalarField::Boundary& hBf = h.boundaryFieldRef();
forAll(hBf, patchi)
{
if (isA<gradientEnergyFvPatchScalarField>(hBf[patchi]))
{
refCast<gradientEnergyFvPatchScalarField>(hBf[patchi]).gradient()
= hBf[patchi].fvPatchField::snGrad();
}
else if (isA<mixedEnergyFvPatchScalarField>(hBf[patchi]))
{
refCast<mixedEnergyFvPatchScalarField>(hBf[patchi]).refGrad()
= hBf[patchi].fvPatchField::snGrad();
}
}
}
tmp<volScalarField> SpalartAllmarasIDDES<BasicTurbulenceModel>::rd
(
const volScalarField& nur,
const volScalarField& magGradU
) const
{
return min
(
nur
/(
max
(
magGradU,
dimensionedScalar("SMALL", magGradU.dimensions(), SMALL)
)*sqr(this->kappa_*this->y_)
),
scalar(10)
);
}
void writeCellGraph
(
const volScalarField& vsf,
const word& graphFormat
)
{
fileName path(vsf.time().path()/"graphs"/vsf.time().timeName());
mkDir(path);
graph
(
vsf.name(),
"x",
vsf.name(),
vsf.mesh().C().primitiveField().component(vector::X),
vsf.primitiveField()
).write(path/vsf.name(), graphFormat);
}
tmp<GeometricField<typename flux<Type>::type, fvsPatchField, surfaceMesh> >
ddtPhiCorr
(
const volScalarField& rA,
const volScalarField& rho,
const GeometricField<Type, fvPatchField, volMesh>& U,
const GeometricField
<
typename flux<Type>::type,
fvsPatchField,
surfaceMesh
>& phi
)
{
return fv::ddtScheme<Type>::New
(
U.mesh(),
U.mesh().ddtScheme("ddt(" + rho.name() + ',' + U.name() + ')')
)().fvcDdtPhiCorr(rA, rho, U, phi);
}
isoBubble::isoBubble
(
const IOobject& io,
const volScalarField& isoField,
bool isTime ,
scalar isoValue,
label timeIndexPad,
word outputFormat,
bool regularize
)
:
regIOobject(io, isTime),
isoPointField_(isoField.mesh().nPoints(),0),
bubblePtr_(),
timeIndexPad_(timeIndexPad),
outputFormat_(outputFormat)
{
// Reconstruct immediately using the tracked field.
reconstruct(isoField, isoValue, regularize);
}
void dilute::setScalarAverage
(
volScalarField& field,
double**& value,
double**& weight,
volScalarField& weightField,
double**const& mask,
double**const& weight2, //allows the specification of a 2nd weight field
bool weightWithWeight2 //switch to activate 2nd weight field
) const
{
label cellI;
scalar valueScal;
scalar weightP;
if(weightWithWeight2)
FatalError << "dilute::setScalarAverage: attempt to weight with weight2, which is not implemented" << abort(FatalError);
for(int index=0; index< particleCloud_.numberOfParticles(); index++)
{
for(int subCell=0;subCell<particleCloud_.cellsPerParticle()[index][0];subCell++)
{
//Info << "subCell=" << subCell << endl;
cellI = particleCloud_.cellIDs()[index][subCell];
if (cellI >= 0)
{
valueScal = value[index][0];
weightP = weight[index][0];
weightField[cellI] += weightP;
field[cellI] = valueScal/weightP;
}
}
}
// correct cell values to patches
field.correctBoundaryConditions();
}
void Foam::MULES::explicitSolve
(
const RhoType& rho,
volScalarField& psi,
const surfaceScalarField& phiPsi,
const SpType& Sp,
const SuType& Su
)
{
const fvMesh& mesh = psi.mesh();
if (fv::localEulerDdt::enabled(mesh))
{
const volScalarField& rDeltaT = fv::localEulerDdt::localRDeltaT(mesh);
explicitSolve(rDeltaT, rho, psi, phiPsi, Sp, Su);
}
else
{
const scalar rDeltaT = 1.0/mesh.time().deltaTValue();
explicitSolve(rDeltaT, rho, psi, phiPsi, Sp, Su);
}
}
Foam::scalar Foam::compressibleCourantNo
(
const fvMesh& mesh,
const Time& runTime,
const volScalarField& rho,
const surfaceScalarField& phi
)
{
scalarField sumPhi
(
fvc::surfaceSum(mag(phi))().primitiveField()
/ rho.primitiveField()
);
scalar CoNum = 0.5*gMax(sumPhi/mesh.V().field())*runTime.deltaTValue();
scalar meanCoNum =
0.5*(gSum(sumPhi)/gSum(mesh.V().field()))*runTime.deltaTValue();
Info<< "Region: " << mesh.name() << " Courant Number mean: " << meanCoNum
<< " max: " << CoNum << endl;
return CoNum;
}
void Foam::setRefCell
(
const volScalarField& field,
const volScalarField& fieldRef,
const dictionary& dict,
label& refCelli,
scalar& refValue,
const bool forceReference
)
{
if (fieldRef.needReference() || forceReference)
{
word refCellName = field.name() + "RefCell";
word refPointName = field.name() + "RefPoint";
word refValueName = field.name() + "RefValue";
if (dict.found(refCellName))
{
if (Pstream::master())
{
refCelli = readLabel(dict.lookup(refCellName));
if (refCelli < 0 || refCelli >= field.mesh().nCells())
{
FatalIOErrorIn
(
"void Foam::setRefCell\n"
"(\n"
" const volScalarField&,\n"
" const volScalarField&,\n"
" const dictionary&,\n"
" label& scalar&,\n"
" bool\n"
")",
dict
) << "Illegal master cellID " << refCelli
<< ". Should be 0.." << field.mesh().nCells()
<< exit(FatalIOError);
}
}
else
{
refCelli = -1;
}
}
else if (dict.found(refPointName))
{
point refPointi(dict.lookup(refPointName));
refCelli = field.mesh().findCell(refPointi);
label hasRef = (refCelli >= 0 ? 1 : 0);
label sumHasRef = returnReduce<label>(hasRef, sumOp<label>());
if (sumHasRef != 1)
{
FatalIOErrorIn
(
"void Foam::setRefCell\n"
"(\n"
" const volScalarField&,\n"
" const volScalarField&,\n"
" const dictionary&,\n"
" label& scalar&,\n"
" bool\n"
")",
dict
) << "Unable to set reference cell for field " << field.name()
<< nl << " Reference point " << refPointName
<< " " << refPointi
<< " found on " << sumHasRef << " domains (should be one)"
<< nl << exit(FatalIOError);
}
}
else
{
FatalIOErrorIn
(
"void Foam::setRefCell\n"
"(\n"
" const volScalarField&,\n"
" const volScalarField&,\n"
" const dictionary&,\n"
" label& scalar&,\n"
" bool\n"
")",
dict
) << "Unable to set reference cell for field " << field.name()
<< nl
<< " Please supply either " << refCellName
<< " or " << refPointName << nl << exit(FatalIOError);
}
refValue = readScalar(dict.lookup(refValueName));
}
}
void thixotropicViscosity::correct
(
const volScalarField& p,
const volScalarField& T
)
{
const kinematicSingleLayer& film = filmType<kinematicSingleLayer>();
const volVectorField& U = film.U();
const volVectorField& Uw = film.Uw();
const volScalarField& delta = film.delta();
const volScalarField& deltaRho = film.deltaRho();
const surfaceScalarField& phi = film.phi();
const volScalarField& alpha = film.alpha();
const Time& runTime = this->film().regionMesh().time();
// Shear rate
const volScalarField gDot
(
"gDot",
alpha*mag(U - Uw)/(delta + film.deltaSmall())
);
if (debug && runTime.writeTime())
{
gDot.write();
}
const dimensionedScalar deltaRho0
(
"deltaRho0",
deltaRho.dimensions(),
rootVSmall
);
const surfaceScalarField phiU(phi/fvc::interpolate(deltaRho + deltaRho0));
const dimensionedScalar c0("c0", dimless/dimTime, rootVSmall);
const volScalarField coeff("coeff", -c_*pow(gDot, d_) + c0);
fvScalarMatrix lambdaEqn
(
fvm::ddt(lambda_)
+ fvm::div(phiU, lambda_)
- fvm::Sp(fvc::div(phiU), lambda_)
==
a_*pow((1 - lambda_), b_)
+ fvm::SuSp(coeff, lambda_)
// Include the effect of the impinging droplets added with lambda = 0
- fvm::Sp
(
max
(
-film.rhoSp(),
dimensionedScalar(film.rhoSp().dimensions(), 0)
)/(deltaRho + deltaRho0),
lambda_
)
);
lambdaEqn.relax();
lambdaEqn.solve();
lambda_.min(1);
lambda_.max(0);
mu_ = muInf_/(sqr(1 - K_*lambda_) + rootVSmall);
mu_.correctBoundaryConditions();
}
Foam::capillarityModels::pcVanGenuchten::pcVanGenuchten
(
const word& name,
const dictionary& transportProperties,
const volScalarField& Sb
)
:
capillarityModel(name, transportProperties,Sb),
pcVanGenuchtenCoeffs_(transportProperties.subDict(typeName + "Coeffs")),
Smin_
(
IOobject
(
Sb_.name()+"min",
Sb_.time().timeName(),
Sb_.db(),
IOobject::READ_IF_PRESENT,
IOobject::NO_WRITE
),
Sb.mesh(),
transportProperties.lookupOrDefault(Sb_.name()+"min",dimensionedScalar(Sb_.name()+"min",dimless,0))
),
Smax_
(
IOobject
(
Sb_.name()+"max",
Sb_.time().timeName(),
Sb_.db(),
IOobject::READ_IF_PRESENT,
IOobject::NO_WRITE
),
Sb.mesh(),
transportProperties.lookupOrDefault(Sb_.name()+"max",dimensionedScalar(Sb_.name()+"max",dimless,0))
),
m_
(
IOobject
(
"m",
Sb_.time().timeName(),
Sb_.db(),
IOobject::READ_IF_PRESENT,
IOobject::NO_WRITE
),
Sb.mesh(),
dimensionedScalar("m",dimless,pcVanGenuchtenCoeffs_.lookupOrDefault<scalar>("m",0))
),
n_(1/(1-m_)),
alpha_ // necessary for Richards solver
(
IOobject
(
"alpha",
Sb_.time().timeName(),
Sb_.db(),
IOobject::READ_IF_PRESENT,
IOobject::NO_WRITE
),
Sb.mesh(),
dimensionedScalar("alpha",dimless,pcVanGenuchtenCoeffs_.lookupOrDefault<scalar>("alpha",0))
),
pc0_
(
IOobject
(
"pc0",
Sb_.time().timeName(),
Sb_.db(),
IOobject::READ_IF_PRESENT,
IOobject::NO_WRITE
),
Sb.mesh(),
pcVanGenuchtenCoeffs_.lookupOrDefault("pc0",dimensionedScalar("pc0",dimensionSet(1,-1,-2,0,0),0.))
),
Se_((Sb_- Smin_)/(Smax_-Smin_))
{
if (gMin(m_) == 0) FatalErrorIn("Foam::capillarityModels::pcVanGenuchten::pcVanGenuchten") << "m = 0 in pcVanGenuchten" << abort(FatalError);
Info << "Van Genuchten parameters for capillary pressure model" << nl << "{" << endl;
Info << " m ";
if (m_.headerOk()) { Info << "read file" << endl;}
else {Info << average(m_).value() << endl;}
Info << " pc0 ";
if (pc0_.headerOk()) { Info << "read file" << endl;}
else {Info << average(pc0_).value() << endl;}
Info << " alpha ";
if (alpha_.headerOk()) { Info << "read file" << endl;}
else {Info << average(alpha_).value() << endl;}
Info << " Smin ";
if (Smin_.headerOk()) { Info << "read file" << endl;}
else {Info << average(Smin_).value() << endl;}
Info << " Smax ";
if (Smax_.headerOk()) { Info << "read file" << endl;}
else {Info << average(Smax_).value() << endl;}
Info << "} \n" << endl;
}
void Foam::MULES::explicitSolve
(
const RhoType& rho,
volScalarField& psi,
const surfaceScalarField& phi,
surfaceScalarField& phiPsi,
const SpType& Sp,
const SuType& Su,
const scalar psiMax,
const scalar psiMin
)
{
Info<< "MULES: Solving for " << psi.name() << endl;
const fvMesh& mesh = psi.mesh();
psi.correctBoundaryConditions();
surfaceScalarField phiBD(upwind<scalar>(psi.mesh(), phi).flux(psi));
surfaceScalarField& phiCorr = phiPsi;
phiCorr -= phiBD;
scalarField allLambda(mesh.nFaces(), 1.0);
slicedSurfaceScalarField lambda
(
IOobject
(
"lambda",
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
mesh,
dimless,
allLambda,
false // Use slices for the couples
);
limiter
(
allLambda,
rho,
psi,
phiBD,
phiCorr,
Sp,
Su,
psiMax,
psiMin,
3
);
phiPsi = phiBD + lambda*phiCorr;
scalarField& psiIf = psi;
const scalarField& psi0 = psi.oldTime();
const scalar deltaT = mesh.time().deltaTValue();
psiIf = 0.0;
fvc::surfaceIntegrate(psiIf, phiPsi);
if (mesh.moving())
{
psiIf =
(
mesh.Vsc0()().field()*rho.oldTime().field()
*psi0/(deltaT*mesh.Vsc()().field())
+ Su.field()
- psiIf
)/(rho.field()/deltaT - Sp.field());
}
else
{
psiIf =
(
rho.oldTime().field()*psi0/deltaT
+ Su.field()
- psiIf
)/(rho.field()/deltaT - Sp.field());
}
psi.correctBoundaryConditions();
}
int main(int argc, char *argv[])
{
timeSelector::addOptions();
#include "setRootCase.H"
#include "createTime.H"
instantList timeDirs = timeSelector::select0(runTime, args);
#include "createMesh.H"
#include "createFields.H"
forAll(timeDirs, timeI)
{
runTime.setTime(timeDirs[timeI], timeI);
Info<< "Time = " << runTime.timeName() << endl;
// Cache the turbulence fields
Info<< "\nRetrieving field k from turbulence model" << endl;
const volScalarField k = RASModel->k();
Info<< "\nRetrieving field epsilon from turbulence model" << endl;
const volScalarField epsilon = RASModel->epsilon();
Info<< "\nRetrieving field R from turbulence model" << endl;
const volSymmTensorField R = RASModel->R();
// Check availability of tubulence fields
if (!IOobject("k", runTime.timeName(), mesh).headerOk())
{
Info<< "\nWriting turbulence field k" << endl;
k.write();
}
else
{
Info<< "\nTurbulence k field already exists" << endl;
}
if (!IOobject("epsilon", runTime.timeName(), mesh).headerOk())
{
Info<< "\nWriting turbulence field epsilon" << endl;
epsilon.write();
}
else
{
Info<< "\nTurbulence epsilon field already exists" << endl;
}
if (!IOobject("R", runTime.timeName(), mesh).headerOk())
{
Info<< "\nWriting turbulence field R" << endl;
R.write();
}
else
{
Info<< "\nTurbulence R field already exists" << endl;
}
if (!IOobject("omega", runTime.timeName(), mesh).headerOk())
{
const scalar Cmu = 0.09;
Info<< "creating omega" << endl;
volScalarField omega
(
IOobject
(
"omega",
runTime.timeName(),
mesh
),
epsilon/(Cmu*k),
epsilon.boundaryField().types()
);
Info<< "\nWriting turbulence field omega" << endl;
omega.write();
}
else
{
Info<< "\nTurbulence omega field already exists" << endl;
}
}
void Foam::MULES::limiter
(
scalarField& allLambda,
const RdeltaTType& rDeltaT,
const RhoType& rho,
const volScalarField& psi,
const surfaceScalarField& phiBD,
const surfaceScalarField& phiCorr,
const SpType& Sp,
const SuType& Su,
const scalar psiMax,
const scalar psiMin
)
{
const scalarField& psiIf = psi;
const volScalarField::GeometricBoundaryField& psiBf = psi.boundaryField();
const fvMesh& mesh = psi.mesh();
const dictionary& MULEScontrols = mesh.solverDict(psi.name());
label nLimiterIter
(
MULEScontrols.lookupOrDefault<label>("nLimiterIter", 3)
);
scalar smoothLimiter
(
MULEScontrols.lookupOrDefault<scalar>("smoothLimiter", 0)
);
const scalarField& psi0 = psi.oldTime();
const labelUList& owner = mesh.owner();
const labelUList& neighb = mesh.neighbour();
tmp<volScalarField::DimensionedInternalField> tVsc = mesh.Vsc();
const scalarField& V = tVsc();
const scalarField& phiBDIf = phiBD;
const surfaceScalarField::GeometricBoundaryField& phiBDBf =
phiBD.boundaryField();
const scalarField& phiCorrIf = phiCorr;
const surfaceScalarField::GeometricBoundaryField& phiCorrBf =
phiCorr.boundaryField();
slicedSurfaceScalarField lambda
(
IOobject
(
"lambda",
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
mesh,
dimless,
allLambda,
false // Use slices for the couples
);
scalarField& lambdaIf = lambda;
surfaceScalarField::GeometricBoundaryField& lambdaBf =
lambda.boundaryField();
scalarField psiMaxn(psiIf.size(), psiMin);
scalarField psiMinn(psiIf.size(), psiMax);
scalarField sumPhiBD(psiIf.size(), 0.0);
scalarField sumPhip(psiIf.size(), VSMALL);
scalarField mSumPhim(psiIf.size(), VSMALL);
forAll(phiCorrIf, facei)
{
label own = owner[facei];
label nei = neighb[facei];
psiMaxn[own] = max(psiMaxn[own], psiIf[nei]);
psiMinn[own] = min(psiMinn[own], psiIf[nei]);
psiMaxn[nei] = max(psiMaxn[nei], psiIf[own]);
psiMinn[nei] = min(psiMinn[nei], psiIf[own]);
sumPhiBD[own] += phiBDIf[facei];
sumPhiBD[nei] -= phiBDIf[facei];
scalar phiCorrf = phiCorrIf[facei];
if (phiCorrf > 0.0)
{
sumPhip[own] += phiCorrf;
mSumPhim[nei] += phiCorrf;
}
else
{
mSumPhim[own] -= phiCorrf;
sumPhip[nei] -= phiCorrf;
}
}
Foam::KinematicCloud<CloudType>::KinematicCloud
(
const word& cloudName,
const volScalarField& rho,
const volVectorField& U,
const volScalarField& mu,
const dimensionedVector& g,
bool readFields
)
:
CloudType(rho.mesh(), cloudName, false),
kinematicCloud(),
cloudCopyPtr_(NULL),
mesh_(rho.mesh()),
particleProperties_
(
IOobject
(
cloudName + "Properties",
rho.mesh().time().constant(),
rho.mesh(),
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
),
solution_(mesh_, particleProperties_.subDict("solution")),
constProps_(particleProperties_, solution_.active()),
subModelProperties_
(
particleProperties_.subOrEmptyDict("subModels", solution_.active())
),
rndGen_
(
label(0),
solution_.steadyState() ?
particleProperties_.lookupOrDefault<label>("randomSampleSize", 100000)
: -1
),
cellOccupancyPtr_(),
rho_(rho),
U_(U),
mu_(mu),
g_(g),
pAmbient_(0.0),
forces_
(
*this,
mesh_,
subModelProperties_.subOrEmptyDict
(
"particleForces",
solution_.active()
),
solution_.active()
),
functions_
(
*this,
particleProperties_.subOrEmptyDict("cloudFunctions"),
solution_.active()
),
dispersionModel_(NULL),
injectionModel_(NULL),
patchInteractionModel_(NULL),
surfaceFilmModel_(NULL),
UIntegrator_(NULL),
UTrans_
(
new DimensionedField<vector, volMesh>
(
IOobject
(
this->name() + "UTrans",
this->db().time().timeName(),
this->db(),
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
mesh_,
dimensionedVector("zero", dimMass*dimVelocity, vector::zero)
)
),
UCoeff_
(
new DimensionedField<scalar, volMesh>
(
IOobject
(
this->name() + "UCoeff",
this->db().time().timeName(),
this->db(),
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
mesh_,
dimensionedScalar("zero", dimMass, 0.0)
)
)
{
if (solution_.active())
{
setModels();
if (readFields)
{
parcelType::readFields(*this);
}
}
if (solution_.resetSourcesOnStartup())
{
resetSourceTerms();
}
}
bool Foam::cfdemCloud::evolve
(
volScalarField& alpha,
volVectorField& Us,
volVectorField& U
)
{
numberOfParticlesChanged_ = false;
arraysReallocated_=false;
bool doCouple=false;
if(!ignore())
{
if (dataExchangeM().couple())
{
Info << "\n Coupling..." << endl;
doCouple=true;
// reset vol Fields
clockM().start(16,"resetVolFields");
if(verbose_)
{
Info << "couplingStep:" << dataExchangeM().couplingStep()
<< "\n- resetVolFields()" << endl;
}
averagingM().resetVectorAverage(averagingM().UsPrev(),averagingM().UsNext());
voidFractionM().resetVoidFractions();
averagingM().resetVectorAverage(forceM(0).impParticleForces(),forceM(0).impParticleForces(),true);
averagingM().resetVectorAverage(forceM(0).expParticleForces(),forceM(0).expParticleForces(),true);
averagingM().resetWeightFields();
for (int i=0;i<momCoupleModels_.size(); i++)
momCoupleM(i).resetMomSourceField();
if(verbose_) Info << "resetVolFields done." << endl;
clockM().stop("resetVolFields");
if(verbose_) Info << "- getDEMdata()" << endl;
clockM().start(17,"getDEMdata");
getDEMdata();
clockM().stop("getDEMdata");
if(verbose_) Info << "- getDEMdata done." << endl;
// search cellID of particles
clockM().start(18,"findCell");
if(verbose_) Info << "- findCell()" << endl;
findCells();
if(verbose_) Info << "findCell done." << endl;
clockM().stop("findCell");
// set void fraction field
clockM().start(19,"setvoidFraction");
if(verbose_) Info << "- setvoidFraction()" << endl;
voidFractionM().setvoidFraction(NULL,voidfractions_,particleWeights_,particleVolumes_);
if(verbose_) Info << "setvoidFraction done." << endl;
clockM().stop("setvoidFraction");
// set particles velocity field
clockM().start(20,"setVectorAverage");
setVectorAverages();
clockM().stop("setVectorAverage");
// set particles forces
clockM().start(21,"setForce");
if(verbose_) Info << "- setForce(forces_)" << endl;
setForces();
if(verbose_) Info << "setForce done." << endl;
clockM().stop("setForce");
// get next force field
clockM().start(22,"setParticleForceField");
if(verbose_) Info << "- setParticleForceField()" << endl;
averagingM().setVectorSum
(
forceM(0).impParticleForces(),
impForces_,
particleWeights_,
NULL //mask
);
averagingM().setVectorSum
(
forceM(0).expParticleForces(),
expForces_,
particleWeights_,
NULL //mask
);
if(verbose_) Info << "- setParticleForceField done." << endl;
clockM().stop("setParticleForceField");
// write DEM data
if(verbose_) Info << " -giveDEMdata()" << endl;
clockM().start(23,"giveDEMdata");
giveDEMdata();
clockM().stop("giveDEMdata");
}//end dataExchangeM().couple()
Info << "\n timeStepFraction() = " << dataExchangeM().timeStepFraction() << endl;
clockM().start(24,"interpolateEulerFields");
// update smoothing model
smoothingM().dSmoothing();
//============================================
// update voidFractionField V1
alpha = voidFractionM().voidFractionInterp();
smoothingM().smoothen(alpha);
if(dataExchangeM().couplingStep() < 2)
{
alpha.oldTime() = alpha; // supress volume src
alpha.oldTime().correctBoundaryConditions();
}
alpha.correctBoundaryConditions();
// calc ddt(voidfraction)
//calcDdtVoidfraction(voidFractionM().voidFractionNext());
calcDdtVoidfraction(alpha);
// update particle velocity Field
Us = averagingM().UsInterp();
//smoothingM().smoothenReferenceField(Us);
Us.correctBoundaryConditions();
/*//============================================
// update voidFractionField
volScalarField oldAlpha = alpha.oldTime(); //save old (smooth) alpha field
alpha.oldTime().internalField() = voidFractionM().voidFractionInterp();
smoothingM().smoothen(alpha);
alpha.correctBoundaryConditions();
alpha.oldTime() = oldAlpha; //set old (smooth) alpha field to allow correct computation of ddt
// calc ddt(voidfraction)
if (doCouple) calcDdtVoidfraction(alpha);
//calcDdtVoidfraction(alpha); // alternative with scale=1! (does not see change in alpha?)
// update particle velocity Field
Us.oldTime().internalField() = averagingM().UsInterp();
smoothingM().smoothenReferenceField(Us);
Us.correctBoundaryConditions();
//============================================*/
clockM().stop("interpolateEulerFields");
if(verbose_){
#include "debugInfo.H"
}
clockM().start(25,"dumpDEMdata");
// do particle IO
IOM().dumpDEMdata();
clockM().stop("dumpDEMdata");
}//end ignore
return doCouple;
}
void Foam::MULES::implicitSolve
(
const RhoType& rho,
volScalarField& psi,
const surfaceScalarField& phi,
surfaceScalarField& phiPsi,
const SpType& Sp,
const SuType& Su,
const scalar psiMax,
const scalar psiMin
)
{
const fvMesh& mesh = psi.mesh();
const dictionary& MULEScontrols = mesh.solverDict(psi.name());
label maxIter
(
readLabel(MULEScontrols.lookup("maxIter"))
);
label nLimiterIter
(
readLabel(MULEScontrols.lookup("nLimiterIter"))
);
scalar maxUnboundedness
(
readScalar(MULEScontrols.lookup("maxUnboundedness"))
);
scalar CoCoeff
(
readScalar(MULEScontrols.lookup("CoCoeff"))
);
scalarField allCoLambda(mesh.nFaces());
{
tmp<surfaceScalarField> Cof =
mesh.time().deltaT()*mesh.surfaceInterpolation::deltaCoeffs()
*mag(phi)/mesh.magSf();
slicedSurfaceScalarField CoLambda
(
IOobject
(
"CoLambda",
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
mesh,
dimless,
allCoLambda,
false // Use slices for the couples
);
CoLambda == 1.0/max(CoCoeff*Cof, scalar(1));
}
scalarField allLambda(allCoLambda);
//scalarField allLambda(mesh.nFaces(), 1.0);
slicedSurfaceScalarField lambda
(
IOobject
(
"lambda",
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
mesh,
dimless,
allLambda,
false // Use slices for the couples
);
linear<scalar> CDs(mesh);
upwind<scalar> UDs(mesh, phi);
//fv::uncorrectedSnGrad<scalar> snGrads(mesh);
fvScalarMatrix psiConvectionDiffusion
(
fvm::ddt(rho, psi)
+ fv::gaussConvectionScheme<scalar>(mesh, phi, UDs).fvmDiv(phi, psi)
//- fv::gaussLaplacianScheme<scalar, scalar>(mesh, CDs, snGrads)
//.fvmLaplacian(Dpsif, psi)
- fvm::Sp(Sp, psi)
- Su
);
surfaceScalarField phiBD(psiConvectionDiffusion.flux());
surfaceScalarField& phiCorr = phiPsi;
phiCorr -= phiBD;
for (label i=0; i<maxIter; i++)
{
if (i != 0 && i < 4)
{
allLambda = allCoLambda;
}
limiter
(
allLambda,
rho,
psi,
phiBD,
phiCorr,
Sp,
Su,
psiMax,
psiMin,
nLimiterIter
);
solve
(
psiConvectionDiffusion + fvc::div(lambda*phiCorr),
MULEScontrols
);
scalar maxPsiM1 = gMax(psi.internalField()) - 1.0;
scalar minPsi = gMin(psi.internalField());
scalar unboundedness = max(max(maxPsiM1, 0.0), -min(minPsi, 0.0));
if (unboundedness < maxUnboundedness)
{
break;
}
else
{
Info<< "MULES: max(" << psi.name() << " - 1) = " << maxPsiM1
<< " min(" << psi.name() << ") = " << minPsi << endl;
phiBD = psiConvectionDiffusion.flux();
/*
word gammaScheme("div(phi,gamma)");
word gammarScheme("div(phirb,gamma)");
const surfaceScalarField& phir =
mesh.lookupObject<surfaceScalarField>("phir");
phiCorr =
fvc::flux
(
phi,
psi,
gammaScheme
)
+ fvc::flux
(
-fvc::flux(-phir, scalar(1) - psi, gammarScheme),
psi,
gammarScheme
)
- phiBD;
*/
}
}
phiPsi = psiConvectionDiffusion.flux() + lambda*phiCorr;
}
