[WIP] - Remove solver warnings (chaos-polymtl#1254)

Description
This is a follow up to chaos-polymtl#1243 but for the solvers library.

Testing
All tests should pass.

Former-commit-id: 65020c6

Author: blaisb

include/solvers/flow_control.h

@@ -124,10 +124,10 @@ class FlowControl
   }
 
   void
-  save(std::string prefix);
+  save(const std::string &prefix);
 
   void
-  read(std::string prefix);
+  read(const std::string &prefix);
 
 private:
   // The coefficients are stored in the following fashion :

include/solvers/fluid_dynamics_matrix_free.h

@@ -74,14 +74,14 @@ class MFNavierStokesPreconditionGMG
    * @param[in] fe Describes the FE system for the vector-valued problem.
    */
   MFNavierStokesPreconditionGMG(
-    const SimulationParameters<dim>         &simulation_parameters,
-    const DoFHandler<dim>                   &dof_handler,
-    const DoFHandler<dim>                   &dof_handler_fe_q_iso_q1,
-    const std::shared_ptr<Mapping<dim>>     &mapping,
-    const std::shared_ptr<Quadrature<dim>>  &cell_quadrature,
-    const std::shared_ptr<Function<dim>>     forcing_function,
-    const std::shared_ptr<SimulationControl> simulation_control,
-    const std::shared_ptr<FESystem<dim>>     fe);
+    const SimulationParameters<dim>          &simulation_parameters,
+    const DoFHandler<dim>                    &dof_handler,
+    const DoFHandler<dim>                    &dof_handler_fe_q_iso_q1,
+    const std::shared_ptr<Mapping<dim>>      &mapping,
+    const std::shared_ptr<Quadrature<dim>>   &cell_quadrature,
+    const std::shared_ptr<Function<dim>>      forcing_function,
+    const std::shared_ptr<SimulationControl> &simulation_control,
+    const std::shared_ptr<FESystem<dim>>      fe);
 
   /**
    * @brief Initialize smoother, coarse grid solver and multigrid object
@@ -95,9 +95,9 @@ class MFNavierStokesPreconditionGMG
    * derivatives of previous solutions.
    */
   void
-  initialize(const std::shared_ptr<SimulationControl> simulation_control,
-             FlowControl<dim>                        &flow_control,
-             const VectorType                        &present_solution,
+  initialize(const std::shared_ptr<SimulationControl> &simulation_control,
+             FlowControl<dim>                         &flow_control,
+             const VectorType                         &present_solution,
              const VectorType &time_derivative_previous_solutions);
 
   /**

include/solvers/fluid_dynamics_matrix_free_operators.h

@@ -79,17 +79,17 @@ class NavierStokesOperatorBase : public Subscriptor
    * residual on or off.
    */
   NavierStokesOperatorBase(
-    const Mapping<dim>                  &mapping,
-    const DoFHandler<dim>               &dof_handler,
-    const AffineConstraints<number>     &constraints,
-    const Quadrature<dim>               &quadrature,
-    const std::shared_ptr<Function<dim>> forcing_function,
-    const double                         kinematic_viscosity,
-    const StabilizationType              stabilization,
-    const unsigned int                   mg_level,
-    std::shared_ptr<SimulationControl>   simulation_control,
-    const bool                          &enable_hessians_jacobian,
-    const bool                          &enable_hessians_residual);
+    const Mapping<dim>                       &mapping,
+    const DoFHandler<dim>                    &dof_handler,
+    const AffineConstraints<number>          &constraints,
+    const Quadrature<dim>                    &quadrature,
+    const std::shared_ptr<Function<dim>>      forcing_function,
+    const double                              kinematic_viscosity,
+    const StabilizationType                   stabilization,
+    const unsigned int                        mg_level,
+    const std::shared_ptr<SimulationControl> &simulation_control,
+    const bool                               &enable_hessians_jacobian,
+    const bool                               &enable_hessians_residual);
 
   /**
    * @brief Initialize the main matrix free object that contains all data and is
@@ -113,17 +113,17 @@ class NavierStokesOperatorBase : public Subscriptor
    * residual on or off.
    */
   void
