src/finiteArea/faMatrices/faMatrix/faMatrix.H

   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 Class
  26     faMatrix<Type>
  27
  28 Description
  29     Finite-Area matrix.
  30
  31 SourceFiles
  32     faMatrix.C
  33     faMatrixSolve.C
  34
  35 \*---------------------------------------------------------------------------*/
  36
  37 #ifndef faMatrix_H
  38 #define faMatrix_H
  39
  40 #include "areaFields.H"
  41 #include "edgeFields.H"
  42 #include "lduMatrix.H"
  43 #include "tmp.H"
  44 #include "autoPtr.H"
  45 #include "dimensionedTypes.H"
  46 #include "className.H"
  47
  48 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  49
  50 namespace Foam
  51 {
  52
  53 // * * * * * * Forward declaration of template friend fuctions * * * * * * * //
  54
  55 template<class Type>
  56 class faMatrix;
  57
  58 template<class Type>
  59 Ostream& operator<<(Ostream&, const faMatrix<Type>&);
  60
  61
  62 /*---------------------------------------------------------------------------*\
  63                            Class faMatrix Declaration
  64 \*---------------------------------------------------------------------------*/
  65
  66 template<class Type>
  67 class faMatrix
  68 :
  69     public refCount,
  70     public lduMatrix
  71 {
  72     // Private data
  73
  74         // Reference to GeometricField<Type, faPatchField, areaMesh>
  75         GeometricField<Type, faPatchField, areaMesh>& psi_;
  76
  77         //- Dimension set
  78         dimensionSet dimensions_;
  79
  80         //- Source term
  81         Field<Type> source_;
  82
  83         //- Boundary scalar field containing pseudo-matrix coeffs
  84         //  for internal faces
  85         FieldField<Field, Type> internalCoeffs_;
  86
  87         //- Boundary scalar field containing pseudo-matrix coeffs
  88         //  for boundary faces
  89         FieldField<Field, Type> boundaryCoeffs_;
  90
  91
  92         //- Face flux field for non-orthogonal correction
  93         mutable GeometricField<Type, faePatchField, edgeMesh>
  94             *faceFluxCorrectionPtr_;
  95
  96         direction solvingComponent;
  97
  98
  99     // Private member functions
 100
 101         //- Add patch contribution to internal field
 102         template<class Type2>
 103         void addToInternalField
 104         (
 105             const unallocLabelList& addr,
 106             const Field<Type2>& pf,
 107             Field<Type2>& intf
 108         ) const;
 109
 110         template<class Type2>
 111         void addToInternalField
 112         (
 113             const unallocLabelList& addr,
 114             const tmp<Field<Type2> >& tpf,
 115             Field<Type2>& intf
 116         ) const;
 117
 118         //- Subtract patch contribution from internal field
 119         template<class Type2>
 120         void subtractFromInternalField
 121         (
 122             const unallocLabelList& addr,
 123             const Field<Type2>& pf,
 124             Field<Type2>& intf
 125         ) const;
 126
 127         template<class Type2>
 128         void subtractFromInternalField
 129         (
 130             const unallocLabelList& addr,
 131             const tmp<Field<Type2> >& tpf,
 132             Field<Type2>& intf
 133         ) const;
 134
 135
 136         // Matrix completion functionality
 137
 138             void addBoundaryDiag
 139             (
 140                 scalarField& diag,
 141                 const direction cmpt
 142             ) const;
 143
 144             void addCmptAvBoundaryDiag(scalarField& diag) const;
 145
 146             void addBoundarySource
 147             (
 148                 Field<Type>& source,
 149                 const bool couples = true
 150             ) const;
 151
 152
 153 public:
 154
 155     //- Solver class returned by the solver function
 156     class faSolver
 157     {
 158         faMatrix<Type>& faMat_;
 159
 160         autoPtr<lduSolver> solver_;
 161
 162     public:
 163
 164         // Constructors
 165
 166             faSolver(faMatrix<Type>& faMat, autoPtr<lduSolver> sol)
 167             :
 168                 faMat_(faMat),
 169                 solver_(sol)
 170             {}
 171
 172
 173         // Member functions
 174
 175             //- Solve returning the solution statistics.
 176             //  Solver controls read from dictionary
 177             lduSolverPerformance solve(const dictionary&);
 178
 179             //- Solve returning the solution statistics.
 180             //  Solver controls read from faSolution
 181             lduSolverPerformance solve();
 182     };
 183
 184
 185     ClassName("faMatrix");
 186
 187
 188     // Constructors
 189
 190         //- Construct given a field to solve for
 191         faMatrix
 192         (
 193             GeometricField<Type, faPatchField, areaMesh>&,
 194             const dimensionSet&
 195         );
 196
 197         //- Construct as copy
 198         faMatrix(const faMatrix<Type>&);
 199
 200         //- Construct from Istream given field to solve for
 201         faMatrix(GeometricField<Type, faPatchField, areaMesh>&, Istream&);
 202
 203
 204     // Destructor
 205
 206         virtual ~faMatrix();
 207
 208
 209     // Member functions
 210
 211         // Access
 212
 213             const GeometricField<Type, faPatchField, areaMesh>& psi() const
 214             {
 215                 return psi_;
 216             }
 217
 218             GeometricField<Type, faPatchField, areaMesh>& psi()
 219             {
 220                 return psi_;
 221             }
 222
 223             const dimensionSet& dimensions() const
 224             {
 225                 return dimensions_;
 226             }
 227
 228             Field<Type>& source()
 229             {
 230                 return source_;
 231             }
 232
 233             const Field<Type>& source() const
 234             {
 235                 return source_;
 236             }
 237
 238             //- faBoundary scalar field containing pseudo-matrix coeffs
 239             //  for internal cells
 240             FieldField<Field, Type>& internalCoeffs()
 241             {
 242                 return internalCoeffs_;
 243             }
 244
 245             //- faBoundary scalar field containing pseudo-matrix coeffs
 246             //  for boundary cells
 247             FieldField<Field, Type>& boundaryCoeffs()
 248             {
 249                 return boundaryCoeffs_;
 250             }
 251
 252
 253             //- Declare return type of the faceFluxCorrectionPtr() function
 254             typedef GeometricField<Type, faePatchField, edgeMesh>
 255                 *edgeTypeFieldPtr;
 256
 257             //- Return pointer to face-flux non-orthogonal correction field
 258             edgeTypeFieldPtr& faceFluxCorrectionPtr()
 259             {
 260                 return faceFluxCorrectionPtr_;
 261             }
 262
 263
 264         // Operations
 265
 266             //- Set solution in given cells and eliminate corresponding
 267             //  equations from the matrix
 268             void setValues
 269             (
 270                 const labelList& faces,
 271                 const Field<Type>& values
 272             );
 273
 274             //- Set reference level for solution
 275             void setReference
 276             (
 277                 const label facei,
 278                 const Type& value
 279             );
 280
 281             //- Set reference level for a component of the solution
 282             //  on a given patch face
 283             void setComponentReference
 284             (
 285                 const label patchi,
 286                 const label facei,
 287                 const direction cmpt,
 288                 const scalar value
 289             );
 290
 291             //- Relax matrix (for steady-state solution).
 292             //  alpha = 1 : diagonally equal
 293             //  alpha < 1 :    ,,      dominant
 294             //  alpha = 0 : do nothing
 295             void relax(const scalar alpha);
 296
 297             //- Relax matrix (for steadty-state solution).
 298             //  alpha is read from controlDict
 299             void relax();
 300
 301             //- Construct and return the solver
 302             //  Solver controls read from Istream
 303             autoPtr<faSolver> solver(const dictionary&);
 304
 305             //- Construct and return the solver
 306             //  Solver controls read from faSolution
 307             autoPtr<faSolver> solver();
 308
 309             //- Solve returning the solution statistics.
 310             //  Solver controls read Istream
 311             lduSolverPerformance solve(const dictionary&);
 312
 313             //- Solve returning the solution statistics.
 314             //  Solver controls read from faSolution
 315             lduSolverPerformance solve();
 316
 317             //- Return the matrix residual
 318             tmp<Field<Type> > residual() const;
 319
 320             //- Return the matrix diagonal
 321             tmp<scalarField> D() const;
 322
 323             //- Return the central coefficient
 324             tmp<areaScalarField> A() const;
 325
 326             //- Return the H operation source
 327             tmp<GeometricField<Type, faPatchField, areaMesh> > H() const;
 328
 329             //- Return the face-flux field from the matrix
 330             tmp<GeometricField<Type, faePatchField, edgeMesh> > flux() const;
 331
 332
 333     // Member operators
 334
 335         void operator=(const faMatrix<Type>&);
 336         void operator=(const tmp<faMatrix<Type> >&);
 337
 338         void negate();
 339
 340         void operator+=(const faMatrix<Type>&);
 341         void operator+=(const tmp<faMatrix<Type> >&);
 342
 343         void operator-=(const faMatrix<Type>&);
 344         void operator-=(const tmp<faMatrix<Type> >&);
 345
 346         void operator+=(const GeometricField<Type,faPatchField,areaMesh>&);
 347         void operator+=(const tmp<GeometricField<Type,faPatchField,areaMesh> >&);
 348
 349         void operator-=(const GeometricField<Type,faPatchField,areaMesh>&);
 350         void operator-=(const tmp<GeometricField<Type,faPatchField,areaMesh> >&);
 351
 352         void operator+=(const dimensioned<Type>&);
 353         void operator-=(const dimensioned<Type>&);
 354
 355         void operator*=(const areaScalarField&);
 356         void operator*=(const tmp<areaScalarField>&);
 357
 358         void operator*=(const dimensioned<scalar>&);
 359
 360
 361     // Ostream operator
 362
 363         friend Ostream& operator<< <Type>
 364         (
 365             Ostream&,
 366             const faMatrix<Type>&
 367         );
 368 };
 369
 370
 371 // * * * * * * * * * * * * * * * Global functions  * * * * * * * * * * * * * //
 372
 373 template<class Type>
 374 void checkMethod
 375 (
 376     const faMatrix<Type>&,
 377     const faMatrix<Type>&,
 378     const char*
 379 );
 380
 381 template<class Type>
 382 void checkMethod
 383 (
 384     const faMatrix<Type>&,
 385     const GeometricField<Type, faPatchField, areaMesh>&,
 386     const char*
 387 );
 388
 389 template<class Type>
 390 void checkMethod
 391 (
 392     const faMatrix<Type>&,
 393     const dimensioned<Type>&,
 394     const char*
 395 );
 396
 397
 398 //- Solve returning the solution statistics given convergence tolerance
 399 //  Solver controls read Istream
 400 template<class Type>
 401 lduSolverPerformance solve(faMatrix<Type>&, Istream&);
 402
 403
 404 //- Solve returning the solution statistics given convergence tolerance,
 405 //  deleting temporary matrix after solution.
 406 //  Solver controls read Istream
 407 template<class Type>
 408 lduSolverPerformance solve(const tmp<faMatrix<Type> >&, Istream&);
 409
 410
 411 //- Solve returning the solution statistics given convergence tolerance
 412 //  Solver controls read faSolution
 413 template<class Type>
 414 lduSolverPerformance solve(faMatrix<Type>&);
 415
 416
 417 //- Solve returning the solution statistics given convergence tolerance,
 418 //  deleting temporary matrix after solution.
 419 //  Solver controls read faSolution
 420 template<class Type>
 421 lduSolverPerformance solve(const tmp<faMatrix<Type> >&);
 422
 423
 424 // * * * * * * * * * * * * * * * Global operators  * * * * * * * * * * * * * //
 425
 426 template<class Type>
 427 tmp<faMatrix<Type> > operator-
 428 (
 429     const faMatrix<Type>&
 430 );
 431
 432 template<class Type>
 433 tmp<faMatrix<Type> > operator-
 434 (
 435     const tmp<faMatrix<Type> >&
 436 );
 437
 438 template<class Type>
 439 tmp<faMatrix<Type> > operator+
 440 (
 441     const faMatrix<Type>&,
 442     const faMatrix<Type>&
 443 );
 444
 445 template<class Type>
 446 tmp<faMatrix<Type> > operator+
 447 (
 448     const tmp<faMatrix<Type> >&,
 449     const faMatrix<Type>&
 450 );
 451
 452 template<class Type>
 453 tmp<faMatrix<Type> > operator+
 454 (
 455     const faMatrix<Type>&,
 456     const tmp<faMatrix<Type> >&
 457 );
 458
 459 template<class Type>
 460 tmp<faMatrix<Type> > operator+
 461 (
 462     const tmp<faMatrix<Type> >&,
 463     const tmp<faMatrix<Type> >&
 464 );
 465
 466 template<class Type>
 467 tmp<faMatrix<Type> > operator-
 468 (
 469     const faMatrix<Type>&,
 470     const faMatrix<Type>&
 471 );
 472
 473 template<class Type>
 474 tmp<faMatrix<Type> > operator-
 475 (
 476     const tmp<faMatrix<Type> >&,
 477     const faMatrix<Type>&
 478 );
 479
 480 template<class Type>
 481 tmp<faMatrix<Type> > operator-
 482 (
 483     const faMatrix<Type>&,
 484     const tmp<faMatrix<Type> >&
 485 );
 486
 487 template<class Type>
 488 tmp<faMatrix<Type> > operator-
 489 (
 490     const tmp<faMatrix<Type> >&,
 491     const tmp<faMatrix<Type> >&
 492 );
 493
 494 template<class Type>
 495 tmp<faMatrix<Type> > operator==
 496 (
 497     const faMatrix<Type>&,
 498     const faMatrix<Type>&
 499 );
 500
 501 template<class Type>
 502 tmp<faMatrix<Type> > operator==
 503 (
 504     const tmp<faMatrix<Type> >&,
 505     const faMatrix<Type>&
 506 );
 507
 508 template<class Type>
 509 tmp<faMatrix<Type> > operator==
 510 (
 511     const faMatrix<Type>&,
 512     const tmp<faMatrix<Type> >&
 513 );
 514
 515 template<class Type>
 516 tmp<faMatrix<Type> > operator==
 517 (
 518     const tmp<faMatrix<Type> >&,
 519     const tmp<faMatrix<Type> >&
 520 );
 521
 522 template<class Type>
 523 tmp<faMatrix<Type> > operator+
 524 (
 525     const faMatrix<Type>&,
 526     const GeometricField<Type, faPatchField, areaMesh>&
 527 );
 528
 529 template<class Type>
 530 tmp<faMatrix<Type> > operator+
 531 (
 532     const tmp<faMatrix<Type> >&,
 533     const GeometricField<Type, faPatchField, areaMesh>&
 534 );
 535
 536 template<class Type>
 537 tmp<faMatrix<Type> > operator+
 538 (
 539     const faMatrix<Type>&,
 540     const tmp<GeometricField<Type, faPatchField, areaMesh> >&
 541 );
 542
 543 template<class Type>
 544 tmp<faMatrix<Type> > operator+
 545 (
 546     const tmp<faMatrix<Type> >&,
 547     const tmp<GeometricField<Type, faPatchField, areaMesh> >&
 548 );
 549
 550 template<class Type>
 551 tmp<faMatrix<Type> > operator+
 552 (
 553     const GeometricField<Type, faPatchField, areaMesh>&,
 554     const faMatrix<Type>&
 555 );
 556
 557 template<class Type>
 558 tmp<faMatrix<Type> > operator+
 559 (
 560     const GeometricField<Type, faPatchField, areaMesh>&,
 561     const tmp<faMatrix<Type> >&
 562 );
 563
 564 template<class Type>
 565 tmp<faMatrix<Type> > operator+
 566 (
 567     const tmp<GeometricField<Type, faPatchField, areaMesh> >&,
 568     const faMatrix<Type>&
 569 );
 570
 571 template<class Type>
 572 tmp<faMatrix<Type> > operator+
 573 (
 574     const tmp<GeometricField<Type, faPatchField, areaMesh> >&,
 575     const tmp<faMatrix<Type> >&
 576 );
 577
 578 template<class Type>
 579 tmp<faMatrix<Type> > operator-
 580 (
 581     const faMatrix<Type>&,
 582     const GeometricField<Type, faPatchField, areaMesh>&
 583 );
 584
 585 template<class Type>
 586 tmp<faMatrix<Type> > operator-
 587 (
 588     const tmp<faMatrix<Type> >&,
 589     const GeometricField<Type, faPatchField, areaMesh>&
 590 );
 591
 592 template<class Type>
 593 tmp<faMatrix<Type> > operator-
 594 (
 595     const faMatrix<Type>&,
 596     const tmp<GeometricField<Type, faPatchField, areaMesh> >&
 597 );
 598
 599 template<class Type>
 600 tmp<faMatrix<Type> > operator-
 601 (
 602     const tmp<faMatrix<Type> >&,
 603     const tmp<GeometricField<Type, faPatchField, areaMesh> >&
 604 );
 605
 606 template<class Type>
 607 tmp<faMatrix<Type> > operator-
 608 (
 609     const GeometricField<Type, faPatchField, areaMesh>&,
 610     const faMatrix<Type>&
 611 );
 612
 613 template<class Type>
 614 tmp<faMatrix<Type> > operator-
 615 (
 616     const GeometricField<Type, faPatchField, areaMesh>&,
 617     const tmp<faMatrix<Type> >&
 618 );
 619
 620 template<class Type>
 621 tmp<faMatrix<Type> > operator-
 622 (
 623     const tmp<GeometricField<Type, faPatchField, areaMesh> >&,
 624     const faMatrix<Type>&
 625 );
 626
 627 template<class Type>
 628 tmp<faMatrix<Type> > operator-
 629 (
 630     const tmp<GeometricField<Type, faPatchField, areaMesh> >&,
 631     const tmp<faMatrix<Type> >&
 632 );
 633
 634 template<class Type>
 635 tmp<faMatrix<Type> > operator+
 636 (
 637     const tmp<faMatrix<Type> >&,
 638     const dimensioned<Type>&
 639 );
 640
 641 template<class Type>
 642 tmp<faMatrix<Type> > operator+
 643 (
 644     const dimensioned<Type>&,
 645     const tmp<faMatrix<Type> >&
 646 );
 647
 648 template<class Type>
 649 tmp<faMatrix<Type> > operator-
 650 (
 651     const tmp<faMatrix<Type> >&,
 652     const dimensioned<Type>&
 653 );
 654
 655 template<class Type>
 656 tmp<faMatrix<Type> > operator-
 657 (
 658     const dimensioned<Type>&,
 659     const tmp<faMatrix<Type> >&
 660 );
 661
 662 template<class Type>
 663 tmp<faMatrix<Type> > operator==
 664 (
 665     const faMatrix<Type>&,
 666     const GeometricField<Type, faPatchField, areaMesh>&
 667 );
 668
 669 template<class Type>
 670 tmp<faMatrix<Type> > operator==
 671 (
 672     const tmp<faMatrix<Type> >&,
 673     const GeometricField<Type, faPatchField, areaMesh>&
 674 );
 675
 676 template<class Type>
 677 tmp<faMatrix<Type> > operator==
 678 (
 679     const faMatrix<Type>&,
 680     const tmp<GeometricField<Type, faPatchField, areaMesh> >&
 681 );
 682
 683 template<class Type>
 684 tmp<faMatrix<Type> > operator==
 685 (
 686     const tmp<faMatrix<Type> >&,
 687     const tmp<GeometricField<Type, faPatchField, areaMesh> >&
 688 );
 689
 690 template<class Type>
 691 tmp<faMatrix<Type> > operator==
 692 (
 693     const faMatrix<Type>&,
 694     const dimensioned<Type>&
 695 );
 696
 697 template<class Type>
 698 tmp<faMatrix<Type> > operator==
 699 (
 700     const tmp<faMatrix<Type> >&,
 701     const dimensioned<Type>&
 702 );
 703
 704
 705 template<class Type>
 706 tmp<faMatrix<Type> > operator*
 707 (
 708     const areaScalarField&,
 709     const faMatrix<Type>&
 710 );
 711
 712 template<class Type>
 713 tmp<faMatrix<Type> > operator*
 714 (
 715     const areaScalarField&,
 716     const tmp<faMatrix<Type> >&
 717 );
 718
 719 template<class Type>
 720 tmp<faMatrix<Type> > operator*
 721 (
 722     const tmp<areaScalarField>&,
 723     const faMatrix<Type>&
 724 );
 725
 726 template<class Type>
 727 tmp<faMatrix<Type> > operator*
 728 (
 729     const tmp<areaScalarField>&,
 730     const tmp<faMatrix<Type> >&
 731 );
 732
 733
 734 template<class Type>
 735 tmp<faMatrix<Type> > operator*
 736 (
 737     const dimensioned<scalar>&,
 738     const faMatrix<Type>&
 739 );
 740
 741 template<class Type>
 742 tmp<faMatrix<Type> > operator*
 743 (
 744     const dimensioned<scalar>&,
 745     const tmp<faMatrix<Type> >&
 746 );
 747
 748
 749 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 750
 751 } // End namespace Foam
 752
 753 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 754
 755 #ifdef NoRepository
 756 #   include "faMatrix.C"
 757 #endif
 758
 759 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 760
 761 #endif
 762
 763 // ************************************************************************* //