src/lagrangian/intermediate/parcels/Templates/ThermoParcel/ThermoParcelIO.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 "ThermoParcel.H"
  28 #include "IOstreams.H"
  29
  30 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  31
  32 template <class ParcelType>
  33 Foam::string Foam::ThermoParcel<ParcelType>::propHeader =
  34     KinematicParcel<ParcelType>::propHeader
  35   + " T"
  36   + " cp";
  37
  38
  39 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  40
  41 template<class ParcelType>
  42 Foam::ThermoParcel<ParcelType>::ThermoParcel
  43 (
  44     const Cloud<ParcelType>& cloud,
  45     Istream& is,
  46     bool readFields
  47 )
  48 :
  49     KinematicParcel<ParcelType>(cloud, is, readFields),
  50     T_(0.0),
  51     cp_(0.0),
  52     Tc_(0.0),
  53     cpc_(0.0)
  54 {
  55     if (readFields)
  56     {
  57         if (is.format() == IOstream::ASCII)
  58         {
  59             T_ = readScalar(is);
  60             cp_ = readScalar(is);
  61         }
  62         else
  63         {
  64             is.read
  65             (
  66                 reinterpret_cast<char*>(&T_),
  67               + sizeof(T_)
  68               + sizeof(cp_)
  69             );
  70         }
  71     }
  72
  73     // Check state of Istream
  74     is.check
  75     (
  76         "ThermoParcel::ThermoParcel(const Cloud<ParcelType>&, Istream&, bool)"
  77     );
  78 }
  79
  80
  81 template<class ParcelType>
  82 void Foam::ThermoParcel<ParcelType>::readFields(Cloud<ParcelType>& c)
  83 {
  84     if (!c.size())
  85     {
  86         return;
  87     }
  88
  89     KinematicParcel<ParcelType>::readFields(c);
  90
  91     IOField<scalar> T(c.fieldIOobject("T", IOobject::MUST_READ));
  92     c.checkFieldIOobject(c, T);
  93
  94     IOField<scalar> cp(c.fieldIOobject("cp", IOobject::MUST_READ));
  95     c.checkFieldIOobject(c, cp);
  96
  97
  98     label i = 0;
  99     forAllIter(typename Cloud<ParcelType>, c, iter)
 100     {
 101         ThermoParcel<ParcelType>& p = iter();
 102
 103         p.T_ = T[i];
 104         p.cp_ = cp[i];
 105         i++;
 106     }
 107 }
 108
 109
 110 template<class ParcelType>
 111 void Foam::ThermoParcel<ParcelType>::writeFields(const Cloud<ParcelType>& c)
 112 {
 113     KinematicParcel<ParcelType>::writeFields(c);
 114
 115     label np =  c.size();
 116
 117     IOField<scalar> T(c.fieldIOobject("T", IOobject::NO_READ), np);
 118     IOField<scalar> cp(c.fieldIOobject("cp", IOobject::NO_READ), np);
 119
 120     label i = 0;
 121     forAllConstIter(typename Cloud<ParcelType>, c, iter)
 122     {
 123         const ThermoParcel<ParcelType>& p = iter();
 124
 125         T[i] = p.T_;
 126         cp[i] = p.cp_;
 127         i++;
 128     }
 129
 130     T.write();
 131     cp.write();
 132 }
 133
 134
 135 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 136
 137 template<class ParcelType>
 138 Foam::Ostream& Foam::operator<<
 139 (
 140     Ostream& os,
 141     const ThermoParcel<ParcelType>& p
 142 )
 143 {
 144     if (os.format() == IOstream::ASCII)
 145     {
 146         os  << static_cast<const KinematicParcel<ParcelType>&>(p)
 147             << token::SPACE << p.T()
 148             << token::SPACE << p.cp();
 149     }
 150     else
 151     {
 152         os  << static_cast<const KinematicParcel<ParcelType>&>(p);
 153         os.write
 154         (
 155             reinterpret_cast<const char*>(&p.T_),
 156             sizeof(p.T()) + sizeof(p.cp())
 157         );
 158     }
 159
 160     // Check state of Ostream
 161     os.check
 162     (
 163         "Ostream& operator<<(Ostream&, const ThermoParcel<ParcelType>&)"
 164     );
 165
 166     return os;
 167 }
 168
 169
 170 // ************************************************************************* //