Foam::LESModels::PrandtlDelta::PrandtlDelta
(
const word& name,
const turbulenceModel& turbulence,
const dictionary& dict
)
:
LESdelta(name, turbulence),
geometricDelta_
(
LESdelta::New
(
name,
turbulence,
dict.optionalSubDict(type() + "Coeffs")
)
),
kappa_(dict.lookupOrDefault<scalar>("kappa", 0.41)),
Cdelta_
(
dict.optionalSubDict(type() + "Coeffs").lookupOrDefault<scalar>
(
"Cdelta",
0.158
)
)
{
calcDelta();
}
Foam::viscosityModels::strainRateFunction::strainRateFunction
(
const word& name,
const dictionary& viscosityProperties,
const volVectorField& U,
const surfaceScalarField& phi
)
:
viscosityModel(name, viscosityProperties, U, phi),
strainRateFunctionCoeffs_
(
viscosityProperties.optionalSubDict(typeName + "Coeffs")
),
strainRateFunction_
(
Function1<scalar>::New("function", strainRateFunctionCoeffs_)
),
nu_
(
IOobject
(
name,
U_.time().timeName(),
U_.db(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
U_.mesh(),
dimensionedScalar(name, dimViscosity, 0)
)
{
correct();
}
Foam::reactionRateFlameArea::reactionRateFlameArea
(
const word& modelType,
const dictionary& dict,
const fvMesh& mesh,
const combustionModel& combModel
)
:
coeffDict_(dict.optionalSubDict(modelType + "Coeffs")),
mesh_(mesh),
combModel_(combModel),
fuel_(dict.lookup("fuel")),
omega_
(
IOobject
(
"FSDomega",
mesh_.time().timeName(),
mesh_,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh_
)
{}
bool Foam::fv::option::read(const dictionary& dict)
{
dict.readIfPresent("active", active_);
coeffs_ = dict.optionalSubDict(modelType_ + "Coeffs");
return true;
}
Foam::kineticTheoryModels::conductivityModels::HrenyaSinclair::HrenyaSinclair
(
const dictionary& dict
)
:
conductivityModel(dict),
coeffDict_(dict.optionalSubDict(typeName + "Coeffs")),
L_("L", dimensionSet(0, 1, 0, 0, 0), coeffDict_)
{}
void Foam::LESModels::PrandtlDelta::read(const dictionary& dict)
{
const dictionary& coeffDict(dict.optionalSubDict(type() + "Coeffs"));
geometricDelta_().read(coeffDict);
dict.readIfPresent<scalar>("kappa", kappa_);
coeffDict.readIfPresent<scalar>("Cdelta", Cdelta_);
calcDelta();
}
Foam::manualDecomp::manualDecomp(const dictionary& decompositionDict)
:
decompositionMethod(decompositionDict),
decompDataFile_
(
decompositionDict.optionalSubDict
(
word(decompositionDict.lookup("method")) + "Coeffs"
).lookup("dataFile")
)
{}
Foam::CuthillMcKeeRenumber::CuthillMcKeeRenumber(const dictionary& renumberDict)
:
renumberMethod(renumberDict),
reverse_
(
renumberDict.optionalSubDict
(
typeName + "Coeffs"
).lookupOrDefault<Switch>("reverse", false)
)
{}
Foam::radiation::constantAbsorptionEmission::constantAbsorptionEmission
(
const dictionary& dict,
const fvMesh& mesh
)
:
absorptionEmissionModel(dict, mesh),
coeffsDict_(dict.optionalSubDict(typeName + "Coeffs")),
a_(coeffsDict_.lookup("absorptivity")),
e_(coeffsDict_.lookup("emissivity")),
E_(coeffsDict_.lookup("E"))
{}
Foam::solidBodyMotionFunction::solidBodyMotionFunction
(
const dictionary& SBMFCoeffs,
const Time& runTime
)
:
SBMFCoeffs_
(
SBMFCoeffs.optionalSubDict
(
word(SBMFCoeffs.lookup("solidBodyMotionFunction")) + "Coeffs"
)
),
time_(runTime)
{}
Foam::laminarModels::generalizedNewtonianViscosityModels::strainRateFunction::
strainRateFunction
(
const dictionary& viscosityProperties
)
:
generalizedNewtonianViscosityModel(viscosityProperties),
strainRateFunction_
(
Function1<scalar>::New
(
"function",
viscosityProperties.optionalSubDict(typeName + "Coeffs")
)
)
{}
Foam::kineticTheoryModels::frictionalStressModels::JohnsonJackson::
JohnsonJackson
(
const dictionary& dict
)
:
frictionalStressModel(dict),
coeffDict_(dict.optionalSubDict(typeName + "Coeffs")),
Fr_("Fr", dimensionSet(1, -1, -2, 0, 0), coeffDict_),
eta_("eta", dimless, coeffDict_),
p_("p", dimless, coeffDict_),
phi_("phi", dimless, coeffDict_),
alphaDeltaMin_("alphaDeltaMin", dimless, coeffDict_)
{
phi_ *= constant::mathematical::pi/180.0;
}
Foam::fv::option::option
(
const word& name,
const word& modelType,
const dictionary& dict,
const fvMesh& mesh
)
:
name_(name),
modelType_(modelType),
mesh_(mesh),
dict_(dict),
coeffs_(dict.optionalSubDict(modelType + "Coeffs")),
active_(dict_.lookupOrDefault<Switch>("active", true)),
fieldNames_(),
applied_()
{
Info<< incrIndent << indent << "Source: " << name_ << endl << decrIndent;
}
bool Foam::laminarModels::generalizedNewtonianViscosityModels::
strainRateFunction::read
(
const dictionary& viscosityProperties
)
{
generalizedNewtonianViscosityModel::read(viscosityProperties);
strainRateFunction_.clear();
strainRateFunction_ = Function1<scalar>::New
(
"function",
viscosityProperties.optionalSubDict
(
typeName + "Coeffs"
)
);
return true;
}
bool Foam::solidBodyMotionFunction::read(const dictionary& SBMFCoeffs)
{
SBMFCoeffs_ = SBMFCoeffs.optionalSubDict(type() + "Coeffs");
return true;
}
Foam::autoPtr<Foam::liquidProperties> Foam::liquidProperties::New
(
const dictionary& dict
)
{
if (debug)
{
InfoInFunction << "Constructing liquidProperties" << endl;
}
const word& liquidPropertiesTypeName = dict.dictName();
if (dict.found("defaultCoeffs"))
{
// Backward-compatibility
if (Switch(dict.lookup("defaultCoeffs")))
{
return New(liquidPropertiesTypeName);
}
else
{
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(liquidPropertiesTypeName);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorInFunction
<< "Unknown liquidProperties type "
<< liquidPropertiesTypeName << nl << nl
<< "Valid liquidProperties types are:" << nl
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalError);
}
return autoPtr<liquidProperties>
(
cstrIter()
(
dict.optionalSubDict(liquidPropertiesTypeName + "Coeffs")
)
);
}
}
else
{
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(liquidPropertiesTypeName);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorInFunction
<< "Unknown liquidProperties type "
<< liquidPropertiesTypeName << nl << nl
<< "Valid liquidProperties types are:" << nl
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalError);
}
return autoPtr<liquidProperties>(cstrIter()(dict));
}
}
bool Foam::diameterModel::read(const dictionary& phaseProperties)
{
diameterProperties_ = phaseProperties.optionalSubDict(type() + "Coeffs");
return true;
}
