src/finiteArea/fields/faPatchFields/faPatchField/faPatchField.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     faPatchField
  27
  28 Description
  29     faPatchField<Type> abstract base class.  This class gives a fat-interface
  30     to all derived classes covering all possible ways in which they might be
  31     used.  The first level of derivation is to basic patchFields which cover
  32     zero-gradient, fixed-gradient, fixed-value and mixed conditions.  The next
  33     level of derivation covers all the specialised typed with specific
  34     evaluation proceedures, particularly with respect to specific fields.
  35
  36 SourceFiles
  37     faPatchField.C
  38     newPatchField.C
  39
  40 \*---------------------------------------------------------------------------*/
  41
  42 #ifndef faPatchField_H
  43 #define faPatchField_H
  44
  45 #include "faPatch.H"
  46 #include "DimensionedField.H"
  47
  48 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  49
  50 namespace Foam
  51 {
  52
  53 // Class forward declarations
  54
  55 class objectRegistry;
  56 class dictionary;
  57 class faPatchFieldMapper;
  58 class areaMesh;
  59
  60
  61 // * * * * * * Forward declaration of template friend fuctions * * * * * * * //
  62
  63 template<class Type>
  64 class faPatchField;
  65
  66 template<class Type>
  67 Ostream& operator<<(Ostream&, const faPatchField<Type>&);
  68
  69 /*---------------------------------------------------------------------------*\
  70                          Class faPatchField Declaration
  71 \*---------------------------------------------------------------------------*/
  72
  73 template<class Type>
  74 class faPatchField
  75 :
  76     public Field<Type>
  77 {
  78     // Private data
  79
  80         //- Reference to a patch
  81         const faPatch& patch_;
  82
  83         //- Reference to internal field
  84         const DimensionedField<Type, areaMesh>& internalField_;
  85
  86         //- Update index used so that updateCoeffs is called only once during
  87         //  the construction of the matrix
  88         bool updated_;
  89
  90
  91 public:
  92
  93     typedef faPatch Patch;
  94
  95
  96     //- Runtime type information
  97     TypeName("faPatchField");
  98
  99     //- Debug switch to disallow the use of
 100     static int disallowDefaultFaPatchField;
 101
 102
 103     // Declare run-time constructor selection tables
 104
 105         declareRunTimeSelectionTable
 106         (
 107             tmp,
 108             faPatchField,
 109             patch,
 110             (
 111                 const faPatch& p,
 112                 const DimensionedField<Type, areaMesh>& iF
 113             ),
 114             (p, iF)
 115         );
 116
 117         declareRunTimeSelectionTable
 118         (
 119             tmp,
 120             faPatchField,
 121             patchMapper,
 122             (
 123                 const faPatchField<Type>& ptf,
 124                 const faPatch& p,
 125                 const DimensionedField<Type, areaMesh>& iF,
 126                 const faPatchFieldMapper& m
 127             ),
 128             (dynamic_cast<const faPatchFieldType&>(ptf), p, iF, m)
 129         );
 130
 131         declareRunTimeSelectionTable
 132         (
 133             tmp,
 134             faPatchField,
 135             dictionary,
 136             (
 137                 const faPatch& p,
 138                 const DimensionedField<Type, areaMesh>& iF,
 139                 const dictionary& dict
 140             ),
 141             (p, iF, dict)
 142         );
 143
 144
 145     // Constructors
 146
 147         //- Construct from patch and internal field
 148         faPatchField
 149         (
 150             const faPatch&,
 151             const DimensionedField<Type, areaMesh>&
 152         );
 153
 154         //- Construct from patch and internal field and patch field
 155         faPatchField
 156         (
 157             const faPatch&,
 158             const DimensionedField<Type, areaMesh>&,
 159             const Field<Type>&
 160         );
 161
 162         //- Construct from patch, internal field and dictionary
 163         faPatchField
 164         (
 165             const faPatch&,
 166             const DimensionedField<Type, areaMesh>&,
 167             const dictionary&
 168         );
 169
 170         //- Construct by mapping the given faPatchField onto a new patch
 171         faPatchField
 172         (
 173             const faPatchField<Type>&,
 174             const faPatch&,
 175             const DimensionedField<Type, areaMesh>&,
 176             const faPatchFieldMapper&
 177         );
 178
 179         //- Construct as copy
 180         faPatchField(const faPatchField<Type>&);
 181
 182         //- Construct and return a clone
 183         virtual tmp<faPatchField<Type> > clone() const
 184         {
 185             return tmp<faPatchField<Type> >(new faPatchField<Type>(*this));
 186         }
 187
 188         //- Construct as copy setting internal field reference
 189         faPatchField
 190         (
 191             const faPatchField<Type>&,
 192             const DimensionedField<Type, areaMesh>&
 193         );
 194
 195         //- Construct and return a clone setting internal field reference
 196         virtual tmp<faPatchField<Type> > clone
 197         (
 198             const DimensionedField<Type, areaMesh>& iF
 199         ) const
 200         {
 201             return tmp<faPatchField<Type> >(new faPatchField<Type>(*this, iF));
 202         }
 203
 204
 205     // Selectors
 206
 207         //- Return a pointer to a new patchField created on freestore given
 208         //  patch and internal field
 209         //  (does not set the patch field values)
 210         static tmp<faPatchField<Type> > New
 211         (
 212             const word&,
 213             const faPatch&,
 214             const DimensionedField<Type, areaMesh>&
 215         );
 216
 217         //- Return a pointer to a new patchField created on freestore from
 218         //  a given faPatchField mapped onto a new patch
 219         static tmp<faPatchField<Type> > New
 220         (
 221             const faPatchField<Type>&,
 222             const faPatch&,
 223             const DimensionedField<Type, areaMesh>&,
 224             const faPatchFieldMapper&
 225         );
 226
 227         //- Return a pointer to a new patchField created on freestore
 228         //  from dictionary
 229         static tmp<faPatchField<Type> > New
 230         (
 231             const faPatch&,
 232             const DimensionedField<Type, areaMesh>&,
 233             const dictionary&
 234         );
 235
 236         //- Return a pointer to a new calculatedFaPatchField created on
 237         //  freestore without setting patchField values
 238         template<class Type2>
 239         static tmp<faPatchField<Type> > NewCalculatedType
 240         (
 241             const faPatchField<Type2>&
 242         );
 243
 244
 245     // Destructor
 246
 247         virtual ~faPatchField<Type>()
 248         {}
 249
 250
 251     // Member functions
 252
 253         // Access
 254
 255             //- Return local objectRegistry
 256             const objectRegistry& db() const;
 257
 258             //- Return patch
 259             const faPatch& patch() const
 260             {
 261                 return patch_;
 262             }
 263
 264             //- Return dimensioned internal field reference
 265             const DimensionedField<Type, areaMesh>&
 266             dimensionedInternalField() const
 267             {
 268                 return internalField_;
 269             }
 270
 271             //- Return internal field reference
 272             const Field<Type>& internalField() const
 273             {
 274                 return internalField_;
 275             }
 276
 277             //- Return the type of the calculated for of faPatchField
 278             static const word& calculatedType();
 279
 280             //- Return true if this patch field fixes a value.
 281             //  Needed to check if a level has to be specified while solving
 282             //  Poissons equations.
 283             virtual bool fixesValue() const
 284             {
 285                 return false;
 286             }
 287
 288             //- Return true if this patch field is coupled
 289             virtual bool coupled() const
 290             {
 291                 return false;
 292             }
 293
 294             //- Return true if the boundary condition has already been updated
 295             bool updated() const
 296             {
 297                 return updated_;
 298             }
 299
 300
 301         // Mapping functions
 302
 303             //- Map (and resize as needed) from self given a mapping object
 304             virtual void autoMap
 305             (
 306                 const faPatchFieldMapper&
 307             );
 308
 309             //- Reverse map the given faPatchField onto this faPatchField
 310             virtual void rmap
 311             (
 312                 const faPatchField<Type>&,
 313                 const labelList&
 314             );
 315
 316
 317         // Evaluation functions
 318
 319             //- Return patch-normal gradient
 320             virtual tmp<Field<Type> > snGrad() const;
 321
 322             //- Update the coefficients associated with the patch field
 323             //  Sets Updated to true
 324             virtual void updateCoeffs()
 325             {
 326                 updated_ = true;
 327             }
 328
 329             //- Return internal field next to patch as patch field
 330             virtual tmp<Field<Type> > patchInternalField() const;
 331
 332             //- Return patchField on the opposite patch of a coupled patch
 333             virtual tmp<Field<Type> > patchNeighbourField() const
 334             {
 335                 notImplemented(type() + "patchNeighbourField()");
 336                 return *this;
 337             }
 338
 339             //- Initialise the evaluation of the patch field
 340             virtual void initEvaluate
 341             (
 342                 const Pstream::commsTypes commsType=Pstream::blocking
 343             )
 344             {}
 345
 346             //- Evaluate the patch field, sets Updated to false
 347             virtual void evaluate
 348             (
 349                 const Pstream::commsTypes commsType=Pstream::blocking
 350             );
 351
 352
 353             //- Return the matrix diagonal coefficients corresponding to the
 354             //  evaluation of the value of this patchField with given weights
 355             virtual tmp<Field<Type> > valueInternalCoeffs
 356             (
 357                 const tmp<Field<scalar> >&
 358             ) const
 359             {
 360                 notImplemented
 361                 (
 362                     type()
 363                   + "::valueInternalCoeffs(const tmp<Field<scalar> >&)"
 364                 );
 365                 return *this;
 366             }
 367
 368             //- Return the matrix source coefficients corresponding to the
 369             //  evaluation of the value of this patchField with given weights
 370             virtual tmp<Field<Type> > valueBoundaryCoeffs
 371             (
 372                 const tmp<Field<scalar> >&
 373             ) const
 374             {
 375                 notImplemented
 376                 (
 377                     type()
 378                   + "::valueBoundaryCoeffs(const tmp<Field<scalar> >&)"
 379                 );
 380                 return *this;
 381             }
 382
 383             //- Return the matrix diagonal coefficients corresponding to the
 384             //  evaluation of the gradient of this patchField
 385             virtual tmp<Field<Type> > gradientInternalCoeffs() const
 386             {
 387                 notImplemented(type() + "::gradientInternalCoeffs()");
 388                 return *this;
 389             }
 390
 391             //- Return the matrix source coefficients corresponding to the
 392             //  evaluation of the gradient of this patchField
 393             virtual tmp<Field<Type> > gradientBoundaryCoeffs() const
 394             {
 395                 notImplemented(type() + "::gradientBoundaryCoeffs()");
 396                 return *this;
 397             }
 398
 399
 400         //- Write
 401         virtual void write(Ostream&) const;
 402
 403
 404         // Check
 405
 406             //- Check faPatchField<Type> against given faPatchField<Type>
 407             void check(const faPatchField<Type>&) const;
 408
 409
 410     // Member operators
 411
 412         virtual void operator=(const UList<Type>&);
 413
 414         virtual void operator=(const faPatchField<Type>&);
 415         virtual void operator+=(const faPatchField<Type>&);
 416         virtual void operator-=(const faPatchField<Type>&);
 417         virtual void operator*=(const faPatchField<scalar>&);
 418         virtual void operator/=(const faPatchField<scalar>&);
 419
 420         virtual void operator+=(const Field<Type>&);
 421         virtual void operator-=(const Field<Type>&);
 422
 423         virtual void operator*=(const Field<scalar>&);
 424         virtual void operator/=(const Field<scalar>&);
 425
 426         virtual void operator=(const Type&);
 427         virtual void operator+=(const Type&);
 428         virtual void operator-=(const Type&);
 429         virtual void operator*=(const scalar);
 430         virtual void operator/=(const scalar);
 431
 432
 433         // Force an assignment irrespective of form of patch
 434
 435         virtual void operator==(const faPatchField<Type>&);
 436         virtual void operator==(const Field<Type>&);
 437         virtual void operator==(const Type&);
 438
 439
 440     // Ostream operator
 441
 442         friend Ostream& operator<< <Type>(Ostream&, const faPatchField<Type>&);
 443 };
 444
 445
 446 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 447
 448 } // End namespace Foam
 449
 450 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 451
 452 #ifdef NoRepository
 453 #   include "faPatchField.C"
 454 #   include "calculatedFaPatchField.H"
 455 #endif
 456
 457
 458 #define makeFaPatchTypeFieldTypeName(typePatchTypeField)                   \
 459                                                                            \
 460 defineNamedTemplateTypeNameAndDebug(typePatchTypeField, 0);
 461
 462 #define makeFaPatchFieldsTypeName(typePatchField)                          \
 463                                                                            \
 464 makeFaPatchTypeFieldTypeName(typePatchField##FaPatchScalarField);          \
 465 makeFaPatchTypeFieldTypeName(typePatchField##FaPatchVectorField);          \
 466 makeFaPatchTypeFieldTypeName(typePatchField##FaPatchSphericalTensorField); \
 467 makeFaPatchTypeFieldTypeName(typePatchField##FaPatchSymmTensorField);      \
 468 makeFaPatchTypeFieldTypeName(typePatchField##FaPatchTensorField);
 469
 470 #define makeFaPatchTypeField(PatchTypeField, typePatchTypeField)           \
 471                                                                            \
 472 defineNamedTemplateTypeNameAndDebug(typePatchTypeField, 0);                \
 473                                                                            \
 474 addToRunTimeSelectionTable                                                 \
 475 (                                                                          \
 476     PatchTypeField, typePatchTypeField, patch                              \
 477 );                                                                         \
 478                                                                            \
 479 addToRunTimeSelectionTable                                                 \
 480 (                                                                          \
 481     PatchTypeField,                                                        \
 482     typePatchTypeField,                                                    \
 483     patchMapper                                                            \
 484 );                                                                         \
 485                                                                            \
 486 addToRunTimeSelectionTable                                                 \
 487 (                                                                          \
 488     PatchTypeField, typePatchTypeField, dictionary                         \
 489 );
 490
 491
 492 #define makeFaPatchFields(type)                                            \
 493                                                                            \
 494 makeFaPatchTypeField(faPatchScalarField, type##FaPatchScalarField);        \
 495 makeFaPatchTypeField(faPatchVectorField, type##FaPatchVectorField);        \
 496 makeFaPatchTypeField                                                       \
 497 (                                                                          \
 498     faPatchSphericalTensorField,                                           \
 499     type##FaPatchSphericalTensorField                                      \
 500 );                                                                         \
 501 makeFaPatchTypeField(faPatchSymmTensorField, type##FaPatchSymmTensorField);\
 502 makeFaPatchTypeField(faPatchTensorField, type##FaPatchTensorField);
 503
 504
 505 #define makeFaPatchTypeFieldTypedefs(type)                                   \
 506                                                                              \
 507 typedef type##FaPatchField<scalar> type##FaPatchScalarField;                 \
 508 typedef type##FaPatchField<vector> type##FaPatchVectorField;                 \
 509 typedef type##FaPatchField<sphericalTensor>                                  \
 510      type##FaPatchSphericalTensorField;                                      \
 511 typedef type##FaPatchField<symmTensor> type##FaPatchSymmTensorField;         \
 512 typedef type##FaPatchField<tensor> type##FaPatchTensorField;
 513
 514
 515 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 516
 517 #endif
 518
 519 // ************************************************************************* //