src/lagrangian/molecularDynamics/molecularMeasurements/bufferedAccumulator/bufferedAccumulator.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   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 \*---------------------------------------------------------------------------*/
  25
  26 #include "bufferedAccumulator.H"
  27
  28 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  29
  30 template<class Type>
  31 const char* const
  32     Foam::bufferedAccumulator<Type>::typeName("bufferedAccumulator");
  33
  34
  35 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  36
  37 template<class Type>
  38 void Foam::bufferedAccumulator<Type>::accumulateAndResetBuffer(const label b)
  39 {
  40     accumulationBuffer() += (*this)[b];
  41
  42     averagesTaken_++;
  43
  44     (*this)[b] = Field<Type>(bufferLength(), pTraits<Type>::zero);
  45
  46     bufferOffsets_[b] = 0;
  47 }
  48
  49
  50 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  51
  52 template<class Type>
  53 Foam::bufferedAccumulator<Type>::bufferedAccumulator()
  54 :
  55     List< Field<Type> >(),
  56     averagesTaken_(),
  57     bufferOffsets_()
  58 {}
  59
  60
  61 template<class Type>
  62 Foam::bufferedAccumulator<Type>::bufferedAccumulator
  63 (
  64     const label nBuffers,
  65     const label bufferLength,
  66     const label bufferingInterval
  67 )
  68 :
  69     List< Field<Type> >(),
  70     averagesTaken_(),
  71     bufferOffsets_()
  72 {
  73     setSizes
  74     (
  75         nBuffers,
  76         bufferLength,
  77         bufferingInterval
  78     );
  79 }
  80
  81
  82 template<class Type>
  83 Foam::bufferedAccumulator<Type>::bufferedAccumulator
  84 (
  85     const bufferedAccumulator<Type>& bA
  86 )
  87 :
  88     List< Field<Type> >(static_cast< List< Field<Type> > >(bA)),
  89     averagesTaken_(bA.averagesTaken()),
  90     bufferOffsets_(bA.bufferOffsets())
  91 {}
  92
  93
  94 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
  95
  96 template<class Type>
  97 Foam::bufferedAccumulator<Type>::~bufferedAccumulator()
  98 {}
  99
 100
 101 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 102
 103 template<class Type>
 104 void Foam::bufferedAccumulator<Type>::setSizes
 105 (
 106     const label nBuffers,
 107     const label bufferLength,
 108     const label bufferingInterval
 109 )
 110 {
 111     (*this).setSize(nBuffers + 1);
 112
 113     forAll((*this), b)
 114     {
 115         (*this)[b] = Field<Type>(bufferLength, pTraits<Type>::zero);
 116     }
 117
 118     averagesTaken_ = 0;
 119
 120     bufferOffsets_.setSize(nBuffers);
 121
 122     forAll(bufferOffsets_, bO)
 123     {
 124         bufferOffsets_[bO] = -bufferingInterval * bO - 1;
 125     }
 126 }
 127
 128
 129 template<class Type>
 130 Foam::label Foam::bufferedAccumulator<Type>::addToBuffers
 131 (
 132     const List<Type>& valuesToAdd
 133 )
 134 {
 135     label bufferToRefill = -1;
 136
 137     for (label b = 0; b < nBuffers(); b++)
 138     {
 139         Field<Type>& buf((*this)[b]);
 140
 141         label& bO = bufferOffsets_[b];
 142
 143         if (bO >= 0)
 144         {
 145             buf[bO] = valuesToAdd[b];
 146         }
 147
 148         bO++;
 149
 150         if (bO == bufferLength())
 151         {
 152             accumulateAndResetBuffer(b);
 153         }
 154
 155         if (bO == 0)
 156         {
 157             if (bufferToRefill != -1)
 158             {
 159                 FatalErrorIn("bufferedAccumulator<Type>::addToBuffers ")
 160                     << "More than one bufferedAccumulator accumulation "
 161                     << "buffer filled at once, this is considered an error."
 162                     << abort(FatalError);
 163             }
 164
 165             bufferToRefill = b;
 166         }
 167     }
 168
 169     return bufferToRefill;
 170 }
 171
 172
 173 template<class Type>
 174 Foam::Field<Type> Foam::bufferedAccumulator<Type>::averaged() const
 175 {
 176     if (averagesTaken_)
 177     {
 178         Field<Type> bA = accumulationBuffer()/averagesTaken_;
 179
 180         return bA;
 181     }
 182     else
 183     {
 184         WarningIn
 185         (
 186             "bufferedAccumulator<Type>::averagedbufferedAccumulator() const"
 187         )   << "Averaged correlation function requested but averagesTaken = "
 188             << averagesTaken_
 189             << ". Returning empty field."
 190             << endl;
 191
 192         return Field<Type>(bufferLength(), pTraits<Type>::zero);
 193     }
 194 }
 195
 196
 197 template<class Type>
 198 void Foam::bufferedAccumulator<Type>::resetAveraging()
 199 {
 200     accumulationBuffer() = Field<Type>(bufferLength(), pTraits<Type>::zero);
 201
 202     averagesTaken_ = 0;
 203 }
 204
 205
 206 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 207
 208 template<class Type>
 209 void Foam::bufferedAccumulator<Type>::operator=
 210 (
 211     const bufferedAccumulator<Type>& rhs
 212 )
 213 {
 214     // Check for assignment to self
 215     if (this == &rhs)
 216     {
 217         FatalErrorIn
 218         (
 219             "bufferedAccumulator<Type>::operator=(const bufferedAccumulator&)"
 220         )   << "Attempted assignment to self"
 221             << abort(FatalError);
 222     }
 223
 224     List< Field<Type> >::operator=(rhs);
 225
 226     averagesTaken_ = rhs.averagesTaken();
 227
 228     bufferOffsets_ = rhs.bufferOffsets();
 229 }
 230
 231
 232 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 233
 234 #   include "bufferedAccumulatorIO.C"
 235
 236 // ************************************************************************* //