src/lagrangian/spray/parcels/Templates/SprayParcel/SprayParcel.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011-2011 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
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your 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, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     Foam::SprayParcel
  26
  27 Description
  28     Reacing spray parcel, with added functionality for atomization and breakup
  29
  30 \*---------------------------------------------------------------------------*/
  31
  32 #ifndef SprayParcel_H
  33 #define SprayParcel_H
  34
  35 #include "particle.H"
  36
  37 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  38
  39 namespace Foam
  40 {
  41
  42 template<class ParcelType>
  43 class SprayParcel;
  44
  45 template<class ParcelType>
  46 Ostream& operator<<
  47 (
  48     Ostream&,
  49     const SprayParcel<ParcelType>&
  50 );
  51
  52 /*---------------------------------------------------------------------------*\
  53                           Class SprayParcel Declaration
  54 \*---------------------------------------------------------------------------*/
  55
  56 template<class ParcelType>
  57 class SprayParcel
  58 :
  59     public ParcelType
  60 {
  61
  62 protected:
  63
  64     // Protected data
  65
  66         // Spray parcel properties
  67
  68             //- Initial droplet diameter
  69             scalar d0_;
  70
  71             //- Injection position
  72             vector position0_;
  73
  74             //- Part of liquid core ( >0.5=liquid, <0.5=droplet )
  75             scalar liquidCore_;
  76
  77             //- Index for KH Breakup
  78             scalar KHindex_;
  79
  80             //- Spherical deviation
  81             scalar y_;
  82
  83             //- Rate of change of spherical deviation
  84             scalar yDot_;
  85
  86             //- Characteristic time (used in atomization and/or breakup model)
  87             scalar tc_;
  88
  89             //- Stripped parcel mass due to breakup
  90             scalar ms_;
  91
  92             //- Injected from injector (needed e.g. for calculating distance
  93             //  from injector)
  94             scalar injector_;
  95
  96             //- Momentum relaxation time (needed for calculating parcel acc.)
  97             scalar tMom_;
  98
  99             //- Passive scalar (extra variable to be defined by user)
 100             scalar user_;
 101
 102
 103 public:
 104
 105     // Static data members
 106
 107         //- String representation of properties
 108         static string propHeader;
 109
 110         //- Runtime type information
 111         TypeName("SprayParcel");
 112
 113
 114     // Constructors
 115
 116         //- Construct from owner, position, and cloud owner
 117         //  Other properties initialised as null
 118         inline SprayParcel
 119         (
 120             const polyMesh& mesh,
 121             const vector& position,
 122             const label cellI,
 123             const label tetFaceI,
 124             const label tetPtI
 125         );
 126
 127         //- Construct from components
 128         inline SprayParcel
 129         (
 130             const polyMesh& mesh,
 131             const vector& position,
 132             const label cellI,
 133             const label tetFaceI,
 134             const label tetPtI,
 135             const label typeId,
 136             const scalar nParticle0,
 137             const scalar d0,
 138             const scalar dTarget0,
 139             const vector& U0,
 140             const vector& f0,
 141             const vector& angularMomentum0,
 142             const vector& torque0,
 143             const scalarField& Y0,
 144             const scalar liquidCore,
 145             const scalar KHindex,
 146             const scalar y,
 147             const scalar yDot,
 148             const scalar tc,
 149             const scalar ms,
 150             const scalar injector,
 151             const scalar tMom,
 152             const scalar user,
 153             const typename ParcelType::constantProperties& constProps
 154         );
 155
 156         //- Construct from Istream
 157         SprayParcel
 158         (
 159             const polyMesh& mesh,
 160             Istream& is,
 161             bool readFields = true
 162         );
 163
 164         //- Construct as a copy
 165         SprayParcel
 166         (
 167             const SprayParcel& p,
 168             const polyMesh& mesh
 169         );
 170
 171         //- Construct as a copy
 172         SprayParcel(const SprayParcel& p);
 173
 174         //- Construct and return a (basic particle) clone
 175         virtual autoPtr<particle> clone() const
 176         {
 177             return autoPtr<particle>(new SprayParcel<ParcelType>(*this));
 178         }
 179
 180         //- Construct and return a (basic particle) clone
 181         virtual autoPtr<particle> clone(const polyMesh& mesh) const
 182         {
 183             return autoPtr<particle>
 184             (
 185                 new SprayParcel<ParcelType>(*this, mesh)
 186             );
 187         }
 188
 189         //- Factory class to read-construct particles used for
 190         //  parallel transfer
 191         class iNew
 192         {
 193             const polyMesh& mesh_;
 194
 195         public:
 196
 197             iNew(const polyMesh& mesh)
 198             :
 199                 mesh_(mesh)
 200             {}
 201
 202             autoPtr<SprayParcel<ParcelType> > operator()(Istream& is) const
 203             {
 204                 return autoPtr<SprayParcel<ParcelType> >
 205                 (
 206                     new SprayParcel<ParcelType>(mesh_, is, true)
 207                 );
 208             }
 209         };
 210
 211
 212     // Member Functions
 213
 214         // Access
 215
 216             //- Return const access to initial droplet diameter
 217             inline scalar d0() const;
 218
 219             //- Return const access to initial droplet position
 220             inline const vector& position0() const;
 221
 222             //- Return const access to liquid core
 223             inline scalar liquidCore() const;
 224
 225             //- Return const access to Kelvin-Helmholtz breakup index
 226             inline scalar KHindex() const;
 227
 228             //- Return const access to spherical deviation
 229             inline scalar y() const;
 230
 231             //- Return const access to rate of change of spherical deviation
 232             inline scalar yDot() const;
 233
 234             //- Return const access to atomization characteristic time
 235             inline scalar tc() const;
 236
 237             //- Return const access to stripped parcel mass
 238             inline scalar ms() const;
 239
 240             //- Return const access to injector id
 241             inline scalar injector() const;
 242
 243             //- Return const access to momentum relaxation time
 244             inline scalar tMom() const;
 245
 246             //- Return const access to passive user scalar
 247             inline scalar user() const;
 248
 249
 250         // Edit
 251
 252             //- Return access to initial droplet diameter
 253             inline scalar& d0();
 254
 255             //- Return access to initial droplet position
 256             inline vector& position0();
 257
 258             //- Return access to liquid core
 259             inline scalar& liquidCore();
 260
 261             //- Return access to Kelvin-Helmholtz breakup index
 262             inline scalar& KHindex();
 263
 264             //- Return access to spherical deviation
 265             inline scalar& y();
 266
 267             //- Return access to rate of change of spherical deviation
 268             inline scalar& yDot();
 269
 270             //- Return access to atomization characteristic time
 271             inline scalar& tc();
 272
 273             //- Return access to stripped parcel mass
 274             inline scalar& ms();
 275
 276             //- Return access to injector id
 277             inline scalar& injector();
 278
 279             //- Return access to momentum relaxation time
 280             inline scalar& tMom();
 281
 282             //- Return access to passive user scalar
 283             inline scalar& user();
 284
 285
 286         // Main calculation loop
 287
 288             //- Set cell values
 289             template<class TrackData>
 290             void setCellValues
 291             (
 292                 TrackData& td,
 293                 const scalar dt,
 294                 const label cellI
 295             );
 296
 297             //- Correct parcel properties according to atomization model
 298             template<class TrackData>
 299             void calcAtomization
 300             (
 301                 TrackData& td,
 302                 const scalar dt,
 303                 const label cellI
 304             );
 305
 306             //- Correct parcel properties according to breakup model
 307             template<class TrackData>
 308             void calcBreakup
 309             (
 310                 TrackData& td,
 311                 const scalar dt,
 312                 const label cellI
 313             );
 314
 315             //- Correct cell values using latest transfer information
 316             template<class TrackData>
 317             void cellValueSourceCorrection
 318             (
 319                 TrackData& td,
 320                 const scalar dt,
 321                 const label cellI
 322             );
 323
 324             //- Correct surface values due to emitted species
 325             template<class TrackData>
 326             void correctSurfaceValues
 327             (
 328                 TrackData& td,
 329                 const label cellI,
 330                 const scalar T,
 331                 const scalarField& Cs,
 332                 scalar& rhos,
 333                 scalar& mus,
 334                 scalar& Pr,
 335                 scalar& kappa
 336             );
 337
 338             //- Update parcel properties over the time interval
 339             template<class TrackData>
 340             void calc
 341             (
 342                 TrackData& td,
 343                 const scalar dt,
 344                 const label cellI
 345             );
 346
 347             //- Calculate the chi-factor for flash-boiling for the
 348             //  atomization model
 349             template<class TrackData>
 350             scalar chi
 351             (
 352                 TrackData& td,
 353                 const scalarField& X
 354             ) const;
 355
 356             //- Solve the TAB equation
 357             template<class TrackData>
 358             void solveTABEq
 359             (
 360                 TrackData& td,
 361                 const scalar dt
 362             );
 363
 364
 365         // I-O
 366
 367             //- Read
 368             template<class CloudType, class CompositionType>
 369             static void readFields
 370             (
 371                 CloudType& c,
 372                 const CompositionType& compModel
 373             );
 374
 375             //- Read - no composition
 376             template<class CloudType>
 377             static void readFields(CloudType& c);
 378
 379             //- Write
 380             template<class CloudType, class CompositionType>
 381             static void writeFields
 382             (
 383                 const CloudType& c,
 384                 const CompositionType& compModel
 385             );
 386
 387             //- Write - composition supplied
 388             template<class CloudType>
 389             static void writeFields(const CloudType& c);
 390
 391
 392     // Ostream Operator
 393
 394         friend Ostream& operator<< <ParcelType>
 395         (
 396             Ostream&,
 397             const SprayParcel<ParcelType>&
 398         );
 399 };
 400
 401
 402 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 403
 404 } // End namespace Foam
 405
 406 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 407
 408 #include "SprayParcelI.H"
 409
 410 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 411
 412 #ifdef NoRepository
 413     #include "SprayParcel.C"
 414 #endif
 415
 416
 417 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 418
 419 #endif
 420
 421 // ************************************************************************* //