void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh) { IOobject phiHeader ( "phi", runTime.timeName(), mesh, IOobject::MUST_READ ); IOobject faceIbMaskHeader ( "faceIbMask", runTime.timeName(), mesh, IOobject::MUST_READ ); if (phiHeader.headerOk() && faceIbMaskHeader.headerOk()) { Info<< " Reading phi" << endl; surfaceScalarField phi(phiHeader, mesh); Info<< " Reading faceIbMask" << endl; surfaceScalarField faceIbMask(faceIbMaskHeader, mesh); volScalarField contErr = fvc::div(faceIbMask*phi); scalar sumLocalContErr = runTime.deltaT().value()* mag(contErr)().weightedAverage(mesh.V()).value(); scalar globalContErr = runTime.deltaT().value()* contErr.weightedAverage(mesh.V()).value(); Info<< "IB time step continuity errors : sum local = " << sumLocalContErr << ", global = " << globalContErr << endl; volScalarField magContErr ( "magContErr", mag(contErr) ); magContErr.write(); } else { Info<< " No phi or faceIbMask" << endl; } }
void createDummyFvMeshFiles(const polyMesh& mesh, const word& regionName) { // Create dummy system/fv* { IOobject io ( "fvSchemes", mesh.time().system(), regionName, mesh, IOobject::NO_READ, IOobject::NO_WRITE, false ); Info<< "Testing:" << io.objectPath() << endl; if (!io.headerOk()) { Info<< "Writing dummy " << regionName/io.name() << endl; dictionary dummyDict; dictionary divDict; dummyDict.add("divSchemes", divDict); dictionary gradDict; dummyDict.add("gradSchemes", gradDict); dictionary laplDict; dummyDict.add("laplacianSchemes", laplDict); IOdictionary(io, dummyDict).regIOobject::write(); } } { IOobject io ( "fvSolution", mesh.time().system(), regionName, mesh, IOobject::NO_READ, IOobject::NO_WRITE, false ); if (!io.headerOk()) { Info<< "Writing dummy " << regionName/io.name() << endl; dictionary dummyDict; IOdictionary(io, dummyDict).regIOobject::write(); } } }
bool addFieldsToList ( const fvMesh& mesh, PtrList<GeometricField<Type, fvPatchField, volMesh> >& list, const wordList& fieldNames ) { typedef GeometricField<Type, fvPatchField, volMesh> fieldType; label index = 0; forAll(fieldNames, i) { IOobject obj ( fieldNames[i], mesh.time().timeName(), mesh, IOobject::MUST_READ ); if (obj.headerOk() && obj.headerClassName() == fieldType::typeName) { list.set(index++, new fieldType(obj, mesh)); } else { Info<< "Could not find " << fieldNames[i] << endl; return false; } }
Foam::wordList Foam::vtkPV4Foam::readZoneNames(const word& zoneType) { wordList zoneNames; // mesh not loaded - read from file IOobject ioObj ( zoneType, dbPtr_().findInstance ( meshDir_, zoneType, IOobject::READ_IF_PRESENT ), meshDir_, dbPtr_(), IOobject::READ_IF_PRESENT, IOobject::NO_WRITE, false ); if (ioObj.headerOk()) { zonesEntries zones(ioObj); zoneNames.setSize(zones.size()); forAll(zones, zoneI) { zoneNames[zoneI] = zones[zoneI].keyword(); } }
Foam::IOobject Foam::fv::IOoptionList::createIOobject ( const fvMesh& mesh ) const { IOobject io ( "fvOptions", mesh.time().system(), mesh, IOobject::MUST_READ, IOobject::NO_WRITE ); if (io.headerOk()) { Info<< "Creating fintite volume options from " << io.name() << nl << endl; io.readOpt() = IOobject::MUST_READ_IF_MODIFIED; return io; } else { Info<< "No finite volume options present" << nl << endl; io.readOpt() = IOobject::NO_READ; return io; } }
void Foam::calcTypes::scalarMult::calc ( const argList& args, const Time& runTime, const fvMesh& mesh ) { IOobject baseFieldHeader ( baseFieldName_, runTime.timeName(), mesh, IOobject::MUST_READ ); if (baseFieldHeader.headerOk()) { writeScalarMultValues(runTime, mesh, baseFieldHeader); } else { FatalErrorIn("calcTypes::scalarMult::calc") << "Unable to read base field: " << baseFieldName_ << nl << exit(FatalError); } }
void replaceBoundaryType ( const fvMesh& mesh, const word& fieldName, const word& boundaryType, const string& boundaryValue ) { IOobject header ( fieldName, mesh.time().timeName(), mesh, IOobject::MUST_READ, IOobject::NO_WRITE ); if (!header.headerOk()) { return; } Info<< "Updating boundary types for field " << header.name() << endl; const word oldTypeName = IOdictionary::typeName; const_cast<word&>(IOdictionary::typeName) = word::null; IOdictionary dict(header); const_cast<word&>(IOdictionary::typeName) = oldTypeName; const_cast<word&>(dict.type()) = dict.headerClassName(); // Make a backup of the old file if (mvBak(dict.objectPath(), "old")) { Info<< " Backup original file to " << (dict.objectPath() + ".old") << endl; } // Loop through boundary patches and update const polyBoundaryMesh& bMesh = mesh.boundaryMesh(); dictionary& boundaryDict = dict.subDict("boundaryField"); forAll(bMesh, patchI) { if (isA<wallPolyPatch>(bMesh[patchI])) { word patchName = bMesh[patchI].name(); dictionary& oldPatch = boundaryDict.subDict(patchName); dictionary newPatch(dictionary::null); newPatch.add("type", boundaryType); newPatch.add("value", ("uniform " + boundaryValue).c_str()); oldPatch = newPatch; } } Info<< " writing updated " << dict.name() << nl << endl; dict.regIOobject::write(); }
bool Foam::sampledSurfaceElevation::checkFieldTypes() { wordList fieldTypes(fieldNames_.size()); // check files for a particular time if (loadFromFiles_) { forAll (fieldNames_, fieldi) { IOobject io ( fieldNames_[fieldi], mesh_.time().timeName(), mesh_, IOobject::MUST_READ, IOobject::NO_WRITE, false ); if (io.headerOk()) { fieldTypes[fieldi] = io.headerClassName(); } else { fieldTypes[fieldi] = "(notFound)"; } } }
void Foam::StandardWallInteraction<CloudType>::readProps() { if (!this->owner().solution().transient()) { return; } IOobject propsDictHeader ( "standardWallInteractionProperties", this->owner().db().time().timeName(), "uniform"/cloud::prefix/this->owner().name(), this->owner().db(), IOobject::MUST_READ_IF_MODIFIED, IOobject::NO_WRITE, false ); if (propsDictHeader.headerOk()) { const IOdictionary propsDict(propsDictHeader); propsDict.readIfPresent("nEscape", nEscape0_); propsDict.readIfPresent("massEscape", massEscape0_); propsDict.readIfPresent("nStick", nStick0_); propsDict.readIfPresent("massStick", massStick0_); } }
int main(int argc, char *argv[]) { argList::validArgs.append("scaling factor"); # include "setRootCase.H" const scalar scaleFactor = args.argRead<scalar>(1); # include "createTime.H" # include "createMesh.H" volPointInterpolation pInterp(mesh); // Get times list instantList Times = runTime.times(); pointField zeroPoints(mesh.points()); // skip "constant" time for (label timeI = 1; timeI < Times.size(); ++timeI) { runTime.setTime(Times[timeI], timeI); Info<< "Time = " << runTime.timeName() << endl; IOobject Uheader ( "U", runTime.timeName(), mesh, IOobject::MUST_READ ); // Check U exists if (Uheader.headerOk()) { Info<< " Reading U" << endl; volVectorField U(Uheader, mesh); pointField newPoints ( zeroPoints + scaleFactor*pInterp.interpolate(U)().internalField() ); mesh.polyMesh::movePoints(newPoints); mesh.write(); } else { Info<< " No U" << endl; } Info<< endl; } Info<< "End\n" << endl; return 0; }
Foam::IOobject Foam::IOMRFZoneList::createIOobject ( const fvMesh& mesh ) const { IOobject io ( "MRFProperties", mesh.time().constant(), mesh, IOobject::MUST_READ, IOobject::NO_WRITE ); if (io.headerOk()) { Info<< "Creating MRF zone list from " << io.name() << endl; io.readOpt() = IOobject::MUST_READ_IF_MODIFIED; return io; } else { Info<< "No MRF models present" << nl << endl; io.readOpt() = IOobject::NO_READ; return io; } }
void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh) { bool writeResults = !args.optionFound("noWrite"); IOobject Uheader ( "U", runTime.timeName(), mesh, IOobject::MUST_READ ); if (Uheader.headerOk()) { Info<< " Reading U" << endl; volVectorField U(Uheader, mesh); Info<< " Calculating vorticity" << endl; volVectorField vorticity ( IOobject ( "vorticity", runTime.timeName(), mesh, IOobject::NO_READ ), fvc::curl(U) ); volScalarField magVorticity ( IOobject ( "magVorticity", runTime.timeName(), mesh, IOobject::NO_READ ), mag(vorticity) ); Info<< "vorticity max/min : " << max(magVorticity).value() << " " << min(magVorticity).value() << endl; if (writeResults) { vorticity.write(); magVorticity.write(); } } else { Info<< " No U" << endl; } Info<< "\nEnd\n" << endl; }
int main(int argc, char *argv[]) { timeSelector::addOptions(); #include "addRegionOption.H" argList::validArgs.append("fieldName"); #include "setRootCase.H" #include "createTime.H" instantList timeDirs = timeSelector::select0(runTime, args); #include "createNamedMesh.H" const word fieldName = args[1]; forAll(timeDirs, timeI) { runTime.setTime(timeDirs[timeI], timeI); Info<< "Time = " << runTime.timeName() << endl; IOobject fieldHeader ( fieldName, runTime.timeName(), mesh, IOobject::MUST_READ ); // Check field exists if (fieldHeader.headerOk()) { mesh.readUpdate(); // Give fluid volume Info<< " Volume of fluid = " << gSum(mesh.V()) << " [m3]" << endl; // Read field and calc integral bool done = false; printIntegrate<volScalarField>(mesh,fieldHeader,done); printIntegrate<volVectorField>(mesh,fieldHeader,done); printIntegrate<volSphericalTensorField>(mesh,fieldHeader,done); printIntegrate<volSymmTensorField>(mesh,fieldHeader,done); printIntegrate<volTensorField>(mesh,fieldHeader,done); if (!done) { FatalError << "Only possible to integrate volFields." << " Field " << fieldName << " is of type " << fieldHeader.headerClassName() << nl << exit(FatalError); } } else { Info<< " No field " << fieldName << endl; } Info<< endl; }
int main(int argc, char *argv[]) { timeSelector::addOptions(); argList::validArgs.append("patchName"); #include "setRootCase.H" #include "createTime.H" instantList timeDirs = timeSelector::select0(runTime, args); const word vecFieldName = "wallShearStress"; #include "createMesh.H" runTime.setTime(timeDirs.last(), timeDirs.size()-1); const word patchName = args[1]; forAll(timeDirs, timeI) { runTime.setTime(timeDirs[timeI], timeI); Info<< "Time = " << runTime.timeName() << endl; Info << " Read vector field " << vecFieldName << endl; IOobject vecFieldHeader ( vecFieldName, runTime.timeName(), mesh, IOobject::MUST_READ, IOobject::NO_WRITE ); if (!vecFieldHeader.headerOk()) { Info << "Unable to read vector field" << vecFieldName << endl; return EXIT_FAILURE; } const label patchI = mesh.boundaryMesh().findPatchID(patchName); if (patchI < 0) { FatalError << "Unable to find patch " << patchName << nl << exit(FatalError); } const volVectorField vectorField(vecFieldHeader, mesh); const scalarField magVecField = magSqr(vectorField.boundaryField()[patchI]); const scalar area = gSum(mesh.magSf().boundaryField()[patchI]); scalar meanSqr = gSum(magVecField * mesh.magSf().boundaryField()[patchI]) / area; Info << " RMS(mag(" << vecFieldName << ")) = " << Foam::sqrt(meanSqr) << endl; Info << " max(mag(" << vecFieldName << ")) = " << Foam::sqrt(Foam::gMax(magVecField)); Info << endl; }
word postProcessingWaves::dataType() { std::stringstream ss; ss << callName_ << "_0"; IOobject fileHeader ( ss.str(), rT_.constant(), addDir_, rT_, IOobject::MUST_READ ); // The inquiry to fileHeader.headerOk() is needed to update // headerClassName() from IOobject. This is weird but not looked into. #if OFPLUSBRANCH == 1 #if OFVERSION<1606 if (!fileHeader.headerOk()) { } #else // Dummy question to read in the class name fileHeader.typeHeaderOk<volScalarField>(false); #endif #else if (!fileHeader.headerOk()) { } #endif if (fileHeader.headerClassName() == "scalarField") { return "scalar"; } else if (fileHeader.headerClassName() == "vectorField") { return "vector"; } else { return "unknown"; } }
Foam::tmp<Foam::IOField<Type>> Foam::reconstructLagrangianField ( const word& cloudName, const polyMesh& mesh, const PtrList<fvMesh>& meshes, const word& fieldName ) { // Construct empty field on mesh tmp<IOField<Type>> tfield ( new IOField<Type> ( IOobject ( fieldName, mesh.time().timeName(), cloud::prefix/cloudName, mesh, IOobject::NO_READ, IOobject::NO_WRITE ), Field<Type>(0) ) ); Field<Type>& field = tfield.ref(); forAll(meshes, i) { // Check object on local mesh IOobject localIOobject ( fieldName, meshes[i].time().timeName(), cloud::prefix/cloudName, meshes[i], IOobject::MUST_READ, IOobject::NO_WRITE ); if (localIOobject.headerOk()) { IOField<Type> fieldi(localIOobject); label offset = field.size(); field.setSize(offset + fieldi.size()); forAll(fieldi, j) { field[offset + j] = fieldi[j]; } }
int main(int argc, char *argv[]) { timeSelector::addOptions(); #include "setRootCase.H" #include "createTime.H" instantList timeDirs = timeSelector::select0(runTime, args); const word vecFieldName = "U"; #include "createMesh.H" runTime.setTime(timeDirs.last(), timeDirs.size()-1); forAll(timeDirs, timeI) { runTime.setTime(timeDirs[timeI], timeI); Info<< "Time = " << runTime.timeName() << endl; Info << " Read vector field " << vecFieldName << endl; IOobject vecFieldHeader ( vecFieldName, runTime.timeName(), mesh, IOobject::MUST_READ, IOobject::NO_WRITE ); if (!vecFieldHeader.headerOk()) { Info << "Unable to read vector field" << vecFieldName << endl; return EXIT_FAILURE; } const volVectorField vecField(vecFieldHeader, mesh); const volScalarField magVecField(magSqr(vecField)); scalar volIntegral2 = 0; vector volIntegral(0, 0, 0); scalar volume = 0; forAll (magVecField, cellI) { volIntegral2 += magVecField[cellI]*magVecField.mesh().V()[cellI]; volIntegral += vecField[cellI]*vecField.mesh().V()[cellI]; volume += magVecField.mesh().V()[cellI]; }
Foam::IOobjectList::IOobjectList ( const objectRegistry& db, const fileName& instance, const fileName& local, IOobject::readOption r, IOobject::writeOption w, bool registerObject ) : HashPtrTable<IOobject>() { word newInstance = instance; if (!isDir(db.path(instance))) { newInstance = db.time().findInstancePath(instant(instance)); if (newInstance.empty()) { return; } } // Create a list of file names in this directory fileNameList ObjectNames = readDir(db.path(newInstance, db.dbDir()/local), fileName::FILE); forAll(ObjectNames, i) { IOobject* objectPtr = new IOobject ( ObjectNames[i], newInstance, local, db, r, w, registerObject ); if (objectPtr->headerOk()) { insert(ObjectNames[i], objectPtr); } else { delete objectPtr; } }
int main(int argc, char *argv[]) { timeSelector::addOptions(); # include "addRegionOption.H" # include "setRootCase.H" # include "createTime.H" instantList timeDirs = timeSelector::select0(runTime, args); # include "createNamedMesh.H" forAll(timeDirs, timeI) { runTime.setTime(timeDirs[timeI], timeI); Info<< "Time = " << runTime.timeName() << nl << endl; const IOobjectList fieldObjs(mesh, runTime.timeName()); const wordList objNames = fieldObjs.names(); PtrList<volScalarField> vsf(objNames.size()); PtrList<volVectorField> vvf(objNames.size()); PtrList<volSphericalTensorField> vsptf(objNames.size()); PtrList<volSymmTensorField> vsytf(objNames.size()); PtrList<volTensorField> vtf(objNames.size()); Info<< "Valid fields:" << endl; forAll(objNames, objI) { IOobject obj ( objNames[objI], runTime.timeName(), mesh, IOobject::MUST_READ ); if (obj.headerOk()) { addToFieldList<scalar>(vsf, obj, objI, mesh); addToFieldList<vector>(vvf, obj, objI, mesh); addToFieldList<sphericalTensor>(vsptf, obj, objI, mesh); addToFieldList<symmTensor>(vsytf, obj, objI, mesh); addToFieldList<tensor>(vtf, obj, objI, mesh); } }
void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh) { bool writeResults = !args.optionFound("noWrite"); IOobject kheader ( "k", runTime.timeName(), mesh, IOobject::MUST_READ ); if (kheader.headerOk()) { Info<< " Reading k" << endl; volScalarField k(kheader, mesh); Info<< " Calculating uprime" << endl; volScalarField uprime ( IOobject ( "uprime", runTime.timeName(), mesh, IOobject::NO_READ ), sqrt((2.0/3.0)*k) ); Info<< "uprime max/min : " << max(uprime).value() << " " << min(uprime).value() << endl; if (writeResults) { uprime.write(); } } else { Info<< " No k" << endl; } Info<< "\nEnd\n" << endl; }
void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh) { bool writeResults = !args.optionFound("noWrite"); IOobject Uheader ( "U", runTime.timeName(), mesh, IOobject::MUST_READ ); if (Uheader.headerOk()) { Info<< " Reading U" << endl; volVectorField U(Uheader, mesh); Info<< " Calculating enstrophy" << endl; volScalarField enstrophy ( IOobject ( "enstrophy", runTime.timeName(), mesh, IOobject::NO_READ ), 0.5*magSqr(fvc::curl(U)) ); Info<< "enstrophy(U) max/min : " << max(enstrophy).value() << " " << min(enstrophy).value() << endl; if (writeResults) { enstrophy.write(); } } else { Info<< " No U" << endl; } Info<< "\nEnd\n" << endl; }
Foam::IOobjectList::IOobjectList ( const objectRegistry& db, const fileName& instance, const fileName& local ) : HashPtrTable<IOobject>() { word newInstance = instance; if (!isDir(db.path(instance))) { newInstance = db.time().findInstancePath(instant(instance)); if (newInstance.empty()) { return; } } // Create list file names in directory fileNameList ObjectNames = readDir(db.path(newInstance, db.dbDir()/local), fileName::FILE); forAll(ObjectNames, i) { IOobject* objectPtr = new IOobject ( ObjectNames[i], newInstance, local, db, IOobject::MUST_READ, IOobject::NO_WRITE ); if (objectPtr->headerOk()) { insert(ObjectNames[i], objectPtr); } else { delete objectPtr; } }
void Foam::calcTypes::interpolate::calc ( const argList& args, const Time& runTime, const fvMesh& mesh ) { #ifdef FOAM_DEV const word& fieldName = args.additionalArgs()[1]; #else const word fieldName = args[2]; #endif IOobject fieldHeader ( fieldName, runTime.timeName(), mesh, IOobject::MUST_READ ); // Check field exists if (fieldHeader.headerOk()) { bool processed = false; writeInterpolateField<scalar>(fieldHeader, mesh, processed); writeInterpolateField<vector>(fieldHeader, mesh, processed); writeInterpolateField<sphericalTensor>(fieldHeader, mesh, processed); writeInterpolateField<symmTensor>(fieldHeader, mesh, processed); writeInterpolateField<tensor>(fieldHeader, mesh, processed); if (!processed) { FatalError << "Unable to process " << fieldName << nl << "No call to interpolate for fields of type " << fieldHeader.headerClassName() << nl << nl << exit(FatalError); } } else { Info<< " No " << fieldName << endl; } }
void calcCompressibleYPlus ( const fvMesh& mesh, const Time& runTime, const volVectorField& U, volScalarField& yPlus ) { IOobject rhoHeader ( "rho", runTime.timeName(), mesh, IOobject::MUST_READ, IOobject::NO_WRITE ); if (!rhoHeader.headerOk()) { Info<< " no rho field" << endl; return; } Info<< "Reading field rho\n" << endl; volScalarField rho(rhoHeader, mesh); #include "compressibleCreatePhi.H" autoPtr<fluidThermo> pThermo(fluidThermo::New(mesh)); fluidThermo& thermo = pThermo(); autoPtr<compressible::turbulenceModel> turbulenceModel ( compressible::turbulenceModel::New ( rho, U, phi, thermo ) ); calcYPlus(turbulenceModel, mesh, U, yPlus); }
void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh) { IOobject Uheader ( "U", runTime.timeName(), mesh, IOobject::MUST_READ ); if (Uheader.headerOk()) { Info<< " Reading U" << endl; volVectorField U(Uheader, mesh); volTensorField gradU = fvc::grad(U); volScalarField magD = mag(symm(gradU)); volScalarField magOmega = mag(skew(gradU)); dimensionedScalar smallMagD("smallMagD", magD.dimensions(), SMALL); Info<< " Calculating flowType" << endl; volScalarField flowType ( IOobject ( "flowType", runTime.timeName(), mesh, IOobject::NO_READ ), (magD - magOmega)/(magD + magOmega + smallMagD) ); flowType.write(); } else { Info<< " No U" << endl; } Info<< "\nEnd\n" << endl; }
void Foam::calcTypes::domainIntegrate::calc ( const argList& args, const Time& runTime, const fvMesh& mesh ) { const word& fieldName = args.additionalArgs()[1]; IOobject fieldHeader ( fieldName, runTime.timeName(), mesh, IOobject::MUST_READ ); // Check field exists if (fieldHeader.headerOk()) { bool processed = false; calcDomainIntegrate<scalar>(fieldHeader, mesh, processed); calcDomainIntegrate<vector>(fieldHeader, mesh, processed); calcDomainIntegrate<sphericalTensor>(fieldHeader, mesh, processed); calcDomainIntegrate<symmTensor>(fieldHeader, mesh, processed); calcDomainIntegrate<tensor>(fieldHeader, mesh, processed); if (!processed) { FatalError << "Unable to process " << fieldName << nl << "No call to mag for fields of type " << fieldHeader.headerClassName() << nl << nl << exit(FatalError); } } else { Info<< " No " << fieldName << endl; } }
void Foam::calcTypes::components::calc ( const argList& args, const Time& runTime, const fvMesh& mesh ) { const word fieldName = args[2]; IOobject fieldHeader ( fieldName, runTime.timeName(), mesh, IOobject::MUST_READ ); // Check field exists if (fieldHeader.headerOk()) { bool processed = false; writeComponentFields<vector>(fieldHeader, mesh, processed); writeComponentFields<sphericalTensor>(fieldHeader, mesh, processed); writeComponentFields<symmTensor>(fieldHeader, mesh, processed); writeComponentFields<tensor>(fieldHeader, mesh, processed); if (!processed) { FatalError << "Unable to process " << fieldName << nl << "No call to components for fields of type " << fieldHeader.headerClassName() << nl << nl << exit(FatalError); } } else { Info<< " No " << fieldName << endl; } }
bool loadFieldFunction( fvMesh &mesh, const word &fName, SLPtrList<FieldType> &fieldList ) { const Time &runTime=mesh.time(); IOobject f ( fName, runTime.timeName(), mesh, IOobject::MUST_READ, IOobject::NO_WRITE ); f.headerOk(); word className=f.headerClassName(); if(className==FieldType::typeName) { Info << "Reading field " << fName << " of type " << FieldType::typeName << endl; fieldList.append( new FieldType ( IOobject ( fName, runTime.timeName(), mesh, IOobject::MUST_READ, IOobject::AUTO_WRITE ), mesh ) ); return true; } else { return false; } }
void Foam::calcTypes::div::calc ( const argList& args, const Time& runTime, const fvMesh& mesh ) { const word fieldName = args[2]; IOobject fieldHeader ( fieldName, runTime.timeName(), mesh, IOobject::MUST_READ ); // Check field exists if (fieldHeader.headerOk()) { bool processed = false; writeDivField<surfaceScalarField>(fieldHeader, mesh, processed); writeDivField<volVectorField>(fieldHeader, mesh, processed); if (!processed) { FatalError << "Unable to process " << fieldName << nl << "No call to div for fields of type " << fieldHeader.headerClassName() << nl << nl << exit(FatalError); } } else { Info<< " No " << fieldName << endl; } }
void Foam::InjectionModel<CloudType>::readProps() { IOobject propsDictHeader ( "injectionProperties", owner_.db().time().timeName(), "uniform"/cloud::prefix/owner_.name(), owner_.db(), IOobject::MUST_READ, IOobject::NO_WRITE, false ); if (propsDictHeader.headerOk()) { const IOdictionary propsDict(propsDictHeader); propsDict.readIfPresent("massInjected", massInjected_); propsDict.readIfPresent("nInjections", nInjections_); propsDict.readIfPresent("parcelsAddedTotal", parcelsAddedTotal_); propsDict.readIfPresent("timeStep0", timeStep0_); } }