Foam::autoPtr<Foam::IncompressibleTurbulenceModel<TransportModel> >
Foam::IncompressibleTurbulenceModel<TransportModel>::New
(
const volVectorField& U,
const surfaceScalarField& phi,
const TransportModel& transportModel,
const word& propertiesName
)
{
return autoPtr<IncompressibleTurbulenceModel>
(
static_cast<IncompressibleTurbulenceModel*>(
TurbulenceModel
<
geometricOneField,
geometricOneField,
incompressibleTurbulenceModel,
TransportModel
>::New
(
geometricOneField(),
geometricOneField(),
U,
phi,
phi,
transportModel,
propertiesName
).ptr())
);
}
PDRkEpsilon::PDRkEpsilon
(
const geometricOneField& alpha,
const volScalarField& rho,
const volVectorField& U,
const surfaceScalarField& alphaRhoPhi,
const surfaceScalarField& phi,
const fluidThermo& thermophysicalModel,
const word& turbulenceModelName,
const word& modelName
)
:
Foam::RASModels::kEpsilon<EddyDiffusivity<compressible::turbulenceModel>>
(
geometricOneField(),
rho,
U,
phi,
phi,
thermophysicalModel,
turbulenceModelName,
modelName
),
C4_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C4",
coeffDict_,
0.1
)
)
{}
void Foam::porosityZone::addResistance
(
const fvVectorMatrix& UEqn,
volTensorField& AU,
bool correctAUprocBC
) const
{
if (cellZoneID_ == -1)
{
return;
}
bool compressible = false;
if (UEqn.dimensions() == dimensionSet(1, 1, -2, 0, 0))
{
compressible = true;
}
const labelList& cells = mesh_.cellZones()[cellZoneID_];
const vectorField& U = UEqn.psi();
const tensor& D = D_.value();
const tensor& F = F_.value();
if (magSqr(D) > VSMALL || magSqr(F) > VSMALL)
{
if (compressible)
{
addViscousInertialResistance
(
AU,
cells,
mesh_.lookupObject<volScalarField>("rho"),
mesh_.lookupObject<volScalarField>("mu"),
U
);
}
else
{
addViscousInertialResistance
(
AU,
cells,
geometricOneField(),
mesh_.lookupObject<volScalarField>("nu"),
U
);
}
}
if (correctAUprocBC)
{
// Correct the boundary conditions of the tensorial diagonal to ensure
// processor boundaries are correctly handled when AU^-1 is interpolated
// for the pressure equation.
AU.correctBoundaryConditions();
}
}
autoPtr<BasicCompressibleTurbulenceModel> New
(
const volVectorField& U,
const surfaceScalarField& phi,
const typename BasicCompressibleTurbulenceModel::transportModel&
transport,
const word& propertiesName
)
{
return BasicCompressibleTurbulenceModel::New
(
geometricOneField(),
geometricOneField(),
U,
phi,
phi,
transport,
propertiesName
);
}
void Foam::porosityZone::addResistance(fvVectorMatrix& UEqn) const
{
if (cellZoneID_ == -1)
{
return;
}
bool compressible = false;
if (UEqn.dimensions() == dimensionSet(1, 1, -2, 0, 0))
{
compressible = true;
}
const labelList& cells = mesh_.cellZones()[cellZoneID_];
const scalarField& V = mesh_.V();
scalarField& Udiag = UEqn.diag();
vectorField& Usource = UEqn.source();
const vectorField& U = UEqn.psi();
const tensor& D = D_.value();
const tensor& F = F_.value();
if (magSqr(D) > VSMALL || magSqr(F) > VSMALL)
{
if (compressible)
{
addViscousInertialResistance
(
Udiag,
Usource,
cells,
V,
mesh_.lookupObject<volScalarField>("rho"),
mesh_.lookupObject<volScalarField>("mu"),
U
);
}
else
{
addViscousInertialResistance
(
Udiag,
Usource,
cells,
V,
geometricOneField(),
mesh_.lookupObject<volScalarField>("nu"),
U
);
}
}
}
void Foam::MULES::LTScorrect
(
volScalarField& psi,
const surfaceScalarField& phi,
surfaceScalarField& phiPsiCorr,
const scalar psiMax,
const scalar psiMin
)
{
LTScorrect
(
geometricOneField(),
psi,
phi,
phiPsiCorr,
zeroField(), zeroField(),
psiMax, psiMin
);
}
void Foam::MULES::implicitSolve
(
volScalarField& psi,
const surfaceScalarField& phi,
surfaceScalarField& phiPsi,
const scalar psiMax,
const scalar psiMin
)
{
implicitSolve
(
geometricOneField(),
psi,
phi,
phiPsi,
zeroField(), zeroField(),
psiMax, psiMin
);
}
void Foam::porosityModels::powerLaw::correct
(
const fvVectorMatrix& UEqn,
volTensorField& AU
) const
{
const vectorField& U = UEqn.psi();
if (UEqn.dimensions() == dimForce)
{
const volScalarField& rho =
mesh_.lookupObject<volScalarField>(rhoName_);
apply(AU, rho, U);
}
else
{
apply(AU, geometricOneField(), U);
}
}
void Foam::actuationDiskSource::addSu(fvMatrix<vector>& UEqn)
{
if (cellZoneID_ == -1)
{
return;
}
bool compressible = false;
if (UEqn.dimensions() == dimensionSet(1, 1, -2, 0, 0))
{
compressible = true;
}
const labelList& cells = mesh_.cellZones()[cellZoneID_];
const scalarField& V = this->mesh().V();
vectorField& Usource = UEqn.source();
const vectorField& U = UEqn.psi();
if (compressible)
{
addActuationDiskAxialInertialResistance
(
Usource,
cells,
V,
this->mesh().lookupObject<volScalarField>("rho"),
U
);
}
else
{
addActuationDiskAxialInertialResistance
(
Usource,
cells,
V,
geometricOneField(),
U
);
}
}
void Foam::porosityModels::powerLaw::correct
(
fvVectorMatrix& UEqn
) const
{
const vectorField& U = UEqn.psi();
const scalarField& V = mesh_.V();
scalarField& Udiag = UEqn.diag();
if (UEqn.dimensions() == dimForce)
{
const volScalarField& rho =
mesh_.lookupObject<volScalarField>(rhoName_);
apply(Udiag, V, rho, U);
}
else
{
apply(Udiag, V, geometricOneField(), U);
}
}
void Foam::porosityModels::solidification::apply
(
tensorField& AU,
const RhoFieldType& rho,
const volVectorField& U
) const
{
if (alphaName_ == "none")
{
return apply(AU, geometricOneField(), rho, U);
}
else
{
const volScalarField& alpha = mesh_.lookupObject<volScalarField>
(
IOobject::groupName(alphaName_, U.group())
);
return apply(AU, alpha, rho, U);
}
}
void Foam::actuationDiskSource::addSu(fvMatrix<vector>& UEqn)
{
bool compressible = false;
if (UEqn.dimensions() == dimensionSet(1, 1, -2, 0, 0))
{
compressible = true;
}
const scalarField& cellsV = this->mesh().V();
vectorField& Usource = UEqn.source();
const vectorField& U = UEqn.psi();
if (V() > VSMALL)
{
if (compressible)
{
addActuationDiskAxialInertialResistance
(
Usource,
cells_,
cellsV,
this->mesh().lookupObject<volScalarField>("rho"),
U
);
}
else
{
addActuationDiskAxialInertialResistance
(
Usource,
cells_,
cellsV,
geometricOneField(),
U
);
}
}
}