-  reinit(const Mapping<dim>                  &mapping,
-         const DoFHandler<dim>               &dof_handler,
-         const AffineConstraints<number>     &constraints,
-         const Quadrature<dim>               &quadrature,
-         const std::shared_ptr<Function<dim>> forcing_function,
-         const double                         kinematic_viscosity,
-         const StabilizationType              stabilization,
-         const unsigned int                   mg_level,
-         std::shared_ptr<SimulationControl>   simulation_control,
-         const bool                          &enable_hessians_jacobian,
-         const bool                          &enable_hessians_residual);
+  reinit(const Mapping<dim>                       &mapping,
+         const DoFHandler<dim>                    &dof_handler,
+         const AffineConstraints<number>          &constraints,
+         const Quadrature<dim>                    &quadrature,
+         const std::shared_ptr<Function<dim>>      forcing_function,
+         const double                              kinematic_viscosity,
+         const StabilizationType                   stabilization,
+         const unsigned int                        mg_level,
+         const std::shared_ptr<SimulationControl> &simulation_control,
+         const bool                               &enable_hessians_jacobian,
+         const bool                               &enable_hessians_residual);
 
   /**
    * @brief Compute the element size h of the cells required to calculate

include/solvers/postprocessing_velocities.h

@@ -194,7 +194,7 @@ class AverageVelocities
    * @return Vector with average values.
    */
   std::vector<const VectorType *>
-  save(std::string prefix);
+  save(const std::string &prefix);
 
   /**
    * @brief Read checkpoints to continuing averaging after restart.
@@ -204,7 +204,7 @@ class AverageVelocities
    * @return Vector with average values.
    */
   std::vector<VectorType *>
-  read(std::string prefix);
+  read(const std::string &prefix);
 
 private:
   /**

include/solvers/tracer.h

@@ -388,7 +388,7 @@ class Tracer : public AuxiliaryPhysics<dim, GlobalVectorType>
    * @brief Writes the tracer flow rates to an output file
    */
   void
