standardRadiation::standardRadiation
(
surfaceFilmModel& owner,
const dictionary& dict
)
:
filmRadiationModel(typeName, owner, dict),
QinPrimary_
(
IOobject
(
"Qin", // same name as Qin on primary region to enable mapping
owner.time().timeName(),
owner.regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
owner.regionMesh(),
dimensionedScalar("zero", dimMass/pow3(dimTime), 0.0),
owner.mappedPushedFieldPatchTypes<scalar>()
),
delta_(owner.delta()),
beta_(readScalar(coeffDict_.lookup("beta"))),
kappaBar_(readScalar(coeffDict_.lookup("kappaBar")))
{}
thixotropicViscosity::thixotropicViscosity
(
surfaceFilmModel& owner,
const dictionary& dict,
volScalarField& mu
)
:
filmViscosityModel(typeName, owner, dict, mu),
a_("a", dimless/dimTime, coeffDict_),
b_("b", dimless, coeffDict_),
d_("d", dimless, coeffDict_),
c_("c", pow(dimTime, d_.value() - scalar(1)), coeffDict_),
mu0_("mu0", dimPressure*dimTime, coeffDict_),
muInf_("muInf", mu0_.dimensions(), coeffDict_),
K_(1.0 - Foam::sqrt(muInf_/mu0_)),
lambda_
(
IOobject
(
typeName + ":lambda",
owner.regionMesh().time().timeName(),
owner.regionMesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
owner.regionMesh()
)
{
lambda_.min(1.0);
lambda_.max(0.0);
// Initialise viscosity to inf value because it cannot be evaluated yet
mu_ = muInf_;
mu_.correctBoundaryConditions();
}
standardRadiation::standardRadiation
(
const surfaceFilmModel& owner,
const dictionary& dict
)
:
filmRadiationModel(typeName, owner, dict),
QrPrimary_
(
IOobject
(
//pqr "Qr", // (net radiation) same name as Qr on primary region to enable mapping
"Qin", // (incident radiation) same name as Qr on primary region to enable mapping
owner.time().timeName(),
owner.regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
owner.regionMesh(),
dimensionedScalar("zero", dimMass/pow3(dimTime), 0.0),
owner.mappedPushedFieldPatchTypes<scalar>()
),
QrNet_
(
IOobject
(
"QrNet",
owner.time().timeName(),
owner.regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
owner.regionMesh(),
dimensionedScalar("zero", dimMass/pow3(dimTime), 0.0),
zeroGradientFvPatchScalarField::typeName
),
/*QrFilm_ is used for diagnostics*/
QrFilm_
(
IOobject
(
"QrFilm",
owner.time().timeName(),
owner.regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
owner.regionMesh(),
dimensionedScalar("zero", dimMass/pow3(dimTime), 0.0),
zeroGradientFvPatchScalarField::typeName
),
delta_(owner.delta()),
deltaMin_(readScalar(coeffs_.lookup("deltaMin"))),
beta_(readScalar(coeffs_.lookup("beta"))),
kappaBar_(readScalar(coeffs_.lookup("kappaBar")))
{}
thixotropicViscosity::thixotropicViscosity
(
surfaceFilmModel& owner,
const dictionary& dict,
volScalarField& mu
)
:
filmViscosityModel(typeName, owner, dict, mu),
a_(coeffDict_.lookup("a")),
b_(coeffDict_.lookup("b")),
c_(coeffDict_.lookup("c")),
d_(coeffDict_.lookup("d")),
mu0_(coeffDict_.lookup("mu0")),
muInf_(coeffDict_.lookup("muInf")),
K_(1.0 - Foam::sqrt(muInf_/mu0_)),
lambda_
(
IOobject
(
typeName + ":lambda",
owner.regionMesh().time().timeName(),
owner.regionMesh(),
IOobject::MUST_READ_IF_MODIFIED,
IOobject::AUTO_WRITE
),
owner.regionMesh()
)
{
lambda_.min(1.0);
lambda_.max(0.0);
// initialise viscosity to inf value
// - cannot call updateMu() since this calls film.netMass() which
// cannot be evaluated yet (still in construction)
mu_ = muInf_;
mu_.correctBoundaryConditions();
}
filmSubModelBase::filmSubModelBase
(
const word& modelName,
surfaceFilmModel& owner,
const dictionary& dict,
const word& baseName,
const word& modelType
)
:
subModelBase
(
modelName,
owner.outputProperties(),
dict,
baseName,
modelType
),
owner_(owner)
{}
mappedConvectiveHeatTransfer::mappedConvectiveHeatTransfer
(
surfaceFilmModel& owner,
const dictionary& dict
)
:
heatTransferModel(owner),
htcConvPrimary_
(
IOobject
(
"htcConv",
owner.time().timeName(),
owner.primaryMesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
owner.primaryMesh()
),
htcConvFilm_
(
IOobject
(
htcConvPrimary_.name(), // must have same name as above for mapping
owner.time().timeName(),
owner.regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
owner.regionMesh(),
dimensionedScalar("zero", dimMass/pow3(dimTime)/dimTemperature, 0.0),
owner.mappedPushedFieldPatchTypes<scalar>()
)
{
// Update the primary-side convective heat transfer coefficient
htcConvPrimary_.correctBoundaryConditions();
// Pull the data from the primary region via direct mapped BCs
htcConvFilm_.correctBoundaryConditions();
}
constantRadiation::constantRadiation
(
surfaceFilmModel& owner,
const dictionary& dict
)
:
filmRadiationModel(typeName, owner, dict),
QrConst_
(
IOobject
(
typeName + ":QrConst",
owner.time().timeName(),
owner.regionMesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
owner.regionMesh()
),
mask_
(
IOobject
(
typeName + ":mask",
owner.time().timeName(),
owner.regionMesh(),
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
owner.regionMesh(),
dimensionedScalar("one", dimless, 1.0)
),
absorptivity_(readScalar(coeffDict_.lookup("absorptivity"))),
timeStart_(readScalar(coeffDict_.lookup("timeStart"))),
duration_(readScalar(coeffDict_.lookup("duration")))
{
mask_ = pos(mask_);
}
filmSubModelBase::filmSubModelBase(surfaceFilmModel& owner)
:
subModelBase(owner.outputProperties()),
owner_(owner)
{}
rampingRadiation::rampingRadiation
(
const surfaceFilmModel& owner,
const dictionary& dict
)
:
filmRadiationModel(typeName, owner, dict),
QrConst_
(
IOobject
(
typeName + "_QrConst",
owner.time().timeName(),
owner.regionMesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
owner.regionMesh()
),
mask_
(
IOobject
(
typeName + "_mask",
owner.time().timeName(),
owner.regionMesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
owner.regionMesh()//,
// dimensionedScalar("one", dimless, 1.0)//,
// zeroGradientFvPatchScalarField::typeName
),
absorptivity_(readScalar(coeffs_.lookup("absorptivity"))),
// initialValue_(readScalar(coeffs_.lookup("initialValue"))),
rampTimeInterval_(readScalar(coeffs_.lookup("rampTimeInterval"))),
rampStep_(readScalar(coeffs_.lookup("rampStep"))),
rampStartTime_(0.0),
Qin_
(
IOobject
(
"Qin", // same name as Qin on primary region to enable mapping
owner.time().timeName(),
owner.regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
owner.regionMesh(),
dimensionedScalar("zero", dimMass/pow3(dimTime), 0.0),
zeroGradientFvPatchScalarField::typeName
),
timeStart_(readScalar(coeffs_.lookup("timeStart"))),
duration_(readScalar(coeffs_.lookup("duration")))
{
mask_ = pos(mask_ - 0.5);
rampStartTime_=max(timeStart_,owner.time().value());
// for non-uniform heat flux (2d parabolic profile)
// forAll(QrConst_,cellI){
// scalar x=owner.regionMesh().cellCentres()[cellI][0];
// scalar y=owner.regionMesh().cellCentres()[cellI][1];
// scalar xCenter = 0.255;
// scalar yCenter = 0.605;
// QrConst_[cellI] = (-26.02*pow(x-xCenter,2)-25.94*pow(y-yCenter,2)+54.98)*1e3;
// }
}
