src/OpenFOAM/fields/Fields/Field/Field.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-2010 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
  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::Field
  26
  27 Description
  28     Generic templated field type.
  29
  30 SourceFiles
  31     FieldFunctions.H
  32     FieldFunctionsM.H
  33     FieldMapper.H
  34     FieldM.H
  35     Field.C
  36     FieldFunctions.C
  37     FieldFunctionsM.C
  38
  39 \*---------------------------------------------------------------------------*/
  40
  41 #ifndef Field_H
  42 #define Field_H
  43
  44 #include "tmp.H"
  45 #include "direction.H"
  46 #include "VectorSpace.H"
  47 #include "scalarList.H"
  48 #include "labelList.H"
  49
  50 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  51
  52 namespace Foam
  53 {
  54
  55 // Forward declaration of friend functions and operators
  56
  57 template<class Type>
  58 class Field;
  59
  60 //- Pre-declare related SubField type
  61 template<class Type>
  62 class SubField;
  63
  64 template<class Type>
  65 Ostream& operator<<(Ostream&, const Field<Type>&);
  66
  67 template<class Type>
  68 Ostream& operator<<(Ostream&, const tmp<Field<Type> >&);
  69
  70 class FieldMapper;
  71 class dictionary;
  72
  73 /*---------------------------------------------------------------------------*\
  74                            Class Field Declaration
  75 \*---------------------------------------------------------------------------*/
  76
  77 template<class Type>
  78 class Field
  79 :
  80     public refCount,
  81     public List<Type>
  82 {
  83
  84 public:
  85
  86     //- Component type
  87     typedef typename pTraits<Type>::cmptType cmptType;
  88
  89     //- Declare type of subField
  90     typedef SubField<Type> subField;
  91
  92
  93     // Static data members
  94
  95         static const char* const typeName;
  96
  97
  98     // Static Member Functions
  99
 100         //- Return a null field
 101         inline static const Field<Type>& null()
 102         {
 103             return *reinterpret_cast< Field<Type>* >(0);
 104         }
 105
 106
 107     // Constructors
 108
 109         //- Construct null
 110         //  Used for temporary fields which are initialised after construction
 111         Field();
 112
 113         //- Construct given size
 114         //  Used for temporary fields which are initialised after construction
 115         explicit Field(const label);
 116
 117         //- Construct given size and initial value
 118         Field(const label, const Type&);
 119
 120         //- Construct as copy of a UList\<Type\>
 121         explicit Field(const UList<Type>&);
 122
 123         //- Construct by transferring the List contents
 124         explicit Field(const Xfer<List<Type> >&);
 125
 126         //- Construct by 1 to 1 mapping from the given field
 127         Field
 128         (
 129             const UList<Type>& mapF,
 130             const labelUList& mapAddressing
 131         );
 132
 133         //- Construct by 1 to 1 mapping from the given tmp field
 134         Field
 135         (
 136             const tmp<Field<Type> >& tmapF,
 137             const labelUList& mapAddressing
 138         );
 139
 140         //- Construct by interpolative mapping from the given field
 141         Field
 142         (
 143             const UList<Type>& mapF,
 144             const labelListList& mapAddressing,
 145             const scalarListList& weights
 146         );
 147
 148         //- Construct by interpolative mapping from the given tmp field
 149         Field
 150         (
 151             const tmp<Field<Type> >& tmapF,
 152             const labelListList& mapAddressing,
 153             const scalarListList& weights
 154         );
 155
 156         //- Construct by mapping from the given field
 157         Field
 158         (
 159             const UList<Type>& mapF,
 160             const FieldMapper& map
 161         );
 162
 163         //- Construct by mapping from the given tmp field
 164         Field
 165         (
 166             const tmp<Field<Type> >& tmapF,
 167             const FieldMapper& map
 168         );
 169
 170         //- Construct as copy
 171         Field(const Field<Type>&);
 172
 173         //- Construct as copy or re-use as specified.
 174         Field(Field<Type>&, bool reUse);
 175
 176         //- Construct by transferring the Field contents
 177         Field(const Xfer<Field<Type> >&);
 178
 179 #ifdef __INTEL_COMPILER
 180         //- Construct as copy of subField
 181         Field(const typename Field<Type>::subField&);
 182 #endif
 183
 184         //- Construct as copy of tmp<Field>
 185 #       ifdef ConstructFromTmp
 186         Field(const tmp<Field<Type> >&);
 187 #       endif
 188
 189         //- Construct from Istream
 190         Field(Istream&);
 191
 192         //- Construct from a dictionary entry
 193         Field(const word& keyword, const dictionary&, const label size);
 194
 195         //- Clone
 196         tmp<Field<Type> > clone() const;
 197
 198         //- Return a pointer to a new calculatedFvPatchFieldField created on
 199         //  freestore without setting patchField values
 200         template<class Type2>
 201         static tmp<Field<Type> > NewCalculatedType(const Field<Type2>& f)
 202         {
 203             return tmp<Field<Type> >(new Field<Type>(f.size()));
 204         }
 205
 206
 207     // Member Functions
 208
 209         //- 1 to 1 map from the given field
 210         void map
 211         (
 212             const UList<Type>& mapF,
 213             const labelUList& mapAddressing
 214         );
 215
 216         //- 1 to 1 map from the given tmp field
 217         void map
 218         (
 219             const tmp<Field<Type> >& tmapF,
 220             const labelUList& mapAddressing
 221         );
 222
 223         //- Interpolative map from the given field
 224         void map
 225         (
 226             const UList<Type>& mapF,
 227             const labelListList& mapAddressing,
 228             const scalarListList& weights
 229         );
 230
 231         //- Interpolative map from the given tmp field
 232         void map
 233         (
 234             const tmp<Field<Type> >& tmapF,
 235             const labelListList& mapAddressing,
 236             const scalarListList& weights
 237         );
 238
 239         //- Map from the given field
 240         void map
 241         (
 242             const UList<Type>& mapF,
 243             const FieldMapper& map
 244         );
 245
 246         //- Map from the given tmp field
 247         void map
 248         (
 249             const tmp<Field<Type> >& tmapF,
 250             const FieldMapper& map
 251         );
 252
 253         //- Map from self
 254         void autoMap
 255         (
 256             const FieldMapper& map
 257         );
 258
 259         //- 1 to 1 reverse-map from the given field
 260         void rmap
 261         (
 262             const UList<Type>& mapF,
 263             const labelUList& mapAddressing
 264         );
 265
 266         //- 1 to 1 reverse-map from the given tmp field
 267         void rmap
 268         (
 269             const tmp<Field<Type> >& tmapF,
 270             const labelUList& mapAddressing
 271         );
 272
 273         //- Interpolative reverse map from the given field
 274         void rmap
 275         (
 276             const UList<Type>& mapF,
 277             const labelUList& mapAddressing,
 278             const UList<scalar>& weights
 279         );
 280
 281         //- Interpolative reverse map from the given tmp field
 282         void rmap
 283         (
 284             const tmp<Field<Type> >& tmapF,
 285             const labelUList& mapAddressing,
 286             const UList<scalar>& weights
 287         );
 288
 289         //- Negate this field
 290         void negate();
 291
 292         //- Return a component field of the field
 293         tmp<Field<cmptType> > component(const direction) const;
 294
 295         //- Replace a component field of the field
 296         void replace(const direction, const UList<cmptType>&);
 297
 298         //- Replace a component field of the field
 299         void replace(const direction, const tmp<Field<cmptType> >&);
 300
 301         //- Replace a component field of the field
 302         void replace(const direction, const cmptType&);
 303
 304         //- Return the field transpose (only defined for second rank tensors)
 305         tmp<Field<Type> > T() const;
 306
 307         //- Write the field as a dictionary entry
 308         void writeEntry(const word& keyword, Ostream& os) const;
 309
 310
 311     // Member operators
 312
 313         void operator=(const Field<Type>&);
 314         void operator=(const UList<Type>&);
 315         void operator=(const SubField<Type>&);
 316         void operator=(const tmp<Field<Type> >&);
 317         void operator=(const Type&);
 318
 319         template<class Form, class Cmpt, int nCmpt>
 320         void operator=(const VectorSpace<Form,Cmpt,nCmpt>&);
 321
 322         void operator+=(const UList<Type>&);
 323         void operator+=(const tmp<Field<Type> >&);
 324
 325         void operator-=(const UList<Type>&);
 326         void operator-=(const tmp<Field<Type> >&);
 327
 328         void operator*=(const UList<scalar>&);
 329         void operator*=(const tmp<Field<scalar> >&);
 330
 331         void operator/=(const UList<scalar>&);
 332         void operator/=(const tmp<Field<scalar> >&);
 333
 334         void operator+=(const Type&);
 335         void operator-=(const Type&);
 336
 337         void operator*=(const scalar&);
 338         void operator/=(const scalar&);
 339
 340
 341     // IOstream operators
 342
 343         friend Ostream& operator<< <Type>
 344         (Ostream&, const Field<Type>&);
 345
 346         friend Ostream& operator<< <Type>
 347         (Ostream&, const tmp<Field<Type> >&);
 348 };
 349
 350
 351 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 352
 353 } // End namespace Foam
 354
 355 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 356
 357 #include "FieldFunctions.H"
 358
 359 #ifdef NoRepository
 360 #   include "Field.C"
 361 #endif
 362
 363 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 364
 365 #endif
 366
 367 // ************************************************************************* //