src/OpenFOAM/db/Time/Time.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software: you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     Foam::Time
  26
  27 Description
  28     Class to control time during OpenFOAM simulations that is also the
  29     top-level objectRegistry.
  30
  31 SourceFiles
  32     Time.C
  33     TimeIO.C
  34     findInstance.C
  35
  36 \*---------------------------------------------------------------------------*/
  37
  38 #ifndef Time_H
  39 #define Time_H
  40
  41 #include "TimePaths.H"
  42 #include "objectRegistry.H"
  43 #include "IOdictionary.H"
  44 #include "FIFOStack.H"
  45 #include "clock.H"
  46 #include "cpuTime.H"
  47 #include "TimeState.H"
  48 #include "Switch.H"
  49 #include "instantList.H"
  50 #include "NamedEnum.H"
  51 #include "typeInfo.H"
  52 #include "dlLibraryTable.H"
  53 #include "functionObjectList.H"
  54 #include "fileMonitor.H"
  55
  56 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  57
  58 namespace Foam
  59 {
  60 // Forward declaration of classes
  61 class argList;
  62
  63 /*---------------------------------------------------------------------------*\
  64                              Class Time Declaration
  65 \*---------------------------------------------------------------------------*/
  66
  67 class Time
  68 :
  69     public clock,
  70     public cpuTime,
  71     public TimePaths,
  72     public objectRegistry,
  73     public TimeState
  74 {
  75     // Private data
  76
  77         //- file-change monitor for all registered files
  78         mutable autoPtr<fileMonitor> monitorPtr_;
  79
  80         //- Any loaded dynamic libraries. Make sure to construct before
  81         //  reading controlDict.
  82         dlLibraryTable libs_;
  83
  84         //- The controlDict
  85         IOdictionary controlDict_;
  86
  87 public:
  88
  89         //- Write control options
  90         enum writeControls
  91         {
  92             wcTimeStep,
  93             wcRunTime,
  94             wcAdjustableRunTime,
  95             wcClockTime,
  96             wcCpuTime
  97         };
  98
  99         //- Stop-run control options
 100         enum stopAtControls
 101         {
 102             saEndTime,    /*!< stop when Time reaches the prescribed endTime */
 103             saNoWriteNow, /*!< set endTime to stop immediately w/o writing */
 104             saWriteNow,   /*!< set endTime to stop immediately w/ writing */
 105             saNextWrite   /*!< stop the next time data are written */
 106         };
 107
 108         //- Supported time directory name formats
 109         enum fmtflags
 110         {
 111             general    = 0,
 112             fixed      = ios_base::fixed,
 113             scientific = ios_base::scientific
 114         };
 115
 116
 117 protected:
 118
 119     // Protected data
 120
 121         label  startTimeIndex_;
 122         scalar startTime_;
 123         mutable scalar endTime_;
 124
 125         static const NamedEnum<stopAtControls, 4> stopAtControlNames_;
 126         mutable stopAtControls stopAt_;
 127
 128         static const NamedEnum<writeControls, 5> writeControlNames_;
 129         writeControls writeControl_;
 130
 131         scalar writeInterval_;
 132
 133         label  purgeWrite_;
 134         mutable FIFOStack<word> previousOutputTimes_;
 135
 136         //- Is the time currently being sub-cycled?
 137         bool subCycling_;
 138
 139         //- If time is being sub-cycled this is the previous TimeState
 140         autoPtr<TimeState> prevTimeState_;
 141
 142         //- Time directory name format
 143         static fmtflags format_;
 144
 145         //- Time directory name precision
 146         static int precision_;
 147
 148         //- Adjust the time step so that writing occurs at the specified time
 149         void adjustDeltaT();
 150
 151         //- Set the controls from the current controlDict
 152         void setControls();
 153
 154         //- Read the control dictionary and set the write controls etc.
 155         virtual void readDict();
 156
 157
 158 private:
 159
 160         //- Default write option
 161         IOstream::streamFormat writeFormat_;
 162
 163         //- Default output file format version number
 164         IOstream::versionNumber writeVersion_;
 165
 166         //- Default output compression
 167         IOstream::compressionType writeCompression_;
 168
 169         //- Default graph format
 170         word graphFormat_;
 171
 172         //- Is runtime modification of dictionaries allowed?
 173         Switch runTimeModifiable_;
 174
 175         //- Function objects executed at start and on ++, +=
 176         mutable functionObjectList functionObjects_;
 177
 178
 179 public:
 180
 181     TypeName("time");
 182
 183     //- The default control dictionary name (normally "controlDict")
 184     static word controlDictName;
 185
 186
 187     // Constructors
 188
 189         //- Construct given name of dictionary to read and argument list
 190         Time
 191         (
 192             const word& name,
 193             const argList& args,
 194             const word& systemName = "system",
 195             const word& constantName = "constant"
 196         );
 197
 198         //- Construct given name of dictionary to read, rootPath and casePath
 199         Time
 200         (
 201             const word& name,
 202             const fileName& rootPath,
 203             const fileName& caseName,
 204             const word& systemName = "system",
 205             const word& constantName = "constant",
 206             const bool enableFunctionObjects = true
 207         );
 208
 209         //- Construct given dictionary, rootPath and casePath
 210         Time
 211         (
 212             const dictionary& dict,
 213             const fileName& rootPath,
 214             const fileName& caseName,
 215             const word& systemName = "system",
 216             const word& constantName = "constant",
 217             const bool enableFunctionObjects = true
 218         );
 219
 220         //- Construct given endTime, rootPath and casePath
 221         Time
 222         (
 223             const fileName& rootPath,
 224             const fileName& caseName,
 225             const word& systemName = "system",
 226             const word& constantName = "constant",
 227             const bool enableFunctionObjects = true
 228         );
 229
 230
 231     //- Destructor
 232     virtual ~Time();
 233
 234
 235     // Member functions
 236
 237         // Database functions
 238
 239             //- Return root path
 240             const fileName& rootPath() const
 241             {
 242                 return TimePaths::rootPath();
 243             }
 244
 245             //- Return case name
 246             const fileName& caseName() const
 247             {
 248                 return TimePaths::caseName();
 249             }
 250
 251             //- Return path
 252             fileName path() const
 253             {
 254                 return rootPath()/caseName();
 255             }
 256
 257             const dictionary& controlDict() const
 258             {
 259                 return controlDict_;
 260             }
 261
 262             virtual const fileName& dbDir() const
 263             {
 264                 return fileName::null;
 265             }
 266
 267             //- Return current time path
 268             fileName timePath() const
 269             {
 270                 return path()/timeName();
 271             }
 272
 273             //- Default write format
 274             IOstream::streamFormat writeFormat() const
 275             {
 276                 return writeFormat_;
 277             }
 278
 279             //- Default write version number
 280             IOstream::versionNumber writeVersion() const
 281             {
 282                 return writeVersion_;
 283             }
 284
 285             //- Default write compression
 286             IOstream::compressionType writeCompression() const
 287             {
 288                 return writeCompression_;
 289             }
 290
 291             //- Default graph format
 292             const word& graphFormat() const
 293             {
 294                 return graphFormat_;
 295             }
 296
 297             //- Supports re-reading
 298             const Switch& runTimeModifiable() const
 299             {
 300                 return runTimeModifiable_;
 301             }
 302
 303             //- Read control dictionary, update controls and time
 304             virtual bool read();
 305
 306             // Automatic rereading
 307
 308                 //- Read the objects that have been modified
 309                 void readModifiedObjects();
 310
 311                 //- Add watching of a file. Returns handle
 312                 label addWatch(const fileName&) const;
 313
 314                 //- Remove watch on a file (using handle)
 315                 bool removeWatch(const label) const;
 316
 317                 //- Get name of file being watched (using handle)
 318                 const fileName& getFile(const label) const;
 319
 320                 //- Get current state of file (using handle)
 321                 fileMonitor::fileState getState(const label) const;
 322
 323                 //- Set current state of file (using handle) to unmodified
 324                 void setUnmodified(const label) const;
 325
 326
 327             //- Return the location of "dir" containing the file "name".
 328             //  (eg, used in reading mesh data)
 329             //  If name is null, search for the directory "dir" only.
 330             //  Does not search beyond stopInstance (if set) or constant.
 331             word findInstance
 332             (
 333                 const fileName& dir,
 334                 const word& name = word::null,
 335                 const IOobject::readOption rOpt = IOobject::MUST_READ,
 336                 const word& stopInstance = word::null
 337             ) const;
 338
 339             //- Search the case for valid time directories
 340             instantList times() const;
 341
 342             //- Search the case for the time directory path
 343             //  corresponding to the given instance
 344             word findInstancePath(const instant&) const;
 345
 346             //- Search the case for the time closest to the given time
 347             instant findClosestTime(const scalar) const;
 348
 349             //- Search instantList for the time index closest to the given time
 350             static label findClosestTimeIndex(const instantList&, const scalar);
 351
 352             //- Write using given format, version and compression
 353             virtual bool writeObject
 354             (
 355                 IOstream::streamFormat,
 356                 IOstream::versionNumber,
 357                 IOstream::compressionType
 358             ) const;
 359
 360             //- Write the objects now and continue the run
 361             bool writeNow();
 362
 363             //- Write the objects now and end the run
 364             bool writeAndEnd();
 365
 366
 367         // Access
 368
 369             //- Return time name of given scalar time
 370             static word timeName(const scalar);
 371
 372             //- Return current time name
 373             virtual word timeName() const;
 374
 375             //- Search a given directory for valid time directories
 376             static instantList findTimes(const fileName&);
 377
 378             //- Return start time index
 379             virtual label startTimeIndex() const;
 380
 381             //- Return start time
 382             virtual dimensionedScalar startTime() const;
 383
 384             //- Return end time
 385             virtual dimensionedScalar endTime() const;
 386
 387             //- Return the list of function objects
 388             const functionObjectList& functionObjects() const
 389             {
 390                 return functionObjects_;
 391             }
 392
 393             //- External access to the loaded libraries
 394             dlLibraryTable& libs()
 395             {
 396                 return libs_;
 397             }
 398
 399             //- Return true if time currently being sub-cycled, otherwise false
 400             bool subCycling() const
 401             {
 402                 return subCycling_;
 403             }
 404
 405             //- Return previous TimeState if time is being sub-cycled
 406             const TimeState& prevTimeState() const
 407             {
 408                 return prevTimeState_();
 409             }
 410
 411
 412         // Check
 413
 414             //- Return true if run should continue,
 415             //  also invokes the functionObjectList::end() method
 416             //  when the time goes out of range
 417             //  \note
 418             //  For correct behaviour, the following style of time-loop
 419             //  is recommended:
 420             //  \code
 421             //      while (runTime.run())
 422             //      {
 423             //          runTime++;
 424             //          solve;
 425             //          runTime.write();
 426             //      }
 427             //  \endcode
 428             virtual bool run() const;
 429
 430             //- Return true if run should continue and if so increment time
 431             //  also invokes the functionObjectList::end() method
 432             //  when the time goes out of range
 433             //  \note
 434             //  For correct behaviour, the following style of time-loop
 435             //  is recommended:
 436             //  \code
 437             //      while (runTime.loop())
 438             //      {
 439             //          solve;
 440             //          runTime.write();
 441             //      }
 442             //  \endcode
 443             virtual bool loop();
 444
 445             //- Return true if end of run,
 446             //  does not invoke any functionObject methods
 447             //  \note
 448             //      The rounding heuristics near endTime mean that
 449             //      \code run() \endcode and \code !end() \endcode may
 450             //      not yield the same result
 451             virtual bool end() const;
 452
 453
 454         // Edit
 455
 456             //- Adjust the current stopAtControl. Note that this value
 457             //  only persists until the next time the dictionary is read.
 458             //  Return true if the stopAtControl changed.
 459             virtual bool stopAt(const stopAtControls) const;
 460
 461             //- Reset the time and time-index to those of the given time
 462             virtual void setTime(const Time&);
 463
 464             //- Reset the time and time-index
 465             virtual void setTime(const instant&, const label newIndex);
 466
 467             //- Reset the time and time-index
 468             virtual void setTime
 469             (
 470                 const dimensionedScalar&,
 471                 const label newIndex
 472             );
 473
 474             //- Reset the time and time-index
 475             virtual void setTime(const scalar, const label newIndex);
 476
 477             //- Reset end time
 478             virtual void setEndTime(const dimensionedScalar&);
 479
 480             //- Reset end time
 481             virtual void setEndTime(const scalar);
 482
 483             //- Reset time step
 484             virtual void setDeltaT(const dimensionedScalar&);
 485
 486             //- Reset time step
 487             virtual void setDeltaT(const scalar);
 488
 489             //- Set time to sub-cycle for the given number of steps
 490             virtual TimeState subCycle(const label nSubCycles);
 491
 492             //- Reset time after sub-cycling back to previous TimeState
 493             virtual void endSubCycle();
 494
 495             //- Return non-const access to the list of function objects
 496             functionObjectList& functionObjects()
 497             {
 498                 return functionObjects_;
 499             }
 500
 501
 502     // Member operators
 503
 504         //- Set deltaT to that specified and increment time via operator++()
 505         virtual Time& operator+=(const dimensionedScalar&);
 506
 507         //- Set deltaT to that specified and increment time via operator++()
 508         virtual Time& operator+=(const scalar);
 509
 510         //- Prefix increment,
 511         //  also invokes the functionObjectList::start() or
 512         //  functionObjectList::execute() method, depending on the time-index
 513         virtual Time& operator++();
 514
 515         //- Postfix increment, this is identical to the prefix increment
 516         virtual Time& operator++(int);
 517 };
 518
 519
 520 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 521
 522 } // End namespace Foam
 523
 524 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 525
 526 #endif
 527
 528 // ************************************************************************* //