src/finiteVolume/fields/fvPatchFields/constraint/processor/processorFvPatchField.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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::processorFvPatchField
  27
  28 Description
  29     Foam::processorFvPatchField
  30
  31 SourceFiles
  32     processorFvPatchField.C
  33
  34 \*---------------------------------------------------------------------------*/
  35
  36 #ifndef processorFvPatchField_H
  37 #define processorFvPatchField_H
  38
  39 #include "coupledFvPatchField.H"
  40 #include "processorLduInterfaceField.H"
  41 #include "processorFvPatch.H"
  42
  43 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  44
  45 namespace Foam
  46 {
  47
  48 /*---------------------------------------------------------------------------*\
  49                       Class processorFvPatch Declaration
  50 \*---------------------------------------------------------------------------*/
  51
  52 template<class Type>
  53 class processorFvPatchField
  54 :
  55     public processorLduInterfaceField,
  56     public coupledFvPatchField<Type>
  57 {
  58     // Private data
  59
  60         //- Local reference cast into the processor patch
  61         const processorFvPatch& procPatch_;
  62
  63
  64 public:
  65
  66     //- Runtime type information
  67     TypeName(processorFvPatch::typeName_());
  68
  69
  70     // Constructors
  71
  72         //- Construct from patch and internal field
  73         processorFvPatchField
  74         (
  75             const fvPatch&,
  76             const DimensionedField<Type, volMesh>&
  77         );
  78
  79         //- Construct from patch and internal field and patch field
  80         processorFvPatchField
  81         (
  82             const fvPatch&,
  83             const DimensionedField<Type, volMesh>&,
  84             const Field<Type>&
  85         );
  86
  87         //- Construct from patch, internal field and dictionary
  88         processorFvPatchField
  89         (
  90             const fvPatch&,
  91             const DimensionedField<Type, volMesh>&,
  92             const dictionary&
  93         );
  94
  95         //- Construct by mapping given processorFvPatchField onto a new patch
  96         processorFvPatchField
  97         (
  98             const processorFvPatchField<Type>&,
  99             const fvPatch&,
 100             const DimensionedField<Type, volMesh>&,
 101             const fvPatchFieldMapper&
 102         );
 103
 104         //- Construct as copy
 105         processorFvPatchField(const processorFvPatchField<Type>&);
 106
 107         //- Construct and return a clone
 108         virtual tmp<fvPatchField<Type> > clone() const
 109         {
 110             return tmp<fvPatchField<Type> >
 111             (
 112                 new processorFvPatchField<Type>(*this)
 113             );
 114         }
 115
 116         //- Construct as copy setting internal field reference
 117         processorFvPatchField
 118         (
 119             const processorFvPatchField<Type>&,
 120             const DimensionedField<Type, volMesh>&
 121         );
 122
 123         //- Construct and return a clone setting internal field reference
 124         virtual tmp<fvPatchField<Type> > clone
 125         (
 126             const DimensionedField<Type, volMesh>& iF
 127         ) const
 128         {
 129             return tmp<fvPatchField<Type> >
 130             (
 131                 new processorFvPatchField<Type>(*this, iF)
 132             );
 133         }
 134
 135
 136     // Destructor
 137
 138         ~processorFvPatchField();
 139
 140
 141     // Member functions
 142
 143         // Access
 144
 145             //- Return true if running parallel
 146             virtual bool coupled() const
 147             {
 148                 if (Pstream::parRun())
 149                 {
 150                     return true;
 151                 }
 152                 else
 153                 {
 154                     return false;
 155                 }
 156             }
 157
 158             //- Return neighbour field given internal field
 159             // Returning patch values, which stores neighbour
 160             // data after update due to scheduling issues.  HJ, 11/May/2009
 161             virtual tmp<Field<Type> > patchNeighbourField() const;
 162
 163
 164         // Evaluation functions
 165
 166             //- Initialise the evaluation of the patch field
 167             virtual void initEvaluate(const Pstream::commsTypes commsType);
 168
 169             //- Evaluate the patch field
 170             virtual void evaluate(const Pstream::commsTypes commsType);
 171
 172             //- Return patch-normal gradient
 173             virtual tmp<Field<Type> > snGrad() const;
 174
 175             //- Initialise neighbour matrix update
 176             virtual void initInterfaceMatrixUpdate
 177             (
 178                 const scalarField& psiInternal,
 179                 scalarField& result,
 180                 const lduMatrix& m,
 181                 const scalarField& coeffs,
 182                 const direction cmpt,
 183                 const Pstream::commsTypes commsType
 184             ) const;
 185
 186             //- Update result field based on interface functionality
 187             virtual void updateInterfaceMatrix
 188             (
 189                 const scalarField& psiInternal,
 190                 scalarField& result,
 191                 const lduMatrix& m,
 192                 const scalarField& coeffs,
 193                 const direction cmpt,
 194                 const Pstream::commsTypes commsType
 195             ) const;
 196
 197         // Block coupled interface functionality
 198
 199             //- Initialise neighbour matrix update
 200             virtual void initInterfaceMatrixUpdate
 201             (
 202                 const Field<Type>&,
 203                 Field<Type>&,
 204                 const BlockLduMatrix<Type>&,
 205                 const CoeffField<Type>&,
 206                 const Pstream::commsTypes commsType
 207             ) const
 208             {}
 209
 210             //- Update result field based on interface functionality
 211             virtual void updateInterfaceMatrix
 212             (
 213                 const Field<Type>&,
 214                 Field<Type>&,
 215                 const BlockLduMatrix<Type>&,
 216                 const CoeffField<Type>&,
 217                 const Pstream::commsTypes commsType
 218             ) const
 219             {
 220                 notImplemented("processorFvPatchField<Type>::updateInterfaceMatrix for block matrices")
 221             }
 222
 223         //- Processor coupled interface functions
 224
 225             //- Return processor number
 226             virtual int myProcNo() const
 227             {
 228                 return procPatch_.myProcNo();
 229             }
 230
 231             //- Return neigbour processor number
 232             virtual int neighbProcNo() const
 233             {
 234                 return procPatch_.neighbProcNo();
 235             }
 236
 237             //- Does the patch field perform the transfromation
 238             virtual bool doTransform() const
 239             {
 240                 return !(procPatch_.parallel() || pTraits<Type>::rank == 0);
 241             }
 242
 243             //- Return face transformation tensor
 244             virtual const tensorField& forwardT() const
 245             {
 246                 return procPatch_.forwardT();
 247             }
 248
 249             //- Return rank of component for transform
 250             virtual int rank() const
 251             {
 252                 return pTraits<Type>::rank;
 253             }
 254 };
 255
 256
 257 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 258
 259 } // End namespace Foam
 260
 261 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 262
 263 #ifdef NoRepository
 264 #   include "processorFvPatchField.C"
 265 #endif
 266
 267 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 268
 269 #endif
 270
 271 // ************************************************************************* //