src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcel.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::KinematicParcel
  27
  28 Description
  29     Kinematic parcel class with one/two-way coupling with the continuous
  30     phase.
  31
  32     Sub-models include:
  33     - drag
  34     - turbulent dispersion
  35     - wall interactions
  36
  37 SourceFiles
  38     KinematicParcelI.H
  39     KinematicParcel.C
  40     KinematicParcelIO.C
  41
  42 \*---------------------------------------------------------------------------*/
  43
  44 #ifndef KinematicParcel_H
  45 #define KinematicParcel_H
  46
  47 #include "Particle.H"
  48 #include "IOstream.H"
  49 #include "autoPtr.H"
  50 #include "interpolationCellPoint.H"
  51 #include "contiguous.H"
  52
  53 #include "KinematicCloud.H"
  54
  55 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  56
  57 namespace Foam
  58 {
  59
  60 template<class ParcelType>
  61 class KinematicParcel;
  62
  63 // Forward declaration of friend functions
  64
  65 template<class ParcelType>
  66 Ostream& operator<<
  67 (
  68     Ostream&,
  69     const KinematicParcel<ParcelType>&
  70 );
  71
  72 /*---------------------------------------------------------------------------*\
  73                          Class KinematicParcel Declaration
  74 \*---------------------------------------------------------------------------*/
  75
  76 template<class ParcelType>
  77 class KinematicParcel
  78 :
  79     public Particle<ParcelType>
  80 {
  81 public:
  82
  83     //- Class to hold kinematic particle constant properties
  84     class constantProperties
  85     {
  86         // Private data
  87
  88             //- Constant properties dictionary
  89             const dictionary dict_;
  90
  91             //- Minimum density [kg/m3]
  92             const scalar rhoMin_;
  93
  94             //- Particle density [kg/m3] (constant)
  95             const scalar rho0_;
  96
  97             //- Minimum particle mass [kg]
  98             const scalar minParticleMass_;
  99
 100
 101     public:
 102
 103         //- Constructor
 104         constantProperties(const dictionary& parentDict);
 105
 106         // Member functions
 107
 108             //- Return const access to the constant properties dictionary
 109             inline const dictionary& dict() const;
 110
 111             //- Return const access to the minimum density
 112             inline scalar rhoMin() const;
 113
 114             //- Return const access to the particle density
 115             inline scalar rho0() const;
 116
 117             //- Return const access to the minimum particle mass
 118             inline scalar minParticleMass() const;
 119     };
 120
 121
 122     //- Class used to pass kinematic tracking data to the trackToFace function
 123     class trackData
 124     :
 125         public Particle<ParcelType>::trackData
 126     {
 127         // Private data
 128
 129             //- Reference to the cloud containing this particle
 130             KinematicCloud<ParcelType>& cloud_;
 131
 132             //- Particle constant properties
 133             const constantProperties& constProps_;
 134
 135
 136             // Interpolators for continuous phase fields
 137
 138                 //- Density interpolator
 139                 const interpolation<scalar>& rhoInterp_;
 140
 141                 //- Velocity interpolator
 142                 const interpolation<vector>& UInterp_;
 143
 144                 //- Dynamic viscosity interpolator
 145                 const interpolation<scalar>& muInterp_;
 146
 147             //- Local gravitational or other body-force acceleration
 148             const vector& g_;
 149
 150
 151    public:
 152
 153         // Constructors
 154
 155            //- Construct from components
 156            inline trackData
 157             (
 158                 KinematicCloud<ParcelType>& cloud,
 159                 const constantProperties& constProps,
 160                 const interpolation<scalar>& rhoInterp,
 161                 const interpolation<vector>& UInterp,
 162                 const interpolation<scalar>& muInterp,
 163                 const vector& g
 164             );
 165
 166
 167         // Member functions
 168
 169             //- Return access to the owner cloud
 170             inline KinematicCloud<ParcelType>& cloud();
 171
 172             //- Return const access to the constant properties
 173             inline const constantProperties& constProps() const;
 174
 175             //- Return conat access to the interpolator for continuous
 176             //  phase density field
 177             inline const interpolation<scalar>& rhoInterp() const;
 178
 179             //- Return conat access to the interpolator for continuous
 180             //  phase velocity field
 181             inline const interpolation<vector>& UInterp() const;
 182
 183             //- Return conat access to the interpolator for continuous
 184             //  phase dynamic viscosity field
 185             inline const interpolation<scalar>& muInterp() const;
 186
 187             // Return const access to the gravitational acceleration vector
 188             inline const vector& g() const;
 189     };
 190
 191
 192 protected:
 193
 194     // Protected data
 195
 196         // Parcel properties
 197
 198             //- Parcel type id
 199             label typeId_;
 200
 201             //- Number of particles in Parcel
 202             scalar nParticle_;
 203
 204             //- Diameter [m]
 205             scalar d_;
 206
 207             //- Velocity of Parcel [m/s]
 208             vector U_;
 209
 210             //- Density [kg/m3]
 211             scalar rho_;
 212
 213             //- Time spent in turbulent eddy [s]
 214             scalar tTurb_;
 215
 216             //- Turbulent velocity fluctuation [m/s]
 217             vector UTurb_;
 218
 219
 220         // Cell-based quantities
 221
 222             //- Density [kg/m3]
 223             scalar rhoc_;
 224
 225             //- Velocity [m/s]
 226             vector Uc_;
 227
 228             //- Viscosity [Pa.s]
 229             scalar muc_;
 230
 231
 232     // Protected member functions
 233
 234         //- Calculate new particle velocity
 235         template<class TrackData>
 236         const vector calcVelocity
 237         (
 238             TrackData& td,
 239             const scalar dt,           // timestep
 240             const label cellI,         // owner cell
 241             const scalar Re,           // Reynolds number
 242             const scalar mu,           // local carrier viscosity
 243             const scalar d,            // diameter
 244             const vector& U,           // velocity
 245             const scalar rho,          // density
 246             const scalar mass,         // mass
 247             const vector& Su,          // explicit particle momentum source
 248             vector& dUTrans            // momentum transfer to carrier
 249         ) const;
 250
 251
 252 public:
 253
 254     // Static data members
 255
 256         //- String representation of properties
 257         static string propHeader;
 258
 259         //- Runtime type information
 260         TypeName("KinematicParcel");
 261
 262
 263     friend class Cloud<ParcelType>;
 264
 265
 266     // Constructors
 267
 268         //- Construct from owner, position, and cloud owner
 269         //  Other properties initialised as null
 270         inline KinematicParcel
 271         (
 272             KinematicCloud<ParcelType>& owner,
 273             const vector& position,
 274             const label cellI
 275         );
 276
 277         //- Construct from components
 278         inline KinematicParcel
 279         (
 280             KinematicCloud<ParcelType>& owner,
 281             const vector& position,
 282             const label cellI,
 283             const label typeId,
 284             const scalar nParticle0,
 285             const scalar d0,
 286             const vector& U0,
 287             const constantProperties& constProps
 288         );
 289
 290         //- Construct from Istream
 291         KinematicParcel
 292         (
 293             const Cloud<ParcelType>& c,
 294             Istream& is,
 295             bool readFields = true
 296         );
 297
 298         //- Construct as a copy
 299         KinematicParcel(const KinematicParcel& p);
 300
 301         //- Construct and return a clone
 302         autoPtr<KinematicParcel> clone() const
 303         {
 304             return autoPtr<KinematicParcel>(new KinematicParcel(*this));
 305         }
 306
 307
 308     // Member Functions
 309
 310         // Access
 311
 312             //- Return const access to type id
 313             inline label typeId() const;
 314
 315             //- Return const access to number of particles
 316             inline scalar nParticle() const;
 317
 318             //- Return const access to diameter
 319             inline scalar d() const;
 320
 321             //- Return const access to velocity
 322             inline const vector& U() const;
 323
 324             //- Return const access to density
 325             inline scalar rho() const;
 326
 327             //- Return const access to time spent in turbulent eddy
 328             inline scalar tTurb() const;
 329
 330             //- Return const access to turbulent velocity fluctuation
 331             inline const vector& UTurb() const;
 332
 333
 334         // Edit
 335
 336             //- Return access to type id
 337             inline label typeId();
 338
 339             //- Return access to number of particles
 340             inline scalar& nParticle();
 341
 342             //- Return access to diameter
 343             inline scalar& d();
 344
 345             //- Return access to velocity
 346             inline vector& U();
 347
 348             //- Return access to density
 349             inline scalar& rho();
 350
 351             //- Return access to time spent in turbulent eddy
 352             inline scalar& tTurb();
 353
 354             //- Return access to turbulent velocity fluctuation
 355             inline vector& UTurb();
 356
 357
 358         // Helper functions
 359
 360             //- The nearest distance to a wall that
 361             //  the particle can be in the n direction
 362             inline scalar wallImpactDistance(const vector& n) const;
 363
 364             //- Return the index of the face to be used in the interpolation
 365             //  routine
 366             inline label faceInterpolation() const;
 367
 368             //- Cell owner mass
 369             inline scalar massCell(const label cellI) const;
 370
 371             //- Particle mass
 372             inline scalar mass() const;
 373
 374             //- Particle volume
 375             inline scalar volume() const;
 376
 377             //- Particle volume for a given diameter
 378             inline scalar volume(const scalar d) const;
 379
 380             //- Particle projected area
 381             inline scalar areaP() const;
 382
 383             //- Projected area for given diameter
 384             inline scalar areaP(const scalar d) const;
 385
 386             //- Particle surface area
 387             inline scalar areaS() const;
 388
 389             //- Surface area for given diameter
 390             inline scalar areaS(const scalar d) const;
 391
 392             //- Reynolds number
 393             inline scalar Re
 394             (
 395                 const vector& U,        // particle velocity
 396                 const scalar d,         // particle diameter
 397                 const scalar rhoc,      // carrier density
 398                 const scalar muc        // carrier dynamic viscosity
 399             ) const;
 400
 401
 402         // Main calculation loop
 403
 404             //- Set cell values
 405             template<class TrackData>
 406             void setCellValues
 407             (
 408                 TrackData& td,
 409                 const scalar dt,
 410                 const label cellI
 411             );
 412
 413             //- Correct cell values using latest transfer information
 414             template<class TrackData>
 415             void cellValueSourceCorrection
 416             (
 417                 TrackData& td,
 418                 const scalar dt,
 419                 const label cellI
 420             );
 421
 422             //- Update parcel properties over the time interval
 423             template<class TrackData>
 424             void calc
 425             (
 426                 TrackData& td,
 427                 const scalar dt,
 428                 const label cellI
 429             );
 430
 431
 432         // Tracking
 433
 434             //- Move the parcel
 435             template<class TrackData>
 436             bool move(TrackData& td);
 437
 438
 439         // Patch interactions
 440
 441             //- Overridable function to handle the particle hitting a patch
 442             //  Executed before other patch-hitting functions
 443             template<class TrackData>
 444             bool hitPatch
 445             (
 446                 const polyPatch& p,
 447                 TrackData& td,
 448                 const label patchI
 449             );
 450
 451
 452             //- Overridable function to handle the particle hitting a patch
 453             //  Executed before other patch-hitting functions without trackData
 454             bool hitPatch
 455             (
 456                 const polyPatch& p,
 457                 int& td,
 458                 const label patchI
 459             );
 460
 461
 462             //- Overridable function to handle the particle hitting a
 463             //  processorPatch
 464             template<class TrackData>
 465             void hitProcessorPatch
 466             (
 467                 const processorPolyPatch&,
 468                 TrackData& td
 469             );
 470
 471             //- Overridable function to handle the particle hitting a
 472             //  processorPatch without trackData
 473             void hitProcessorPatch
 474             (
 475                 const processorPolyPatch&,
 476                 int&
 477             );
 478
 479             //- Overridable function to handle the particle hitting a wallPatch
 480             template<class TrackData>
 481             void hitWallPatch
 482             (
 483                 const wallPolyPatch&,
 484                 TrackData& td
 485             );
 486
 487             //- Overridable function to handle the particle hitting a wallPatch
 488             //  without trackData
 489             void hitWallPatch
 490             (
 491                 const wallPolyPatch&,
 492                 int&
 493             );
 494
 495             //- Overridable function to handle the particle hitting a polyPatch
 496             template<class TrackData>
 497             void hitPatch
 498             (
 499                 const polyPatch&,
 500                 TrackData& td
 501             );
 502
 503             //- Overridable function to handle the particle hitting a polyPatch
 504             //- without trackData
 505             void hitPatch
 506             (
 507                 const polyPatch&,
 508                 int&
 509             );
 510
 511             //- Transform the physical properties of the particle
 512             //  according to the given transformation tensor
 513             void transformProperties(const tensor& T);
 514
 515             //- Transform the physical properties of the particle
 516             //  according to the given separation vector
 517             void transformProperties(const vector& separation);
 518
 519
 520         // I-O
 521
 522             //- Read
 523             static void readFields(Cloud<ParcelType>& c);
 524
 525             //- Write
 526             static void writeFields(const Cloud<ParcelType>& c);
 527
 528
 529     // Ostream Operator
 530
 531         friend Ostream& operator<< <ParcelType>
 532         (
 533             Ostream&,
 534             const KinematicParcel<ParcelType>&
 535         );
 536 };
 537
 538
 539 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 540
 541 } // End namespace Foam
 542
 543 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 544
 545 #include "KinematicParcelI.H"
 546
 547 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 548
 549 #define defineParcelTypeNameAndDebug(Type, DebugSwitch)                       \
 550     template<>                                                                \
 551     const Foam::word KinematicParcel<Type>::typeName(#Type);                  \
 552     template<>                                                                \
 553     int KinematicParcel<Type>::debug                                          \
 554     (                                                                         \
 555         Foam::debug::debugSwitch(#Type, DebugSwitch)                          \
 556     );
 557
 558 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 559
 560 #ifdef NoRepository
 561     #include "KinematicParcel.C"
 562 #endif
 563
 564 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 565
 566 #endif
 567
 568 // ************************************************************************* //
 569