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