src/dynamicMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     ePatch
  26
  27 SourceFiles
  28     ePatch.C
  29     newEPatch.C
  30
  31 \*---------------------------------------------------------------------------*/
  32
  33 #ifndef ePatch_H
  34 #define ePatch_H
  35
  36 #include "patchIdentifier.H"
  37 #include "labelList.H"
  38 #include "pointField.H"
  39 #include "typeInfo.H"
  40 #include "autoPtr.H"
  41 #include "runTimeSelectionTables.H"
  42
  43 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  44
  45 namespace Foam
  46 {
  47
  48 class eBoundaryMesh;
  49
  50 /*---------------------------------------------------------------------------*\
  51                            Class ePatch Declaration
  52 \*---------------------------------------------------------------------------*/
  53
  54 class ePatch
  55 :
  56     public patchIdentifier
  57 {
  58 private:
  59
  60     // Private data
  61
  62         //- Reference to boundary mesh
  63         const eBoundaryMesh& boundaryMesh_;
  64
  65         //- Start index of the patch
  66         label start_;
  67
  68         //- Size of the patch
  69         label size_;
  70
  71 protected:
  72
  73         // The ePatch geometry initialisation is called by eBoundaryMesh
  74         friend class eBoundaryMesh;
  75
  76         //- Initialise the calculation of the patch geometry
  77         virtual void initGeometry()
  78         {}
  79
  80         //- Calculate the patch geometry
  81         virtual void calcGeometry()
  82         {}
  83
  84         //- Initialise the patches for moving points
  85         virtual void initMovePoints(const pointField&)
  86         {}
  87
  88         //- Correct patch after moving points
  89         virtual void movePoints(const pointField&)
  90         {}
  91
  92         //- Initialise the update of the patch topology
  93         virtual void initUpdateMesh()
  94         {}
  95
  96         //- Update of the patch topology
  97         virtual void updateMesh()
  98         {}
  99
 100
 101 public:
 102
 103     typedef eBoundaryMesh BoundaryMesh;
 104
 105
 106     //- Runtime type information
 107     TypeName("patch");
 108
 109     // Declare run-time constructor selection tables
 110
 111         declareRunTimeSelectionTable
 112         (
 113             autoPtr,
 114             ePatch,
 115             word,
 116             (
 117                 const word& name,
 118                 const label size,
 119                 const label start,
 120                 const label index,
 121                 const eBoundaryMesh& bm
 122             ),
 123             (name, size, start, index, bm)
 124         );
 125
 126
 127         declareRunTimeSelectionTable
 128         (
 129             autoPtr,
 130             ePatch,
 131             dictionary,
 132             (
 133                 const word& name,
 134                 const dictionary& dict,
 135                 const label index,
 136                 const eBoundaryMesh& bm
 137             ),
 138             (name, dict, index, bm)
 139         );
 140
 141
 142     // Constructors
 143
 144         //- Construct from components
 145         ePatch
 146         (
 147             const word& name,
 148             const label size,
 149             const label start,
 150             const label index,
 151             const eBoundaryMesh& bm
 152         );
 153
 154         //- Construct from dictionary
 155         ePatch
 156         (
 157             const word& name,
 158             const dictionary& dict,
 159             const label index,
 160             const eBoundaryMesh& bm
 161         );
 162
 163         //- Construct as copy, resetting the boundary mesh
 164         ePatch(const ePatch&, const eBoundaryMesh&);
 165
 166         //- Construct as copy
 167         ePatch(const ePatch&);
 168
 169
 170     // Selectors
 171
 172         //- Return a pointer to a new patch created on freestore from
 173         //  components
 174         static autoPtr<ePatch> New
 175         (
 176             const word& patchType,
 177             const word& name,
 178             const label size,
 179             const label start,
 180             const label index,
 181             const eBoundaryMesh& bm
 182         );
 183
 184
 185         //- Return a pointer to a new patch created
 186         // on freestore from dictionary
 187         static autoPtr<ePatch> New
 188         (
 189             const word& name,
 190             const dictionary& dict,
 191             const label index,
 192             const eBoundaryMesh& bm
 193         );
 194
 195
 196     // Destructor
 197
 198         virtual ~ePatch();
 199
 200
 201     // Member Functions
 202
 203         //- Return the index of this patch in the boundaryMesh
 204         label index() const
 205         {
 206             return patchIdentifier::index();
 207         }
 208
 209         //- Return boundaryMesh reference
 210         const eBoundaryMesh& boundaryMesh() const;
 211
 212         //- Return true if this patch is coupled
 213         virtual bool coupled() const
 214         {
 215             return false;
 216         }
 217
 218         //- Patch start in edge list
 219         label start() const
 220         {
 221             return start_;
 222         }
 223
 224         //- Patch size
 225         virtual label size() const
 226         {
 227             return size_;
 228         }
 229
 230         //- Slice list to patch
 231         template<class T>
 232         typename List<T>::subList patchSlice(const List<T>& l) const
 233         {
 234             return typename List<T>::subList(l, size(), start());
 235         }
 236
 237         //- Write
 238         virtual void write(Ostream&) const;
 239
 240         //- Assignment operator
 241         void operator=(const ePatch&);
 242
 243
 244     // Ostream Operator
 245
 246         friend Ostream& operator<<(Ostream&, const ePatch&);
 247 };
 248
 249
 250 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 251
 252 } // End namespace Foam
 253
 254 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 255
 256 #endif
 257
 258 // ************************************************************************* //