src/lagrangian/dieselSpray/parcel/parcelIO.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
   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     IOField<scalar> d(c.fieldIOobject("d", IOobject::MUST_READ));
 110     c.checkFieldIOobject(c, d);
 111
 112     IOField<scalar> T(c.fieldIOobject("T", IOobject::MUST_READ));
 113     c.checkFieldIOobject(c, T);
 114
 115     IOField<scalar> m(c.fieldIOobject("m", IOobject::MUST_READ));
 116     c.checkFieldIOobject(c, m);
 117
 118     IOField<scalar> y(c.fieldIOobject("y", IOobject::MUST_READ));
 119     c.checkFieldIOobject(c, y);
 120
 121     IOField<scalar> yDot(c.fieldIOobject("yDot", IOobject::MUST_READ));
 122     c.checkFieldIOobject(c, yDot);
 123
 124     IOField<scalar> ct(c.fieldIOobject("ct", IOobject::MUST_READ));
 125     c.checkFieldIOobject(c, ct);
 126
 127     IOField<scalar> ms(c.fieldIOobject("ms", IOobject::MUST_READ));
 128     c.checkFieldIOobject(c, ms);
 129
 130     IOField<scalar> tTurb(c.fieldIOobject("tTurb", IOobject::MUST_READ));
 131     c.checkFieldIOobject(c, tTurb);
 132
 133     IOField<scalar> liquidCore
 134     (
 135         c.fieldIOobject("liquidCore", IOobject::MUST_READ)
 136     );
 137     c.checkFieldIOobject(c, liquidCore);
 138
 139     IOField<scalar> injector(c.fieldIOobject("injector", IOobject::MUST_READ));
 140     c.checkFieldIOobject(c, injector);
 141
 142     IOField<vector> U(c.fieldIOobject("U", IOobject::MUST_READ));
 143     c.checkFieldIOobject(c, U);
 144
 145     IOField<vector> Uturb(c.fieldIOobject("Uturb", IOobject::MUST_READ));
 146     c.checkFieldIOobject(c, Uturb);
 147
 148     IOField<vector> n(c.fieldIOobject("n", IOobject::MUST_READ));
 149     c.checkFieldIOobject(c, n);
 150
 151     label i = 0;
 152     forAllIter(Cloud<parcel>, c, iter)
 153     {
 154         parcel& p = iter();
 155
 156         p.d_ = d[i];
 157         p.T_ = T[i];
 158         p.m_ = m[i];
 159         p.y_ = y[i];
 160         p.yDot_ = yDot[i];
 161         p.ct_ = ct[i];
 162         p.ms_ = ms[i];
 163         p.tTurb_ = tTurb[i];
 164         p.liquidCore_ = liquidCore[i];
 165         p.injector_ = injector[i];
 166
 167         p.U_ = U[i];
 168         p.Uturb_ = Uturb[i];
 169         p.n_ = n[i];
 170
 171         i++;
 172     }
 173
 174     // read the liquid molar fractions
 175     if (c.size())
 176     {
 177         Cloud<parcel>::const_iterator iter = c.begin();
 178         const parcel& p0 = iter();
 179
 180         label nX = p0.X().size();
 181         const List<word>& names = p0.liquidNames();
 182
 183         for (label j=0; j<nX; j++)
 184         {
 185             IOField<scalar> X(c.fieldIOobject(names[j], IOobject::MUST_READ));
 186
 187             label i = 0;
 188             forAllIter(Cloud<parcel>, c, iter)
 189             {
 190                 parcel& p = iter();
 191                 p.X_[j] = X[i++];
 192             }
 193         }
 194     }
 195 }
 196
 197
 198 void Foam::parcel::writeFields
 199 (
 200     const Cloud<parcel>& c
 201 )
 202 {
 203     Particle<parcel>::writeFields(c);
 204
 205     label np = c.size();
 206
 207     IOField<scalar> d(c.fieldIOobject("d", IOobject::NO_READ), np);
 208     IOField<scalar> T(c.fieldIOobject("T", IOobject::NO_READ), np);
 209     IOField<scalar> m(c.fieldIOobject("m", IOobject::NO_READ), np);
 210     IOField<scalar> y(c.fieldIOobject("y", IOobject::NO_READ), np);
 211     IOField<scalar> yDot(c.fieldIOobject("yDot", IOobject::NO_READ), np);
 212     IOField<scalar> ct(c.fieldIOobject("ct", IOobject::NO_READ), np);
 213     IOField<scalar> ms(c.fieldIOobject("ms", IOobject::NO_READ), np);
 214     IOField<scalar> tTurb(c.fieldIOobject("tTurb", IOobject::NO_READ), np);
 215     IOField<scalar> liquidCore
 216     (
 217         c.fieldIOobject("liquidCore", IOobject::NO_READ),
 218         np
 219     );
 220     IOField<scalar> injector
 221     (
 222         c.fieldIOobject("injector", IOobject::NO_READ),
 223         np
 224     );
 225     IOField<vector> U(c.fieldIOobject("U", IOobject::NO_READ), np);
 226     IOField<vector> Uturb(c.fieldIOobject("Uturb", IOobject::NO_READ), np);
 227     IOField<vector> n(c.fieldIOobject("n", IOobject::NO_READ), np);
 228
 229     label i = 0;
 230     forAllConstIter(Cloud<parcel>, c, iter)
 231     {
 232         const parcel& p = iter();
 233
 234         d[i] = p.d_;
 235         T[i] = p.T_;
 236         m[i] = p.m_;
 237         y[i] = p.y_;
 238         yDot[i] = p.yDot_;
 239         ct[i] = p.ct_;
 240         ms[i] = p.ms_;
 241         tTurb[i] = p.tTurb_;
 242         liquidCore[i] = p.liquidCore_;
 243         injector[i] = p.injector_;
 244
 245         U[i] = p.U_;
 246         Uturb[i] = p.Uturb_;
 247         n[i] = p.n_;
 248
 249         i++;
 250     }
 251
 252     d.write();
 253     T.write();
 254     m.write();
 255     y.write();
 256     yDot.write();
 257     ct.write();
 258     ms.write();
 259     tTurb.write();
 260     liquidCore.write();
 261     injector.write();
 262
 263     U.write();
 264     Uturb.write();
 265     n.write();
 266
 267     // write the liquid molar fractions
 268     if (np > 0)
 269     {
 270         Cloud<parcel>::const_iterator iter = c.begin();
 271         const parcel& p0 = iter();
 272
 273         label nX = p0.X().size();
 274         const List<word>& names = p0.liquidNames();
 275
 276         for (label j=0; j<nX; j++)
 277         {
 278             IOField<scalar> X(c.fieldIOobject(names[j], IOobject::NO_READ), np);
 279
 280             label i = 0;
 281             forAllConstIter(Cloud<parcel>, c, iter)
 282             {
 283                 const parcel& p = iter();
 284                 X[i++] = p.X()[j];
 285             }
 286
 287             X.write();
 288         }
 289     }
 290 }
 291
 292
 293 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 294
 295 Foam::Ostream& Foam::operator<<(Ostream& os, const parcel& p)
 296 {
 297
 298     if (os.format() == IOstream::ASCII)
 299     {
 300         os  << static_cast<const Particle<parcel>&>(p)
 301             << token::SPACE << p.d_
 302             << token::SPACE << p.T_
 303             << token::SPACE << p.m_
 304             << token::SPACE << p.y_
 305             << token::SPACE << p.yDot_
 306             << token::SPACE << p.ct_
 307             << token::SPACE << p.ms_
 308             << token::SPACE << p.tTurb_
 309             << token::SPACE << p.liquidCore_
 310             << token::SPACE << p.injector_
 311             << token::SPACE << p.U_
 312             << token::SPACE << p.Uturb_
 313             << token::SPACE << p.n_
 314             << token::SPACE << p.X_;
 315     }
 316     else
 317     {
 318         os  << static_cast<const Particle<parcel>&>(p);
 319         os.write
 320         (
 321             reinterpret_cast<const char*>(&p.d_),
 322             sizeof(p.d_) + sizeof(p.T_) + sizeof(p.m_) + sizeof(p.y_)
 323           + sizeof(p.yDot_) + sizeof(p.ct_) + sizeof(p.ms_) + sizeof(p.tTurb_)
 324           + sizeof(p.liquidCore_) + sizeof(p.injector_)
 325           + sizeof(p.U_) + sizeof(p.Uturb_) + sizeof(p.n_)
 326         );
 327
 328         os.write
 329         (
 330             reinterpret_cast<const char*>(p.X_.begin()),
 331             p.X_.size()*sizeof(scalar)
 332         );
 333     }
 334
 335     // Check state of Ostream
 336     os.check("Ostream& operator<<(Ostream&, const parcel&)");
 337
 338     return os;
 339 }
 340
 341
 342 // ************************************************************************* //