Merge branch 'issue-1615-solver-verbosity' into 'develop'

ENH: linear solvers: add variable-specific debug flags

See merge request Development/openfoam!478

src/OpenFOAM/matrices/LduMatrix/LduMatrix/LduMatrix.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -134,6 +134,9 @@ public:
             //- Minimum number of iterations in the solver
             label minIter_;
 
+            //- Level of verbosity in the solver output statements
+            label log_;
+
             //- Final convergence tolerance
             Type tolerance_;
 

src/OpenFOAM/matrices/LduMatrix/LduMatrix/LduMatrixSolver.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -131,6 +131,7 @@ Foam::LduMatrix<Type, DType, LUType>::solver::solver
 
     maxIter_(defaultMaxIter_),
     minIter_(0),
+    log_(1),
     tolerance_(1e-6*pTraits<Type>::one),
     relTol_(Zero)
 {
@@ -145,6 +146,7 @@ void Foam::LduMatrix<Type, DType, LUType>::solver::readControls()
 {
     readControl(controlDict_, maxIter_, "maxIter");
     readControl(controlDict_, minIter_, "minIter");
+    readControl(controlDict_, log_, "log");
     readControl(controlDict_, tolerance_, "tolerance");
     readControl(controlDict_, relTol_, "relTol");
 }

src/OpenFOAM/matrices/LduMatrix/LduMatrix/SolverPerformance.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -62,10 +63,11 @@ template<class Type>
 bool Foam::SolverPerformance<Type>::checkConvergence
 (
     const Type& Tolerance,
-    const Type& RelTolerance
+    const Type& RelTolerance,
+    const label log
 )
 {
-    if (debug >= 2)
+    if ((log >= 2) || (debug >= 2))
     {
         Info<< solverName_
             << ":  Iteration " << nIterations_

src/OpenFOAM/matrices/LduMatrix/LduMatrix/SolverPerformance.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2012-2016 OpenFOAM Foundation
+    Copyright (C) 2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -218,7 +219,8 @@ public:
         bool checkConvergence
         (
             const Type& tolerance,
-            const Type& relTolerance
+            const Type& relTolerance,
+            const label log
         );
 
         //- Singularity test

src/OpenFOAM/matrices/LduMatrix/Solvers/PBiCCCG/PBiCCCG.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -98,7 +99,7 @@ Foam::PBiCCCG<Type, DType, LUType>::solve
     // --- Calculate normalisation factor
     Type normFactor = this->normFactor(psi, wA, pA);
 
-    if (LduMatrix<Type, DType, LUType>::debug >= 2)
+    if ((this->log_ >= 2) || (LduMatrix<Type, DType, LUType>::debug >= 2))
     {
         Info<< "   Normalisation factor = " << normFactor << endl;
     }
@@ -111,7 +112,12 @@ Foam::PBiCCCG<Type, DType, LUType>::solve
     if
     (
         this->minIter_ > 0
-     || !solverPerf.checkConvergence(this->tolerance_, this->relTol_)
+     || !solverPerf.checkConvergence
+        (
+            this->tolerance_,
+            this->relTol_,
+            this->log_
+        )
     )
     {
         // --- Select and construct the preconditioner
@@ -192,7 +198,12 @@ Foam::PBiCCCG<Type, DType, LUType>::solve
         (
             (
                 nIter++ < this->maxIter_
-            && !solverPerf.checkConvergence(this->tolerance_, this->relTol_)
+            && !solverPerf.checkConvergence
+                (
+                    this->tolerance_,
+                    this->relTol_,
+                    this->log_
+                )
             )
          || nIter < this->minIter_
         );

src/OpenFOAM/matrices/LduMatrix/Solvers/PBiCICG/PBiCICG.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -95,7 +96,7 @@ Foam::PBiCICG<Type, DType, LUType>::solve(Field<Type>& psi) const
     // --- Calculate normalisation factor
     Type normFactor = this->normFactor(psi, wA, pA);
 
-    if (LduMatrix<Type, DType, LUType>::debug >= 2)
+    if ((this->log_ >= 2) || (LduMatrix<Type, DType, LUType>::debug >= 2))
     {
         Info<< "   Normalisation factor = " << normFactor << endl;
     }
@@ -105,7 +106,15 @@ Foam::PBiCICG<Type, DType, LUType>::solve(Field<Type>& psi) const
     solverPerf.finalResidual() = solverPerf.initialResidual();
 
     // --- Check convergence, solve if not converged
-    if (!solverPerf.checkConvergence(this->tolerance_, this->relTol_))
+    if
+    (
+        !solverPerf.checkConvergence
+        (
+            this->tolerance_,
+            this->relTol_,
+            this->log_
+        )
+    )
     {
         // --- Select and construct the preconditioner
         autoPtr<typename LduMatrix<Type, DType, LUType>::preconditioner>
@@ -192,7 +201,12 @@ Foam::PBiCICG<Type, DType, LUType>::solve(Field<Type>& psi) const
         } while
         (
             nIter++ < this->maxIter_
-        && !(solverPerf.checkConvergence(this->tolerance_, this->relTol_))
+        && !solverPerf.checkConvergence
+            (
+                this->tolerance_,
+                this->relTol_,
+                this->log_
+            )
         );
     }
 

src/OpenFOAM/matrices/LduMatrix/Solvers/PCICG/PCICG.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -86,7 +87,7 @@ Foam::PCICG<Type, DType, LUType>::solve(Field<Type>& psi) const
     // --- Calculate normalisation factor
     Type normFactor = this->normFactor(psi, wA, pA);
 
-    if (LduMatrix<Type, DType, LUType>::debug >= 2)
+    if ((this->log_ >= 2) || (LduMatrix<Type, DType, LUType>::debug >= 2))
     {
         Info<< "   Normalisation factor = " << normFactor << endl;
     }
@@ -99,7 +100,12 @@ Foam::PCICG<Type, DType, LUType>::solve(Field<Type>& psi) const
     if
     (
         this->minIter_ > 0
-     || !solverPerf.checkConvergence(this->tolerance_, this->relTol_)
+     || !solverPerf.checkConvergence
+        (
+            this->tolerance_,
+            this->relTol_,
+            this->log_
+        )
     )
     {
         // --- Select and construct the preconditioner
@@ -184,7 +190,12 @@ Foam::PCICG<Type, DType, LUType>::solve(Field<Type>& psi) const
         (
             (
                 nIter++ < this->maxIter_
-            && !solverPerf.checkConvergence(this->tolerance_, this->relTol_)
+            && !solverPerf.checkConvergence
+                (
+                    this->tolerance_,
+                    this->relTol_,
+                    this->log_
+                )
             )
          || nIter < this->minIter_
         );

src/OpenFOAM/matrices/LduMatrix/Solvers/SmoothSolver/SmoothSolver.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -110,7 +111,7 @@ Foam::SmoothSolver<Type, DType, LUType>::solve(Field<Type>& psi) const
             solverPerf.finalResidual() = solverPerf.initialResidual();
         }
 
-        if (LduMatrix<Type, DType, LUType>::debug >= 2)
+        if ((this->log_ >= 2) || (LduMatrix<Type, DType, LUType>::debug >= 2))
         {
             Info<< "   Normalisation factor = " << normFactor << endl;
         }
@@ -120,7 +121,12 @@ Foam::SmoothSolver<Type, DType, LUType>::solve(Field<Type>& psi) const
         if
         (
             this->minIter_ > 0
-         || !solverPerf.checkConvergence(this->tolerance_, this->relTol_)
+         || !solverPerf.checkConvergence
+            (
+                this->tolerance_,
+                this->relTol_,
+                this->log_
+            )
         )
         {
             autoPtr<typename LduMatrix<Type, DType, LUType>::smoother>
@@ -150,7 +156,12 @@ Foam::SmoothSolver<Type, DType, LUType>::solve(Field<Type>& psi) const
             (
                 (
                     (nIter += nSweeps_) < this->maxIter_
-                && !solverPerf.checkConvergence(this->tolerance_, this->relTol_)
+                && !solverPerf.checkConvergence
+                    (
+                        this->tolerance_,
+                        this->relTol_,
+                        this->log_
+                    )
                 )
              || nIter < this->minIter_
             );

src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrix.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2016-2019 OpenCFD Ltd.
+    Copyright (C) 2016-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -120,6 +120,9 @@ public:
             //- Minimum number of iterations in the solver
             label minIter_;
 
+            //- Level of verbosity in the solver output statements
+            label log_;
+
             //- Final convergence tolerance
             scalar tolerance_;
 

src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrixSolver.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2016-2020 OpenCFD Ltd.
+    Copyright (C) 2016-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -164,6 +164,7 @@ void Foam::lduMatrix::solver::readControls()
 {
     maxIter_ = controlDict_.getOrDefault<label>("maxIter", defaultMaxIter_);
     minIter_ = controlDict_.getOrDefault<label>("minIter", 0);
+    log_ = controlDict_.getOrDefault<label>("log", 1);
     tolerance_ = controlDict_.getOrDefault<scalar>("tolerance", 1e-6);
     relTol_ = controlDict_.getOrDefault<scalar>("relTol", 0);
 }

src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGSolver.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
+    Copyright (C) 2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -208,8 +209,7 @@ Foam::GAMGSolver::GAMGSolver
         }
     }
 
-
+    if ((log_ >= 2) || (debug & 2))
-    if (debug & 2)
     {
         for
         (
@@ -368,7 +368,7 @@ void Foam::GAMGSolver::readControls()
     controlDict_.readIfPresent("scaleCorrection", scaleCorrection_);
     controlDict_.readIfPresent("directSolveCoarsest", directSolveCoarsest_);
 
-    if (debug)
+    if ((log_ >= 2) || debug)
     {
         Info<< "GAMGSolver settings :"
             << " cacheAgglomeration:" << cacheAgglomeration_

src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGSolverSolve.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2016-2019 OpenCFD Ltd.
+    Copyright (C) 2016-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -59,7 +59,7 @@ Foam::solverPerformance Foam::GAMGSolver::solve
     solveScalar normFactor =
         this->normFactor(psi, tsource(), Apsi, finestCorrection);
 
-    if (debug >= 2)
+    if ((log_ >= 2) || (debug >= 2))
     {
         Pout<< "   Normalisation factor = " << normFactor << endl;
     }
@@ -87,7 +87,7 @@ Foam::solverPerformance Foam::GAMGSolver::solve
     if
     (
         minIter_ > 0
-     || !solverPerf.checkConvergence(tolerance_, relTol_)
+     || !solverPerf.checkConvergence(tolerance_, relTol_, log_)
     )
     {
         // Create coarse grid correction fields
@@ -144,7 +144,7 @@ Foam::solverPerformance Foam::GAMGSolver::solve
                 matrix().mesh().comm()
             )/normFactor;
 
-            if (debug >= 2)
+            if ((log_ >= 2) || (debug >= 2))
             {
                 solverPerf.print(Info.masterStream(matrix().mesh().comm()));
             }
@@ -152,7 +152,7 @@ Foam::solverPerformance Foam::GAMGSolver::solve
         (
             (
               ++solverPerf.nIterations() < maxIter_
-            && !solverPerf.checkConvergence(tolerance_, relTol_)
+            && !solverPerf.checkConvergence(tolerance_, relTol_, log_)
             )
          || solverPerf.nIterations() < minIter_
         );
@@ -193,7 +193,7 @@ void Foam::GAMGSolver::Vcycle
     // Restrict finest grid residual for the next level up.
     agglomeration_.restrictField(coarseSources[0], finestResidual, 0, true);
 
-    if (debug >= 2 && nPreSweeps_)
+    if (nPreSweeps_ && ((log_ >= 2) || (debug >= 2)))
     {
         Pout<< "Pre-smoothing scaling factors: ";
     }
@@ -274,7 +274,7 @@ void Foam::GAMGSolver::Vcycle
         }
     }
 
-    if (debug >= 2 && nPreSweeps_)
+    if (nPreSweeps_ && ((log_ >= 2) || (debug >= 2)))
     {
         Pout<< endl;
     }
@@ -290,7 +290,7 @@ void Foam::GAMGSolver::Vcycle
         );
     }
 
-    if (debug >= 2)
+    if ((log_ >= 2) || (debug >= 2))
     {
         Pout<< "Post-smoothing scaling factors: ";
     }
@@ -703,7 +703,7 @@ void Foam::GAMGSolver::solveCoarsestLevel
             )
         );
 
