src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.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::KinematicCloud
  26
  27 Description
  28     Templated base class for kinematic cloud
  29
  30     - cloud function objects
  31
  32     - particle forces, e.g.
  33       - buoyancy
  34       - drag
  35       - pressure gradient
  36       - ...
  37
  38     - sub-models:
  39       - dispersion model
  40       - injection model
  41       - patch interaction model
  42       - surface film model
  43
  44 SourceFiles
  45     KinematicCloudI.H
  46     KinematicCloud.C
  47
  48 \*---------------------------------------------------------------------------*/
  49
  50 #ifndef KinematicCloud_H
  51 #define KinematicCloud_H
  52
  53 #include "particle.H"
  54 #include "Cloud.H"
  55 #include "kinematicCloud.H"
  56 #include "IOdictionary.H"
  57 #include "autoPtr.H"
  58 #include "cachedRandom.H"
  59 #include "fvMesh.H"
  60 #include "volFields.H"
  61 #include "fvMatrices.H"
  62 #include "IntegrationSchemesFwd.H"
  63 #include "cloudSolution.H"
  64
  65 #include "ParticleForceList.H"
  66 #include "CloudFunctionObjectList.H"
  67
  68 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  69
  70 namespace Foam
  71 {
  72
  73 // Forward declaration of classes
  74
  75 template<class CloudType>
  76 class DispersionModel;
  77
  78 template<class CloudType>
  79 class InjectionModel;
  80
  81 template<class CloudType>
  82 class PatchInteractionModel;
  83
  84 template<class CloudType>
  85 class SurfaceFilmModel;
  86
  87
  88 /*---------------------------------------------------------------------------*\
  89                        Class KinematicCloud Declaration
  90 \*---------------------------------------------------------------------------*/
  91
  92 template<class CloudType>
  93 class KinematicCloud
  94 :
  95     public CloudType,
  96     public kinematicCloud
  97 {
  98 public:
  99
 100     // Public typedefs
 101
 102         //- Type of cloud this cloud was instantiated for
 103         typedef CloudType cloudType;
 104
 105         //- Type of parcel the cloud was instantiated for
 106         typedef typename CloudType::particleType parcelType;
 107
 108         //- Convenience typedef for this cloud type
 109         typedef KinematicCloud<CloudType> kinematicCloudType;
 110
 111         //- Force models type
 112         typedef ParticleForceList<KinematicCloud<CloudType> > forceType;
 113
 114         //- Function object type
 115         typedef CloudFunctionObjectList<KinematicCloud<CloudType> >
 116             functionType;
 117
 118
 119 private:
 120
 121     // Private data
 122
 123         //- Cloud copy pointer
 124         autoPtr<KinematicCloud<CloudType> > cloudCopyPtr_;
 125
 126
 127     // Private Member Functions
 128
 129         //- Disallow default bitwise copy construct
 130         KinematicCloud(const KinematicCloud&);
 131
 132         //- Disallow default bitwise assignment
 133         void operator=(const KinematicCloud&);
 134
 135
 136 protected:
 137
 138     // Protected data
 139
 140         //- References to the mesh and time databases
 141         const fvMesh& mesh_;
 142
 143         //- Dictionary of particle properties
 144         IOdictionary particleProperties_;
 145
 146         //- Solution properties
 147         cloudSolution solution_;
 148
 149         //- Parcel constant properties
 150         typename parcelType::constantProperties constProps_;
 151
 152         //- Sub-models dictionary
 153         const dictionary subModelProperties_;
 154
 155         //- Random number generator - used by some injection routines
 156         cachedRandom rndGen_;
 157
 158         //- Cell occupancy information for each parcel, (demand driven)
 159         autoPtr<List<DynamicList<parcelType*> > > cellOccupancyPtr_;
 160
 161
 162         // References to the carrier gas fields
 163
 164             //- Density [kg/m3]
 165             const volScalarField& rho_;
 166
 167             //- Velocity [m/s]
 168             const volVectorField& U_;
 169
 170             //- Dynamic viscosity [Pa.s]
 171             const volScalarField& mu_;
 172
 173
 174         // Environmental properties
 175
 176             //- Gravity
 177             const dimensionedVector& g_;
 178
 179             //- Averaged ambient domain pressure
 180             scalar pAmbient_;
 181
 182
 183         //- Optional particle forces
 184         forceType forces_;
 185
 186         //- Optional cloud function objects
 187         functionType functions_;
 188
 189
 190         // References to the cloud sub-models
 191
 192             //- Dispersion model
 193             autoPtr<DispersionModel<KinematicCloud<CloudType> > >
 194                 dispersionModel_;
 195
 196             //- Injector model
 197             autoPtr<InjectionModel<KinematicCloud<CloudType> > >
 198                 injectionModel_;
 199
 200             //- Patch interaction model
 201             autoPtr<PatchInteractionModel<KinematicCloud<CloudType> > >
 202                 patchInteractionModel_;
 203
 204             //- Surface film model
 205             autoPtr<SurfaceFilmModel<KinematicCloud<CloudType> > >
 206                 surfaceFilmModel_;
 207
 208
 209         // Reference to the particle integration schemes
 210
 211             //- Velocity integration
 212             autoPtr<vectorIntegrationScheme> UIntegrator_;
 213
 214
 215         // Sources
 216
 217             //- Momentum
 218             autoPtr<DimensionedField<vector, volMesh> > UTrans_;
 219
 220             //- Coefficient for carrier phase U equation
 221             autoPtr<DimensionedField<scalar, volMesh> > UCoeff_;
 222
 223
 224         // Initialisation
 225
 226             //- Set cloud sub-models
 227             void setModels();
 228
 229
 230         // Cloud evolution functions
 231
 232             //- Solve the cloud - calls all evolution functions
 233             template<class TrackData>
 234             void solve(TrackData& td);
 235
 236             //- Build the cellOccupancy
 237             void buildCellOccupancy();
 238
 239             //- Update (i.e. build) the cellOccupancy if it has
 240             //  already been used
 241             void updateCellOccupancy();
 242
 243             //- Evolve the cloud
 244             template<class TrackData>
 245             void evolveCloud(TrackData& td);
 246
 247             //- Post-evolve
 248             void postEvolve();
 249
 250             //- Reset state of cloud
 251             void cloudReset(KinematicCloud<CloudType>& c);
 252
 253
 254 public:
 255
 256     // Constructors
 257
 258         //- Construct given carrier gas fields
 259         KinematicCloud
 260         (
 261             const word& cloudName,
 262             const volScalarField& rho,
 263             const volVectorField& U,
 264             const volScalarField& mu,
 265             const dimensionedVector& g,
 266             bool readFields = true
 267         );
 268
 269         //- Copy constructor with new name
 270         KinematicCloud
 271         (
 272             KinematicCloud<CloudType>& c,
 273             const word& name
 274         );
 275
 276         //- Copy constructor with new name - creates bare cloud
 277         KinematicCloud
 278         (
 279             const fvMesh& mesh,
 280             const word& name,
 281             const KinematicCloud<CloudType>& c
 282         );
 283
 284         //- Construct and return clone based on (this) with new name
 285         virtual autoPtr<Cloud<parcelType> > clone(const word& name)
 286         {
 287             return autoPtr<Cloud<parcelType> >
 288             (
 289                 new KinematicCloud(*this, name)
 290             );
 291         }
 292
 293         //- Construct and return bare clone based on (this) with new name
 294         virtual autoPtr<Cloud<parcelType> > cloneBare(const word& name) const
 295         {
 296             return autoPtr<Cloud<parcelType> >
 297             (
 298                 new KinematicCloud(this->mesh(), name, *this)
 299             );
 300         }
 301
 302
 303     //- Destructor
 304     virtual ~KinematicCloud();
 305
 306
 307     // Member Functions
 308
 309         // Access
 310
 311             //- Return a reference to the cloud copy
 312             inline const KinematicCloud& cloudCopy() const;
 313
 314             //- Switch to specify if particles of the cloud can return
 315             //  non-zero wall distance values - true for kinematic parcels
 316             virtual bool hasWallImpactDistance() const;
 317
 318
 319             // References to the mesh and databases
 320
 321                 //- Return reference to the mesh
 322                 inline const fvMesh& mesh() const;
 323
 324                 //- Return particle properties dictionary
 325                 inline const IOdictionary& particleProperties() const;
 326
 327                 //- Return const access to the solution properties
 328                 inline const cloudSolution& solution() const;
 329
 330                 //- Return access to the solution properties
 331                 inline cloudSolution& solution();
 332
 333                 //- Return the constant properties
 334                 inline const typename parcelType::constantProperties&
 335                     constProps() const;
 336
 337                     //- Return reference to the sub-models dictionary
 338                 inline const dictionary& subModelProperties() const;
 339
 340
 341             // Cloud data
 342
 343                 //- Return reference to the random object
 344                 inline cachedRandom& rndGen();
 345
 346                 //- Return the cell occupancy information for each
 347                 //  parcel, non-const access, the caller is
 348                 //  responsible for updating it for its own purposes
 349                 //  if particles are removed or created.
 350                 inline List<DynamicList<parcelType*> >& cellOccupancy();
 351
 352
 353             // References to the carrier gas fields
 354
 355                 //- Return carrier gas velocity
 356                 inline const volVectorField& U() const;
 357
 358                 //- Return carrier gas density
 359                 inline const volScalarField& rho() const;
 360
 361                 //- Return carrier gas dynamic viscosity
 362                 inline const volScalarField& mu() const;
 363
 364
 365             // Environmental properties
 366
 367                 //- Gravity
 368                 inline const dimensionedVector& g() const;
 369
 370                 //- Return const-access to the ambient pressure
 371                 inline scalar pAmbient() const;
 372
 373                 //- Return reference to the ambient pressure
 374                 inline scalar& pAmbient();
 375
 376
 377             //- Optional particle forces
 378 //            inline const typename parcelType::forceType& forces() const;
 379             inline const forceType& forces() const;
 380
 381             //- Optional cloud function objects
 382             inline functionType& functions();
 383
 384
 385             // Sub-models
 386
 387                 //- Return const-access to the dispersion model
 388                 inline const DispersionModel<KinematicCloud<CloudType> >&
 389                     dispersion() const;
 390
 391                 //- Return reference to the dispersion model
 392                 inline DispersionModel<KinematicCloud<CloudType> >&
 393                     dispersion();
 394
 395                 //- Return const access to the injection model
 396                 inline const InjectionModel<KinematicCloud<CloudType> >&
 397                     injection() const;
 398
 399                 //- Return reference to the injection model
 400                 inline InjectionModel<KinematicCloud<CloudType> >&
 401                     injection();
 402
 403                 //- Return const-access to the patch interaction model
 404                 inline const PatchInteractionModel<KinematicCloud<CloudType> >&
 405                     patchInteraction() const;
 406
 407                 //- Return reference to the patch interaction model
 408                 inline PatchInteractionModel<KinematicCloud<CloudType> >&
 409                     patchInteraction();
 410
 411                 //- Return const-access to the surface film model
 412                 inline const SurfaceFilmModel<KinematicCloud<CloudType> >&
 413                     surfaceFilm() const;
 414
 415                 //- Return reference to the surface film model
 416                 inline SurfaceFilmModel<KinematicCloud<CloudType> >&
 417                     surfaceFilm();
 418
 419
 420             // Integration schemes
 421
 422                 //-Return reference to velocity integration
 423                 inline const vectorIntegrationScheme& UIntegrator() const;
 424
 425
 426             // Sources
 427
 428                 // Momentum
 429
 430                     //- Return reference to momentum source
 431                     inline DimensionedField<vector, volMesh>& UTrans();
 432
 433                     //- Return const reference to momentum source
 434                     inline const DimensionedField<vector, volMesh>&
 435                         UTrans() const;
 436
 437                      //- Return coefficient for carrier phase U equation
 438                     inline DimensionedField<scalar, volMesh>& UCoeff();
 439
 440                     //- Return const coefficient for carrier phase U equation
 441                     inline const DimensionedField<scalar, volMesh>&
 442                         UCoeff() const;
 443
 444                     //- Return tmp momentum source term
 445                     inline tmp<fvVectorMatrix> SU(volVectorField& U) const;
 446
 447
 448         // Check
 449
 450             //- Total mass injected
 451             inline scalar massInjected() const;
 452
 453             //- Total mass in system
 454             inline scalar massInSystem() const;
 455
 456             //- Total linear momentum of the system
 457             inline vector linearMomentumOfSystem() const;
 458
 459             //- Total linear kinetic energy in the system
 460             inline scalar linearKineticEnergyOfSystem() const;
 461
 462             //- Total rotational kinetic energy in the system
 463             inline scalar rotationalKineticEnergyOfSystem() const;
 464
 465             //- Penetration for percentage of the current total mass
 466             inline scalar penetration(const scalar& prc) const;
 467
 468             //- Mean diameter Dij
 469             inline scalar Dij(const label i, const label j) const;
 470
 471
 472             // Fields
 473
 474                 //- Return the particle volume fraction field
 475                 //  Note: for particles belonging to this cloud only
 476                 inline const tmp<volScalarField> theta() const;
 477
 478                 //- Return the particle mass fraction field
 479                 //  Note: for particles belonging to this cloud only
 480                 inline const tmp<volScalarField> alpha() const;
 481
 482                 //- Return the particle effective density field
 483                 //  Note: for particles belonging to this cloud only
 484                 inline const tmp<volScalarField> rhoEff() const;
 485
 486
 487         // Cloud evolution functions
 488
 489             //- Set parcel thermo properties
 490             void setParcelThermoProperties
 491             (
 492                 parcelType& parcel,
 493                 const scalar lagrangianDt
 494             );
 495
 496             //- Check parcel properties
 497             void checkParcelProperties
 498             (
 499                 parcelType& parcel,
 500                 const scalar lagrangianDt,
 501                 const bool fullyDescribed
 502             );
 503
 504             //- Store the current cloud state
 505             void storeState();
 506
 507             //- Reset the current cloud to the previously stored state
 508             void restoreState();
 509
 510             //- Reset the cloud source terms
 511             void resetSourceTerms();
 512
 513             //- Relax field
 514             template<class Type>
 515             void relax
 516             (
 517                 DimensionedField<Type, volMesh>& field,
 518                 const DimensionedField<Type, volMesh>& field0,
 519                 const word& name
 520             ) const;
 521
 522             //- Scale field
 523             template<class Type>
 524             void scale
 525             (
 526                 DimensionedField<Type, volMesh>& field,
 527                 const word& name
 528             ) const;
 529
 530             //- Apply relaxation to (steady state) cloud sources
 531             void relaxSources(const KinematicCloud<CloudType>& cloudOldTime);
 532
 533             //- Apply scaling to (transient) cloud sources
 534             void scaleSources();
 535
 536             //- Pre-evolve
 537             void preEvolve();
 538
 539             //- Evolve the cloud
 540             void evolve();
 541
 542             //- Particle motion
 543             template<class TrackData>
 544             void motion(TrackData& td);
 545
 546             //- Print cloud information
 547             void info() const;
 548 };
 549
 550
 551 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 552
 553 } // End namespace Foam
 554
 555 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 556
 557 #include "KinematicCloudI.H"
 558
 559 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 560
 561 #ifdef NoRepository
 562 #   include "KinematicCloud.C"
 563 #endif
 564
 565 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 566
 567 #endif
 568
 569 // ************************************************************************* //