src/lagrangian/intermediate/clouds/Templates/CollidingCloud/CollidingCloud.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::CollidingCloud
  26
  27 Description
  28     Adds coolisions to kinematic clouds
  29
  30 SourceFiles
  31     CollidingCloudI.H
  32     CollidingCloud.C
  33
  34 \*---------------------------------------------------------------------------*/
  35
  36 #ifndef CollidingCloud_H
  37 #define CollidingCloud_H
  38
  39 #include "particle.H"
  40 #include "Cloud.H"
  41 #include "IOdictionary.H"
  42 #include "autoPtr.H"
  43 #include "fvMesh.H"
  44 #include "volFields.H"
  45
  46 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  47
  48 namespace Foam
  49 {
  50
  51 // Forward declaration of classes
  52
  53 template<class CloudType>
  54 class CollisionModel;
  55
  56 /*---------------------------------------------------------------------------*\
  57                        Class CollidingCloud Declaration
  58 \*---------------------------------------------------------------------------*/
  59
  60 template<class CloudType>
  61 class CollidingCloud
  62 :
  63     public CloudType
  64 {
  65 public:
  66
  67     // Public typedefs
  68
  69         //- Type of cloud this cloud was instantiated for
  70         typedef CloudType cloudType;
  71
  72         //- Type of parcel the cloud was instantiated for
  73         typedef typename CloudType::particleType parcelType;
  74
  75         //- Convenience typedef for this cloud type
  76         typedef CollidingCloud<CloudType> collidingCloudType;
  77
  78
  79 private:
  80
  81     // Private data
  82
  83         //- Cloud copy pointer
  84         autoPtr<CollidingCloud<CloudType> > cloudCopyPtr_;
  85
  86
  87     // Private Member Functions
  88
  89         //- Disallow default bitwise copy construct
  90         CollidingCloud(const CollidingCloud&);
  91
  92         //- Disallow default bitwise assignment
  93         void operator=(const CollidingCloud&);
  94
  95
  96 protected:
  97
  98     // Protected data
  99
 100         // References to the cloud sub-models
 101
 102             //- Collision model
 103             autoPtr<CollisionModel<CollidingCloud<CloudType> > >
 104                 collisionModel_;
 105
 106
 107         // Initialisation
 108
 109             //- Set cloud sub-models
 110             void setModels();
 111
 112
 113         // Cloud evolution functions
 114
 115             //- Move-collide particles
 116             template<class TrackData>
 117             void moveCollide(TrackData& td, const scalar deltaT);
 118
 119             //- Reset state of cloud
 120             void cloudReset(CollidingCloud<CloudType>& c);
 121
 122
 123 public:
 124
 125     // Constructors
 126
 127         //- Construct given carrier gas fields
 128         CollidingCloud
 129         (
 130             const word& cloudName,
 131             const volScalarField& rho,
 132             const volVectorField& U,
 133             const volScalarField& mu,
 134             const dimensionedVector& g,
 135             bool readFields = true
 136         );
 137
 138         //- Copy constructor with new name
 139         CollidingCloud
 140         (
 141             CollidingCloud<CloudType>& c,
 142             const word& name
 143         );
 144
 145         //- Copy constructor with new name - creates bare cloud
 146         CollidingCloud
 147         (
 148             const fvMesh& mesh,
 149             const word& name,
 150             const CollidingCloud<CloudType>& c
 151         );
 152
 153         //- Construct and return clone based on (this) with new name
 154         virtual autoPtr<Cloud<parcelType> > clone(const word& name)
 155         {
 156             return autoPtr<Cloud<parcelType> >
 157             (
 158                 new CollidingCloud(*this, name)
 159             );
 160         }
 161
 162         //- Construct and return bare clone based on (this) with new name
 163         virtual autoPtr<Cloud<parcelType> > cloneBare(const word& name) const
 164         {
 165             return autoPtr<Cloud<parcelType> >
 166             (
 167                 new CollidingCloud(this->mesh(), name, *this)
 168             );
 169         }
 170
 171
 172     //- Destructor
 173     virtual ~CollidingCloud();
 174
 175
 176     // Member Functions
 177
 178         // Access
 179
 180             //- Return a reference to the cloud copy
 181             inline const CollidingCloud& cloudCopy() const;
 182
 183             //- If the collision model controls the wall interaction,
 184             //  then the wall impact distance should be zero.
 185             //  Otherwise, it should be allowed to be the value from
 186             //  the Parcel.
 187             virtual bool hasWallImpactDistance() const;
 188
 189
 190             // Sub-models
 191
 192                 //- Return const access to the collision model
 193                 inline const CollisionModel<CollidingCloud<CloudType> >&
 194                     collision() const;
 195
 196                 //- Return reference to the collision model
 197                 inline CollisionModel<CollidingCloud<CloudType> >&
 198                     collision();
 199
 200
 201         // Evolution
 202
 203             //- Store the current cloud state
 204             void storeState();
 205
 206             //- Reset the current cloud to the previously stored state
 207             void restoreState();
 208
 209             //- Evolve the cloud
 210             void evolve();
 211
 212             //- Particle motion
 213             template<class TrackData>
 214             void motion(TrackData& td);
 215 };
 216
 217
 218 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 219
 220 } // End namespace Foam
 221
 222 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 223
 224 #include "CollidingCloudI.H"
 225
 226 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 227
 228 #ifdef NoRepository
 229 #   include "CollidingCloud.C"
 230 #endif
 231
 232 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 233
 234 #endif
 235
 236 // ************************************************************************* //