bool Foam::functionObjects::systemCall::read(const dictionary& dict) { dict.readIfPresent("executeCalls", executeCalls_); dict.readIfPresent("endCalls", endCalls_); dict.readIfPresent("writeCalls", writeCalls_); if (executeCalls_.empty() && endCalls_.empty() && writeCalls_.empty()) { WarningInFunction << "no executeCalls, endCalls or writeCalls defined." << endl; } else if (!dynamicCode::allowSystemOperations) { FatalErrorInFunction << "Executing user-supplied system calls is not enabled by " << "default because of " << nl << "security issues. If you trust the case you can enable this " << "facility by " << nl << "adding to the InfoSwitches setting in the system controlDict:" << nl << nl << " allowSystemOperations 1" << nl << nl << "The system controlDict is either" << nl << nl << " ~/.OpenFOAM/$WM_PROJECT_VERSION/controlDict" << nl << nl << "or" << nl << nl << " $WM_PROJECT_DIR/etc/controlDict" << nl << nl << exit(FatalError); } return true; }
bool Foam::functionObjects::pressureTools::read(const dictionary& dict) { dict.readIfPresent("pName", pName_); dict.readIfPresent("UName", UName_); dict.readIfPresent("rhoName", rhoName_); if (rhoName_ == "rhoInf") { dict.lookup("rhoInf") >> rhoInf_; }
Foam::patchIdentifier::patchIdentifier ( const word& name, const dictionary& dict, const label index ) : name_(name), index_(index) { dict.readIfPresent("physicalType", physicalType_); dict.readIfPresent("inGroups", inGroups_); }
void Foam::fieldValues::cellSource::initialise(const dictionary& dict) { setCellZoneCells(); if (nCells_ == 0) { WarningIn ( "Foam::fieldValues::cellSource::initialise(const dictionary&)" ) << type() << " " << name_ << ": " << sourceTypeNames_[source_] << "(" << sourceName_ << "):" << nl << " Source has no cells - deactivating" << endl; active_ = false; return; } Info<< type() << " " << name_ << ":" << sourceTypeNames_[source_] << "(" << sourceName_ << "):" << nl << " total cells = " << nCells_ << nl << " total volume = " << gSum(filterField(mesh().V())) << nl << endl; if (dict.readIfPresent("weightField", weightFieldName_)) { Info<< " weight field = " << weightFieldName_; } Info<< nl << endl; }
Foam:: timeVaryingMappedFixedValuePointPatchField<Type>:: timeVaryingMappedFixedValuePointPatchField ( const pointPatch& p, const DimensionedField<Type, pointMesh>& iF, const dictionary& dict ) : fixedValuePointPatchField<Type>(p, iF), fieldTableName_(iF.name()), setAverage_(readBool(dict.lookup("setAverage"))), perturb_(dict.lookupOrDefault("perturb", 1E-5)), mapperPtr_(NULL), sampleTimes_(0), startSampleTime_(-1), startSampledValues_(0), startAverage_(pTraits<Type>::zero), endSampleTime_(-1), endSampledValues_(0), endAverage_(pTraits<Type>::zero) { dict.readIfPresent("fieldTableName", fieldTableName_); updateCoeffs(); }
Foam::sampledPlane::sampledPlane ( const word& name, const polyMesh& mesh, const dictionary& dict ) : sampledSurface(name, mesh, dict), cuttingPlane(plane(dict)), zoneKey_(keyType::null), triangulate_(dict.lookupOrDefault("triangulate", true)), needsUpdate_(true) { // Make plane relative to the coordinateSystem (Cartesian) // allow lookup from global coordinate systems if (dict.found("coordinateSystem")) { coordinateSystem cs(mesh, dict.subDict("coordinateSystem")); 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", zoneKey_); if (debug && zoneKey_.size() && mesh.cellZones().findIndex(zoneKey_) < 0) { Info<< "cellZone " << zoneKey_ << " not found - using entire mesh" << endl; } }
freestreamFvPatchField<Type>::freestreamFvPatchField ( const fvPatch& p, const DimensionedField<Type, volMesh>& iF, const dictionary& dict ) : inletOutletFvPatchField<Type>(p, iF) { freestreamValue() = Field<Type>("freestreamValue", dict, p.size()); if (dict.found("value")) { fvPatchField<Type>::operator= ( Field<Type>("value", dict, p.size()) ); } else { fvPatchField<Type>::operator=(freestreamValue()); } dict.readIfPresent("phi", this->phiName_); }
timeVaryingMappedFixedValueFvPatchField<Type>:: timeVaryingMappedFixedValueFvPatchField ( const fvPatch& p, const DimensionedField<Type, volMesh>& iF, const dictionary& dict ) : fixedValueFvPatchField<Type>(p, iF), fieldTableName_(iF.name()), setAverage_(readBool(dict.lookup("setAverage"))), perturb_(dict.lookupOrDefault("perturb", 1E-5)), referenceCS_(NULL), nearestVertex_(0), nearestVertexWeight_(0), sampleTimes_(0), startSampleTime_(-1), startSampledValues_(0), startAverage_(pTraits<Type>::zero), endSampleTime_(-1), endSampledValues_(0), endAverage_(pTraits<Type>::zero) { dict.readIfPresent("fieldTableName", fieldTableName_); if (dict.found("value")) { fvPatchField<Type>::operator==(Field<Type>("value", dict, p.size())); } else { updateCoeffs(); } }
Foam::timeVaryingMappedFixedValueFvPatchField<Type>:: timeVaryingMappedFixedValueFvPatchField ( const fvPatch& p, const DimensionedField<Type, volMesh>& iF, const dictionary& dict ) : fixedValueFvPatchField<Type>(p, iF), fieldTableName_(iF.name()), setAverage_(readBool(dict.lookup("setAverage"))), perturb_(dict.lookupOrDefault("perturb", 1e-5)), mapMethod_ ( dict.lookupOrDefault<word> ( "mapMethod", "planarInterpolation" ) ), mapperPtr_(NULL), sampleTimes_(0), startSampleTime_(-1), startSampledValues_(0), startAverage_(Zero), endSampleTime_(-1), endSampledValues_(0), endAverage_(Zero), offset_(Function1<Type>::New("offset", dict)) { if ( mapMethod_ != "planarInterpolation" && mapMethod_ != "nearest" ) { FatalIOErrorInFunction ( dict ) << "mapMethod should be one of 'planarInterpolation'" << ", 'nearest'" << exit(FatalIOError); } dict.readIfPresent("fieldTableName", fieldTableName_); if (dict.found("value")) { fvPatchField<Type>::operator==(Field<Type>("value", dict, p.size())); } else { // Note: we use evaluate() here to trigger updateCoeffs followed // by re-setting of fvatchfield::updated_ flag. This is // so if first use is in the next time step it retriggers // a new update. this->evaluate(Pstream::blocking); } }
bool Foam::fv::option::read(const dictionary& dict) { dict.readIfPresent("active", active_); coeffs_ = dict.optionalSubDict(modelType_ + "Coeffs"); return true; }
Foam:: timeVaryingMappedFixedValuePointPatchField<Type>:: timeVaryingMappedFixedValuePointPatchField ( const pointPatch& p, const DimensionedField<Type, pointMesh>& iF, const dictionary& dict ) : fixedValuePointPatchField<Type>(p, iF), fieldTableName_(iF.name()), setAverage_(readBool(dict.lookup("setAverage"))), perturb_(dict.lookupOrDefault("perturb", 1e-5)), mapMethod_ ( dict.lookupOrDefault<word> ( "mapMethod", "planarInterpolation" ) ), mapperPtr_(NULL), sampleTimes_(0), startSampleTime_(-1), startSampledValues_(0), startAverage_(pTraits<Type>::zero), endSampleTime_(-1), endSampledValues_(0), endAverage_(pTraits<Type>::zero), offset_() { if (dict.found("offset")) { offset_ = DataEntry<Type>::New("offset", dict); } dict.readIfPresent("fieldTableName", fieldTableName_); if (dict.found("value")) { fixedValuePointPatchField<Type>::operator== ( Field<Type>("value", dict, p.size()) ); } else { // Note: use evaluate to do updateCoeffs followed by a reset // of the pointPatchField::updated_ flag. This is // so if first use is in the next time step it retriggers // a new update. pointPatchField<Type>::evaluate(Pstream::blocking); } }
Foam::surfZoneIdentifier::surfZoneIdentifier ( const word& name, const dictionary& dict, const label index ) : name_(name), index_(index) { dict.readIfPresent("geometricType", geometricType_); }
advectiveFvPatchField<Type>::advectiveFvPatchField ( const fvPatch& p, const DimensionedField<Type, volMesh>& iF, const dictionary& dict ) : mixedFvPatchField<Type>(p, iF), phiName_(dict.lookupOrDefault<word>("phi", "phi")), rhoName_(dict.lookupOrDefault<word>("rho", "rho")), fieldInf_(pTraits<Type>::zero), lInf_(0.0), inletOutlet_(dict.lookup("inletOutlet")), correctSupercritical_(dict.lookup("correctSupercritical")) { if (dict.found("value")) { fvPatchField<Type>::operator= ( Field<Type>("value", dict, p.size()) ); } else { fvPatchField<Type>::operator=(this->patchInternalField()); } this->refValue() = *this; this->refGrad() = pTraits<Type>::zero; this->valueFraction() = 0.0; if (dict.readIfPresent("lInf", lInf_)) { dict.lookup("fieldInf") >> fieldInf_; if (lInf_ < 0.0) { FatalIOErrorIn ( "advectiveFvPatchField<Type>::" "advectiveFvPatchField" "(const fvPatch&, const Field<Type>&, const dictionary&)", dict ) << "unphysical lInf specified (lInf < 0)\n" << " on patch " << this->patch().name() << " of field " << this->dimensionedInternalField().name() << " in file " << this->dimensionedInternalField().objectPath() << exit(FatalIOError); } }
void Foam::abortCalculation::read(const dictionary& dict) { if (dict.found("action")) { action_ = actionTypeNames_.read(dict.lookup("action")); } else { action_ = nextWrite; } if (dict.readIfPresent("fileName", abortFile_)) { abortFile_.expand(); } }
Foam::autoPtr<Foam::polyPatch> Foam::polyPatch::New ( const word& name, const dictionary& dict, const label index, const polyBoundaryMesh& bm ) { if (debug) { Info<< "polyPatch::New(const word&, const dictionary&, const label, " "const polyBoundaryMesh&) : constructing polyPatch" << endl; } word patchType(dict.lookup("type")); dict.readIfPresent("geometricType", patchType); dictionaryConstructorTable::iterator cstrIter = dictionaryConstructorTablePtr_->find(patchType); if (cstrIter == dictionaryConstructorTablePtr_->end()) { if (!disallowGenericPolyPatch) { cstrIter = dictionaryConstructorTablePtr_->find("genericPatch"); } if (cstrIter == dictionaryConstructorTablePtr_->end()) { FatalIOErrorIn ( "polyPatch::New(const word&, const dictionary&, " "const label, const polyBoundaryMesh&)", dict ) << "Unknown polyPatch type " << patchType << " for patch " << name << endl << endl << "Valid polyPatch types are :" << endl << dictionaryConstructorTablePtr_->toc() << exit(FatalIOError); } } return autoPtr<polyPatch>(cstrIter()(name, dict, index, bm)); }
Foam::autoPtr<Foam::polyPatch> Foam::polyPatch::New ( const word& name, const dictionary& dict, const label index, const polyBoundaryMesh& bm ) { if (debug) { InfoInFunction << "Constructing polyPatch" << endl; } word patchType(dict.lookup("type")); dict.readIfPresent("geometricType", patchType); return polyPatch::New(patchType, name, dict, index, bm); }
bool Foam::functionObjects::abort::read(const dictionary& dict) { if (dict.found("action")) { action_ = actionTypeNames_.read(dict.lookup("action")); } else { action_ = actionType::nextWrite; } if (dict.readIfPresent("file", abortFile_)) { abortFile_.expand(); } return true; }
Foam::SolverPerformance<Type> Foam::fvMatrix<Type>::solve ( const dictionary& solverControls ) { if (debug) { Info.masterStream(this->mesh().comm()) << "fvMatrix<Type>::solve(const dictionary& solverControls) : " "solving fvMatrix<Type>" << endl; } label maxIter = -1; if (solverControls.readIfPresent("maxIter", maxIter)) { if (maxIter == 0) { return SolverPerformance<Type>(); } } word type(solverControls.lookupOrDefault<word>("type", "segregated")); if (type == "segregated") { return solveSegregated(solverControls); } else if (type == "coupled") { return solveCoupled(solverControls); } else { FatalIOErrorInFunction ( solverControls ) << "Unknown type " << type << "; currently supported solver types are segregated and coupled" << exit(FatalIOError); return SolverPerformance<Type>(); } }
Foam::autoPtr<Foam::coordinateSystem> Foam::coordinateSystem::New ( const word& name, const dictionary& dict ) { if (debug) { Pout<< "coordinateSystem::New(const word&, const dictionary&) : " << "constructing coordinateSystem" << endl; } // construct base class directly, also allow 'cartesian' as an alias word coordType(typeName_()); if ( !dict.readIfPresent("type", coordType) || coordType == typeName_() || coordType == "cartesian" ) { return autoPtr<coordinateSystem>(new coordinateSystem(name, dict)); } dictionaryConstructorTable::iterator cstrIter = dictionaryConstructorTablePtr_->find(coordType); if (cstrIter == dictionaryConstructorTablePtr_->end()) { FatalIOErrorIn ( "coordinateSystem::New(const word&, const dictionary&)", dict ) << "Unknown coordinateSystem type " << coordType << nl << nl << "Valid coordinateSystem types are :" << nl << "[default: " << typeName_() << "]" << dictionaryConstructorTablePtr_->toc() << exit(FatalIOError); } return autoPtr<coordinateSystem>(cstrIter()(name, dict)); }
void Foam::liquidProperties::readIfPresent(const dictionary &dict) { thermophysicalProperties::readIfPresent(dict); dict.readIfPresent("Tc", Tc_); dict.readIfPresent("Pc", Pc_); dict.readIfPresent("Vc", Vc_); dict.readIfPresent("Zc", Zc_); dict.readIfPresent("Tt", Tt_); dict.readIfPresent("Pt", Pt_); dict.readIfPresent("Tb", Tb_); dict.readIfPresent("dipm", dipm_); dict.readIfPresent("omega", omega_); dict.readIfPresent("delta", delta_); }
Foam::autoPtr<Foam::dynamicFvMesh> Foam::dynamicFvMesh::New ( const IOobject& io, const dictionary& dict, const word& defaultMeshTypeName ) { word dynamicFvMeshTypeName(defaultMeshTypeName); if (dict.readIfPresent("dynamicFvMesh", dynamicFvMeshTypeName)) { Info<< "Selecting dynamicFvMesh " << dynamicFvMeshTypeName << endl; } const_cast<Time&>(io.time()).libs().open ( dict, "dynamicFvMeshLibs", IOobjectConstructorTablePtr_ ); if (!IOobjectConstructorTablePtr_) { FatalErrorInFunction << "dynamicFvMesh table is empty" << exit(FatalError); } IOobjectConstructorTable::iterator cstrIter = IOobjectConstructorTablePtr_->find(dynamicFvMeshTypeName); if (cstrIter == IOobjectConstructorTablePtr_->end()) { FatalErrorInFunction << "Unknown dynamicFvMesh type " << dynamicFvMeshTypeName << nl << nl << "Valid dynamicFvMesh types are :" << endl << IOobjectConstructorTablePtr_->sortedToc() << exit(FatalError); } return autoPtr<dynamicFvMesh>(cstrIter()(io)); }
Foam::autoPtr<Foam::coordinateRotationOFext> Foam::coordinateRotationOFext::New ( const dictionary& dict ) { if (debug) { Pout<< "coordinateRotation::New(const dictionary&) : " << "constructing coordinateRotation" << endl; } // default type is self (alias: "axes") word rotType(typeName_()); dict.readIfPresent("type", rotType); // can (must) construct base class directly if (rotType == typeName_() || rotType == "axes") { return autoPtr<coordinateRotationOFext>(new coordinateRotationOFext(dict)); } dictionaryConstructorTable::iterator cstrIter = dictionaryConstructorTablePtr_->find(rotType); if (cstrIter == dictionaryConstructorTablePtr_->end()) { FatalIOErrorIn ( "coordinateRotation::New(const dictionary&)", dict ) << "Unknown coordinateRotation type " << rotType << nl << nl << "Valid coordinateRotation types are :" << nl << "[default: axes " << typeName_() << "]" << dictionaryConstructorTablePtr_->toc() << exit(FatalIOError); } return autoPtr<coordinateRotationOFext>(cstrIter()(dict)); }
sixDoFRigidBodyDisplacementPointPatchVectorField:: sixDoFRigidBodyDisplacementPointPatchVectorField ( const pointPatch& p, const DimensionedField<vector, pointMesh>& iF, const dictionary& dict ) : fixedValuePointPatchField<vector>(p, iF, dict), motion_(dict), rhoInf_(1.0), rhoName_(dict.lookupOrDefault<word>("rhoName", "rho")), lookupGravity_(-1), g_(vector::zero), relaxationFactor_(dict.lookupOrDefault<scalar>("relaxationFactor", 1)) { if (rhoName_ == "rhoInf") { rhoInf_ = readScalar(dict.lookup("rhoInf")); } if (dict.readIfPresent("g", g_)) { lookupGravity_ = -2; } if (!dict.found("value")) { updateCoeffs(); } if (dict.found("initialPoints")) { initialPoints_ = vectorField("initialPoints", dict , p.size()); } else { initialPoints_ = p.localPoints(); } }
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; } } }
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(); }
void Foam::thermophysicalProperties::readIfPresent(const dictionary &dict) { dict.readIfPresent("W", W_); }
bool Foam::motionSmootherAlgo::checkMesh ( const bool report, const polyMesh& mesh, const dictionary& dict, const labelList& checkFaces, const List<labelPair>& baffles, labelHashSet& wrongFaces ) { const scalar maxNonOrtho ( readScalar(dict.lookup("maxNonOrtho", true)) ); const scalar minVol ( readScalar(dict.lookup("minVol", true)) ); const scalar minTetQuality ( readScalar(dict.lookup("minTetQuality", true)) ); const scalar maxConcave ( readScalar(dict.lookup("maxConcave", true)) ); const scalar minArea ( readScalar(dict.lookup("minArea", true)) ); const scalar maxIntSkew ( readScalar(dict.lookup("maxInternalSkewness", true)) ); const scalar maxBounSkew ( readScalar(dict.lookup("maxBoundarySkewness", true)) ); const scalar minWeight ( readScalar(dict.lookup("minFaceWeight", true)) ); const scalar minVolRatio ( readScalar(dict.lookup("minVolRatio", true)) ); const scalar minTwist ( readScalar(dict.lookup("minTwist", true)) ); const scalar minTriangleTwist ( readScalar(dict.lookup("minTriangleTwist", true)) ); scalar minFaceFlatness = -1.0; dict.readIfPresent("minFaceFlatness", minFaceFlatness, true); const scalar minDet ( readScalar(dict.lookup("minDeterminant", true)) ); label nWrongFaces = 0; Info<< "Checking faces in error :" << endl; //Pout.setf(ios_base::left); if (maxNonOrtho < 180.0-SMALL) { polyMeshGeometry::checkFaceDotProduct ( report, maxNonOrtho, mesh, mesh.cellCentres(), mesh.faceAreas(), checkFaces, baffles, &wrongFaces ); label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>()); Info<< " non-orthogonality > " << setw(3) << maxNonOrtho << " degrees : " << nNewWrongFaces-nWrongFaces << endl; nWrongFaces = nNewWrongFaces; } if (minVol > -GREAT) { polyMeshGeometry::checkFacePyramids ( report, minVol, mesh, mesh.cellCentres(), mesh.points(), checkFaces, baffles, &wrongFaces ); label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>()); Info<< " faces with face pyramid volume < " << setw(5) << minVol << " : " << nNewWrongFaces-nWrongFaces << endl; nWrongFaces = nNewWrongFaces; } if (minTetQuality > -GREAT) { polyMeshGeometry::checkFaceTets ( report, minTetQuality, mesh, mesh.cellCentres(), mesh.faceCentres(), mesh.points(), checkFaces, baffles, &wrongFaces ); label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>()); Info<< " faces with face-decomposition tet quality < " << setw(5) << minTetQuality << " : " << nNewWrongFaces-nWrongFaces << endl; nWrongFaces = nNewWrongFaces; } if (maxConcave < 180.0-SMALL) { polyMeshGeometry::checkFaceAngles ( report, maxConcave, mesh, mesh.faceAreas(), mesh.points(), checkFaces, &wrongFaces ); label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>()); Info<< " faces with concavity > " << setw(3) << maxConcave << " degrees : " << nNewWrongFaces-nWrongFaces << endl; nWrongFaces = nNewWrongFaces; } if (minArea > -SMALL) { polyMeshGeometry::checkFaceArea ( report, minArea, mesh, mesh.faceAreas(), checkFaces, &wrongFaces ); label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>()); Info<< " faces with area < " << setw(5) << minArea << " m^2 : " << nNewWrongFaces-nWrongFaces << endl; nWrongFaces = nNewWrongFaces; } if (maxIntSkew > 0 || maxBounSkew > 0) { polyMeshGeometry::checkFaceSkewness ( report, maxIntSkew, maxBounSkew, mesh, mesh.points(), mesh.cellCentres(), mesh.faceCentres(), mesh.faceAreas(), checkFaces, baffles, &wrongFaces ); label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>()); Info<< " faces with skewness > " << setw(3) << maxIntSkew << " (internal) or " << setw(3) << maxBounSkew << " (boundary) : " << nNewWrongFaces-nWrongFaces << endl; nWrongFaces = nNewWrongFaces; } if (minWeight >= 0 && minWeight < 1) { polyMeshGeometry::checkFaceWeights ( report, minWeight, mesh, mesh.cellCentres(), mesh.faceCentres(), mesh.faceAreas(), checkFaces, baffles, &wrongFaces ); label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>()); Info<< " faces with interpolation weights (0..1) < " << setw(5) << minWeight << " : " << nNewWrongFaces-nWrongFaces << endl; nWrongFaces = nNewWrongFaces; } if (minVolRatio >= 0) { polyMeshGeometry::checkVolRatio ( report, minVolRatio, mesh, mesh.cellVolumes(), checkFaces, baffles, &wrongFaces ); label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>()); Info<< " faces with volume ratio of neighbour cells < " << setw(5) << minVolRatio << " : " << nNewWrongFaces-nWrongFaces << endl; nWrongFaces = nNewWrongFaces; } if (minTwist > -1) { //Pout<< "Checking face twist: dot product of face normal " // << "with face triangle normals" << endl; polyMeshGeometry::checkFaceTwist ( report, minTwist, mesh, mesh.cellCentres(), mesh.faceAreas(), mesh.faceCentres(), mesh.points(), checkFaces, &wrongFaces ); label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>()); Info<< " faces with face twist < " << setw(5) << minTwist << " : " << nNewWrongFaces-nWrongFaces << endl; nWrongFaces = nNewWrongFaces; } if (minTriangleTwist > -1) { //Pout<< "Checking triangle twist: dot product of consecutive triangle" // << " normals resulting from face-centre decomposition" << endl; polyMeshGeometry::checkTriangleTwist ( report, minTriangleTwist, mesh, mesh.faceAreas(), mesh.faceCentres(), mesh.points(), checkFaces, &wrongFaces ); label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>()); Info<< " faces with triangle twist < " << setw(5) << minTriangleTwist << " : " << nNewWrongFaces-nWrongFaces << endl; nWrongFaces = nNewWrongFaces; } if (minFaceFlatness > -SMALL) { polyMeshGeometry::checkFaceFlatness ( report, minFaceFlatness, mesh, mesh.faceAreas(), mesh.faceCentres(), mesh.points(), checkFaces, &wrongFaces ); label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>()); Info<< " faces with flatness < " << setw(5) << minFaceFlatness << " : " << nNewWrongFaces-nWrongFaces << endl; nWrongFaces = nNewWrongFaces; } if (minDet > -1) { polyMeshGeometry::checkCellDeterminant ( report, minDet, mesh, mesh.faceAreas(), checkFaces, polyMeshGeometry::affectedCells(mesh, checkFaces), &wrongFaces ); label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>()); Info<< " faces on cells with determinant < " << setw(5) << minDet << " : " << nNewWrongFaces-nWrongFaces << endl; nWrongFaces = nNewWrongFaces; } //Pout.setf(ios_base::right); return nWrongFaces > 0; }
bool dimensioned<Type>::readIfPresent(const dictionary& dict) { return dict.readIfPresent(name_, value_); }