renaming some variables

Author: landinjm

include/prismspf/core/variable_attributes.h

@@ -134,21 +134,21 @@ struct VariableAttributes
 
 #ifdef ADDITIONAL_OPTIMIZATIONS
   /**
-   * @brief Set the duplicate field index.
+   * @brief Set the degenerate field index.
    */
   void
-  set_duplicate_field_index(const Types::Index &_duplicate_field_index)
+  set_degenerate_field_index(const Types::Index &_degenerate_field_index)
   {
-    duplicate_field_index = _duplicate_field_index;
+    degenerate_field_index = _degenerate_field_index;
   }
 
   /**
-   * @brief Get the duplicate field index.
+   * @brief Get the degenerate field index.
    */
   [[nodiscard]] Types::Index
-  get_duplicate_field_index() const
+  get_degenerate_field_index() const
   {
-    return duplicate_field_index;
+    return degenerate_field_index;
   }
 #endif
 
@@ -358,12 +358,10 @@ struct VariableAttributes
 
 #ifdef ADDITIONAL_OPTIMIZATIONS
   /**
-   * @brief Duplicate field index.
+   * @brief Degenerate field index.
    * @remark Internally determined
-   *
-   * TODO (landinjm): Rename
    */
-  mutable Types::Index duplicate_field_index = Numbers::invalid_index;
+  mutable Types::Index degenerate_field_index = Numbers::invalid_index;
 #endif
 
   /**

include/prismspf/user_inputs/boundary_parameters.h

@@ -166,8 +166,8 @@ struct BoundaryParameters
    * @brief Check whether the boundary conditions for two fields are the same.
    */
   [[nodiscard]] bool
