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