-        if (debug)
+        if ((log_ >= 2) || debug)
         {
             coarseSolverPerf.print(Info.masterStream(coarseComm));
         }

src/OpenFOAM/matrices/lduMatrix/solvers/PBiCG/PBiCG.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -111,7 +111,7 @@ Foam::solverPerformance Foam::PBiCG::solve
     // --- Calculate normalisation factor
     const solveScalar normFactor = this->normFactor(psi, tsource(), wA, pA);
 
-    if (lduMatrix::debug >= 2)
+    if ((log_ >= 2) || (lduMatrix::debug >= 2))
     {
         Info<< "   Normalisation factor = " << normFactor << endl;
     }
@@ -126,7 +126,7 @@ Foam::solverPerformance Foam::PBiCG::solve
     if
     (
         minIter_ > 0
-     || !solverPerf.checkConvergence(tolerance_, relTol_)
+     || !solverPerf.checkConvergence(tolerance_, relTol_, log_)
     )
     {
         solveScalarField pT(nCells, 0);
@@ -217,7 +217,7 @@ Foam::solverPerformance Foam::PBiCG::solve
         (
             (
               ++solverPerf.nIterations() < maxIter_
-            && !solverPerf.checkConvergence(tolerance_, relTol_)
+            && !solverPerf.checkConvergence(tolerance_, relTol_, log_)
             )
          || solverPerf.nIterations() < minIter_
         );

src/OpenFOAM/matrices/lduMatrix/solvers/PBiCGStab/PBiCGStab.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016-2017 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -110,7 +110,7 @@ Foam::solverPerformance Foam::PBiCGStab::scalarSolve
     // --- Calculate normalisation factor
     const solveScalar normFactor = this->normFactor(psi, source, yA, pA);
 
-    if (lduMatrix::debug >= 2)
+    if ((log_ >= 2) || (lduMatrix::debug >= 2))
     {
         Info<< "   Normalisation factor = " << normFactor << endl;
     }
@@ -125,7 +125,7 @@ Foam::solverPerformance Foam::PBiCGStab::scalarSolve
     if
     (
         minIter_ > 0
-     || !solverPerf.checkConvergence(tolerance_, relTol_)
+     || !solverPerf.checkConvergence(tolerance_, relTol_, log_)
     )
     {
         solveScalarField AyA(nCells);
@@ -219,7 +219,7 @@ Foam::solverPerformance Foam::PBiCGStab::scalarSolve
             if
             (
                 solverPerf.nIterations() >= minIter_
-             && solverPerf.checkConvergence(tolerance_, relTol_)
+             && solverPerf.checkConvergence(tolerance_, relTol_, log_)
             )
             {
                 for (label cell=0; cell<nCells; cell++)
@@ -258,7 +258,7 @@ Foam::solverPerformance Foam::PBiCGStab::scalarSolve
         (
             (
               ++solverPerf.nIterations() < maxIter_
-            && !solverPerf.checkConvergence(tolerance_, relTol_)
+            && !solverPerf.checkConvergence(tolerance_, relTol_, log_)
             )
          || solverPerf.nIterations() < minIter_
         );

src/OpenFOAM/matrices/lduMatrix/solvers/PCG/PCG.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -110,7 +110,7 @@ Foam::solverPerformance Foam::PCG::scalarSolve
     // --- Calculate normalisation factor
     solveScalar normFactor = this->normFactor(psi, source, wA, pA);
 
-    if (lduMatrix::debug >= 2)
+    if ((log_ >= 2) || (lduMatrix::debug >= 2))
     {
         Info<< "   Normalisation factor = " << normFactor << endl;
     }
@@ -125,7 +125,7 @@ Foam::solverPerformance Foam::PCG::scalarSolve
     if
     (
         minIter_ > 0
-     || !solverPerf.checkConvergence(tolerance_, relTol_)
+     || !solverPerf.checkConvergence(tolerance_, relTol_, log_)
     )
     {
         // --- Select and construct the preconditioner
@@ -193,7 +193,7 @@ Foam::solverPerformance Foam::PCG::scalarSolve
         (
             (
               ++solverPerf.nIterations() < maxIter_
-            && !solverPerf.checkConvergence(tolerance_, relTol_)
+            && !solverPerf.checkConvergence(tolerance_, relTol_, log_)
             )
          || solverPerf.nIterations() < minIter_
         );

src/OpenFOAM/matrices/lduMatrix/solvers/PPCG/PPCG.C

@@ -107,7 +107,7 @@ Foam::solverPerformance Foam::PPCG::scalarSolveCG
     solveScalarField p(nCells);
     const solveScalar normFactor = this->normFactor(psi, source, w, p);
 
-    if (lduMatrix::debug >= 2)
+    if ((log_ >= 2) || (lduMatrix::debug >= 2))
     {
         Info<< "   Normalisation factor = " << normFactor << endl;
     }
@@ -190,7 +190,7 @@ Foam::solverPerformance Foam::PPCG::scalarSolveCG
         if
         (
             (minIter_ <= 0 || solverPerf.nIterations() >= minIter_)
-         && solverPerf.checkConvergence(tolerance_, relTol_)
+         && solverPerf.checkConvergence(tolerance_, relTol_, log_)
         )
         {
             break;

src/OpenFOAM/matrices/lduMatrix/solvers/smoothSolver/smoothSolver.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2014 OpenFOAM Foundation
-    Copyright (C) 2016-2020 OpenCFD Ltd.
+    Copyright (C) 2016-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -149,7 +149,7 @@ Foam::solverPerformance Foam::smoothSolver::solve
             solverPerf.finalResidual() = solverPerf.initialResidual();
         }
 
-        if (lduMatrix::debug >= 2)
+        if ((log_ >= 2) || (lduMatrix::debug >= 2))
         {
             Info.masterStream(matrix().mesh().comm())
                 << "   Normalisation factor = " << normFactor << endl;
@@ -160,7 +160,7 @@ Foam::solverPerformance Foam::smoothSolver::solve
         if
         (
             minIter_ > 0
-         || !solverPerf.checkConvergence(tolerance_, relTol_)
+         || !solverPerf.checkConvergence(tolerance_, relTol_, log_)
         )
         {
             addProfiling(solve, "lduMatrix::smoother." + fieldName_);
@@ -203,7 +203,7 @@ Foam::solverPerformance Foam::smoothSolver::solve
             (
                 (
                     (solverPerf.nIterations() += nSweeps_) < maxIter_
-                && !solverPerf.checkConvergence(tolerance_, relTol_)
+                && !solverPerf.checkConvergence(tolerance_, relTol_, log_)
                 )
              || solverPerf.nIterations() < minIter_
             );

src/finiteVolume/fvMatrices/fvMatrix/fvMatrixSolve.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2020 OpenCFD Ltd.
+    Copyright (C) 2016-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -222,7 +222,14 @@ Foam::SolverPerformance<Type> Foam::fvMatrix<Type>::solveSegregated
             solverControls
         )->solve(psiCmpt, sourceCmpt, cmpt);
 
-        if (SolverPerformance<Type>::debug)
+        const label log =
+            solverControls.getOrDefault<label>
+            (
+                "log",
+                SolverPerformance<Type>::debug
+            );
+
+        if (log)
         {
             solverPerf.print(Info.masterStream(this->mesh().comm()));
         }
@@ -289,7 +296,14 @@ Foam::SolverPerformance<Type> Foam::fvMatrix<Type>::solveCoupled
         coupledMatrixSolver->solve(psi)
     );
 
-    if (SolverPerformance<Type>::debug)
+    const label log =
+        solverControls.getOrDefault<label>
+        (
+            "log",
+            SolverPerformance<Type>::debug
+        );
+
+    if (log)
     {
         solverPerf.print(Info.masterStream(this->mesh().comm()));
     }

src/finiteVolume/fvMatrices/fvScalarMatrix/fvScalarMatrix.C

@@ -137,7 +137,10 @@ Foam::solverPerformance Foam::fvMatrix<Foam::scalar>::fvSolver::solve
         totalSource
     );
 
-    if (solverPerformance::debug)
+    const label log =
+        solverControls.getOrDefault<label>("log", solverPerformance::debug);
+
+    if (log)
     {
         solverPerf.print(Info.masterStream(fvMat_.mesh().comm()));
     }
@@ -264,7 +267,10 @@ Foam::solverPerformance Foam::fvMatrix<Foam::scalar>::solveSegregated
         }
     }
 
-    if (solverPerformance::debug)
+    const label log =
+        solverControls.getOrDefault<label>("log", solverPerformance::debug);
+
+    if (log)
     {
         solverPerf.print(Info.masterStream(mesh().comm()));
     }

src/regionFaModels/KirchhoffShell/KirchhoffShell.C

@@ -108,7 +108,9 @@ void KirchhoffShell::solveDisplacement()
 
         wEqn.solve();
 
-        Info<< "w min/max   = " << min(w_) << ", " << max(w_) << endl;
+        Info<< "ws_vibrationShell: "
+            << "min = " << min(w_).value() << ", "
+            << "max = " << max(w_).value() << endl;
 
         if (wSubCycle.index() >= wSubCycle.nSubCycles())
         {

tutorials/incompressible/pimpleFoam/RAS/rotatingFanInRoom/system/snappyHexMeshDict

@@ -71,7 +71,7 @@ castellatedMeshControls
         // AMI{ mode inside; levels ((1E15 3));}
     }
 
-    locationInMesh (0.1 0.0 0.01);
+    locationInMesh (0.1001 0.001 0.0101);
     allowFreeStandingZoneFaces false;
 }