Fix serial "load balancer"

src/scheme/LoadBalancer.cpp

@@ -23,46 +23,22 @@ 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) {
+      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());
+              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->template dispatch(discrete_function.cellArrays());
+              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}));
             }
@@ -71,8 +47,6 @@ LoadBalancer::balance(const std::vector<std::shared_ptr<const DiscreteFunctionVa
       }
     },
     p_balanced_mesh_v->variant());
-#endif   // PUGS_HAS_MPI
-  }
 
   return balanced_discrete_function_list;
 }