src/lagrangian/intermediate/parcels/Templates/ReactingParcel/ReactingParcel.H

   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 Class
  26     Foam::ReactingParcel
  27
  28 Description
  29     Reacting parcel class with one/two-way coupling with the continuous
  30     phase.
  31
  32 SourceFiles
  33     ReactingParcelI.H
  34     ReactingParcel.C
  35     ReactingParcelIO.C
  36
  37 \*---------------------------------------------------------------------------*/
  38
  39 #ifndef ReactingParcel_H
  40 #define ReactingParcel_H
  41
  42 #include "IOstream.H"
  43 #include "autoPtr.H"
  44 #include "interpolationCellPoint.H"
  45 #include "contiguous.H"
  46
  47 #include "ThermoParcel.H"
  48 #include "ReactingCloud.H"
  49 #include "reactingParcel.H"
  50
  51 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  52
  53 namespace Foam
  54 {
  55
  56 template<class ParcelType>
  57 class ReactingParcel;
  58
  59 template<class ParcelType>
  60 Ostream& operator<<
  61 (
  62     Ostream&,
  63     const ReactingParcel<ParcelType>&
  64 );
  65
  66 /*---------------------------------------------------------------------------*\
  67                         Class ReactingParcel Declaration
  68 \*---------------------------------------------------------------------------*/
  69
  70 template<class ParcelType>
  71 class ReactingParcel
  72 :
  73     public reactingParcel,
  74     public ThermoParcel<ParcelType>
  75 {
  76 public:
  77
  78     //- Class to hold reacting particle constant properties
  79     class constantProperties
  80     :
  81         public ThermoParcel<ParcelType>::constantProperties
  82     {
  83         // Private data
  84
  85             //- Minimum pressure [Pa]
  86             const scalar pMin_;
  87
  88             //- Constant volume flag - e.g. during mass transfer
  89             Switch constantVolume_;
  90
  91             //- Vaporisation temperature [K]
  92             const scalar Tvap_;
  93
  94             //- Boiling point [K]
  95             const scalar Tbp_;
  96
  97
  98     public:
  99
 100         //- Constructor
 101         constantProperties(const dictionary& parentDict);
 102
 103         // Access
 104
 105             //- Return const access to the minimum pressure
 106             inline scalar pMin() const;
 107
 108             //- Return const access to the constant volume flag
 109             inline Switch constantVolume() const;
 110
 111             //- Return const access to the vaporisation temperature
 112             inline scalar Tvap() const;
 113
 114             //- Return const access to the boiling point
 115             inline scalar Tbp() const;
 116    };
 117
 118
 119     //- Class used to pass reacting tracking data to the trackToFace function
 120     class trackData
 121     :
 122         public ThermoParcel<ParcelType>::trackData
 123     {
 124
 125         // Private data
 126
 127             //- Reference to the cloud containing this particle
 128             ReactingCloud<ParcelType>& cloud_;
 129
 130             //- Particle constant properties
 131             const constantProperties& constProps_;
 132
 133             //- Interpolator for continuous phase pressure field
 134             const interpolation<scalar>& pInterp_;
 135
 136
 137     public:
 138
 139         typedef ReactingCloud<ParcelType> cloudType;
 140
 141
 142         // Constructors
 143
 144             //- Construct from components
 145             inline trackData
 146             (
 147                 ReactingCloud<ParcelType>& cloud,
 148                 const constantProperties& constProps,
 149                 const interpolation<scalar>& rhoInterp,
 150                 const interpolation<vector>& UInterp,
 151                 const interpolation<scalar>& muInterp,
 152                 const interpolation<scalar>& TInterp,
 153                 const interpolation<scalar>& CpInterp,
 154                 const interpolation<scalar>& pInterp,
 155                 const vector& g
 156             );
 157
 158
 159         // Member functions
 160
 161             //- Return access to the owner cloud
 162             inline ReactingCloud<ParcelType>& cloud();
 163
 164             //- Return const access to the constant properties
 165             inline const constantProperties& constProps() const;
 166
 167             //- Return const access to the interpolator for continuous
 168             //  phase pressure field
 169             inline const interpolation<scalar>& pInterp() const;
 170     };
 171
 172
 173 protected:
 174
 175     // Protected data
 176
 177         // Parcel properties
 178
 179             //- Initial particle mass [kg]
 180             scalar mass0_;
 181
 182             //- Mass fractions of mixture []
 183             scalarField Y_;
 184
 185
 186         // Cell-based quantities
 187
 188             //- Pressure [Pa]
 189             scalar pc_;
 190
 191
 192     // Protected member functions
 193
 194         //- Calculate Phase change
 195         template<class TrackData>
 196         void calcPhaseChange
 197         (
 198             TrackData& td,
 199             const scalar dt,           // timestep
 200             const label cellI,         // owner cell
 201             const scalar Re,           // Reynolds number
 202             const scalar Ts,           // Surface temperature
 203             const scalar nus,          // Surface kinematic viscosity
 204             const scalar d,            // diameter
 205             const scalar T,            // temperature
 206             const scalar mass,         // mass
 207             const label idPhase,       // id of phase involved in phase change
 208             const scalar YPhase,       // total mass fraction
 209             const scalarField& YComponents, // component mass fractions
 210             scalarField& dMassPC,      // mass transfer - local to particle
 211             scalar& Sh,                // explicit particle enthalpy source
 212             scalar& N,                 // flux of species emitted from particle
 213             scalar& NCpW,              // sum of N*Cp*W of emission species
 214             scalarField& Cs            // carrier conc. of emission species
 215         );
 216
 217         //- Update mass fraction
 218         scalar updateMassFraction
 219         (
 220             const scalar mass0,
 221             const scalarField& dMass,
 222             scalarField& Y
 223         ) const;
 224
 225
 226 public:
 227
 228     // Static data members
 229
 230         //- String representation of properties
 231         static string propHeader;
 232
 233         //- Runtime type information
 234         TypeName("ReactingParcel");
 235
 236
 237     friend class Cloud<ParcelType>;
 238
 239
 240     // Constructors
 241
 242         //- Construct from owner, position, and cloud owner
 243         //  Other properties initialised as null
 244         inline ReactingParcel
 245         (
 246             ReactingCloud<ParcelType>& owner,
 247             const vector& position,
 248             const label cellI
 249         );
 250
 251         //- Construct from components
 252         inline ReactingParcel
 253         (
 254             ReactingCloud<ParcelType>& owner,
 255             const vector& position,
 256             const label cellI,
 257             const label typeId,
 258             const scalar nParticle0,
 259             const scalar d0,
 260             const vector& U0,
 261             const scalarField& Y0,
 262             const constantProperties& constProps
 263         );
 264
 265         //- Construct from Istream
 266         ReactingParcel
 267         (
 268             const Cloud<ParcelType>& c,
 269             Istream& is,
 270             bool readFields = true
 271         );
 272
 273         //- Construct as a copy
 274         ReactingParcel(const ReactingParcel& p);
 275
 276         //- Construct and return a clone
 277         autoPtr<ReactingParcel> clone() const
 278         {
 279             return autoPtr<ReactingParcel>(new ReactingParcel(*this));
 280         }
 281
 282
 283     // Member Functions
 284
 285         // Access
 286
 287             //- Return const access to initial mass
 288             inline scalar mass0() const;
 289
 290             //- Return const access to mass fractions of mixture
 291             inline const scalarField& Y() const;
 292
 293             //- Return the owner cell pressure
 294             inline scalar pc() const;
 295
 296
 297         // Edit
 298
 299             //- Return access to initial mass
 300             inline scalar& mass0();
 301
 302             //- Return access to mass fractions of mixture
 303             inline scalarField& Y();
 304
 305
 306         // Main calculation loop
 307
 308             //- Set cell values
 309             template<class TrackData>
 310             void setCellValues
 311             (
 312                 TrackData& td,
 313                 const scalar dt,
 314                 const label cellI
 315             );
 316
 317             //- Correct cell values using latest transfer information
 318             template<class TrackData>
 319             void cellValueSourceCorrection
 320             (
 321                 TrackData& td,
 322                 const scalar dt,
 323                 const label cellI
 324             );
 325
 326             //- Correct surface values due to emitted species
 327             template<class TrackData>
 328             void correctSurfaceValues
 329             (
 330                 TrackData& td,
 331                 const label cellI,
 332                 const scalar T,
 333                 const scalarField& Cs,
 334                 scalar& rhos,
 335                 scalar& mus,
 336                 scalar& Pr,
 337                 scalar& kappa
 338             );
 339
 340             //- Update parcel properties over the time interval
 341             template<class TrackData>
 342             void calc
 343             (
 344                 TrackData& td,
 345                 const scalar dt,
 346                 const label cellI
 347             );
 348
 349
 350         // I-O
 351
 352             //- Read
 353             static void readFields(Cloud<ParcelType>& c);
 354
 355             //- Write
 356             static void writeFields(const Cloud<ParcelType>& c);
 357
 358
 359     // Ostream Operator
 360
 361         friend Ostream& operator<< <ParcelType>
 362         (
 363             Ostream&,
 364             const ReactingParcel<ParcelType>&
 365         );
 366 };
 367
 368
 369 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 370
 371 } // End namespace Foam
 372
 373 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 374
 375 #include "ReactingParcelI.H"
 376
 377 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 378
 379 #ifdef NoRepository
 380     #include "ReactingParcel.C"
 381 #endif
 382
 383 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 384
 385 #endif
 386
 387 // ************************************************************************* //