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 (C) 2011 OpenFOAM Foundation
   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::KinematicParcel
  26
  27 Description
  28     Kinematic parcel class with rotational motion (as spherical
  29     particles only) and 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 "interpolation.H"
  51
  52 // #include "ParticleForceList.H" // TODO
  53
  54 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  55
  56 namespace Foam
  57 {
  58
  59 template<class ParcelType>
  60 class KinematicParcel;
  61
  62 // Forward declaration of friend functions
  63
  64 template<class ParcelType>
  65 Ostream& operator<<
  66 (
  67     Ostream&,
  68     const KinematicParcel<ParcelType>&
  69 );
  70
  71 /*---------------------------------------------------------------------------*\
  72                          Class KinematicParcel Declaration
  73 \*---------------------------------------------------------------------------*/
  74
  75 template<class ParcelType>
  76 class KinematicParcel
  77 :
  78     public ParcelType
  79 {
  80 public:
  81
  82     //- Class to hold kinematic particle constant properties
  83     class constantProperties
  84     {
  85         // Private data
  86
  87             //- Constant properties dictionary
  88             const dictionary dict_;
  89
  90             //- Parcel type id - used for post-processing to flag the type
  91             //  of parcels issued by this cloud
  92             label parcelTypeId_;
  93
  94             //- Minimum density [kg/m3]
  95             scalar rhoMin_;
  96
  97             //- Particle density [kg/m3] (constant)
  98             scalar rho0_;
  99
 100             //- Minimum particle mass [kg]
 101             scalar minParticleMass_;
 102
 103             //- Young's modulus [N/m2]
 104             scalar youngsModulus_;
 105
 106             //- Poisson's ratio
 107             scalar poissonsRatio_;
 108
 109
 110     public:
 111
 112         // Constructors
 113
 114             //- Null constructor
 115             constantProperties();
 116
 117             //- Copy constructor
 118             constantProperties(const constantProperties& cp);
 119
 120             //- Constructor from dictionary
 121             constantProperties
 122             (
 123                 const dictionary& parentDict,
 124                 const bool readFields = true
 125             );
 126
 127             //- Construct from components
 128             constantProperties
 129             (
 130                 const label parcelTypeId,
 131                 const scalar rhoMin,
 132                 const scalar rho0,
 133                 const scalar minParticleMass,
 134                 const scalar youngsModulus,
 135                 const scalar poissonsRatio
 136             );
 137
 138
 139         // Member functions
 140
 141             //- Return const access to the constant properties dictionary
 142             inline const dictionary& dict() const;
 143
 144             //- Return const access to the parcel type id
 145             inline label parcelTypeId() const;
 146
 147             //- Return const access to the minimum density
 148             inline scalar rhoMin() const;
 149
 150             //- Return const access to the particle density
 151             inline scalar rho0() const;
 152
 153             //- Return const access to the minimum particle mass
 154             inline scalar minParticleMass() const;
 155
 156             //- Return const access to Young's Modulus
 157             inline scalar youngsModulus() const;
 158
 159             //- Return const access to Poisson's ratio
 160             inline scalar poissonsRatio() const;
 161     };
 162
 163
 164     template<class CloudType>
 165     class TrackingData
 166     :
 167         public ParcelType::template TrackingData<CloudType>
 168     {
 169     public:
 170
 171         enum trackPart
 172         {
 173             tpVelocityHalfStep,
 174             tpLinearTrack,
 175             tpRotationalTrack
 176         };
 177
 178
 179     private:
 180
 181         // Private data
 182
 183             // Interpolators for continuous phase fields
 184
 185                 //- Density interpolator
 186                 autoPtr<interpolation<scalar> > rhoInterp_;
 187
 188                 //- Velocity interpolator
 189                 autoPtr<interpolation<vector> > UInterp_;
 190
 191                 //- Dynamic viscosity interpolator
 192                 autoPtr<interpolation<scalar> > muInterp_;
 193
 194
 195             //- Local gravitational or other body-force acceleration
 196             const vector& g_;
 197
 198             // label specifying which part of the integration
 199             // algorithm is taking place
 200             trackPart part_;
 201
 202
 203     public:
 204
 205         // Constructors
 206
 207             //- Construct from components
 208             inline TrackingData
 209             (
 210                 CloudType& cloud,
 211                 trackPart part = tpLinearTrack
 212             );
 213
 214
 215         // Member functions
 216
 217             //- Return conat access to the interpolator for continuous
 218             //  phase density field
 219             inline const interpolation<scalar>& rhoInterp() const;
 220
 221             //- Return conat access to the interpolator for continuous
 222             //  phase velocity field
 223             inline const interpolation<vector>& UInterp() const;
 224
 225             //- Return conat access to the interpolator for continuous
 226             //  phase dynamic viscosity field
 227             inline const interpolation<scalar>& muInterp() const;
 228
 229             // Return const access to the gravitational acceleration vector
 230             inline const vector& g() const;
 231
 232             //- Return the part of the tracking operation taking place
 233             inline trackPart part() const;
 234
 235             //- Return access to the part of the tracking operation taking place
 236             inline trackPart& part();
 237     };
 238
 239
 240 protected:
 241
 242     // Protected data
 243
 244         // Parcel properties
 245
 246             //- Active flag - tracking inactive when active = false
 247             bool active_;
 248
 249             //- Parcel type id
 250             label typeId_;
 251
 252             //- Number of particles in Parcel
 253             scalar nParticle_;
 254
 255             //- Diameter [m]
 256             scalar d_;
 257
 258             //- Target diameter [m]
 259             scalar dTarget_;
 260
 261             //- Velocity of Parcel [m/s]
 262             vector U_;
 263
 264             //- Force on particle due to collisions [N]
 265             vector f_;
 266
 267             //- Angular momentum of Parcel in global reference frame
 268             // [kg m2/s]
 269             vector angularMomentum_;
 270
 271             //- Torque on particle due to collisions in global
 272             //  reference frame [Nm]
 273             vector torque_;
 274
 275             //- Density [kg/m3]
 276             scalar rho_;
 277
 278             //- Age [s]
 279             scalar age_;
 280
 281             //- Time spent in turbulent eddy [s]
 282             scalar tTurb_;
 283
 284             //- Turbulent velocity fluctuation [m/s]
 285             vector UTurb_;
 286
 287
 288         // Cell-based quantities
 289
 290             //- Density [kg/m3]
 291             scalar rhoc_;
 292
 293             //- Velocity [m/s]
 294             vector Uc_;
 295
 296             //- Viscosity [Pa.s]
 297             scalar muc_;
 298
 299
 300     // Protected Member Functions
 301
 302         //- Calculate new particle velocity
 303         template<class TrackData>
 304         const vector calcVelocity
 305         (
 306             TrackData& td,
 307             const scalar dt,           // timestep
 308             const label cellI,         // owner cell
 309             const scalar Re,           // Reynolds number
 310             const scalar mu,           // local carrier viscosity
 311             const scalar mass,         // mass
 312             const vector& Su,          // explicit particle momentum source
 313             vector& dUTrans,           // momentum transfer to carrier
 314             scalar& Spu                // linearised drag coefficient
 315         ) const;
 316
 317
 318 public:
 319
 320     // Static data members
 321
 322         //- String representation of properties
 323         static string propHeader;
 324
 325         //- Runtime type information
 326         TypeName("KinematicParcel");
 327
 328
 329     // Constructors
 330
 331         //- Construct from owner, position, and cloud owner
 332         //  Other properties initialised as null
 333         inline KinematicParcel
 334         (
 335             const polyMesh& mesh,
 336             const vector& position,
 337             const label cellI,
 338             const label tetFaceI,
 339             const label tetPtI
 340         );
 341
 342         //- Construct from components
 343         inline KinematicParcel
 344         (
 345             const polyMesh& mesh,
 346             const vector& position,
 347             const label cellI,
 348             const label tetFaceI,
 349             const label tetPtI,
 350             const label typeId,
 351             const scalar nParticle0,
 352             const scalar d0,
 353             const scalar dTarget0,
 354             const vector& U0,
 355             const vector& f0,
 356             const vector& angularMomentum0,
 357             const vector& torque0,
 358             const constantProperties& constProps
 359         );
 360
 361         //- Construct from Istream
 362         KinematicParcel
 363         (
 364             const polyMesh& mesh,
 365             Istream& is,
 366             bool readFields = true
 367         );
 368
 369         //- Construct as a copy
 370         KinematicParcel(const KinematicParcel& p);
 371
 372         //- Construct as a copy
 373         KinematicParcel(const KinematicParcel& p, const polyMesh& mesh);
 374
 375         //- Construct and return a (basic particle) clone
 376         virtual autoPtr<particle> clone() const
 377         {
 378             return autoPtr<particle>(new KinematicParcel(*this));
 379         }
 380
 381         //- Construct and return a (basic particle) clone
 382         virtual autoPtr<particle> clone(const polyMesh& mesh) const
 383         {
 384             return autoPtr<particle>(new KinematicParcel(*this, mesh));
 385         }
 386
 387         //- Factory class to read-construct particles used for
 388         //  parallel transfer
 389         class iNew
 390         {
 391             const polyMesh& mesh_;
 392
 393         public:
 394
 395             iNew(const polyMesh& mesh)
 396             :
 397                 mesh_(mesh)
 398             {}
 399
 400             autoPtr<KinematicParcel<ParcelType> > operator()(Istream& is) const
 401             {
 402                 return autoPtr<KinematicParcel<ParcelType> >
 403                 (
 404                     new KinematicParcel<ParcelType>(mesh_, is, true)
 405                 );
 406             }
 407         };
 408
 409
 410     // Member Functions
 411
 412         // Access
 413
 414             //- Return const access to active flag
 415             inline bool active() const;
 416
 417             //- Return const access to type id
 418             inline label typeId() const;
 419
 420             //- Return const access to number of particles
 421             inline scalar nParticle() const;
 422
 423             //- Return const access to diameter
 424             inline scalar d() const;
 425
 426             //- Return const access to target diameter
 427             inline scalar dTarget() const;
 428
 429             //- Return const access to velocity
 430             inline const vector& U() const;
 431
 432             //- Return const access to force
 433             inline const vector& f() const;
 434
 435             //- Return const access to angular momentum
 436             inline const vector& angularMomentum() const;
 437
 438             //- Return const access to torque
 439             inline const vector& torque() const;
 440
 441             //- Return const access to density
 442             inline scalar rho() const;
 443
 444             //- Return const access to the age
 445             inline scalar age() const;
 446
 447             //- Return const access to time spent in turbulent eddy
 448             inline scalar tTurb() const;
 449
 450             //- Return const access to turbulent velocity fluctuation
 451             inline const vector& UTurb() const;
 452
 453             //- Return const access to carrier density [kg/m3]
 454             inline scalar rhoc() const;
 455
 456             //- Return const access to carrier velocity [m/s]
 457             inline const vector& Uc() const;
 458
 459             //- Return const access to carrier viscosity [Pa.s]
 460             inline scalar muc() const;
 461
 462
 463         // Edit
 464
 465             //- Return const access to active flag
 466             inline bool& active();
 467
 468             //- Return access to type id
 469             inline label& typeId();
 470
 471             //- Return access to number of particles
 472             inline scalar& nParticle();
 473
 474             //- Return access to diameter
 475             inline scalar& d();
 476
 477             //- Return access to target diameter
 478             inline scalar& dTarget();
 479
 480             //- Return access to velocity
 481             inline vector& U();
 482
 483             //- Return access to force
 484             inline vector& f();
 485
 486             //- Return access to angular momentum
 487             inline vector& angularMomentum();
 488
 489             //- Return access to torque
 490             inline vector& torque();
 491
 492             //- Return access to density
 493             inline scalar& rho();
 494
 495             //- Return access to the age
 496             inline scalar& age();
 497
 498             //- Return access to time spent in turbulent eddy
 499             inline scalar& tTurb();
 500
 501             //- Return access to turbulent velocity fluctuation
 502             inline vector& UTurb();
 503
 504
 505         // Helper functions
 506
 507             //- Return the index of the face to be used in the interpolation
 508             //  routine
 509             inline label faceInterpolation() const;
 510
 511             //- Cell owner mass
 512             inline scalar massCell(const label cellI) const;
 513
 514             //- Particle mass
 515             inline scalar mass() const;
 516
 517             //- Particle moment of inertia around diameter axis
 518             inline scalar momentOfInertia() const;
 519
 520             //- Particle angular velocity
 521             inline vector omega() const;
 522
 523             //- Particle volume
 524             inline scalar volume() const;
 525
 526             //- Particle volume for a given diameter
 527             inline static scalar volume(const scalar d);
 528
 529             //- Particle projected area
 530             inline scalar areaP() const;
 531
 532             //- Projected area for given diameter
 533             inline static scalar areaP(const scalar d);
 534
 535             //- Particle surface area
 536             inline scalar areaS() const;
 537
 538             //- Surface area for given diameter
 539             inline static scalar areaS(const scalar d);
 540
 541             //- Reynolds number
 542             inline scalar Re
 543             (
 544                 const vector& U,        // particle velocity
 545                 const scalar d,         // particle diameter
 546                 const scalar rhoc,      // carrier density
 547                 const scalar muc        // carrier dynamic viscosity
 548             ) const;
 549
 550             //- Weber number
 551             inline scalar We
 552             (
 553                 const vector& U,        // particle velocity
 554                 const scalar d,         // particle diameter
 555                 const scalar rhoc,      // carrier density
 556                 const scalar sigma      // particle surface tension
 557             ) const;
 558
 559
 560         // Main calculation loop
 561
 562             //- Set cell values
 563             template<class TrackData>
 564             void setCellValues
 565             (
 566                 TrackData& td,
 567                 const scalar dt,
 568                 const label cellI
 569             );
 570
 571             //- Correct cell values using latest transfer information
 572             template<class TrackData>
 573             void cellValueSourceCorrection
 574             (
 575                 TrackData& td,
 576                 const scalar dt,
 577                 const label cellI
 578             );
 579
 580             //- Update parcel properties over the time interval
 581             template<class TrackData>
 582             void calc
 583             (
 584                 TrackData& td,
 585                 const scalar dt,
 586                 const label cellI
 587             );
 588
 589
 590         // Tracking
 591
 592             //- Move the parcel
 593             template<class TrackData>
 594             bool move(TrackData& td, const scalar trackTime);
 595
 596
 597         // Patch interactions
 598
 599             //- Overridable function to handle the particle hitting a face
 600             //  without trackData
 601             void hitFace(int& td);
 602
 603             //- Overridable function to handle the particle hitting a face
 604             template<class TrackData>
 605             void hitFace(TrackData& td);
 606
 607             //- Overridable function to handle the particle hitting a patch
 608             //  Executed before other patch-hitting functions
 609             template<class TrackData>
 610             bool hitPatch
 611             (
 612                 const polyPatch& p,
 613                 TrackData& td,
 614                 const label patchI,
 615                 const scalar trackFraction,
 616                 const tetIndices& tetIs
 617             );
 618
 619             //- Overridable function to handle the particle hitting a
 620             //  processorPatch
 621             template<class TrackData>
 622             void hitProcessorPatch
 623             (
 624                 const processorPolyPatch&,
 625                 TrackData& td
 626             );
 627
 628             //- Overridable function to handle the particle hitting a wallPatch
 629             template<class TrackData>
 630             void hitWallPatch
 631             (
 632                 const wallPolyPatch&,
 633                 TrackData& td,
 634                 const tetIndices&
 635             );
 636
 637             //- Overridable function to handle the particle hitting a polyPatch
 638             template<class TrackData>
 639             void hitPatch
 640             (
 641                 const polyPatch&,
 642                 TrackData& td
 643             );
 644
 645             //- Transform the physical properties of the particle
 646             //  according to the given transformation tensor
 647             virtual void transformProperties(const tensor& T);
 648
 649             //- Transform the physical properties of the particle
 650             //  according to the given separation vector
 651             virtual void transformProperties(const vector& separation);
 652
 653             //- The nearest distance to a wall that the particle can be
 654             //  in the n direction
 655             virtual scalar wallImpactDistance(const vector& n) const;
 656
 657
 658         // I-O
 659
 660             //- Read
 661             template<class CloudType>
 662             static void readFields(CloudType& c);
 663
 664             //- Write
 665             template<class CloudType>
 666             static void writeFields(const CloudType& c);
 667
 668
 669     // Ostream Operator
 670
 671         friend Ostream& operator<< <ParcelType>
 672         (
 673             Ostream&,
 674             const KinematicParcel<ParcelType>&
 675         );
 676 };
 677
 678
 679 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 680
 681 } // End namespace Foam
 682
 683 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 684
 685 #include "KinematicParcelI.H"
 686 #include "KinematicParcelTrackingDataI.H"
 687
 688 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 689
 690 #ifdef NoRepository
 691     #include "KinematicParcel.C"
 692 #endif
 693
 694 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 695
 696 #endif
 697
 698 // ************************************************************************* //