src/OpenFOAM/db/Time/Time.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 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 the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     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, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 \*---------------------------------------------------------------------------*/
  26
  27 #include "Time.H"
  28 #include "PstreamReduceOps.H"
  29
  30 #include <sstream>
  31
  32 // * * * * * * * * * * * * * Static Member Data  * * * * * * * * * * * * * * //
  33
  34 defineTypeNameAndDebug(Foam::Time, 0);
  35
  36 template<>
  37 const char* Foam::NamedEnum<Foam::Time::stopAtControls, 4>::names[] =
  38 {
  39     "endTime",
  40     "noWriteNow",
  41     "writeNow",
  42     "nextWrite"
  43 };
  44
  45 const Foam::NamedEnum<Foam::Time::stopAtControls, 4>
  46     Foam::Time::stopAtControlNames_;
  47
  48 template<>
  49 const char* Foam::NamedEnum<Foam::Time::writeControls, 5>::names[] =
  50 {
  51     "timeStep",
  52     "runTime",
  53     "adjustableRunTime",
  54     "clockTime",
  55     "cpuTime"
  56 };
  57
  58 const Foam::NamedEnum<Foam::Time::writeControls, 5>
  59     Foam::Time::writeControlNames_;
  60
  61 Foam::Time::fmtflags Foam::Time::format_(Foam::Time::general);
  62 int Foam::Time::precision_(6);
  63
  64 Foam::word Foam::Time::controlDictName("controlDict");
  65
  66
  67 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  68
  69 void Foam::Time::adjustDeltaT()
  70 {
  71     if (writeControl_ == wcAdjustableRunTime)
  72     {
  73         scalar timeToNextWrite = max
  74         (
  75             0.0,
  76             (outputTimeIndex_ + 1)*writeInterval_ - (value() - startTime_)
  77         );
  78
  79         label nStepsToNextWrite = label(timeToNextWrite/deltaT_ - SMALL) + 1;
  80         scalar newDeltaT = timeToNextWrite/nStepsToNextWrite;
  81
  82         // Control the increase of the time step to within a factor of 2
  83         // and the decrease within a factor of 5.
  84         if (newDeltaT >= deltaT_)
  85         {
  86             deltaT_ = min(newDeltaT, 2.0*deltaT_);
  87         }
  88         else
  89         {
  90             deltaT_ = max(newDeltaT, 0.2*deltaT_);
  91         }
  92     }
  93 }
  94
  95
  96 void Foam::Time::setControls()
  97 {
  98     // default is to resume calculation from "latestTime"
  99     word startFrom = controlDict_.lookupOrDefault<word>
 100     (
 101         "startFrom",
 102         "latestTime"
 103     );
 104
 105     if (startFrom == "startTime")
 106     {
 107         controlDict_.lookup("startTime") >> startTime_;
 108     }
 109     else
 110     {
 111         // Search directory for valid time directories
 112         instantList timeDirs = findTimes(path());
 113
 114         if (startFrom == "firstTime")
 115         {
 116             if (timeDirs.size())
 117             {
 118                 startTime_ = timeDirs[0].value();
 119             }
 120         }
 121         else if (startFrom == "latestTime")
 122         {
 123             if (timeDirs.size())
 124             {
 125                 startTime_ = timeDirs[timeDirs.size()-1].value();
 126             }
 127         }
 128         else
 129         {
 130             WarningIn("Time::setControls()")
 131                 << "    expected startTime, firstTime or latestTime"
 132                 << " found '" << startFrom
 133                 << "' in dictionary " << controlDict_.name() << nl
 134                 << "    Setting time to " << startTime_ << endl;
 135         }
 136     }
 137
 138     setTime(startTime_, 0);
 139
 140     readDict();
 141     deltaTSave_ = deltaT_;
 142     deltaT0_ = deltaTSave_;
 143
 144     if (Pstream::parRun())
 145     {
 146         scalar sumStartTime = startTime_;
 147         reduce(sumStartTime, sumOp<scalar>());
 148         if
 149         (
 150             mag(Pstream::nProcs()*startTime_ - sumStartTime)
 151           > Pstream::nProcs()*deltaT_/10.0
 152         )
 153         {
 154             FatalErrorIn("Time::setControls()")
 155                 << "Start time is not the same for all processors" << nl
 156                 << "processor " << Pstream::myProcNo() << " has startTime "
 157                 << startTime_ << exit(FatalError);
 158         }
 159     }
 160
 161     IOdictionary timeDict
 162     (
 163         IOobject
 164         (
 165             "time",
 166             timeName(),
 167             "uniform",
 168             *this,
 169             IOobject::READ_IF_PRESENT,
 170             IOobject::NO_WRITE,
 171             false
 172         )
 173     );
 174
 175     if (timeDict.readIfPresent("deltaT", deltaTSave_))
 176     {
 177         deltaT0_ = deltaTSave_;
 178     }
 179
 180     if (timeDict.readIfPresent("index", startTimeIndex_))
 181     {
 182         timeIndex_ = startTimeIndex_;
 183     }
 184 }
 185
 186
 187 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 188
 189 Foam::Time::Time
 190 (
 191     const word& controlDictName,
 192     const fileName& rootPath,
 193     const fileName& caseName,
 194     const word& systemName,
 195     const word& constantName
 196 )
 197 :
 198     TimePaths
 199     (
 200         rootPath,
 201         caseName,
 202         systemName,
 203         constantName
 204     ),
 205
 206     objectRegistry(*this),
 207
 208     controlDict_
 209     (
 210         IOobject
 211         (
 212             controlDictName,
 213             system(),
 214             *this,
 215             IOobject::MUST_READ,
 216             IOobject::NO_WRITE,
 217             false
 218         )
 219     ),
 220
 221     startTimeIndex_(0),
 222     startTime_(0),
 223     endTime_(0),
 224
 225     stopAt_(saEndTime),
 226     writeControl_(wcTimeStep),
 227     writeInterval_(GREAT),
 228     purgeWrite_(0),
 229     subCycling_(false),
 230
 231     writeFormat_(IOstream::ASCII),
 232     writeVersion_(IOstream::currentVersion),
 233     writeCompression_(IOstream::UNCOMPRESSED),
 234     graphFormat_("raw"),
 235     runTimeModifiable_(true),
 236
 237     readLibs_(controlDict_, "libs"),
 238     functionObjects_(*this)
 239 {
 240     setControls();
 241 }
 242
 243
 244 Foam::Time::Time
 245 (
 246     const dictionary& dict,
 247     const fileName& rootPath,
 248     const fileName& caseName,
 249     const word& systemName,
 250     const word& constantName
 251 )
 252 :
 253     TimePaths
 254     (
 255         rootPath,
 256         caseName,
 257         systemName,
 258         constantName
 259     ),
 260
 261     objectRegistry(*this),
 262
 263     controlDict_
 264     (
 265         IOobject
 266         (
 267             controlDictName,
 268             system(),
 269             *this,
 270             IOobject::NO_READ,
 271             IOobject::NO_WRITE,
 272             false
 273         ),
 274         dict
 275     ),
 276
 277     startTimeIndex_(0),
 278     startTime_(0),
 279     endTime_(0),
 280
 281     stopAt_(saEndTime),
 282     writeControl_(wcTimeStep),
 283     writeInterval_(GREAT),
 284     purgeWrite_(0),
 285     subCycling_(false),
 286
 287     writeFormat_(IOstream::ASCII),
 288     writeVersion_(IOstream::currentVersion),
 289     writeCompression_(IOstream::UNCOMPRESSED),
 290     graphFormat_("raw"),
 291     runTimeModifiable_(true),
 292
 293     readLibs_(controlDict_, "libs"),
 294     functionObjects_(*this)
 295 {
 296     setControls();
 297 }
 298
 299
 300 Foam::Time::Time
 301 (
 302     const fileName& rootPath,
 303     const fileName& caseName,
 304     const word& systemName,
 305     const word& constantName
 306 )
 307 :
 308     TimePaths
 309     (
 310         rootPath,
 311         caseName,
 312         systemName,
 313         constantName
 314     ),
 315
 316     objectRegistry(*this),
 317
 318     controlDict_
 319     (
 320         IOobject
 321         (
 322             controlDictName,
 323             system(),
 324             *this,
 325             IOobject::NO_READ,
 326             IOobject::NO_WRITE,
 327             false
 328         )
 329     ),
 330
 331     startTimeIndex_(0),
 332     startTime_(0),
 333     endTime_(0),
 334
 335     stopAt_(saEndTime),
 336     writeControl_(wcTimeStep),
 337     writeInterval_(GREAT),
 338     purgeWrite_(0),
 339     subCycling_(false),
 340
 341     writeFormat_(IOstream::ASCII),
 342     writeVersion_(IOstream::currentVersion),
 343     writeCompression_(IOstream::UNCOMPRESSED),
 344     graphFormat_("raw"),
 345     runTimeModifiable_(true),
 346
 347     readLibs_(controlDict_, "libs"),
 348     functionObjects_(*this)
 349 {}
 350
 351
 352 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 353
 354 Foam::Time::~Time()
 355 {
 356     // destroy function objects first
 357     functionObjects_.clear();
 358 }
 359
 360
 361 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 362
 363 Foam::word Foam::Time::timeName(const scalar t)
 364 {
 365     std::ostringstream buf;
 366     buf.setf(ios_base::fmtflags(format_), ios_base::floatfield);
 367     buf.precision(precision_);
 368     buf << t;
 369     return buf.str();
 370 }
 371
 372
 373 Foam::word Foam::Time::timeName() const
 374 {
 375     return dimensionedScalar::name();
 376 }
 377
 378
 379 // Search the construction path for times
 380 Foam::instantList Foam::Time::times() const
 381 {
 382     return findTimes(path());
 383 }
 384
 385
 386 Foam::word Foam::Time::findInstancePath(const instant& t) const
 387 {
 388     instantList timeDirs = findTimes(path());
 389
 390     forAllReverse(timeDirs, timeI)
 391     {
 392         if (timeDirs[timeI] == t)
 393         {
 394             return timeDirs[timeI].name();
 395         }
 396     }
 397
 398     return word::null;
 399 }
 400
 401
 402 Foam::instant Foam::Time::findClosestTime(const scalar t) const
 403 {
 404     instantList timeDirs = findTimes(path());
 405
 406     // there is only one time (likely "constant") so return it
 407     if (timeDirs.size() == 1)
 408     {
 409         return timeDirs[0];
 410     }
 411
 412     if (t < timeDirs[1].value())
 413     {
 414         return timeDirs[1];
 415     }
 416     else if (t > timeDirs[timeDirs.size()-1].value())
 417     {
 418         return timeDirs[timeDirs.size()-1];
 419     }
 420
 421     label nearestIndex = -1;
 422     scalar deltaT = GREAT;
 423
 424     for (label timeI=1; timeI < timeDirs.size(); ++timeI)
 425     {
 426         scalar diff = mag(timeDirs[timeI].value() - t);
 427         if (diff < deltaT)
 428         {
 429             deltaT = diff;
 430             nearestIndex = timeI;
 431         }
 432     }
 433
 434     return timeDirs[nearestIndex];
 435 }
 436
 437
 438 // This should work too,
 439 // if we don't worry about checking "constant" explicitly
 440 //
 441 // Foam::instant Foam::Time::findClosestTime(const scalar t) const
 442 // {
 443 //     instantList timeDirs = findTimes(path());
 444 //     label timeIndex = min(findClosestTimeIndex(timeDirs, t), 0);
 445 //     return timeDirs[timeIndex];
 446 // }
 447
 448 Foam::label Foam::Time::findClosestTimeIndex
 449 (
 450     const instantList& timeDirs,
 451     const scalar t
 452 )
 453 {
 454     label nearestIndex = -1;
 455     scalar deltaT = GREAT;
 456
 457     forAll(timeDirs, timeI)
 458     {
 459         if (timeDirs[timeI].name() == "constant") continue;
 460
 461         scalar diff = mag(timeDirs[timeI].value() - t);
 462         if (diff < deltaT)
 463         {
 464             deltaT = diff;
 465             nearestIndex = timeI;
 466         }
 467     }
 468
 469     return nearestIndex;
 470 }
 471
 472
 473 Foam::label Foam::Time::startTimeIndex() const
 474 {
 475     return startTimeIndex_;
 476 }
 477
 478
 479 Foam::dimensionedScalar Foam::Time::startTime() const
 480 {
 481     return dimensionedScalar("startTime", dimTime, startTime_);
 482 }
 483
 484
 485 Foam::dimensionedScalar Foam::Time::endTime() const
 486 {
 487     return dimensionedScalar("endTime", dimTime, endTime_);
 488 }
 489
 490
 491 bool Foam::Time::run() const
 492 {
 493     bool running = value() < (endTime_ - 0.5*deltaT_);
 494
 495     if (!subCycling_)
 496     {
 497         // only execute when the condition is no longer true
 498         // ie, when exiting the control loop
 499         if (!running && timeIndex_ != startTimeIndex_)
 500         {
 501             // Note, end() also calls an indirect start() as required
 502             functionObjects_.end();
 503         }
 504     }
 505
 506     return running;
 507 }
 508
 509
 510 bool Foam::Time::loop()
 511 {
 512     bool running = run();
 513
 514     if (running)
 515     {
 516         operator++();
 517     }
 518
 519     return running;
 520 }
 521
 522
 523 bool Foam::Time::end() const
 524 {
 525     return value() > (endTime_ + 0.5*deltaT_);
 526 }
 527
 528
 529 void Foam::Time::setTime(const Time& t)
 530 {
 531     value() = t.value();
 532     dimensionedScalar::name() = t.dimensionedScalar::name();
 533     timeIndex_ = t.timeIndex_;
 534 }
 535
 536
 537 void Foam::Time::setTime(const instant& inst, const label newIndex)
 538 {
 539     value() = inst.value();
 540     dimensionedScalar::name() = inst.name();
 541     timeIndex_ = newIndex;
 542
 543     IOdictionary timeDict
 544     (
 545         IOobject
 546         (
 547             "time",
 548             timeName(),
 549             "uniform",
 550             *this,
 551             IOobject::READ_IF_PRESENT,
 552             IOobject::NO_WRITE,
 553             false
 554         )
 555     );
 556
 557     timeDict.readIfPresent("deltaT", deltaT_);
 558     timeDict.readIfPresent("deltaT0", deltaT0_);
 559     timeDict.readIfPresent("index", timeIndex_);
 560 }
 561
 562
 563 void Foam::Time::setTime(const dimensionedScalar& newTime, const label newIndex)
 564 {
 565     setTime(newTime.value(), newIndex);
 566 }
 567
 568
 569 void Foam::Time::setTime(const scalar newTime, const label newIndex)
 570 {
 571     value() = newTime;
 572     dimensionedScalar::name() = timeName(timeToUserTime(newTime));
 573     timeIndex_ = newIndex;
 574 }
 575
 576
 577 void Foam::Time::setEndTime(const dimensionedScalar& endTime)
 578 {
 579     setEndTime(endTime.value());
 580 }
 581
 582
 583 void Foam::Time::setEndTime(const scalar endTime)
 584 {
 585     endTime_ = endTime;
 586 }
 587
 588
 589 void Foam::Time::setDeltaT(const dimensionedScalar& deltaT)
 590 {
 591     setDeltaT(deltaT.value());
 592 }
 593
 594
 595 void Foam::Time::setDeltaT(const scalar deltaT)
 596 {
 597     deltaT_ = deltaT;
 598     deltaTchanged_ = true;
 599     adjustDeltaT();
 600 }
 601
 602
 603 Foam::TimeState Foam::Time::subCycle(const label nSubCycles)
 604 {
 605     subCycling_ = true;
 606
 607     TimeState ts = *this;
 608     setTime(*this - deltaT(), (timeIndex() - 1)*nSubCycles);
 609     deltaT_ /= nSubCycles;
 610     deltaT0_ /= nSubCycles;
 611     deltaTSave_ = deltaT0_;
 612
 613     return ts;
 614 }
 615
 616
 617 void Foam::Time::endSubCycle(const TimeState& ts)
 618 {
 619     subCycling_ = false;
 620     TimeState::operator=(ts);
 621 }
 622
 623
 624 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 625
 626 Foam::Time& Foam::Time::operator+=(const dimensionedScalar& deltaT)
 627 {
 628     return operator+=(deltaT.value());
 629 }
 630
 631
 632 Foam::Time& Foam::Time::operator+=(const scalar deltaT)
 633 {
 634     setDeltaT(deltaT);
 635     return operator++();
 636 }
 637
 638
 639 Foam::Time& Foam::Time::operator++()
 640 {
 641     readModifiedObjects();
 642
 643     if (!subCycling_)
 644     {
 645         if (timeIndex_ == startTimeIndex_)
 646         {
 647             functionObjects_.start();
 648         }
 649         else
 650         {
 651             functionObjects_.execute();
 652         }
 653     }
 654
 655     deltaT0_ = deltaTSave_;
 656     deltaTSave_ = deltaT_;
 657     setTime(value() + deltaT_, timeIndex_ + 1);
 658
 659     // If the time is very close to zero reset to zero
 660     if (mag(value()) < 10*SMALL*deltaT_)
 661     {
 662         setTime(0.0, timeIndex_);
 663     }
 664
 665     switch (writeControl_)
 666     {
 667         case wcTimeStep:
 668             outputTime_ = !(timeIndex_ % label(writeInterval_));
 669         break;
 670
 671         case wcRunTime:
 672         case wcAdjustableRunTime:
 673         {
 674             label outputIndex =
 675                 label(((value() - startTime_) + 0.5*deltaT_)/writeInterval_);
 676
 677             if (outputIndex > outputTimeIndex_)
 678             {
 679                 outputTime_ = true;
 680                 outputTimeIndex_ = outputIndex;
 681             }
 682             else
 683             {
 684                 outputTime_ = false;
 685             }
 686         }
 687         break;
 688
 689         case wcCpuTime:
 690         {
 691             label outputIndex = label(elapsedCpuTime()/writeInterval_);
 692             if (outputIndex > outputTimeIndex_)
 693             {
 694                 outputTime_ = true;
 695                 outputTimeIndex_ = outputIndex;
 696             }
 697             else
 698             {
 699                 outputTime_ = false;
 700             }
 701         }
 702         break;
 703
 704         case wcClockTime:
 705         {
 706             label outputIndex = label(elapsedClockTime()/writeInterval_);
 707             if (outputIndex > outputTimeIndex_)
 708             {
 709                 outputTime_ = true;
 710                 outputTimeIndex_ = outputIndex;
 711             }
 712             else
 713             {
 714                 outputTime_ = false;
 715             }
 716         }
 717         break;
 718     }
 719
 720     // see if endTime needs adjustment to stop at the next run()/end() check
 721     if (!end())
 722     {
 723         if (stopAt_ == saNoWriteNow)
 724         {
 725             endTime_ = value();
 726         }
 727         else if (stopAt_ == saWriteNow)
 728         {
 729             endTime_ = value();
 730             outputTime_ = true;
 731         }
 732         else if (stopAt_ == saNextWrite && outputTime_ == true)
 733         {
 734             endTime_ = value();
 735         }
 736     }
 737
 738     return *this;
 739 }
 740
 741
 742 Foam::Time& Foam::Time::operator++(int)
 743 {
 744     return operator++();
 745 }
 746
 747
 748 // ************************************************************************* //