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