-  check_duplicate_boundary_conditions(const Types::Index &index_1,
-                                      const Types::Index &index_2) const;
+  check_degenerate_boundary_conditions(const Types::Index &index_1,
+                                       const Types::Index &index_2) const;
 
   /**
    * @brief Print parameters to summary.log
@@ -342,12 +342,12 @@ BoundaryParameters<dim>::postprocess_and_validate(
   bc_list.clear();
 
 #ifdef ADDITIONAL_OPTIMIZATIONS
-  // Check if any fields are duplicates in terms of boundary conditions
+  // Check if any fields are degenerate in terms of boundary conditions
   // TODO (landinjm): Clean this up
   for (const auto &[index_1, variable_1] : var_attributes)
     {
-      // Skip is the duplicate index has already been assigned
-      if (variable_1.get_duplicate_field_index() != Numbers::invalid_index)
+      // Skip is the degenerate index has already been assigned
+      if (variable_1.get_degenerate_field_index() != Numbers::invalid_index)
         {
           continue;
         }
@@ -365,20 +365,20 @@ BoundaryParameters<dim>::postprocess_and_validate(
               continue;
             }
 
-          bool is_duplicate = false;
+          bool is_degenerate = false;
 
           const auto field_type_2 = variable_2.get_field_type();
 
-          is_duplicate = field_type_1 == field_type_2 &&
-                         check_duplicate_boundary_conditions(index_1, index_2);
+          is_degenerate = field_type_1 == field_type_2 &&
+                          check_degenerate_boundary_conditions(index_1, index_2);
 
-          if (is_duplicate)
+          if (is_degenerate)
             {
               ConditionalOStreams::pout_verbose()
                 << "Field " << variable_1.get_name()
                 << " has the same boundary conditions as " << variable_2.get_name()
                 << ". Using optimizations...\n";
-              variable_2.set_duplicate_field_index(index_1);
+              variable_2.set_degenerate_field_index(index_1);
             }
         }
     }
@@ -387,7 +387,7 @@ BoundaryParameters<dim>::postprocess_and_validate(
 
 template <unsigned int dim>
 inline bool
-BoundaryParameters<dim>::check_duplicate_boundary_conditions(
+BoundaryParameters<dim>::check_degenerate_boundary_conditions(
   const Types::Index &index_1,
   const Types::Index &index_2) const
 {
@@ -402,22 +402,22 @@ BoundaryParameters<dim>::check_duplicate_boundary_conditions(
   Assert(boundary_condition_list.contains(index_2),
          dealii::ExcMessage("Invalid entry for index = " + std::to_string(index_2)));
 
-  bool is_duplicate = false;
+  bool is_degenerate = false;
 
   // First check the boundary_condition_list
   const auto &boundary_condition_1 = boundary_condition_list.at(index_1);
   const auto &boundary_condition_2 = boundary_condition_list.at(index_2);
 
-  is_duplicate = boundary_condition_1 == boundary_condition_2;
+  is_degenerate = boundary_condition_1 == boundary_condition_2;
 
   // Check the pinned points
   if (pinned_point_list.contains(index_1) && pinned_point_list.contains(index_2))
     {
-      is_duplicate =
-        is_duplicate && pinned_point_list.at(index_1) == pinned_point_list.at(index_2);
+      is_degenerate =
+        is_degenerate && pinned_point_list.at(index_1) == pinned_point_list.at(index_2);
     }
 
-  return is_duplicate;
+  return is_degenerate;
 }
 
 template <unsigned int dim>

src/core/dof_handler.cc

@@ -31,15 +31,15 @@ DofHandler<dim>::DofHandler(const UserInputParameters<dim> &_user_inputs,
   for (const auto &[index, variable] : user_inputs->get_variable_attributes())
     {
 #ifdef ADDITIONAL_OPTIMIZATIONS
-      const Types::Index duplicate_field_index =
-        user_inputs->get_variable_attributes().at(index).get_duplicate_field_index();
-      if (duplicate_field_index != Numbers::invalid_index)
+      const Types::Index degenerate_field_index =
+        user_inputs->get_variable_attributes().at(index).get_degenerate_field_index();
+      if (degenerate_field_index != Numbers::invalid_index)
         {
-          Assert(dof_handlers.contains(duplicate_field_index),
+          Assert(dof_handlers.contains(degenerate_field_index),
                  dealii::ExcMessage(
                    "The DoFHandler set does not contain an entry for index = " +
-                   std::to_string(duplicate_field_index)));
-          const_dof_handlers.push_back(dof_handlers.at(duplicate_field_index).get());
+                   std::to_string(degenerate_field_index)));
+          const_dof_handlers.push_back(dof_handlers.at(degenerate_field_index).get());
           continue;
         }
 #endif
@@ -62,37 +62,38 @@ DofHandler<dim>::DofHandler(const UserInputParameters<dim> &_user_inputs,
     {
       const unsigned int relative_level = min_level - global_min_level;
 #ifdef ADDITIONAL_OPTIMIZATIONS
-      const Types::Index duplicate_field_index =
-        user_inputs->get_variable_attributes().at(index).get_duplicate_field_index();
-      // TODO (landinjm): Duplicate field indices aren't well support because we have to
+      const Types::Index degenerate_field_index =
+        user_inputs->get_variable_attributes().at(index).get_degenerate_field_index();
+      // TODO (landinjm): Degenerate field indices aren't well support because we have to
       // deal with the edge case where the minimum multigrid levels are different
-      if (duplicate_field_index != Numbers::invalid_index)
+      if (degenerate_field_index != Numbers::invalid_index)
         {
-          if (!mg_dof_handlers.contains(duplicate_field_index))
+          if (!mg_dof_handlers.contains(degenerate_field_index))
             {
-              Assert(!degenerate_field_indices_outside_mg.contains(duplicate_field_index),
+              Assert(!degenerate_field_indices_outside_mg.contains(
+                       degenerate_field_index),
                      dealii::ExcInternalError());
-              degenerate_field_indices_outside_mg.insert(duplicate_field_index);
-              mg_dof_handlers[duplicate_field_index] =
+              degenerate_field_indices_outside_mg.insert(degenerate_field_index);
+              mg_dof_handlers[degenerate_field_index] =
                 dealii::MGLevelObject<std::unique_ptr<dealii::DoFHandler<dim>>>(
                   min_level,
                   global_max_level);
               for (unsigned int level = relative_level;
                    level < const_mg_dof_handlers.size();
                    level++)
                 {
-                  mg_dof_handlers[duplicate_field_index][level + global_min_level] =
+                  mg_dof_handlers[degenerate_field_index][level + global_min_level] =
                     std::make_unique<dealii::DoFHandler<dim>>();
                 }
             }
-          Assert(mg_dof_handlers.at(duplicate_field_index).min_level() == min_level,
+          Assert(mg_dof_handlers.at(degenerate_field_index).min_level() == min_level,
                  dealii::ExcMessage("There was a mismatch in the minimum multigrid level "
-                                    "for the duplicate fields."));
+                                    "for the degenerate fields."));
           for (unsigned int level = relative_level; level < const_mg_dof_handlers.size();
                level++)
             {
               const_mg_dof_handlers[level].push_back(
-                mg_dof_handlers[duplicate_field_index][level + global_min_level].get());
+                mg_dof_handlers[degenerate_field_index][level + global_min_level].get());
             }
           continue;
         }
@@ -133,11 +134,11 @@ DofHandler<dim>::init(const TriangulationHandler<dim> &triangulation_handler,
   for (const auto &[index, variable] : user_inputs->get_variable_attributes())
     {
 #ifdef ADDITIONAL_OPTIMIZATIONS
-      const Types::Index duplicate_field_index =
-        user_inputs->get_variable_attributes().at(index).get_duplicate_field_index();
-      if (duplicate_field_index != Numbers::invalid_index)
+      const Types::Index degenerate_field_index =
+        user_inputs->get_variable_attributes().at(index).get_degenerate_field_index();
+      if (degenerate_field_index != Numbers::invalid_index)
         {
-          n_dofs += dof_handlers.at(duplicate_field_index)->n_dofs();
+          n_dofs += dof_handlers.at(degenerate_field_index)->n_dofs();
           continue;
         }
 #endif
@@ -166,34 +167,34 @@ DofHandler<dim>::init(const TriangulationHandler<dim> &triangulation_handler,
   for (const auto &[index, dependency, min_level] : mg_info.get_lhs_fields())
     {
 #ifdef ADDITIONAL_OPTIMIZATIONS
-      const Types::Index duplicate_field_index =
-        user_inputs->get_variable_attributes().at(index).get_duplicate_field_index();
-      if (duplicate_field_index != Numbers::invalid_index)
+      const Types::Index degenerate_field_index =
+        user_inputs->get_variable_attributes().at(index).get_degenerate_field_index();
+      if (degenerate_field_index != Numbers::invalid_index)
         {
-          if (degenerate_field_indices_outside_mg.contains(duplicate_field_index) &&
-              !processed_degenerate_field_indices.contains(duplicate_field_index))
+          if (degenerate_field_indices_outside_mg.contains(degenerate_field_index) &&
+              !processed_degenerate_field_indices.contains(degenerate_field_index))
             {
-              Assert(mg_dof_handlers.contains(duplicate_field_index),
+              Assert(mg_dof_handlers.contains(degenerate_field_index),
                      dealii::ExcNotInitialized());
               for (unsigned int level = min_level; level <= mg_info.get_mg_max_level();
                    ++level)
                 {
-                  Assert(mg_dof_handlers.at(duplicate_field_index)[level] != nullptr,
+                  Assert(mg_dof_handlers.at(degenerate_field_index)[level] != nullptr,
                          dealii::ExcNotInitialized());
-                  mg_dof_handlers.at(duplicate_field_index)[level]->reinit(
+                  mg_dof_handlers.at(degenerate_field_index)[level]->reinit(
                     triangulation_handler.get_mg_triangulation(level));
-                  mg_dof_handlers.at(duplicate_field_index)[level]->distribute_dofs(
+                  mg_dof_handlers.at(degenerate_field_index)[level]->distribute_dofs(
                     fe_system.at(user_inputs->get_variable_attributes()
-                                   .at(duplicate_field_index)
+                                   .at(degenerate_field_index)
                                    .get_field_type()));
                 }
-              processed_degenerate_field_indices.insert(duplicate_field_index);
+              processed_degenerate_field_indices.insert(degenerate_field_index);
             }
           for (unsigned int level = min_level; level <= mg_info.get_mg_max_level();
                ++level)
             {
               n_dofs_with_mg +=
-                mg_dof_handlers.at(duplicate_field_index)[level]->n_dofs();
+                mg_dof_handlers.at(degenerate_field_index)[level]->n_dofs();
             }
           continue;
         }