src/finiteVolume/fields/fvPatchFields/basic/sliced/slicedFvPatchField.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::slicedFvPatchField
  26
  27 Description
  28     Specialization of fvPatchField which creates the underlying
  29     fvPatchField as a slice of the given complete field.
  30
  31     The destructor is wrapped to avoid deallocation of the storage of the
  32     complete fields when this is destroyed.
  33
  34     Should only used as a template argument for SlicedGeometricField.
  35
  36 SourceFiles
  37     slicedFvPatchField.C
  38
  39 \*---------------------------------------------------------------------------*/
  40
  41 #ifndef slicedFvPatchField_H
  42 #define slicedFvPatchField_H
  43
  44 #include "fvPatchField.H"
  45
  46 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  47
  48 namespace Foam
  49 {
  50
  51 /*---------------------------------------------------------------------------*\
  52                            Class slicedFvPatch Declaration
  53 \*---------------------------------------------------------------------------*/
  54
  55 template<class Type>
  56 class slicedFvPatchField
  57 :
  58     public fvPatchField<Type>
  59 {
  60
  61 public:
  62
  63     //- Runtime type information
  64     TypeName("sliced");
  65
  66
  67     // Constructors
  68
  69         //- Construct from patch, internal field and field to slice
  70         slicedFvPatchField
  71         (
  72             const fvPatch&,
  73             const DimensionedField<Type, volMesh>&,
  74             const Field<Type>&
  75         );
  76
  77         //- Construct from patch and internal field. Assign value later.
  78         slicedFvPatchField
  79         (
  80             const fvPatch&,
  81             const DimensionedField<Type, volMesh>&
  82         );
  83
  84         //- Construct from patch, internal field and dictionary
  85         slicedFvPatchField
  86         (
  87             const fvPatch&,
  88             const DimensionedField<Type, volMesh>&,
  89             const dictionary&
  90         );
  91
  92         //- Construct by mapping the given slicedFvPatchField<Type>
  93         //  onto a new patch
  94         slicedFvPatchField
  95         (
  96             const slicedFvPatchField<Type>&,
  97             const fvPatch&,
  98             const DimensionedField<Type, volMesh>&,
  99             const fvPatchFieldMapper&
 100         );
 101
 102         //- Construct as copy
 103         slicedFvPatchField(const slicedFvPatchField<Type>&);
 104
 105         //- Construct and return a clone
 106         virtual tmp<fvPatchField<Type> > clone() const;
 107
 108         //- Construct as copy setting internal field reference
 109         slicedFvPatchField
 110         (
 111             const slicedFvPatchField<Type>&,
 112             const DimensionedField<Type, volMesh>&
 113         );
 114
 115         //- Construct and return a clone setting internal field reference
 116         virtual tmp<fvPatchField<Type> > clone
 117         (
 118             const DimensionedField<Type, volMesh>& iF
 119         ) const;
 120
 121
 122     //- Destructor
 123     virtual ~slicedFvPatchField<Type>();
 124
 125
 126     // Member functions
 127
 128         // Access
 129
 130             //- Return true if this patch field fixes a value.
 131             //  Needed to check if a level has to be specified while solving
 132             //  Poissons equations.
 133             virtual bool fixesValue() const
 134             {
 135                 return true;
 136             }
 137
 138
 139         // Evaluation functions
 140
 141             //- Return patch-normal gradient
 142             virtual tmp<Field<Type> > snGrad() const;
 143
 144             //- Update the coefficients associated with the patch field
 145             //  Sets Updated to true
 146             virtual void updateCoeffs();
 147
 148             //- Return internal field next to patch as patch field
 149             virtual tmp<Field<Type> > patchInternalField() const;
 150
 151             //- Return neighbour coupled given internal cell data
 152             virtual tmp<Field<Type> > patchNeighbourField
 153             (
 154                 const Field<Type>& iField
 155             ) const;
 156
 157             //- Return patchField of the values on the patch or on the
 158             //  opposite patch
 159             virtual tmp<Field<Type> > patchNeighbourField() const;
 160
 161             //- Initialise the evaluation of the patch field
 162             virtual void initEvaluate
 163             (
 164                 const Pstream::commsTypes commsType=Pstream::blocking
 165             )
 166             {}
 167
 168             //- Evaluate the patch field, sets Updated to false
 169             virtual void evaluate
 170             (
 171                 const Pstream::commsTypes commsType=Pstream::blocking
 172             )
 173             {}
 174
 175             //- Return the matrix diagonal coefficients corresponding to the
 176             //  evaluation of the value of this patchField with given weights
 177             virtual tmp<Field<Type> > valueInternalCoeffs
 178             (
 179                 const tmp<scalarField>&
 180             ) const;
 181
 182             //- Return the matrix source coefficients corresponding to the
 183             //  evaluation of the value of this patchField with given weights
 184             virtual tmp<Field<Type> > valueBoundaryCoeffs
 185             (
 186                 const tmp<scalarField>&
 187             ) const;
 188
 189             //- Return the matrix diagonal coefficients corresponding to the
 190             //  evaluation of the gradient of this patchField
 191             virtual tmp<Field<Type> > gradientInternalCoeffs() const;
 192
 193             //- Return the matrix source coefficients corresponding to the
 194             //  evaluation of the gradient of this patchField
 195             virtual tmp<Field<Type> > gradientBoundaryCoeffs() const;
 196
 197
 198         //- Write
 199         virtual void write(Ostream&) const;
 200
 201
 202     // Member operators
 203
 204         virtual void operator=(const UList<Type>&) {}
 205
 206         virtual void operator=(const fvPatchField<Type>&) {}
 207         virtual void operator+=(const fvPatchField<Type>&) {}
 208         virtual void operator-=(const fvPatchField<Type>&) {}
 209         virtual void operator*=(const fvPatchField<scalar>&) {}
 210         virtual void operator/=(const fvPatchField<scalar>&) {}
 211
 212         virtual void operator+=(const Field<Type>&) {}
 213         virtual void operator-=(const Field<Type>&) {}
 214
 215         virtual void operator*=(const Field<scalar>&) {}
 216         virtual void operator/=(const Field<scalar>&) {}
 217
 218         virtual void operator=(const Type&) {}
 219         virtual void operator+=(const Type&) {}
 220         virtual void operator-=(const Type&) {}
 221         virtual void operator*=(const scalar) {}
 222         virtual void operator/=(const scalar) {}
 223 };
 224
 225
 226 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 227
 228 } // End namespace Foam
 229
 230 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 231
 232 #ifdef NoRepository
 233 #   include "slicedFvPatchField.C"
 234 #endif
 235
 236 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 237
 238 #endif
 239
 240 // ************************************************************************* //