-
Mark OLESEN authored- provide a plain stream() method on messageStream to reduce reliance on casting operators and slightly opaque operator()() calls etc - support alternative stream for messageStream serial output. This can be used to support local redirection of output. For example, refPtr<OFstream> logging; // or autoPtr, unique_ptr etc // Later... Info.stream(logging.get()) << "Detailed output ..." << endl; This will use the stdout semantics in the normal case, or allow redirection to an output file if a target output stream is defined, but still effectively use /dev/null on non-master processes. This is mostly the same as this ternary (logging ? *logging : Info()) except that the ternary could be incorrect on sub-processes, requires more typing etc. ENH: use case-relative names of dictionary, IOstream for FatalIOError - normally yields more easily understandable informationMark OLESEN authored- provide a plain stream() method on messageStream to reduce reliance on casting operators and slightly opaque operator()() calls etc - support alternative stream for messageStream serial output. This can be used to support local redirection of output. For example, refPtr<OFstream> logging; // or autoPtr, unique_ptr etc // Later... Info.stream(logging.get()) << "Detailed output ..." << endl; This will use the stdout semantics in the normal case, or allow redirection to an output file if a target output stream is defined, but still effectively use /dev/null on non-master processes. This is mostly the same as this ternary (logging ? *logging : Info()) except that the ternary could be incorrect on sub-processes, requires more typing etc. ENH: use case-relative names of dictionary, IOstream for FatalIOError - normally yields more easily understandable information
TimeIO.C 16.33 KiB
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2017 OpenFOAM Foundation
Copyright (C) 2016-2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "Time.H"
#include "argList.H"
#include "Pstream.H"
#include "simpleObjectRegistry.H"
#include "dimensionedConstants.H"
#include "profiling.H"
#include "IOdictionary.H"
#include "fileOperation.H"
#include "fstreamPointer.H"
#include <iomanip>
// * * * * * * * * * * * * * * * Local Functions * * * * * * * * * * * * * * //
namespace Foam
{
// Output seconds as day-hh:mm:ss
static std::ostream& printTimeHMS(std::ostream& os, double seconds)
{
const unsigned long ss = seconds;
// days
const auto dd = (ss / 86400);
if (dd) os << dd << '-';
// hours
const int hh = ((ss / 3600) % 24);
if (dd || hh)
{
os << std::setw(2) << std::setfill('0')
<< hh << ':';
}
// minutes
os << std::setw(2) << std::setfill('0')
<< ((ss / 60) % 60) << ':';
// seconds
os << std::setw(2) << std::setfill('0') << (ss % 60);
// 1/100th seconds. As none or 2 decimal places
const int hundredths = int(100 * (seconds - ss)) % 100;
if (hundredths)
{
os << '.' << std::setw(2) << std::setfill('0') << hundredths;
}
return os;
}
} // End namespace Foam
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::Time::readDict()
{
word application;
if (controlDict_.readIfPresent("application", application))
{
// Do not override if already set so external application can override
setEnv("FOAM_APPLICATION", application, false);
}
// Check for local switches and settings
const dictionary* localDict = nullptr;
// DebugSwitches
if
(
(localDict = controlDict_.findDict("DebugSwitches")) != nullptr
&& localDict->size()
)
{
DetailInfo
<< "Overriding DebugSwitches according to "
<< controlDict_.name() << nl;
debug::debugObjects().setValues(*localDict, true);
}
// InfoSwitches
if
(
(localDict = controlDict_.findDict("InfoSwitches")) != nullptr
&& localDict->size()
)
{
DetailInfo
<< "Overriding InfoSwitches according to "
<< controlDict_.name() << nl;
debug::infoObjects().setValues(*localDict, true);
}
// OptimisationSwitches
if
(
(localDict = controlDict_.findDict("OptimisationSwitches")) != nullptr
&& localDict->size()
)
{
DetailInfo
<< "Overriding OptimisationSwitches according to " << controlDict_.name() << nl;
debug::optimisationObjects().setValues(*localDict, true);
}
// Handle fileHandler explicitly since it affects local dictionary
// monitoring.
word fileHandlerName;
if
(
localDict
&& localDict->readIfPresent("fileHandler", fileHandlerName)
&& fileHandler().type() != fileHandlerName
)
{
DetailInfo << "Overriding fileHandler to " << fileHandlerName << nl;
// Remove old watches since destroying the file
fileNameList oldWatched(controlDict_.watchIndices().size());
forAllReverse(controlDict_.watchIndices(), i)
{
const label watchi = controlDict_.watchIndices()[i];
oldWatched[i] = fileHandler().getFile(watchi);
fileHandler().removeWatch(watchi);
}
controlDict_.watchIndices().clear();
// The new handler, with verbosity
autoPtr<fileOperation> newHandler =
fileOperation::New(fileHandlerName, true);
if (TimePaths::distributed() && newHandler)
{
newHandler->distributed(true);
}
// Installing the new handler
Foam::fileHandler(std::move(newHandler));
// Reinstall old watches
fileHandler().addWatches(controlDict_, oldWatched);
}
// DimensionedConstants.
// - special case since it may change both the 'unitSet' and the
// individual values
if
(
(localDict = controlDict_.findDict("DimensionedConstants")) != nullptr
&& localDict->size()
)
{
DetailInfo
<< "Overriding DimensionedConstants according to "
<< controlDict_.name() << nl;
simpleObjectRegistry& objs = debug::dimensionedConstantObjects();
// Change in-memory
dimensionedConstants().merge(*localDict);
IStringStream dummyIs("");
forAllConstIters(objs, iter)
{
const List<simpleRegIOobject*>& objects = *iter;
for (simpleRegIOobject* obj : objects)
{
obj->readData(dummyIs);
if (Foam::infoDetailLevel > 0)
{
Info<< " ";
obj->writeData(Info);
Info<< nl;
}
}
}
}
// DimensionSets
if
(
(localDict = controlDict_.findDict("DimensionSets")) != nullptr
&& localDict->size()
)
{
DetailInfo
<< "Overriding DimensionSets according to "
<< controlDict_.name() << nl;
simpleObjectRegistry& objs = debug::dimensionSetObjects();
dictionary dict(Foam::dimensionSystems());
dict.merge(*localDict);
simpleObjectRegistryEntry* objPtr = objs.find("DimensionSets");
if (objPtr)
{
DetailInfo << *localDict << nl;
const List<simpleRegIOobject*>& objects = *objPtr;
for (simpleRegIOobject* obj : objects)
{
OStringStream os;
os << dict;
IStringStream is(os.str());
obj->readData(is);
}
}
}
if (!deltaTchanged_)
{
controlDict_.readEntry("deltaT", deltaT_);
}
writeControlNames.readIfPresent
(
"writeControl",
controlDict_,
writeControl_
);
scalar oldWriteInterval = writeInterval_;
if (controlDict_.readIfPresent("writeInterval", writeInterval_))
{
if (writeControl_ == wcTimeStep && label(writeInterval_) < 1)
{
FatalIOErrorInFunction(controlDict_)
<< "writeInterval < 1 for writeControl timeStep" << exit(FatalIOError);
}
}
else
{
controlDict_.readEntry("writeFrequency", writeInterval_);
}
if (oldWriteInterval != writeInterval_)
{
switch (writeControl_)
{
case wcRunTime:
case wcAdjustableRunTime:
// Recalculate writeTimeIndex_ to be in units of current
// writeInterval.
writeTimeIndex_ = label
(
writeTimeIndex_
* oldWriteInterval
/ writeInterval_
);
break;
default:
break;
}
}
if (controlDict_.readIfPresent("purgeWrite", purgeWrite_))
{
if (purgeWrite_ < 0)
{
WarningInFunction
<< "invalid value for purgeWrite " << purgeWrite_
<< ", should be >= 0, setting to 0"
<< endl;
purgeWrite_ = 0;
}
}
if (controlDict_.found("timeFormat"))
{
const word formatName(controlDict_.get<word>("timeFormat"));
if (formatName == "general")
{
format_ = general;
}
else if (formatName == "fixed")
{
format_ = fixed;
}
else if (formatName == "scientific")
{
format_ = scientific;
}
else
{
WarningInFunction
<< "unsupported time format " << formatName
<< endl;
}
}
controlDict_.readIfPresent("timePrecision", precision_);
// stopAt at 'endTime' or a specified value // if nothing is specified, the endTime is zero
if (stopAtControlNames.readIfPresent("stopAt", controlDict_, stopAt_))
{
if (stopAt_ == saEndTime)
{
controlDict_.readEntry("endTime", endTime_);
}
else
{
endTime_ = GREAT;
}
}
else if (!controlDict_.readIfPresent("endTime", endTime_))
{
endTime_ = 0;
}
dimensionedScalar::name() = timeName(value());
if (controlDict_.found("writeVersion"))
{
writeStreamOption_.version(controlDict_.get<token>("writeVersion"));
}
if (controlDict_.found("writeFormat"))
{
writeStreamOption_.format(controlDict_.get<word>("writeFormat"));
}
if (controlDict_.found("writePrecision"))
{
IOstream::defaultPrecision
(
controlDict_.get<unsigned int>("writePrecision")
);
Sout.precision(IOstream::defaultPrecision());
Serr.precision(IOstream::defaultPrecision());
Pout.precision(IOstream::defaultPrecision());
Perr.precision(IOstream::defaultPrecision());
FatalError.stream().precision(IOstream::defaultPrecision());
FatalIOError.stream().precision(IOstream::defaultPrecision());
}
if (controlDict_.found("writeCompression"))
{
writeStreamOption_.compression
(
controlDict_.get<word>("writeCompression")
);
if (writeStreamOption_.compression() == IOstreamOption::COMPRESSED)
{
if (writeStreamOption_.format() == IOstreamOption::BINARY)
{
IOWarningInFunction(controlDict_)
<< "Disabled binary format compression"
<< " (inefficient/ineffective)"
<< endl;
writeStreamOption_.compression(IOstreamOption::UNCOMPRESSED);
}
else if (!ofstreamPointer::supports_gz())
{
IOWarningInFunction(controlDict_)
<< "Disabled output compression"
<< " (missing libz support)"
<< endl;
writeStreamOption_.compression(IOstreamOption::UNCOMPRESSED);
}
}
}
controlDict_.readIfPresent("graphFormat", graphFormat_);
controlDict_.readIfPresent("runTimeModifiable", runTimeModifiable_);
if (!runTimeModifiable_ && controlDict_.watchIndices().size())
{
forAllReverse(controlDict_.watchIndices(), i)
{
fileHandler().removeWatch(controlDict_.watchIndices()[i]);
}
controlDict_.watchIndices().clear();
}
}
bool Foam::Time::read()
{
if (controlDict_.regIOobject::read())
{
// Read contents
readDict();
functionObjects_.read();
if (runTimeModifiable_)
{
// For IOdictionary the call to regIOobject::read() would have
// already updated all the watchIndices via the addWatch but
// controlDict_ is an unwatchedIOdictionary so will only have
// stored the dependencies as files.
fileHandler().addWatches(controlDict_, controlDict_.files());
}
controlDict_.files().clear();
return true;
}
return false;
}
void Foam::Time::readModifiedObjects()
{
if (runTimeModifiable_)
{
// Get state of all monitored objects (=registered objects with a
// valid filePath).
// Note: requires same ordering in objectRegistries on different
// processors!
fileHandler().updateStates
(
(
IOobject::fileModificationChecking == IOobject::inotifyMaster
|| IOobject::fileModificationChecking == IOobject::timeStampMaster
),
Pstream::parRun()
);
// Time handling is special since controlDict_ is the one dictionary
// that is not registered to any database.
if (controlDict_.readIfModified())
{
readDict();
functionObjects_.read();
if (runTimeModifiable_)
{
// For IOdictionary the call to regIOobject::read() would have
// already updated all the watchIndices via the addWatch but
// controlDict_ is an unwatchedIOdictionary so will only have
// stored the dependencies as files.
fileHandler().addWatches(controlDict_, controlDict_.files());
}
controlDict_.files().clear();
}
bool registryModified = objectRegistry::modified();
if (registryModified)
{
objectRegistry::readModifiedObjects();
}
}
}
bool Foam::Time::writeTimeDict() const
{
addProfiling(writing, "objectRegistry::writeObject");
const word tmName(timeName());
IOdictionary timeDict
(
IOobject
(
"time",
tmName,
"uniform",
*this,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
)
);
timeDict.add("value", timeName(timeToUserTime(value()), maxPrecision_));
timeDict.add("name", string(tmName));
timeDict.add("index", timeIndex_);
timeDict.add("deltaT", timeToUserTime(deltaT_));
timeDict.add("deltaT0", timeToUserTime(deltaT0_));
return timeDict.regIOobject::writeObject
(
IOstreamOption(IOstreamOption::ASCII),
true
);
}
bool Foam::Time::writeObject
(
IOstreamOption streamOpt,
const bool valid
) const
{
if (writeTime())
{
bool writeOK = writeTimeDict();
if (writeOK)
{
writeOK = objectRegistry::writeObject(streamOpt, valid);
}
if (writeOK)
{
// Does the writeTime trigger purging?
if (writeTime_ && purgeWrite_)
{
if
(
previousWriteTimes_.empty()
|| previousWriteTimes_.top() != timeName()
)
{
previousWriteTimes_.push(timeName());
}
while (previousWriteTimes_.size() > purgeWrite_)
{
fileHandler().rmDir
(
fileHandler().filePath
(
objectRegistry::path(previousWriteTimes_.pop())
)
);
}
}
}
return writeOK;
}
return false;
}
bool Foam::Time::writeNow()
{
writeTime_ = true;
return write();
}
bool Foam::Time::writeAndEnd()
{
stopAt_ = saWriteNow;
endTime_ = value();
return writeNow();
}
void Foam::Time::writeOnce()
{
writeOnce_ = true;
}
Foam::Ostream& Foam::Time::printExecutionTime(OSstream& os) const
{
switch (printExecutionFormat_)
{
case 1:
{
os << "ExecutionTime = ";
printTimeHMS(os.stdStream(), elapsedCpuTime());
os << " ClockTime = ";
printTimeHMS(os.stdStream(), elapsedClockTime());
}
break;
default:
{
os << "ExecutionTime = " << elapsedCpuTime() << " s"
<< " ClockTime = " << elapsedClockTime() << " s";
}
break;
}
os << nl << endl;
return os;
}
// ************************************************************************* //