src/mesh/autoMesh/autoHexMesh/trackedParticle/trackedParticle.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::trackedParticle
  26
  27 Description
  28     Particle class that marks cells it passes through. Used to mark cells
  29     visited by feature edges.
  30
  31 SourceFiles
  32     trackedParticle.C
  33
  34 \*---------------------------------------------------------------------------*/
  35
  36 #ifndef trackedParticle_H
  37 #define trackedParticle_H
  38
  39 #include "particle.H"
  40 #include "autoPtr.H"
  41
  42 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  43
  44 namespace Foam
  45 {
  46
  47 class trackedParticleCloud;
  48
  49 /*---------------------------------------------------------------------------*\
  50                      Class trackedParticle Declaration
  51 \*---------------------------------------------------------------------------*/
  52
  53 class trackedParticle
  54 :
  55     public particle
  56 {
  57     // Private data
  58
  59         //- end point to track to
  60         point end_;
  61
  62         //- level of this particle
  63         label level_;
  64
  65         //- passive label
  66         label i_;
  67
  68         //- passive label
  69         label j_;
  70
  71
  72 public:
  73
  74     friend class Cloud<trackedParticle>;
  75
  76     //- Class used to pass tracking data to the trackToFace function
  77     class trackingData
  78     :
  79         public particle::TrackingData<Cloud<trackedParticle> >
  80     {
  81         labelList& maxLevel_;
  82
  83     public:
  84
  85
  86         // Constructors
  87
  88             trackingData(Cloud<trackedParticle>& cloud, labelList& maxLevel)
  89             :
  90                 particle::TrackingData<Cloud<trackedParticle> >(cloud),
  91                 maxLevel_(maxLevel)
  92             {}
  93
  94
  95         // Member functions
  96
  97             labelList& maxLevel()
  98             {
  99                 return maxLevel_;
 100             }
 101     };
 102
 103
 104
 105     // Constructors
 106
 107         //- Construct from components
 108         trackedParticle
 109         (
 110             const polyMesh& mesh,
 111             const vector& position,
 112             const label cellI,
 113             const label tetFaceI,
 114             const label tetPtI,
 115             const point& end,
 116             const label level,
 117             const label i,
 118             const label j
 119         );
 120
 121         //- Construct from Istream
 122         trackedParticle
 123         (
 124             const polyMesh& mesh,
 125             Istream& is,
 126             bool readFields = true
 127         );
 128
 129         //- Construct and return a clone
 130         autoPtr<particle> clone() const
 131         {
 132             return autoPtr<particle>(new trackedParticle(*this));
 133         }
 134
 135         //- Factory class to read-construct particles used for
 136         //  parallel transfer
 137         class iNew
 138         {
 139             const polyMesh& mesh_;
 140
 141         public:
 142
 143             iNew(const polyMesh& mesh)
 144             :
 145                 mesh_(mesh)
 146             {}
 147
 148             autoPtr<trackedParticle> operator()(Istream& is) const
 149             {
 150                 return autoPtr<trackedParticle>
 151                 (
 152                     new trackedParticle(mesh_, is, true)
 153                 );
 154             }
 155         };
 156
 157
 158     // Member Functions
 159
 160         //- point to track to
 161         point& end()
 162         {
 163             return end_;
 164         }
 165
 166         //- transported label
 167         label& i()
 168         {
 169             return i_;
 170         }
 171
 172         //- transported label
 173         label& j()
 174         {
 175             return j_;
 176         }
 177
 178
 179
 180         // Tracking
 181
 182             //- Track all particles to their end point
 183             bool move(trackingData&, const scalar);
 184
 185
 186             //- Overridable function to handle the particle hitting a patch
 187             //  Executed before other patch-hitting functions
 188             bool hitPatch
 189             (
 190                 const polyPatch&,
 191                 trackingData& td,
 192                 const label patchI,
 193                 const scalar trackFraction,
 194                 const tetIndices& tetIs
 195             );
 196
 197             //- Overridable function to handle the particle hitting a wedge
 198             void hitWedgePatch
 199             (
 200                 const wedgePolyPatch&,
 201                 trackingData& td
 202             );
 203
 204             //- Overridable function to handle the particle hitting a
 205             //  symmetryPlane
 206             void hitSymmetryPatch
 207             (
 208                 const symmetryPolyPatch&,
 209                 trackingData& td
 210             );
 211
 212             //- Overridable function to handle the particle hitting a cyclic
 213             void hitCyclicPatch
 214             (
 215                 const cyclicPolyPatch&,
 216                 trackingData& td
 217             );
 218
 219             //- Overridable function to handle the particle hitting a
 220             //- processorPatch
 221             void hitProcessorPatch
 222             (
 223                 const processorPolyPatch&,
 224                 trackingData& td
 225             );
 226
 227             //- Overridable function to handle the particle hitting a wallPatch
 228             void hitWallPatch
 229             (
 230                 const wallPolyPatch&,
 231                 trackingData& td,
 232                 const tetIndices&
 233             );
 234
 235             //- Overridable function to handle the particle hitting a polyPatch
 236             void hitPatch
 237             (
 238                 const polyPatch&,
 239                 trackingData& td
 240             );
 241
 242
 243     // Ostream Operator
 244
 245         friend Ostream& operator<<(Ostream&, const trackedParticle&);
 246 };
 247
 248
 249 template<>
 250 inline bool contiguous<trackedParticle>()
 251 {
 252     return true;
 253 }
 254
 255 //template<>
 256 //void Cloud<trackedParticle>::readFields();
 257 //
 258 //template<>
 259 //void Cloud<trackedParticle>::writeFields() const;
 260
 261
 262 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 263
 264 } // End namespace Foam
 265
 266 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 267
 268 #endif
 269
 270 // ************************************************************************* //