src/OpenFOAM/fields/Fields/Field/FieldFunctions.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   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 \*---------------------------------------------------------------------------*/
  25
  26 #include "PstreamReduceOps.H"
  27 #include "FieldReuseFunctions.H"
  28
  29 #define TEMPLATE template<class Type>
  30 #include "FieldFunctionsM.C"
  31
  32 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  33
  34 namespace Foam
  35 {
  36
  37 /* * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * */
  38
  39 template<class Type>
  40 void component
  41 (
  42     Field<typename Field<Type>::cmptType>& res,
  43     const UList<Type>& f,
  44     const direction d
  45 )
  46 {
  47     typedef typename Field<Type>::cmptType cmptType;
  48     TFOR_ALL_F_OP_F_FUNC_S
  49     (
  50         cmptType, res, =, Type, f, .component, const direction, d
  51     )
  52 }
  53
  54
  55 template<class Type>
  56 void T(Field<Type>& res, const UList<Type>& f)
  57 {
  58     TFOR_ALL_F_OP_F_FUNC(Type, res, =, Type, f, T)
  59 }
  60
  61
  62 template<class Type, int r>
  63 void pow
  64 (
  65     Field<typename powProduct<Type, r>::type>& res,
  66     const UList<Type>& vf
  67 )
  68 {
  69     typedef typename powProduct<Type, r>::type powProductType;
  70     TFOR_ALL_F_OP_FUNC_F_S
  71     (
  72         powProductType, res, =, pow, Type, vf, powProductType,
  73         pTraits<powProductType>::zero
  74     )
  75 }
  76
  77 template<class Type, int r>
  78 tmp<Field<typename powProduct<Type, r>::type> >
  79 pow
  80 (
  81     const UList<Type>& f,
  82     typename powProduct<Type, r>::type
  83 )
  84 {
  85     typedef typename powProduct<Type, r>::type powProductType;
  86     tmp<Field<powProductType> > tRes
  87     (
  88         new Field<powProductType>(f.size())
  89     );
  90     pow<Type, r>(tRes(), f);
  91     return tRes;
  92 }
  93
  94 template<class Type, int r>
  95 tmp<Field<typename powProduct<Type, r>::type> >
  96 pow
  97 (
  98     const tmp<Field<Type> >& tf,
  99     typename powProduct<Type, r>::type
 100 )
 101 {
 102     typedef typename powProduct<Type, r>::type powProductType;
 103     tmp<Field<powProductType> > tRes = reuseTmp<powProductType, Type>::New(tf);
 104     pow<Type, r>(tRes(), tf());
 105     reuseTmp<powProductType, Type>::clear(tf);
 106     return tRes;
 107 }
 108
 109
 110 template<class Type>
 111 void sqr
 112 (
 113     Field<typename outerProduct<Type, Type>::type>& res,
 114     const UList<Type>& vf
 115 )
 116 {
 117     typedef typename outerProduct<Type, Type>::type outerProductType;
 118     TFOR_ALL_F_OP_FUNC_F(outerProductType, res, =, sqr, Type, vf)
 119 }
 120
 121 template<class Type>
 122 tmp<Field<typename outerProduct<Type, Type>::type> >
 123 sqr(const UList<Type>& f)
 124 {
 125     typedef typename outerProduct<Type, Type>::type outerProductType;
 126     tmp<Field<outerProductType> > tRes
 127     (
 128         new Field<outerProductType>(f.size())
 129     );
 130     sqr(tRes(), f);
 131     return tRes;
 132 }
 133
 134 template<class Type>
 135 tmp<Field<typename outerProduct<Type, Type>::type> >
 136 sqr(const tmp<Field<Type> >& tf)
 137 {
 138     typedef typename outerProduct<Type, Type>::type outerProductType;
 139     tmp<Field<outerProductType> > tRes =
 140         reuseTmp<outerProductType, Type>::New(tf);
 141     sqr(tRes(), tf());
 142     reuseTmp<outerProductType, Type>::clear(tf);
 143     return tRes;
 144 }
 145
 146
 147 template<class Type>
 148 void magSqr(Field<scalar>& res, const UList<Type>& f)
 149 {
 150     TFOR_ALL_F_OP_FUNC_F(scalar, res, =, magSqr, Type, f)
 151 }
 152
 153 template<class Type>
 154 tmp<Field<scalar> > magSqr(const UList<Type>& f)
 155 {
 156     tmp<Field<scalar> > tRes(new Field<scalar>(f.size()));
 157     magSqr(tRes(), f);
 158     return tRes;
 159 }
 160
 161 template<class Type>
 162 tmp<Field<scalar> > magSqr(const tmp<Field<Type> >& tf)
 163 {
 164     tmp<Field<scalar> > tRes = reuseTmp<scalar, Type>::New(tf);
 165     magSqr(tRes(), tf());
 166     reuseTmp<scalar, Type>::clear(tf);
 167     return tRes;
 168 }
 169
 170
 171 template<class Type>
 172 void mag(Field<scalar>& res, const UList<Type>& f)
 173 {
 174     TFOR_ALL_F_OP_FUNC_F(scalar, res, =, mag, Type, f)
 175 }
 176
 177 template<class Type>
 178 tmp<Field<scalar> > mag(const UList<Type>& f)
 179 {
 180     tmp<Field<scalar> > tRes(new Field<scalar>(f.size()));
 181     mag(tRes(), f);
 182     return tRes;
 183 }
 184
 185 template<class Type>
 186 tmp<Field<scalar> > mag(const tmp<Field<Type> >& tf)
 187 {
 188     tmp<Field<scalar> > tRes = reuseTmp<scalar, Type>::New(tf);
 189     mag(tRes(), tf());
 190     reuseTmp<scalar, Type>::clear(tf);
 191     return tRes;
 192 }
 193
 194
 195 template<class Type>
 196 void cmptMax(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f)
 197 {
 198     typedef typename Field<Type>::cmptType cmptType;
 199     TFOR_ALL_F_OP_FUNC_F(cmptType, res, =, cmptMax, Type, f)
 200 }
 201
 202 template<class Type>
 203 tmp<Field<typename Field<Type>::cmptType> > cmptMax(const UList<Type>& f)
 204 {
 205     typedef typename Field<Type>::cmptType cmptType;
 206     tmp<Field<cmptType> > tRes(new Field<cmptType>(f.size()));
 207     cmptMax(tRes(), f);
 208     return tRes;
 209 }
 210
 211 template<class Type>
 212 tmp<Field<typename Field<Type>::cmptType> > cmptMax(const tmp<Field<Type> >& tf)
 213 {
 214     typedef typename Field<Type>::cmptType cmptType;
 215     tmp<Field<cmptType> > tRes = reuseTmp<cmptType, Type>::New(tf);
 216     cmptMax(tRes(), tf());
 217     reuseTmp<cmptType, Type>::clear(tf);
 218     return tRes;
 219 }
 220
 221
 222 template<class Type>
 223 void cmptMin(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f)
 224 {
 225     typedef typename Field<Type>::cmptType cmptType;
 226     TFOR_ALL_F_OP_FUNC_F(cmptType, res, =, cmptMin, Type, f)
 227 }
 228
 229 template<class Type>
 230 tmp<Field<typename Field<Type>::cmptType> > cmptMin(const UList<Type>& f)
 231 {
 232     typedef typename Field<Type>::cmptType cmptType;
 233     tmp<Field<cmptType> > tRes(new Field<cmptType>(f.size()));
 234     cmptMin(tRes(), f);
 235     return tRes;
 236 }
 237
 238 template<class Type>
 239 tmp<Field<typename Field<Type>::cmptType> > cmptMin(const tmp<Field<Type> >& tf)
 240 {
 241     typedef typename Field<Type>::cmptType cmptType;
 242     tmp<Field<cmptType> > tRes = reuseTmp<cmptType, Type>::New(tf);
 243     cmptMin(tRes(), tf());
 244     reuseTmp<cmptType, Type>::clear(tf);
 245     return tRes;
 246 }
 247
 248
 249 template<class Type>
 250 void cmptAv(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f)
 251 {
 252     typedef typename Field<Type>::cmptType cmptType;
 253     TFOR_ALL_F_OP_FUNC_F(cmptType, res, =, cmptAv, Type, f)
 254 }
 255
 256 template<class Type>
 257 tmp<Field<typename Field<Type>::cmptType> > cmptAv(const UList<Type>& f)
 258 {
 259     typedef typename Field<Type>::cmptType cmptType;
 260     tmp<Field<cmptType> > tRes(new Field<cmptType>(f.size()));
 261     cmptAv(tRes(), f);
 262     return tRes;
 263 }
 264
 265 template<class Type>
 266 tmp<Field<typename Field<Type>::cmptType> > cmptAv(const tmp<Field<Type> >& tf)
 267 {
 268     typedef typename Field<Type>::cmptType cmptType;
 269     tmp<Field<cmptType> > tRes = reuseTmp<cmptType, Type>::New(tf);
 270     cmptAv(tRes(), tf());
 271     reuseTmp<cmptType, Type>::clear(tf);
 272     return tRes;
 273 }
 274
 275
 276 template<class Type>
 277 void cmptMag(Field<Type>& res, const UList<Type>& f)
 278 {
 279     TFOR_ALL_F_OP_FUNC_F(Type, res, =, cmptMag, Type, f)
 280 }
 281
 282 template<class Type>
 283 tmp<Field<Type> > cmptMag(const UList<Type>& f)
 284 {
 285     tmp<Field<Type> > tRes(new Field<Type>(f.size()));
 286     cmptMag(tRes(), f);
 287     return tRes;
 288 }
 289
 290 template<class Type>
 291 tmp<Field<Type> > cmptMag(const tmp<Field<Type> >& tf)
 292 {
 293     tmp<Field<Type> > tRes = reuseTmp<Type, Type>::New(tf);
 294     cmptMag(tRes(), tf());
 295     reuseTmp<Type, Type>::clear(tf);
 296     return tRes;
 297 }
 298
 299
 300 #define TMP_UNARY_FUNCTION(ReturnType, Func)                                  \
 301                                                                               \
 302 template<class Type>                                                          \
 303 ReturnType Func(const tmp<Field<Type> >& tf1)                                 \
 304 {                                                                             \
 305     ReturnType res = Func(tf1());                                             \
 306     tf1.clear();                                                              \
 307     return res;                                                               \
 308 }
 309
 310 template<class Type>
 311 Type max(const UList<Type>& f)
 312 {
 313     if (f.size())
 314     {
 315         Type Max(f[0]);
 316         TFOR_ALL_S_OP_FUNC_F_S(Type, Max, =, max, Type, f, Type, Max)
 317         return Max;
 318     }
 319     else
 320     {
 321         return pTraits<Type>::min;
 322     }
 323 }
 324
 325 TMP_UNARY_FUNCTION(Type, max)
 326
 327 template<class Type>
 328 Type min(const UList<Type>& f)
 329 {
 330     if (f.size())
 331     {
 332         Type Min(f[0]);
 333         TFOR_ALL_S_OP_FUNC_F_S(Type, Min, =, min, Type, f, Type, Min)
 334         return Min;
 335     }
 336     else
 337     {
 338         return pTraits<Type>::max;
 339     }
 340 }
 341
 342 TMP_UNARY_FUNCTION(Type, min)
 343
 344 template<class Type>
 345 Type sum(const UList<Type>& f)
 346 {
 347     if (f.size())
 348     {
 349         Type Sum = pTraits<Type>::zero;
 350         TFOR_ALL_S_OP_F(Type, Sum, +=, Type, f)
 351         return Sum;
 352     }
 353     else
 354     {
 355         return pTraits<Type>::zero;
 356     }
 357 }
 358
 359 TMP_UNARY_FUNCTION(Type, sum)
 360
 361
 362 template<class Type>
 363 scalar sumProd(const UList<Type>& f1, const UList<Type>& f2)
 364 {
 365     if (f1.size() && (f1.size() == f2.size()))
 366     {
 367         scalar SumProd = 0.0;
 368         TFOR_ALL_S_OP_F_OP_F(scalar, SumProd, +=, Type, f1, *, Type, f2)
 369         return SumProd;
 370     }
 371     else
 372     {
 373         return 0.0;
 374     }
 375 }
 376
 377
 378 template<class Type>
 379 Type sumCmptProd(const UList<Type>& f1, const UList<Type>& f2)
 380 {
 381     if (f1.size() && (f1.size() == f2.size()))
 382     {
 383         Type SumProd = pTraits<Type>::zero;
 384         TFOR_ALL_S_OP_FUNC_F_F
 385         (
 386             Type,
 387             SumProd,
 388             +=,
 389             cmptMultiply,
 390             Type,
 391             f1,
 392             Type,
 393             f2
 394         )
 395         return SumProd;
 396     }
 397     else
 398     {
 399         return pTraits<Type>::zero;
 400     }
 401 }
 402
 403
 404 template<class Type>
 405 scalar sumSqr(const UList<Type>& f)
 406 {
 407     if (f.size())
 408     {
 409         scalar SumSqr = 0.0;
 410         TFOR_ALL_S_OP_FUNC_F(scalar, SumSqr, +=, sqr, Type, f)
 411         return SumSqr;
 412     }
 413     else
 414     {
 415         return 0.0;
 416     }
 417 }
 418
 419 TMP_UNARY_FUNCTION(scalar, sumSqr)
 420
 421 template<class Type>
 422 scalar sumMag(const UList<Type>& f)
 423 {
 424     if (f.size())
 425     {
 426         scalar SumMag = 0.0;
 427         TFOR_ALL_S_OP_FUNC_F(scalar, SumMag, +=, mag, Type, f)
 428         return SumMag;
 429     }
 430     else
 431     {
 432         return 0.0;
 433     }
 434 }
 435
 436 TMP_UNARY_FUNCTION(scalar, sumMag)
 437
 438
 439 template<class Type>
 440 Type sumCmptMag(const UList<Type>& f)
 441 {
 442     if (f.size())
 443     {
 444         Type SumMag = pTraits<Type>::zero;
 445         TFOR_ALL_S_OP_FUNC_F(scalar, SumMag, +=, cmptMag, Type, f)
 446         return SumMag;
 447     }
 448     else
 449     {
 450         return pTraits<Type>::zero;
 451     }
 452 }
 453
 454 TMP_UNARY_FUNCTION(Type, sumCmptMag)
 455
 456 template<class Type>
 457 Type average(const UList<Type>& f)
 458 {
 459     if (f.size())
 460     {
 461         Type avrg = sum(f)/f.size();
 462
 463         return avrg;
 464     }
 465     else
 466     {
 467         WarningIn("average(const UList<Type>&)")
 468             << "empty field, returning zero" << endl;
 469
 470         return pTraits<Type>::zero;
 471     }
 472 }
 473
 474 TMP_UNARY_FUNCTION(Type, average)
 475
 476
 477 #define G_UNARY_FUNCTION(ReturnType, gFunc, Func, rFunc)                      \
 478                                                                               \
 479 template<class Type>                                                          \
 480 ReturnType gFunc(const UList<Type>& f)                                        \
 481 {                                                                             \
 482     ReturnType res = Func(f);                                                 \
 483     reduce(res, rFunc##Op<Type>());                                           \
 484     return res;                                                               \
 485 }                                                                             \
 486 TMP_UNARY_FUNCTION(ReturnType, gFunc)
 487
 488 G_UNARY_FUNCTION(Type, gMax, max, max)
 489 G_UNARY_FUNCTION(Type, gMin, min, min)
 490 G_UNARY_FUNCTION(Type, gSum, sum, sum)
 491 G_UNARY_FUNCTION(scalar, gSumSqr, sumSqr, sum)
 492 G_UNARY_FUNCTION(scalar, gSumMag, sumMag, sum)
 493 G_UNARY_FUNCTION(Type, gSumCmptMag, sumCmptMag, sum)
 494
 495 #undef G_UNARY_FUNCTION
 496
 497 template<class Type>
 498 scalar gSumProd(const UList<Type>& f1, const UList<Type>& f2)
 499 {
 500     scalar SumProd = sumProd(f1, f2);
 501     reduce(SumProd, sumOp<Type>());
 502     return SumProd;
 503 }
 504
 505 template<class Type>
 506 Type gSumCmptProd(const UList<Type>& f1, const UList<Type>& f2)
 507 {
 508     Type SumProd = sumCmptProd(f1, f2);
 509     reduce(SumProd, sumOp<Type>());
 510     return SumProd;
 511 }
 512
 513 template<class Type>
 514 Type gAverage(const UList<Type>& f)
 515 {
 516     label n = f.size();
 517     reduce(n, sumOp<label>());
 518
 519     if (n > 0)
 520     {
 521         Type avrg = gSum(f)/n;
 522
 523         return avrg;
 524     }
 525     else
 526     {
 527         WarningIn("gAverage(const UList<Type>&)")
 528             << "empty field, returning zero." << endl;
 529
 530         return pTraits<Type>::zero;
 531     }
 532 }
 533
 534 TMP_UNARY_FUNCTION(Type, gAverage)
 535
 536 #undef TMP_UNARY_FUNCTION
 537
 538
 539 BINARY_FUNCTION(Type, Type, Type, max)
 540 BINARY_FUNCTION(Type, Type, Type, min)
 541 BINARY_FUNCTION(Type, Type, Type, cmptMultiply)
 542 BINARY_FUNCTION(Type, Type, Type, cmptDivide)
 543
 544 BINARY_TYPE_FUNCTION(Type, Type, Type, max)
 545 BINARY_TYPE_FUNCTION(Type, Type, Type, min)
 546 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
 547 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
 548
 549
 550 /* * * * * * * * * * * * * * * * Global operators  * * * * * * * * * * * * * */
 551
 552 UNARY_OPERATOR(Type, Type, -, negate)
 553
 554 BINARY_OPERATOR(Type, Type, scalar, *, multiply)
 555 BINARY_OPERATOR(Type, scalar, Type, *, multiply)
 556 BINARY_OPERATOR(Type, Type, scalar, /, divide)
 557
 558 BINARY_TYPE_OPERATOR_SF(Type, scalar, Type, *, multiply)
 559 BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, *, multiply)
 560
 561 BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, divide)
 562
 563
 564 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 565
 566 #define PRODUCT_OPERATOR(product, Op, OpFunc)                                 \
 567                                                                               \
 568 template<class Type1, class Type2>                                            \
 569 void OpFunc                                                                   \
 570 (                                                                             \
 571     Field<typename product<Type1, Type2>::type>& res,                         \
 572     const UList<Type1>& f1,                                                   \
 573     const UList<Type2>& f2                                                    \
 574 )                                                                             \
 575 {                                                                             \
 576     typedef typename product<Type1, Type2>::type productType;                 \
 577     TFOR_ALL_F_OP_F_OP_F(productType, res, =, Type1, f1, Op, Type2, f2)       \
 578 }                                                                             \
 579                                                                               \
 580 template<class Type1, class Type2>                                            \
 581 tmp<Field<typename product<Type1, Type2>::type> >                             \
 582 operator Op(const UList<Type1>& f1, const UList<Type2>& f2)                   \
 583 {                                                                             \
 584     typedef typename product<Type1, Type2>::type productType;                 \
 585     tmp<Field<productType> > tRes(new Field<productType>(f1.size()));         \
 586     OpFunc(tRes(), f1, f2);                                                   \
 587     return tRes;                                                              \
 588 }                                                                             \
 589                                                                               \
 590 template<class Type1, class Type2>                                            \
 591 tmp<Field<typename product<Type1, Type2>::type> >                             \
 592 operator Op(const UList<Type1>& f1, const tmp<Field<Type2> >& tf2)            \
 593 {                                                                             \
 594     typedef typename product<Type1, Type2>::type productType;                 \
 595     tmp<Field<productType> > tRes = reuseTmp<productType, Type2>::New(tf2);   \
 596     OpFunc(tRes(), f1, tf2());                                                \
 597     reuseTmp<productType, Type2>::clear(tf2);                                 \
 598     return tRes;                                                              \
 599 }                                                                             \
 600                                                                               \
 601 template<class Type1, class Type2>                                            \
 602 tmp<Field<typename product<Type1, Type2>::type> >                             \
 603 operator Op(const tmp<Field<Type1> >& tf1, const UList<Type2>& f2)            \
 604 {                                                                             \
 605     typedef typename product<Type1, Type2>::type productType;                 \
 606     tmp<Field<productType> > tRes = reuseTmp<productType, Type1>::New(tf1);   \
 607     OpFunc(tRes(), tf1(), f2);                                                \
 608     reuseTmp<productType, Type1>::clear(tf1);                                 \
 609     return tRes;                                                              \
 610 }                                                                             \
 611                                                                               \
 612 template<class Type1, class Type2>                                            \
 613 tmp<Field<typename product<Type1, Type2>::type> >                             \
 614 operator Op(const tmp<Field<Type1> >& tf1, const tmp<Field<Type2> >& tf2)     \
 615 {                                                                             \
 616     typedef typename product<Type1, Type2>::type productType;                 \
 617     tmp<Field<productType> > tRes =                                           \
 618         reuseTmpTmp<productType, Type1, Type1, Type2>::New(tf1, tf2);         \
 619     OpFunc(tRes(), tf1(), tf2());                                             \
 620     reuseTmpTmp<productType, Type1, Type1, Type2>::clear(tf1, tf2);           \
 621     return tRes;                                                              \
 622 }                                                                             \
 623                                                                               \
 624 template<class Type, class Form, class Cmpt, int nCmpt>                       \
 625 void OpFunc                                                                   \
 626 (                                                                             \
 627     Field<typename product<Type, Form>::type>& res,                           \
 628     const UList<Type>& f1,                                                    \
 629     const VectorSpace<Form,Cmpt,nCmpt>& vs                                    \
 630 )                                                                             \
 631 {                                                                             \
 632     typedef typename product<Type, Form>::type productType;                   \
 633     TFOR_ALL_F_OP_F_OP_S                                                      \
 634         (productType, res, =,Type, f1, Op, Form, static_cast<const Form&>(vs))\
 635 }                                                                             \
 636                                                                               \
 637 template<class Type, class Form, class Cmpt, int nCmpt>                       \
 638 tmp<Field<typename product<Type, Form>::type> >                               \
 639 operator Op(const UList<Type>& f1, const VectorSpace<Form,Cmpt,nCmpt>& vs)    \
 640 {                                                                             \
 641     typedef typename product<Type, Form>::type productType;                   \
 642     tmp<Field<productType> > tRes(new Field<productType>(f1.size()));         \
 643     OpFunc(tRes(), f1, static_cast<const Form&>(vs));                         \
 644     return tRes;                                                              \
 645 }                                                                             \
 646                                                                               \
 647 template<class Type, class Form, class Cmpt, int nCmpt>                       \
 648 tmp<Field<typename product<Type, Form>::type> >                               \
 649 operator Op                                                                   \
 650 (                                                                             \
 651     const tmp<Field<Type> >& tf1,                                             \
 652     const VectorSpace<Form,Cmpt,nCmpt>& vs                                    \
 653 )                                                                             \
 654 {                                                                             \
 655     typedef typename product<Type, Form>::type productType;                   \
 656     tmp<Field<productType> > tRes = reuseTmp<productType, Type>::New(tf1);    \
 657     OpFunc(tRes(), tf1(), static_cast<const Form&>(vs));                      \
 658     reuseTmp<productType, Type>::clear(tf1);                                  \
 659     return tRes;                                                              \
 660 }                                                                             \
 661                                                                               \
 662 template<class Form, class Cmpt, int nCmpt, class Type>                       \
 663 void OpFunc                                                                   \
 664 (                                                                             \
 665     Field<typename product<Form, Type>::type>& res,                           \
 666     const VectorSpace<Form,Cmpt,nCmpt>& vs,                                   \
 667     const UList<Type>& f1                                                     \
 668 )                                                                             \
 669 {                                                                             \
 670     typedef typename product<Form, Type>::type productType;                   \
 671     TFOR_ALL_F_OP_S_OP_F                                                      \
 672         (productType, res, =,Form,static_cast<const Form&>(vs), Op, Type, f1) \
 673 }                                                                             \
 674                                                                               \
 675 template<class Form, class Cmpt, int nCmpt, class Type>                       \
 676 tmp<Field<typename product<Form, Type>::type> >                               \
 677 operator Op(const VectorSpace<Form,Cmpt,nCmpt>& vs, const UList<Type>& f1)    \
 678 {                                                                             \
 679     typedef typename product<Form, Type>::type productType;                   \
 680     tmp<Field<productType> > tRes(new Field<productType>(f1.size()));         \
 681     OpFunc(tRes(), static_cast<const Form&>(vs), f1);                         \
 682     return tRes;                                                              \
 683 }                                                                             \
 684                                                                               \
 685 template<class Form, class Cmpt, int nCmpt, class Type>                       \
 686 tmp<Field<typename product<Form, Type>::type> >                               \
 687 operator Op                                                                   \
 688 (                                                                             \
 689     const VectorSpace<Form,Cmpt,nCmpt>& vs, const tmp<Field<Type> >& tf1      \
 690 )                                                                             \
 691 {                                                                             \
 692     typedef typename product<Form, Type>::type productType;                   \
 693     tmp<Field<productType> > tRes = reuseTmp<productType, Type>::New(tf1);    \
 694     OpFunc(tRes(), static_cast<const Form&>(vs), tf1());                      \
 695     reuseTmp<productType, Type>::clear(tf1);                                  \
 696     return tRes;                                                              \
 697 }
 698
 699 PRODUCT_OPERATOR(typeOfSum, +, add)
 700 PRODUCT_OPERATOR(typeOfSum, -, subtract)
 701
 702 PRODUCT_OPERATOR(outerProduct, *, outer)
 703 PRODUCT_OPERATOR(crossProduct, ^, cross)
 704 PRODUCT_OPERATOR(innerProduct, &, dot)
 705 PRODUCT_OPERATOR(scalarProduct, &&, dotdot)
 706
 707 #undef PRODUCT_OPERATOR
 708
 709
 710 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 711
 712 } // End namespace Foam
 713
 714 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 715
 716 #include "undefFieldFunctionsM.H"
 717
 718 // ************************************************************************* //