src/multiSolver/timeCluster/timeCluster.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     |
   5     \\  /    A nd           | For copyright notice see file Copyright
   6      \\/     M anipulation  |
   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 Class
  25     Foam::timeCluster
  26
  27 Description
  28     A cluster of time instances, used with multiSolver.  Catalogues all the
  29     time directories within a superLoop, within a solverDomain.  A single
  30     time cluster describes what would be analogous to all the time directories
  31     for a solver that does not use multiSolver.
  32
  33 SourceFiles
  34     timeCluster.C
  35
  36 Author
  37     David L. F. Gaden
  38
  39 \*---------------------------------------------------------------------------*/
  40
  41 #ifndef timeCluster_H
  42 #define timeCluster_H
  43
  44 #include "word.H"
  45 #include "scalar.H"
  46 #include "instantList.H"
  47
  48 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  49
  50 namespace Foam
  51 {
  52
  53 // Forward declaration of friend functions and operators
  54
  55 class timeCluster;
  56
  57 // Friend IOstream Operators
  58
  59 Istream& operator>>(Istream&, timeCluster&);
  60 Ostream& operator<<(Ostream&, const timeCluster&);
  61
  62
  63 /*---------------------------------------------------------------------------*\
  64                         Class timeCluster Declaration
  65 \*---------------------------------------------------------------------------*/
  66
  67 class timeCluster
  68 :
  69     public instantList
  70 {
  71     // Private data
  72
  73         scalar globalOffset_;
  74         label globalIndex_;
  75         label superLoop_;
  76         word solverDomainName_;
  77
  78         // PreConditioned file name - used only for pre and post conditioning
  79         // a data set for parallel runs
  80         word preConName_;
  81
  82 public:
  83
  84     // Public classes
  85
  86         //- Less function class used in sorting timeClusters
  87         class less
  88         {
  89         public:
  90
  91             bool operator()(const timeCluster& one, const timeCluster& two) const
  92             {
  93                 return one.globalMinValue() < two.globalMinValue();
  94             }
  95         };
  96
  97
  98     // Static data members
  99
 100         static const char* const typeName;
 101
 102
 103     // Constructors
 104
 105         //- Construct null
 106         timeCluster();
 107
 108         //- Construct from components
 109         timeCluster
 110         (
 111             const instantList& times,
 112             const scalar globalOffset,
 113             const label globalIndex,
 114             const label superLoop,
 115             const word& solverDomainName,
 116             const word& preConName = word::null
 117         );
 118
 119         //- Construct given a timeCluster and an index
 120         //  This creates a 'timeCluster' that holds a single instant
 121         //  in time, whose other values match those of tc.
 122         timeCluster
 123         (
 124             const timeCluster& tc,
 125             const label index
 126         );
 127
 128         //- Construct a time cluster given a scalar value.  This constructs
 129         //  a timeCluster with a single instant of time at value t, and whose
 130         //  other values are zero or empty.
 131         explicit timeCluster(const scalar t);
 132
 133     // Member Functions
 134
 135         // Access
 136
 137             //- Times
 138             inline const instantList& times() const;
 139
 140             inline instantList& times();
 141
 142             //- Global offset
 143             inline scalar globalOffset() const;
 144
 145             inline scalar& globalOffset();
 146
 147             //- Global index
 148             inline label globalIndex() const;
 149
 150             inline label& globalIndex();
 151
 152             //- SuperLoop
 153             inline label superLoop() const;
 154
 155             inline label& superLoop();
 156
 157             //- Solver domain name
 158             inline const word& solverDomainName() const;
 159
 160             inline word& solverDomainName();
 161
 162             //- Solver domain name
 163             inline const word& preConName() const;
 164
 165             inline word& preConName();
 166
 167         // Derived values
 168
 169             //- Global value at index
 170             scalar globalValue(const label& index) const;
 171
 172             //- Search for and return global min value.  If empty,
 173             //  returns VGREAT.
 174             scalar globalMinValue() const;
 175
 176             //- Search for and return global max value.  If empty,
 177             //  returns 0.
 178             scalar globalMaxValue() const;
 179
 180             //- Search for and return index of global min value
 181             label globalMinIndex() const;
 182
 183             //- Search for and return index of global max value
 184             label globalMaxIndex() const;
 185
 186             //- Global closest time
 187             scalar globalFindClosestTimeValue(const scalar) const;
 188
 189             //- Global closest time index
 190             label globalFindClosestTimeIndex(const scalar) const;
 191
 192             //- Local value at index
 193             scalar localValue(const label& index) const;
 194
 195             //- Search for and return local min value
 196             scalar localMinValue() const;
 197
 198             //- Search for and return local max value
 199             scalar localMaxValue() const;
 200
 201             //- Search for and return index of global min value.  If empty,
 202             //  returns VGREAT
 203             label localMinIndex() const;
 204
 205             //- Search for and return index of global max value.  If empty,
 206             //  returns 0.
 207             label localMaxIndex() const;
 208
 209             //-Local closest time
 210             scalar localFindClosestTimeValue(const scalar) const;
 211
 212             //-Local closest time index
 213             label localFindClosestTimeIndex(const scalar) const;
 214
 215         // Operators
 216
 217             //- Chip off a single instant given an index, return as timeCluster
 218                 // This retains superLoop, solverDomain, etc.. with a timevalue
 219             timeCluster operator()(const label index) const;
 220
 221
 222     // Friend IOstream Operators
 223
 224         friend Istream& operator>>(Istream&, timeCluster&);
 225         friend Ostream& operator<<(Ostream&, const timeCluster&);
 226 };
 227
 228
 229 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 230
 231 } // End namespace Foam
 232
 233 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 234
 235 #include "timeClusterI.H"
 236
 237 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 238
 239 #endif
 240
 241 // ************************************************************************* //