autoPtr<polyIntegrator> polyIntegrator::New
(
Time& t,
polyMoleculeCloud& molCloud,
const dictionary& dict
)
{
word polyIntegratorName = "velocityVerlet";
if(dict.found("integrator"))
{
const word polyIntegratorNameTemp
(
dict.lookup("integrator")
);
polyIntegratorName = polyIntegratorNameTemp;
}
Info<< "Selecting polyIntegrator "
<< polyIntegratorName << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(polyIntegratorName);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalError
<< "polyIntegrator::New(const dictionary&) : " << endl
<< " unknown polyIntegrator type "
<< polyIntegratorName
<< ", constructor not in hash table" << endl << endl
<< " Valid types are :" << endl;
Info<< dictionaryConstructorTablePtr_->toc() << abort(FatalError);
}
return autoPtr<polyIntegrator>
(
cstrIter()(t, molCloud, dict)
);
}
Foam::fvPatchField<Type>::fvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict,
const bool valueRequired
)
:
Field<Type>(p.size()),
patch_(p),
internalField_(iF),
updated_(false),
patchType_(dict.lookupOrDefault<word>("patchType", word::null))
{
if (dict.found("value"))
{
fvPatchField<Type>::operator=
(
Field<Type>("value", dict, p.size())
);
}
else if (!valueRequired)
{
fvPatchField<Type>::operator=(pTraits<Type>::zero);
}
else
{
FatalIOErrorIn
(
"fvPatchField<Type>::fvPatchField"
"("
"const fvPatch& p,"
"const DimensionedField<Type, volMesh>& iF,"
"const dictionary& dict,"
"const bool valueRequired"
")",
dict
) << "Essential entry 'value' missing"
<< exit(FatalIOError);
}
}
Foam::myVelocityFvPatchVectorField::
myVelocityFvPatchVectorField
(
const fvPatch& u,
const DimensionedField<vector, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchVectorField(u, iF)
{
// Info << "myVelocity-Konstructor 3" << endl;
// fvPatchVectorField::operator=(alpha*patch().nf());
if (dict.found("value"))
{
Info << "found" << endl;
fixedValueFvPatchField<vector>::operator==
(
Field<vector>("value", dict, u.size())
);
}
}
Foam::energyJumpFvPatchScalarField::energyJumpFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
fixedJumpFvPatchField<scalar>(p, iF)
{
if (dict.found("value"))
{
fvPatchScalarField::operator=
(
scalargpuField("value", dict, p.size())
);
}
else
{
evaluate(Pstream::blocking);
}
}
solidBodyMotionDisplacementPointPatchVectorField::
solidBodyMotionDisplacementPointPatchVectorField
(
const pointPatch& p,
const DimensionedField<vector, pointMesh>& iF,
const dictionary& dict
)
:
fixedValuePointPatchVectorField(p, iF, dict, false),
SBMFPtr_(solidBodyMotionFunction::New(dict, this->db().time()))
{
if (!dict.found("value"))
{
// Determine current local points and offset
fixedValuePointPatchVectorField::operator==
(
transformPoints(SBMFPtr_().transformation(), localPoints0())
-localPoints0()
);
}
}
Foam::RBD::rigidBodyMotion::rigidBodyMotion
(
const dictionary& dict
)
:
rigidBodyModel(dict),
motionState_(*this, dict),
motionState0_(motionState_),
X00_(X0_.size()),
aRelax_(dict.lookupOrDefault<scalar>("accelerationRelaxation", 1.0)),
aDamp_(dict.lookupOrDefault<scalar>("accelerationDamping", 1.0)),
report_(dict.lookupOrDefault<Switch>("report", false)),
solver_(rigidBodySolver::New(*this, dict.subDict("solver")))
{
if (dict.found("g"))
{
g() = vector(dict.lookup("g"));
}
initialize();
}
Foam::backwardDiffusionFvPatchScalarField::backwardDiffusionFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
mixedUserDefinedFvPatchScalarField(p, iF)
{
// Name of field
nameInternal_ = dimensionedInternalField().name();
// Set the nominal value
omega0() = scalarField("omega0", dict, p.size());
rho0() = scalarField("rho0", dict, p.size());
// Fixed value condition is forced
alfa() = 1000.;
eta() = 1.;
// Calculating epsilon
epsilon() = 0;
// Calculating beta
const double Dmix = 1e-10;
beta() = Dmix*this->patch().deltaCoeffs();
// Read value if available
if (dict.found("value"))
{
fvPatchField<scalar>::operator=
(
scalarField("value", dict, p.size())
);
}
else
{
evaluate();
}
}
Foam::activePressureForceBaffleVelocityFvPatchVectorField::
activePressureForceBaffleVelocityFvPatchVectorField
(
const fvPatch& p,
const DimensionedField<vector, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchVectorField(p, iF),
pName_(dict.lookupOrDefault<word>("p", "p")),
cyclicPatchName_(dict.lookup("cyclicPatch")),
cyclicPatchLabel_(p.patch().boundaryMesh().findPatchID(cyclicPatchName_)),
orientation_(readLabel(dict.lookup("orientation"))),
initWallSf_(0),
initCyclicSf_(0),
nbrCyclicSf_(0),
openFraction_(readScalar(dict.lookup("openFraction"))),
openingTime_(readScalar(dict.lookup("openingTime"))),
maxOpenFractionDelta_(readScalar(dict.lookup("maxOpenFractionDelta"))),
curTimeIndex_(-1),
minThresholdValue_(readScalar(dict.lookup("minThresholdValue"))),
fBased_(readBool(dict.lookup("forceBased"))),
baffleActivated_(0)
{
fvPatchVectorField::operator=(vector::zero);
if (p.size() > 0)
{
initWallSf_ = p.Sf();
initCyclicSf_ = p.boundaryMesh()[cyclicPatchLabel_].Sf();
nbrCyclicSf_ = refCast<const cyclicFvPatch>
(
p.boundaryMesh()[cyclicPatchLabel_]
).neighbFvPatch().Sf();
}
if (dict.found("p"))
{
dict.lookup("p") >> pName_;
}
void Foam::addGlobalVariable::read(const dictionary& dict)
{
if(dict.found("globalVariables")) {
const dictionary variables(dict.subDict("globalVariables"));
const word scope(dict.lookup("globalScope"));
wordList names(variables.toc());
forAll(names,i) {
const word &name=names[i];
const dictionary &dict=variables.subDict(name);
ExpressionResult &res=GlobalVariablesRepository::getGlobalVariables(
obr_
).addValue(
name,
scope,
ExpressionResult(dict,true,true),
false
);
res.noReset();
}
} else {
Foam::temperatureDirectedInletOutletVelocityFvPatchVectorField::
temperatureDirectedInletOutletVelocityFvPatchVectorField
(
const fvPatch& p,
const DimensionedField<vector, volMesh>& iF,
const dictionary& dict
)
:
mixedFvPatchVectorField(p, iF),
phiName_("phi"),
TName_("T"),
T0_("T0", dict, p.size()),
inletDir_("inletDirection", dict, p.size()),
cylindricalCCS_(dict.lookup("cylindricalCCS")),
omega_(dict.lookup("omega"))
{
fvPatchVectorField::operator=(vectorField("value", dict, p.size()));
if (dict.found("phi"))
{
dict.lookup("phi") >> phiName_;
}
Foam::wavyFilmHeightFvPatchScalarField::wavyFilmHeightFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchScalarField(p, iF),
mean_(DataEntry<scalar>::New("mean", dict)),
a_(DataEntry<scalar>::New("a", dict)),
omega_(DataEntry<scalar>::New("omega", dict))
{
if (dict.found("value"))
{
fvPatchScalarField::operator=(scalarField("value", dict, p.size()));
}
else
{
const scalar t = db().time().timeOutputValue();
fvPatchScalarField::operator=(mean_->value(t));
}
}
Foam::wordList Foam::functionObjects::forces::createFileNames
(
const dictionary& dict
) const
{
DynamicList<word> names(1);
const word forceType(dict.lookup("type"));
names.append(forceType);
if (dict.found("binData"))
{
const dictionary& binDict(dict.subDict("binData"));
label nb = readLabel(binDict.lookup("nBin"));
if (nb > 0)
{
names.append(forceType + "_bins");
}
}
return names;
}
Foam::radiation::greyDiffusiveRadiationMixedFvPatchScalarField::
greyDiffusiveRadiationMixedFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
mixedFvPatchScalarField(p, iF),
TName_(dict.lookup("T")),
emissivity_(readScalar(dict.lookup("emissivity")))
{
if (dict.found("refValue"))
{
fvPatchScalarField::operator=
(
scalarField("value", dict, p.size())
);
refValue() = scalarField("refValue", dict, p.size());
refGrad() = scalarField("refGradient", dict, p.size());
valueFraction() = scalarField("valueFraction", dict, p.size());
}
else
{
// No value given. Restart as fixedValue b.c.
const scalarField& Tp =
patch().lookupPatchField<volScalarField, scalar>(TName_);
refValue() =
emissivity_*4.0*radiation::sigmaSB.value()*pow4(Tp)
/Foam::mathematicalConstant::pi;
refGrad() = 0.0;
valueFraction() = 1.0;
fvPatchScalarField::operator=(refValue());
}
}
groovyBCCommon<Type>::groovyBCCommon
(
const dictionary& dict,
bool hasGradient,
bool isPoint,
string fractionExpression
)
:
evaluateDuringConstruction_(
dict.lookupOrDefault<bool>("evaluateDuringConstruction",false)
),
debug_(dict.lookupOrDefault<bool>("debug",false)),
hasGradient_(hasGradient),
fractionExpression_(dict.lookupOrDefault(
"fractionExpression",
isPoint ? string("toPoint("+fractionExpression+")") : string(fractionExpression))
)
{
if (dict.found("valueExpression"))
{
dict.lookup("valueExpression") >> valueExpression_;
} else {
Foam::alphaContactAngleFvPatchScalarField::alphaContactAngleFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
fixedGradientFvPatchScalarField(p, iF),
limit_(limitControlNames_.read(dict.lookup("limit")))
{
if (dict.found("gradient"))
{
gradient() = scalarField("gradient", dict, p.size());
fixedGradientFvPatchScalarField::updateCoeffs();
fixedGradientFvPatchScalarField::evaluate();
}
else
{
fvPatchField<scalar>::operator=(patchInternalField());
gradient() = 0.0;
}
}
void Foam::sixDoFRigidBodyMotion::addRestraints
(
const dictionary& dict
)
{
if (dict.found("restraints"))
{
const dictionary& restraintDict = dict.subDict("restraints");
label i = 0;
restraints_.setSize(restraintDict.size());
restraintNames_.setSize(restraintDict.size());
forAllConstIter(IDLList<entry>, restraintDict, iter)
{
if (iter().isDict())
{
// Info<< "Adding restraint: " << iter().keyword() << endl;
restraints_.set
(
i,
sixDoFRigidBodyMotionRestraint::New(iter().dict())
);
restraintNames_[i] = iter().keyword();
i++;
}
}
restraints_.setSize(i);
restraintNames_.setSize(i);
}
}
Foam::valuePointPatchField<Type>::valuePointPatchField
(
const pointPatch& p,
const DimensionedField<Type, pointMesh>& iF,
const dictionary& dict,
const bool valueRequired
)
:
pointPatchField<Type>(p, iF, dict),
Field<Type>(p.size())
{
if (dict.found("value"))
{
Field<Type>::operator=
(
Field<Type>("value", dict, p.size())
);
}
else if (!valueRequired)
{
Field<Type>::operator=(pTraits<Type>::zero);
}
else
{
FatalIOErrorIn
(
"pointPatchField<Type>::pointPatchField"
"("
"const fvPatch& p,"
"const DimensionedField<Type, pointMesh>& iF,"
"const dictionary& dict,"
"const bool valueRequired"
")",
dict
) << "Essential entry 'value' missing"
<< exit(FatalIOError);
}
}
faePatchField<Type>::faePatchField
(
const faPatch& p,
const DimensionedField<Type, edgeMesh>& iF,
const dictionary& dict
)
:
Field<Type>(p.size()),
patch_(p),
internalField_(iF)
{
if (dict.found("value"))
{
faePatchField<Type>::operator=
(
Field<Type>("value", dict, p.size())
);
}
else
{
faePatchField<Type>::operator=(pTraits<Type>::zero);
}
}
void polyStateController::updateStateControllerProperties
(
const dictionary& newDict
)
{
// controllerDict_ = newDict.subDict("controllerProperties");
//- you can reset the controlling zone from here. This essentially
// means that the coupling zone can infact move arbitrarily. To make
// this happen we probably need to devise a technique for automatically
// changing the cellZone else where, and then calling this function to
// reset the controlling zone in which the controller operates in.
if (newDict.found("control"))
{
control_ = Switch(newDict.lookup("control"));
}
/*
if (newDict.found("readStateFromFile"))
{
readStateFromFile_ = Switch(newDict.lookup("readStateFromFile"));
}*/
}
Foam::myPressureFvPatchScalarField::
myPressureFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
//fixedValueFvPatchScalarField(p, iF, dict),
fixedValueFvPatchScalarField(p, iF)//,
// alpha("alpha", dict, p.size())
{
// Info << "myPressure-Constructor 3" << endl;
//fvPatchScalarField::operator=(alpha*patch().nf());
if (dict.found("value"))
{
Info << "found" << endl;
fixedValueFvPatchField<scalar>::operator==
(
Field<scalar>("value", dict, p.size())
);
}
}
Foam::alphaFixedPressureFvPatchScalarField::
alphaFixedPressureFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchScalarField(p, iF),
p_("p", dict, p.size())
{
if (dict.found("value"))
{
fvPatchField<scalar>::operator=
(
scalarField("value", dict, p.size())
);
}
else
{
fvPatchField<scalar>::operator=(p_);
}
}
Foam::plenumPressureFvPatchScalarField::plenumPressureFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchScalarField(p, iF),
gamma_(readScalar(dict.lookup("gamma"))),
R_(readScalar(dict.lookup("R"))),
supplyMassFlowRate_(readScalar(dict.lookup("supplyMassFlowRate"))),
supplyTotalTemperature_
(
readScalar(dict.lookup("supplyTotalTemperature"))
),
plenumVolume_(readScalar(dict.lookup("plenumVolume"))),
plenumDensity_(readScalar(dict.lookup("plenumDensity"))),
plenumTemperature_(readScalar(dict.lookup("plenumTemperature"))),
rho_(1.0),
hasRho_(false),
inletAreaRatio_(readScalar(dict.lookup("inletAreaRatio"))),
inletDischargeCoefficient_
(
readScalar(dict.lookup("inletDischargeCoefficient"))
),
timeScale_(dict.lookupOrDefault<scalar>("timeScale", 0.0)),
phiName_(dict.lookupOrDefault<word>("phi", "phi")),
UName_(dict.lookupOrDefault<word>("U", "U"))
{
fvPatchScalarField::operator=(scalarField("value", dict, p.size()));
if (dict.found("rho"))
{
rho_ = readScalar(dict.lookup("rho"));
hasRho_ = true;
}
}
void Foam::coordinateSystem::operator=(const dictionary& rhs)
{
if (debug)
{
Pout<< "coordinateSystem::operator=(const dictionary&) : "
<< "assign from " << rhs << endl;
}
// allow as embedded sub-dictionary "coordinateSystem"
const dictionary& dict =
(
rhs.found(typeName_())
? rhs.subDict(typeName_())
: rhs
);
// unspecified origin is (0 0 0)
origin_ = point::zero;
dict.readIfPresent("origin", origin_);
// The note entry is optional
note_.clear();
rhs.readIfPresent("note", note_);
// specify via coordinateRotation sub-dictionary
if (dict.found("coordinateRotation"))
{
R_ = coordinateRotation::New(dict.subDict("coordinateRotation"))();
}
else
{
// let coordinateRotation constructor extract the axes specification
R_ = coordinateRotation(dict);
}
Rtr_ = R_.T();
}
Foam::sampledPlane::sampledPlane
(
const word& name,
const polyMesh& mesh,
const dictionary& dict
)
:
sampledSurface(name, mesh, dict),
cuttingPlane(plane(dict.lookup("basePoint"), dict.lookup("normalVector"))),
zoneName_(word::null),
needsUpdate_(true)
{
// make plane relative to the coordinateSystem (Cartesian)
// allow lookup from global coordinate systems
if (dict.found("coordinateSystem"))
{
coordinateSystem cs(dict, mesh);
point base = cs.globalPosition(planeDesc().refPoint());
vector norm = cs.globalVector(planeDesc().normal());
// assign the plane description
static_cast<plane&>(*this) = plane(base, norm);
}
dict.readIfPresent("zone", zoneName_);
if (debug && zoneName_.size())
{
if (mesh.cellZones().findZoneID(zoneName_) < 0)
{
Info<< "cellZone \"" << zoneName_
<< "\" not found - using entire mesh" << endl;
}
}
}
Foam::codedFixedValuePointPatchField<Type>::codedFixedValuePointPatchField
(
const pointPatch& p,
const DimensionedField<Type, pointMesh>& iF,
const dictionary& dict,
const bool valueRequired
)
:
fixedValuePointPatchField<Type>(p, iF, dict, valueRequired),
codedBase(),
dict_(dict),
name_
(
dict.found("redirectType")
? dict.lookup("redirectType")
: dict.lookup("name")
),
redirectPatchFieldPtr_()
{
// Compilation options
context_.addFilterVariable(false, dict, "codeOptions");
context_.addFilterVariable(false, dict, "codeLibs");
// From looking through the fixedValuePointPatchFieldTemplate*[CH] :
context_.addFilterVariables
(
dynamicCode::resolveTemplate(codeTemplateC),
dict
);
context_.addFilterVariables
(
dynamicCode::resolveTemplate(codeTemplateH),
dict
);
updateLibrary(name_, context_);
}
regionCouplingFvPatchField<Type>::regionCouplingFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
coupledFvPatchField<Type>(p, iF, dict),
regionCouplePatch_(refCast<const regionCoupleFvPatch>(p)),
remoteFieldName_(dict.lookup("remoteField")),
matrixUpdateBuffer_(),
originalPatchField_(),
curTimeIndex_(-1)
{
if (!isType<regionCoupleFvPatch>(p))
{
FatalIOErrorIn
(
"regionCouplingFvPatchField<Type>::regionCouplingFvPatchField\n"
"(\n"
" const fvPatch& p,\n"
" const DimensionedField<Type, volMesh>& iF,\n"
" const dictionary& dict\n"
")\n",
dict
) << "patch " << this->patch().index() << " not regionCouple type. "
<< "Patch type = " << p.type()
<< exit(FatalIOError);
}
if (!dict.found("value"))
{
// Grab the internal value for initialisation. (?) HJ, 27/Feb/2009
fvPatchField<Type>::operator=(this->patchInternalField()());
}
}
Foam::varyingGammaTotalTemperatureFvPatchScalarField::varyingGammaTotalTemperatureFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchScalarField(p, iF),
UName_(dict.lookupOrDefault<word>("U", "U")),
phiName_(dict.lookupOrDefault<word>("phi", "phi")),
T0_("T0", dict, p.size())
{
if (dict.found("value"))
{
fvPatchField<scalar>::operator=
(
scalarField("value", dict, p.size())
);
}
else
{
fvPatchField<scalar>::operator=(T0_);
}
}
uniformFixedValuePointPatchField<Type>::
uniformFixedValuePointPatchField
(
const pointPatch& p,
const DimensionedField<Type, pointMesh>& iF,
const dictionary& dict
)
:
fixedValuePointPatchField<Type>(p, iF, dict, false),
uniformValue_(DataEntry<Type>::New("uniformValue", dict))
{
if (dict.found("value"))
{
fixedValuePointPatchField<Type>::operator==
(
Field<Type>("value", dict, p.size())
);
}
else
{
const scalar t = this->db().time().timeOutputValue();
fixedValuePointPatchField<Type>::operator=(uniformValue_->value(t));
}
}
timeVaryingMappedFixedValueFvPatchField<Type>::
timeVaryingMappedFixedValueFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchField<Type>(p, iF),
setAverage_(readBool(dict.lookup("setAverage"))),
referenceCS_(NULL),
nearestVertex_(0),
nearestVertexWeight_(0),
sampleTimes_(0),
startSampleTime_(-1),
startSampledValues_(0),
startAverage_(pTraits<Type>::zero),
endSampleTime_(-1),
endSampledValues_(0),
endAverage_(pTraits<Type>::zero)
{
if (debug)
{
Pout<< "timeVaryingMappedFixedValue : construct from dictionary"
<< endl;
}
if (dict.found("value"))
{
fvPatchField<Type>::operator==(Field<Type>("value", dict, p.size()));
}
else
{
updateCoeffs();
}
}
Foam::timeVaryingUniformInletOutletFvPatchField<Type>::
timeVaryingUniformInletOutletFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
inletOutletFvPatchField<Type>(p, iF),
timeSeries_(dict)
{
this->refValue() = timeSeries_(this->db().time().timeOutputValue());
this->refGrad() = pTraits<Type>::zero;
this->valueFraction() = 0.0;
if (dict.found("value"))
{
fvPatchField<Type>::operator==(Field<Type>("value", dict, p.size()));
}
else
{
fvPatchField<Type>::operator=(this->refValue());
}
}
