// Construct from components dsmcMixedDiffuseSpecularWallFieldPatch::dsmcMixedDiffuseSpecularWallFieldPatch ( Time& t, const polyMesh& mesh, dsmcCloud& cloud, const dictionary& dict ) : dsmcPatchBoundary(t, mesh, cloud, dict), propsDict_(dict.subDict(typeName + "Properties")), boundaryT_ ( volScalarField ( IOobject ( "boundaryT", mesh_.time().timeName(), mesh_, IOobject::MUST_READ, IOobject::AUTO_WRITE ), mesh_ ) ), boundaryU_ ( volVectorField ( IOobject ( "boundaryU", mesh_.time().timeName(), mesh_, IOobject::MUST_READ, IOobject::AUTO_WRITE ), mesh_ ) ), diffuseFraction_(readScalar(propsDict_.lookup("diffuseFraction"))) { writeInTimeDir_ = false; writeInCase_ = false; measurePropertiesAtWall_ = true; }
Foam::groovyFixedNormalSlipFvPatchField<Type>::groovyFixedNormalSlipFvPatchField ( const fvPatch& p, const DimensionedField<Type, volMesh>& iF, const dictionary& dict ) : fixedNormalSlipFvPatchField<Type>(p, iF), fixedValueExpression_( dict.lookup("fixedValueExpression"), dict ), driver_(dict,this->patch()) { this->evaluate(); }
// Construct from components dsmcField::dsmcField ( Time& t, const polyMesh& mesh, dsmcCloud& cloud, const dictionary& dict ) : mesh_(refCast<const fvMesh>(mesh)), cloud_(cloud), timeDict_(dict.subDict("timeProperties")), time_(t, timeDict_), casePath_(), timePath_() { }
Foam::laminarFlameSpeedModels::Gulders::Gulders ( const dictionary& dict, const hhuCombustionThermo& ct ) : laminarFlameSpeed(dict, ct), coeffsDict_(dict.subDict(typeName + "Coeffs").subDict(fuel_)), W_(readScalar(coeffsDict_.lookup("W"))), eta_(readScalar(coeffsDict_.lookup("eta"))), xi_(readScalar(coeffsDict_.lookup("xi"))), f_(readScalar(coeffsDict_.lookup("f"))), alpha_(readScalar(coeffsDict_.lookup("alpha"))), beta_(readScalar(coeffsDict_.lookup("beta"))) {}
bool Foam::functionObjects::cloudInfo::read(const dictionary& dict) { regionFunctionObject::read(dict); logFiles::resetNames(dict.lookup("clouds")); Info<< type() << " " << name() << ": "; if (names().size()) { Info<< "applying to clouds:" << nl; forAll(names(), i) { Info<< " " << names()[i] << nl; } Info<< endl; }
Foam::liquidProperties::liquidProperties(const dictionary& dict) : W_(readScalar(dict.lookup("W"))), Tc_(readScalar(dict.lookup("Tc"))), Pc_(readScalar(dict.lookup("Pc"))), Vc_(readScalar(dict.lookup("Vc"))), Zc_(readScalar(dict.lookup("Zc"))), Tt_(readScalar(dict.lookup("Tt"))), Pt_(readScalar(dict.lookup("Pt"))), Tb_(readScalar(dict.lookup("Tb"))), dipm_(readScalar(dict.lookup("dipm"))), omega_(readScalar(dict.lookup("omega"))), delta_(readScalar(dict.lookup("delta"))) {}
void texture::clear_cache(const gsgl::string & category) { for (dictionary<texture_cache, string>::iterator cat = textures.iter(); cat.is_valid(); ++cat) { if (category == L"__ALL__" || cat.get_index() == category) { for (texture_cache::iterator i = cat->iter(); i.is_valid(); ++i) { if (i->get_ref_count() > 1) throw runtime_exception(L"Dangling texture '%ls'!", i.get_index()); } cat->clear(); } } } // texture::clear_cache()
Foam::subModelBase::subModelBase ( dictionary& properties, const dictionary& dict, const word& baseName, const word& modelType, const word& dictExt ) : modelName_(word::null), properties_(properties), dict_(dict), baseName_(baseName), modelType_(modelType), coeffDict_(dict.subDict(modelType + dictExt)) {}
Foam::laminarModels::generalizedNewtonianViscosityModels::strainRateFunction:: strainRateFunction ( const dictionary& viscosityProperties ) : generalizedNewtonianViscosityModel(viscosityProperties), strainRateFunction_ ( Function1<scalar>::New ( "function", viscosityProperties.optionalSubDict(typeName + "Coeffs") ) ) {}
// Construct from components reitzKHRT::reitzKHRT ( const dictionary& dict, spray& sm ) : breakupModel(dict, sm), coeffsDict_(dict.subDict(typeName + "Coeffs")), g_(sm.g()), b0_(readScalar(coeffsDict_.lookup("B0"))), b1_(readScalar(coeffsDict_.lookup("B1"))), cTau_(readScalar(coeffsDict_.lookup("Ctau"))), cRT_(readScalar(coeffsDict_.lookup("CRT"))), msLimit_(readScalar(coeffsDict_.lookup("msLimit"))), weberLimit_(readScalar(coeffsDict_.lookup("WeberLimit"))) {}
Foam::SubModelBase<CloudType>::SubModelBase ( CloudType& owner, const dictionary& dict, const word& baseName, const word& modelType, const word& dictExt ) : owner_(owner), dict_(dict), baseName_(baseName), modelType_(modelType), modelName_(word::null), coeffDict_(dict.subDict(modelType + dictExt)) {}
// Construct from components tail::tail ( Time& t, polyMoleculeCloud& molCloud, const dictionary& dict ) : polyStateController(t, molCloud, dict), propsDict_(dict.subDict(typeName + "Properties")), molIds_() { writeInTimeDir_ = true; writeInCase_ = true; // singleValueController() = true; molIds_.clear(); selectIds ids ( molCloud_.cP(), propsDict_ ); molIds_ = ids.molIds(); // read in tracking numbers // trackingNumbers_ = List<label>(propsDict_.lookup("trackingNumbers")); trackingNumber_ = readLabel(propsDict_.lookup("trackingNumber")); centre_ = propsDict_.lookup("centre"); a_ = readScalar(propsDict_.lookup("a")); b_ = readScalar(propsDict_.lookup("b")); deltaT_ = readScalar(propsDict_.lookup("deltaT")); t_ = 0.0; tI_= 0.0; relaxationTime_ = readScalar(propsDict_.lookup("relaxationTime")); startPoint_ = propsDict_.lookup("startPoint"); deltaTMD_ = time_.deltaT().value(); }
Foam::coordinateSystem::coordinateSystem ( const dictionary& dict, const objectRegistry& obr ) : name_(type()), note_(), origin_(point::zero), R_(), Rtr_(sphericalTensor::I) { const entry* entryPtr = dict.lookupEntryPtr(typeName_(), false, false); // a simple entry is a lookup into global coordinateSystems if (entryPtr && !entryPtr->isDict()) { word csName; entryPtr->stream() >> csName; const coordinateSystems& csLst = coordinateSystems::New(obr); label csId = csLst.find(csName); if (debug) { Info<< "coordinateSystem::coordinateSystem" "(const dictionary&, const objectRegistry&):" << nl << "using global coordinate system: " << csName << "=" << csId << endl; } if (csId < 0) { FatalErrorIn ( "coordinateSystem::coordinateSystem" "(const dictionary&, const objectRegistry&)" ) << "could not find coordinate system: " << csName << nl << "available coordinate systems: " << csLst.toc() << nl << nl << exit(FatalError); } // copy coordinateSystem, but assign the name as the typeName // to avoid strange things in writeDict() operator=(csLst[csId]); name_ = typeName_(); }
// Construct from components KochHillDrag::KochHillDrag ( const dictionary& dict, cfdemCloud& sm ) : forceModel(dict,sm), propsDict_(dict.subDict(typeName + "Props")), velFieldName_(propsDict_.lookup("velFieldName")), U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)), voidfractionFieldName_(propsDict_.lookup("voidfractionFieldName")), voidfraction_(sm.mesh().lookupObject<volScalarField> (voidfractionFieldName_)), UsFieldName_(propsDict_.lookupOrDefault("granVelFieldName",word("Us"))), UsField_(sm.mesh().lookupObject<volVectorField> (UsFieldName_)) { // suppress particle probe if (probeIt_ && propsDict_.found("suppressProbe")) probeIt_=!Switch(propsDict_.lookup("suppressProbe")); if(probeIt_) { particleCloud_.probeM().initialize(typeName, typeName+".logDat"); particleCloud_.probeM().vectorFields_.append("dragForce"); //first entry must the be the force particleCloud_.probeM().vectorFields_.append("Urel"); //other are debug particleCloud_.probeM().scalarFields_.append("Rep"); //other are debug particleCloud_.probeM().scalarFields_.append("beta"); //other are debug particleCloud_.probeM().scalarFields_.append("voidfraction"); //other are debug particleCloud_.probeM().writeHeader(); } // init force sub model setForceSubModels(propsDict_); // define switches which can be read from dict forceSubM(0).setSwitchesList(0,true); // activate search for treatExplicit switch forceSubM(0).setSwitchesList(2,true); // activate search for implDEM switch forceSubM(0).setSwitchesList(3,true); // activate search for verbose switch forceSubM(0).setSwitchesList(4,true); // activate search for interpolate switch forceSubM(0).setSwitchesList(7,true); // activate implForceDEMacc switch forceSubM(0).setSwitchesList(8,true); // activate scalarViscosity switch // read those switches defined above, if provided in dict for (int iFSub=0;iFSub<nrForceSubModels();iFSub++) forceSubM(iFSub).readSwitches(); particleCloud_.checkCG(true); }
// Construct from dictionary Foam::shapeToCell::shapeToCell ( const polyMesh& mesh, const dictionary& dict ) : topoSetSource(mesh), type_(dict.lookup("type")) { if (!cellModeller::lookup(type_) && (type_ != "splitHex")) { FatalErrorIn ( "shapeToCell::shapeToCell(const polyMesh&, const dictionary&)" ) << "Illegal cell type " << type_ << exit(FatalError); } }
// Construct from dictionary Foam::refinementParameters::refinementParameters ( const dictionary& dict, const label dummy ) : maxGlobalCells_(readLabel(dict.lookup("cellLimit"))), maxLocalCells_(readLabel(dict.lookup("procCellLimit"))), minRefineCells_(readLabel(dict.lookup("minimumRefine"))), curvature_(readScalar(dict.lookup("curvature"))), nBufferLayers_(readLabel(dict.lookup("nBufferLayers"))), keepPoints_(dict.lookup("keepPoints")), allowFreeStandingZoneFaces_(dict.lookup("allowFreeStandingZoneFaces")), maxLoadUnbalance_(dict.lookupOrDefault<scalar>("maxLoadUnbalance",0)) {}
Foam::combustionModel::combustionModel ( const word& modelType, const dictionary& combustionProps, hsCombustionThermo& thermo, const compressible::turbulenceModel& turbulence, const surfaceScalarField& phi, const volScalarField& rho ) : coeffs_(combustionProps.subDict(modelType + "Coeffs")), thermo_(thermo), turbulence_(turbulence), mesh_(phi.mesh()), phi_(phi), rho_(rho) {}
autoPtr<initialPointsMethod> initialPointsMethod::New ( const dictionary& initialPointsDict, const Time& runTime, Random& rndGen, const conformationSurfaces& geometryToConformTo, const cellShapeControl& cellShapeControls, const autoPtr<backgroundMeshDecomposition>& decomposition ) { word initialPointsMethodTypeName ( initialPointsDict.lookup("initialPointsMethod") ); Info<< nl << "Selecting initialPointsMethod " << initialPointsMethodTypeName << endl; dictionaryConstructorTable::iterator cstrIter = dictionaryConstructorTablePtr_->find(initialPointsMethodTypeName); if (cstrIter == dictionaryConstructorTablePtr_->end()) { FatalErrorInFunction << "Unknown initialPointsMethod type " << initialPointsMethodTypeName << endl << endl << "Valid initialPointsMethod types are :" << endl << dictionaryConstructorTablePtr_->toc() << exit(FatalError); } return autoPtr<initialPointsMethod> ( cstrIter() ( initialPointsDict, runTime, rndGen, geometryToConformTo, cellShapeControls, decomposition ) ); }
UniformFixedValuePointPatchField <PatchField, Mesh, PointPatch, MatrixType, Type>:: UniformFixedValuePointPatchField ( const PointPatch& p, const DimensionedField<Type, Mesh>& iF, const dictionary& dict ) : FixedValuePointPatchField <PatchField, Mesh, PointPatch, MatrixType, Type>(p, iF), uniformValue_(pTraits<Type>(dict.lookup("uniformValue"))) { FixedValuePointPatchField <PatchField, Mesh, PointPatch, MatrixType, Type>::operator== (uniformValue_); }
turbulentHeatFluxTemperatureFvPatchScalarField:: turbulentHeatFluxTemperatureFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF, const dictionary& dict ) : fixedGradientFvPatchScalarField(p, iF), temperatureCoupledBase(patch(), dict), heatSource_(heatSourceTypeNames_.read(dict.lookup("heatSource"))), q_("q", dict, p.size()), QrName_(dict.lookupOrDefault<word>("Qr", "none")) { fvPatchField<scalar>::operator=(patchInternalField()); gradient() = 0.0; }
Foam::radiation::binaryAbsorptionEmission::binaryAbsorptionEmission ( const dictionary& dict, const fvMesh& mesh ) : absorptionEmissionModel(dict, mesh), coeffsDict_(dict.subDict(typeName + "Coeffs")), model1_ ( absorptionEmissionModel::New(coeffsDict_.subDict("model1"), mesh) ), model2_ ( absorptionEmissionModel::New(coeffsDict_.subDict("model2"), mesh) ) {}
executeIfFunctionObjectPresentFunctionObject::executeIfFunctionObjectPresentFunctionObject ( const word& name, const Time& t, const dictionary& dict ) : conditionalFunctionObjectListProxy( name, t, dict ), functionObjectName_( dict.lookup("functionObjectName") ) { }
Foam::STARCDCoordinateRotation::STARCDCoordinateRotation ( const dictionary& dict ) : coordinateRotation() { vector rotation(dict.lookup("rotation")); calcTransform ( rotation.component(vector::X), rotation.component(vector::Y), rotation.component(vector::Z), dict.lookupOrDefault<Switch>("degrees", true) ); }
Foam::functionObjects::regionFunctionObject::regionFunctionObject ( const word& name, const Time& runTime, const dictionary& dict ) : functionObject(name), time_(runTime), obr_ ( runTime.lookupObject<objectRegistry> ( dict.lookupOrDefault("region", polyMesh::defaultRegion) ) ) {}
Foam::sampledIsoSurface::sampledIsoSurface ( const word& name, const polyMesh& mesh, const dictionary& dict ) : sampledSurface(name, mesh, dict), isoField_(dict.lookup("isoField")), isoVal_(readScalar(dict.lookup("isoValue"))), mergeTol_(dict.lookupOrDefault("mergeTol", 1e-6)), regularise_(dict.lookupOrDefault("regularise", true)), average_(dict.lookupOrDefault("average", false)), zoneID_(dict.lookupOrDefault("zone", word::null), mesh.cellZones()), exposedPatchName_(word::null), surfPtr_(nullptr), facesPtr_(nullptr), prevTimeIndex_(-1), storedVolFieldPtr_(nullptr), volFieldPtr_(nullptr), pointFieldPtr_(nullptr) { if (!sampledSurface::interpolate()) { FatalIOErrorInFunction ( dict ) << "Non-interpolated iso surface not supported since triangles" << " span across cells." << exit(FatalIOError); } if (zoneID_.index() != -1) { dict.lookup("exposedPatchName") >> exposedPatchName_; if (mesh.boundaryMesh().findPatchID(exposedPatchName_) == -1) { FatalIOErrorInFunction ( dict ) << "Cannot find patch " << exposedPatchName_ << " in which to put exposed faces." << endl << "Valid patches are " << mesh.boundaryMesh().names() << exit(FatalIOError); } if (debug && zoneID_.index() != -1) { Info<< "Restricting to cellZone " << zoneID_.name() << " with exposed internal faces into patch " << exposedPatchName_ << endl; } }
// Construct from components DiFeliceDrag::DiFeliceDrag ( const dictionary& dict, cfdemCloud& sm ) : forceModel(dict,sm), propsDict_(dict.subDict(typeName + "Props")), velFieldName_(propsDict_.lookup("velFieldName")), U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)), voidfractionFieldName_(propsDict_.lookup("voidfractionFieldName")), voidfraction_(sm.mesh().lookupObject<volScalarField> (voidfractionFieldName_)), UsFieldName_(propsDict_.lookup("granVelFieldName")), UsField_(sm.mesh().lookupObject<volVectorField> (UsFieldName_)), scaleDia_(1.), scaleDrag_(1.) { //Append the field names to be probed particleCloud_.probeM().initialize(typeName, "diFeliceDrag.logDat"); particleCloud_.probeM().vectorFields_.append("dragForce"); //first entry must the be the force particleCloud_.probeM().vectorFields_.append("Urel"); //other are debug particleCloud_.probeM().scalarFields_.append("Rep"); //other are debug particleCloud_.probeM().scalarFields_.append("Cd"); //other are debug particleCloud_.probeM().scalarFields_.append("voidfraction"); //other are debug particleCloud_.probeM().writeHeader(); particleCloud_.checkCG(true); if (propsDict_.found("scale")) scaleDia_=scalar(readScalar(propsDict_.lookup("scale"))); if (propsDict_.found("scaleDrag")) scaleDrag_=scalar(readScalar(propsDict_.lookup("scaleDrag"))); // init force sub model setForceSubModels(propsDict_); // define switches which can be read from dict forceSubM(0).setSwitchesList(0,true); // activate treatExplicit switch forceSubM(0).setSwitchesList(2,true); // activate implDEM switch forceSubM(0).setSwitchesList(3,true); // activate search for verbose switch forceSubM(0).setSwitchesList(4,true); // activate search for interpolate switch forceSubM(0).setSwitchesList(8,true); // activate scalarViscosity switch // read those switches defined above, if provided in dict forceSubM(0).readSwitches(); }
// Construct from components KochHillDrag::KochHillDrag ( const dictionary& dict, cfdemCloud& sm ) : forceModel(dict,sm), propsDict_(dict.subDict(typeName + "Props")), verbose_(false), velFieldName_(propsDict_.lookup("velFieldName")), U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)), densityFieldName_(propsDict_.lookup("densityFieldName")), rho_(sm.mesh().lookupObject<volScalarField> (densityFieldName_)), voidfractionFieldName_(propsDict_.lookup("voidfractionFieldName")), voidfraction_(sm.mesh().lookupObject<volScalarField> (voidfractionFieldName_)), interpolation_(false), scaleDia_(1.), scaleDrag_(1.) { //Append the field names to be probed particleCloud_.probeM().initialize(typeName, "kochHillDrag.logDat"); particleCloud_.probeM().vectorFields_.append("dragForce"); //first entry must the be the force particleCloud_.probeM().vectorFields_.append("Urel"); //other are debug particleCloud_.probeM().scalarFields_.append("Rep"); //other are debug particleCloud_.probeM().scalarFields_.append("beta"); //other are debug particleCloud_.probeM().scalarFields_.append("voidfraction"); //other are debug particleCloud_.probeM().writeHeader(); if (propsDict_.found("verbose")) verbose_=true; if (propsDict_.found("treatExplicit")) treatExplicit_=true; if (propsDict_.found("interpolation")) interpolation_=true; if (propsDict_.found("implDEM")) { treatExplicit_=false; implDEM_=true; setImpDEMdrag(); Info << "Using implicit DEM drag formulation." << endl; } particleCloud_.checkCG(true); if (propsDict_.found("scale")) scaleDia_=scalar(readScalar(propsDict_.lookup("scale"))); if (propsDict_.found("scaleDrag")) scaleDrag_=scalar(readScalar(propsDict_.lookup("scaleDrag"))); }
std::string get_value(char const * name) { std::string r; bool error = false; std::string error_msg; #pragma omp critical (gparams) { try { symbol m, p; normalize(name, m, p); if (m == symbol::null) { if (m_params.contains(p)) { r = get_value(m_params, p); } else { r = get_default(get_param_descrs(), p, m); } } else { params_ref * ps = nullptr; if (m_module_params.find(m, ps) && ps->contains(p)) { r = get_value(*ps, p); } else { param_descrs * d; if (get_module_param_descrs().find(m, d)) { r = get_default(*d, p, m); } else { std::stringstream strm; strm << "unknown module '" << m << "'"; throw exception(strm.str()); } } } } catch (z3_exception & ex) { // Exception cannot cross critical section boundaries. error = true; error_msg = ex.msg(); } } if (error) throw exception(std::move(error_msg)); return r; }
// Construct from components exponential::exponential ( const dictionary& dict, Random& rndGen ) : pdf(dict, rndGen), pdfDict_(dict.subDict(typeName + "PDF")), minValue_(readScalar(pdfDict_.lookup("minValue"))), maxValue_(readScalar(pdfDict_.lookup("maxValue"))), lambda_(pdfDict_.lookup("lambda")), ls_(lambda_), range_(maxValue_-minValue_) { if (minValue_<0) { FatalErrorIn ( "exponential::exponential(const dictionary& dict)" ) << " minValue = " << minValue_ << ", it must be >0." << abort(FatalError); } scalar sMax = 0; label n = lambda_.size(); for(label i=0; i<n; i++) { scalar s = lambda_[i]*exp(-lambda_[i]*minValue_); for(label j=0; j<n; j++) { if (i!=j) { scalar y = lambda_[j]*exp(-lambda_[j]*minValue_); s += y; } } sMax = max(sMax, s); } for(label i=0; i<n; i++) { ls_[i] /= sMax; } }
Foam::functionObjects::processorField::processorField ( const word& name, const Time& runTime, const dictionary& dict ) : functionObject(name), obr_ ( runTime.lookupObject<objectRegistry> ( dict.lookupOrDefault("region", polyMesh::defaultRegion) ) ) { if (!isA<fvMesh>(obr_)) { FatalErrorInFunction << "objectRegistry is not an fvMesh" << exit(FatalError); } read(dict); const fvMesh& mesh = refCast<const fvMesh>(obr_); volScalarField* procFieldPtr ( new volScalarField ( IOobject ( "processorID", mesh.time().timeName(), mesh, IOobject::NO_READ, IOobject::NO_WRITE ), mesh, dimensionedScalar("0", dimless, 0.0) ) ); mesh.objectRegistry::store(procFieldPtr); }