src/multiSolver/timeCluster/timeCluster.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "timeClusterList.H"
  27 #include "objectRegistry.H"
  28
  29 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  30
  31 const char* const Foam::timeCluster::typeName = "timeCluster";
  32
  33 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  34
  35 Foam::timeCluster::timeCluster()
  36 {}
  37
  38
  39 Foam::timeCluster::timeCluster
  40 (
  41     const instantList& times,
  42     const scalar globalOffset,
  43     const label globalIndex,
  44     const label superLoop,
  45     const word& solverDomainName,
  46     const word& preConName
  47 )
  48 :
  49     instantList(times),
  50     globalOffset_(globalOffset),
  51     globalIndex_(globalIndex),
  52     superLoop_(superLoop),
  53     solverDomainName_(solverDomainName),
  54     preConName_(preConName)
  55 {}
  56
  57 Foam::timeCluster::timeCluster
  58 (
  59     const timeCluster& tc,
  60     const label index
  61 )
  62 :
  63     instantList(1, tc[index]),
  64     globalOffset_(tc.globalOffset_),
  65     globalIndex_(tc.globalIndex_),
  66     superLoop_(tc.superLoop_),
  67     solverDomainName_(tc.solverDomainName_),
  68     preConName_(tc.preConName_)
  69 {}
  70
  71
  72 Foam::timeCluster::timeCluster(const Foam::scalar t)
  73 :
  74     instantList(1, instant(0)),
  75     globalOffset_(0),
  76     globalIndex_(0),
  77     superLoop_(0),
  78     solverDomainName_(word::null),
  79     preConName_(word::null)
  80 {}
  81
  82
  83 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  84
  85 Foam::scalar Foam::timeCluster::globalValue(const label& index) const
  86 {
  87     return this->operator[](index).value() + globalOffset_;
  88 }
  89
  90 Foam::scalar Foam::timeCluster::globalMinValue() const
  91 {
  92     return this->localMinValue() + globalOffset_;
  93 }
  94
  95
  96 Foam::scalar Foam::timeCluster::globalMaxValue() const
  97 {
  98     return this->localMaxValue() + globalOffset_;
  99 }
 100
 101
 102 Foam::label Foam::timeCluster::globalMinIndex() const
 103 {
 104     return this->localMinIndex();
 105 }
 106
 107
 108 Foam::label Foam::timeCluster::globalMaxIndex() const
 109 {
 110     return this->localMaxIndex();
 111 }
 112
 113
 114 Foam::scalar Foam::timeCluster::globalFindClosestTimeValue
 115 (
 116     const scalar timeValue
 117 ) const
 118 {
 119     return this->operator[]
 120     (
 121         Foam::Time::findClosestTimeIndex
 122         (
 123             this->times(), timeValue - globalOffset_
 124         )
 125     ).value() + globalOffset_;
 126 }
 127
 128
 129 Foam::label Foam::timeCluster::globalFindClosestTimeIndex
 130 (
 131     const scalar timeValue
 132 ) const
 133 {
 134     return Foam::Time::findClosestTimeIndex
 135     (
 136         this->times(), timeValue - globalOffset_
 137     );
 138 }
 139
 140
 141 Foam::scalar Foam::timeCluster::localValue(const label& index) const
 142 {
 143     return this->operator[](index).value();
 144 }
 145
 146
 147 Foam::scalar Foam::timeCluster::localMinValue() const
 148 {
 149     return this->operator[](this->localMinIndex()).value();
 150 }
 151
 152
 153 Foam::scalar Foam::timeCluster::localMaxValue() const
 154 {
 155     return this->operator[](this->localMaxIndex()).value();
 156 }
 157
 158
 159 Foam::label Foam::timeCluster::localMinIndex() const
 160 {
 161     label bestIndex(0);
 162     scalar min(VGREAT);
 163     forAll(*this, i)
 164     {
 165         if (this->operator[](i).value() < min)
 166         {
 167             min = this->operator[](i).value();
 168             bestIndex = i;
 169         }
 170     }
 171     return bestIndex;
 172 }
 173
 174
 175 Foam::label Foam::timeCluster::localMaxIndex() const
 176 {
 177     label bestIndex(0);
 178     scalar max(0);
 179     forAll(*this, i)
 180     {
 181         if (this->operator[](i).value() > max)
 182         {
 183             max = this->operator[](i).value();
 184             bestIndex = i;
 185         }
 186     }
 187     return bestIndex;
 188 }
 189
 190
 191 Foam::scalar Foam::timeCluster::localFindClosestTimeValue
 192 (
 193     const scalar timeValue
 194 ) const
 195 {
 196     return this->operator[]
 197     (
 198         Foam::Time::findClosestTimeIndex
 199         (
 200             this->times(), timeValue
 201         )
 202     ).value();
 203 }
 204
 205
 206 Foam::label Foam::timeCluster::localFindClosestTimeIndex
 207 (
 208     const scalar timeValue
 209 ) const
 210 {
 211     return Foam::Time::findClosestTimeIndex
 212     (
 213         this->times(), timeValue
 214     );
 215 }
 216
 217
 218 Foam::timeCluster Foam::timeCluster::operator()(const Foam::label index) const
 219 {
 220     return timeCluster(*this, index);
 221 }
 222
 223
 224 // * * * * * * * * * * * * * Friend IOstream Operators * * * * * * * * * * * //
 225
 226 Foam::Istream& Foam::operator>>(Istream& is, timeCluster& I)
 227 {
 228     return is   >> I.globalOffset_
 229                 >> I.globalIndex_
 230                 >> I.superLoop_
 231                 >> I.solverDomainName_
 232                 >> I.preConName_
 233                 >> I.times();
 234 }
 235
 236
 237 Foam::Ostream& Foam::operator<<(Ostream& os, const timeCluster& I)
 238 {
 239     return os   << "/* globalOffset: */\t" << I.globalOffset_ << nl
 240                 << "/* globalIndex:  */\t" << I.globalIndex_ << nl
 241                 << "/* superLoop:    */\t" << I.superLoop_ << nl
 242                 << "/* solverDomain: */\t" << I.solverDomainName_ << nl
 243                 << "/* preConName:   */\t" << I.preConName_ << nl
 244                 << "/* Instant list: */\t" << I.times();
 245 }
 246
 247 // ************************************************************************* //