updating nonlinear printing info (#385)

landinjm · landinjm · commit 241dad83c6c7 · 2025-01-27T11:21:47.000-05:00
diff --git a/applications/allenCahn_conserved/customPDE.h b/applications/allenCahn_conserved/customPDE.h
@@ -177,13 +177,13 @@ customPDE<dim, degree>::solveIncrement(bool skip_time_dependent)
   // parabolic and auxilary equations should also be here
   if (this->hasNonExplicitEquation)
     {
-      bool         nonlinear_it_converged = false;
-      unsigned int nonlinear_it_index     = 0;
+      bool         nonlinear_iteration_converged = false;
+      unsigned int nonlinear_iteration_index     = 0;
 
-      while (!nonlinear_it_converged)
+      while (!nonlinear_iteration_converged)
         {
-          nonlinear_it_converged = true; // Set to true here and will be set to false if
-                                         // any variable isn't converged
+          nonlinear_iteration_converged = true; // Set to true here and will be set to
+                                                // false if any variable isn't converged
 
           // Update residualSet for the non-explicitly updated variables
           // compute_nonexplicit_RHS()
@@ -214,16 +214,16 @@ customPDE<dim, degree>::solveIncrement(bool skip_time_dependent)
                       this->pcout << buffer;
                     }
 
-                  nonlinear_it_converged =
-                    this->updateImplicitSolution(fieldIndex, nonlinear_it_index);
+                  nonlinear_iteration_converged =
+                    this->updateImplicitSolution(fieldIndex, nonlinear_iteration_index);
 
                   // Apply Boundary conditions
                   this->applyBCs(fieldIndex);
                 }
               else if (this->fields[fieldIndex].pdetype == AUXILIARY)
                 {
                   if (this->var_attributes.at(fieldIndex).is_nonlinear ||
-                      nonlinear_it_index == 0)
+                      nonlinear_iteration_index == 0)
                     {
                       // If the equation for this field is nonlinear, save the
                       // old solution
@@ -281,18 +281,19 @@ customPDE<dim, degree>::solveIncrement(bool skip_time_dependent)
                                 {
                                   this->pcout << "Relative difference between nonlinear "
                                                  "iterations: "
-                                              << diff << " " << nonlinear_it_index << " "
-                                              << this->currentIncrement << std::endl;
+                                              << diff << " " << nonlinear_iteration_index
+                                              << " " << this->currentIncrement
+                                              << std::endl;
                                 }
 
                               if (diff > MatrixFreePDE<dim, degree>::userInputs
                                            .nonlinear_solver_parameters.getToleranceValue(
                                              fieldIndex) &&
-                                  nonlinear_it_index <
+                                  nonlinear_iteration_index <
                                     MatrixFreePDE<dim, degree>::userInputs
                                       .nonlinear_solver_parameters.getMaxIterations())
                                 {
-                                  nonlinear_it_converged = false;
+                                  nonlinear_iteration_converged = false;
                                 }
                             }
                           else
@@ -318,7 +319,7 @@ customPDE<dim, degree>::solveIncrement(bool skip_time_dependent)
                 }
             }
 
-          nonlinear_it_index++;
+          nonlinear_iteration_index++;
         }
     }
 
diff --git a/include/core/matrixFreePDE.h b/include/core/matrixFreePDE.h
@@ -288,7 +288,7 @@ class MatrixFreePDE : public Subscriptor
 
   /*Method to compute an implicit timestep*/
   bool
-  updateImplicitSolution(unsigned int fieldIndex, unsigned int nonlinear_it_index);
+  updateImplicitSolution(unsigned int fieldIndex, unsigned int nonlinear_iteration_index);
 
   /*Method to apply boundary conditions*/
   void
diff --git a/src/core/invM.cc b/src/core/invM.cc
@@ -42,20 +42,6 @@ MatrixFreePDE<dim, degree>::computeInvM()
         }
     }
 
