src/lagrangian/intermediate/parcels/Templates/CollidingParcel/CollidingParcel.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
   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::CollidingParcel
  26
  27 Description
  28     Wrapper around kinematic parcel types to add collision modelling
  29
  30 SourceFiles
  31     CollidingParcelI.H
  32     CollidingParcel.C
  33     CollidingParcelIO.C
  34
  35 \*---------------------------------------------------------------------------*/
  36
  37 #ifndef CollidingParcel_H
  38 #define CollidingParcel_H
  39
  40 #include "particle.H"
  41
  42 #include "CollisionRecordList.H"
  43 #include "labelFieldIOField.H"
  44 #include "vectorFieldIOField.H"
  45
  46
  47 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  48
  49 namespace Foam
  50 {
  51
  52 typedef CollisionRecordList<vector, vector> collisionRecordList;
  53 typedef vectorFieldCompactIOField pairDataFieldCompactIOField;
  54 typedef vectorFieldCompactIOField wallDataFieldCompactIOField;
  55
  56 template<class ParcelType>
  57 class CollidingParcel;
  58
  59 // Forward declaration of friend functions
  60
  61 template<class ParcelType>
  62 Ostream& operator<<
  63 (
  64     Ostream&,
  65     const CollidingParcel<ParcelType>&
  66 );
  67
  68 /*---------------------------------------------------------------------------*\
  69                          Class CollidingParcel Declaration
  70 \*---------------------------------------------------------------------------*/
  71
  72 template<class ParcelType>
  73 class CollidingParcel
  74 :
  75     public ParcelType
  76 {
  77 protected:
  78
  79     // Protected data
  80
  81         //- Particle collision records
  82         collisionRecordList collisionRecords_;
  83
  84
  85 public:
  86
  87     // Static data members
  88
  89         //- String representation of properties
  90         static string propHeader;
  91
  92         //- Runtime type information
  93         TypeName("CollidingParcel");
  94
  95
  96     // Constructors
  97
  98         //- Construct from owner, position, and cloud owner
  99         //  Other properties initialised as null
 100         inline CollidingParcel
 101         (
 102             const polyMesh& mesh,
 103             const vector& position,
 104             const label cellI,
 105             const label tetFaceI,
 106             const label tetPtI
 107         );
 108
 109         //- Construct from components
 110         inline CollidingParcel
 111         (
 112             const polyMesh& mesh,
 113             const vector& position,
 114             const label cellI,
 115             const label tetFaceI,
 116             const label tetPtI,
 117             const label typeId,
 118             const scalar nParticle0,
 119             const scalar d0,
 120             const scalar dTarget0,
 121             const vector& U0,
 122             const vector& f0,
 123             const vector& angularMomentum0,
 124             const vector& torque0,
 125             const typename ParcelType::constantProperties& constProps
 126         );
 127
 128         //- Construct from Istream
 129         CollidingParcel
 130         (
 131             const polyMesh& mesh,
 132             Istream& is,
 133             bool readFields = true
 134         );
 135
 136         //- Construct as a copy
 137         CollidingParcel(const CollidingParcel& p);
 138
 139         //- Construct as a copy
 140         CollidingParcel(const CollidingParcel& p, const polyMesh& mesh);
 141
 142         //- Construct and return a (basic particle) clone
 143         virtual autoPtr<particle> clone() const
 144         {
 145             return autoPtr<particle>(new CollidingParcel(*this));
 146         }
 147
 148         //- Construct and return a (basic particle) clone
 149         virtual autoPtr<particle> clone(const polyMesh& mesh) const
 150         {
 151             return autoPtr<particle>(new CollidingParcel(*this, mesh));
 152         }
 153
 154         //- Factory class to read-construct particles used for
 155         //  parallel transfer
 156         class iNew
 157         {
 158             const polyMesh& mesh_;
 159
 160         public:
 161
 162             iNew(const polyMesh& mesh)
 163             :
 164                 mesh_(mesh)
 165             {}
 166
 167             autoPtr<CollidingParcel<ParcelType> > operator()(Istream& is) const
 168             {
 169                 return autoPtr<CollidingParcel<ParcelType> >
 170                 (
 171                     new CollidingParcel<ParcelType>(mesh_, is, true)
 172                 );
 173             }
 174         };
 175
 176
 177     // Member Functions
 178
 179         // Access
 180
 181             //- Return const access to the collision records
 182             inline const collisionRecordList& collisionRecords() const;
 183
 184             //- Return access to collision records
 185             inline collisionRecordList& collisionRecords();
 186
 187
 188         // Tracking
 189
 190             //- Move the parcel
 191             template<class TrackData>
 192             bool move(TrackData& td, const scalar trackTime);
 193
 194
 195        // I-O
 196
 197             //- Read
 198             template<class CloudType>
 199             static void readFields(CloudType& c);
 200
 201             //- Write
 202             template<class CloudType>
 203             static void writeFields(const CloudType& c);
 204
 205
 206     // Ostream Operator
 207
 208         friend Ostream& operator<< <ParcelType>
 209         (
 210             Ostream&,
 211             const CollidingParcel<ParcelType>&
 212         );
 213 };
 214
 215
 216 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 217
 218 } // End namespace Foam
 219
 220 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 221
 222 #include "CollidingParcelI.H"
 223
 224 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 225
 226 #ifdef NoRepository
 227     #include "CollidingParcel.C"
 228 #endif
 229
 230 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 231
 232 #endif
 233
 234 // ************************************************************************* //