src/postProcessing/fieldAverage/fieldAverage/fieldAverageTemplates.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 "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     PtrList<GeometricField<Type, fvPatchField, volMesh> >& meanFieldList
  38 )
  39 {
  40     if (faItems_[fieldi].mean())
  41     {
  42         typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
  43
  44         const word& fieldName = faItems_[fieldi].fieldName();
  45         const fieldType& baseField = obr_.lookupObject<fieldType>(fieldName);
  46
  47         const word meanFieldName = fieldName + EXT_MEAN;
  48         Info<< "Reading/calculating field " << meanFieldName << nl << endl;
  49         meanFieldList.set
  50         (
  51             fieldi,
  52             new fieldType
  53             (
  54                 IOobject
  55                 (
  56                     meanFieldName,
  57                     obr_.time().timeName(),
  58                     obr_,
  59                     IOobject::READ_IF_PRESENT,
  60                     IOobject::NO_WRITE
  61                 ),
  62                 baseField
  63             )
  64         );
  65     }
  66 }
  67
  68
  69 template<class Type1, class Type2>
  70 void Foam::fieldAverage::addPrime2MeanField
  71 (
  72     const label fieldi,
  73     PtrList<GeometricField<Type1, fvPatchField, volMesh> >& meanFieldList,
  74     PtrList<GeometricField<Type2, fvPatchField, volMesh> >& prime2MeanFieldList
  75 )
  76 {
  77     if (faItems_[fieldi].mean() && meanFieldList.set(fieldi))
  78     {
  79         typedef GeometricField<Type1, fvPatchField, volMesh> fieldType1;
  80         typedef GeometricField<Type2, fvPatchField, volMesh> fieldType2;
  81
  82         const word& fieldName = faItems_[fieldi].fieldName();
  83         const fieldType1& baseField = obr_.lookupObject<fieldType1>(fieldName);
  84         const fieldType1& meanField = meanFieldList[fieldi];
  85
  86         const word meanFieldName = fieldName + EXT_PRIME2MEAN;
  87         Info<< "Reading/calculating field " << meanFieldName << nl << endl;
  88         prime2MeanFieldList.set
  89         (
  90             fieldi,
  91             new fieldType2
  92             (
  93                 IOobject
  94                 (
  95                     meanFieldName,
  96                     obr_.time().timeName(),
  97                     obr_,
  98                     IOobject::READ_IF_PRESENT,
  99                     IOobject::NO_WRITE
 100                 ),
 101                 sqr(baseField) - sqr(meanField)
 102             )
 103         );
 104     }
 105 }
 106
 107
 108 template<class Type>
 109 void Foam::fieldAverage::calculateMeanFields
 110 (
 111     PtrList<GeometricField<Type, fvPatchField, volMesh> >& meanFieldList
 112 )
 113 {
 114     typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
 115
 116     const scalar dt = obr_.time().deltaT().value();
 117
 118     forAll(faItems_, i)
 119     {
 120         if (faItems_[i].mean() && meanFieldList.set(i))
 121         {
 122             const word& fieldName = faItems_[i].fieldName();
 123             const fieldType& baseField =
 124                 obr_.lookupObject<fieldType>(fieldName);
 125             fieldType& meanField = meanFieldList[i];
 126
 127             scalar alpha = 0.0;
 128             scalar beta = 0.0;
 129             if (faItems_[i].timeBase())
 130             {
 131                  alpha = (totalTime_[i] - dt)/totalTime_[i];
 132                  beta = dt/totalTime_[i];
 133             }
 134             else
 135             {
 136                 alpha = scalar(totalIter_[i] - 1)/scalar(totalIter_[i]);
 137                 beta = 1.0/scalar(totalIter_[i]);
 138             }
 139
 140             meanField = alpha*meanField + beta*baseField;
 141         }
 142     }
 143 }
 144
 145
 146 template<class Type1, class Type2>
 147 void Foam::fieldAverage::calculatePrime2MeanFields
 148 (
 149     PtrList<GeometricField<Type1, fvPatchField, volMesh> >& meanFieldList,
 150     PtrList<GeometricField<Type2, fvPatchField, volMesh> >& prime2MeanFieldList
 151 )
 152 {
 153     typedef GeometricField<Type1, fvPatchField, volMesh> fieldType1;
 154     typedef GeometricField<Type2, fvPatchField, volMesh> fieldType2;
 155
 156     const scalar dt = obr_.time().deltaT().value();
 157
 158     forAll(faItems_, i)
 159     {
 160         if
 161         (
 162             faItems_[i].prime2Mean()
 163          && meanFieldList.set(i)
 164          && prime2MeanFieldList.set(i)
 165         )
 166         {
 167             const word& fieldName = faItems_[i].fieldName();
 168             const fieldType1& baseField =
 169                 obr_.lookupObject<fieldType1>(fieldName);
 170             const fieldType1& meanField = meanFieldList[i];
 171             fieldType2& prime2MeanField = prime2MeanFieldList[i];
 172
 173             scalar alpha = 0.0;
 174             scalar beta = 0.0;
 175             if (faItems_[i].timeBase())
 176             {
 177                 alpha = (totalTime_[i] - dt)/totalTime_[i];
 178                 beta = dt/totalTime_[i];
 179             }
 180             else
 181             {
 182                 alpha = scalar(totalIter_[i] - 1)/scalar(totalIter_[i]);
 183                 beta = 1.0/scalar(totalIter_[i]);
 184             }
 185
 186             prime2MeanField =
 187                 alpha*prime2MeanField
 188               + beta*sqr(baseField)
 189               - sqr(meanField);
 190         }
 191     }
 192 }
 193
 194
 195 template<class Type1, class Type2>
 196 void Foam::fieldAverage::addMeanSqrToPrime2Mean
 197 (
 198     PtrList<GeometricField<Type1, fvPatchField, volMesh> >& meanFieldList,
 199     PtrList<GeometricField<Type2, fvPatchField, volMesh> >& prime2MeanFieldList
 200 )
 201 {
 202     typedef GeometricField<Type1, fvPatchField, volMesh> fieldType1;
 203     typedef GeometricField<Type2, fvPatchField, volMesh> fieldType2;
 204
 205     forAll(faItems_, i)
 206     {
 207         if
 208         (
 209             faItems_[i].prime2Mean()
 210          && meanFieldList.set(i)
 211          && prime2MeanFieldList.set(i)
 212         )
 213         {
 214             const fieldType1& meanField = meanFieldList[i];
 215             fieldType2& prime2MeanField = prime2MeanFieldList[i];
 216
 217             prime2MeanField += sqr(meanField);
 218         }
 219     }
 220 }
 221
 222
 223 template<class Type>
 224 void Foam::fieldAverage::writeFieldList
 225 (
 226     const PtrList<GeometricField<Type, fvPatchField, volMesh> >& fieldList
 227 ) const
 228 {
 229     forAll(fieldList, i)
 230     {
 231         if (fieldList.set(i))
 232         {
 233             fieldList[i].write();
 234         }
 235     }
 236 }
 237
 238
 239 // ************************************************************************* //