Add new version of MGTransferGlobalCoarseningTools::create_geometric_…

…coarsening_sequence() that takes partitioner

Conflicts:
	include/deal.II/multigrid/mg_transfer_global_coarsening.templates.h

include/deal.II/multigrid/mg_transfer_global_coarsening.h

@@ -33,6 +33,12 @@ namespace internal
 {
   class MGTwoLevelTransferImplementation;
 }
+
+namespace RepartitioningPolicyTools
+{
+  template <int dim, int spacedim>
+  class Base;
+}
 #endif
 
 
@@ -102,6 +108,22 @@ namespace MGTransferGlobalCoarseningTools
   create_geometric_coarsening_sequence(
     const Triangulation<dim, spacedim> &tria);
 
+  /**
+   * Similar to the above function but also taking a @p policy for
+   * repartitioning the triangulations on the coarser levels.
+   *
+   * @note For convenience, a reference to the input triangulation is stored in
+   *   the last entry of the return vector.
+   * @note The type of the returned triangulations is
+   *   parallel::fullydistributed::Triangulation.
+   * @note Currently, only implemented for parallel::distributed::Triangulation.
+   */
+  template <int dim, int spacedim>
+  std::vector<std::shared_ptr<const Triangulation<dim, spacedim>>>
+  create_geometric_coarsening_sequence(
+    const Triangulation<dim, spacedim> &                  tria,
+    const RepartitioningPolicyTools::Base<dim, spacedim> &policy);
+
 } // namespace MGTransferGlobalCoarseningTools
 
 

include/deal.II/multigrid/mg_transfer_global_coarsening.templates.h

@@ -23,6 +23,7 @@
 #include <deal.II/base/mpi_consensus_algorithms.h>
 
 #include <deal.II/distributed/fully_distributed_tria.h>
+#include <deal.II/distributed/repartitioning_policy_tools.h>
 #include <deal.II/distributed/shared_tria.h>
 #include <deal.II/distributed/tria.h>
 
@@ -32,6 +33,7 @@
 #include <deal.II/fe/fe_tools.h>
 
 #include <deal.II/grid/grid_tools.h>
+#include <deal.II/grid/tria_description.h>
 
 #include <deal.II/hp/dof_handler.h>
 
@@ -2311,6 +2313,83 @@ namespace MGTransferGlobalCoarseningTools
 
     return coarse_grid_triangulations;
   }
+
+
+
+  template <int dim, int spacedim>
+  std::vector<std::shared_ptr<const Triangulation<dim, spacedim>>>
+  create_geometric_coarsening_sequence(
+    const Triangulation<dim, spacedim> &                  fine_triangulation_in,
+    const RepartitioningPolicyTools::Base<dim, spacedim> &policy)
+  {
+    std::vector<std::shared_ptr<const Triangulation<dim, spacedim>>>
+      coarse_grid_triangulations(fine_triangulation_in.n_global_levels());
+
+    coarse_grid_triangulations.back().reset(&fine_triangulation_in, [](auto *) {
+      // empty deleter, since fine_triangulation_in is an external field and its
+      // destructor is called somewhere else
+    });
+
+    // for a single level nothing has to be done
+    if (fine_triangulation_in.n_global_levels() == 1)
+      return coarse_grid_triangulations;
+
+#ifndef DEAL_II_WITH_P4EST
+    Assert(false, ExcNotImplemented());
+    (void)policy;
+#else
+    const auto fine_triangulation =
+      dynamic_cast<const parallel::distributed::Triangulation<dim, spacedim> *>(
+        &fine_triangulation_in);
+
+    Assert(fine_triangulation, ExcNotImplemented());
+
+    const auto comm = fine_triangulation->get_communicator();
+
+    parallel::distributed::Triangulation<dim, spacedim> temp_triangulation(
+      comm, fine_triangulation->get_mesh_smoothing());
+
+    temp_triangulation.copy_triangulation(*fine_triangulation);
+
+    const unsigned int max_level = fine_triangulation->n_global_levels() - 1;
+
+    // create coarse meshes
+    for (unsigned int l = max_level; l > 0; --l)
+      {
+        // coarsen mesh
+        temp_triangulation.coarsen_global();
+
+        // perform partition
+        const auto partition = policy.partition(temp_triangulation);
+        partition.update_ghost_values();
+
+        // create triangulation description
+        const auto construction_data =
+          partition.size() == 0 ?
+            TriangulationDescription::Utilities::
+              create_description_from_triangulation(temp_triangulation, comm) :
+            TriangulationDescription::Utilities::
+              create_description_from_triangulation(temp_triangulation,
+                                                    partition);
+
+        // create new triangulation
+        const auto level_triangulation = std::make_shared<
+          parallel::fullydistributed::Triangulation<dim, spacedim>>(comm);
+
+        for (const auto i : fine_triangulation->get_manifold_ids())
+          if (i != numbers::flat_manifold_id)
+            level_triangulation->set_manifold(
+              i, fine_triangulation->get_manifold(i));
+
+        level_triangulation->create_triangulation(construction_data);
+
+        // save mesh
+        coarse_grid_triangulations[l - 1] = level_triangulation;
+      }
+#endif
+
+    return coarse_grid_triangulations;
+  }
 } // namespace MGTransferGlobalCoarseningTools
 
 

