Foam::IOList<T>::IOList(const IOobject& io) : regIOobject(io) { // Temporary warning if (io.readOpt() == IOobject::MUST_READ_IF_MODIFIED) { WarningIn("IOList::IOList(const IOobject&)") << "IOList " << name() << " constructed with IOobject::MUST_READ_IF_MODIFIED" " but IOList does not support automatic rereading." << endl; } if ( ( io.readOpt() == IOobject::MUST_READ || io.readOpt() == IOobject::MUST_READ_IF_MODIFIED ) || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk()) ) { readStream(typeName) >> *this; close(); }
Foam::surfMesh::surfMesh(const IOobject& io, const word& surfName) : surfaceRegistry(io.db(), (surfName.size() ? surfName : io.name())), Allocator ( IOobject ( "points", time().findInstance(meshDir(), "points"), meshSubDir, *this, IOobject::MUST_READ, IOobject::NO_WRITE ), IOobject ( "faces", time().findInstance(meshDir(), "faces"), meshSubDir, *this, IOobject::MUST_READ, IOobject::NO_WRITE ), IOobject ( "surfZones", time().findInstance(meshDir(), "surfZones"), meshSubDir, *this, IOobject::MUST_READ, IOobject::NO_WRITE ) ), MeshReference(this->storedIOFaces(), this->storedIOPoints()) {}
Foam::IOobject Foam::IOporosityModelList::createIOobject ( const fvMesh& mesh ) const { IOobject io ( "porosityProperties", mesh.time().constant(), mesh, IOobject::MUST_READ, IOobject::NO_WRITE ); if (io.typeHeaderOk<IOdictionary>(true)) { Info<< "Creating porosity model list from " << io.name() << nl << endl; io.readOpt() = IOobject::MUST_READ_IF_MODIFIED; return io; } else { Info<< "No porosity models present" << nl << endl; io.readOpt() = IOobject::NO_READ; return io; } }
void printSum ( const fvMesh& mesh, const IOobject& fieldHeader, const label patchI, bool& done ) { if (!done && fieldHeader.headerClassName() == FieldType::typeName) { Info<< " Reading " << FieldType::typeName << " " << fieldHeader.name() << endl; FieldType field(fieldHeader, mesh); typename FieldType::value_type sumField = gSum ( field.boundaryField()[patchI] ); Info<< " Integral of " << fieldHeader.name() << " over patch " << mesh.boundary()[patchI].name() << '[' << patchI << ']' << " = " << sumField << nl; done = true; } }
void Foam::calcTypes::curl::writeCurlField ( const IOobject& header, const fvMesh& mesh, bool& processed ) { typedef GeometricField<Type, fvPatchField, volMesh> fieldType; if (header.headerClassName() == fieldType::typeName) { Info<< " Reading " << header.name() << endl; fieldType field(header, mesh); Info<< " Calculating curl" << header.name() << endl; volVectorField curlField ( IOobject ( "curl" + header.name(), mesh.time().timeName(), mesh, IOobject::NO_READ ), Foam::fvc::curl(field) ); curlField.write(); processed = true; } }
void Foam::calcTypes::interpolate::writeInterpolateField ( const IOobject& header, const fvMesh& mesh, bool& processed ) { typedef GeometricField<Type, fvPatchField, volMesh> fieldType; typedef GeometricField<Type, fvsPatchField, surfaceMesh> surfaceFieldType; if (header.headerClassName() == fieldType::typeName) { Info<< " Reading " << header.name() << endl; fieldType field(header, mesh); Info<< " Calculating interpolate" << header.name() << endl; surfaceFieldType interpolateField ( IOobject ( "interpolate" + header.name(), mesh.time().timeName(), mesh, IOobject::NO_READ ), fvc::interpolate(field) ); interpolateField.write(); processed = true; } }
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; } }
bool Foam::sampledSets::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)"; } } }
Foam::solidBodyMotionFvMesh::solidBodyMotionFvMesh(const IOobject& io) : dynamicFvMesh(io), dynamicMeshCoeffs_ ( IOdictionary ( IOobject ( "dynamicMeshDict", io.time().constant(), *this, IOobject::MUST_READ, IOobject::NO_WRITE ) ).subDict(typeName + "Coeffs") ), SBMFPtr_(solidBodyMotionFunction::New(dynamicMeshCoeffs_, io.time())), undisplacedPoints_ ( IOobject ( "points", io.time().constant(), meshSubDir, *this, IOobject::MUST_READ, IOobject::NO_WRITE ) ) {}
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); } }
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[]) { argList::validArgs.append("scaling factor"); # include <OpenFOAM/setRootCase.H> scalar scaleFactor(readScalar(IStringStream(args.additionalArgs()[0])())); # include <OpenFOAM/createTime.H> # include <OpenFOAM/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; }
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; }
Foam::IOdictionary::IOdictionary(const IOobject& io, const dictionary& dict) : regIOobject(io) { // Temporary warning if (debug && io.readOpt() == IOobject::MUST_READ) { WarningInFunction << "Dictionary " << name() << " constructed with IOobject::MUST_READ" " instead of IOobject::MUST_READ_IF_MODIFIED." << nl << "Use MUST_READ_IF_MODIFIED if you need automatic rereading." << endl; } // Everyone check or just master bool masterOnly = regIOobject::fileModificationChecking == timeStampMaster || regIOobject::fileModificationChecking == inotifyMaster; // Check if header is ok for READ_IF_PRESENT bool isHeaderOk = false; if (io.readOpt() == IOobject::READ_IF_PRESENT) { if (masterOnly) { if (Pstream::master()) { isHeaderOk = headerOk(); } Pstream::scatter(isHeaderOk); } else { isHeaderOk = headerOk(); } } if ( ( io.readOpt() == IOobject::MUST_READ || io.readOpt() == IOobject::MUST_READ_IF_MODIFIED ) || isHeaderOk ) { readFile(masterOnly); } else { dictionary::operator=(dict); } dictionary::name() = IOobject::objectPath(); }
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; }
Foam::fileName Foam::fileOperations::masterFileOperation::processorsCasePath ( const IOobject& io ) { return io.rootPath() /io.time().globalCaseName() /"processors"; }
Foam::autoPtr<Foam::dynamicFvMesh> Foam::dynamicFvMesh::New(const IOobject& io) { // Enclose the creation of the dynamicMesh to ensure it is // deleted before the dynamicFvMesh is created otherwise the dictionary // is entered in the database twice IOdictionary dynamicMeshDict ( IOobject ( "dynamicMeshDict", io.time().constant(), io.db(), IOobject::MUST_READ, IOobject::NO_WRITE, false ) ); word dynamicFvMeshTypeName(dynamicMeshDict.lookup("dynamicFvMesh")); Info<< "Selecting dynamicFvMesh " << dynamicFvMeshTypeName << endl; dlLibraryTable::open ( dynamicMeshDict, "dynamicFvMeshLibs", IOobjectConstructorTablePtr_ ); if (!IOobjectConstructorTablePtr_) { FatalErrorIn ( "dynamicFvMesh::New(const IOobject&)" ) << "dynamicFvMesh table is empty" << exit(FatalError); } IOobjectConstructorTable::iterator cstrIter = IOobjectConstructorTablePtr_->find(dynamicFvMeshTypeName); if (cstrIter == IOobjectConstructorTablePtr_->end()) { FatalErrorIn ( "dynamicFvMesh::New(const IOobject&)" ) << "Unknown dynamicFvMesh type " << dynamicFvMeshTypeName << endl << endl << "Valid dynamicFvMesh types are :" << endl << IOobjectConstructorTablePtr_->sortedToc() << exit(FatalError); } return autoPtr<dynamicFvMesh>(cstrIter()(io)); }
Foam::autoPtr<Foam::dynamicFvMesh> Foam::dynamicFvMesh::New(const IOobject& io) { // Note: - do not register the dictionary since dynamicFvMeshes themselves // do this. // - defaultRegion (region0) gets loaded from constant, other ones // get loaded from constant/<regionname>. Normally we'd use // polyMesh::dbDir() but we haven't got a polyMesh yet ... IOdictionary dict ( IOobject ( "dynamicMeshDict", io.time().constant(), (io.name() == polyMesh::defaultRegion ? "" : io.name()), io.db(), IOobject::MUST_READ_IF_MODIFIED, IOobject::NO_WRITE, false ) ); const word dynamicFvMeshTypeName(dict.lookup("dynamicFvMesh")); 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)); }
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; } }
Foam::fileName Foam::fileOperations::masterFileOperation::processorsPath ( const IOobject& io, const word& instance ) { return processorsCasePath(io) /instance /io.db().dbDir() /io.local(); }
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::IOList<T>::IOList(const IOobject& io) : regIOobject(io) { if ( io.readOpt() == IOobject::MUST_READ || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk()) ) { readStream(typeName) >> *this; close(); }
Foam::binaryOperationSearchableSurface::binaryOperationSearchableSurface ( const IOobject& io, const dictionary& dict ) : searchableSurface(io), aName_(dict.lookupOrDefault<word>("aName","A")), bName_(dict.lookupOrDefault<word>("bName","B")), a_( searchableSurface::New ( word(dict.subDict("a").lookup("type")), IOobject( name()+"_"+word(dict.lookup("type"))+"_"+aName_, io.instance(), io.db(), io.readOpt(), io.writeOpt() ), dict.subDict("a") ) ), b_( searchableSurface::New ( word(dict.subDict("b").lookup("type")), IOobject( name()+"_"+word(dict.lookup("type"))+"_"+bName_, io.instance(), io.db(), io.readOpt(), io.writeOpt() ), dict.subDict("b") ) ), nrARegions_( a().regions().size() ), nrBRegions_( b().regions().size() ) { if(aName_==bName_) { FatalErrorIn("binaryOperationSearchableSurface::binaryOperationSearchableSurface") << "'aName' and 'bName' have the same value " << aName_ << " for " << name() << endl << exit(FatalError); } if(regions().size()!=size()) { FatalErrorIn("binaryOperationSearchableSurface::binaryOperationSearchableSurface") << "Number of regions " << regions().size() << " not equal to size " << size() << nl << "Regions: " << regions() << endl << exit(FatalError); } }
Foam::featureEdgeMesh::featureEdgeMesh(const IOobject& io) : regIOobject(io), edgeMesh(pointField(0), edgeList(0)) { if ( io.readOpt() == IOobject::MUST_READ || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk()) ) { readStream(typeName) >> *this; close(); }
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; } }
Foam::IOPtrList<T>::IOPtrList(const IOobject& io) : regIOobject(io) { if ( io.readOpt() == IOobject::MUST_READ || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk()) ) { PtrList<T>::read(readStream(typeName), INew<T>()); close(); } }
Foam::objectRegistry::objectRegistry ( const IOobject& io, const label nIoObjects ) : regIOobject(io), HashTable<regIOobject*>(nIoObjects), time_(io.time()), parent_(io.db()), dbDir_(parent_.dbDir()/local()/name()), event_(1) { writeOpt() = IOobject::AUTO_WRITE; }
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); } }
Foam::tmp<Foam::DimensionedField<Type, Foam::volMesh>> Foam::fvFieldReconstructor::reconstructFvVolumeInternalField ( const IOobject& fieldIoObject ) const { // Read the field for all the processors PtrList<DimensionedField<Type, volMesh>> procFields ( procMeshes_.size() ); forAll(procMeshes_, proci) { procFields.set ( proci, new DimensionedField<Type, volMesh> ( IOobject ( fieldIoObject.name(), procMeshes_[proci].time().timeName(), procMeshes_[proci], IOobject::MUST_READ, IOobject::NO_WRITE ), procMeshes_[proci] ) ); }