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 (C) 2011 OpenFOAM Foundation
   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
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your 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, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "ThermoParcel.H"
  27 #include "IOstreams.H"
  28
  29 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  30
  31 template<class ParcelType>
  32 Foam::string Foam::ThermoParcel<ParcelType>::propHeader =
  33     ParcelType::propHeader
  34   + " T"
  35   + " Cp";
  36
  37
  38 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  39
  40 template<class ParcelType>
  41 Foam::ThermoParcel<ParcelType>::ThermoParcel
  42 (
  43     const polyMesh& mesh,
  44     Istream& is,
  45     bool readFields
  46 )
  47 :
  48     ParcelType(mesh, is, readFields),
  49     T_(0.0),
  50     Cp_(0.0),
  51     Tc_(0.0),
  52     Cpc_(0.0)
  53 {
  54     if (readFields)
  55     {
  56         if (is.format() == IOstream::ASCII)
  57         {
  58             T_ = readScalar(is);
  59             Cp_ = readScalar(is);
  60         }
  61         else
  62         {
  63             is.read
  64             (
  65                 reinterpret_cast<char*>(&T_),
  66               + sizeof(T_)
  67               + sizeof(Cp_)
  68             );
  69         }
  70     }
  71
  72     // Check state of Istream
  73     is.check
  74     (
  75         "ThermoParcel::ThermoParcel(const polyMesh&, Istream&, bool)"
  76     );
  77 }
  78
  79
  80 template<class ParcelType>
  81 template<class CloudType>
  82 void Foam::ThermoParcel<ParcelType>::readFields(CloudType& c)
  83 {
  84     if (!c.size())
  85     {
  86         return;
  87     }
  88
  89     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<ThermoParcel<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 template<class CloudType>
 112 void Foam::ThermoParcel<ParcelType>::writeFields(const CloudType& c)
 113 {
 114     ParcelType::writeFields(c);
 115
 116     label np =  c.size();
 117
 118     IOField<scalar> T(c.fieldIOobject("T", IOobject::NO_READ), np);
 119     IOField<scalar> Cp(c.fieldIOobject("Cp", IOobject::NO_READ), np);
 120
 121     label i = 0;
 122     forAllConstIter(typename Cloud<ThermoParcel<ParcelType> >, c, iter)
 123     {
 124         const ThermoParcel<ParcelType>& p = iter();
 125
 126         T[i] = p.T_;
 127         Cp[i] = p.Cp_;
 128         i++;
 129     }
 130
 131     T.write();
 132     Cp.write();
 133 }
 134
 135
 136 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 137
 138 template<class ParcelType>
 139 Foam::Ostream& Foam::operator<<
 140 (
 141     Ostream& os,
 142     const ThermoParcel<ParcelType>& p
 143 )
 144 {
 145     if (os.format() == IOstream::ASCII)
 146     {
 147         os  << static_cast<const ParcelType&>(p)
 148             << token::SPACE << p.T()
 149             << token::SPACE << p.Cp();
 150     }
 151     else
 152     {
 153         os  << static_cast<const ParcelType&>(p);
 154         os.write
 155         (
 156             reinterpret_cast<const char*>(&p.T_),
 157             sizeof(p.T()) + sizeof(p.Cp())
 158         );
 159     }
 160
 161     // Check state of Ostream
 162     os.check
 163     (
 164         "Ostream& operator<<(Ostream&, const ThermoParcel<ParcelType>&)"
 165     );
 166
 167     return os;
 168 }
 169
 170
 171 // ************************************************************************* //