src/lagrangian/intermediate/parcels/Templates/ReactingMultiphaseParcel/ReactingMultiphaseParcel.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::ReactingMultiphaseParcel
  27
  28 Description
  29     Multiphase variant of the reacting parcel class with one/two-way coupling
  30     with the continuous phase.
  31
  32 SourceFiles
  33     ReactingMultiphaseParcelI.H
  34     ReactingMultiphaseParcel.C
  35     ReactingMultiphaseParcelIO.C
  36
  37 \*---------------------------------------------------------------------------*/
  38
  39 #ifndef ReactingMultiphaseParcel_H
  40 #define ReactingMultiphaseParcel_H
  41
  42 #include "ReactingParcel.H"
  43 #include "ReactingMultiphaseCloud.H"
  44
  45 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  46
  47 namespace Foam
  48 {
  49
  50 template<class ParcelType>
  51 class ReactingMultiphaseParcel;
  52
  53 template<class ParcelType>
  54 Ostream& operator<<
  55 (
  56     Ostream&,
  57     const ReactingMultiphaseParcel<ParcelType>&
  58 );
  59
  60 /*---------------------------------------------------------------------------*\
  61                  Class ReactingMultiphaseParcel Declaration
  62 \*---------------------------------------------------------------------------*/
  63
  64 template<class ParcelType>
  65 class ReactingMultiphaseParcel
  66 :
  67     public ReactingParcel<ParcelType>
  68 {
  69 public:
  70
  71     // IDs of phases in ReacingParcel phase list (Y)
  72
  73         static const label GAS;
  74         static const label LIQ;
  75         static const label SLD;
  76
  77
  78     //- Class to hold reacting multiphase particle constant properties
  79     class constantProperties
  80     :
  81         public ReactingParcel<ParcelType>::constantProperties
  82     {
  83         // Private data
  84
  85             //- Latent heat of devolatilisation [J/kg]
  86             const scalar LDevol_;
  87
  88             //- Fraction of enthalpy retained by parcel due to surface
  89             //  reactions
  90             scalar hRetentionCoeff_;
  91
  92
  93     public:
  94
  95         //- Constructor
  96         constantProperties(const dictionary& parentDict);
  97
  98         // Access
  99
 100             //- Return const access to the latent heat of devolatilisation
 101             inline scalar LDevol() const;
 102
 103             //- Return const access to the fraction of enthalpy retained by
 104             //  parcel due to surface reactions
 105             inline scalar hRetentionCoeff() const;
 106     };
 107
 108
 109     //- Class used to pass reacting tracking data to the trackToFace function
 110     class trackData
 111     :
 112         public ReactingParcel<ParcelType>::trackData
 113     {
 114         // Private data
 115
 116             //- Reference to the cloud containing this particle
 117             ReactingMultiphaseCloud<ParcelType>& cloud_;
 118
 119             //- Particle constant properties
 120             const constantProperties& constProps_;
 121
 122
 123     public:
 124
 125         // Constructors
 126
 127             //- Construct from components
 128             inline trackData
 129             (
 130                 ReactingMultiphaseCloud<ParcelType>& cloud,
 131                 const constantProperties& constProps,
 132                 const interpolation<scalar>& rhoInterp,
 133                 const interpolation<vector>& UInterp,
 134                 const interpolation<scalar>& muInterp,
 135                 const interpolation<scalar>& TInterp,
 136                 const interpolation<scalar>& CpInterp,
 137                 const interpolation<scalar>& pInterp,
 138                 const vector& g
 139             );
 140
 141
 142         // Member functions
 143
 144             //- Return access to the owner cloud
 145             inline ReactingMultiphaseCloud<ParcelType>& cloud();
 146
 147             //- Return const access to the constant properties
 148             inline const constantProperties& constProps() const;
 149     };
 150
 151
 152 private:
 153
 154     // Private member functions
 155
 156         //- Return the mixture effective specific heat capacity
 157         template<class TrackData>
 158         scalar cpEff
 159         (
 160             TrackData& td,
 161             const scalar p,
 162             const scalar T,
 163             const label idG,
 164             const label idL,
 165             const label idS
 166         ) const;
 167
 168         //- Return the mixture effective enthalpy
 169         template<class TrackData>
 170         scalar HEff
 171         (
 172             TrackData& td,
 173             const scalar p,
 174             const scalar T,
 175             const label idG,
 176             const label idL,
 177             const label idS
 178         ) const;
 179
 180         //- Return the mixture effective latent heat
 181         template<class TrackData>
 182         scalar LEff
 183         (
 184             TrackData& td,
 185             const scalar p,
 186             const scalar T,
 187             const label idG,
 188             const label idL,
 189             const label idS
 190         ) const;
 191
 192         //- Update the mass fractions (Y, YGas, YLiquid, YSolid)
 193         scalar updateMassFractions
 194         (
 195             const scalar mass0,
 196             const scalarField& dMassGas,
 197             const scalarField& dMassLiquid,
 198             const scalarField& dMassSolid
 199         );
 200
 201
 202 protected:
 203
 204     // Protected data
 205
 206         // Parcel properties
 207
 208             //- Mass fractions of gases []
 209             scalarField YGas_;
 210
 211             //- Mass fractions of liquids []
 212             scalarField YLiquid_;
 213
 214             //- Mass fractions of solids []
 215             scalarField YSolid_;
 216
 217             //- Flag to say that the particle is allowed to combust
 218             //  Only true after volatile content falls below threshold value
 219             bool canCombust_;
 220
 221
 222     // Protected member functions
 223
 224         //- Calculate Devolatilisation
 225         template<class TrackData>
 226         void calcDevolatilisation
 227         (
 228             TrackData& td,
 229             const scalar dt,           // timestep
 230             const scalar Ts,           // Surface temperature
 231             const scalar d,            // diameter
 232             const scalar T,            // temperature
 233             const scalar mass,         // mass
 234             const scalar mass0,        // mass (initial on injection)
 235             const label idVolatile,    // id of volatile phase
 236             const scalar YVolatileTot, // total volatile mass fraction
 237             const scalarField& YVolatile, // volatile component mass fractions
 238             bool& canCombust,          // 'can combust' flag
 239             scalarField& dMassDV,      // mass transfer - local to particle
 240             scalar& Sh,                // explicit particle enthalpy source
 241             scalar& N,                 // flux of species emitted from particle
 242             scalar& NCpW,              // sum of N*Cp*W of emission species
 243             scalarField& Cs            // carrier conc. of emission species
 244         ) const;
 245
 246         //- Calculate surface reactions
 247         template<class TrackData>
 248         void calcSurfaceReactions
 249         (
 250             TrackData& td,
 251             const scalar dt,           // timestep
 252             const label cellI,         // owner cell
 253             const scalar d,            // diameter
 254             const scalar T,            // temperature
 255             const scalar mass,         // mass
 256             const bool canCombust,     // 'can combust' flag
 257             const scalar N,            // flux of species emitted from particle
 258             const scalarField& YMix,   // mixture mass fractions
 259             const scalarField& YGas,   // gas-phase mass fractions
 260             const scalarField& YLiquid,// liquid-phase mass fractions
 261             const scalarField& YSolid, // solid-phase mass fractions
 262             scalarField& dMassSRGas,   // gas-phase mass transfer - local
 263             scalarField& dMassSRLiquid,// liquid-phase mass transfer - local
 264             scalarField& dMassSRSolid, // solid-phase mass transfer - local
 265             scalarField& dMassSRCarrier, // carrier phase mass transfer
 266             scalar& Sh,                // explicit particle enthalpy source
 267             scalar& dhsTrans           // sensible enthalpy transfer to carrier
 268         ) const;
 269
 270
 271 public:
 272
 273     // Static data members
 274
 275         //- String representation of properties
 276         static string propHeader;
 277
 278         //- Runtime type information
 279         TypeName("ReactingMultiphaseParcel");
 280
 281
 282     friend class Cloud<ParcelType>;
 283
 284
 285     // Constructors
 286
 287         //- Construct from owner, position, and cloud owner
 288         //  Other properties initialised as null
 289         inline ReactingMultiphaseParcel
 290         (
 291             ReactingMultiphaseCloud<ParcelType>& owner,
 292             const vector& position,
 293             const label cellI
 294         );
 295
 296
 297         //- Construct from components
 298         inline ReactingMultiphaseParcel
 299         (
 300             ReactingMultiphaseCloud<ParcelType>& owner,
 301             const vector& position,
 302             const label cellI,
 303             const label typeId,
 304             const scalar nParticle0,
 305             const scalar d0,
 306             const vector& U0,
 307             const scalarField& Y0,
 308             const scalarField& YGas0,
 309             const scalarField& YLiquid0,
 310             const scalarField& YSolid0,
 311             const constantProperties& constProps
 312         );
 313
 314         //- Construct from Istream
 315         ReactingMultiphaseParcel
 316         (
 317             const Cloud<ParcelType>& c,
 318             Istream& is,
 319             bool readFields = true
 320         );
 321
 322         //- Construct as a copy
 323         ReactingMultiphaseParcel(const ReactingMultiphaseParcel& p);
 324
 325         //- Construct and return a clone
 326         autoPtr<ReactingMultiphaseParcel> clone() const
 327         {
 328             return
 329                 autoPtr<ReactingMultiphaseParcel>
 330                 (
 331                     new ReactingMultiphaseParcel(*this)
 332                 );
 333         }
 334
 335
 336     // Member Functions
 337
 338         // Access
 339
 340             //- Return const access to mass fractions of gases
 341             inline const scalarField& YGas() const;
 342
 343             //- Return const access to mass fractions of liquids
 344             inline const scalarField& YLiquid() const;
 345
 346             //- Return const access to mass fractions of solids
 347             inline const scalarField& YSolid() const;
 348
 349             //- Return const access to the canCombust flag
 350             inline bool canCombust() const;
 351
 352
 353         // Edit
 354
 355             //- Return access to mass fractions of gases
 356             inline scalarField& YGas();
 357
 358             //- Return access to mass fractions of liquids
 359             inline scalarField& YLiquid();
 360
 361             //- Return access to mass fractions of solids
 362             inline scalarField& YSolid();
 363
 364             //- Return access to the canCombust flag
 365             inline bool& canCombust();
 366
 367
 368         // Main calculation loop
 369
 370             //- Set cell values
 371             template<class TrackData>
 372             void setCellValues
 373             (
 374                 TrackData& td,
 375                 const scalar dt,
 376                 const label cellI
 377             );
 378
 379             //- Correct cell values using latest transfer information
 380             template<class TrackData>
 381             void cellValueSourceCorrection
 382             (
 383                 TrackData& td,
 384                 const scalar dt,
 385                 const label cellI
 386             );
 387
 388             //- Update parcel properties over the time interval
 389             template<class TrackData>
 390             void calc
 391             (
 392                 TrackData& td,
 393                 const scalar dt,
 394                 const label cellI
 395             );
 396
 397
 398         // I-O
 399
 400             //- Read
 401             static void readFields(Cloud<ParcelType>& c);
 402
 403             //- Write
 404             static void writeFields(const Cloud<ParcelType>& c);
 405
 406
 407     // Ostream Operator
 408
 409         friend Ostream& operator<< <ParcelType>
 410         (
 411             Ostream&,
 412             const ReactingMultiphaseParcel<ParcelType>&
 413         );
 414 };
 415
 416
 417 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 418
 419 } // End namespace Foam
 420
 421 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 422
 423 #include "ReactingMultiphaseParcelI.H"
 424
 425 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 426
 427 #ifdef NoRepository
 428     #include "ReactingMultiphaseParcel.C"
 429 #endif
 430
 431 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 432
 433 #endif
 434
 435 // ************************************************************************* //