-  // Check if invM has been found. If not, print an "error" message
-  if (!invMscalarFound)
-    {
-      pcout << "matrixFreePDE.h: no PARABOLIC scalar field... hence setting "
-               "parabolicScalarFieldIndex to 0 and marching ahead withn invM "
-               "computation\n";
-    }
-  else if (!invMvectorFound)
-    {
-      pcout << "matrixFreePDE.h: no PARABOLIC vector field... hence setting "
-               "parabolicVectorFieldIndex to 0 and marching ahead withn invM "
-               "computation\n";
-    }
-
   // Initialize invM and clear its values
   matrixFreeObject.initialize_dof_vector(invMscalar, parabolicScalarFieldIndex);
   invMscalar = 0.0;
diff --git a/src/core/solvers/solveIncrement.cc b/src/core/solvers/solveIncrement.cc
@@ -66,19 +66,14 @@ MatrixFreePDE<dim, degree>::solveIncrement(bool skip_time_dependent)
   // parabolic and auxilary equations should also be here
   if (hasNonExplicitEquation)
     {
-      bool         nonlinear_it_converged = false;
-      unsigned int nonlinear_it_index     = 0;
+      bool         nonlinear_iteration_converged = false;
+      unsigned int nonlinear_iteration_index     = 0;
 
-      while (!nonlinear_it_converged)
+      while (!nonlinear_iteration_converged)
         {
-          nonlinear_it_converged = true; // Set to true here and will be set to false if
-                                         // any variable isn't converged
+          nonlinear_iteration_converged = true;
 
           // Update residualSet for the non-explicitly updated variables
-          // compute_nonexplicit_RHS()
-          // Ideally, I'd just do this for the non-explicit variables, but for
-          // now I'll do all of them this is a little redundant, but hopefully
-          // not too terrible
           computeNonexplicitRHS();
 
           for (const auto &[fieldIndex, variable] : var_attributes)
@@ -102,15 +97,15 @@ MatrixFreePDE<dim, degree>::solveIncrement(bool skip_time_dependent)
                       pcout << buffer;
                     }
 
-                  nonlinear_it_converged =
-                    updateImplicitSolution(fieldIndex, nonlinear_it_index);
+                  nonlinear_iteration_converged =
+                    updateImplicitSolution(fieldIndex, nonlinear_iteration_index);
 
                   // Apply Boundary conditions
                   applyBCs(fieldIndex);
                 }
               else if (fields[fieldIndex].pdetype == AUXILIARY)
                 {
-                  if (variable.is_nonlinear || nonlinear_it_index == 0)
+                  if (variable.is_nonlinear || nonlinear_iteration_index == 0)
                     {
                       // If the equation for this field is nonlinear, save the old
                       // solution
@@ -164,19 +159,26 @@ MatrixFreePDE<dim, degree>::solveIncrement(bool skip_time_dependent)
                                 }
                               if (currentIncrement % userInputs.skip_print_steps == 0)
                                 {
-                                  pcout << "Relative difference between nonlinear "
-                                           "iterations: "
-                                        << diff << " " << nonlinear_it_index << " "
-                                        << currentIncrement << "\n";
+                                  snprintf(buffer,
+                                           sizeof(buffer),
+                                           "  field '%2s' [nonlinear solve] current "
+                                           "increment: %u, nonlinear "
+                                           "iteration: "
+                                           "%u, dU: %12.6e\n",
+                                           fields[fieldIndex].name.c_str(),
+                                           currentIncrement,
+                                           nonlinear_iteration_index,
+                                           diff);
+                                  pcout << buffer;
                                 }
 
                               if (diff > userInputs.nonlinear_solver_parameters
                                            .getToleranceValue(fieldIndex) &&
-                                  nonlinear_it_index <
+                                  nonlinear_iteration_index <
                                     userInputs.nonlinear_solver_parameters
                                       .getMaxIterations())
                                 {
-                                  nonlinear_it_converged = false;
+                                  nonlinear_iteration_converged = false;
                                 }
                             }
                           else