source/multigrid/mg_transfer_global_coarsening.inst.in

@@ -29,5 +29,13 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
     MGTransferGlobalCoarseningTools::create_geometric_coarsening_sequence(
       const Triangulation<deal_II_dimension, deal_II_space_dimension>
         &fine_triangulation_in);
+
+    template std::vector<std::shared_ptr<
+      const Triangulation<deal_II_dimension, deal_II_space_dimension>>>
+    MGTransferGlobalCoarseningTools::create_geometric_coarsening_sequence(
+      const Triangulation<deal_II_dimension, deal_II_space_dimension>
+        &fine_triangulation_in,
+      const RepartitioningPolicyTools::Base<deal_II_dimension,
+                                            deal_II_space_dimension> &policy);
 #endif
   }

tests/fullydistributed_grids/repartitioning_03.cc

@@ -0,0 +1,136 @@
+// ---------------------------------------------------------------------
+//
+// Copyright (C) 2021 by the deal.II authors
+//
+// This file is part of the deal.II library.
+//
+// The deal.II library is free software; you can use it, redistribute
+// it, and/or modify it under the terms of the GNU Lesser General
+// Public License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+// The full text of the license can be found in the file LICENSE.md at
+// the top level directory of deal.II.
+//
+// ---------------------------------------------------------------------
+
+
+// Test MGTransferGlobalCoarseningTools::create_geometric_coarsening_sequence
+// with RepartitioningPolicyTools.
+
+
+#include <deal.II/base/mpi_consensus_algorithms.h>
+
+#include <deal.II/distributed/fully_distributed_tria.h>
+#include <deal.II/distributed/repartitioning_policy_tools.h>
+#include <deal.II/distributed/tria.h>
+
+#include <deal.II/fe/fe_q.h>
+
+#include <deal.II/grid/grid_generator.h>
+#include <deal.II/grid/grid_out.h>
+#include <deal.II/grid/grid_tools.h>
+#include <deal.II/grid/tria_description.h>
+
+#include <deal.II/lac/la_parallel_vector.h>
+
+#include <deal.II/multigrid/mg_transfer_global_coarsening.h>
+
+#include <deal.II/numerics/data_out.h>
+
+#include "tests.h"
+
+using namespace dealii;
+
+template <int dim, int spacedim>
+void
+create_triangulation(Triangulation<dim, spacedim> &tria)
+{
+  const unsigned int n_ref_global = 3;
+  const unsigned int n_ref_local  = 3;
+  GridGenerator::hyper_cube(tria, -1.0, +1.0);
+  tria.refine_global(n_ref_global);
+
+  for (unsigned int i = 0; i < n_ref_local; ++i)
+    {
+      for (auto cell : tria.active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            bool flag = true;
+            for (unsigned int d = 0; d < dim; d++)
+              if (cell->center()[d] > 0.0)
+                flag = false;
+            if (flag)
+              cell->set_refine_flag();
+          }
+      tria.execute_coarsening_and_refinement();
+    }
+}
+
+template <int dim, int spacedim>
+void
+output_grid(
+  const std::vector<std::shared_ptr<const Triangulation<dim, spacedim>>> &trias,
+  const std::string &                                                     label)
+{
+  deallog.push(label);
+  const auto comm    = trias.front()->get_communicator();
+  const auto my_rank = Utilities::MPI::this_mpi_process(comm);
+
+  for (unsigned int i = 0; i < trias.size(); ++i)
+    {
+      const auto &tria = *trias[i];
+
+      FE_Q<dim>       fe(2);
+      DoFHandler<dim> dof_handler(tria);
+      dof_handler.distribute_dofs(fe);
+
+      // print statistics
+      print_statistics(tria);
+      print_statistics(dof_handler);
+
+      if (false)
+        {
+          Vector<double> ranks(tria.n_active_cells());
+          ranks = my_rank;
+
+          DataOut<dim> data_out;
+          data_out.attach_triangulation(tria);
+          data_out.add_data_vector(ranks, "ranks");
+          data_out.build_patches();
+
+          data_out.write_vtu_with_pvtu_record("./", label, i, comm, 2, 0);
+        }
+    }
+  deallog.pop();
+}
+
+int
+main(int argc, char **argv)
+{
+  Utilities::MPI::MPI_InitFinalize mpi(argc, argv, 1);
+  MPILogInitAll                    all;
+
+  const unsigned int dim  = 2;
+  const MPI_Comm     comm = MPI_COMM_WORLD;
+
+  parallel::distributed::Triangulation<dim> tria(comm);
+  create_triangulation(tria);
+
+  const auto test = [&](const auto &policy, const std::string &label) {
+    const auto trias =
+      MGTransferGlobalCoarseningTools::create_geometric_coarsening_sequence(
+        tria, policy);
+    output_grid(trias, label);
+  };
+
+  // default policy (simply copy p:d:T)
+  test(RepartitioningPolicyTools::DefaultPolicy<dim>(), "grid_policy_default");
+
+  // first-child policy
+  test(RepartitioningPolicyTools::FirstChildPolicy<dim>(tria),
+       "grid_policy_first");
+
+  // first-child policy
+  test(RepartitioningPolicyTools::MinimalGranularityPolicy<dim>(4),
+       "grid_policy_minimal");
+}