src/lagrangian/intermediate/submodels/IO/DataEntry/Table/Table.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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 "Table.H"
  28
  29 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  30
  31 template<class Type>
  32 Foam::Table<Type>::Table(const word& entryName, Istream& is)
  33 :
  34     DataEntry<Type>(entryName),
  35     table_(is)
  36 {
  37     if (!table_.size())
  38     {
  39         FatalErrorIn("Foam::Table<Type>::Table(const Istream&)")
  40             << "Table for entry " << this->name_ << " is invalid (empty)"
  41             << nl << exit(FatalError);
  42     }
  43 }
  44
  45
  46 template<class Type>
  47 Foam::Table<Type>::Table(const Table<Type>& tbl)
  48 :
  49     DataEntry<Type>(tbl),
  50     table_(tbl.table_)
  51 {}
  52
  53
  54 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
  55
  56 template<class Type>
  57 Foam::Table<Type>::~Table()
  58 {}
  59
  60
  61 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  62
  63 template<class Type>
  64 Type Foam::Table<Type>::value(const scalar x) const
  65 {
  66     // Return zero if out of bounds
  67     if (x < table_[0].first() || x > table_[table_.size()-1].first())
  68     {
  69         return pTraits<Type>::zero;
  70     }
  71
  72     // Find i such that x(i) < x < x(i+1)
  73     label i = 0;
  74     while ((table_[i+1].first() < x) && (i+1 < table_.size()))
  75     {
  76         i++;
  77     }
  78
  79     // Linear interpolation to find value. Note constructor needed for
  80     // Table<label> to convert intermediate scalar back to label.
  81     return Type
  82     (
  83         (x - table_[i].first())/(table_[i+1].first() - table_[i].first())
  84       * (table_[i+1].second() - table_[i].second())
  85       + table_[i].second()
  86     );
  87 }
  88
  89
  90 template<class Type>
  91 Type Foam::Table<Type>::integrate(const scalar x1, const scalar x2) const
  92 {
  93     // Initialise return value
  94     Type sum = pTraits<Type>::zero;
  95
  96     // Return zero if out of bounds
  97     if ((x1 > table_[table_.size()-1].first()) || (x2 < table_[0].first()))
  98     {
  99         return sum;
 100     }
 101
 102     // Find next index greater than x1
 103     label id1 = 0;
 104     while ((table_[id1].first() < x1) && (id1 < table_.size()))
 105     {
 106         id1++;
 107     }
 108
 109     // Find next index less than x2
 110     label id2 = table_.size() - 1;
 111     while ((table_[id2].first() > x2) && (id2 >= 1))
 112     {
 113         id2--;
 114     }
 115
 116     if ((id1 - id2) == 1)
 117     {
 118         // x1 and x2 lie within 1 interval
 119         sum = 0.5*(value(x1) + value(x2))*(x2 - x1);
 120     }
 121     else
 122     {
 123         // x1 and x2 cross multiple intervals
 124
 125         // Integrate table body
 126         for (label i=id1; i<id2; i++)
 127         {
 128             sum +=
 129                 (table_[i].second() + table_[i+1].second())
 130               * (table_[i+1].first() - table_[i].first());
 131         }
 132         sum *= 0.5;
 133
 134         // Add table ends (partial segments)
 135         if (id1 > 0)
 136         {
 137             sum += 0.5
 138               * (value(x1) + table_[id1].second())
 139               * (table_[id1].first() - x1);
 140         }
 141         if (id2 < table_.size() - 1)
 142         {
 143             sum += 0.5
 144               * (table_[id2].second() + value(x2))
 145               * (x2 - table_[id2].first());
 146         }
 147     }
 148
 149     return sum;
 150 }
 151
 152
 153 // * * * * * * * * * * * * * *  IOStream operators * * * * * * * * * * * * * //
 154
 155 #include "TableIO.C"
 156
 157
 158 // ************************************************************************* //