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()); } }