lduMatrix.H
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration | Website: https://openfoam.org
5  \\ / A nd | Copyright (C) 2011-2019 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 Class
25  Foam::lduMatrix
26 
27 Description
28  lduMatrix is a general matrix class in which the coefficients are
29  stored as three arrays, one for the upper triangle, one for the
30  lower triangle and a third for the diagonal.
31 
32  Addressing arrays must be supplied for the upper and lower triangles.
33 
34  It might be better if this class were organised as a hierarchy starting
35  from an empty matrix, then deriving diagonal, symmetric and asymmetric
36  matrices.
37 
38 SourceFiles
39  lduMatrixATmul.C
40  lduMatrix.C
41  lduMatrixTemplates.C
42  lduMatrixOperations.C
43  lduMatrixSolver.C
44  lduMatrixPreconditioner.C
45  lduMatrixTests.C
46  lduMatrixUpdateMatrixInterfaces.C
47 
48 \*---------------------------------------------------------------------------*/
49 
50 #ifndef lduMatrix_H
51 #define lduMatrix_H
52 
53 #include "lduMesh.H"
54 #include "primitiveFieldsFwd.H"
55 #include "FieldField.H"
57 #include "typeInfo.H"
58 #include "autoPtr.H"
59 #include "runTimeSelectionTables.H"
60 #include "solverPerformance.H"
61 #include "InfoProxy.H"
62 
63 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
64 
65 namespace Foam
66 {
67 
68 // Forward declaration of friend functions and operators
69 
70 class lduMatrix;
71 
72 Ostream& operator<<(Ostream&, const lduMatrix&);
73 Ostream& operator<<(Ostream&, const InfoProxy<lduMatrix>&);
74 
75 
76 /*---------------------------------------------------------------------------*\
77  Class lduMatrix Declaration
78 \*---------------------------------------------------------------------------*/
79 
80 class lduMatrix
81 {
82  // private data
83 
84  //- LDU mesh reference
85  const lduMesh& lduMesh_;
86 
87  //- Coefficients (not including interfaces)
88  scalarField *lowerPtr_, *diagPtr_, *upperPtr_;
89 
90 
91 public:
92 
93  //- Abstract base-class for lduMatrix solvers
94  class solver
95  {
96  protected:
97 
98  // Protected data
99 
105 
106  //- Dictionary of controls
108 
109  //- Default maximum number of iterations in the solver
110  static const label defaultMaxIter_;
111 
112  //- Maximum number of iterations in the solver
113  label maxIter_;
114 
115  //- Minimum number of iterations in the solver
116  label minIter_;
117 
118  //- Final convergence tolerance
119  scalar tolerance_;
120 
121  //- Convergence tolerance relative to the initial
122  scalar relTol_;
123 
124 
125  // Protected Member Functions
126 
127  //- Read the control parameters from the controlDict_
128  virtual void readControls();
129 
130 
131  public:
132 
133  //- Runtime type information
134  virtual const word& type() const = 0;
135 
136 
137  // Declare run-time constructor selection tables
138 
140  (
141  autoPtr,
142  solver,
143  symMatrix,
144  (
145  const word& fieldName,
146  const lduMatrix& matrix,
147  const FieldField<Field, scalar>& interfaceBouCoeffs,
148  const FieldField<Field, scalar>& interfaceIntCoeffs,
149  const lduInterfaceFieldPtrsList& interfaces,
150  const dictionary& solverControls
151  ),
152  (
153  fieldName,
154  matrix,
155  interfaceBouCoeffs,
156  interfaceIntCoeffs,
157  interfaces,
158  solverControls
159  )
160  );
161 
163  (
164  autoPtr,
165  solver,
166  asymMatrix,
167  (
168  const word& fieldName,
169  const lduMatrix& matrix,
170  const FieldField<Field, scalar>& interfaceBouCoeffs,
171  const FieldField<Field, scalar>& interfaceIntCoeffs,
172  const lduInterfaceFieldPtrsList& interfaces,
173  const dictionary& solverControls
174  ),
175  (
176  fieldName,
177  matrix,
178  interfaceBouCoeffs,
179  interfaceIntCoeffs,
180  interfaces,
181  solverControls
182  )
183  );
184 
185 
186  // Constructors
187 
188  solver
189  (
190  const word& fieldName,
191  const lduMatrix& matrix,
192  const FieldField<Field, scalar>& interfaceBouCoeffs,
193  const FieldField<Field, scalar>& interfaceIntCoeffs,
194  const lduInterfaceFieldPtrsList& interfaces,
195  const dictionary& solverControls
196  );
197 
198  // Selectors
199 
200  //- Return a new solver
201  static autoPtr<solver> New
202  (
203  const word& fieldName,
204  const lduMatrix& matrix,
205  const FieldField<Field, scalar>& interfaceBouCoeffs,
206  const FieldField<Field, scalar>& interfaceIntCoeffs,
207  const lduInterfaceFieldPtrsList& interfaces,
208  const dictionary& solverControls
209  );
210 
211 
212 
213  //- Destructor
214  virtual ~solver()
215  {}
216 
217 
218  // Member Functions
219 
220  // Access
222  const word& fieldName() const
223  {
224  return fieldName_;
225  }
227  const lduMatrix& matrix() const
228  {
229  return matrix_;
230  }
233  {
234  return interfaceBouCoeffs_;
235  }
238  {
239  return interfaceIntCoeffs_;
240  }
243  {
244  return interfaces_;
245  }
246 
247 
248  //- Read and reset the solver parameters from the given stream
249  virtual void read(const dictionary&);
250 
251  virtual solverPerformance solve
252  (
253  scalarField& psi,
254  const scalarField& source,
255  const direction cmpt=0
256  ) const = 0;
257 
258  //- Return the matrix norm used to normalise the residual for the
259  // stopping criterion
260  scalar normFactor
261  (
262  const scalarField& psi,
263  const scalarField& source,
264  const scalarField& Apsi,
265  scalarField& tmpField
266  ) const;
267  };
268 
269 
270  //- Abstract base-class for lduMatrix smoothers
271  class smoother
272  {
273  protected:
274 
275  // Protected data
282 
283 
284  public:
285 
286  //- Find the smoother name (directly or from a sub-dictionary)
287  static word getName(const dictionary&);
288 
289  //- Runtime type information
290  virtual const word& type() const = 0;
291 
292 
293  // Declare run-time constructor selection tables
294 
296  (
297  autoPtr,
298  smoother,
299  symMatrix,
300  (
301  const word& fieldName,
302  const lduMatrix& matrix,
303  const FieldField<Field, scalar>& interfaceBouCoeffs,
304  const FieldField<Field, scalar>& interfaceIntCoeffs,
305  const lduInterfaceFieldPtrsList& interfaces
306  ),
307  (
308  fieldName,
309  matrix,
310  interfaceBouCoeffs,
311  interfaceIntCoeffs,
312  interfaces
313  )
314  );
315 
317  (
318  autoPtr,
319  smoother,
320  asymMatrix,
321  (
322  const word& fieldName,
323  const lduMatrix& matrix,
324  const FieldField<Field, scalar>& interfaceBouCoeffs,
325  const FieldField<Field, scalar>& interfaceIntCoeffs,
326  const lduInterfaceFieldPtrsList& interfaces
327  ),
328  (
329  fieldName,
330  matrix,
331  interfaceBouCoeffs,
332  interfaceIntCoeffs,
333  interfaces
334  )
335  );
336 
337 
338  // Constructors
339 
340  smoother
341  (
342  const word& fieldName,
343  const lduMatrix& matrix,
344  const FieldField<Field, scalar>& interfaceBouCoeffs,
345  const FieldField<Field, scalar>& interfaceIntCoeffs,
346  const lduInterfaceFieldPtrsList& interfaces
347  );
348 
349 
350  // Selectors
351 
352  //- Return a new smoother
353  static autoPtr<smoother> New
354  (
355  const word& fieldName,
356  const lduMatrix& matrix,
357  const FieldField<Field, scalar>& interfaceBouCoeffs,
358  const FieldField<Field, scalar>& interfaceIntCoeffs,
359  const lduInterfaceFieldPtrsList& interfaces,
360  const dictionary& solverControls
361  );
362 
363 
364  //- Destructor
365  virtual ~smoother()
366  {}
367 
368 
369  // Member Functions
370 
371  // Access
373  const word& fieldName() const
374  {
375  return fieldName_;
376  }
378  const lduMatrix& matrix() const
379  {
380  return matrix_;
381  }
384  {
385  return interfaceBouCoeffs_;
386  }
389  {
390  return interfaceIntCoeffs_;
391  }
394  {
395  return interfaces_;
396  }
397 
398 
399  //- Smooth the solution for a given number of sweeps
400  virtual void smooth
401  (
402  scalarField& psi,
403  const scalarField& source,
404  const direction cmpt,
405  const label nSweeps
406  ) const = 0;
407  };
408 
409 
410  //- Abstract base-class for lduMatrix preconditioners
411  class preconditioner
412  {
413  protected:
414 
415  // Protected data
416 
417  //- Reference to the base-solver this preconditioner is used with
418  const solver& solver_;
419 
420 
421  public:
422 
423  //- Find the preconditioner name (directly or from a sub-dictionary)
424  static word getName(const dictionary&);
425 
426  //- Runtime type information
427  virtual const word& type() const = 0;
428 
429 
430  // Declare run-time constructor selection tables
431 
433  (
434  autoPtr,
436  symMatrix,
437  (
438  const solver& sol,
439  const dictionary& solverControls
440  ),
441  (sol, solverControls)
442  );
443 
445  (
446  autoPtr,
448  asymMatrix,
449  (
450  const solver& sol,
451  const dictionary& solverControls
452  ),
453  (sol, solverControls)
454  );
455 
456 
457  // Constructors
458 
460  (
461  const solver& sol
462  )
463  :
464  solver_(sol)
465  {}
466 
467 
468  // Selectors
469 
470  //- Return a new preconditioner
472  (
473  const solver& sol,
474  const dictionary& solverControls
475  );
476 
477 
478  //- Destructor
479  virtual ~preconditioner()
480  {}
481 
482 
483  // Member Functions
484 
485  //- Read and reset the preconditioner parameters
486  // from the given stream
487  virtual void read(const dictionary&)
488  {}
489 
490  //- Return wA the preconditioned form of residual rA
491  virtual void precondition
492  (
493  scalarField& wA,
494  const scalarField& rA,
495  const direction cmpt=0
496  ) const = 0;
497 
498  //- Return wT the transpose-matrix preconditioned form of
499  // residual rT.
500  // This is only required for preconditioning asymmetric matrices.
501  virtual void preconditionT
502  (
503  scalarField& wT,
504  const scalarField& rT,
505  const direction cmpt=0
506  ) const
507  {
509  }
510  };
511 
512 
513  // Static data
514 
515  // Declare name of the class and its debug switch
516  ClassName("lduMatrix");
517 
518 
519  // Constructors
520 
521  //- Construct given an LDU addressed mesh.
522  // The coefficients are initially empty for subsequent setting.
523  lduMatrix(const lduMesh&);
524 
525  //- Copy constructor
526  lduMatrix(const lduMatrix&);
527 
528  //- Copy constructor or re-use as specified.
529  lduMatrix(lduMatrix&, bool reuse);
530 
531  //- Construct given an LDU addressed mesh and an Istream
532  // from which the coefficients are read
533  lduMatrix(const lduMesh&, Istream&);
534 
535 
536  //- Destructor
537  ~lduMatrix();
538 
539 
540  // Member Functions
541 
542  // Access to addressing
543 
544  //- Return the LDU mesh from which the addressing is obtained
545  const lduMesh& mesh() const
546  {
547  return lduMesh_;
548  }
549 
550  //- Return the LDU addressing
551  const lduAddressing& lduAddr() const
552  {
553  return lduMesh_.lduAddr();
554  }
555 
556  //- Return the patch evaluation schedule
557  const lduSchedule& patchSchedule() const
558  {
559  return lduAddr().patchSchedule();
560  }
561 
562 
563  // Access to coefficients
564 
565  scalarField& lower();
566  scalarField& diag();
567  scalarField& upper();
568 
569  // Size with externally provided sizes (for constructing with 'fake'
570  // mesh in GAMG)
571 
572  scalarField& lower(const label size);
573  scalarField& diag(const label nCoeffs);
574  scalarField& upper(const label nCoeffs);
575 
576 
577  const scalarField& lower() const;
578  const scalarField& diag() const;
579  const scalarField& upper() const;
581  bool hasDiag() const
582  {
583  return (diagPtr_);
584  }
586  bool hasUpper() const
587  {
588  return (upperPtr_);
589  }
591  bool hasLower() const
592  {
593  return (lowerPtr_);
594  }
596  bool diagonal() const
597  {
598  return (diagPtr_ && !lowerPtr_ && !upperPtr_);
599  }
601  bool symmetric() const
602  {
603  return (diagPtr_ && (!lowerPtr_ && upperPtr_));
604  }
606  bool asymmetric() const
607  {
608  return (diagPtr_ && lowerPtr_ && upperPtr_);
609  }
610 
611 
612  // operations
613 
614  void sumDiag();
615  void negSumDiag();
616 
617  void sumMagOffDiag(scalarField& sumOff) const;
618 
619  //- Matrix multiplication with updated interfaces.
620  void Amul
621  (
622  scalarField&,
623  const tmp<scalarField>&,
626  const direction cmpt
627  ) const;
628 
629  //- Matrix transpose multiplication with updated interfaces.
630  void Tmul
631  (
632  scalarField&,
633  const tmp<scalarField>&,
636  const direction cmpt
637  ) const;
638 
639 
640  //- Sum the coefficients on each row of the matrix
641  void sumA
642  (
643  scalarField&,
646  ) const;
647 
648 
649  void residual
650  (
651  scalarField& rA,
652  const scalarField& psi,
653  const scalarField& source,
654  const FieldField<Field, scalar>& interfaceBouCoeffs,
655  const lduInterfaceFieldPtrsList& interfaces,
656  const direction cmpt
657  ) const;
658 
660  (
661  const scalarField& psi,
662  const scalarField& source,
663  const FieldField<Field, scalar>& interfaceBouCoeffs,
664  const lduInterfaceFieldPtrsList& interfaces,
665  const direction cmpt
666  ) const;
667 
668 
669  //- Initialise the update of interfaced interfaces
670  // for matrix operations
672  (
673  const FieldField<Field, scalar>& interfaceCoeffs,
674  const lduInterfaceFieldPtrsList& interfaces,
675  const scalarField& psiif,
676  scalarField& result,
677  const direction cmpt
678  ) const;
679 
680  //- Update interfaced interfaces for matrix operations
682  (
683  const FieldField<Field, scalar>& interfaceCoeffs,
684  const lduInterfaceFieldPtrsList& interfaces,
685  const scalarField& psiif,
686  scalarField& result,
687  const direction cmpt
688  ) const;
689 
690 
691  template<class Type>
692  tmp<Field<Type>> H(const Field<Type>&) const;
693 
694  template<class Type>
695  tmp<Field<Type>> H(const tmp<Field<Type>>&) const;
696 
697  tmp<scalarField> H1() const;
698 
699  template<class Type>
700  tmp<Field<Type>> faceH(const Field<Type>&) const;
701 
702  template<class Type>
703  tmp<Field<Type>> faceH(const tmp<Field<Type>>&) const;
704 
705 
706  // Info
707 
708  //- Return info proxy.
709  // Used to print matrix information to a stream
710  InfoProxy<lduMatrix> info() const
711  {
712  return *this;
713  }
714 
715 
716  // Member Operators
717 
718  void operator=(const lduMatrix&);
719 
720  void negate();
721 
722  void operator+=(const lduMatrix&);
723  void operator-=(const lduMatrix&);
724 
725  void operator*=(const scalarField&);
726  void operator*=(scalar);
727 
728 
729  // Ostream operator
730 
731  friend Ostream& operator<<(Ostream&, const lduMatrix&);
732  friend Ostream& operator<<(Ostream&, const InfoProxy<lduMatrix>&);
733 };
734 
735 
736 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
737 
738 } // End namespace Foam
739 
740 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
741 
742 #ifdef NoRepository
743  #include "lduMatrixTemplates.C"
744 #endif
745 
746 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
747 
748 #endif
749 
750 // ************************************************************************* //
tmp< Field< Type > > faceH(const Field< Type > &) const
virtual void read(const dictionary &)
Read and reset the solver parameters from the given stream.
intWM_LABEL_SIZE_t label
A label is an int32_t or int64_t as specified by the pre-processor macro WM_LABEL_SIZE.
Definition: label.H:59
const FieldField< Field, scalar > & interfaceIntCoeffs_
Definition: lduMatrix.H:102
bool hasUpper() const
Definition: lduMatrix.H:585
A list of keyword definitions, which are a keyword followed by any number of values (e...
Definition: dictionary.H:158
lduMatrix(const lduMesh &)
Construct given an LDU addressed mesh.
Definition: lduMatrix.C:43
declareRunTimeSelectionTable(autoPtr, solver, symMatrix,(const word &fieldName, const lduMatrix &matrix, const FieldField< Field, scalar > &interfaceBouCoeffs, const FieldField< Field, scalar > &interfaceIntCoeffs, const lduInterfaceFieldPtrsList &interfaces, const dictionary &solverControls),(fieldName, matrix, interfaceBouCoeffs, interfaceIntCoeffs, interfaces, solverControls))
virtual solverPerformance solve(scalarField &psi, const scalarField &source, const direction cmpt=0) const =0
const FieldField< Field, scalar > & interfaceBouCoeffs_
Definition: lduMatrix.H:101
uint8_t direction
Definition: direction.H:45
An Istream is an abstract base class for all input systems (streams, files, token lists etc)...
Definition: Istream.H:57
void initMatrixInterfaces(const FieldField< Field, scalar > &interfaceCoeffs, const lduInterfaceFieldPtrsList &interfaces, const scalarField &psiif, scalarField &result, const direction cmpt) const
Initialise the update of interfaced interfaces.
virtual ~solver()
Destructor.
Definition: lduMatrix.H:213
void Tmul(scalarField &, const tmp< scalarField > &, const FieldField< Field, scalar > &, const lduInterfaceFieldPtrsList &, const direction cmpt) const
Matrix transpose multiplication with updated interfaces.
Abstract base class for meshes which provide LDU addressing for the construction of lduMatrix and LDU...
Definition: lduMesh.H:59
const lduMatrix & matrix() const
Definition: lduMatrix.H:226
InfoProxy< lduMatrix > info() const
Return info proxy.
Definition: lduMatrix.H:709
bool hasLower() const
Definition: lduMatrix.H:590
const FieldField< Field, scalar > & interfaceBouCoeffs() const
Definition: lduMatrix.H:231
scalarField & upper()
Definition: lduMatrix.C:197
ClassName("lduMatrix")
tmp< scalarField > H1() const
void sumMagOffDiag(scalarField &sumOff) const
Generic field type.
Definition: FieldField.H:51
void smooth(volScalarField &field, const scalar coeff)
Definition: fvcSmooth.C:35
void Amul(scalarField &, const tmp< scalarField > &, const FieldField< Field, scalar > &, const lduInterfaceFieldPtrsList &, const direction cmpt) const
Matrix multiplication with updated interfaces.
label minIter_
Minimum number of iterations in the solver.
Definition: lduMatrix.H:115
const FieldField< Field, scalar > & interfaceIntCoeffs() const
Definition: lduMatrix.H:236
void residual(scalarField &rA, const scalarField &psi, const scalarField &source, const FieldField< Field, scalar > &interfaceBouCoeffs, const lduInterfaceFieldPtrsList &interfaces, const direction cmpt) const
void sumA(scalarField &, const FieldField< Field, scalar > &, const lduInterfaceFieldPtrsList &) const
Sum the coefficients on each row of the matrix.
const lduSchedule & patchSchedule() const
Return the patch evaluation schedule.
Definition: lduMatrix.H:556
Abstract base-class for lduMatrix smoothers.
Definition: lduMatrix.H:270
Forward declarations of the specialisations of Field<T> for scalar, vector and tensor.
scalar tolerance_
Final convergence tolerance.
Definition: lduMatrix.H:118
bool hasDiag() const
Definition: lduMatrix.H:580
A class for handling words, derived from string.
Definition: word.H:59
SolverPerformance is the class returned by the LduMatrix solver containing performance statistics...
label maxIter_
Maximum number of iterations in the solver.
Definition: lduMatrix.H:112
Abstract base-class for lduMatrix solvers.
Definition: lduMatrix.H:93
lduMatrix member H operations.
const lduInterfaceFieldPtrsList & interfaces() const
Definition: lduMatrix.H:241
friend Ostream & operator<<(Ostream &, const lduMatrix &)
void updateMatrixInterfaces(const FieldField< Field, scalar > &interfaceCoeffs, const lduInterfaceFieldPtrsList &interfaces, const scalarField &psiif, scalarField &result, const direction cmpt) const
Update interfaced interfaces for matrix operations.
virtual const lduAddressing & lduAddr() const =0
Return ldu addressing.
solver(const word &fieldName, const lduMatrix &matrix, const FieldField< Field, scalar > &interfaceBouCoeffs, const FieldField< Field, scalar > &interfaceIntCoeffs, const lduInterfaceFieldPtrsList &interfaces, const dictionary &solverControls)
virtual const word & type() const =0
Runtime type information.
static autoPtr< solver > New(const word &fieldName, const lduMatrix &matrix, const FieldField< Field, scalar > &interfaceBouCoeffs, const FieldField< Field, scalar > &interfaceIntCoeffs, const lduInterfaceFieldPtrsList &interfaces, const dictionary &solverControls)
Return a new solver.
void operator=(const lduMatrix &)
const lduMatrix & matrix_
Definition: lduMatrix.H:100
bool asymmetric() const
Definition: lduMatrix.H:605
An Ostream is an abstract base class for all output systems (streams, files, token lists...
Definition: Ostream.H:53
void operator*=(const scalarField &)
lduInterfaceFieldPtrsList interfaces_
Definition: lduMatrix.H:103
scalar normFactor(const scalarField &psi, const scalarField &source, const scalarField &Apsi, scalarField &tmpField) const
Return the matrix norm used to normalise the residual for the.
dictionary controlDict_
Dictionary of controls.
Definition: lduMatrix.H:106
lduMatrix is a general matrix class in which the coefficients are stored as three arrays...
Definition: lduMatrix.H:79
Abstract base-class for lduMatrix preconditioners.
Definition: lduMatrix.H:410
A helper class for outputting values to Ostream.
Definition: InfoProxy.H:45
const lduAddressing & lduAddr() const
Return the LDU addressing.
Definition: lduMatrix.H:550
scalarField & lower()
Definition: lduMatrix.C:168
bool diagonal() const
Definition: lduMatrix.H:595
Ostream & operator<<(Ostream &, const ensightPart &)
const word & fieldName() const
Definition: lduMatrix.H:221
An auto-pointer similar to the STL auto_ptr but with automatic casting to a reference to the type and...
Definition: PtrList.H:52
const volScalarField & psi
The class contains the addressing required by the lduMatrix: upper, lower and losort.
tmp< Field< Type > > H(const Field< Type > &) const
Macros to ease declaration of run-time selection tables.
void operator-=(const lduMatrix &)
void operator+=(const lduMatrix &)
A class for managing temporary objects.
Definition: PtrList.H:53
scalarField & diag()
Definition: lduMatrix.C:186
#define NotImplemented
Issue a FatalErrorIn for a function not currently implemented.
Definition: error.H:366
const lduMesh & mesh() const
Return the LDU mesh from which the addressing is obtained.
Definition: lduMatrix.H:544
bool symmetric() const
Definition: lduMatrix.H:600
Namespace for OpenFOAM.
~lduMatrix()
Destructor.
Definition: lduMatrix.C:149
virtual void readControls()
Read the control parameters from the controlDict_.
virtual const lduSchedule & patchSchedule() const =0
static const label defaultMaxIter_
Default maximum number of iterations in the solver.
Definition: lduMatrix.H:109
scalar relTol_
Convergence tolerance relative to the initial.
Definition: lduMatrix.H:121