src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.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::fvPatch
  26
  27 Description
  28     A finiteVolume patch using a polyPatch and a fvBoundaryMesh
  29
  30 SourceFiles
  31     fvPatch.C
  32     fvPatchNew.C
  33
  34 \*---------------------------------------------------------------------------*/
  35
  36 #ifndef fvPatch_H
  37 #define fvPatch_H
  38
  39 #include "polyPatch.H"
  40 #include "labelList.H"
  41 #include "SubList.H"
  42 #include "typeInfo.H"
  43 #include "tmp.H"
  44 #include "primitiveFields.H"
  45 #include "SubField.H"
  46 #include "fvPatchFieldsFwd.H"
  47 #include "autoPtr.H"
  48 #include "runTimeSelectionTables.H"
  49
  50 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  51
  52 namespace Foam
  53 {
  54
  55 class fvBoundaryMesh;
  56 class surfaceInterpolation;
  57
  58 /*---------------------------------------------------------------------------*\
  59                            Class fvPatch Declaration
  60 \*---------------------------------------------------------------------------*/
  61
  62 class fvPatch
  63 {
  64     // Private data
  65
  66         //- Reference to the underlying polyPatch
  67         const polyPatch& polyPatch_;
  68
  69         //- Reference to boundary mesh
  70         const fvBoundaryMesh& boundaryMesh_;
  71
  72
  73     // Private Member Functions
  74
  75         //- Disallow construct as copy
  76         fvPatch(const fvPatch&);
  77
  78         //- Disallow assignment
  79         void operator=(const fvPatch&);
  80
  81
  82 protected:
  83
  84     // Protected Member Functions
  85
  86         //- Make patch weighting factors
  87         virtual void makeWeights(scalarField&) const;
  88
  89         //- Make patch face - neighbour cell distances
  90         virtual void makeDeltaCoeffs(scalarField&) const;
  91
  92         //- Initialise the patches for moving points
  93         virtual void initMovePoints();
  94
  95         //- Correct patches after moving points
  96         virtual void movePoints();
  97
  98
  99 public:
 100
 101     typedef fvBoundaryMesh BoundaryMesh;
 102
 103     friend class fvBoundaryMesh;
 104     friend class surfaceInterpolation;
 105
 106     //- Runtime type information
 107     TypeName(polyPatch::typeName_());
 108
 109
 110     // Declare run-time constructor selection tables
 111
 112         declareRunTimeSelectionTable
 113         (
 114             autoPtr,
 115             fvPatch,
 116             polyPatch,
 117             (const polyPatch& patch, const fvBoundaryMesh& bm),
 118             (patch, bm)
 119         );
 120
 121
 122     // Constructors
 123
 124         //- Construct from polyPatch and fvBoundaryMesh
 125         fvPatch(const polyPatch&, const fvBoundaryMesh&);
 126
 127
 128     // Selectors
 129
 130         //- Return a pointer to a new patch created on freestore from polyPatch
 131         static autoPtr<fvPatch> New
 132         (
 133             const polyPatch&,
 134             const fvBoundaryMesh&
 135         );
 136
 137
 138     //- Destructor
 139     virtual ~fvPatch();
 140
 141
 142     // Member Functions
 143
 144     // Access
 145
 146             //- Return the polyPatch
 147             const polyPatch& patch() const
 148             {
 149                 return polyPatch_;
 150             }
 151
 152             //- Return name
 153             const word& name() const
 154             {
 155                 return polyPatch_.name();
 156             }
 157
 158             //- Return start label of this patch in the polyMesh face list
 159             label start() const
 160             {
 161                 return polyPatch_.start();
 162             }
 163
 164             //- Return size
 165             virtual label size() const
 166             {
 167                 return polyPatch_.size();
 168             }
 169
 170             //- Return true if this patch is coupled
 171             bool coupled() const
 172             {
 173                 return polyPatch_.coupled();
 174             }
 175
 176             //- Return true if the given type is a constraint type
 177             static bool constraintType(const word& pt);
 178
 179             //- Return a list of all the constraint patch types
 180             static wordList constraintTypes();
 181
 182             //- Return the index of this patch in the fvBoundaryMesh
 183             label index() const
 184             {
 185                 return polyPatch_.index();
 186             }
 187
 188             //- Return boundaryMesh reference
 189             const fvBoundaryMesh& boundaryMesh() const
 190             {
 191                 return boundaryMesh_;
 192             }
 193
 194             //- Slice list to patch
 195             template<class T>
 196             const typename List<T>::subList patchSlice(const List<T>& l) const
 197             {
 198                 return typename List<T>::subList(l, size(), start());
 199             }
 200
 201             //- Return faceCells
 202             virtual const labelUList& faceCells() const;
 203
 204
 205         // Access functions for geometrical data
 206
 207             //- Return face centres
 208             const vectorField& Cf() const;
 209
 210             //- Return neighbour cell centres
 211             tmp<vectorField> Cn() const;
 212
 213             //- Return face area vectors
 214             const vectorField& Sf() const;
 215
 216             //- Return face area magnitudes
 217             const scalarField& magSf() const;
 218
 219             //- Return face normals
 220             tmp<vectorField> nf() const;
 221
 222             //- Return cell-centre to face-centre vector
 223             //  except for coupled patches for which the cell-centre
 224             //  to coupled-cell-centre vector is returned
 225             virtual tmp<vectorField> delta() const;
 226
 227
 228         // Access functions for demand driven data
 229
 230             //- Return patch weighting factors
 231             const scalarField& weights() const;
 232
 233             //- Return the face - cell distance coeffient
 234             //  except for coupled patches for which the cell-centre
 235             //  to coupled-cell-centre distance coeffient is returned
 236             const scalarField& deltaCoeffs() const;
 237
 238
 239         // Evaluation functions
 240
 241             //- Return given internal field next to patch as patch field
 242             template<class Type>
 243             tmp<Field<Type> > patchInternalField(const UList<Type>&) const;
 244
 245             //- Return the corresponding patchField of the named field
 246             template<class GeometricField, class Type>
 247             const typename GeometricField::PatchFieldType& patchField
 248             (
 249                 const GeometricField&
 250             ) const;
 251
 252             //- Lookup and return the patchField of the named field from the
 253             //  local objectRegistry.
 254             //  N.B.  The dummy pointer arguments are used if this function is
 255             //  instantiated within a templated function to avoid a bug in gcc.
 256             //  See inletOutletFvPatchField.C and outletInletFvPatchField.C
 257             template<class GeometricField, class Type>
 258             const typename GeometricField::PatchFieldType& lookupPatchField
 259             (
 260                 const word& name,
 261                 const GeometricField* = NULL,
 262                 const Type* = NULL
 263             ) const;
 264 };
 265
 266
 267 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 268
 269 } // End namespace Foam
 270
 271 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 272
 273 #ifdef NoRepository
 274 #   include "fvPatchTemplates.C"
 275 #endif
 276
 277 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 278
 279 #endif
 280
 281 // ************************************************************************* //