Merge pull request #15576 from pcafrica/serialization_tria_base

Unified interface for serializing triangulations.
dealii · Jul 9, 2023 · 41355f7 · 41355f7
2 parents 5a53477 + f765e89
commit 41355f7
Show file tree

Hide file tree

Showing 38 changed files with 1,940 additions and 1,860 deletions.
diff --git a/doc/news/changes/minor/20230703PasqualeClaudioAfrica b/doc/news/changes/minor/20230703PasqualeClaudioAfrica
@@ -0,0 +1,3 @@
+Deprecated: The CellStatus enumeration has been deprecated in the Triangulation<dim, spacedim> class and moved to the global deal.II namespace. As a consequence, all references to Triangulation<dim, spacedim>, parallel::distributed::Triangulation<dim, spacedim>::CellStatus, and similar should be updated to use CellStatus directly. Also, the enumeration values have been renamed: CELL_PERSIST -> cell_will_persist, CELL_REFINE -> cell_will_be_refined, CELL_COARSEN -> children_will_be_coarsened, CELL_INVALID -> cell_invalid).
+<br>
+(Pasquale Claudio Africa, 2023/07/03)
diff --git a/examples/step-68/step-68.cc b/examples/step-68/step-68.cc
@@ -253,9 +253,8 @@ namespace Step68
     // `private`.
     unsigned int cell_weight(
       const typename parallel::distributed::Triangulation<dim>::cell_iterator
-        &cell,
-      const typename parallel::distributed::Triangulation<dim>::CellStatus
-        status) const;
+        &              cell,
+      const CellStatus status) const;
 
     // The following two functions are responsible for outputting the simulation
     // results for the particles and for the velocity profile on the background
@@ -329,9 +328,8 @@ namespace Step68
   template <int dim>
   unsigned int ParticleTracking<dim>::cell_weight(
     const typename parallel::distributed::Triangulation<dim>::cell_iterator
-      &                                                                  cell,
-    const typename parallel::distributed::Triangulation<dim>::CellStatus status)
-    const
+      &              cell,
+    const CellStatus status) const
   {
     // First, we introduce a base weight that will be assigned to every cell.
     const unsigned int base_weight = 1;
@@ -347,21 +345,21 @@ namespace Step68
     const unsigned int particle_weight = 10;
 
     // This example does not use adaptive refinement, therefore every cell
-    // should have the status `CELL_PERSIST`. However this function can also
-    // be used to distribute load during refinement, therefore we consider
-    // refined or coarsened cells as well.
+    // should have the status `CellStatus::cell_will_persist`. However this
+    // function can also be used to distribute load during refinement, therefore
+    // we consider refined or coarsened cells as well.
     unsigned int n_particles_in_cell = 0;
     switch (status)
       {
-        case parallel::distributed::Triangulation<dim>::CELL_PERSIST:
-        case parallel::distributed::Triangulation<dim>::CELL_REFINE:
+        case CellStatus::cell_will_persist:
+        case CellStatus::cell_will_be_refined:
           n_particles_in_cell = particle_handler.n_particles_in_cell(cell);
           break;
 
-        case parallel::distributed::Triangulation<dim>::CELL_INVALID:
+        case CellStatus::cell_invalid:
           break;
 
-        case parallel::distributed::Triangulation<dim>::CELL_COARSEN:
+        case CellStatus::children_will_be_coarsened:
           for (const auto &child : cell->child_iterators())
             n_particles_in_cell += particle_handler.n_particles_in_cell(child);
           break;
@@ -399,11 +397,11 @@ namespace Step68
     // of this class, but for the purpose of this example we want to group the
     // particle related instructions.
     background_triangulation.signals.weight.connect(
-      [&](
-        const typename parallel::distributed::Triangulation<dim>::cell_iterator
-          &cell,
-        const typename parallel::distributed::Triangulation<dim>::CellStatus
-          status) -> unsigned int { return this->cell_weight(cell, status); });
+      [&](const typename parallel::distributed::Triangulation<
+            dim>::cell_iterator &cell,
+          const CellStatus       status) -> unsigned int {
+        return this->cell_weight(cell, status);
+      });
 
     // This initializes the background triangulation where the particles are
     // living and the number of properties of the particles.

diff --git a/include/deal.II/base/quadrature_point_data.h b/include/deal.II/base/quadrature_point_data.h
@@ -500,9 +500,8 @@ namespace parallel
       std::vector<char>
       pack_function(
         const typename parallel::distributed::Triangulation<dim>::cell_iterator
-          &cell,
-        const typename parallel::distributed::Triangulation<dim>::CellStatus
-          status);
+          &              cell,
+        const CellStatus status);
 
       /**
        * A callback function used to unpack the data on the current mesh that
@@ -512,9 +511,8 @@ namespace parallel
       void
       unpack_function(
         const typename parallel::distributed::Triangulation<dim>::cell_iterator
-          &cell,
-        const typename parallel::distributed::Triangulation<dim>::CellStatus
-          status,
+          &              cell,
+        const CellStatus status,
         const boost::iterator_range<std::vector<char>::const_iterator>
           &data_range);
 
@@ -935,11 +933,11 @@ namespace parallel
       data_storage  = &data_storage_;
 
       handle = triangulation->register_data_attach(
-        [this](
-          const typename parallel::distributed::Triangulation<
-            dim>::cell_iterator &cell,
-          const typename parallel::distributed::Triangulation<dim>::CellStatus
-            status) { return this->pack_function(cell, status); },
+        [this](const typename parallel::distributed::Triangulation<
+                 dim>::cell_iterator &cell,
+               const CellStatus       status) {
+          return this->pack_function(cell, status);
+        },
         /*returns_variable_size_data=*/true);
     }
 