@@ -201,7 +203,7 @@ MatrixFreePDE<dim, degree>::solveIncrement(bool skip_time_dependent)
                 }
             }
 
-          nonlinear_it_index++;
+          nonlinear_iteration_index++;
         }
     }
 
@@ -286,12 +288,12 @@ MatrixFreePDE<dim, degree>::updateExplicitSolution(unsigned int fieldIndex)
 template <int dim, int degree>
 bool
 MatrixFreePDE<dim, degree>::updateImplicitSolution(unsigned int fieldIndex,
-                                                   unsigned int nonlinear_it_index)
+                                                   unsigned int nonlinear_iteration_index)
 {
   char buffer[200];
 
   // Assume convergence criterion is met, unless otherwise proven later on.
-  bool nonlinear_it_converged = true;
+  bool nonlinear_iteration_converged = true;
 
   // Apply Dirichlet BC's. This clears the residual where we want to apply Dirichlet BCs,
   // otherwise the solver sees a positive residual
@@ -469,18 +471,32 @@ MatrixFreePDE<dim, degree>::updateImplicitSolution(unsigned int fieldIndex,
             }
           if (currentIncrement % userInputs.skip_print_steps == 0)
             {
-              pcout << "Relative difference between nonlinear "
-                       "iterations: "
-                    << diff << " " << nonlinear_it_index << " " << currentIncrement
-                    << "\n";
+              snprintf(buffer,
+                       sizeof(buffer),
+                       "  field '%2s' [nonlinear solve] current increment: %u, nonlinear "
+                       "iteration: "
+                       "%u, dU: %12.6e\n",
+                       fields[fieldIndex].name.c_str(),
+                       currentIncrement,
+                       nonlinear_iteration_index,
+                       diff);
+              pcout << buffer;
             }
 
           if (diff >
                 userInputs.nonlinear_solver_parameters.getToleranceValue(fieldIndex) &&
-              nonlinear_it_index <
+              nonlinear_iteration_index <
                 userInputs.nonlinear_solver_parameters.getMaxIterations())
             {
-              nonlinear_it_converged = false;
+              nonlinear_iteration_converged = false;
+            }
+          else if (diff >
+                   userInputs.nonlinear_solver_parameters.getToleranceValue(fieldIndex))
+            {
+              pcout << "\nWarning: nonlinear solver did not converge as "
+                       "per set tolerances. consider increasing the "
+                       "maximum number of iterations or decreasing the "
+                       "solver tolerance.\n";
             }
         }
       else
