src/lagrangian/basic/Cloud/Cloud.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::Cloud
  26
  27 Description
  28     Base cloud calls templated on particle type
  29
  30 SourceFiles
  31     Cloud.C
  32     CloudIO.C
  33
  34 \*---------------------------------------------------------------------------*/
  35
  36 #ifndef Cloud_H
  37 #define Cloud_H
  38
  39 #include "cloud.H"
  40 #include "IDLList.H"
  41 #include "IOField.H"
  42 #include "CompactIOField.H"
  43 #include "polyMesh.H"
  44 #include "indexedOctree.H"
  45 #include "treeDataCell.H"
  46 #include "tetPointRef.H"
  47 #include "PackedBoolList.H"
  48
  49 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  50
  51 namespace Foam
  52 {
  53
  54 // Forward declaration of functions
  55 template<class ParticleType>
  56 class Cloud;
  57
  58 template<class ParticleType>
  59 class IOPosition;
  60
  61 template<class ParticleType>
  62 Ostream& operator<<
  63 (
  64     Ostream&,
  65     const Cloud<ParticleType>&
  66 );
  67
  68
  69 /*---------------------------------------------------------------------------*\
  70                            Class Cloud Declaration
  71 \*---------------------------------------------------------------------------*/
  72
  73 template<class ParticleType>
  74 class Cloud
  75 :
  76     public cloud,
  77     public IDLList<ParticleType>
  78 {
  79     // Private data
  80
  81         const polyMesh& polyMesh_;
  82
  83         //- Temporary storage for addressing. Used in findTris.
  84         mutable DynamicList<label> labels_;
  85
  86         //- Count of how many tracking rescue corrections have been
  87         //  applied
  88         mutable label nTrackingRescues_;
  89
  90         //- Does the cell have wall faces
  91         mutable autoPtr<PackedBoolList> cellWallFacesPtr_;
  92
  93
  94     // Private Member Functions
  95
  96         //- Initialise cloud on IO constructor
  97         void initCloud(const bool checkClass);
  98
  99         //- Find all cells which have wall faces
 100         void calcCellWallFaces() const;
 101
 102         //- Read cloud properties dictionary
 103         void readCloudUniformProperties();
 104
 105         //- Write cloud properties dictionary
 106         void writeCloudUniformProperties() const;
 107
 108
 109 public:
 110
 111     friend class particle;
 112     template<class ParticleT>
 113     friend class IOPosition;
 114
 115     typedef ParticleType particleType;
 116
 117     typedef typename IDLList<ParticleType>::iterator iterator;
 118     typedef typename IDLList<ParticleType>::const_iterator const_iterator;
 119
 120     //-Runtime type information
 121     TypeName("Cloud");
 122
 123
 124     // Static data
 125
 126         //- Name of cloud properties dictionary
 127         static word cloudPropertiesName;
 128
 129
 130     // Constructors
 131
 132         //- Construct from mesh and a list of particles
 133         Cloud
 134         (
 135             const polyMesh& mesh,
 136             const IDLList<ParticleType>& particles
 137         );
 138
 139         //- Construct from mesh, cloud name, and a list of particles
 140         Cloud
 141         (
 142             const polyMesh& mesh,
 143             const word& cloudName,
 144             const IDLList<ParticleType>& particles
 145         );
 146
 147         //- Construct from mesh by reading from file
 148         //  Optionally disable checking of class name for post-processing
 149         Cloud
 150         (
 151             const polyMesh& mesh,
 152             const bool checkClass = true
 153         );
 154
 155
 156         //- Construct from mesh by reading from file with given cloud instance
 157         //  Optionally disable checking of class name for post-processing
 158         Cloud
 159         (
 160             const polyMesh& pMesh,
 161             const word& cloudName,
 162             const bool checkClass = true
 163         );
 164
 165
 166     // Member Functions
 167
 168         // Access
 169
 170             //- Return the polyMesh reference
 171             const polyMesh& pMesh() const
 172             {
 173                 return polyMesh_;
 174             }
 175
 176             label size() const
 177             {
 178                 return IDLList<ParticleType>::size();
 179             };
 180
 181             DynamicList<label>& labels()
 182             {
 183                 return labels_;
 184             }
 185
 186             //- Return nTrackingRescues
 187             label nTrackingRescues() const
 188             {
 189                 return nTrackingRescues_;
 190             }
 191
 192             //- Increment the nTrackingRescues counter
 193             void trackingRescue() const
 194             {
 195                 nTrackingRescues_++;
 196                 if (cloud::debug && size() && (nTrackingRescues_ % size() == 0))
 197                 {
 198                     Pout<< "    " << nTrackingRescues_
 199                         << " tracking rescues " << endl;
 200                 }
 201             }
 202
 203             //- Whether each cell has any wall faces (demand driven data)
 204             const PackedBoolList& cellHasWallFaces() const;
 205
 206             //- Switch to specify if particles of the cloud can return
 207             //  non-zero wall distance values.  By default, assume
 208             //  that they can't (default for wallImpactDistance in
 209             //  particle is 0.0).
 210             virtual bool hasWallImpactDistance() const
 211             {
 212                 return false;
 213             }
 214
 215
 216             // Iterators
 217
 218                 const const_iterator begin() const
 219                 {
 220                     return IDLList<ParticleType>::begin();
 221                 };
 222
 223                 const const_iterator cbegin() const
 224                 {
 225                     return IDLList<ParticleType>::cbegin();
 226                 };
 227
 228                 const const_iterator end() const
 229                 {
 230                     return IDLList<ParticleType>::end();
 231                 };
 232
 233                 const const_iterator cend() const
 234                 {
 235                     return IDLList<ParticleType>::cend();
 236                 };
 237
 238                 iterator begin()
 239                 {
 240                     return IDLList<ParticleType>::begin();
 241                 };
 242
 243                 iterator end()
 244                 {
 245                     return IDLList<ParticleType>::end();
 246                 };
 247
 248
 249         // Edit
 250
 251             void clear()
 252             {
 253                 return IDLList<ParticleType>::clear();
 254             };
 255
 256             //- Transfer particle to cloud
 257             void addParticle(ParticleType* pPtr);
 258
 259             //- Remove particle from cloud and delete
 260             void deleteParticle(ParticleType&);
 261
 262             //- Reset the particles
 263             void cloudReset(const Cloud<ParticleType>& c);
 264
 265             //- Move the particles
 266             //  passing the TrackingData to the track function
 267             template<class TrackData>
 268             void move(TrackData& td, const scalar trackTime);
 269
 270             //- Remap the cells of particles corresponding to the
 271             //  mesh topology change
 272             template<class TrackData>
 273             void autoMap(TrackData& td, const mapPolyMesh&);
 274
 275
 276         // Read
 277
 278             //- Helper to construct IOobject for field and current time.
 279             IOobject fieldIOobject
 280             (
 281                 const word& fieldName,
 282                 const IOobject::readOption r
 283             ) const;
 284
 285             //- Check lagrangian data field
 286             template<class DataType>
 287             void checkFieldIOobject
 288             (
 289                 const Cloud<ParticleType>& c,
 290                 const IOField<DataType>& data
 291             ) const;
 292
 293             //- Check lagrangian data fieldfield
 294             template<class DataType>
 295             void checkFieldFieldIOobject
 296             (
 297                 const Cloud<ParticleType>& c,
 298                 const CompactIOField<Field<DataType>, DataType>& data
 299             ) const;
 300
 301             //- Read the field data for the cloud of particles. Dummy at
 302             //  this level.
 303             virtual void readFields();
 304
 305
 306         // Write
 307
 308             //- Write the field data for the cloud of particles Dummy at
 309             //  this level.
 310             virtual void writeFields() const;
 311
 312             //- Write using given format, version and compression.
 313             //  Only writes the cloud file if the Cloud isn't empty
 314             virtual bool writeObject
 315             (
 316                 IOstream::streamFormat fmt,
 317                 IOstream::versionNumber ver,
 318                 IOstream::compressionType cmp
 319             ) const;
 320
 321             //- Write positions to \<cloudName\>_positions.obj file
 322             void writePositions() const;
 323
 324
 325     // Ostream Operator
 326
 327         friend Ostream& operator<< <ParticleType>
 328         (
 329             Ostream&,
 330             const Cloud<ParticleType>&
 331         );
 332 };
 333
 334
 335 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 336
 337 } // End namespace Foam
 338
 339 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 340
 341 #ifdef NoRepository
 342 #   include "Cloud.C"
 343 #endif
 344
 345 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 346
 347 #endif
 348
 349 // ************************************************************************* //