src/postProcessing/functionObjects/field/fieldAverage/fieldAverage/fieldAverageTemplates.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 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 "fieldAverageItem.H"
  28 #include "volFields.H"
  29 #include "OFstream.H"
  30
  31 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  32
  33 template<class Type>
  34 void Foam::fieldAverage::addMeanField
  35 (
  36     const label fieldI,
  37     wordList& meanFieldList
  38 ) const
  39 {
  40     if (faItems_[fieldI].mean())
  41     {
  42         typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
  43
  44         const word& fieldName = faItems_[fieldI].fieldName();
  45
  46         const word meanFieldName = fieldName + EXT_MEAN;
  47
  48         Info<< "Reading/calculating field " << meanFieldName << nl << endl;
  49
  50         if (obr_.foundObject<fieldType>(meanFieldName))
  51         {
  52             meanFieldList[fieldI] = meanFieldName;
  53         }
  54         else if (obr_.found(meanFieldName))
  55         {
  56             Info<< "Cannot allocate average field " << meanFieldName
  57                 << " since an object with that name already exists."
  58                 << " Disabling averaging." << nl << endl;
  59             meanFieldList[fieldI] = word::null;
  60         }
  61         else
  62         {
  63             const fieldType& baseField =
  64                 obr_.lookupObject<fieldType>(fieldName);
  65
  66             // Store on registry
  67             obr_.store
  68             (
  69                 new fieldType
  70                 (
  71                     IOobject
  72                     (
  73                         meanFieldName,
  74                         obr_.time().timeName(),
  75                         obr_,
  76                         IOobject::READ_IF_PRESENT,
  77                         IOobject::NO_WRITE
  78                     ),
  79                     1*baseField
  80                 )
  81             );
  82
  83             meanFieldList[fieldI] = meanFieldName;
  84         }
  85     }
  86 }
  87
  88
  89 template<class Type1, class Type2>
  90 void Foam::fieldAverage::addPrime2MeanField
  91 (
  92     const label fieldI,
  93     const wordList& meanFieldList,
  94     wordList& prime2MeanFieldList
  95 ) const
  96 {
  97     if (faItems_[fieldI].mean() && meanFieldList[fieldI].size())
  98     {
  99         typedef GeometricField<Type1, fvPatchField, volMesh> fieldType1;
 100         typedef GeometricField<Type2, fvPatchField, volMesh> fieldType2;
 101
 102         const word& fieldName = faItems_[fieldI].fieldName();
 103
 104         const word meanFieldName = fieldName + EXT_PRIME2MEAN;
 105         Info<< "Reading/calculating field " << meanFieldName << nl << endl;
 106
 107         if (obr_.foundObject<fieldType2>(meanFieldName))
 108         {
 109             prime2MeanFieldList[fieldI] = meanFieldName;
 110         }
 111         else if (obr_.found(meanFieldName))
 112         {
 113             Info<< "Cannot allocate average field " << meanFieldName
 114                 << " since an object with that name already exists."
 115                 << " Disabling averaging." << nl << endl;
 116             prime2MeanFieldList[fieldI] = word::null;
 117         }
 118         else
 119         {
 120             const fieldType1& baseField =
 121                 obr_.lookupObject<fieldType1>(fieldName);
 122             const fieldType1& meanField =
 123                 obr_.lookupObject<fieldType1>(meanFieldList[fieldI]);
 124
 125             obr_.store
 126             (
 127                 new fieldType2
 128                 (
 129                     IOobject
 130                     (
 131                         meanFieldName,
 132                         obr_.time().timeName(),
 133                         obr_,
 134                         IOobject::READ_IF_PRESENT,
 135                         IOobject::NO_WRITE
 136                     ),
 137                     sqr(baseField) - sqr(meanField)
 138                 )
 139             );
 140
 141             prime2MeanFieldList[fieldI] = meanFieldName;
 142         }
 143     }
 144 }
 145
 146
 147 template<class Type>
 148 void Foam::fieldAverage::calculateMeanFields(const wordList& meanFieldList)
 149 const
 150 {
 151     typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
 152
 153     const scalar dt = obr_.time().deltaT().value();
 154
 155     forAll(faItems_, i)
 156     {
 157         if (faItems_[i].mean() && meanFieldList[i].size())
 158         {
 159             const word& fieldName = faItems_[i].fieldName();
 160             const fieldType& baseField =
 161                 obr_.lookupObject<fieldType>(fieldName);
 162             fieldType& meanField = const_cast<fieldType&>
 163             (
 164                 obr_.lookupObject<fieldType>(meanFieldList[i])
 165             );
 166
 167             scalar alpha = 0.0;
 168             scalar beta = 0.0;
 169             if (faItems_[i].timeBase())
 170             {
 171                  alpha = (totalTime_[i] - dt)/totalTime_[i];
 172                  beta = dt/totalTime_[i];
 173             }
 174             else
 175             {
 176                 alpha = scalar(totalIter_[i] - 1)/scalar(totalIter_[i]);
 177                 beta = 1.0/scalar(totalIter_[i]);
 178             }
 179
 180             meanField = alpha*meanField + beta*baseField;
 181         }
 182     }
 183 }
 184
 185
 186 template<class Type1, class Type2>
 187 void Foam::fieldAverage::calculatePrime2MeanFields
 188 (
 189     const wordList& meanFieldList,
 190     const wordList& prime2MeanFieldList
 191 ) const
 192 {
 193     typedef GeometricField<Type1, fvPatchField, volMesh> fieldType1;
 194     typedef GeometricField<Type2, fvPatchField, volMesh> fieldType2;
 195
 196     const scalar dt = obr_.time().deltaT().value();
 197
 198     forAll(faItems_, i)
 199     {
 200         if
 201         (
 202             faItems_[i].prime2Mean()
 203          && meanFieldList[i].size()
 204          && prime2MeanFieldList[i].size()
 205         )
 206         {
 207             const word& fieldName = faItems_[i].fieldName();
 208             const fieldType1& baseField =
 209                 obr_.lookupObject<fieldType1>(fieldName);
 210             const fieldType1& meanField =
 211                 obr_.lookupObject<fieldType1>(meanFieldList[i]);
 212             fieldType2& prime2MeanField = const_cast<fieldType2&>
 213             (
 214                 obr_.lookupObject<fieldType2>(prime2MeanFieldList[i])
 215             );
 216
 217             scalar alpha = 0.0;
 218             scalar beta = 0.0;
 219             if (faItems_[i].timeBase())
 220             {
 221                 alpha = (totalTime_[i] - dt)/totalTime_[i];
 222                 beta = dt/totalTime_[i];
 223             }
 224             else
 225             {
 226                 alpha = scalar(totalIter_[i] - 1)/scalar(totalIter_[i]);
 227                 beta = 1.0/scalar(totalIter_[i]);
 228             }
 229
 230             prime2MeanField =
 231                 alpha*prime2MeanField
 232               + beta*sqr(baseField)
 233               - sqr(meanField);
 234         }
 235     }
 236 }
 237
 238
 239 template<class Type1, class Type2>
 240 void Foam::fieldAverage::addMeanSqrToPrime2Mean
 241 (
 242     const wordList& meanFieldList,
 243     const wordList& prime2MeanFieldList
 244 ) const
 245 {
 246     typedef GeometricField<Type1, fvPatchField, volMesh> fieldType1;
 247     typedef GeometricField<Type2, fvPatchField, volMesh> fieldType2;
 248
 249     forAll(faItems_, i)
 250     {
 251         if
 252         (
 253             faItems_[i].prime2Mean()
 254          && meanFieldList[i].size()
 255          && prime2MeanFieldList[i].size()
 256         )
 257         {
 258             const fieldType1& meanField =
 259                 obr_.lookupObject<fieldType1>(meanFieldList[i]);
 260             fieldType2& prime2MeanField = const_cast<fieldType2&>
 261             (
 262                 obr_.lookupObject<fieldType2>(prime2MeanFieldList[i])
 263             );
 264
 265             prime2MeanField += sqr(meanField);
 266         }
 267     }
 268 }
 269
 270
 271 template<class Type>
 272 void Foam::fieldAverage::writeFieldList(const wordList& fieldList) const
 273 {
 274     typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
 275
 276     forAll(fieldList, i)
 277     {
 278         if (fieldList[i].size())
 279         {
 280             const fieldType& f = obr_.lookupObject<fieldType>(fieldList[i]);
 281             f.write();
 282         }
 283     }
 284 }
 285
 286
 287 // ************************************************************************* //