Adddress review comments

Co-authored-by: Wolfgang Bangerth <bangerth@colostates.edu>

diff --git a/include/deal.II/fe/fe_values_base.h b/include/deal.II/fe/fe_values_base.h
index 70375e33a4465342dbd3a211b6a5274ee1d61221..979b19e74d5b792dd939cb3262fd091606a4bb17 100644 (file)
--- a/include/deal.II/fe/fe_values_base.h
+++ b/include/deal.II/fe/fe_values_base.h
@@ -227,13 +227,23 @@ public:
    * The detection of simple geometries with CellSimilarity is sensitive to the
    * first cell detected. When using multiple threads, each thread might get a
    * thread local copy of the FEValues object that is initialized to the first
-   * cell the thread sees. As this cell might be differ between runs and number
-   * of threads used, this slight deviation leads to difference in roundoff
-   * errors that propagate through the program. Therefore, the CellSimilarity
-   * check is disabled by default in case more than one thread is used.
+   * cell the thread sees. As this cell might be different between runs and
+   * number of threads used, this slight deviation leads to difference in
+   * roundoff errors that propagate through the program. Therefore, deal.II
+   * disables the CellSimilarity check by default in programs that use more than
+   * one thread. This function can be used to disable this behavior: When
+   * called, FEValues objects will always do the similarity check, even in cases
+   * where the program uses multiple threads. This substantially accelerates the
+   * operations of FEValues because many operations can be avoided if a cell is,
+   * for example, just a translation of the previous cell. On the other hand,
+   * you might get results that differ by an amount proportional to round-off
+   * between the case of using or not using cell similarity information, and
+   * because the order of cells assigned to individual threads may differ from
+   * run to run, when you call this function you may end up with results that
+   * differ by round-off between runs of the same program.
    */
   void
-  allow_check_for_cell_similarity(bool allow);
+  always_allow_check_for_cell_similarity(const bool allow);
 
   /// @name Access to shape function values
   ///

diff --git a/include/deal.II/matrix_free/cuda_matrix_free.templates.h b/include/deal.II/matrix_free/cuda_matrix_free.templates.h
index c72b6f090b5976f55507ba6be380208208f1bbc0..3709471ae3b7caf48dc4ebc2a66734e41358fcc5 100644 (file)
--- a/include/deal.II/matrix_free/cuda_matrix_free.templates.h
+++ b/include/deal.II/matrix_free/cuda_matrix_free.templates.h
@@ -118,7 +118,7 @@ namespace CUDAWrappers
     {
       local_dof_indices.resize(data->dofs_per_cell);
       lexicographic_dof_indices.resize(dofs_per_cell);
-      fe_values.allow_check_for_cell_similarity(true);
+      fe_values.always_allow_check_for_cell_similarity(true);
     }
 
 

diff --git a/source/fe/fe_values_base.cc b/source/fe/fe_values_base.cc
index cb932cdb1b0896259bf79f9d537d3b29a1d6a36f..1976ced6276eeb777fb58ead11f62ae0b60dc688 100644 (file)
--- a/source/fe/fe_values_base.cc
+++ b/source/fe/fe_values_base.cc
@@ -249,7 +249,8 @@ FEValuesBase<dim, spacedim>::~FEValuesBase()
 
 template <int dim, int spacedim>
 void
-FEValuesBase<dim, spacedim>::allow_check_for_cell_similarity(bool allow)
+FEValuesBase<dim, spacedim>::always_allow_check_for_cell_similarity(
+  const bool allow)
 {
   check_for_cell_similarity_allowed = allow;
 }
@@ -1416,19 +1417,7 @@ inline void
 FEValuesBase<dim, spacedim>::check_cell_similarity(
   const typename Triangulation<dim, spacedim>::cell_iterator &cell)
 {
-  // Unfortunately, the detection of simple geometries with CellSimilarity is
-  // sensitive to the first cell detected. When doing this with multiple
-  // threads, each thread will get its own scratch data object with an
-  // FEValues object in the implementation framework from late 2013, which is
-  // initialized to the first cell the thread sees. As this number might
-  // different between different runs (after all, the tasks are scheduled
-  // dynamically onto threads), this slight deviation leads to difference in
-  // roundoff errors that propagate through the program. Therefore, we
-  // disable CellSimilarity by default in case there is more than one thread in
-  // the problem. This will likely not affect many MPI test cases as there
-  // multithreading is disabled on default, but in many other situations
-  // because we rarely explicitly set the number of threads.
-  if (!check_for_cell_similarity_allowed)
+  if (check_for_cell_similarity_allowed == false)
     {
       cell_similarity = CellSimilarity::none;
       return;