src/lagrangian/dieselSpray/parcel/parcelIO.C

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