src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedField.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2008 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 \*---------------------------------------------------------------------------*/
  26
  27 #include "DimensionedField.H"
  28 #include "dimensionedType.H"
  29
  30 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  31
  32 namespace Foam
  33 {
  34
  35 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  36
  37 // check mesh for two fields
  38 #define checkField(df1, df2, op)                                    \
  39 if (&(df1).mesh() != &(df2).mesh())                                 \
  40 {                                                                   \
  41     FatalErrorIn("checkField(df1, df2, op)")                        \
  42         << "different mesh for fields "                             \
  43         << (df1).name() << " and " << (df2).name()                  \
  44         << " during operatrion " <<  op                             \
  45         << abort(FatalError);                                       \
  46 }
  47
  48
  49 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  50
  51 template<class Type, class GeoMesh>
  52 DimensionedField<Type, GeoMesh>::DimensionedField
  53 (
  54     const IOobject& io,
  55     const Mesh& mesh,
  56     const dimensionSet& dims,
  57     const Field<Type>& field
  58 )
  59 :
  60     regIOobject(io),
  61     Field<Type>(field),
  62     mesh_(mesh),
  63     dimensions_(dims)
  64 {
  65     if (field.size() && field.size() != GeoMesh::size(mesh))
  66     {
  67         FatalErrorIn
  68         (
  69             "DimensionedField<Type, GeoMesh>::DimensionedField"
  70             "(const IOobject& io,const Mesh& mesh, "
  71             "const dimensionSet& dims, const Field<Type>& field)"
  72         )   << "size of field = " << field.size()
  73             << " is not the same as the size of mesh = "
  74             << GeoMesh::size(mesh)
  75             << abort(FatalError);
  76     }
  77 }
  78
  79
  80 template<class Type, class GeoMesh>
  81 DimensionedField<Type, GeoMesh>::DimensionedField
  82 (
  83     const IOobject& io,
  84     const Mesh& mesh,
  85     const dimensionSet& dims
  86 )
  87 :
  88     regIOobject(io),
  89     Field<Type>(GeoMesh::size(mesh)),
  90     mesh_(mesh),
  91     dimensions_(dims)
  92 {}
  93
  94
  95 template<class Type, class GeoMesh>
  96 DimensionedField<Type, GeoMesh>::DimensionedField
  97 (
  98     const IOobject& io,
  99     const Mesh& mesh,
 100     const dimensioned<Type>& dt
 101 )
 102 :
 103     regIOobject(io),
 104     Field<Type>(GeoMesh::size(mesh), dt.value()),
 105     mesh_(mesh),
 106     dimensions_(dt.dimensions())
 107 {}
 108
 109
 110 template<class Type, class GeoMesh>
 111 DimensionedField<Type, GeoMesh>::DimensionedField
 112 (
 113     const DimensionedField<Type, GeoMesh>& df
 114 )
 115 :
 116 #   ifdef ConstructFromTmp
 117     regIOobject(df),
 118 #   else
 119     regIOobject(df, true),
 120 #   endif
 121     Field<Type>(df),
 122     mesh_(df.mesh_),
 123     dimensions_(df.dimensions_)
 124 {}
 125
 126
 127 template<class Type, class GeoMesh>
 128 DimensionedField<Type, GeoMesh>::DimensionedField
 129 (
 130     DimensionedField<Type, GeoMesh>& df,
 131     bool reUse
 132 )
 133 :
 134     regIOobject(df, true),
 135     Field<Type>(df, reUse),
 136     mesh_(df.mesh_),
 137     dimensions_(df.dimensions_)
 138 {}
 139
 140
 141 #ifdef ConstructFromTmp
 142 template<class Type, class GeoMesh>
 143 DimensionedField<Type, GeoMesh>::DimensionedField
 144 (
 145     const tmp<DimensionedField<Type, GeoMesh> >& tdf
 146 )
 147 :
 148     regIOobject(tdf(), true),
 149     Field<Type>
 150     (
 151         const_cast<DimensionedField<Type, GeoMesh>&>(tdf()),
 152         tdf.isTmp()
 153     ),
 154     mesh_(tdf().mesh_),
 155     dimensions_(tdf().dimensions_)
 156 {
 157     tdf.clear();
 158 }
 159 #endif
 160
 161
 162 template<class Type, class GeoMesh>
 163 DimensionedField<Type, GeoMesh>::DimensionedField
 164 (
 165     const IOobject& io,
 166     const DimensionedField<Type, GeoMesh>& df
 167 )
 168 :
 169     regIOobject(io),
 170     Field<Type>(df),
 171     mesh_(df.mesh_),
 172     dimensions_(df.dimensions_)
 173 {}
 174
 175
 176 template<class Type, class GeoMesh>
 177 DimensionedField<Type, GeoMesh>::DimensionedField
 178 (
 179     const word& newName,
 180     const DimensionedField<Type, GeoMesh>& df
 181 )
 182 :
 183     regIOobject(IOobject(newName, df.time().timeName(), df.db())),
 184     Field<Type>(df),
 185     mesh_(df.mesh_),
 186     dimensions_(df.dimensions_)
 187 {}
 188
 189
 190 template<class Type, class GeoMesh>
 191 DimensionedField<Type, GeoMesh>::DimensionedField
 192 (
 193     const word& newName,
 194     DimensionedField<Type, GeoMesh>& df,
 195     bool reUse
 196 )
 197 :
 198     regIOobject(IOobject(newName, df.time().timeName(), df.db())),
 199     Field<Type>(df, reUse),
 200     mesh_(df.mesh_),
 201     dimensions_(df.dimensions_)
 202 {}
 203
 204
 205 #ifdef ConstructFromTmp
 206 template<class Type, class GeoMesh>
 207 DimensionedField<Type, GeoMesh>::DimensionedField
 208 (
 209     const word& newName,
 210     const tmp<DimensionedField<Type, GeoMesh> >& tdf
 211 )
 212 :
 213     regIOobject(IOobject(newName, tdf().time().timeName(), tdf().db())),
 214     Field<Type>
 215     (
 216         const_cast<DimensionedField<Type, GeoMesh>&>(tdf()),
 217         tdf.isTmp()
 218     ),
 219     mesh_(tdf().mesh_),
 220     dimensions_(tdf().dimensions_)
 221 {
 222     tdf().clear();
 223 }
 224 #endif
 225
 226
 227 template<class Type, class GeoMesh>
 228 tmp<DimensionedField<Type, GeoMesh> >
 229 DimensionedField<Type, GeoMesh>::clone() const
 230 {
 231     return tmp<DimensionedField<Type, GeoMesh> >
 232     (
 233         new DimensionedField<Type, GeoMesh>(*this)
 234     );
 235 }
 236
 237
 238 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 239
 240 template<class Type, class GeoMesh>
 241 DimensionedField<Type, GeoMesh>::~DimensionedField()
 242 {}
 243
 244
 245 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 246
 247 // Return a null Field
 248 template<class Type, class GeoMesh>
 249 const DimensionedField<Type, GeoMesh>& DimensionedField<Type, GeoMesh>::null()
 250 {
 251     DimensionedField<Type, GeoMesh>* nullPtr =
 252         reinterpret_cast<DimensionedField<Type, GeoMesh>*>(NULL);
 253     return *nullPtr;
 254 }
 255
 256
 257 template<class Type, class GeoMesh>
 258 tmp
 259 <
 260     DimensionedField
 261         <typename DimensionedField<Type, GeoMesh>::cmptType, GeoMesh>
 262 >
 263 DimensionedField<Type, GeoMesh>::component
 264 (
 265     const direction d
 266 ) const
 267 {
 268     tmp<DimensionedField<cmptType, GeoMesh> > result
 269     (
 270         new DimensionedField<cmptType, GeoMesh>
 271         (
 272             IOobject
 273             (
 274                 name() + ".component(" + ::Foam::name(d) + ')',
 275                 instance(),
 276                 db()
 277             ),
 278             mesh_,
 279             dimensions_
 280         )
 281     );
 282
 283     Foam::component(result(), *this, d);
 284
 285     return result;
 286 }
 287
 288
 289 template<class Type, class GeoMesh>
 290 void DimensionedField<Type, GeoMesh>::replace
 291 (
 292     const direction d,
 293     const DimensionedField
 294         <typename DimensionedField<Type, GeoMesh>::cmptType, GeoMesh>& df
 295 )
 296 {
 297     Field<Type>::replace(d, df);
 298 }
 299
 300
 301 template<class Type, class GeoMesh>
 302 void DimensionedField<Type, GeoMesh>::replace
 303 (
 304     const direction d,
 305     const tmp
 306     <
 307         DimensionedField
 308             <typename DimensionedField<Type, GeoMesh>::cmptType, GeoMesh>
 309     >& tdf
 310 )
 311 {
 312     replace(d, tdf());
 313     tdf.clear();
 314 }
 315
 316
 317 template<class Type, class GeoMesh>
 318 tmp<DimensionedField<Type, GeoMesh> >
 319 DimensionedField<Type, GeoMesh>::T() const
 320 {
 321     tmp<DimensionedField<Type, GeoMesh> > result
 322     (
 323         new DimensionedField<Type, GeoMesh>
 324         (
 325             IOobject
 326             (
 327                 name() + ".T()",
 328                 instance(),
 329                 db()
 330             ),
 331             mesh_,
 332             dimensions_
 333         )
 334     );
 335
 336     Foam::T(result(), *this);
 337
 338     return result;
 339 }
 340
 341
 342 template<class Type, class GeoMesh>
 343 dimensioned<Type> DimensionedField<Type, GeoMesh>::average() const
 344 {
 345     dimensioned<Type> Average
 346     (
 347         this->name() + ".average()",
 348         this->dimensions(),
 349         gAverage(field())
 350     );
 351
 352     return Average;
 353 }
 354
 355
 356 template<class Type, class GeoMesh>
 357 dimensioned<Type> DimensionedField<Type, GeoMesh>::weightedAverage
 358 (
 359     const DimensionedField<scalar, GeoMesh>& weightField
 360 ) const
 361 {
 362     return
 363     (
 364         dimensioned<Type>
 365         (
 366             this->name() + ".weightedAverage(weights)",
 367             this->dimensions(),
 368             gSum(weightField*field())/gSum(weightField)
 369         )
 370     );
 371 }
 372
 373
 374 template<class Type, class GeoMesh>
 375 dimensioned<Type> DimensionedField<Type, GeoMesh>::weightedAverage
 376 (
 377     const tmp<DimensionedField<scalar, GeoMesh> >& tweightField
 378 ) const
 379 {
 380     dimensioned<Type> wa = weightedAverage(tweightField());
 381     tweightField.clear();
 382     return wa;
 383 }
 384
 385
 386 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 387
 388 template<class Type, class GeoMesh>
 389 void DimensionedField<Type, GeoMesh>::operator=
 390 (
 391     const DimensionedField<Type, GeoMesh>& df
 392 )
 393 {
 394     // Check for assignment to self
 395     if (this == &df)
 396     {
 397         FatalErrorIn
 398         (
 399             "DimensionedField<Type, GeoMesh>::operator="
 400             "(const DimensionedField<Type, GeoMesh>&)"
 401         )   << "attempted assignment to self"
 402             << abort(FatalError);
 403     }
 404
 405     checkField(*this, df, "=");
 406
 407     dimensions_ = df.dimensions();
 408     Field<Type>::operator=(df);
 409 }
 410
 411
 412 template<class Type, class GeoMesh>
 413 void DimensionedField<Type, GeoMesh>::operator=
 414 (
 415     const tmp<DimensionedField<Type, GeoMesh> >& tdf
 416 )
 417 {
 418     const DimensionedField<Type, GeoMesh>& df = tdf();
 419
 420     // Check for assignment to self
 421     if (this == &df)
 422     {
 423         FatalErrorIn
 424         (
 425             "DimensionedField<Type, GeoMesh>::operator="
 426             "(const tmp<DimensionedField<Type, GeoMesh> >&)"
 427         )   << "attempted assignment to self"
 428             << abort(FatalError);
 429     }
 430
 431     checkField(*this, df, "=");
 432
 433     dimensions_ = df.dimensions();
 434     transfer(const_cast<DimensionedField<Type, GeoMesh>&>(df));
 435     tdf.clear();
 436 }
 437
 438
 439 template<class Type, class GeoMesh>
 440 void DimensionedField<Type, GeoMesh>::operator=
 441 (
 442     const dimensioned<Type>& dt
 443 )
 444 {
 445     dimensions_ = dt.dimensions();
 446     Field<Type>::operator=(dt.value());
 447 }
 448
 449
 450 #define COMPUTED_ASSIGNMENT(TYPE, op)                                         \
 451                                                                               \
 452 template<class Type, class GeoMesh>                                           \
 453 void DimensionedField<Type, GeoMesh>::operator op                             \
 454 (                                                                             \
 455     const DimensionedField<TYPE, GeoMesh>& df                                 \
 456 )                                                                             \
 457 {                                                                             \
 458     checkField(*this, df, #op);                                               \
 459                                                                               \
 460     dimensions_ op df.dimensions();                                           \
 461     Field<Type>::operator op(df);                                             \
 462 }                                                                             \
 463                                                                               \
 464 template<class Type, class GeoMesh>                                           \
 465 void DimensionedField<Type, GeoMesh>::operator op                             \
 466 (                                                                             \
 467     const tmp<DimensionedField<TYPE, GeoMesh> >& tdf                          \
 468 )                                                                             \
 469 {                                                                             \
 470     operator op(tdf());                                                       \
 471     tdf.clear();                                                              \
 472 }                                                                             \
 473                                                                               \
 474 template<class Type, class GeoMesh>                                           \
 475 void DimensionedField<Type, GeoMesh>::operator op                             \
 476 (                                                                             \
 477     const dimensioned<TYPE>& dt                                               \
 478 )                                                                             \
 479 {                                                                             \
 480     dimensions_ op dt.dimensions();                                           \
 481     Field<Type>::operator op(dt.value());                                     \
 482 }
 483
 484 COMPUTED_ASSIGNMENT(Type, +=)
 485 COMPUTED_ASSIGNMENT(Type, -=)
 486 COMPUTED_ASSIGNMENT(scalar, *=)
 487 COMPUTED_ASSIGNMENT(scalar, /=)
 488
 489 #undef COMPUTED_ASSIGNMENT
 490
 491
 492 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 493
 494 #undef checkField
 495
 496 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 497
 498 } // End namespace Foam
 499
 500 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 501
 502 #include "DimensionedFieldIO.C"
 503 #include "DimensionedFieldFunctions.C"
 504
 505 // ************************************************************************* //