src/autoMesh/autoHexMesh/trackedParticle/trackedParticle.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 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 the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     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, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 Class
  26     Foam::trackedParticle
  27
  28 Description
  29     Particle class that marks cells it passes through. Used to mark cells
  30     visited by feature edges. Uses ExactParticle tracking class so
  31     will work on concave cells.
  32
  33 SourceFiles
  34     trackedParticle.C
  35
  36 \*---------------------------------------------------------------------------*/
  37
  38 #ifndef trackedParticle_H
  39 #define trackedParticle_H
  40
  41 #include "ExactParticle.H"
  42 #include "autoPtr.H"
  43
  44 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  45
  46 namespace Foam
  47 {
  48
  49 class trackedParticleCloud;
  50
  51 /*---------------------------------------------------------------------------*\
  52                            Class trackedParticle Declaration
  53 \*---------------------------------------------------------------------------*/
  54
  55 class trackedParticle
  56 :
  57     public ExactParticle<trackedParticle>
  58 {
  59     // Private data
  60
  61         //- end point to track to
  62         point end_;
  63
  64         //- level of this particle
  65         label level_;
  66
  67         //- passive label
  68         label i_;
  69
  70         //- passive label
  71         label j_;
  72
  73 public:
  74
  75     friend class Cloud<trackedParticle>;
  76
  77     //- Class used to pass tracking data to the trackToFace function
  78     class trackData
  79     {
  80         //- Reference to the cloud containing this particle
  81         Cloud<trackedParticle>& cloud_;
  82
  83         labelList& maxLevel_;
  84
  85     public:
  86
  87         bool switchProcessor;
  88         bool keepParticle;
  89
  90
  91         // Constructors
  92
  93             trackData(Cloud<trackedParticle>& cloud, labelList& maxLevel)
  94             :
  95                 cloud_(cloud),
  96                 maxLevel_(maxLevel)
  97             {}
  98
  99
 100         // Member functions
 101
 102             Cloud<trackedParticle>& cloud()
 103             {
 104                 return cloud_;
 105             }
 106
 107             labelList& maxLevel()
 108             {
 109                 return maxLevel_;
 110             }
 111     };
 112
 113
 114
 115     // Constructors
 116
 117         //- Construct from components
 118         trackedParticle
 119         (
 120             const Cloud<trackedParticle>& c,
 121             const vector& position,
 122             const label celli,
 123             const point& end,
 124             const label level,
 125             const label i,
 126             const label j
 127         );
 128
 129         //- Construct from Istream
 130         trackedParticle
 131         (
 132             const Cloud<trackedParticle>& c,
 133             Istream& is,
 134             bool readFields = true
 135         );
 136
 137         //- Construct and return a clone
 138         autoPtr<trackedParticle> clone() const
 139         {
 140             return autoPtr<trackedParticle>(new trackedParticle(*this));
 141         }
 142
 143
 144     // Member Functions
 145
 146         //- point to track to
 147         point& end()
 148         {
 149             return end_;
 150         }
 151
 152         //- transported label
 153         label& i()
 154         {
 155             return i_;
 156         }
 157
 158         //- transported label
 159         label& j()
 160         {
 161             return j_;
 162         }
 163
 164
 165
 166         // Tracking
 167
 168             //- Track all particles to their end point
 169             bool move(trackData&);
 170
 171
 172             //- Overridable function to handle the particle hitting a patch
 173             //  Executed before other patch-hitting functions
 174             bool hitPatch
 175             (
 176                 const polyPatch&,
 177                 trackedParticle::trackData& td,
 178                 const label patchI
 179             );
 180             bool hitPatch
 181             (
 182                 const polyPatch&,
 183                 int&,
 184                 const label patchI
 185            );
 186
 187             //- Overridable function to handle the particle hitting a wedge
 188             void hitWedgePatch
 189             (
 190                 const wedgePolyPatch&,
 191                 trackedParticle::trackData& td
 192             );
 193             void hitWedgePatch
 194             (
 195                 const wedgePolyPatch&,
 196                 int&
 197             );
 198
 199             //- Overridable function to handle the particle hitting a
 200             //  symmetryPlane
 201             void hitSymmetryPatch
 202             (
 203                 const symmetryPolyPatch&,
 204                 trackedParticle::trackData& td
 205             );
 206             void hitSymmetryPatch
 207             (
 208                 const symmetryPolyPatch&,
 209                 int&
 210             );
 211
 212             //- Overridable function to handle the particle hitting a cyclic
 213             void hitCyclicPatch
 214             (
 215                 const cyclicPolyPatch&,
 216                 trackedParticle::trackData& td
 217             );
 218             void hitCyclicPatch
 219             (
 220                 const cyclicPolyPatch&,
 221                 int&
 222             );
 223
 224             //- Overridable function to handle the particle hitting a
 225             //- processorPatch
 226             void hitProcessorPatch
 227             (
 228                 const processorPolyPatch&,
 229                 trackedParticle::trackData& td
 230             );
 231             void hitProcessorPatch
 232             (
 233                 const processorPolyPatch&,
 234                 int&
 235             );
 236
 237             //- Overridable function to handle the particle hitting a wallPatch
 238             void hitWallPatch
 239             (
 240                 const wallPolyPatch&,
 241                 trackedParticle::trackData& td
 242             );
 243             void hitWallPatch
 244             (
 245                 const wallPolyPatch&,
 246                 int&
 247             );
 248
 249             //- Overridable function to handle the particle hitting a polyPatch
 250             void hitPatch
 251             (
 252                 const polyPatch&,
 253                 trackedParticle::trackData& td
 254             );
 255             void hitPatch
 256             (
 257                 const polyPatch&,
 258                 int&
 259             );
 260
 261
 262     // Ostream Operator
 263
 264         friend Ostream& operator<<(Ostream&, const trackedParticle&);
 265
 266
 267 };
 268
 269
 270 template<>
 271 inline bool contiguous<trackedParticle>()
 272 {
 273     return true;
 274 }
 275
 276 //template<>
 277 //void Cloud<trackedParticle>::readFields();
 278 //
 279 //template<>
 280 //void Cloud<trackedParticle>::writeFields() const;
 281
 282
 283 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 284
 285 } // End namespace Foam
 286
 287 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 288
 289 #endif
 290
 291 // ************************************************************************* //