-  write_tracer_flow_rates(const std::vector<double> tracer_flow_rate_vector);
+  write_tracer_flow_rates(const std::vector<double> &tracer_flow_rate_vector);
 
   /**
    * @brief Writes the tracer statistics to an output file

source/solvers/cahn_hilliard.cc

@@ -51,7 +51,7 @@ CahnHilliard<dim>::setup_assemblers()
   // Time-stepping schemes
   if (is_bdf(this->simulation_control->get_assembly_method()))
     {
-      this->assemblers.push_back(
+      this->assemblers.emplace_back(
         std::make_shared<CahnHilliardAssemblerBDF<dim>>(
           this->simulation_control));
     }
@@ -63,7 +63,7 @@ CahnHilliard<dim>::setup_assemblers()
   // to the constructor separately.
 
   // Angle of contact boundary condition
-  this->assemblers.push_back(
+  this->assemblers.emplace_back(
     std::make_shared<CahnHilliardAssemblerAngleOfContact<dim>>(
       this->simulation_control,
       this->simulation_parameters.multiphysics.cahn_hilliard_parameters,
@@ -75,7 +75,7 @@ CahnHilliard<dim>::setup_assemblers()
       this->simulation_parameters.boundary_conditions_cahn_hilliard));
 
   // Free angle of contact boundary condition
-  this->assemblers.push_back(
+  this->assemblers.emplace_back(
     std::make_shared<CahnHilliardAssemblerFreeAngle<dim>>(
       this->simulation_control,
       this->simulation_parameters.multiphysics.cahn_hilliard_parameters,
@@ -87,14 +87,15 @@ CahnHilliard<dim>::setup_assemblers()
       this->simulation_parameters.boundary_conditions_cahn_hilliard));
 
   // Core assembler
-  this->assemblers.push_back(std::make_shared<CahnHilliardAssemblerCore<dim>>(
-    this->simulation_control,
-    this->simulation_parameters.multiphysics.cahn_hilliard_parameters,
-    (this->simulation_parameters.multiphysics.cahn_hilliard_parameters
-       .epsilon_set_method == Parameters::EpsilonSetMethod::manual) ?
-      this->simulation_parameters.multiphysics.cahn_hilliard_parameters
-        .epsilon :
-      GridTools::minimal_cell_diameter(*triangulation)));
+  this->assemblers.emplace_back(
+    std::make_shared<CahnHilliardAssemblerCore<dim>>(
+      this->simulation_control,
+      this->simulation_parameters.multiphysics.cahn_hilliard_parameters,
+      (this->simulation_parameters.multiphysics.cahn_hilliard_parameters
+         .epsilon_set_method == Parameters::EpsilonSetMethod::manual) ?
+        this->simulation_parameters.multiphysics.cahn_hilliard_parameters
+          .epsilon :
+        GridTools::minimal_cell_diameter(*triangulation)));
 }
 
 template <int dim>
@@ -299,12 +300,12 @@ CahnHilliard<dim>::attach_solution_to_output(DataOut<dim> &data_out)
   // phase order (Phi) and the following one is the chemical potential (eta)
 
   std::vector<std::string> solution_names;
-  solution_names.push_back("phase_order");
-  solution_names.push_back("chemical_potential");
+  solution_names.emplace_back("phase_order");
+  solution_names.emplace_back("chemical_potential");
 
   std::vector<std::string> solution_names_filtered;
-  solution_names_filtered.push_back("phase_order_filtered");
-  solution_names_filtered.push_back("chemical_potential_filtered");
+  solution_names_filtered.emplace_back("phase_order_filtered");
+  solution_names_filtered.emplace_back("chemical_potential_filtered");
 
   std::vector<DataComponentInterpretation::DataComponentInterpretation>
     data_component_interpretation(
@@ -783,14 +784,14 @@ CahnHilliard<dim>::postprocess(bool first_iteration)
               std::string independent_column_names = "time";
 
               std::vector<std::string> dependent_column_names;
-              dependent_column_names.push_back("x_cahn_hilliard");
-              dependent_column_names.push_back("y_cahn_hilliard");
+              dependent_column_names.emplace_back("x_cahn_hilliard");
+              dependent_column_names.emplace_back("y_cahn_hilliard");
               if constexpr (dim == 3)
-                dependent_column_names.push_back("z_cahn_hilliard");
-              dependent_column_names.push_back("vx_cahn_hilliard");
-              dependent_column_names.push_back("vy_cahn_hilliard");
+                dependent_column_names.emplace_back("z_cahn_hilliard");
+              dependent_column_names.emplace_back("vx_cahn_hilliard");
+              dependent_column_names.emplace_back("vy_cahn_hilliard");
               if constexpr (dim == 3)
-                dependent_column_names.push_back("vz_cahn_hilliard");
+                dependent_column_names.emplace_back("vz_cahn_hilliard");
 
               std::vector<Tensor<1, dim>> position_vector{
                 position_and_velocity.first};
@@ -941,10 +942,10 @@ CahnHilliard<dim>::write_checkpoint()
     parallel::distributed::SolutionTransfer<dim, GlobalVectorType>>(
     dof_handler);
 
-  sol_set_transfer.push_back(&present_solution);
-  for (unsigned int i = 0; i < previous_solutions.size(); ++i)
+  sol_set_transfer.emplace_back(&present_solution);
+  for (const auto &previous_solution : previous_solutions)
     {
-      sol_set_transfer.push_back(&previous_solutions[i]);
+      sol_set_transfer.emplace_back(&previous_solution);
     }
   solution_transfer->prepare_for_serialization(sol_set_transfer);
 
@@ -1491,14 +1492,10 @@ CahnHilliard<dim>::output_newton_update_norms(
   double local_max = std::numeric_limits<double>::lowest();
 
 
-  for (auto j = index_set_phase_order[0].begin();
-       j != index_set_phase_order[0].end();
-       j++)
+  for (const auto &j : index_set_phase_order[0])
     {
-      double dof_newton_update = newton_update[*j];
-
+      double dof_newton_update = newton_update[j];
       local_sum += dof_newton_update * dof_newton_update;
-
       local_max = std::max(local_max, std::abs(dof_newton_update));
     }
 
@@ -1511,14 +1508,10 @@ CahnHilliard<dim>::output_newton_update_norms(
   local_sum = 0.0;
   local_max = std::numeric_limits<double>::lowest();
 
-  for (auto j = index_set_chemical_potential[1].begin();
-       j != index_set_chemical_potential[1].end();
-       j++)
+  for (const auto &j : index_set_chemical_potential[0])
     {
-      double dof_newton_update = newton_update[*j];
-
+      double dof_newton_update = newton_update[j];
       local_sum += dof_newton_update * dof_newton_update;
-
       local_max = std::max(local_max, std::abs(dof_newton_update));
     }
 

source/solvers/flow_control.cc

@@ -100,7 +100,7 @@ FlowControl<dim>::calculate_beta(const double       &average_velocity_n,
 
 template <int dim>
 void
-FlowControl<dim>::save(std::string prefix)
+FlowControl<dim>::save(const std::string &prefix)
 {
   std::string   filename = prefix + ".flowcontrol";
   std::ofstream output(filename.c_str());
@@ -113,7 +113,7 @@ FlowControl<dim>::save(std::string prefix)
 
 template <int dim>
 void
-FlowControl<dim>::read(std::string prefix)
+FlowControl<dim>::read(const std::string &prefix)
 {
   std::string   filename = prefix + ".flowcontrol";
   std::ifstream input(filename.c_str());