Fix serial "load balancer"

src/scheme/LoadBalancer.cpp

@@ -23,56 +23,30 @@ LoadBalancer::balance(const std::vector<std::shared_ptr<const DiscreteFunctionVa
 
   auto p_balanced_mesh_v = mesh_balancer.mesh();
 
-  if (parallel::size() == 1) {
-    std::visit(
-      [&balanced_discrete_function_list, &discrete_function_list](auto&& p_balanced_mesh) {
-        for (size_t i_discrete_function = 0; i_discrete_function < discrete_function_list.size();
-             ++i_discrete_function) {
-          std::visit(
-            [&balanced_discrete_function_list, p_balanced_mesh](auto&& discrete_function) {
-              using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
-              if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
-                balanced_discrete_function_list.push_back(std::make_shared<DiscreteFunctionVariant>(
-                  DiscreteFunctionT{p_balanced_mesh, discrete_function.cellValues()}));
-              } else {
-                balanced_discrete_function_list.push_back(std::make_shared<DiscreteFunctionVariant>(
-                  DiscreteFunctionT{p_balanced_mesh, discrete_function.cellArrays()}));
-              }
-            },
-            discrete_function_list[i_discrete_function]->discreteFunction());
-        }
-      },
-      p_balanced_mesh_v->variant());
-  } else {
-    // This macro test is used to avoid none reachable code for serial builds of pugs
-#ifdef PUGS_HAS_MPI
-    std::visit(
-      [&mesh_balancer, &balanced_discrete_function_list, &discrete_function_list](auto&& p_balanced_mesh) {
-        using MeshType             = mesh_type_t<decltype(p_balanced_mesh)>;
-        constexpr size_t Dimension = MeshType::Dimension;
-        const auto& dispatcher     = mesh_balancer.connectivityDispatcher()->get<Dimension>();
-
-        for (size_t i_discrete_function = 0; i_discrete_function < discrete_function_list.size();
-             ++i_discrete_function) {
-          std::visit(
-            [&balanced_discrete_function_list, &dispatcher, &p_balanced_mesh](auto&& discrete_function) {
-              using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
-              if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
-                const auto& dispatched_cell_value = dispatcher->template dispatch(discrete_function.cellValues());
-                balanced_discrete_function_list.push_back(
-                  std::make_shared<DiscreteFunctionVariant>(DiscreteFunctionT{p_balanced_mesh, dispatched_cell_value}));
-              } else {
-                const auto& dispatched_cell_array = dispatcher->template dispatch(discrete_function.cellArrays());
-                balanced_discrete_function_list.push_back(
-                  std::make_shared<DiscreteFunctionVariant>(DiscreteFunctionT{p_balanced_mesh, dispatched_cell_array}));
-              }
-            },
-            discrete_function_list[i_discrete_function]->discreteFunction());
-        }
-      },
-      p_balanced_mesh_v->variant());
-#endif   // PUGS_HAS_MPI
-  }
+  std::visit(
+    [&mesh_balancer, &balanced_discrete_function_list, &discrete_function_list](auto&& p_balanced_mesh) {
+      using MeshType             = mesh_type_t<decltype(p_balanced_mesh)>;
+      constexpr size_t Dimension = MeshType::Dimension;
+      const auto& dispatcher     = mesh_balancer.connectivityDispatcher()->get<Dimension>();
+
+      for (size_t i_discrete_function = 0; i_discrete_function < discrete_function_list.size(); ++i_discrete_function) {
+        std::visit(
+          [&balanced_discrete_function_list, &dispatcher, &p_balanced_mesh](auto&& discrete_function) {
+            using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
+            if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
+              const auto& dispatched_cell_value = dispatcher->dispatch(discrete_function.cellValues());
+              balanced_discrete_function_list.push_back(
+                std::make_shared<DiscreteFunctionVariant>(DiscreteFunctionT{p_balanced_mesh, dispatched_cell_value}));
+            } else {
+              const auto& dispatched_cell_array = dispatcher->dispatch(discrete_function.cellArrays());
+              balanced_discrete_function_list.push_back(
+                std::make_shared<DiscreteFunctionVariant>(DiscreteFunctionT{p_balanced_mesh, dispatched_cell_array}));
+            }
+          },
+          discrete_function_list[i_discrete_function]->discreteFunction());
+      }
+    },
+    p_balanced_mesh_v->variant());
 
   return balanced_discrete_function_list;
 }