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

   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 Class
  26     Foam::ThermoParcel
  27
  28 Description
  29     Thermodynamic parcel class with one/two-way coupling with the continuous
  30     phase. Includes Kinematic parcel sub-models, plus:
  31     - heat transfer
  32
  33 SourceFiles
  34     ThermoParcelI.H
  35     ThermoParcel.C
  36     ThermoParcelIO.C
  37
  38 \*---------------------------------------------------------------------------*/
  39
  40 #ifndef ThermoParcel_H
  41 #define ThermoParcel_H
  42
  43 #include "IOstream.H"
  44 #include "autoPtr.H"
  45 #include "interpolationCellPoint.H"
  46 #include "contiguous.H"
  47
  48 #include "KinematicParcel.H"
  49 #include "ThermoCloud.H"
  50
  51 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  52
  53 namespace Foam
  54 {
  55
  56 template<class ParcelType>
  57 class ThermoParcel;
  58
  59 template<class ParcelType>
  60 Ostream& operator<<
  61 (
  62     Ostream&,
  63     const ThermoParcel<ParcelType>&
  64 );
  65
  66 /*---------------------------------------------------------------------------*\
  67                        Class ThermoParcel Declaration
  68 \*---------------------------------------------------------------------------*/
  69
  70 template<class ParcelType>
  71 class ThermoParcel
  72 :
  73     public KinematicParcel<ParcelType>
  74 {
  75 public:
  76
  77     //- Class to hold thermo particle constant properties
  78     class constantProperties
  79     :
  80         public KinematicParcel<ParcelType>::constantProperties
  81     {
  82
  83         // Private data
  84
  85             //- Particle initial temperature [K]
  86             const scalar T0_;
  87
  88             //- Minimum temperature [K]
  89             const scalar TMin_;
  90
  91             //- Particle specific heat capacity [J/(kg.K)]
  92             const scalar cp0_;
  93
  94             //- Particle emissivity [] (radiation)
  95             const scalar epsilon0_;
  96
  97             //- Particle scattering factor [] (radiation)
  98             const scalar f0_;
  99
 100
 101     public:
 102
 103         // Constructors
 104         constantProperties(const dictionary& parentDict);
 105
 106         // Member functions
 107
 108             // Access
 109
 110                 //- Return const access to the particle initial temperature [K]
 111                 inline scalar T0() const;
 112
 113                 //- Return const access to minimum temperature [K]
 114                 inline scalar TMin() const;
 115
 116                 //- Return const access to the particle specific heat capacity
 117                 //  [J/(kg.K)]
 118                 inline scalar cp0() const;
 119
 120                 //- Return const access to the particle emissivity []
 121                 //  Active for radiation only
 122                 inline scalar epsilon0() const;
 123
 124                 //- Return const access to the particle scattering factor []
 125                 //  Active for radiation only
 126                 inline scalar f0() const;
 127     };
 128
 129
 130     //- Class used to pass thermo tracking data to the trackToFace function
 131     class trackData
 132     :
 133         public KinematicParcel<ParcelType>::trackData
 134     {
 135
 136         // Private data
 137
 138             //- Reference to the cloud containing this particle
 139             ThermoCloud<ParcelType>& cloud_;
 140
 141             //- Particle constant properties
 142             const constantProperties& constProps_;
 143
 144             // Interpolators for continuous phase fields
 145
 146                 //- Temperature field interpolator
 147                 const interpolation<scalar>& TInterp_;
 148
 149                 //- Specific heat capacity field interpolator
 150                 const interpolation<scalar>& cpInterp_;
 151
 152
 153     public:
 154
 155         // Constructors
 156
 157             //- Construct from components
 158             inline trackData
 159             (
 160                 ThermoCloud<ParcelType>& cloud,
 161                 const constantProperties& constProps,
 162                 const interpolation<scalar>& rhoInterp,
 163                 const interpolation<vector>& UInterp,
 164                 const interpolation<scalar>& muInterp,
 165                 const interpolation<scalar>& TInterp,
 166                 const interpolation<scalar>& cpInterp,
 167                 const vector& g
 168             );
 169
 170
 171         // Member functions
 172
 173             //- Return access to the owner cloud
 174             inline ThermoCloud<ParcelType>& cloud();
 175
 176             //- Return const access to the owner cloud
 177             inline const constantProperties& constProps() const;
 178
 179             //- Return const access to the interpolator for continuous
 180             //  phase temperature field
 181             inline const interpolation<scalar>& TInterp() const;
 182
 183             //- Return const access to the interpolator for continuous
 184             //  phase specific heat capacity field
 185             inline const interpolation<scalar>& cpInterp() const;
 186     };
 187
 188
 189 protected:
 190
 191     // Protected data
 192
 193         // Parcel properties
 194
 195             //- Temperature [K]
 196             scalar T_;
 197
 198             //- Specific heat capacity [J/(kg.K)]
 199             scalar cp_;
 200
 201
 202         // Cell-based quantities
 203
 204             //- Temperature [K]
 205             scalar Tc_;
 206
 207             //- Specific heat capacity [J/(kg.K)]
 208             scalar cpc_;
 209
 210
 211     // Protected member functions
 212
 213         //- Calculate new particle temperature
 214         template<class TrackData>
 215         scalar calcHeatTransfer
 216         (
 217             TrackData& td,
 218             const scalar dt,           // timestep
 219             const label cellI,         // owner cell
 220             const scalar d,            // diameter
 221             const vector& U,           // velocity
 222             const scalar rho,          // density
 223             const scalar T,            // temperature
 224             const scalar cp,           // specific heat capacity
 225             const scalar Sh,           // explicit particle enthalpy source
 226             scalar& dhsTrans           // sensible enthalpy transfer to carrier
 227         );
 228
 229
 230 public:
 231
 232     // Static data members
 233
 234         //- String representation of properties
 235         static string propHeader;
 236
 237         //- Runtime type information
 238         TypeName("ThermoParcel");
 239
 240
 241     friend class Cloud<ParcelType>;
 242
 243
 244     // Constructors
 245
 246         //- Construct from owner, position, and cloud owner
 247         //  Other properties initialised as null
 248         inline ThermoParcel
 249         (
 250             ThermoCloud<ParcelType>& owner,
 251             const vector& position,
 252             const label cellI
 253         );
 254
 255         //- Construct from components
 256         inline ThermoParcel
 257         (
 258             ThermoCloud<ParcelType>& owner,
 259             const vector& position,
 260             const label cellI,
 261             const label typeId,
 262             const scalar nParticle0,
 263             const scalar d0,
 264             const vector& U0,
 265             const constantProperties& constProps
 266         );
 267
 268         //- Construct from Istream
 269         ThermoParcel
 270         (
 271             const Cloud<ParcelType>& c,
 272             Istream& is,
 273             bool readFields = true
 274         );
 275
 276         //- Construct as a copy
 277         ThermoParcel(const ThermoParcel& p);
 278
 279         //- Construct and return a clone
 280         autoPtr<ThermoParcel> clone() const
 281         {
 282             return autoPtr<ThermoParcel>(new ThermoParcel(*this));
 283         }
 284
 285
 286     // Member Functions
 287
 288         // Access
 289
 290             //- Return const access to temperature
 291             inline scalar T() const;
 292
 293             //- Return const access to specific heat capacity
 294             inline scalar cp() const;
 295
 296
 297         // Edit
 298
 299             //- Return access to temperature
 300             inline scalar& T();
 301
 302             //- Return access to specific heat capacity
 303             inline scalar& cp();
 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             //- Update parcel properties over the time interval
 327             template<class TrackData>
 328             void calc
 329             (
 330                 TrackData& td,
 331                 const scalar dt,
 332                 const label cellI
 333             );
 334
 335
 336         // I-O
 337
 338             //- Read
 339             static void readFields(ThermoCloud<ParcelType>& c);
 340
 341             //- Write
 342             static void writeFields(const ThermoCloud<ParcelType>& c);
 343
 344
 345     // Ostream Operator
 346
 347         friend Ostream& operator<< <ParcelType>
 348         (
 349             Ostream&,
 350             const ThermoParcel<ParcelType>&
 351         );
 352 };
 353
 354
 355 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 356
 357 } // End namespace Foam
 358
 359 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 360
 361 #include "ThermoParcelI.H"
 362
 363 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 364
 365 #ifdef NoRepository
 366     #include "ThermoParcel.C"
 367 #endif
 368
 369 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 370
 371 #endif
 372
 373 // ************************************************************************* //