src/finiteArea/fields/faPatchFields/faPatchField/faPatchField.C

   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 \*---------------------------------------------------------------------------*/
  26
  27 #include "IOobject.H"
  28 #include "dictionary.H"
  29 #include "faMesh.H"
  30 #include "faPatchFieldMapper.H"
  31
  32 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  33
  34 namespace Foam
  35 {
  36
  37 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  38
  39 template<class Type>
  40 faPatchField<Type>::faPatchField
  41 (
  42     const faPatch& p,
  43     const DimensionedField<Type, areaMesh>& iF
  44 )
  45 :
  46     Field<Type>(p.size()),
  47     patch_(p),
  48     internalField_(iF),
  49     updated_(false)
  50 {}
  51
  52
  53 template<class Type>
  54 faPatchField<Type>::faPatchField
  55 (
  56     const faPatch& p,
  57     const DimensionedField<Type, areaMesh>& iF,
  58     const Field<Type>& f
  59 )
  60 :
  61     Field<Type>(f),
  62     patch_(p),
  63     internalField_(iF),
  64     updated_(false)
  65 {}
  66
  67
  68 template<class Type>
  69 faPatchField<Type>::faPatchField
  70 (
  71     const faPatchField<Type>& ptf,
  72     const faPatch& p,
  73     const DimensionedField<Type, areaMesh>& iF,
  74     const faPatchFieldMapper& mapper
  75 )
  76 :
  77     Field<Type>(ptf, mapper),
  78     patch_(p),
  79     internalField_(iF),
  80     updated_(false)
  81 {}
  82
  83
  84 template<class Type>
  85 faPatchField<Type>::faPatchField
  86 (
  87     const faPatch& p,
  88     const DimensionedField<Type, areaMesh>& iF,
  89     const dictionary& dict
  90 )
  91 :
  92     Field<Type>(p.size()),
  93     patch_(p),
  94     internalField_(iF),
  95     updated_(false)
  96 {
  97     if (dict.found("value"))
  98     {
  99         faPatchField<Type>::operator=
 100         (
 101             Field<Type>("value", dict, p.size())
 102         );
 103     }
 104     else
 105     {
 106         faPatchField<Type>::operator=(pTraits<Type>::zero);
 107     }
 108 }
 109
 110
 111 template<class Type>
 112 faPatchField<Type>::faPatchField
 113 (
 114     const faPatchField<Type>& ptf
 115 )
 116 :
 117     Field<Type>(ptf),
 118     patch_(ptf.patch_),
 119     internalField_(ptf.internalField_),
 120     updated_(false)
 121 {}
 122
 123
 124 template<class Type>
 125 faPatchField<Type>::faPatchField
 126 (
 127     const faPatchField<Type>& ptf,
 128     const DimensionedField<Type, areaMesh>& iF
 129 )
 130 :
 131     Field<Type>(ptf),
 132     patch_(ptf.patch_),
 133     internalField_(iF),
 134     updated_(false)
 135 {}
 136
 137
 138 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 139
 140 template<class Type>
 141 const objectRegistry& faPatchField<Type>::db() const
 142 {
 143     return patch_.boundaryMesh().mesh();
 144 }
 145
 146
 147 template<class Type>
 148 void faPatchField<Type>::check(const faPatchField<Type>& ptf) const
 149 {
 150     if (&patch_ != &(ptf.patch_))
 151     {
 152         FatalErrorIn("PatchField<Type>::check(const faPatchField<Type>&)")
 153             << "different patches for faPatchField<Type>s"
 154             << abort(FatalError);
 155     }
 156 }
 157
 158
 159 // Return gradient at boundary
 160 template<class Type>
 161 tmp<Field<Type> > faPatchField<Type>::snGrad() const
 162 {
 163     return (*this - patchInternalField())*patch_.deltaCoeffs();
 164 }
 165
 166
 167 // Return internal field next to patch as patch field
 168 template<class Type>
 169 tmp<Field<Type> > faPatchField<Type>::patchInternalField() const
 170 {
 171     return patch_.patchInternalField(internalField_);
 172 }
 173
 174
 175 template<class Type>
 176 void faPatchField<Type>::autoMap
 177 (
 178     const faPatchFieldMapper& m
 179 )
 180 {
 181     Field<Type>::autoMap(m);
 182 }
 183
 184
 185 template<class Type>
 186 void faPatchField<Type>::rmap
 187 (
 188     const faPatchField<Type>& ptf,
 189     const labelList& addr
 190 )
 191 {
 192     Field<Type>::rmap(ptf, addr);
 193 }
 194
 195
 196 template<class Type>
 197 void faPatchField<Type>::evaluate(const Pstream::commsTypes)
 198 {
 199     if (!updated_)
 200     {
 201         updateCoeffs();
 202     }
 203
 204     updated_ = false;
 205 }
 206
 207
 208 template<class Type>
 209 void faPatchField<Type>::write(Ostream& os) const
 210 {
 211     os.writeKeyword("type") << type() << token::END_STATEMENT << nl;
 212 }
 213
 214
 215 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 216
 217 template<class Type>
 218 void faPatchField<Type>::operator=
 219 (
 220     const UList<Type>& ul
 221 )
 222 {
 223     Field<Type>::operator=(ul);
 224 }
 225
 226
 227 template<class Type>
 228 void faPatchField<Type>::operator=
 229 (
 230     const faPatchField<Type>& ptf
 231 )
 232 {
 233     check(ptf);
 234     Field<Type>::operator=(ptf);
 235 }
 236
 237
 238 template<class Type>
 239 void faPatchField<Type>::operator+=
 240 (
 241     const faPatchField<Type>& ptf
 242 )
 243 {
 244     check(ptf);
 245     Field<Type>::operator+=(ptf);
 246 }
 247
 248
 249 template<class Type>
 250 void faPatchField<Type>::operator-=
 251 (
 252     const faPatchField<Type>& ptf
 253 )
 254 {
 255     check(ptf);
 256     Field<Type>::operator-=(ptf);
 257 }
 258
 259
 260 template<class Type>
 261 void faPatchField<Type>::operator*=
 262 (
 263     const faPatchField<scalar>& ptf
 264 )
 265 {
 266     if (&patch_ != &ptf.patch())
 267     {
 268         FatalErrorIn
 269         (
 270             "PatchField<Type>::operator*=(const faPatchField<scalar>& ptf)"
 271         )   << "incompatible patches for patch fields"
 272             << abort(FatalError);
 273     }
 274
 275     Field<Type>::operator*=(ptf);
 276 }
 277
 278
 279 template<class Type>
 280 void faPatchField<Type>::operator/=
 281 (
 282     const faPatchField<scalar>& ptf
 283 )
 284 {
 285     if (&patch_ != &ptf.patch())
 286     {
 287         FatalErrorIn
 288         (
 289             "PatchField<Type>::operator/=(const faPatchField<scalar>& ptf)"
 290         )   << "    incompatible patches for patch fields"
 291             << abort(FatalError);
 292     }
 293
 294     Field<Type>::operator/=(ptf);
 295 }
 296
 297
 298 template<class Type>
 299 void faPatchField<Type>::operator+=
 300 (
 301     const Field<Type>& tf
 302 )
 303 {
 304     Field<Type>::operator+=(tf);
 305 }
 306
 307
 308 template<class Type>
 309 void faPatchField<Type>::operator-=
 310 (
 311     const Field<Type>& tf
 312 )
 313 {
 314     Field<Type>::operator-=(tf);
 315 }
 316
 317
 318 template<class Type>
 319 void faPatchField<Type>::operator*=
 320 (
 321     const scalarField& tf
 322 )
 323 {
 324     Field<Type>::operator*=(tf);
 325 }
 326
 327
 328 template<class Type>
 329 void faPatchField<Type>::operator/=
 330 (
 331     const scalarField& tf
 332 )
 333 {
 334     Field<Type>::operator/=(tf);
 335 }
 336
 337
 338 template<class Type>
 339 void faPatchField<Type>::operator=
 340 (
 341     const Type& t
 342 )
 343 {
 344     Field<Type>::operator=(t);
 345 }
 346
 347
 348 template<class Type>
 349 void faPatchField<Type>::operator+=
 350 (
 351     const Type& t
 352 )
 353 {
 354     Field<Type>::operator+=(t);
 355 }
 356
 357
 358 template<class Type>
 359 void faPatchField<Type>::operator-=
 360 (
 361     const Type& t
 362 )
 363 {
 364     Field<Type>::operator-=(t);
 365 }
 366
 367
 368 template<class Type>
 369 void faPatchField<Type>::operator*=
 370 (
 371     const scalar s
 372 )
 373 {
 374     Field<Type>::operator*=(s);
 375 }
 376
 377
 378 template<class Type>
 379 void faPatchField<Type>::operator/=
 380 (
 381     const scalar s
 382 )
 383 {
 384     Field<Type>::operator/=(s);
 385 }
 386
 387
 388 // Force an assignment, overriding fixedValue status
 389 template<class Type>
 390 void faPatchField<Type>::operator==
 391 (
 392     const faPatchField<Type>& ptf
 393 )
 394 {
 395     Field<Type>::operator=(ptf);
 396 }
 397
 398
 399 template<class Type>
 400 void faPatchField<Type>::operator==
 401 (
 402     const Field<Type>& tf
 403 )
 404 {
 405     Field<Type>::operator=(tf);
 406 }
 407
 408
 409 template<class Type>
 410 void faPatchField<Type>::operator==
 411 (
 412     const Type& t
 413 )
 414 {
 415     Field<Type>::operator=(t);
 416 }
 417
 418
 419 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 420
 421 template<class Type>
 422 Ostream& operator<<(Ostream& os, const faPatchField<Type>& ptf)
 423 {
 424     ptf.write(os);
 425
 426     os.check("Ostream& operator<<(Ostream&, const faPatchField<Type>&");
 427
 428     return os;
 429 }
 430
 431
 432 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 433
 434 } // End namespace Foam
 435
 436 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 437
 438 #   include "newFaPatchField.C"
 439
 440 // ************************************************************************* //