src/postProcessing/fieldAverage/fieldAverage/fieldAverage.H

   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 Class
  26     Foam::fieldAverage
  27
  28 Description
  29     Calculates the field averages given list of fieldAverageItems, e.g.
  30
  31     @verbatim
  32     fieldAverage1
  33     {
  34         // Type of functionObject
  35         type fieldAverage;
  36
  37         // Where to load it from (if not already in solver)
  38         functionObjectLibs ("libfieldAverage.so");
  39
  40         // Fields to be probed. runTime modifiable!
  41         fields
  42         (
  43             U
  44             {
  45                 mean            on;
  46                 prime2Mean      on;
  47                 base            time;
  48             }
  49             p
  50             {
  51                 mean            on;
  52                 prime2Mean      on;
  53                 base            time;
  54             }
  55         );
  56     @endverbatim
  57
  58     Member function calcAverages() calculates the averages.
  59
  60     Member function fieldAverage::write() calls calcAverages(). Average
  61     field names are constructed by concatenating the base field with the
  62     averaging type, e.g.
  63     - base field, U
  64     - arithmetic mean field, UMean
  65     - prime-squared field, UPrime2Mean
  66
  67     Information regarding the number of averaging steps, and total averaging
  68     time are written on a (base) per-field basis to the
  69     fieldAveragingProperties dictionary, located in \<time\>/uniform
  70
  71 SourceFiles
  72     fieldAverage.C
  73     fieldAverageTemplates.C
  74
  75 \*---------------------------------------------------------------------------*/
  76
  77 #ifndef fieldAverage_H
  78 #define fieldAverage_H
  79
  80 #include "volFieldsFwd.H"
  81 #include "pointFieldFwd.H"
  82 #include "Switch.H"
  83
  84 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  85
  86 namespace Foam
  87 {
  88
  89 // Forward declaration of classes
  90 class objectRegistry;
  91 class dictionary;
  92 class fieldAverageItem;
  93 class OFstream;
  94 template<class Type>
  95 class List;
  96 class mapPolyMesh;
  97
  98 /*---------------------------------------------------------------------------*\
  99                          Class fieldAverage Declaration
 100 \*---------------------------------------------------------------------------*/
 101
 102 class fieldAverage
 103 {
 104 protected:
 105
 106     // Private data
 107
 108         //- Name of this set of field averages.
 109         word name_;
 110
 111         //- Database this class is registered to
 112         const objectRegistry& obr_;
 113
 114         //- On/off switch
 115         bool active_;
 116
 117         //- Time at last call, prevents repeated averaging
 118         label prevTimeIndex_;
 119
 120         //- resetOnOutput flag
 121         Switch resetOnOutput_;
 122
 123         //- List of field average items, describing what averages to be
 124         //  calculated and output
 125         List<fieldAverageItem> faItems_;
 126
 127         // File and field name extensions
 128
 129             //- Mean average
 130             static const word EXT_MEAN;
 131
 132             //- Prime-squared average
 133             static const word EXT_PRIME2MEAN;
 134
 135
 136         // Lists of averages
 137
 138             // Arithmetic mean fields
 139             wordList meanScalarFields_;
 140             wordList meanVectorFields_;
 141             wordList meanSphericalTensorFields_;
 142             wordList meanSymmTensorFields_;
 143             wordList meanTensorFields_;
 144
 145             // Prime-squared fields - applicable to volVectorFields only
 146             wordList prime2MeanScalarFields_;
 147             wordList prime2MeanSymmTensorFields_;
 148
 149
 150         // Counters
 151
 152             //- Iteration steps counter
 153             List<label> totalIter_;
 154
 155             //- Total time counter
 156             List<scalar> totalTime_;
 157
 158
 159     // Private Member Functions
 160
 161         // Initialisation routines
 162
 163             //- Checkout fields (causes deletion) from the database
 164             void checkoutFields(const wordList&) const;
 165
 166             //- Reset size of lists (clear existing values)
 167             void resetLists(const label nItems);
 168
 169             //- Intitialise averaging. Check requested field averages are
 170             //  valid, and populate field lists
 171             void initialise();
 172
 173             //- Add mean average field to PtrList
 174             template<class Type>
 175             void addMeanField(const label, wordList&) const;
 176
 177             //- Add prime-squared average field to PtrList
 178             template<class Type1, class Type2>
 179             void addPrime2MeanField
 180             (
 181                 const label,
 182                 const wordList&,
 183                 wordList&
 184             ) const;
 185
 186
 187         // Calculation functions
 188
 189             //- Main calculation routine
 190             virtual void calcAverages();
 191
 192             //- Calculate mean average fields
 193             template<class Type>
 194             void calculateMeanFields(const wordList&) const;
 195
 196             //- Add mean-squared field value to prime-squared mean field
 197             template<class Type1, class Type2>
 198             void addMeanSqrToPrime2Mean
 199             (
 200                 const wordList&,
 201                 const wordList&
 202             ) const;
 203
 204             //- Calculate prime-squared average fields
 205             template<class Type1, class Type2>
 206             void calculatePrime2MeanFields
 207             (
 208                 const wordList&,
 209                 const wordList&
 210             ) const;
 211
 212
 213         // I-O
 214
 215             //- Write averages
 216             virtual void writeAverages() const;
 217
 218             //- Write fields
 219             template<class Type>
 220             void writeFieldList(const wordList&) const;
 221
 222             //- Write averaging properties - steps and time
 223             void writeAveragingProperties() const;
 224
 225             //- Read averaging properties - steps and time
 226             void readAveragingProperties();
 227
 228
 229         // Functions to be over-ridden from IOoutputFilter class
 230
 231             //- Update mesh
 232             virtual void updateMesh(const mapPolyMesh&);
 233
 234             //- Move points
 235             virtual void movePoints(const Field<point>&);
 236
 237
 238         //- Disallow default bitwise copy construct
 239         fieldAverage(const fieldAverage&);
 240
 241         //- Disallow default bitwise assignment
 242         void operator=(const fieldAverage&);
 243
 244
 245 public:
 246
 247     //- Runtime type information
 248     TypeName("fieldAverage");
 249
 250
 251     // Constructors
 252
 253         //- Construct for given objectRegistry and dictionary.
 254         //  Allow the possibility to load fields from files
 255         fieldAverage
 256         (
 257             const word& name,
 258             const objectRegistry&,
 259             const dictionary&,
 260             const bool loadFromFiles = false
 261         );
 262
 263
 264     //- Destructor
 265
 266         virtual ~fieldAverage();
 267
 268
 269     // Member Functions
 270
 271         //- Return name of the set of field averages
 272         virtual const word& name() const
 273         {
 274             return name_;
 275         }
 276
 277         //- Read the field average data
 278         virtual void read(const dictionary&);
 279
 280         //- Calculate the field average data and write
 281         virtual void write();
 282 };
 283
 284
 285 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 286
 287 } // End namespace Foam
 288
 289 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 290
 291 #ifdef NoRepository
 292 #   include "fieldAverageTemplates.C"
 293 #endif
 294
 295 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 296
 297 #endif
 298
 299 // ************************************************************************* //