src/postProcessing/fieldAverage/fieldAverage/fieldAverage.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 "fieldAverage.H"
  28 #include "volFields.H"
  29 #include "dictionary.H"
  30 #include "Time.H"
  31 #include "IFstream.H"
  32 #include "OFstream.H"
  33
  34 #include "fieldAverageItem.H"
  35
  36 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  37
  38 namespace Foam
  39 {
  40     defineTypeNameAndDebug(fieldAverage, 0);
  41 }
  42
  43 const Foam::word Foam::fieldAverage::EXT_MEAN = "Mean";
  44 const Foam::word Foam::fieldAverage::EXT_PRIME2MEAN = "Prime2Mean";
  45
  46
  47 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  48
  49 void Foam::fieldAverage::checkoutFields(const wordList& fieldNames) const
  50 {
  51     forAll(fieldNames, i)
  52     {
  53         if (fieldNames[i] != word::null)
  54         {
  55             obr_.checkOut(*obr_[fieldNames[i]]);
  56         }
  57     }
  58 }
  59
  60
  61 void Foam::fieldAverage::resetLists(const label nItems)
  62 {
  63     checkoutFields(meanScalarFields_);
  64     meanScalarFields_.clear();
  65     meanScalarFields_.setSize(nItems);
  66
  67     checkoutFields(meanVectorFields_);
  68     meanVectorFields_.clear();
  69     meanVectorFields_.setSize(nItems);
  70
  71     checkoutFields(meanSphericalTensorFields_);
  72     meanSphericalTensorFields_.clear();
  73     meanSphericalTensorFields_.setSize(nItems);
  74
  75     checkoutFields(meanSymmTensorFields_);
  76     meanSymmTensorFields_.clear();
  77     meanSymmTensorFields_.setSize(nItems);
  78
  79     checkoutFields(meanTensorFields_);
  80     meanTensorFields_.clear();
  81     meanTensorFields_.setSize(nItems);
  82
  83     checkoutFields(prime2MeanScalarFields_);
  84     prime2MeanScalarFields_.clear();
  85     prime2MeanScalarFields_.setSize(nItems);
  86
  87     checkoutFields(prime2MeanSymmTensorFields_);
  88     prime2MeanSymmTensorFields_.clear();
  89     prime2MeanSymmTensorFields_.setSize(nItems);
  90
  91     totalIter_.clear();
  92     totalIter_.setSize(nItems, 1);
  93
  94     totalTime_.clear();
  95     totalTime_.setSize(nItems, obr_.time().deltaT().value());
  96 }
  97
  98
  99 void Foam::fieldAverage::initialise()
 100 {
 101     // Add mean fields to the field lists
 102     forAll(faItems_, i)
 103     {
 104         const word& fieldName = faItems_[i].fieldName();
 105         if (obr_.foundObject<volScalarField>(fieldName))
 106         {
 107             addMeanField<scalar>(i, meanScalarFields_);
 108         }
 109         else if (obr_.foundObject<volVectorField>(fieldName))
 110         {
 111             addMeanField<vector>(i, meanVectorFields_);
 112         }
 113         else if (obr_.foundObject<volSphericalTensorField>(fieldName))
 114         {
 115             addMeanField<sphericalTensor>(i, meanSphericalTensorFields_);
 116         }
 117         else if (obr_.foundObject<volSymmTensorField>(fieldName))
 118         {
 119             addMeanField<symmTensor>(i, meanSymmTensorFields_);
 120         }
 121         else if (obr_.foundObject<volTensorField>(fieldName))
 122         {
 123             addMeanField<tensor>(i, meanTensorFields_);
 124         }
 125         else
 126         {
 127             FatalErrorIn("Foam::fieldAverage::initialise()")
 128                 << "Requested field " << faItems_[i].fieldName()
 129                 << " does not exist in the database" << nl
 130                 << exit(FatalError);
 131         }
 132     }
 133
 134     // Add prime-squared mean fields to the field lists
 135     forAll(faItems_, i)
 136     {
 137         if (faItems_[i].prime2Mean())
 138         {
 139             const word& fieldName = faItems_[i].fieldName();
 140             if (!faItems_[i].mean())
 141             {
 142                 FatalErrorIn("Foam::fieldAverage::initialise()")
 143                     << "To calculate the prime-squared average, the "
 144                     << "mean average must also be selected for field "
 145                     << fieldName << nl << exit(FatalError);
 146             }
 147
 148             if (obr_.foundObject<volScalarField>(fieldName))
 149             {
 150                 addPrime2MeanField<scalar, scalar>
 151                 (
 152                     i,
 153                     meanScalarFields_,
 154                     prime2MeanScalarFields_
 155                 );
 156             }
 157             else if (obr_.foundObject<volVectorField>(fieldName))
 158             {
 159                 addPrime2MeanField<vector, symmTensor>
 160                 (
 161                     i,
 162                     meanVectorFields_,
 163                     prime2MeanSymmTensorFields_
 164                 );
 165             }
 166             else
 167             {
 168                 FatalErrorIn("Foam::fieldAverage::initialise()")
 169                     << "prime2Mean average can only be applied to "
 170                     << "volScalarFields and volVectorFields"
 171                     << nl << "    Field: " << fieldName << nl
 172                     << exit(FatalError);
 173             }
 174         }
 175     }
 176 }
 177
 178
 179 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 180
 181 Foam::fieldAverage::fieldAverage
 182 (
 183     const word& name,
 184     const objectRegistry& obr,
 185     const dictionary& dict,
 186     const bool loadFromFiles
 187 )
 188 :
 189     name_(name),
 190     obr_(obr),
 191     active_(true),
 192     faItems_(dict.lookup("fields")),
 193     meanScalarFields_(faItems_.size()),
 194     meanVectorFields_(faItems_.size()),
 195     meanSphericalTensorFields_(faItems_.size()),
 196     meanSymmTensorFields_(faItems_.size()),
 197     meanTensorFields_(faItems_.size()),
 198     prime2MeanScalarFields_(faItems_.size()),
 199     prime2MeanSymmTensorFields_(faItems_.size()),
 200     totalIter_(faItems_.size(), 1),
 201     totalTime_(faItems_.size(), obr_.time().deltaT().value())
 202 {
 203     // Check if the available mesh is an fvMesh otherise deactivate
 204     if (!isA<fvMesh>(obr_))
 205     {
 206         active_ = false;
 207         WarningIn
 208         (
 209             "fieldAverage::fieldAverage\n"
 210             "(\n"
 211                 "const word&,\n"
 212                 "const objectRegistry&,\n"
 213                 "const dictionary&,\n"
 214                 "const bool\n"
 215             ")"
 216         )   << "No fvMesh available, deactivating."
 217             << nl << endl;
 218     }
 219
 220     read(dict);
 221 }
 222
 223
 224 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 225
 226 Foam::fieldAverage::~fieldAverage()
 227 {}
 228
 229
 230 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 231
 232 void Foam::fieldAverage::read(const dictionary& dict)
 233 {
 234     if (active_)
 235     {
 236         faItems_.clear();
 237         faItems_ = List<fieldAverageItem>(dict.lookup("fields"));
 238
 239         resetLists(faItems_.size());
 240
 241         initialise();
 242
 243         readAveragingProperties();
 244     }
 245 }
 246
 247
 248 void Foam::fieldAverage::write()
 249 {
 250     if (active_)
 251     {
 252         calcAverages();
 253
 254         if (obr_.time().outputTime())
 255         {
 256             writeAverages();
 257
 258             writeAveragingProperties();
 259         }
 260     }
 261 }
 262
 263
 264 void Foam::fieldAverage::calcAverages()
 265 {
 266     Info<< "Calculating averages" << nl << endl;
 267     forAll(faItems_, i)
 268     {
 269         totalIter_[i]++;
 270         totalTime_[i] += obr_.time().deltaT().value();
 271     }
 272
 273     addMeanSqrToPrime2Mean<scalar, scalar>
 274     (
 275         meanScalarFields_,
 276         prime2MeanScalarFields_
 277     );
 278     addMeanSqrToPrime2Mean<vector, symmTensor>
 279     (
 280         meanVectorFields_,
 281         prime2MeanSymmTensorFields_
 282     );
 283
 284     calculateMeanFields<scalar>(meanScalarFields_);
 285     calculateMeanFields<vector>(meanVectorFields_);
 286     calculateMeanFields<sphericalTensor>(meanSphericalTensorFields_);
 287     calculateMeanFields<symmTensor>(meanSymmTensorFields_);
 288     calculateMeanFields<tensor>(meanTensorFields_);
 289
 290     calculatePrime2MeanFields<scalar, scalar>
 291     (
 292         meanScalarFields_,
 293         prime2MeanScalarFields_
 294     );
 295     calculatePrime2MeanFields<vector, symmTensor>
 296     (
 297         meanVectorFields_,
 298         prime2MeanSymmTensorFields_
 299     );
 300 }
 301
 302
 303 void Foam::fieldAverage::writeAverages() const
 304 {
 305     writeFieldList<scalar>(meanScalarFields_);
 306     writeFieldList<vector>(meanVectorFields_);
 307     writeFieldList<sphericalTensor>(meanSphericalTensorFields_);
 308     writeFieldList<symmTensor>(meanSymmTensorFields_);
 309     writeFieldList<tensor>(meanTensorFields_);
 310
 311     writeFieldList<scalar>(prime2MeanScalarFields_);
 312     writeFieldList<symmTensor>(prime2MeanSymmTensorFields_);
 313 }
 314
 315
 316 void Foam::fieldAverage::writeAveragingProperties() const
 317 {
 318     IOdictionary propsDict
 319     (
 320         IOobject
 321         (
 322             "fieldAveragingProperties",
 323             obr_.time().timeName(),
 324             "uniform",
 325             obr_,
 326             IOobject::NO_READ,
 327             IOobject::NO_WRITE,
 328             false
 329         )
 330     );
 331
 332     forAll(faItems_, i)
 333     {
 334         const word& fieldName = faItems_[i].fieldName();
 335         propsDict.add(fieldName, dictionary());
 336         propsDict.subDict(fieldName).add("totalIter", totalIter_[i]);
 337         propsDict.subDict(fieldName).add("totalTime", totalTime_[i]);
 338     }
 339
 340     propsDict.regIOobject::write();
 341 }
 342
 343
 344 void Foam::fieldAverage::readAveragingProperties()
 345 {
 346     IOobject io
 347     (
 348         "fieldAveragingProperties",
 349         obr_.time().timeName(),
 350         "uniform",
 351         obr_,
 352         IOobject::NO_READ,
 353         IOobject::NO_WRITE,
 354         false
 355     );
 356
 357     if (io.headerOk())
 358     {
 359         IOdictionary propsDict(io);
 360
 361         forAll(faItems_, i)
 362         {
 363             const word& fieldName = faItems_[i].fieldName();
 364             if (propsDict.found(fieldName))
 365             {
 366                 const dictionary& fieldDict = propsDict.subDict(fieldName);
 367
 368                 totalIter_[i] = readLabel(fieldDict.lookup("totalIter"));
 369                 totalTime_[i] = readScalar(fieldDict.lookup("totalTime"));
 370             }
 371         }
 372     }
 373 }
 374
 375
 376 void Foam::fieldAverage::updateMesh(const mapPolyMesh&)
 377 {
 378     // Do nothing
 379 }
 380
 381
 382 void Foam::fieldAverage::movePoints(const pointField&)
 383 {
 384     // Do nothing
 385 }
 386
 387
 388 // ************************************************************************* //