TimeIO.C

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     | Website:  https://openfoam.org
    \\  /    A nd           | Copyright (C) 2011-2024 OpenFOAM Foundation
     \\/     M anipulation  |
-------------------------------------------------------------------------------
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 "timeIOdictionary.H"
#include "OSspecific.H"
 
// * * * * * * * * * * * * * * * 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);
    }
 
    if (!deltaTchanged_)
    {
        deltaT_ = controlDict_.lookup<scalar>("deltaT", userUnits());
    }
 
    if (controlDict_.found("writeControl"))
    {
        writeControl_ = writeControlNames.read
        (
            controlDict_.lookup("writeControl")
        );
    }
 
    const scalar newWriteInterval =
        controlDict_.lookupBackwardsCompatible<scalar>
        (
            {"writeInterval", "writeFrequency"},
            writeIntervalUnits()
        );
 
    if
    (
        writeControl_ == writeControl::timeStep
     && label(newWriteInterval) < 1
    )
    {
        FatalIOErrorInFunction(controlDict_)
            << "writeInterval < 1 for writeControl timeStep"
            << exit(FatalIOError);
    }
 
    setWriteInterval(newWriteInterval);
 
    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_.lookup("timeFormat"));
 
        if (formatName == "general")
        {
            format_ = format::general;
        }
        else if (formatName == "fixed")
        {
            format_ = format::fixed;
        }
        else if (formatName == "scientific")
        {
            format_ = format::scientific;
        }
        else
        {
            WarningInFunction
                << "unsupported time format " << formatName
                << endl;
        }
    }
 
    controlDict_.readIfPresent("timePrecision", precision_);
    curPrecision_ = precision_;
 
    // stopAt at 'endTime' or a specified value
    // if nothing is specified, the endTime is zero
    if (controlDict_.found("stopAt"))
    {
        stopAt_ = stopAtControlNames.read(controlDict_.lookup("stopAt"));
 
        if (stopAt_ == stopAtControl::endTime || controlDict_.found("endTime"))
        {
            endTime_ = userTimeToTime(controlDict_.lookup<scalar>("endTime"));
        }
        else
        {
            endTime_ = great;
        }
    }
    else if (!controlDict_.readIfPresent("endTime", endTime_))
    {
        endTime_ = 0;
    }
 
    dimensionedScalar::name() = timeName(timeToUserTime(value()));
 
    if (controlDict_.found("writeVersion"))
    {
        writeVersion_ = IOstream::versionNumber
        (
            controlDict_.lookup("writeVersion")
        );
    }
 
    if (controlDict_.found("writeFormat"))
    {
        writeFormat_ = IOstream::formatEnum
        (
            controlDict_.lookup("writeFormat")
        );
    }
 
    if (controlDict_.found("writePrecision"))
    {
        IOstream::defaultPrecision
        (
            controlDict_.lookup<unsigned int>("writePrecision")
        );
 
        Sout.precision(IOstream::defaultPrecision());
        Serr.precision(IOstream::defaultPrecision());
 
        Pout.precision(IOstream::defaultPrecision());
        Perr.precision(IOstream::defaultPrecision());
 
        FatalError().precision(IOstream::defaultPrecision());
        FatalIOError.error::operator()().precision
        (
            IOstream::defaultPrecision()
        );
    }
 
    if (controlDict_.found("writeCompression"))
    {
        writeCompression_ = IOstream::compressionEnum
        (
            controlDict_.lookup("writeCompression")
        );
 
        if
        (
            writeFormat_ == IOstream::BINARY
         && writeCompression_ == IOstream::COMPRESSED
        )
        {
            IOWarningInFunction(controlDict_)
                << "Selecting compressed binary is inefficient and ineffective"
                   ", resetting to uncompressed binary"
                << endl;
 
            writeCompression_ = IOstream::UNCOMPRESSED;
        }
    }
 
    controlDict_.readIfPresent("runTimeModifiable", runTimeModifiable_);
 
    userTime_->read(controlDict_);
}
 
 
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
        (
            (
                regIOobject::fileModificationChecking == inotifyMaster
             || regIOobject::fileModificationChecking == timeStampMaster
            ),
            Pstream::parRun()
        );
 
        objectRegistry::readModifiedObjects();
    }
}
 
 
bool Foam::Time::writeTimeDict() const
{
    const word tmName(name());
 
    timeIOdictionary timeDict
    (
        IOobject
        (
            "time",
            tmName,
            "uniform",
            *this,
            IOobject::NO_READ,
            IOobject::NO_WRITE,
            false
        )
    );
 
    timeDict.add("beginTime", timeToUserTime(beginTime_));
    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
    (
        IOstream::ASCII,
        IOstream::currentVersion,
        IOstream::UNCOMPRESSED,
        true
    );
}
 
 
bool Foam::Time::writeObject
(
    IOstream::streamFormat fmt,
    IOstream::versionNumber ver,
    IOstream::compressionType cmp,
    const bool write
) const
{
    if (writeTime())
    {
        bool writeOK = writeTimeDict();
 
        if (writeOK)
        {
            writeOK = objectRegistry::writeObject(fmt, ver, cmp, write);
        }
 
        if (writeOK)
        {
            // Does the writeTime trigger purging?
            if (writeTime_ && purgeWrite_)
            {
                if
                (
                    previousWriteTimes_.size() == 0
                 || previousWriteTimes_.top() != name()
                )
                {
                    previousWriteTimes_.push(name());
                }
 
                while (previousWriteTimes_.size() > purgeWrite_)
                {
                    fileHandler().rmDir
                    (
                        fileHandler().filePath
                        (
                            objectRegistry::path(previousWriteTimes_.pop())
                        )
                    );
                }
            }
        }
 
        return writeOK;
    }
    else
    {
        return false;
    }
}
 
 
bool Foam::Time::writeNow()
{
    writeTime_ = true;
    return write();
}
 
 
bool Foam::Time::writeAndEnd()
{
    stopAt_  = stopAtControl::writeNow;
    endTime_ = value();
 
    return writeNow();
}
 
 
void Foam::Time::writeOnce()
{
    writeOnce_ = true;
}
 
 
// ************************************************************************* //