@@ -951,13 +949,13 @@ namespace parallel
     {
       triangulation->notify_ready_to_unpack(
         handle,
-        [this](
-          const typename parallel::distributed::Triangulation<
-            dim>::cell_iterator &cell,
-          const typename parallel::distributed::Triangulation<dim>::CellStatus
-            status,
-          const boost::iterator_range<std::vector<char>::const_iterator>
-            &data_range) { this->unpack_function(cell, status, data_range); });
+        [this](const typename parallel::distributed::Triangulation<
+                 dim>::cell_iterator &cell,
+               const CellStatus       status,
+               const boost::iterator_range<std::vector<char>::const_iterator>
+                 &data_range) {
+          this->unpack_function(cell, status, data_range);
+        });
 
       // invalidate the pointers
       data_storage  = nullptr;
@@ -971,8 +969,7 @@ namespace parallel
     ContinuousQuadratureDataTransfer<dim, DataType>::pack_function(
       const typename parallel::distributed::Triangulation<dim>::cell_iterator
         &cell,
-      const typename parallel::distributed::Triangulation<
-        dim>::CellStatus /*status*/)
+      const CellStatus /*status*/)
     {
       pack_cell_data(cell, data_storage, matrix_quadrature);
 
@@ -991,14 +988,12 @@ namespace parallel
     inline void
     ContinuousQuadratureDataTransfer<dim, DataType>::unpack_function(
       const typename parallel::distributed::Triangulation<dim>::cell_iterator
-        &cell,
-      const typename parallel::distributed::Triangulation<dim>::CellStatus
-        status,
+        &              cell,
+      const CellStatus status,
       const boost::iterator_range<std::vector<char>::const_iterator>
         &data_range)
     {
-      Assert((status !=
-              parallel::distributed::Triangulation<dim, dim>::CELL_COARSEN),
+      Assert((status != CellStatus::children_will_be_coarsened),
              ExcNotImplemented());
       (void)status;
 

diff --git a/include/deal.II/distributed/cell_data_transfer.h b/include/deal.II/distributed/cell_data_transfer.h
@@ -290,8 +290,7 @@ namespace parallel
       std::vector<char>
       pack_callback(const typename parallel::distributed::
                       Triangulation<dim, spacedim>::cell_iterator &cell,
-                    const typename parallel::distributed::
-                      Triangulation<dim, spacedim>::CellStatus status);
+                    const CellStatus                               status);
 
       /**
        * A callback function used to unpack the data on the current mesh that
@@ -302,8 +301,7 @@ namespace parallel
       unpack_callback(
         const typename parallel::distributed::Triangulation<dim, spacedim>::
           cell_iterator &cell,
-        const typename parallel::distributed::Triangulation<dim, spacedim>::
-          CellStatus status,
+        const CellStatus status,
         const boost::iterator_range<std::vector<char>::const_iterator>
           &                        data_range,
         std::vector<VectorType *> &all_out);

diff --git a/include/deal.II/distributed/cell_data_transfer.templates.h b/include/deal.II/distributed/cell_data_transfer.templates.h
@@ -110,8 +110,7 @@ namespace parallel
       handle = tria->register_data_attach(
         [this](const typename parallel::distributed::
                  Triangulation<dim, spacedim>::cell_iterator &cell,
-               const typename parallel::distributed::
-                 Triangulation<dim, spacedim>::CellStatus status) {
+               const CellStatus                               status) {
           return this->pack_callback(cell, status);
         },
         /*returns_variable_size_data=*/transfer_variable_size_data);
@@ -185,8 +184,7 @@ namespace parallel
         [this, &all_out](
           const typename parallel::distributed::Triangulation<dim, spacedim>::
             cell_iterator &cell,
-          const typename parallel::distributed::Triangulation<dim, spacedim>::
-            CellStatus status,
+          const CellStatus status,
           const boost::iterator_range<std::vector<char>::const_iterator>
             &data_range) {
           this->unpack_callback(cell, status, data_range, all_out);
@@ -247,9 +245,7 @@ namespace parallel
     CellDataTransfer<dim, spacedim, VectorType>::pack_callback(
       const typename parallel::distributed::Triangulation<dim, spacedim>::
         cell_iterator &cell,
-      const typename parallel::distributed::Triangulation<dim,
-                                                          spacedim>::CellStatus
-        status)
+      const CellStatus status)
     {
       std::vector<value_type> cell_data(input_vectors.size());
 
@@ -260,17 +256,14 @@ namespace parallel
         {
           switch (status)
             {
-              case parallel::distributed::Triangulation<dim,
-                                                        spacedim>::CELL_PERSIST:
-              case parallel::distributed::Triangulation<dim,
-                                                        spacedim>::CELL_REFINE:
+              case CellStatus::cell_will_persist:
+              case CellStatus::cell_will_be_refined:
                 // Cell either persists, or will be refined, and its children do
                 // not exist yet in the latter case.
                 *it_output = (**it_input)[cell->active_cell_index()];
                 break;
 
-              case parallel::distributed::Triangulation<dim,
-                                                        spacedim>::CELL_COARSEN:
+              case CellStatus::children_will_be_coarsened:
                 {
                   // Cell is parent whose children will get coarsened to.
                   // Decide data to store on parent by provided strategy.
@@ -314,9 +307,7 @@ namespace parallel
     CellDataTransfer<dim, spacedim, VectorType>::unpack_callback(
       const typename parallel::distributed::Triangulation<dim, spacedim>::
         cell_iterator &cell,
-      const typename parallel::distributed::Triangulation<dim,
-                                                          spacedim>::CellStatus
-        status,
+      const CellStatus status,
       const boost::iterator_range<std::vector<char>::const_iterator>
         &                        data_range,
       std::vector<VectorType *> &all_out)
@@ -344,17 +335,14 @@ namespace parallel
       for (; it_input != cell_data.cend(); ++it_input, ++it_output)
         switch (status)
           {
-            case parallel::distributed::Triangulation<dim,
-                                                      spacedim>::CELL_PERSIST:
-            case parallel::distributed::Triangulation<dim,
-                                                      spacedim>::CELL_COARSEN:
+            case CellStatus::cell_will_persist:
+            case CellStatus::children_will_be_coarsened:
               // Cell either persists, or has been coarsened.
               // Thus, cell has no (longer) children.
               (**it_output)[cell->active_cell_index()] = *it_input;
               break;
 
-            case parallel::distributed::Triangulation<dim,
-                                                      spacedim>::CELL_REFINE:
+            case CellStatus::cell_will_be_refined:
               {
                 // Cell has been refined, and is now parent of its children.
                 // Thus, distribute parent's data on its children.

diff --git a/include/deal.II/distributed/cell_weights.h b/include/deal.II/distributed/cell_weights.h
@@ -159,7 +159,7 @@ namespace parallel
      */
     static std::function<unsigned int(
       const typename dealii::Triangulation<dim, spacedim>::cell_iterator &cell,
-      const typename dealii::Triangulation<dim, spacedim>::CellStatus status)>
+      const CellStatus status)>
     make_weighting_callback(const DoFHandler<dim, spacedim> &dof_handler,
                             const WeightingFunction &weighting_function);
 
@@ -219,7 +219,7 @@ namespace parallel
     static unsigned int
     weighting_callback(
       const typename dealii::Triangulation<dim, spacedim>::cell_iterator &cell,
-      const typename dealii::Triangulation<dim, spacedim>::CellStatus status,
+      const CellStatus                                  status,
       const DoFHandler<dim, spacedim> &                 dof_handler,
       const parallel::TriangulationBase<dim, spacedim> &triangulation,
       const WeightingFunction &                         weighting_function);

diff --git a/include/deal.II/distributed/fully_distributed_tria.h b/include/deal.II/distributed/fully_distributed_tria.h
@@ -120,9 +120,6 @@ namespace parallel
       using active_cell_iterator =
         typename dealii::Triangulation<dim, spacedim>::active_cell_iterator;
 
-      using CellStatus =
-        typename dealii::Triangulation<dim, spacedim>::CellStatus;
-
       /**
        * Constructor.
        *
@@ -285,7 +282,7 @@ namespace parallel
        * will change in the private member vector local_cell_relations.
        *
        * As no adaptive mesh refinement is supported at the moment for this
-       * class, all cells will be flagged with the CellStatus CELL_PERSIST.
+       * class, all cells will be flagged with CellStatus::cell_will_persist.
        * These relations will currently only be used for serialization.
        *
        * The stored vector will have a size equal to the number of locally owned

diff --git a/include/deal.II/distributed/repartitioning_policy_tools.h b/include/deal.II/distributed/repartitioning_policy_tools.h
@@ -163,8 +163,7 @@ namespace RepartitioningPolicyTools
     CellWeightPolicy(
       const std::function<unsigned int(
         const typename Triangulation<dim, spacedim>::cell_iterator &,
-        const typename Triangulation<dim, spacedim>::CellStatus)>
-        &weighting_function);
+        const CellStatus)> &weighting_function);
 
     virtual LinearAlgebra::distributed::Vector<double>
     partition(const Triangulation<dim, spacedim> &tria_in) const override;
@@ -175,7 +174,7 @@ namespace RepartitioningPolicyTools
      */
     const std::function<
       unsigned int(const typename Triangulation<dim, spacedim>::cell_iterator &,
-                   const typename Triangulation<dim, spacedim>::CellStatus)>
+                   const CellStatus)>
       weighting_function;
   };
 

diff --git a/include/deal.II/distributed/solution_transfer.h b/include/deal.II/distributed/solution_transfer.h
@@ -349,7 +349,7 @@ namespace parallel
       std::vector<char>
       pack_callback(
         const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-        const typename Triangulation<dim, spacedim>::CellStatus     status);
+        const CellStatus                                            status);
 
       /**
        * A callback function used to unpack the data on the current mesh that
@@ -359,7 +359,7 @@ namespace parallel
       void
       unpack_callback(
         const typename Triangulation<dim, spacedim>::cell_iterator &cell,
-        const typename Triangulation<dim, spacedim>::CellStatus     status,
+        const CellStatus                                            status,
         const boost::iterator_range<std::vector<char>::const_iterator>
           &                        data_range,
         std::vector<VectorType *> &all_out,

diff --git a/include/deal.II/distributed/tria.h b/include/deal.II/distributed/tria.h
@@ -290,9 +290,6 @@ namespace parallel
       using active_cell_iterator =
         typename dealii::Triangulation<dim, spacedim>::active_cell_iterator;
 
-      using CellStatus =
-        typename dealii::Triangulation<dim, spacedim>::CellStatus;
-
       /**
        * Configuration flags for distributed Triangulations to be set in the
        * constructor. Settings can be combined using bitwise OR.