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