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 (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::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             tmp<Field<Type> > patchNeighbourField() const;
 160
 161
 162         // Evaluation functions
 163
 164             //- Initialise the evaluation of the patch field
 165             virtual void initEvaluate(const Pstream::commsTypes commsType);
 166
 167             //- Evaluate the patch field
 168             virtual void evaluate(const Pstream::commsTypes commsType);
 169
 170             //- Return patch-normal gradient
 171             virtual tmp<Field<Type> > snGrad() const;
 172
 173             //- Initialise neighbour matrix update
 174             virtual void initInterfaceMatrixUpdate
 175             (
 176                 const scalarField& psiInternal,
 177                 scalarField& result,
 178                 const lduMatrix& m,
 179                 const scalarField& coeffs,
 180                 const direction cmpt,
 181                 const Pstream::commsTypes commsType
 182             ) const;
 183
 184             //- Update result field based on interface functionality
 185             virtual void updateInterfaceMatrix
 186             (
 187                 const scalarField& psiInternal,
 188                 scalarField& result,
 189                 const lduMatrix& m,
 190                 const scalarField& coeffs,
 191                 const direction cmpt,
 192                 const Pstream::commsTypes commsType
 193             ) const;
 194
 195         //- Processor coupled interface functions
 196
 197             //- Return processor number
 198             virtual int myProcNo() const
 199             {
 200                 return procPatch_.myProcNo();
 201             }
 202
 203             //- Return neigbour processor number
 204             virtual int neighbProcNo() const
 205             {
 206                 return procPatch_.neighbProcNo();
 207             }
 208
 209             //- Does the patch field perform the transfromation
 210             virtual bool doTransform() const
 211             {
 212                 return !(procPatch_.parallel() || pTraits<Type>::rank == 0);
 213             }
 214
 215             //- Return face transformation tensor
 216             virtual const tensorField& forwardT() const
 217             {
 218                 return procPatch_.forwardT();
 219             }
 220
 221             //- Return rank of component for transform
 222             virtual int rank() const
 223             {
 224                 return pTraits<Type>::rank;
 225             }
 226 };
 227
 228
 229 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 230
 231 } // End namespace Foam
 232
 233 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 234
 235 #ifdef NoRepository
 236 #   include "processorFvPatchField.C"
 237 #endif
 238
 239 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 240
 241 #endif
 242
 243 // ************************************************************************* //