src/finiteVolume/fvMatrices/fvMatrix/fvMatrix.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 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 Class
  26     Foam::fvMatrix
  27
  28 Description
  29     Finite-Volume matrix.
  30
  31 SourceFiles
  32     fvMatrix.C
  33     fvMatrixSolve.C
  34     fvScalarMatrix.C
  35
  36 \*---------------------------------------------------------------------------*/
  37
  38 #ifndef fvMatrix_H
  39 #define fvMatrix_H
  40
  41 #include "volFields.H"
  42 #include "surfaceFields.H"
  43 #include "lduMatrix.H"
  44 #include "tmp.H"
  45 #include "autoPtr.H"
  46 #include "dimensionedTypes.H"
  47 #include "zeroField.H"
  48 #include "className.H"
  49
  50 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  51
  52 namespace Foam
  53 {
  54
  55 // Forward declaration of friend functions and operators
  56
  57 template<class Type>
  58 class fvMatrix;
  59
  60 template<class Type>
  61 tmp<GeometricField<Type, fvPatchField, volMesh> > operator&
  62 (
  63     const fvMatrix<Type>&,
  64     const DimensionedField<Type, volMesh>&
  65 );
  66
  67 template<class Type>
  68 tmp<GeometricField<Type, fvPatchField, volMesh> > operator&
  69 (
  70     const fvMatrix<Type>&,
  71     const tmp<DimensionedField<Type, volMesh> >&
  72 );
  73
  74 template<class Type>
  75 tmp<GeometricField<Type, fvPatchField, volMesh> > operator&
  76 (
  77     const fvMatrix<Type>&,
  78     const tmp<GeometricField<Type, fvPatchField, volMesh> >&
  79 );
  80
  81 template<class Type>
  82 tmp<GeometricField<Type, fvPatchField, volMesh> > operator&
  83 (
  84     const tmp<fvMatrix<Type> >&,
  85     const DimensionedField<Type, volMesh>&
  86 );
  87
  88 template<class Type>
  89 tmp<GeometricField<Type, fvPatchField, volMesh> > operator&
  90 (
  91     const tmp<fvMatrix<Type> >&,
  92     const tmp<DimensionedField<Type, volMesh> >&
  93 );
  94
  95 template<class Type>
  96 tmp<GeometricField<Type, fvPatchField, volMesh> > operator&
  97 (
  98     const tmp<fvMatrix<Type> >&,
  99     const tmp<GeometricField<Type, fvPatchField, volMesh> >&
 100 );
 101
 102 template<class Type>
 103 Ostream& operator<<(Ostream&, const fvMatrix<Type>&);
 104
 105
 106 /*---------------------------------------------------------------------------*\
 107                            Class fvMatrix Declaration
 108 \*---------------------------------------------------------------------------*/
 109
 110 template<class Type>
 111 class fvMatrix
 112 :
 113     public refCount,
 114     public lduMatrix
 115 {
 116 public:
 117
 118     // Private data
 119
 120         // Reference to GeometricField<Type, fvPatchField, volMesh>
 121         GeometricField<Type, fvPatchField, volMesh>& psi_;
 122
 123         //- Dimension set
 124         dimensionSet dimensions_;
 125
 126         //- Source term
 127         Field<Type> source_;
 128
 129         //- Boundary scalar field containing pseudo-matrix coeffs
 130         //  for internal cells
 131         FieldField<Field, Type> internalCoeffs_;
 132
 133         //- Boundary scalar field containing pseudo-matrix coeffs
 134         //  for boundary cells
 135         FieldField<Field, Type> boundaryCoeffs_;
 136
 137
 138         //- Face flux field for non-orthogonal correction
 139         mutable GeometricField<Type, fvsPatchField, surfaceMesh>
 140             *faceFluxCorrectionPtr_;
 141
 142
 143     // Private member functions
 144
 145         //- Add patch contribution to internal field
 146         template<class Type2>
 147         void addToInternalField
 148         (
 149             const unallocLabelList& addr,
 150             const Field<Type2>& pf,
 151             Field<Type2>& intf
 152         ) const;
 153
 154         template<class Type2>
 155         void addToInternalField
 156         (
 157             const unallocLabelList& addr,
 158             const tmp<Field<Type2> >& tpf,
 159             Field<Type2>& intf
 160         ) const;
 161
 162         //- Subtract patch contribution from internal field
 163         template<class Type2>
 164         void subtractFromInternalField
 165         (
 166             const unallocLabelList& addr,
 167             const Field<Type2>& pf,
 168             Field<Type2>& intf
 169         ) const;
 170
 171         template<class Type2>
 172         void subtractFromInternalField
 173         (
 174             const unallocLabelList& addr,
 175             const tmp<Field<Type2> >& tpf,
 176             Field<Type2>& intf
 177         ) const;
 178
 179
 180         // Matrix completion functionality
 181
 182             void addBoundaryDiag
 183             (
 184                 scalarField& diag,
 185                 const direction cmpt
 186             ) const;
 187
 188             void addCmptAvBoundaryDiag(scalarField& diag) const;
 189
 190             void addBoundarySource
 191             (
 192                 Field<Type>& source,
 193                 const bool couples=true
 194             ) const;
 195
 196
 197 public:
 198
 199     //- Solver class returned by the solver function
 200     //  used for systems in which it is useful to cache the solver for reuse
 201     //  e.g. is the solver is potentialy expensive to construct (AMG) and can
 202     //  be used several times (PISO)
 203     class fvSolver
 204     {
 205         fvMatrix<Type>& fvMat_;
 206
 207         autoPtr<lduMatrix::solver> solver_;
 208
 209     public:
 210
 211         // Constructors
 212
 213             fvSolver(fvMatrix<Type>& fvMat, autoPtr<lduMatrix::solver> sol)
 214             :
 215                 fvMat_(fvMat),
 216                 solver_(sol)
 217             {}
 218
 219
 220         // Member functions
 221
 222             //- Solve returning the solution statistics.
 223             //  Solver controls read from Istream
 224             lduMatrix::solverPerformance solve(Istream&);
 225
 226             //- Solve returning the solution statistics.
 227             //  Solver controls read from fvSolution
 228             lduMatrix::solverPerformance solve();
 229     };
 230
 231
 232     ClassName("fvMatrix");
 233
 234
 235     // Constructors
 236
 237         //- Construct given a field to solve for
 238         fvMatrix
 239         (
 240             GeometricField<Type, fvPatchField, volMesh>&,
 241             const dimensionSet&
 242         );
 243
 244         //- Construct as copy
 245         fvMatrix(const fvMatrix<Type>&);
 246
 247         //- Construct as copy of tmp<fvMatrix<Type> > deleting argument
 248 #       ifdef ConstructFromTmp
 249         fvMatrix(const tmp<fvMatrix<Type> >&);
 250 #       endif
 251
 252         //- Construct from Istream given field to solve for
 253         fvMatrix(GeometricField<Type, fvPatchField, volMesh>&, Istream&);
 254
 255
 256     // Destructor
 257
 258         virtual ~fvMatrix();
 259
 260
 261     // Member functions
 262
 263         // Access
 264
 265             const GeometricField<Type, fvPatchField, volMesh>& psi() const
 266             {
 267                 return psi_;
 268             }
 269
 270             GeometricField<Type, fvPatchField, volMesh>& psi()
 271             {
 272                 return psi_;
 273             }
 274
 275             const dimensionSet& dimensions() const
 276             {
 277                 return dimensions_;
 278             }
 279
 280             Field<Type>& source()
 281             {
 282                 return source_;
 283             }
 284
 285             const Field<Type>& source() const
 286             {
 287                 return source_;
 288             }
 289
 290             //- fvBoundary scalar field containing pseudo-matrix coeffs
 291             //  for internal cells
 292             FieldField<Field, Type>& internalCoeffs()
 293             {
 294                 return internalCoeffs_;
 295             }
 296
 297             //- fvBoundary scalar field containing pseudo-matrix coeffs
 298             //  for boundary cells
 299             FieldField<Field, Type>& boundaryCoeffs()
 300             {
 301                 return boundaryCoeffs_;
 302             }
 303
 304
 305             //- Declare return type of the faceFluxCorrectionPtr() function
 306             typedef GeometricField<Type, fvsPatchField, surfaceMesh>
 307                 *surfaceTypeFieldPtr;
 308
 309             //- Return pointer to face-flux non-orthogonal correction field
 310             surfaceTypeFieldPtr& faceFluxCorrectionPtr()
 311             {
 312                 return faceFluxCorrectionPtr_;
 313             }
 314
 315
 316         // Operations
 317
 318             //- Set solution in given cells and eliminate corresponding
 319             //  equations from the matrix
 320             void setValues
 321             (
 322                 const labelList& cells,
 323                 const Field<Type>& values
 324             );
 325
 326             //- Set reference level for solution
 327             void setReference
 328             (
 329                 const label celli,
 330                 const Type& value,
 331                 const bool forceReference = false
 332             );
 333
 334             //- Set reference level for a component of the solution
 335             //  on a given patch face
 336             void setComponentReference
 337             (
 338                 const label patchi,
 339                 const label facei,
 340                 const direction cmpt,
 341                 const scalar value
 342             );
 343
 344             //- Relax matrix (for steady-state solution).
 345             //  alpha = 1 : diagonally equal
 346             //  alpha < 1 : diagonally dominant
 347             //  alpha = 0 : do nothing
 348             void relax(const scalar alpha);
 349
 350             //- Relax matrix (for steady-state solution).
 351             //  alpha is read from controlDict
 352             void relax();
 353
 354             //- Construct and return the solver
 355             //  Solver controls read from Istream
 356             autoPtr<fvSolver> solver(Istream&);
 357
 358             //- Construct and return the solver
 359             //  Solver controls read from fvSolution
 360             autoPtr<fvSolver> solver();
 361
 362             //- Solve returning the solution statistics.
 363             //  Solver controls read from Istream
 364             lduMatrix::solverPerformance solve(Istream&);
 365
 366             //- Solve returning the solution statistics.
 367             //  Solver controls read from fvSolution
 368             lduMatrix::solverPerformance solve();
 369
 370             //- Return the matrix residual
 371             tmp<Field<Type> > residual() const;
 372
 373             //- Return the matrix scalar diagonal
 374             tmp<scalarField> D() const;
 375
 376             //- Return the matrix Type diagonal
 377             tmp<Field<Type> > DD() const;
 378
 379             //- Return the central coefficient
 380             tmp<volScalarField> A() const;
 381
 382             //- Return the H operation source
 383             tmp<GeometricField<Type, fvPatchField, volMesh> > H() const;
 384
 385             //- Return H(1)
 386             tmp<volScalarField> H1() const;
 387
 388             //- Return the face-flux field from the matrix
 389             tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >
 390             flux() const;
 391
 392
 393     // Member operators
 394
 395         void operator=(const fvMatrix<Type>&);
 396         void operator=(const tmp<fvMatrix<Type> >&);
 397
 398         void negate();
 399
 400         void operator+=(const fvMatrix<Type>&);
 401         void operator+=(const tmp<fvMatrix<Type> >&);
 402
 403         void operator-=(const fvMatrix<Type>&);
 404         void operator-=(const tmp<fvMatrix<Type> >&);
 405
 406         void operator+=
 407         (
 408             const DimensionedField<Type, volMesh>&
 409         );
 410         void operator+=
 411         (
 412             const tmp<DimensionedField<Type, volMesh> >&
 413         );
 414         void operator+=
 415         (
 416             const tmp<GeometricField<Type, fvPatchField, volMesh> >&
 417         );
 418
 419         void operator-=
 420         (
 421             const DimensionedField<Type, volMesh>&
 422         );
 423         void operator-=
 424         (
 425             const tmp<DimensionedField<Type, volMesh> >&
 426         );
 427         void operator-=
 428         (
 429             const tmp<GeometricField<Type, fvPatchField, volMesh> >&
 430         );
 431
 432         void operator+=(const dimensioned<Type>&);
 433         void operator-=(const dimensioned<Type>&);
 434
 435         void operator+=(const zeroField&);
 436         void operator-=(const zeroField&);
 437
 438         void operator*=(const DimensionedField<scalar, volMesh>&);
 439         void operator*=(const tmp<DimensionedField<scalar, volMesh> >&);
 440         void operator*=(const tmp<volScalarField>&);
 441
 442         void operator*=(const dimensioned<scalar>&);
 443
 444
 445     // Friend operators
 446
 447         friend tmp<GeometricField<Type, fvPatchField, volMesh> >
 448         operator& <Type>
 449         (
 450             const fvMatrix<Type>&,
 451             const DimensionedField<Type, volMesh>&
 452         );
 453
 454         friend tmp<GeometricField<Type, fvPatchField, volMesh> >
 455         operator& <Type>
 456         (
 457             const fvMatrix<Type>&,
 458             const tmp<GeometricField<Type, fvPatchField, volMesh> >&
 459         );
 460
 461         friend tmp<GeometricField<Type, fvPatchField, volMesh> >
 462         operator& <Type>
 463         (
 464             const tmp<fvMatrix<Type> >&,
 465             const DimensionedField<Type, volMesh>&
 466         );
 467
 468         friend tmp<GeometricField<Type, fvPatchField, volMesh> >
 469         operator& <Type>
 470         (
 471             const tmp<fvMatrix<Type> >&,
 472             const tmp<GeometricField<Type, fvPatchField, volMesh> >&
 473         );
 474
 475
 476     // Ostream operator
 477
 478         friend Ostream& operator<< <Type>
 479         (
 480             Ostream&,
 481             const fvMatrix<Type>&
 482         );
 483 };
 484
 485
 486 // * * * * * * * * * * * * * * * Global functions  * * * * * * * * * * * * * //
 487
 488 template<class Type>
 489 void checkMethod
 490 (
 491     const fvMatrix<Type>&,
 492     const fvMatrix<Type>&,
 493     const char*
 494 );
 495
 496 template<class Type>
 497 void checkMethod
 498 (
 499     const fvMatrix<Type>&,
 500     const DimensionedField<Type, volMesh>&,
 501     const char*
 502 );
 503
 504 template<class Type>
 505 void checkMethod
 506 (
 507     const fvMatrix<Type>&,
 508     const dimensioned<Type>&,
 509     const char*
 510 );
 511
 512
 513 //- Solve returning the solution statistics given convergence tolerance
 514 //  Solver controls read Istream
 515 template<class Type>
 516 lduMatrix::solverPerformance solve(fvMatrix<Type>&, Istream&);
 517
 518
 519 //- Solve returning the solution statistics given convergence tolerance,
 520 //  deleting temporary matrix after solution.
 521 //  Solver controls read Istream
 522 template<class Type>
 523 lduMatrix::solverPerformance solve(const tmp<fvMatrix<Type> >&, Istream&);
 524
 525
 526 //- Solve returning the solution statistics given convergence tolerance
 527 //  Solver controls read fvSolution
 528 template<class Type>
 529 lduMatrix::solverPerformance solve(fvMatrix<Type>&);
 530
 531
 532 //- Solve returning the solution statistics given convergence tolerance,
 533 //  deleting temporary matrix after solution.
 534 //  Solver controls read fvSolution
 535 template<class Type>
 536 lduMatrix::solverPerformance solve(const tmp<fvMatrix<Type> >&);
 537
 538
 539 // * * * * * * * * * * * * * * * Global operators  * * * * * * * * * * * * * //
 540
 541 template<class Type>
 542 tmp<fvMatrix<Type> > operator==
 543 (
 544     const fvMatrix<Type>&,
 545     const fvMatrix<Type>&
 546 );
 547
 548 template<class Type>
 549 tmp<fvMatrix<Type> > operator==
 550 (
 551     const tmp<fvMatrix<Type> >&,
 552     const fvMatrix<Type>&
 553 );
 554
 555 template<class Type>
 556 tmp<fvMatrix<Type> > operator==
 557 (
 558     const fvMatrix<Type>&,
 559     const tmp<fvMatrix<Type> >&
 560 );
 561
 562 template<class Type>
 563 tmp<fvMatrix<Type> > operator==
 564 (
 565     const tmp<fvMatrix<Type> >&,
 566     const tmp<fvMatrix<Type> >&
 567 );
 568
 569
 570 template<class Type>
 571 tmp<fvMatrix<Type> > operator==
 572 (
 573     const fvMatrix<Type>&,
 574     const DimensionedField<Type, volMesh>&
 575 );
 576
 577 template<class Type>
 578 tmp<fvMatrix<Type> > operator==
 579 (
 580     const fvMatrix<Type>&,
 581     const tmp<DimensionedField<Type, volMesh> >&
 582 );
 583
 584 template<class Type>
 585 tmp<fvMatrix<Type> > operator==
 586 (
 587     const fvMatrix<Type>&,
 588     const tmp<GeometricField<Type, fvPatchField, volMesh> >&
 589 );
 590
 591 template<class Type>
 592 tmp<fvMatrix<Type> > operator==
 593 (
 594     const tmp<fvMatrix<Type> >&,
 595     const DimensionedField<Type, volMesh>&
 596 );
 597
 598 template<class Type>
 599 tmp<fvMatrix<Type> > operator==
 600 (
 601     const tmp<fvMatrix<Type> >&,
 602     const tmp<DimensionedField<Type, volMesh> >&
 603 );
 604
 605 template<class Type>
 606 tmp<fvMatrix<Type> > operator==
 607 (
 608     const tmp<fvMatrix<Type> >&,
 609     const tmp<GeometricField<Type, fvPatchField, volMesh> >&
 610 );
 611
 612 template<class Type>
 613 tmp<fvMatrix<Type> > operator==
 614 (
 615     const fvMatrix<Type>&,
 616     const dimensioned<Type>&
 617 );
 618
 619 template<class Type>
 620 tmp<fvMatrix<Type> > operator==
 621 (
 622     const tmp<fvMatrix<Type> >&,
 623     const dimensioned<Type>&
 624 );
 625
 626
 627 template<class Type>
 628 tmp<fvMatrix<Type> > operator==
 629 (
 630     const fvMatrix<Type>&,
 631     const zeroField&
 632 );
 633
 634 template<class Type>
 635 tmp<fvMatrix<Type> > operator==
 636 (
 637     const tmp<fvMatrix<Type> >&,
 638     const zeroField&
 639 );
 640
 641
 642 template<class Type>
 643 tmp<fvMatrix<Type> > operator-
 644 (
 645     const fvMatrix<Type>&
 646 );
 647
 648 template<class Type>
 649 tmp<fvMatrix<Type> > operator-
 650 (
 651     const tmp<fvMatrix<Type> >&
 652 );
 653
 654
 655 template<class Type>
 656 tmp<fvMatrix<Type> > operator+
 657 (
 658     const fvMatrix<Type>&,
 659     const fvMatrix<Type>&
 660 );
 661
 662 template<class Type>
 663 tmp<fvMatrix<Type> > operator+
 664 (
 665     const tmp<fvMatrix<Type> >&,
 666     const fvMatrix<Type>&
 667 );
 668
 669 template<class Type>
 670 tmp<fvMatrix<Type> > operator+
 671 (
 672     const fvMatrix<Type>&,
 673     const tmp<fvMatrix<Type> >&
 674 );
 675
 676 template<class Type>
 677 tmp<fvMatrix<Type> > operator+
 678 (
 679     const tmp<fvMatrix<Type> >&,
 680     const tmp<fvMatrix<Type> >&
 681 );
 682
 683
 684 template<class Type>
 685 tmp<fvMatrix<Type> > operator+
 686 (
 687     const fvMatrix<Type>&,
 688     const DimensionedField<Type, volMesh>&
 689 );
 690
 691 template<class Type>
 692 tmp<fvMatrix<Type> > operator+
 693 (
 694     const fvMatrix<Type>&,
 695     const tmp<DimensionedField<Type, volMesh> >&
 696 );
 697
 698 template<class Type>
 699 tmp<fvMatrix<Type> > operator+
 700 (
 701     const fvMatrix<Type>&,
 702     const tmp<GeometricField<Type, fvPatchField, volMesh> >&
 703 );
 704
 705 template<class Type>
 706 tmp<fvMatrix<Type> > operator+
 707 (
 708     const tmp<fvMatrix<Type> >&,
 709     const DimensionedField<Type, volMesh>&
 710 );
 711
 712 template<class Type>
 713 tmp<fvMatrix<Type> > operator+
 714 (
 715     const tmp<fvMatrix<Type> >&,
 716     const tmp<DimensionedField<Type, volMesh> >&
 717 );
 718
 719 template<class Type>
 720 tmp<fvMatrix<Type> > operator+
 721 (
 722     const tmp<fvMatrix<Type> >&,
 723     const tmp<GeometricField<Type, fvPatchField, volMesh> >&
 724 );
 725
 726 template<class Type>
 727 tmp<fvMatrix<Type> > operator+
 728 (
 729     const DimensionedField<Type, volMesh>&,
 730     const fvMatrix<Type>&
 731 );
 732
 733 template<class Type>
 734 tmp<fvMatrix<Type> > operator+
 735 (
 736     const tmp<DimensionedField<Type, volMesh> >&,
 737     const fvMatrix<Type>&
 738 );
 739
 740 template<class Type>
 741 tmp<fvMatrix<Type> > operator+
 742 (
 743     const tmp<GeometricField<Type, fvPatchField, volMesh> >&,
 744     const fvMatrix<Type>&
 745 );
 746
 747 template<class Type>
 748 tmp<fvMatrix<Type> > operator+
 749 (
 750     const DimensionedField<Type, volMesh>&,
 751     const tmp<fvMatrix<Type> >&
 752 );
 753
 754 template<class Type>
 755 tmp<fvMatrix<Type> > operator+
 756 (
 757     const tmp<DimensionedField<Type, volMesh> >&,
 758     const tmp<fvMatrix<Type> >&
 759 );
 760
 761 template<class Type>
 762 tmp<fvMatrix<Type> > operator+
 763 (
 764     const tmp<GeometricField<Type, fvPatchField, volMesh> >&,
 765     const tmp<fvMatrix<Type> >&
 766 );
 767
 768
 769 template<class Type>
 770 tmp<fvMatrix<Type> > operator+
 771 (
 772     const fvMatrix<Type>&,
 773     const dimensioned<Type>&
 774 );
 775
 776 template<class Type>
 777 tmp<fvMatrix<Type> > operator+
 778 (
 779     const tmp<fvMatrix<Type> >&,
 780     const dimensioned<Type>&
 781 );
 782
 783 template<class Type>
 784 tmp<fvMatrix<Type> > operator+
 785 (
 786     const dimensioned<Type>&,
 787     const fvMatrix<Type>&
 788 );
 789
 790 template<class Type>
 791 tmp<fvMatrix<Type> > operator+
 792 (
 793     const dimensioned<Type>&,
 794     const tmp<fvMatrix<Type> >&
 795 );
 796
 797
 798 template<class Type>
 799 tmp<fvMatrix<Type> > operator-
 800 (
 801     const fvMatrix<Type>&,
 802     const fvMatrix<Type>&
 803 );
 804
 805 template<class Type>
 806 tmp<fvMatrix<Type> > operator-
 807 (
 808     const tmp<fvMatrix<Type> >&,
 809     const fvMatrix<Type>&
 810 );
 811
 812 template<class Type>
 813 tmp<fvMatrix<Type> > operator-
 814 (
 815     const fvMatrix<Type>&,
 816     const tmp<fvMatrix<Type> >&
 817 );
 818
 819 template<class Type>
 820 tmp<fvMatrix<Type> > operator-
 821 (
 822     const tmp<fvMatrix<Type> >&,
 823     const tmp<fvMatrix<Type> >&
 824 );
 825
 826
 827 template<class Type>
 828 tmp<fvMatrix<Type> > operator-
 829 (
 830     const fvMatrix<Type>&,
 831     const DimensionedField<Type, volMesh>&
 832 );
 833
 834 template<class Type>
 835 tmp<fvMatrix<Type> > operator-
 836 (
 837     const fvMatrix<Type>&,
 838     const tmp<DimensionedField<Type, volMesh> >&
 839 );
 840
 841 template<class Type>
 842 tmp<fvMatrix<Type> > operator-
 843 (
 844     const fvMatrix<Type>&,
 845     const tmp<GeometricField<Type, fvPatchField, volMesh> >&
 846 );
 847
 848 template<class Type>
 849 tmp<fvMatrix<Type> > operator-
 850 (
 851     const tmp<fvMatrix<Type> >&,
 852     const DimensionedField<Type, volMesh>&
 853 );
 854
 855 template<class Type>
 856 tmp<fvMatrix<Type> > operator-
 857 (
 858     const tmp<fvMatrix<Type> >&,
 859     const tmp<DimensionedField<Type, volMesh> >&
 860 );
 861
 862 template<class Type>
 863 tmp<fvMatrix<Type> > operator-
 864 (
 865     const tmp<fvMatrix<Type> >&,
 866     const tmp<GeometricField<Type, fvPatchField, volMesh> >&
 867 );
 868
 869 template<class Type>
 870 tmp<fvMatrix<Type> > operator-
 871 (
 872     const DimensionedField<Type, volMesh>&,
 873     const fvMatrix<Type>&
 874 );
 875
 876 template<class Type>
 877 tmp<fvMatrix<Type> > operator-
 878 (
 879     const tmp<DimensionedField<Type, volMesh> >&,
 880     const fvMatrix<Type>&
 881 );
 882
 883 template<class Type>
 884 tmp<fvMatrix<Type> > operator-
 885 (
 886     const tmp<GeometricField<Type, fvPatchField, volMesh> >&,
 887     const fvMatrix<Type>&
 888 );
 889
 890 template<class Type>
 891 tmp<fvMatrix<Type> > operator-
 892 (
 893     const DimensionedField<Type, volMesh>&,
 894     const tmp<fvMatrix<Type> >&
 895 );
 896
 897 template<class Type>
 898 tmp<fvMatrix<Type> > operator-
 899 (
 900     const tmp<DimensionedField<Type, volMesh> >&,
 901     const tmp<fvMatrix<Type> >&
 902 );
 903
 904 template<class Type>
 905 tmp<fvMatrix<Type> > operator-
 906 (
 907     const tmp<GeometricField<Type, fvPatchField, volMesh> >&,
 908     const tmp<fvMatrix<Type> >&
 909 );
 910
 911
 912 template<class Type>
 913 tmp<fvMatrix<Type> > operator-
 914 (
 915     const fvMatrix<Type>&,
 916     const dimensioned<Type>&
 917 );
 918
 919 template<class Type>
 920 tmp<fvMatrix<Type> > operator-
 921 (
 922     const tmp<fvMatrix<Type> >&,
 923     const dimensioned<Type>&
 924 );
 925
 926 template<class Type>
 927 tmp<fvMatrix<Type> > operator-
 928 (
 929     const dimensioned<Type>&,
 930     const fvMatrix<Type>&
 931 );
 932
 933 template<class Type>
 934 tmp<fvMatrix<Type> > operator-
 935 (
 936     const dimensioned<Type>&,
 937     const tmp<fvMatrix<Type> >&
 938 );
 939
 940
 941 template<class Type>
 942 tmp<fvMatrix<Type> > operator*
 943 (
 944     const DimensionedField<scalar, volMesh>&,
 945     const fvMatrix<Type>&
 946 );
 947
 948 template<class Type>
 949 tmp<fvMatrix<Type> > operator*
 950 (
 951     const tmp<DimensionedField<scalar, volMesh> >&,
 952     const fvMatrix<Type>&
 953 );
 954
 955 template<class Type>
 956 tmp<fvMatrix<Type> > operator*
 957 (
 958     const tmp<volScalarField>&,
 959     const fvMatrix<Type>&
 960 );
 961
 962 template<class Type>
 963 tmp<fvMatrix<Type> > operator*
 964 (
 965     const DimensionedField<scalar, volMesh>&,
 966     const tmp<fvMatrix<Type> >&
 967 );
 968
 969 template<class Type>
 970 tmp<fvMatrix<Type> > operator*
 971 (
 972     const tmp<DimensionedField<scalar, volMesh> >&,
 973     const tmp<fvMatrix<Type> >&
 974 );
 975
 976 template<class Type>
 977 tmp<fvMatrix<Type> > operator*
 978 (
 979     const tmp<volScalarField>&,
 980     const tmp<fvMatrix<Type> >&
 981 );
 982
 983
 984 template<class Type>
 985 tmp<fvMatrix<Type> > operator*
 986 (
 987     const dimensioned<scalar>&,
 988     const fvMatrix<Type>&
 989 );
 990
 991 template<class Type>
 992 tmp<fvMatrix<Type> > operator*
 993 (
 994     const dimensioned<scalar>&,
 995     const tmp<fvMatrix<Type> >&
 996 );
 997
 998
 999 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
1000
1001 } // End namespace Foam
1002
1003 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
1004
1005 #ifdef NoRepository
1006 #   include "fvMatrix.C"
1007 #endif
1008
1009 // Specialisation for scalars
1010 #include "fvScalarMatrix.H"
1011
1012 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
1013
1014 #endif
1015
1016 // ************************************************************************* //