src/errorEstimation/errorEstimate/errorEstimate.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 "errorEstimate.H"
  28 #include "zeroGradientFvPatchField.H"
  29 #include "fixedValueFvPatchField.H"
  30
  31 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  32
  33
  34 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  35
  36 template<class Type>
  37 Foam::wordList Foam::errorEstimate<Type>::errorBCTypes() const
  38 {
  39     // Make the boundary condition type list
  40     // Default types get over-ridden anyway
  41     wordList ebct
  42     (
  43         psi_.boundaryField().size(),
  44         zeroGradientFvPatchField<Type>::typeName
  45     );
  46
  47     forAll (psi_.boundaryField(), patchI)
  48     {
  49         if (psi_.boundaryField()[patchI].fixesValue())
  50         {
  51             ebct[patchI] = fixedValueFvPatchField<Type>::typeName;
  52         }
  53     }
  54
  55     return ebct;
  56 }
  57
  58
  59 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  60
  61 // Construct from components
  62 template<class Type>
  63 Foam::errorEstimate<Type>::errorEstimate
  64 (
  65     const GeometricField<Type, fvPatchField, volMesh>& psi,
  66     const dimensionSet& ds,
  67     const Field<Type>& res,
  68     const scalarField& norm
  69 )
  70 :
  71     psi_(psi),
  72     dimensions_(ds),
  73     residual_(res),
  74     normFactor_(norm)
  75 {}
  76
  77
  78 // Construct as copy
  79 template<class Type>
  80 Foam::errorEstimate<Type>::errorEstimate(const Foam::errorEstimate<Type>& ee)
  81 :
  82     refCount(),
  83     psi_(ee.psi_),
  84     dimensions_(ee.dimensions_),
  85     residual_(ee.residual_),
  86     normFactor_(ee.normFactor_)
  87 {}
  88
  89
  90 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
  91
  92 template<class Type>
  93 Foam::errorEstimate<Type>::~errorEstimate()
  94 {}
  95
  96
  97 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  98
  99 template<class Type>
 100 Foam::tmp<Foam::GeometricField<Type, Foam::fvPatchField, Foam::volMesh> >
 101 Foam::errorEstimate<Type>::residual() const
 102 {
 103     tmp<GeometricField<Type, fvPatchField, volMesh> > tres
 104     (
 105         new GeometricField<Type, fvPatchField, volMesh>
 106         (
 107             IOobject
 108             (
 109                 "residual" + psi_.name(),
 110                 psi_.mesh().time().timeName(),
 111                 psi_.db(),
 112                 IOobject::NO_READ,
 113                 IOobject::NO_WRITE
 114             ),
 115             psi_.mesh(),
 116             psi_.dimensions()/dimTime,
 117             errorBCTypes()
 118         )
 119     );
 120
 121     GeometricField<Type, fvPatchField, volMesh>& res = tres();
 122
 123     res.internalField() = residual_;
 124     res.boundaryField() == pTraits<Type>::zero;
 125
 126     res.correctBoundaryConditions();
 127
 128     return tres;
 129 }
 130
 131
 132 template<class Type>
 133 Foam::tmp<Foam::volScalarField> Foam::errorEstimate<Type>::normFactor() const
 134 {
 135     tmp<volScalarField> tnormFactor
 136     (
 137         new volScalarField
 138         (
 139             IOobject
 140             (
 141                 "normFactor" + psi_.name(),
 142                 psi_.mesh().time().timeName(),
 143                 psi_.db(),
 144                 IOobject::NO_READ,
 145                 IOobject::NO_WRITE
 146             ),
 147             psi_.mesh(),
 148             dimless/dimTime,
 149             errorBCTypes()
 150         )
 151     );
 152
 153     volScalarField& normFactor = tnormFactor();
 154
 155     normFactor.internalField() = normFactor_;
 156     normFactor.boundaryField() == pTraits<Type>::zero;
 157
 158     normFactor.correctBoundaryConditions();
 159
 160     return tnormFactor;
 161 }
 162
 163 template<class Type>
 164 Foam::tmp<Foam::GeometricField<Type, Foam::fvPatchField, Foam::volMesh> >
 165 Foam::errorEstimate<Type>::error() const
 166 {
 167     tmp<GeometricField<Type, fvPatchField, volMesh> > tresError
 168     (
 169         new GeometricField<Type, fvPatchField, volMesh>
 170         (
 171             IOobject
 172             (
 173                 "resError" + psi_.name(),
 174                 psi_.mesh().time().timeName(),
 175                 psi_.db(),
 176                 IOobject::NO_READ,
 177                 IOobject::NO_WRITE
 178             ),
 179             psi_.mesh(),
 180             psi_.dimensions(),
 181             errorBCTypes()
 182         )
 183     );
 184
 185     GeometricField<Type, fvPatchField, volMesh>& resError = tresError();
 186
 187     resError.internalField() = residual_/normFactor_;
 188     resError.boundaryField() == pTraits<Type>::zero;
 189
 190     resError.correctBoundaryConditions();
 191
 192     return tresError;
 193 }
 194
 195 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 196
 197 template<class Type>
 198 void Foam::errorEstimate<Type>::operator=(const Foam::errorEstimate<Type>& rhs)
 199 {
 200     // Check for assignment to self
 201     if (this == &rhs)
 202     {
 203         FatalErrorIn
 204         (
 205             "errorEstimate<Type>::operator=(const Foam::errorEstimate<Type>&)"
 206         )   << "Attempted assignment to self"
 207             << abort(FatalError);
 208     }
 209
 210     if (&psi_ != &(rhs.psi_))
 211     {
 212         FatalErrorIn
 213         (
 214             "errorEstimate<Type>::operator=(const errorEstimate<Type>&)"
 215         )   << "different fields"
 216             << abort(FatalError);
 217     }
 218
 219     residual_ = rhs.residual_;
 220     normFactor_ = rhs.normFactor_;
 221 }
 222
 223
 224 template<class Type>
 225 void Foam::errorEstimate<Type>::operator=(const tmp<errorEstimate<Type> >& teev)
 226 {
 227     operator=(teev());
 228     teev.clear();
 229 }
 230
 231
 232 template<class Type>
 233 void Foam::errorEstimate<Type>::negate()
 234 {
 235     residual_.negate();
 236 }
 237
 238
 239 template<class Type>
 240 void Foam::errorEstimate<Type>::operator+=(const errorEstimate<Type>& eev)
 241 {
 242     checkMethod(*this, eev, "+=");
 243
 244     dimensions_ += eev.dimensions_;
 245
 246     residual_ += eev.residual_;
 247     normFactor_ += eev.normFactor_;
 248 }
 249
 250
 251 template<class Type>
 252 void Foam::errorEstimate<Type>::operator+=
 253 (
 254     const tmp<errorEstimate<Type> >& teev
 255 )
 256 {
 257     operator+=(teev());
 258     teev.clear();
 259 }
 260
 261
 262 template<class Type>
 263 void Foam::errorEstimate<Type>::operator-=(const errorEstimate<Type>& eev)
 264 {
 265     checkMethod(*this, eev, "+=");
 266
 267     dimensions_ -= eev.dimensions_;
 268     residual_ -= eev.residual_;
 269     normFactor_ += eev.normFactor_;
 270 }
 271
 272
 273 template<class Type>
 274 void Foam::errorEstimate<Type>::operator-=(const tmp<errorEstimate<Type> >& teev)
 275 {
 276     operator-=(teev());
 277     teev.clear();
 278 }
 279
 280
 281 template<class Type>
 282 void Foam::errorEstimate<Type>::operator+=
 283 (
 284     const GeometricField<Type, fvPatchField, volMesh>& su
 285 )
 286 {
 287     checkMethod(*this, su, "+=");
 288     residual_ -= su.internalField();
 289 }
 290
 291
 292 template<class Type>
 293 void Foam::errorEstimate<Type>::operator+=
 294 (
 295     const tmp<GeometricField<Type, fvPatchField, volMesh> >& tsu
 296 )
 297 {
 298     operator+=(tsu());
 299     tsu.clear();
 300 }
 301
 302
 303 template<class Type>
 304 void Foam::errorEstimate<Type>::operator-=
 305 (
 306     const GeometricField<Type, fvPatchField, volMesh>& su
 307 )
 308 {
 309     checkMethod(*this, su, "-=");
 310     residual_ += su.internalField();
 311 }
 312
 313
 314 template<class Type>
 315 void Foam::errorEstimate<Type>::operator-=
 316 (
 317     const tmp<GeometricField<Type, fvPatchField, volMesh> >& tsu
 318 )
 319 {
 320     operator-=(tsu());
 321     tsu.clear();
 322 }
 323
 324
 325 template<class Type>
 326 void Foam::errorEstimate<Type>::operator+=
 327 (
 328     const dimensioned<Type>& su
 329 )
 330 {
 331     residual_ -= su;
 332 }
 333
 334
 335 template<class Type>
 336 void Foam::errorEstimate<Type>::operator-=
 337 (
 338     const dimensioned<Type>& su
 339 )
 340 {
 341     residual_ += su;
 342 }
 343
 344
 345 template<class Type>
 346 void Foam::errorEstimate<Type>::operator*=
 347 (
 348     const volScalarField& vsf
 349 )
 350 {
 351     dimensions_ *= vsf.dimensions();
 352     residual_ *= vsf.internalField();
 353     normFactor_ *= vsf.internalField();
 354 }
 355
 356
 357 template<class Type>
 358 void Foam::errorEstimate<Type>::operator*=
 359 (
 360     const tmp<volScalarField>& tvsf
 361 )
 362 {
 363     operator*=(tvsf());
 364     tvsf.clear();
 365 }
 366
 367
 368 template<class Type>
 369 void Foam::errorEstimate<Type>::operator*=
 370 (
 371     const dimensioned<scalar>& ds
 372 )
 373 {
 374     dimensions_ *= ds.dimensions();
 375     residual_ *= ds.value();
 376     normFactor_ *= ds.value();
 377 }
 378
 379
 380 // * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
 381
 382 template<class Type>
 383 void Foam::checkMethod
 384 (
 385     const errorEstimate<Type>& ee1,
 386     const errorEstimate<Type>& ee2,
 387     const char* op
 388 )
 389 {
 390     if (&ee1.psi() != &ee2.psi())
 391     {
 392         FatalErrorIn
 393         (
 394             "checkMethod(const errorEstimate<Type>&, "
 395             "const errorEstimate<Type>&)"
 396         )   << "incompatible fields for operation "
 397             << endl << "    "
 398             << "[" << ee1.psi().name() << "] "
 399             << op
 400             << " [" << ee2.psi().name() << "]"
 401             << abort(FatalError);
 402     }
 403
 404     if (dimensionSet::debug && ee1.dimensions() != ee2.dimensions())
 405     {
 406         FatalErrorIn
 407         (
 408             "checkMethod(const errorEstimate<Type>&, "
 409             "const errorEstimate<Type>&)"
 410         )   << "incompatible dimensions for operation "
 411             << endl << "    "
 412             << "[" << ee1.psi().name() << ee1.dimensions()/dimVolume << " ] "
 413             << op
 414             << " [" << ee2.psi().name() << ee2.dimensions()/dimVolume << " ]"
 415             << abort(FatalError);
 416     }
 417 }
 418
 419
 420 template<class Type>
 421 void Foam::checkMethod
 422 (
 423     const errorEstimate<Type>& ee,
 424     const GeometricField<Type, fvPatchField, volMesh>& vf,
 425     const char* op
 426 )
 427 {
 428     if (dimensionSet::debug && ee.dimensions()/dimVolume != vf.dimensions())
 429     {
 430         FatalErrorIn
 431         (
 432             "checkMethod(const errorEstimate<Type>&, "
 433             "const GeometricField<Type, fvPatchField, volMesh>&)"
 434         )   <<  "incompatible dimensions for operation "
 435             << endl << "    "
 436             << "[" << ee.psi().name() << ee.dimensions()/dimVolume << " ] "
 437             << op
 438             << " [" << vf.name() << vf.dimensions() << " ]"
 439             << abort(FatalError);
 440     }
 441 }
 442
 443
 444 template<class Type>
 445 void Foam::checkMethod
 446 (
 447     const errorEstimate<Type>& ee,
 448     const dimensioned<Type>& dt,
 449     const char* op
 450 )
 451 {
 452     if (dimensionSet::debug && ee.dimensions()/dimVolume != dt.dimensions())
 453     {
 454         FatalErrorIn
 455         (
 456             "checkMethod(const errorEstimate<Type>&, const dimensioned<Type>&)"
 457         )   << "incompatible dimensions for operation "
 458             << endl << "    "
 459             << "[" << ee.psi().name() << ee.dimensions()/dimVolume << " ] "
 460             << op
 461             << " [" << dt.name() << dt.dimensions() << " ]"
 462             << abort(FatalError);
 463     }
 464 }
 465
 466
 467 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 468
 469 namespace Foam
 470 {
 471
 472 template<class Type>
 473 tmp<errorEstimate<Type> > operator+
 474 (
 475     const errorEstimate<Type>& A,
 476     const errorEstimate<Type>& B
 477 )
 478 {
 479     checkMethod(A, B, "+");
 480     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
 481     tC() += B;
 482     return tC;
 483 }
 484
 485
 486 template<class Type>
 487 tmp<errorEstimate<Type> > operator+
 488 (
 489     const tmp<errorEstimate<Type> >& tA,
 490     const errorEstimate<Type>& B
 491 )
 492 {
 493     checkMethod(tA(), B, "+");
 494     tmp<errorEstimate<Type> > tC(tA.ptr());
 495     tC() += B;
 496     return tC;
 497 }
 498
 499
 500 template<class Type>
 501 tmp<errorEstimate<Type> > operator+
 502 (
 503     const errorEstimate<Type>& A,
 504     const tmp<errorEstimate<Type> >& tB
 505 )
 506 {
 507     checkMethod(A, tB(), "+");
 508     tmp<errorEstimate<Type> > tC(tB.ptr());
 509     tC() += A;
 510     return tC;
 511 }
 512
 513
 514 template<class Type>
 515 tmp<errorEstimate<Type> > operator+
 516 (
 517     const tmp<errorEstimate<Type> >& tA,
 518     const tmp<errorEstimate<Type> >& tB
 519 )
 520 {
 521     checkMethod(tA(), tB(), "+");
 522     tmp<errorEstimate<Type> > tC(tA.ptr());
 523     tC() += tB();
 524     tB.clear();
 525     return tC;
 526 }
 527
 528
 529 template<class Type>
 530 tmp<errorEstimate<Type> > operator-
 531 (
 532     const errorEstimate<Type>& A
 533 )
 534 {
 535     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
 536     tC().negate();
 537     return tC;
 538 }
 539
 540
 541 template<class Type>
 542 tmp<errorEstimate<Type> > operator-
 543 (
 544     const tmp<errorEstimate<Type> >& tA
 545 )
 546 {
 547     tmp<errorEstimate<Type> > tC(tA.ptr());
 548     tC().negate();
 549     return tC;
 550 }
 551
 552
 553 template<class Type>
 554 tmp<errorEstimate<Type> > operator-
 555 (
 556     const errorEstimate<Type>& A,
 557     const errorEstimate<Type>& B
 558 )
 559 {
 560     checkMethod(A, B, "-");
 561     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
 562     tC() -= B;
 563     return tC;
 564 }
 565
 566
 567 template<class Type>
 568 tmp<errorEstimate<Type> > operator-
 569 (
 570     const tmp<errorEstimate<Type> >& tA,
 571     const errorEstimate<Type>& B
 572 )
 573 {
 574     checkMethod(tA(), B, "-");
 575     tmp<errorEstimate<Type> > tC(tA.ptr());
 576     tC() -= B;
 577     return tC;
 578 }
 579
 580
 581 template<class Type>
 582 tmp<errorEstimate<Type> > operator-
 583 (
 584     const errorEstimate<Type>& A,
 585     const tmp<errorEstimate<Type> >& tB
 586 )
 587 {
 588     checkMethod(A, tB(), "-");
 589     tmp<errorEstimate<Type> > tC(tB.ptr());
 590     tC() -= A;
 591     tC().negate();
 592     return tC;
 593 }
 594
 595
 596 template<class Type>
 597 tmp<errorEstimate<Type> > operator-
 598 (
 599     const tmp<errorEstimate<Type> >& tA,
 600     const tmp<errorEstimate<Type> >& tB
 601 )
 602 {
 603     checkMethod(tA(), tB(), "-");
 604     tmp<errorEstimate<Type> > tC(tA.ptr());
 605     tC() -= tB();
 606     tB.clear();
 607     return tC;
 608 }
 609
 610
 611 template<class Type>
 612 tmp<errorEstimate<Type> > operator==
 613 (
 614     const errorEstimate<Type>& A,
 615     const errorEstimate<Type>& B
 616 )
 617 {
 618     checkMethod(A, B, "==");
 619     return (A - B);
 620 }
 621
 622
 623 template<class Type>
 624 tmp<errorEstimate<Type> > operator==
 625 (
 626     const tmp<errorEstimate<Type> >& tA,
 627     const errorEstimate<Type>& B
 628 )
 629 {
 630     checkMethod(tA(), B, "==");
 631     return (tA - B);
 632 }
 633
 634
 635 template<class Type>
 636 tmp<errorEstimate<Type> > operator==
 637 (
 638     const errorEstimate<Type>& A,
 639     const tmp<errorEstimate<Type> >& tB
 640 )
 641 {
 642     checkMethod(A, tB(), "==");
 643     return (A - tB);
 644 }
 645
 646
 647 template<class Type>
 648 tmp<errorEstimate<Type> > operator==
 649 (
 650     const tmp<errorEstimate<Type> >& tA,
 651     const tmp<errorEstimate<Type> >& tB
 652 )
 653 {
 654     checkMethod(tA(), tB(), "==");
 655     return (tA - tB);
 656 }
 657
 658
 659 template<class Type>
 660 tmp<errorEstimate<Type> > operator+
 661 (
 662     const errorEstimate<Type>& A,
 663     const GeometricField<Type, fvPatchField, volMesh>& su
 664 )
 665 {
 666     checkMethod(A, su, "+");
 667     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
 668     tC().res() -= su.internalField();
 669     return tC;
 670 }
 671
 672 template<class Type>
 673 tmp<errorEstimate<Type> > operator+
 674 (
 675     const tmp<errorEstimate<Type> >& tA,
 676     const GeometricField<Type, fvPatchField, volMesh>& su
 677 )
 678 {
 679     checkMethod(tA(), su, "+");
 680     tmp<errorEstimate<Type> > tC(tA.ptr());
 681     tC().res() -= su.internalField();
 682     return tC;
 683 }
 684
 685 template<class Type>
 686 tmp<errorEstimate<Type> > operator+
 687 (
 688     const errorEstimate<Type>& A,
 689     const tmp<GeometricField<Type, fvPatchField, volMesh> >& tsu
 690 )
 691 {
 692     checkMethod(A, tsu(), "+");
 693     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
 694     tC().res() -= tsu().internalField();
 695     tsu.clear();
 696     return tC;
 697 }
 698
 699
 700 template<class Type>
 701 tmp<errorEstimate<Type> > operator+
 702 (
 703     const tmp<errorEstimate<Type> >& tA,
 704     const tmp<GeometricField<Type, fvPatchField, volMesh> >& tsu
 705 )
 706 {
 707     checkMethod(tA(), tsu(), "+");
 708     tmp<errorEstimate<Type> > tC(tA.ptr());
 709     tC().res() -= tsu().internalField();
 710     tsu.clear();
 711     return tC;
 712 }
 713
 714 template<class Type>
 715 tmp<errorEstimate<Type> > operator+
 716 (
 717     const GeometricField<Type, fvPatchField, volMesh>& su,
 718     const errorEstimate<Type>& A
 719 )
 720 {
 721     checkMethod(A, su, "+");
 722     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
 723     tC().res() -= su.internalField();
 724     return tC;
 725 }
 726
 727 template<class Type>
 728 tmp<errorEstimate<Type> > operator+
 729 (
 730     const GeometricField<Type, fvPatchField, volMesh>& su,
 731     const tmp<errorEstimate<Type> >& tA
 732 )
 733 {
 734     checkMethod(tA(), su, "+");
 735     tmp<errorEstimate<Type> > tC(tA.ptr());
 736     tC().res() -= su.internalField();
 737     return tC;
 738 }
 739
 740 template<class Type>
 741 tmp<errorEstimate<Type> > operator+
 742 (
 743     const tmp<GeometricField<Type, fvPatchField, volMesh> >& tsu,
 744     const errorEstimate<Type>& A
 745 )
 746 {
 747     checkMethod(A, tsu(), "+");
 748     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
 749     tC().res() -= tsu().internalField();
 750     tsu.clear();
 751     return tC;
 752 }
 753
 754 template<class Type>
 755 tmp<errorEstimate<Type> > operator+
 756 (
 757     const tmp<GeometricField<Type, fvPatchField, volMesh> >& tsu,
 758     const tmp<errorEstimate<Type> >& tA
 759 )
 760 {
 761     checkMethod(tA(), tsu(), "+");
 762     tmp<errorEstimate<Type> > tC(tA.ptr());
 763     tC().res() -= tsu().internalField();
 764     tsu.clear();
 765     return tC;
 766 }
 767
 768
 769 template<class Type>
 770 tmp<errorEstimate<Type> > operator-
 771 (
 772     const errorEstimate<Type>& A,
 773     const GeometricField<Type, fvPatchField, volMesh>& su
 774 )
 775 {
 776     checkMethod(A, su, "-");
 777     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
 778     tC().res() += su.internalField();
 779     return tC;
 780 }
 781
 782 template<class Type>
 783 tmp<errorEstimate<Type> > operator-
 784 (
 785     const tmp<errorEstimate<Type> >& tA,
 786     const GeometricField<Type, fvPatchField, volMesh>& su
 787 )
 788 {
 789     checkMethod(tA(), su, "-");
 790     tmp<errorEstimate<Type> > tC(tA.ptr());
 791     tC().res() += su.internalField();
 792     return tC;
 793 }
 794
 795 template<class Type>
 796 tmp<errorEstimate<Type> > operator-
 797 (
 798     const errorEstimate<Type>& A,
 799     const tmp<GeometricField<Type, fvPatchField, volMesh> >& tsu
 800 )
 801 {
 802     checkMethod(A, tsu(), "-");
 803     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
 804     tC().res() += tsu().internalField();
 805     tsu.clear();
 806     return tC;
 807 }
 808
 809 template<class Type>
 810 tmp<errorEstimate<Type> > operator-
 811 (
 812     const tmp<errorEstimate<Type> >& tA,
 813     const tmp<GeometricField<Type, fvPatchField, volMesh> >& tsu
 814 )
 815 {
 816     checkMethod(tA(), tsu(), "-");
 817     tmp<errorEstimate<Type> > tC(tA.ptr());
 818     tC().res() += tsu().internalField();
 819     tsu.clear();
 820     return tC;
 821 }
 822
 823
 824 template<class Type>
 825 tmp<errorEstimate<Type> > operator-
 826 (
 827     const GeometricField<Type, fvPatchField, volMesh>& su,
 828     const errorEstimate<Type>& A
 829 )
 830 {
 831     checkMethod(A, su, "-");
 832     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
 833     tC().negate();
 834     tC().res() -= su.internalField();
 835     return tC;
 836 }
 837
 838
 839 template<class Type>
 840 tmp<errorEstimate<Type> > operator-
 841 (
 842     const GeometricField<Type, fvPatchField, volMesh>& su,
 843     const tmp<errorEstimate<Type> >& tA
 844 )
 845 {
 846     checkMethod(tA(), su, "-");
 847     tmp<errorEstimate<Type> > tC(tA.ptr());
 848     tC().negate();
 849     tC().res() -= su.internalField();
 850     return tC;
 851 }
 852
 853 template<class Type>
 854 tmp<errorEstimate<Type> > operator-
 855 (
 856     const tmp<GeometricField<Type, fvPatchField, volMesh> >& tsu,
 857     const errorEstimate<Type>& A
 858 )
 859 {
 860     checkMethod(A, tsu(), "-");
 861     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
 862     tC().negate();
 863     tC().res() -= tsu().internalField();
 864     tsu.clear();
 865     return tC;
 866 }
 867
 868
 869 template<class Type>
 870 tmp<errorEstimate<Type> > operator-
 871 (
 872     const tmp<GeometricField<Type, fvPatchField, volMesh> >& tsu,
 873     const tmp<errorEstimate<Type> >& tA
 874 )
 875 {
 876     checkMethod(tA(), tsu(), "-");
 877     tmp<errorEstimate<Type> > tC(tA.ptr());
 878     tC().negate();
 879     tC().res() -= tsu().internalField();
 880     tsu.clear();
 881     return tC;
 882 }
 883
 884
 885 template<class Type>
 886 tmp<errorEstimate<Type> > operator+
 887 (
 888     const errorEstimate<Type>& A,
 889     const dimensioned<Type>& su
 890 )
 891 {
 892     checkMethod(A, su, "+");
 893     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
 894     tC().res() -= su.value();
 895     return tC;
 896 }
 897
 898
 899 template<class Type>
 900 tmp<errorEstimate<Type> > operator+
 901 (
 902     const tmp<errorEstimate<Type> >& tA,
 903     const dimensioned<Type>& su
 904 )
 905 {
 906     checkMethod(tA(), su, "+");
 907     tmp<errorEstimate<Type> > tC(tA.ptr());
 908     tC().res() -= su.value();
 909     return tC;
 910 }
 911
 912
 913 template<class Type>
 914 tmp<errorEstimate<Type> > operator+
 915 (
 916     const dimensioned<Type>& su,
 917     const errorEstimate<Type>& A
 918 )
 919 {
 920     checkMethod(A, su, "+");
 921     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
 922     tC().res() -= su.value();
 923     return tC;
 924 }
 925
 926
 927 template<class Type>
 928 tmp<errorEstimate<Type> > operator+
 929 (
 930     const dimensioned<Type>& su,
 931     const tmp<errorEstimate<Type> >& tA
 932 )
 933 {
 934     checkMethod(tA(), su, "+");
 935     tmp<errorEstimate<Type> > tC(tA.ptr());
 936     tC().res() -= su.value();
 937     return tC;
 938 }
 939
 940
 941 template<class Type>
 942 tmp<errorEstimate<Type> > operator-
 943 (
 944     const errorEstimate<Type>& A,
 945     const dimensioned<Type>& su
 946 )
 947 {
 948     checkMethod(A, su, "-");
 949     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
 950     tC().res() += su.value();
 951     return tC;
 952 }
 953
 954
 955 template<class Type>
 956 tmp<errorEstimate<Type> > operator-
 957 (
 958     const tmp<errorEstimate<Type> >& tA,
 959     const dimensioned<Type>& su
 960 )
 961 {
 962     checkMethod(tA(), su, "-");
 963     tmp<errorEstimate<Type> > tC(tA.ptr());
 964     tC().res() += su.value();
 965     return tC;
 966 }
 967
 968
 969 template<class Type>
 970 tmp<errorEstimate<Type> > operator-
 971 (
 972     const dimensioned<Type>& su,
 973     const errorEstimate<Type>& A
 974 )
 975 {
 976     checkMethod(A, su, "-");
 977     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
 978     tC().negate();
 979     tC().res() -= su.value();
 980     return tC;
 981 }
 982
 983
 984 template<class Type>
 985 tmp<errorEstimate<Type> > operator-
 986 (
 987     const dimensioned<Type>& su,
 988     const tmp<errorEstimate<Type> >& tA
 989 )
 990 {
 991     checkMethod(tA(), su, "-");
 992     tmp<errorEstimate<Type> > tC(tA.ptr());
 993     tC().negate();
 994     tC().res() -= su.value();
 995     return tC;
 996 }
 997
 998
 999 template<class Type>
1000 tmp<errorEstimate<Type> > operator==
1001 (
1002     const errorEstimate<Type>& A,
1003     const GeometricField<Type, fvPatchField, volMesh>& su
1004 )
1005 {
1006     checkMethod(A, su, "==");
1007     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
1008     tC().res() += su.internalField();
1009     return tC;
1010 }
1011
1012 template<class Type>
1013 tmp<errorEstimate<Type> > operator==
1014 (
1015     const tmp<errorEstimate<Type> >& tA,
1016     const GeometricField<Type, fvPatchField, volMesh>& su
1017 )
1018 {
1019     checkMethod(tA(), su, "==");
1020     tmp<errorEstimate<Type> > tC(tA.ptr());
1021     tC().res() += su.internalField();
1022     return tC;
1023 }
1024
1025 template<class Type>
1026 tmp<errorEstimate<Type> > operator==
1027 (
1028     const errorEstimate<Type>& A,
1029     const tmp<GeometricField<Type, fvPatchField, volMesh> >& tsu
1030 )
1031 {
1032     checkMethod(A, tsu(), "==");
1033     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
1034     tC().res() += tsu().internalField();
1035     tsu.clear();
1036     return tC;
1037 }
1038
1039 template<class Type>
1040 tmp<errorEstimate<Type> > operator==
1041 (
1042     const tmp<errorEstimate<Type> >& tA,
1043     const tmp<GeometricField<Type, fvPatchField, volMesh> >& tsu
1044 )
1045 {
1046     checkMethod(tA(), tsu(), "==");
1047     tmp<errorEstimate<Type> > tC(tA.ptr());
1048     tC().res() += tsu().internalField();
1049     tsu.clear();
1050     return tC;
1051 }
1052
1053
1054 template<class Type>
1055 tmp<errorEstimate<Type> > operator==
1056 (
1057     const errorEstimate<Type>& A,
1058     const dimensioned<Type>& su
1059 )
1060 {
1061     checkMethod(A, su, "==");
1062     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
1063     tC().res() += su.value();
1064     return tC;
1065 }
1066
1067
1068 template<class Type>
1069 tmp<errorEstimate<Type> > operator==
1070 (
1071     const tmp<errorEstimate<Type> >& tA,
1072     const dimensioned<Type>& su
1073 )
1074 {
1075     checkMethod(tA(), su, "==");
1076     tmp<errorEstimate<Type> > tC(tA.ptr());
1077     tC().res() += su.value();
1078     return tC;
1079 }
1080
1081
1082 template<class Type>
1083 tmp<errorEstimate<Type> > operator*
1084 (
1085     const volScalarField& vsf,
1086     const errorEstimate<Type>& A
1087 )
1088 {
1089     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
1090     tC() *= vsf;
1091     return tC;
1092 }
1093
1094 template<class Type>
1095 tmp<errorEstimate<Type> > operator*
1096 (
1097     const tmp<volScalarField>& tvsf,
1098     const errorEstimate<Type>& A
1099 )
1100 {
1101     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
1102     tC() *= tvsf;
1103     return tC;
1104 }
1105
1106 template<class Type>
1107 tmp<errorEstimate<Type> > operator*
1108 (
1109     const volScalarField& vsf,
1110     const tmp<errorEstimate<Type> >& tA
1111 )
1112 {
1113     tmp<errorEstimate<Type> > tC(tA.ptr());
1114     tC() *= vsf;
1115     return tC;
1116 }
1117
1118 template<class Type>
1119 tmp<errorEstimate<Type> > operator*
1120 (
1121     const tmp<volScalarField>& tvsf,
1122     const tmp<errorEstimate<Type> >& tA
1123 )
1124 {
1125     tmp<errorEstimate<Type> > tC(tA.ptr());
1126     tC() *= tvsf;
1127     return tC;
1128 }
1129
1130
1131 template<class Type>
1132 tmp<errorEstimate<Type> > operator*
1133 (
1134     const dimensioned<scalar>& ds,
1135     const errorEstimate<Type>& A
1136 )
1137 {
1138     tmp<errorEstimate<Type> > tC(new errorEstimate<Type>(A));
1139     tC() *= ds;
1140     return tC;
1141 }
1142
1143
1144 template<class Type>
1145 tmp<errorEstimate<Type> > operator*
1146 (
1147     const dimensioned<scalar>& ds,
1148     const tmp<errorEstimate<Type> >& tA
1149 )
1150 {
1151     tmp<errorEstimate<Type> > tC(tA.ptr());
1152     tC() *= ds;
1153     return tC;
1154 }
1155
1156
1157 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
1158
1159 } // End namespace Foam
1160
1161 // ************************************************************************* //