@@ -492,7 +508,7 @@ MatrixFreePDE<dim, degree>::updateImplicitSolution(unsigned int fieldIndex,
     }
   else
     {
-      if (nonlinear_it_index == 0)
+      if (nonlinear_iteration_index == 0)
         {
           if (fields[fieldIndex].type == SCALAR)
             {
@@ -532,5 +548,5 @@ MatrixFreePDE<dim, degree>::updateImplicitSolution(unsigned int fieldIndex,
         }
     }
 
-  return nonlinear_it_converged;
+  return nonlinear_iteration_converged;
 }

Original file line number	Diff line number	Diff line change
`@@ -177,13 +177,13 @@ customPDE<dim, degree>::solveIncrement(bool skip_time_dependent)`
`177`	`177`	`// parabolic and auxilary equations should also be here`
`178`	`178`	`if (this->hasNonExplicitEquation)`
`179`	`179`	`{`
`180`		`- bool nonlinear_it_converged = false;`
`181`		`- unsigned int nonlinear_it_index = 0;`
	`180`	`+ bool nonlinear_iteration_converged = false;`
	`181`	`+ unsigned int nonlinear_iteration_index = 0;`
`182`	`182`
`183`		`- while (!nonlinear_it_converged)`
	`183`	`+ while (!nonlinear_iteration_converged)`
`184`	`184`	`{`
`185`		`- nonlinear_it_converged = true; // Set to true here and will be set to false if`
`186`		`- // any variable isn't converged`
	`185`	`+ nonlinear_iteration_converged = true; // Set to true here and will be set to`
	`186`	`+ // false if any variable isn't converged`
`187`	`187`
`188`	`188`	`// Update residualSet for the non-explicitly updated variables`
`189`	`189`	`// compute_nonexplicit_RHS()`
`@@ -214,16 +214,16 @@ customPDE<dim, degree>::solveIncrement(bool skip_time_dependent)`
`214`	`214`	`this->pcout << buffer;`
`215`	`215`	`}`
`216`	`216`
`217`		`- nonlinear_it_converged =`
`218`		`- this->updateImplicitSolution(fieldIndex, nonlinear_it_index);`
	`217`	`+ nonlinear_iteration_converged =`
	`218`	`+ this->updateImplicitSolution(fieldIndex, nonlinear_iteration_index);`
`219`	`219`
`220`	`220`	`// Apply Boundary conditions`
`221`	`221`	`this->applyBCs(fieldIndex);`
`222`	`222`	`}`
`223`	`223`	`else if (this->fields[fieldIndex].pdetype == AUXILIARY)`
`224`	`224`	`{`
`225`	`225`	`if (this->var_attributes.at(fieldIndex).is_nonlinear \|\|`
`226`		`- nonlinear_it_index == 0)`
	`226`	`+ nonlinear_iteration_index == 0)`
`227`	`227`	`{`
`228`	`228`	`// If the equation for this field is nonlinear, save the`
`229`	`229`	`// old solution`
`@@ -281,18 +281,19 @@ customPDE<dim, degree>::solveIncrement(bool skip_time_dependent)`
`281`	`281`	`{`
`282`	`282`	`this->pcout << "Relative difference between nonlinear "`
`283`	`283`	`"iterations: "`
`284`		`- << diff << " " << nonlinear_it_index << " "`
`285`		`- << this->currentIncrement << std::endl;`
	`284`	`+ << diff << " " << nonlinear_iteration_index`
	`285`	`+ << " " << this->currentIncrement`
	`286`	`+ << std::endl;`
`286`	`287`	`}`
`287`	`288`
`288`	`289`	`if (diff > MatrixFreePDE<dim, degree>::userInputs`
`289`	`290`	`.nonlinear_solver_parameters.getToleranceValue(`
`290`	`291`	`fieldIndex) &&`
`291`		`- nonlinear_it_index <`
	`292`	`+ nonlinear_iteration_index <`
`292`	`293`	`MatrixFreePDE<dim, degree>::userInputs`
`293`	`294`	`.nonlinear_solver_parameters.getMaxIterations())`
`294`	`295`	`{`
`295`		`- nonlinear_it_converged = false;`
	`296`	`+ nonlinear_iteration_converged = false;`
`296`	`297`	`}`
`297`	`298`	`}`
`298`	`299`	`else`
`@@ -318,7 +319,7 @@ customPDE<dim, degree>::solveIncrement(bool skip_time_dependent)`
`318`	`319`	`}`
`319`	`320`	`}`
`320`	`321`
`321`		`- nonlinear_it_index++;`
	`322`	`+ nonlinear_iteration_index++;`
`322`	`323`	`}`
`323`	`324`	`}`
`324`	`325`
Original file line number	Diff line number	Diff line change
`@@ -66,19 +66,14 @@ MatrixFreePDE<dim, degree>::solveIncrement(bool skip_time_dependent)`
`66`	`66`	`// parabolic and auxilary equations should also be here`
`67`	`67`	`if (hasNonExplicitEquation)`
`68`	`68`	`{`
`69`		`- bool nonlinear_it_converged = false;`
`70`		`- unsigned int nonlinear_it_index = 0;`
	`69`	`+ bool nonlinear_iteration_converged = false;`
	`70`	`+ unsigned int nonlinear_iteration_index = 0;`
`71`	`71`
`72`		`- while (!nonlinear_it_converged)`
	`72`	`+ while (!nonlinear_iteration_converged)`
`73`	`73`	`{`
`74`		`- nonlinear_it_converged = true; // Set to true here and will be set to false if`
`75`		`- // any variable isn't converged`
	`74`	`+ nonlinear_iteration_converged = true;`
`76`	`75`
`77`	`76`	`// Update residualSet for the non-explicitly updated variables`
`78`		`- // compute_nonexplicit_RHS()`
`79`		`- // Ideally, I'd just do this for the non-explicit variables, but for`
`80`		`- // now I'll do all of them this is a little redundant, but hopefully`
`81`		`- // not too terrible`
`82`	`77`	`computeNonexplicitRHS();`
`83`	`78`
`84`	`79`	`for (const auto &[fieldIndex, variable] : var_attributes)`
`@@ -102,15 +97,15 @@ MatrixFreePDE<dim, degree>::solveIncrement(bool skip_time_dependent)`
`102`	`97`	`pcout << buffer;`
`103`	`98`	`}`
`104`	`99`
`105`		`- nonlinear_it_converged =`
`106`		`- updateImplicitSolution(fieldIndex, nonlinear_it_index);`
	`100`	`+ nonlinear_iteration_converged =`
	`101`	`+ updateImplicitSolution(fieldIndex, nonlinear_iteration_index);`
`107`	`102`
`108`	`103`	`// Apply Boundary conditions`
`109`	`104`	`applyBCs(fieldIndex);`
`110`	`105`	`}`
`111`	`106`	`else if (fields[fieldIndex].pdetype == AUXILIARY)`
`112`	`107`	`{`
`113`		`- if (variable.is_nonlinear \|\| nonlinear_it_index == 0)`
	`108`	`+ if (variable.is_nonlinear \|\| nonlinear_iteration_index == 0)`
`114`	`109`	`{`
`115`	`110`	`// If the equation for this field is nonlinear, save the old`
`116`	`111`	`// solution`
`@@ -164,19 +159,26 @@ MatrixFreePDE<dim, degree>::solveIncrement(bool skip_time_dependent)`
`164`	`159`	`}`
`165`	`160`	`if (currentIncrement % userInputs.skip_print_steps == 0)`
`166`	`161`	`{`
`167`		`- pcout << "Relative difference between nonlinear "`
`168`		`- "iterations: "`
`169`		`- << diff << " " << nonlinear_it_index << " "`
`170`		`- << currentIncrement << "\n";`
	`162`	`+ snprintf(buffer,`
	`163`	`+ sizeof(buffer),`
	`164`	`+ " field '%2s' [nonlinear solve] current "`
	`165`	`+ "increment: %u, nonlinear "`
	`166`	`+ "iteration: "`
	`167`	`+ "%u, dU: %12.6e\n",`
	`168`	`+ fields[fieldIndex].name.c_str(),`
	`169`	`+ currentIncrement,`
	`170`	`+ nonlinear_iteration_index,`
	`171`	`+ diff);`
	`172`	`+ pcout << buffer;`
`171`	`173`	`}`
`172`	`174`
`173`	`175`	`if (diff > userInputs.nonlinear_solver_parameters`
`174`	`176`	`.getToleranceValue(fieldIndex) &&`
`175`		`- nonlinear_it_index <`
	`177`	`+ nonlinear_iteration_index <`
`176`	`178`	`userInputs.nonlinear_solver_parameters`
`177`	`179`	`.getMaxIterations())`
`178`	`180`	`{`
`179`		`- nonlinear_it_converged = false;`
	`181`	`+ nonlinear_iteration_converged = false;`
`180`	`182`	`}`
`181`	`183`	`}`
`182`	`184`	`else`
`@@ -201,7 +203,7 @@ MatrixFreePDE<dim, degree>::solveIncrement(bool skip_time_dependent)`
`201`	`203`	`}`
`202`	`204`	`}`
`203`	`205`
`204`		`- nonlinear_it_index++;`
	`206`	`+ nonlinear_iteration_index++;`
`205`	`207`	`}`
`206`	`208`	`}`
`207`	`209`
`@@ -286,12 +288,12 @@ MatrixFreePDE<dim, degree>::updateExplicitSolution(unsigned int fieldIndex)`
`286`	`288`	`template <int dim, int degree>`
`287`	`289`	`bool`
`288`	`290`	`MatrixFreePDE<dim, degree>::updateImplicitSolution(unsigned int fieldIndex,`
`289`		`- unsigned int nonlinear_it_index)`
	`291`	`+ unsigned int nonlinear_iteration_index)`
`290`	`292`	`{`
`291`	`293`	`char buffer[200];`
`292`	`294`
`293`	`295`	`// Assume convergence criterion is met, unless otherwise proven later on.`
`294`		`- bool nonlinear_it_converged = true;`
	`296`	`+ bool nonlinear_iteration_converged = true;`
`295`	`297`
`296`	`298`	`// Apply Dirichlet BC's. This clears the residual where we want to apply Dirichlet BCs,`
`297`	`299`	`// otherwise the solver sees a positive residual`
`@@ -469,18 +471,32 @@ MatrixFreePDE<dim, degree>::updateImplicitSolution(unsigned int fieldIndex,`
`469`	`471`	`}`
`470`	`472`	`if (currentIncrement % userInputs.skip_print_steps == 0)`
`471`	`473`	`{`
`472`		`- pcout << "Relative difference between nonlinear "`
`473`		`- "iterations: "`
`474`		`- << diff << " " << nonlinear_it_index << " " << currentIncrement`
`475`		`- << "\n";`
	`474`	`+ snprintf(buffer,`
	`475`	`+ sizeof(buffer),`
	`476`	`+ " field '%2s' [nonlinear solve] current increment: %u, nonlinear "`
	`477`	`+ "iteration: "`
	`478`	`+ "%u, dU: %12.6e\n",`
	`479`	`+ fields[fieldIndex].name.c_str(),`
	`480`	`+ currentIncrement,`
	`481`	`+ nonlinear_iteration_index,`
	`482`	`+ diff);`
	`483`	`+ pcout << buffer;`
`476`	`484`	`}`
`477`	`485`
`478`	`486`	`if (diff >`
`479`	`487`	`userInputs.nonlinear_solver_parameters.getToleranceValue(fieldIndex) &&`
`480`		`- nonlinear_it_index <`
	`488`	`+ nonlinear_iteration_index <`
`481`	`489`	`userInputs.nonlinear_solver_parameters.getMaxIterations())`
`482`	`490`	`{`
`483`		`- nonlinear_it_converged = false;`
	`491`	`+ nonlinear_iteration_converged = false;`
	`492`	`+ }`
	`493`	`+ else if (diff >`
	`494`	`+ userInputs.nonlinear_solver_parameters.getToleranceValue(fieldIndex))`
	`495`	`+ {`
	`496`	`+ pcout << "\nWarning: nonlinear solver did not converge as "`
	`497`	`+ "per set tolerances. consider increasing the "`
	`498`	`+ "maximum number of iterations or decreasing the "`
	`499`	`+ "solver tolerance.\n";`
`484`	`500`	`}`
`485`	`501`	`}`
`486`	`502`	`else`
`@@ -492,7 +508,7 @@ MatrixFreePDE<dim, degree>::updateImplicitSolution(unsigned int fieldIndex,`
`492`	`508`	`}`
`493`	`509`	`else`
`494`	`510`	`{`
`495`		`- if (nonlinear_it_index == 0)`
	`511`	`+ if (nonlinear_iteration_index == 0)`
`496`	`512`	`{`
`497`	`513`	`if (fields[fieldIndex].type == SCALAR)`
`498`	`514`	`{`
`@@ -532,5 +548,5 @@ MatrixFreePDE<dim, degree>::updateImplicitSolution(unsigned int fieldIndex,`
`532`	`548`	`}`
`533`	`549`	`}`
`534`	`550`
`535`		`- return nonlinear_it_converged;`
	`551`	`+ return nonlinear_iteration_converged;`
`536`	`552`	`}`