src/lagrangian/spray/parcels/Templates/SprayParcel/SprayParcelIO.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 "SprayParcel.H"
  27 #include "IOstreams.H"
  28
  29 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  30
  31 template <class ParcelType>
  32 Foam::string Foam::SprayParcel<ParcelType>::propHeader =
  33     ParcelType::propHeader
  34   + " d0"
  35   + " position0"
  36   + " liquidCore"
  37   + " KHindex"
  38   + " y"
  39   + " yDot"
  40   + " tc"
  41   + " ms"
  42   + " injector"
  43   + " tMom"
  44   + " user";
  45
  46
  47 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  48
  49 template<class ParcelType>
  50 Foam::SprayParcel<ParcelType>::SprayParcel
  51 (
  52     const polyMesh& mesh,
  53     Istream& is,
  54     bool readFields
  55 )
  56 :
  57     ParcelType(mesh, is, readFields),
  58     d0_(0.0),
  59     position0_(vector::zero),
  60     liquidCore_(0.0),
  61     KHindex_(0.0),
  62     y_(0.0),
  63     yDot_(0.0),
  64     tc_(0.0),
  65     ms_(0.0),
  66     injector_(1.0),
  67     tMom_(GREAT),
  68     user_(0.0)
  69 {
  70     if (readFields)
  71     {
  72
  73         if (is.format() == IOstream::ASCII)
  74         {
  75             d0_ = readScalar(is);
  76             is >> position0_;
  77             liquidCore_ = readScalar(is);
  78             KHindex_ = readScalar(is);
  79             y_ = readScalar(is);
  80             yDot_ = readScalar(is);
  81             tc_ = readScalar(is);
  82             ms_ = readScalar(is);
  83             injector_ = readScalar(is);
  84             tMom_ = readScalar(is);
  85             user_ = readScalar(is);
  86         }
  87         else
  88         {
  89             is.read
  90             (
  91                 reinterpret_cast<char*>(&d0_),
  92                 sizeof(d0_)
  93               + sizeof(position0_)
  94               + sizeof(liquidCore_)
  95               + sizeof(KHindex_)
  96               + sizeof(y_)
  97               + sizeof(yDot_)
  98               + sizeof(tc_)
  99               + sizeof(ms_)
 100               + sizeof(injector_)
 101               + sizeof(tMom_)
 102               + sizeof(user_)
 103             );
 104         }
 105     }
 106
 107     // Check state of Istream
 108     is.check
 109     (
 110         "SprayParcel<ParcelType>::SprayParcel"
 111         "("
 112             "const polyMesh, "
 113             "Istream&, "
 114             "bool"
 115         ")"
 116     );
 117 }
 118
 119
 120 template<class ParcelType>
 121 template<class CloudType>
 122 void Foam::SprayParcel<ParcelType>::readFields(CloudType& c)
 123 {
 124     if (!c.size())
 125     {
 126         return;
 127     }
 128
 129     ParcelType::readFields(c);
 130 }
 131
 132
 133 template<class ParcelType>
 134 template<class CloudType, class CompositionType>
 135 void Foam::SprayParcel<ParcelType>::readFields
 136 (
 137     CloudType& c,
 138     const CompositionType& compModel
 139 )
 140 {
 141     if (!c.size())
 142     {
 143         return;
 144     }
 145
 146     ParcelType::readFields(c, compModel);
 147
 148     IOField<scalar> d0(c.fieldIOobject("d0", IOobject::MUST_READ));
 149     c.checkFieldIOobject(c, d0);
 150
 151     IOField<vector> position0
 152     (
 153         c.fieldIOobject("position0", IOobject::MUST_READ)
 154     );
 155     c.checkFieldIOobject(c, position0);
 156
 157     IOField<scalar> liquidCore(c.fieldIOobject
 158     (
 159         "liquidCore", IOobject::MUST_READ)
 160     );
 161     c.checkFieldIOobject(c, liquidCore);
 162
 163     IOField<scalar> KHindex(c.fieldIOobject("KHindex", IOobject::MUST_READ));
 164     c.checkFieldIOobject(c, KHindex);
 165
 166     IOField<scalar> y(c.fieldIOobject("y", IOobject::MUST_READ));
 167     c.checkFieldIOobject(c, y);
 168
 169     IOField<scalar> yDot(c.fieldIOobject("yDot", IOobject::MUST_READ));
 170     c.checkFieldIOobject(c, yDot);
 171
 172     IOField<scalar> tc(c.fieldIOobject("tc", IOobject::MUST_READ));
 173     c.checkFieldIOobject(c, tc);
 174
 175     IOField<scalar> ms(c.fieldIOobject("ms", IOobject::MUST_READ));
 176     c.checkFieldIOobject(c, ms);
 177
 178     IOField<scalar> injector(c.fieldIOobject("injector", IOobject::MUST_READ));
 179     c.checkFieldIOobject(c, injector);
 180
 181     IOField<scalar> tMom(c.fieldIOobject("tMom", IOobject::MUST_READ));
 182     c.checkFieldIOobject(c, tMom);
 183
 184     IOField<scalar> user(c.fieldIOobject("user", IOobject::MUST_READ));
 185     c.checkFieldIOobject(c, user);
 186
 187     label i = 0;
 188     forAllIter(typename Cloud<SprayParcel<ParcelType> >, c, iter)
 189     {
 190         SprayParcel<ParcelType>& p = iter();
 191         p.d0_ = d0[i];
 192         p.position0_ = position0[i];
 193         p.liquidCore_ = liquidCore[i];
 194         p.KHindex_ = KHindex[i];
 195         p.y_ = y[i];
 196         p.yDot_ = yDot[i];
 197         p.tc_ = tc[i];
 198         p.ms_ = ms[i];
 199         p.injector_ = injector[i];
 200         p.tMom_ = tMom[i];
 201         p.user_ = user[i];
 202         i++;
 203     }
 204 }
 205
 206
 207 template<class ParcelType>
 208 template<class CloudType>
 209 void Foam::SprayParcel<ParcelType>::writeFields(const CloudType& c)
 210 {
 211     ParcelType::writeFields(c);
 212 }
 213
 214
 215 template<class ParcelType>
 216 template<class CloudType, class CompositionType>
 217 void Foam::SprayParcel<ParcelType>::writeFields
 218 (
 219     const CloudType& c,
 220     const CompositionType& compModel
 221 )
 222 {
 223     ParcelType::writeFields(c, compModel);
 224
 225     label np = c.size();
 226
 227     IOField<scalar> d0(c.fieldIOobject("d0", IOobject::NO_READ), np);
 228     IOField<vector> position0
 229     (
 230         c.fieldIOobject("position0", IOobject::NO_READ),
 231         np
 232     );
 233     IOField<scalar> liquidCore
 234     (
 235         c.fieldIOobject("liquidCore", IOobject::NO_READ),
 236         np
 237     );
 238     IOField<scalar> KHindex(c.fieldIOobject("KHindex", IOobject::NO_READ), np);
 239     IOField<scalar> y(c.fieldIOobject("y", IOobject::NO_READ), np);
 240     IOField<scalar> yDot(c.fieldIOobject("yDot", IOobject::NO_READ), np);
 241     IOField<scalar> tc(c.fieldIOobject("tc", IOobject::NO_READ), np);
 242     IOField<scalar> ms(c.fieldIOobject("ms", IOobject::NO_READ), np);
 243     IOField<scalar> injector
 244     (
 245         c.fieldIOobject("injector", IOobject::NO_READ),
 246         np
 247     );
 248     IOField<scalar> tMom(c.fieldIOobject("tMom", IOobject::NO_READ), np);
 249     IOField<scalar> user(c.fieldIOobject("user", IOobject::NO_READ), np);
 250
 251     label i = 0;
 252     forAllConstIter(typename Cloud<SprayParcel<ParcelType> >, c, iter)
 253     {
 254         const SprayParcel<ParcelType>& p = iter();
 255         d0[i] = p.d0_;
 256         position0[i] = p.position0_;
 257         liquidCore[i] = p.liquidCore_;
 258         KHindex[i] = p.KHindex_;
 259         y[i] = p.y_;
 260         yDot[i] = p.yDot_;
 261         tc[i] = p.tc_;
 262         ms[i] = p.ms_;
 263         injector[i] = p.injector_;
 264         tMom[i] = p.tMom_;
 265         user[i] = p.user_;
 266         i++;
 267     }
 268
 269     d0.write();
 270     position0.write();
 271     liquidCore.write();
 272     KHindex.write();
 273     y.write();
 274     yDot.write();
 275     tc.write();
 276     ms.write();
 277     injector.write();
 278     tMom.write();
 279     user.write();
 280 }
 281
 282
 283 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 284
 285 template<class ParcelType>
 286 Foam::Ostream& Foam::operator<<
 287 (
 288     Ostream& os,
 289     const SprayParcel<ParcelType>& p
 290 )
 291 {
 292     if (os.format() == IOstream::ASCII)
 293     {
 294         os  << static_cast<const ParcelType&>(p)
 295         << token::SPACE << p.d0()
 296         << token::SPACE << p.position0()
 297         << token::SPACE << p.liquidCore()
 298         << token::SPACE << p.KHindex()
 299         << token::SPACE << p.y()
 300         << token::SPACE << p.yDot()
 301         << token::SPACE << p.tc()
 302         << token::SPACE << p.ms()
 303         << token::SPACE << p.injector()
 304         << token::SPACE << p.tMom()
 305         << token::SPACE << p.user();
 306     }
 307     else
 308     {
 309         os  << static_cast<const ParcelType&>(p);
 310         os.write
 311         (
 312             reinterpret_cast<const char*>(&p.d0_),
 313             sizeof(p.d0())
 314           + sizeof(p.position0())
 315           + sizeof(p.liquidCore())
 316           + sizeof(p.KHindex())
 317           + sizeof(p.y())
 318           + sizeof(p.yDot())
 319           + sizeof(p.tc())
 320           + sizeof(p.ms())
 321           + sizeof(p.injector())
 322           + sizeof(p.tMom())
 323           + sizeof(p.user())
 324         );
 325     }
 326
 327     // Check state of Ostream
 328     os.check
 329     (
 330         "Ostream& operator<<(Ostream&, const SprayParcel<ParcelType>&)"
 331     );
 332
 333     return os;
 334 }
 335
 336
 337 // ************************************************************************* //