Foam::tmp<Foam::volScalarField>
Foam::populationBalanceSubModels::growthModels::constantGrowth::Kg
(
const volScalarField& abscissa
) const
{
dimensionedScalar minAbs
(
"minAbs",
abscissa.dimensions(),
minAbscissa_.value()
);
dimensionedScalar maxAbs
(
"maxAbs",
abscissa.dimensions(),
maxAbscissa_.value()
);
dimensionedScalar CgND
(
"CgND",
inv(abscissa.dimensions())*inv(abscissa.dimensions())*Cg_.dimensions(),
Cg_.value()
);
return CgND*pos(-abscissa+maxAbs)*pos(abscissa-minAbs);
}
tmp<typename steadyStateDdtScheme<Type>::fluxFieldType>
steadyStateDdtScheme<Type>::fvcDdtPhiCorr
(
const volScalarField& rA,
const volScalarField& rho,
const GeometricField<Type, fvPatchField, volMesh>& U,
const fluxFieldType& phi
)
{
return tmp<fluxFieldType>
(
new fluxFieldType
(
IOobject
(
"ddtPhiCorr("
+ rA.name() + ',' + rho.name()
+ ',' + U.name() + ',' + phi.name() + ')',
mesh().time().timeName(),
mesh()
),
mesh(),
dimensioned<typename flux<Type>::type>
(
"0",
rA.dimensions()*rho.dimensions()*phi.dimensions()/dimTime,
pTraits<typename flux<Type>::type>::zero
)
)
);
}
tmp<volScalarField> SpalartAllmarasDDES<BasicTurbulenceModel>::rd
(
const volScalarField& magGradU
) const
{
tmp<volScalarField> tr
(
min
(
this->nuEff()
/(
max
(
magGradU,
dimensionedScalar("SMALL", magGradU.dimensions(), SMALL)
)
*sqr(this->kappa_*this->y_)
),
scalar(10)
)
);
tr.ref().boundaryField() == 0.0;
return tr;
}
tmp<volScalarField> SpalartAllmarasIDDES::rd
(
const volScalarField& visc,
const volScalarField& S
) const
{
return min
(
visc
/(
max
(
S,
dimensionedScalar("SMALL", S.dimensions(), SMALL)
)*sqr(kappa_*y_)
+ dimensionedScalar
(
"ROOTVSMALL",
dimensionSet(0, 2 , -1, 0, 0),
ROOTVSMALL
)
),
scalar(10)
);
}
tmp<GeometricField<Type, fvPatchField, volMesh>>
steadyStateD2dt2Scheme<Type>::fvcD2dt2
(
const volScalarField& rho,
const GeometricField<Type, fvPatchField, volMesh>& vf
)
{
return tmp<GeometricField<Type, fvPatchField, volMesh>>
(
new GeometricField<Type, fvPatchField, volMesh>
(
IOobject
(
"d2dt2("+rho.name()+','+vf.name()+')',
mesh().time().timeName(),
mesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh(),
dimensioned<Type>
(
"0",
rho.dimensions()*vf.dimensions()/dimTime/dimTime,
Zero
)
)
);
}
tmp<GeometricField<Type, fvPatchField, volMesh> >
steadyStateDdtScheme<Type>::fvcDdt
(
const volScalarField& rho,
const GeometricField<Type, fvPatchField, volMesh>& vf
)
{
return tmp<GeometricField<Type, fvPatchField, volMesh> >
(
new GeometricField<Type, fvPatchField, volMesh>
(
IOobject
(
"ddt("+rho.name()+','+vf.name()+')',
mesh().time().timeName(),
mesh()
),
mesh(),
dimensioned<Type>
(
"0",
rho.dimensions()*vf.dimensions()/dimTime,
pTraits<Type>::zero
)
)
);
}
Foam::tmp<Foam::volScalarField> Foam::functionObjects::pressureTools::rho
(
const volScalarField& p
) const
{
if (p.dimensions() == dimPressure)
{
return p.mesh().lookupObject<volScalarField>(rhoName_);
}
else
{
return
tmp<volScalarField>
(
new volScalarField
(
IOobject
(
"rho",
p.mesh().time().timeName(),
p.mesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
p.mesh(),
dimensionedScalar("zero", dimDensity, rhoInf_)
)
);
}
}
tmp<GeometricField<Type, fvPatchField, volMesh> >
EulerLocalDdtScheme<Type>::fvcDdt
(
const volScalarField& rho,
const GeometricField<Type, fvPatchField, volMesh>& vf
)
{
const objectRegistry& registry = this->mesh();
// get access to the scalar beta[i]
const scalarField& beta =
registry.lookupObject<scalarField>(deltaTName_);
volScalarField rDeltaT =
1.0/(beta[0]*registry.lookupObject<volScalarField>(deltaTauName_));
IOobject ddtIOobject
(
"ddt("+rho.name()+','+vf.name()+')',
mesh().time().timeName(),
mesh()
);
if (mesh().moving())
{
return tmp<GeometricField<Type, fvPatchField, volMesh> >
(
new GeometricField<Type, fvPatchField, volMesh>
(
ddtIOobject,
mesh(),
rDeltaT.dimensions()*rho.dimensions()*vf.dimensions(),
rDeltaT.internalField()*
(
rho.internalField()*vf.internalField()
- rho.oldTime().internalField()
*vf.oldTime().internalField()*mesh().V0()/mesh().V()
),
rDeltaT.boundaryField()*
(
rho.boundaryField()*vf.boundaryField()
- rho.oldTime().boundaryField()
*vf.oldTime().boundaryField()
)
)
);
}
else
{
return tmp<GeometricField<Type, fvPatchField, volMesh> >
(
new GeometricField<Type, fvPatchField, volMesh>
(
ddtIOobject,
rDeltaT*(rho*vf - rho.oldTime()*vf.oldTime())
)
);
}
}
tmp<typename EulerLocalDdtScheme<Type>::fluxFieldType>
EulerLocalDdtScheme<Type>::fvcDdtPhiCorr
(
const volScalarField& rA,
const GeometricField<Type, fvPatchField, volMesh>& U,
const fluxFieldType& phi
)
{
IOobject ddtIOobject
(
"ddtPhiCorr(" + rA.name() + ',' + U.name() + ',' + phi.name() + ')',
mesh().time().timeName(),
mesh()
);
if (mesh().moving())
{
return tmp<fluxFieldType>
(
new fluxFieldType
(
ddtIOobject,
mesh(),
dimensioned<typename flux<Type>::type>
(
"0",
rA.dimensions()*phi.dimensions()/dimTime,
pTraits<typename flux<Type>::type>::zero
)
)
);
}
else
{
const objectRegistry& registry = this->mesh();
// get access to the scalar beta[i]
const scalarField& beta =
registry.lookupObject<scalarField>(deltaTName_);
volScalarField rDeltaT =
1.0/(beta[0]*registry.lookupObject<volScalarField>(deltaTauName_));
return tmp<fluxFieldType>
(
new fluxFieldType
(
ddtIOobject,
fvcDdtPhiCoeff(U.oldTime(), phi.oldTime())*
(
fvc::interpolate(rDeltaT*rA)*phi.oldTime()
- (fvc::interpolate(rDeltaT*rA*U.oldTime()) & mesh().Sf())
)
)
);
}
}
Foam::tmp<Foam::fvScalarMatrix> Foam::combustionModel::R
(
volScalarField& Y
) const
{
return tmp<fvScalarMatrix>
(
new fvScalarMatrix(Y, dimMass/dimTime*Y.dimensions())
);
}
Foam::dimensionedScalar Foam::functionObjects::pressureTools::rhoScale
(
const volScalarField& p
) const
{
if (p.dimensions() == dimPressure)
{
return dimensionedScalar("1", dimless, 1.0);
}
else
{
return dimensionedScalar("rhoRef", dimDensity, rhoInf_);
}
}
Foam::tmp<Foam::volScalarField>
Foam::populationBalanceSubModels::breakupKernels::exponentialBreakup::Kb
(
const volScalarField& abscissa
) const
{
dimensionedScalar minAbs
(
"minAbs",
abscissa.dimensions(),
minAbscissa_.value()
);
return Cb_*pos(abscissa - minAbs)*exp(expCoeff_*pow3(abscissa));
}
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;
}
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_;
}
}
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;
}
tmp<fvMatrix<Type> >
EulerLocalDdtScheme<Type>::fvmDdt
(
const volScalarField& rho,
GeometricField<Type, fvPatchField, volMesh>& vf
)
{
const objectRegistry& registry = this->mesh();
// get access to the scalar beta[i]
const scalarField& beta =
registry.lookupObject<scalarField>(deltaTName_);
tmp<fvMatrix<Type> > tfvm
(
new fvMatrix<Type>
(
vf,
rho.dimensions()*vf.dimensions()*dimVol/dimTime
)
);
fvMatrix<Type>& fvm = tfvm();
scalarField rDeltaT =
1.0/(beta[0]*registry.lookupObject<volScalarField>(deltaTauName_).internalField());
fvm.diag() = rDeltaT*rho.internalField()*mesh().V();
if (mesh().moving())
{
fvm.source() = rDeltaT
*rho.oldTime().internalField()
*vf.oldTime().internalField()*mesh().V0();
}
else
{
fvm.source() = rDeltaT
*rho.oldTime().internalField()
*vf.oldTime().internalField()*mesh().V();
}
return tfvm;
}
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)
);
}
tmp<typename EulerLocalDdtScheme<Type>::fluxFieldType>
EulerLocalDdtScheme<Type>::fvcDdtPhiCorr
(
const volScalarField& rA,
const volScalarField& rho,
const GeometricField<Type, fvPatchField, volMesh>& U,
const fluxFieldType& phi
)
{
IOobject ddtIOobject
(
"ddtPhiCorr("
+ rA.name() + ',' + rho.name() + ',' + U.name() + ',' + phi.name() + ')',
mesh().time().timeName(),
mesh()
);
if (mesh().moving())
{
return tmp<fluxFieldType>
(
new fluxFieldType
(
ddtIOobject,
mesh(),
dimensioned<typename flux<Type>::type>
(
"0",
rA.dimensions()*phi.dimensions()/dimTime,
pTraits<typename flux<Type>::type>::zero
)
)
);
}
else
{
const objectRegistry& registry = this->mesh();
// get access to the scalar beta[i]
const scalarField& beta =
registry.lookupObject<scalarField>(deltaTName_);
volScalarField rDeltaT =
1.0/(beta[0]*registry.lookupObject<volScalarField>(deltaTauName_));
if
(
U.dimensions() == dimVelocity
&& phi.dimensions() == dimVelocity*dimArea
)
{
return tmp<fluxFieldType>
(
new fluxFieldType
(
ddtIOobject,
fvcDdtPhiCoeff(U.oldTime(), phi.oldTime())
*(
fvc::interpolate(rDeltaT*rA*rho.oldTime())*phi.oldTime()
- (fvc::interpolate(rDeltaT*rA*rho.oldTime()*U.oldTime())
& mesh().Sf())
)
)
);
}
else if
(
U.dimensions() == dimVelocity
&& phi.dimensions() == dimDensity*dimVelocity*dimArea
)
{
return tmp<fluxFieldType>
(
new fluxFieldType
(
ddtIOobject,
fvcDdtPhiCoeff
(
U.oldTime(),
phi.oldTime()/fvc::interpolate(rho.oldTime())
)
*(
fvc::interpolate(rDeltaT*rA*rho.oldTime())
*phi.oldTime()/fvc::interpolate(rho.oldTime())
- (
fvc::interpolate
(
rDeltaT*rA*rho.oldTime()*U.oldTime()
) & mesh().Sf()
)
)
)
);
}
else if
(
U.dimensions() == dimDensity*dimVelocity
&& phi.dimensions() == dimDensity*dimVelocity*dimArea
)
{
return tmp<fluxFieldType>
(
new fluxFieldType
(
ddtIOobject,
fvcDdtPhiCoeff(rho.oldTime(), U.oldTime(), phi.oldTime())
*(
fvc::interpolate(rDeltaT*rA)*phi.oldTime()
- (
fvc::interpolate(rDeltaT*rA*U.oldTime())&mesh().Sf()
)
)
)
);
}
else
{
FatalErrorIn
(
"EulerLocalDdtScheme<Type>::fvcDdtPhiCorr"
) << "dimensions of phi are not correct"
<< abort(FatalError);
return fluxFieldType::null();
}
}
}
Foam::tmp<Foam::fvScalarMatrix>
Foam::diameterModels::IATEsources::wallBoiling::R
(
const volScalarField& alphai,
volScalarField& kappai
) const
{
volScalarField::Internal R
(
IOobject
(
"wallBoiling:R",
phase().time().timeName(),
phase().mesh()
),
phase().mesh(),
dimensionedScalar("R", dimless/dimTime, 0)
);
volScalarField::Internal Rdk
(
IOobject
(
"wallBoiling:Rdk",
phase().time().timeName(),
phase().mesh()
),
phase().mesh(),
dimensionedScalar("Rdk", kappai.dimensions()/dimTime, 0)
);
const phaseCompressibleTurbulenceModel& turbulence =
phase().db().lookupObjectRef<phaseCompressibleTurbulenceModel>
(
IOobject::groupName
(
turbulenceModel::propertiesName,
otherPhase().name()
)
);
const tmp<volScalarField> talphat(turbulence.alphat());
const volScalarField::Boundary& alphatBf = talphat().boundaryField();
const scalarField& rho = phase().rho();
typedef compressible::alphatWallBoilingWallFunctionFvPatchScalarField
alphatWallBoilingWallFunction;
forAll(alphatBf, patchi)
{
if
(
isA<alphatWallBoilingWallFunction>(alphatBf[patchi])
)
{
const alphatWallBoilingWallFunction& alphatw =
refCast<const alphatWallBoilingWallFunction>(alphatBf[patchi]);
const scalarField& dmdt = alphatw.dmdt();
const scalarField& dDep = alphatw.dDeparture();
const labelList& faceCells = alphatw.patch().faceCells();
forAll(alphatw, facei)
{
if (dmdt[facei] > SMALL)
{
const label faceCelli = faceCells[facei];
R[faceCelli] =
dmdt[facei]/(alphai[faceCelli]*rho[faceCelli]);
Rdk[faceCelli] = R[faceCelli]*(6.0/dDep[facei]);
}
}
}
}
return Rdk - fvm::Sp(R, kappai);
}
tmp<GeometricField<Type, fvPatchField, volMesh>>
EulerD2dt2Scheme<Type>::fvcD2dt2
(
const volScalarField& rho,
const GeometricField<Type, fvPatchField, volMesh>& vf
)
{
dimensionedScalar rDeltaT2 =
4.0/sqr(mesh().time().deltaT() + mesh().time().deltaT0());
IOobject d2dt2IOobject
(
"d2dt2("+rho.name()+','+vf.name()+')',
mesh().time().timeName(),
mesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
);
scalar deltaT = mesh().time().deltaTValue();
scalar deltaT0 = mesh().time().deltaT0Value();
scalar coefft = (deltaT + deltaT0)/(2*deltaT);
scalar coefft00 = (deltaT + deltaT0)/(2*deltaT0);
if (mesh().moving())
{
scalar halfRdeltaT2 = 0.5*rDeltaT2.value();
scalar quarterRdeltaT2 = 0.25*rDeltaT2.value();
const scalarField VV0rhoRho0
(
(mesh().V() + mesh().V0())
* (rho.primitiveField() + rho.oldTime().primitiveField())
);
const scalarField V0V00rho0Rho00
(
(mesh().V0() + mesh().V00())
* (
rho.oldTime().primitiveField()
+ rho.oldTime().oldTime().primitiveField()
)
);
return tmp<GeometricField<Type, fvPatchField, volMesh>>
(
new GeometricField<Type, fvPatchField, volMesh>
(
d2dt2IOobject,
mesh(),
rDeltaT2.dimensions()*rho.dimensions()*vf.dimensions(),
quarterRdeltaT2*
(
coefft*VV0rhoRho0*vf.primitiveField()
- (coefft*VV0rhoRho0 + coefft00*V0V00rho0Rho00)
*vf.oldTime().primitiveField()
+ (coefft00*V0V00rho0Rho00)
*vf.oldTime().oldTime().primitiveField()
)/mesh().V(),
halfRdeltaT2*
(
coefft
*(rho.boundaryField() + rho.oldTime().boundaryField())
*vf.boundaryField()
- (
coefft
*(
rho.boundaryField()
+ rho.oldTime().boundaryField()
)
+ coefft00
*(
rho.oldTime().boundaryField()
+ rho.oldTime().oldTime().boundaryField()
)
)*vf.oldTime().boundaryField()
+ coefft00
*(
rho.oldTime().boundaryField()
+ rho.oldTime().oldTime().boundaryField()
)*vf.oldTime().oldTime().boundaryField()
)
)
);
}
else
{
dimensionedScalar halfRdeltaT2 = 0.5*rDeltaT2;
const volScalarField rhoRho0(rho + rho.oldTime());
const volScalarField rho0Rho00(rho.oldTime() +rho.oldTime().oldTime());
return tmp<GeometricField<Type, fvPatchField, volMesh>>
(
new GeometricField<Type, fvPatchField, volMesh>
(
d2dt2IOobject,
halfRdeltaT2*
(
coefft*rhoRho0*vf
- (coefft*rhoRho0 + coefft00*rho0Rho00)*vf.oldTime()
+ coefft00*rho0Rho00*vf.oldTime().oldTime()
)
)
);
}
}
tmp<fvMatrix<Type>>
EulerD2dt2Scheme<Type>::fvmD2dt2
(
const volScalarField& rho,
const GeometricField<Type, fvPatchField, volMesh>& vf
)
{
tmp<fvMatrix<Type>> tfvm
(
new fvMatrix<Type>
(
vf,
rho.dimensions()*vf.dimensions()*dimVol
/dimTime/dimTime
)
);
fvMatrix<Type>& fvm = tfvm.ref();
scalar deltaT = mesh().time().deltaTValue();
scalar deltaT0 = mesh().time().deltaT0Value();
scalar coefft = (deltaT + deltaT0)/(2*deltaT);
scalar coefft00 = (deltaT + deltaT0)/(2*deltaT0);
scalar rDeltaT2 = 4.0/sqr(deltaT + deltaT0);
if (mesh().moving())
{
scalar quarterRdeltaT2 = 0.25*rDeltaT2;
const scalarField VV0rhoRho0
(
(mesh().V() + mesh().V0())
*(rho.primitiveField() + rho.oldTime().primitiveField())
);
const scalarField V0V00rho0Rho00
(
(mesh().V0() + mesh().V00())
*(
rho.oldTime().primitiveField()
+ rho.oldTime().oldTime().primitiveField()
)
);
fvm.diag() = (coefft*quarterRdeltaT2)*VV0rhoRho0;
fvm.source() = quarterRdeltaT2*
(
(coefft*VV0rhoRho0 + coefft00*V0V00rho0Rho00)
*vf.oldTime().primitiveField()
- (coefft00*V0V00rho0Rho00)
*vf.oldTime().oldTime().primitiveField()
);
}
else
{
scalar halfRdeltaT2 = 0.5*rDeltaT2;
const scalarField rhoRho0
(
rho.primitiveField()
+ rho.oldTime().primitiveField()
);
const scalarField rho0Rho00
(
rho.oldTime().primitiveField()
+ rho.oldTime().oldTime().primitiveField()
);
fvm.diag() = (coefft*halfRdeltaT2)*mesh().V()*rhoRho0;
fvm.source() = halfRdeltaT2*mesh().V()*
(
(coefft*rhoRho0 + coefft00*rho0Rho00)
*vf.oldTime().primitiveField()
- (coefft00*rho0Rho00)
*vf.oldTime().oldTime().primitiveField()
);
}
return tfvm;
}
