src/lagrangian/intermediate/parcels/Templates/ReactingParcel/ReactingParcelIO.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 "ReactingParcel.H"
  28 #include "IOstreams.H"
  29
  30 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  31
  32 template <class ParcelType>
  33 Foam::string Foam::ReactingParcel<ParcelType>::propHeader =
  34     ThermoParcel<ParcelType>::propHeader
  35   + " mass0"
  36   + " nPhases(Y1..YN)";
  37
  38
  39 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  40
  41 template<class ParcelType>
  42 Foam::ReactingParcel<ParcelType>::ReactingParcel
  43 (
  44     const Cloud<ParcelType>& cloud,
  45     Istream& is,
  46     bool readFields
  47 )
  48 :
  49     ThermoParcel<ParcelType>(cloud, is, readFields),
  50     mass0_(0.0),
  51     Y_(0),
  52     pc_(0.0)
  53 {
  54     if (readFields)
  55     {
  56         const ReactingCloud<ParcelType>& cR =
  57             dynamic_cast<const ReactingCloud<ParcelType>&>(cloud);
  58
  59         const label nMixture = cR.composition().phaseTypes().size();
  60         Y_.setSize(nMixture);
  61
  62         if (is.format() == IOstream::ASCII)
  63         {
  64             is >> mass0_ >> Y_;
  65         }
  66         else
  67         {
  68             is.read
  69             (
  70                 reinterpret_cast<char*>(&mass0_),
  71               + sizeof(mass0_)
  72             );
  73             is >> Y_;
  74         }
  75     }
  76
  77     // Check state of Istream
  78     is.check
  79     (
  80         "ReactingParcel<ParcelType>::ReactingParcel"
  81         "("
  82             "const Cloud<ParcelType>&, "
  83             "Istream&, "
  84             "bool"
  85         ")"
  86     );
  87 }
  88
  89
  90 template<class ParcelType>
  91 void Foam::ReactingParcel<ParcelType>::readFields(Cloud<ParcelType>& cIn)
  92 {
  93     if (!cIn.size())
  94     {
  95         return;
  96     }
  97
  98     ReactingCloud<ParcelType>& c =
  99         dynamic_cast<ReactingCloud<ParcelType>&>(cIn);
 100
 101     ThermoParcel<ParcelType>::readFields(c);
 102
 103     IOField<scalar> mass0(c.fieldIOobject("mass0", IOobject::MUST_READ));
 104     c.checkFieldIOobject(c, mass0);
 105
 106     label i = 0;
 107     forAllIter(typename Cloud<ParcelType>, c, iter)
 108     {
 109         ReactingParcel<ParcelType>& p = iter();
 110         p.mass0_ = mass0[i++];
 111     }
 112
 113     // Get names and sizes for each Y...
 114     const wordList& phaseTypes = c.composition().phaseTypes();
 115     const label nPhases = phaseTypes.size();
 116     wordList stateLabels(nPhases, "");
 117     if (c.composition().nPhase() == 1)
 118     {
 119         stateLabels = c.composition().stateLabels();
 120     }
 121
 122
 123     // Set storage for each Y... for each parcel
 124     forAllIter(typename Cloud<ParcelType>, c, iter)
 125     {
 126         ReactingParcel<ParcelType>& p = iter();
 127         p.Y_.setSize(nPhases, 0.0);
 128     }
 129
 130     // Populate Y for each parcel
 131     forAll(phaseTypes, j)
 132     {
 133         IOField<scalar> Y
 134         (
 135             c.fieldIOobject
 136             (
 137                 "Y" + phaseTypes[j] + stateLabels[j],
 138                  IOobject::MUST_READ
 139             )
 140         );
 141
 142         label i = 0;
 143         forAllIter(typename Cloud<ParcelType>, c, iter)
 144         {
 145             ReactingParcel<ParcelType>& p = iter();
 146             p.Y_[j] = Y[i++];
 147         }
 148     }
 149 }
 150
 151
 152 template<class ParcelType>
 153 void Foam::ReactingParcel<ParcelType>::writeFields
 154 (
 155     const Cloud<ParcelType>& cIn
 156 )
 157 {
 158     const ReactingCloud<ParcelType>& c =
 159         dynamic_cast<const ReactingCloud<ParcelType>&>(cIn);
 160
 161     ThermoParcel<ParcelType>::writeFields(c);
 162
 163     const label np = c.size();
 164
 165     if (np > 0)
 166     {
 167         IOField<scalar> mass0(c.fieldIOobject("mass0", IOobject::NO_READ), np);
 168
 169         label i = 0;
 170         forAllConstIter(typename Cloud<ParcelType>, c, iter)
 171         {
 172             const ReactingParcel<ParcelType>& p = iter();
 173             mass0[i++] = p.mass0_;
 174         }
 175         mass0.write();
 176
 177         // Write the composition fractions
 178         const wordList& phaseTypes = c.composition().phaseTypes();
 179         wordList stateLabels(phaseTypes.size(), "");
 180         if (c.composition().nPhase() == 1)
 181         {
 182             stateLabels = c.composition().stateLabels();
 183         }
 184
 185         forAll(phaseTypes, j)
 186         {
 187             IOField<scalar> Y
 188             (
 189                 c.fieldIOobject
 190                 (
 191                     "Y" + phaseTypes[j] + stateLabels[j],
 192                     IOobject::NO_READ
 193                 ),
 194                 np
 195             );
 196
 197             label i = 0;
 198             forAllConstIter(typename Cloud<ParcelType>, c, iter)
 199             {
 200                 const ReactingParcel<ParcelType>& p0 = iter();
 201                 Y[i++] = p0.Y()[j];
 202             }
 203
 204             Y.write();
 205         }
 206     }
 207 }
 208
 209
 210 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 211
 212 template<class ParcelType>
 213 Foam::Ostream& Foam::operator<<
 214 (
 215     Ostream& os,
 216     const ReactingParcel<ParcelType>& p
 217 )
 218 {
 219     if (os.format() == IOstream::ASCII)
 220     {
 221         os  << static_cast<const ThermoParcel<ParcelType>&>(p)
 222             << token::SPACE << p.mass0()
 223             << token::SPACE << p.Y();
 224     }
 225     else
 226     {
 227         os  << static_cast<const ThermoParcel<ParcelType>&>(p);
 228         os.write
 229         (
 230             reinterpret_cast<const char*>(&p.mass0_),
 231             sizeof(p.mass0())
 232         );
 233         os  << p.Y();
 234     }
 235
 236     // Check state of Ostream
 237     os.check
 238     (
 239         "Ostream& operator<<(Ostream&, const ReactingParcel<ParcelType>&)"
 240     );
 241
 242     return os;
 243 }
 244
 245
 246 // ************************************************************************* //