[Trilinos] Move from Isorropia to Zoltan2

src/contact/src/4C_contact_interface.cpp

@@ -901,9 +901,9 @@ void CONTACT::Interface::redistribute()
       Core::Rebalance::build_graph(*idiscret_, slaveCloseRowEles);
 
   Teuchos::ParameterList slaveCloseRebalanceParams;
-  slaveCloseRebalanceParams.set<std::string>("num parts", std::to_string(scproc));
-  slaveCloseRebalanceParams.set<std::string>("imbalance tol", std::to_string(imbalance_tol));
-  slaveCloseRebalanceParams.set("partitioning method", "graph");
+  slaveCloseRebalanceParams.set<std::string>("num_global_parts", std::to_string(scproc));
+  slaveCloseRebalanceParams.set<std::string>("imbalance_tolerance", std::to_string(imbalance_tol));
+  slaveCloseRebalanceParams.set<std::string>("algorithm", "parmetis");
 
   const auto& [slaveCloseRowNodes, slaveCloseColNodes] =
       Core::Rebalance::rebalance_node_maps(*slaveCloseNodeGraph, slaveCloseRebalanceParams);
@@ -929,9 +929,10 @@ void CONTACT::Interface::redistribute()
       Core::Rebalance::build_graph(*idiscret_, slaveNonCloseRowEles);
 
   Teuchos::ParameterList slaveNonCloseRebalanceParams;
-  slaveNonCloseRebalanceParams.set<std::string>("num parts", std::to_string(sncproc));
-  slaveNonCloseRebalanceParams.set<std::string>("imbalance tol", std::to_string(imbalance_tol));
-  slaveNonCloseRebalanceParams.set("partitioning method", "graph");
+  slaveNonCloseRebalanceParams.set<std::string>("num_global_parts", std::to_string(sncproc));
+  slaveNonCloseRebalanceParams.set<std::string>(
+      "imbalance_tolerance", std::to_string(imbalance_tol));
+  slaveNonCloseRebalanceParams.set<std::string>("algorithm", "parmetis");
 
   const auto& [slaveNonCloseRowNodes, snccolnodes] =
       Core::Rebalance::rebalance_node_maps(*slaveNonCloseNodeGraph, slaveNonCloseRebalanceParams);

src/core/binstrategy/4C_binstrategy.cpp

@@ -820,18 +820,13 @@ void Core::Binstrategy::BinningStrategy::distribute_bins_recurs_coord_bisection(
 {
   // create a parameter list for partitioner
   Teuchos::ParameterList params;
-  params.set("Partitioning Method", "RCB");
-
-  // set low-level partitioning parameters (see Zoltan Users' Guide:
-  // http://www.cs.sandia.gov/zoltan)
-  Teuchos::ParameterList& sublist = params.sublist("Zoltan");
-
-  // debug level (see http://www.cs.sandia.gov/zoltan/ug_html/ug_param.html)
-  sublist.set("DEBUG_LEVEL", "0");
-
-  // recursive coordinate bisection (see http://www.cs.sandia.gov/zoltan/ug_html/ug_alg_rcb.html)
-  sublist.set("RCB_OUTPUT_LEVEL", "0");
-  sublist.set("RCB_RECTILINEAR_BLOCKS", "1");
+  params.set("algorithm", "zoltan");
+  params.set("debug_level", "no_status");
+  Teuchos::ParameterList& zparams = params.sublist("zoltan_parameters", false);
+  zparams.set("LB_METHOD", "RCB");
+  zparams.set("DEBUG_LEVEL", "0");
+  zparams.set("RCB_OUTPUT_LEVEL", "0");
+  zparams.set("RCB_RECTILINEAR_BLOCKS", "1");
 
   std::tie(bincenters, binweights) =
       Core::Rebalance::rebalance_coordinates(*bincenters, params, *binweights);
@@ -1233,12 +1228,13 @@ Core::Binstrategy::BinningStrategy::weighted_distribution_of_bins_to_procs(
   bingraph->optimize_storage();
 
   Teuchos::ParameterList paramlist;
-  paramlist.set("PARTITIONING METHOD", "GRAPH");
-  Teuchos::ParameterList& sublist = paramlist.sublist("Zoltan");
+  paramlist.set("algorithm", "zoltan");
+  Teuchos::ParameterList& zparams = paramlist.sublist("zoltan_parameters", false);
+  zparams.set("LB_METHOD", "GRAPH");
   if (repartition)
-    sublist.set("LB_APPROACH", "REPARTITION");
+    paramlist.set("partitioning_approach", "repartition");
   else
-    sublist.set("LB_APPROACH", "PARTITION");
+    paramlist.set("partitioning_approach", "partition");
 
   auto balanced_bingraph = Core::Rebalance::rebalance_graph(*bingraph, paramlist, vweights);
 

src/core/fem/src/condition/4C_fem_condition_periodic.cpp

@@ -1188,7 +1188,7 @@ void Core::Conditions::PeriodicBoundaryConditions::balance_load()
   auto node_weights = std::make_shared<Core::LinAlg::Vector<double>>(*node_row_map, true);
   {
     // set default node weights
-    node_weights->put_scalar(1.0);
+    node_weights->put_scalar(10.0);
 
     // apply weight of special elements
     for (int node_lid = 0; node_lid < node_row_map->num_my_elements(); ++node_lid)
@@ -1309,7 +1309,7 @@ void Core::Conditions::PeriodicBoundaryConditions::balance_load()
   // 3. set graph edge weights
   auto edge_weights = std::make_shared<Core::LinAlg::SparseMatrix>(graph_rowmap, 15);
   {
-    // set standard value of edge weight to 1.0
+    // set standard value of edge weight to 10.0
     for (int i = 0; i < node_graph.num_local_rows(); ++i)
     {
       const int grow = node_graph.row_map().gid(i);
@@ -1336,27 +1336,20 @@ void Core::Conditions::PeriodicBoundaryConditions::balance_load()
         // we do not want to partition between master and slave nodes
         std::vector<int> master_gid(1, master->id());
         std::vector<int> slave_gid(1, slave->id());
-        // add 99 to the initial value of 1.0 to set costs to 100
-        std::vector<double> value(1, 99.0);
+        // set cost of strong edges to 100.0
+        std::vector<double> value(1, 100.0);
 
         edge_weights->insert_global_values(master->id(), 1, value.data(), slave_gid.data());
         edge_weights->insert_global_values(slave->id(), 1, value.data(), master_gid.data());
       }
     }
   }
-  // TODO: Bug?
-  // Here we fill a data structure, which should be completed at some point, but in doing so we
-  // end up with an error in Zoltan ...
-  // edge_weights->complete();
+  edge_weights->complete();
 
   // 4. setup partitioner and redistribute
-  // TODO: Why does this only work for all tests with ParMETIS?
   Teuchos::ParameterList paramlist;
-  paramlist.set("PARTITIONING METHOD", "GRAPH");
-  Teuchos::ParameterList& sublist = paramlist.sublist("Zoltan");
-  sublist.set("LB_METHOD", "GRAPH");
-  sublist.set("GRAPH_PACKAGE", "ParMETIS");
-  sublist.set("LB_APPROACH", "PARTITION");
+  paramlist.set("algorithm", "parmetis");
+  paramlist.set("partitioning_approach", "repartition");
 
   auto newnodegraph =
       Core::Rebalance::rebalance_graph(node_graph, paramlist, node_weights, edge_weights);

src/core/io/src/4C_io_gridgenerator.cpp

@@ -201,7 +201,7 @@ namespace Core::IO::GridGenerator
 
       Teuchos::ParameterList rebalanceParams;
       rebalanceParams.set<std::string>(
-          "num parts", std::to_string(Core::Communication::num_mpi_ranks(comm)));
+          "num_global_parts", std::to_string(Core::Communication::num_mpi_ranks(comm)));
 
       std::tie(nodeRowMap, nodeColMap) =
           Core::Rebalance::rebalance_node_maps(*nodeGraph, rebalanceParams);

src/core/io/src/4C_io_meshreader.cpp

@@ -363,8 +363,6 @@ namespace
     std::string section_name;
   };
 
-
-
   std::vector<std::shared_ptr<Core::FE::Discretization>> find_dis_node(
       const std::vector<ElementReader>& element_readers, int global_node_id)
   {

src/core/rebalance/src/4C_rebalance.cpp

@@ -31,16 +31,16 @@ do_rebalance_discretization(const Core::LinAlg::Graph& graph,
       if (!Core::Communication::my_mpi_rank(comm))
         std::cout << "Redistributing using hypergraph .........\n";
 
-      rebalanceParams.set("partitioning method", "HYPERGRAPH");
+      rebalanceParams.set("algorithm", "phg");
       std::tie(rowmap, colmap) = Core::Rebalance::rebalance_node_maps(graph, rebalanceParams);
       break;
     }
-    case Core::Rebalance::RebalanceType::recursive_coordinate_bisection:
+    case Core::Rebalance::RebalanceType::multijagged:
     {
       if (!Core::Communication::my_mpi_rank(comm))
         std::cout << "Redistributing using recursive coordinate bisection .........\n";
 
-      rebalanceParams.set("partitioning method", "RCB");
+      rebalanceParams.set("algorithm", "multijagged");
 
       rowmap = std::make_shared<Core::LinAlg::Map>(
           -1, graph.row_map().num_my_elements(), graph.row_map().my_global_elements(), 0, comm);
@@ -66,7 +66,7 @@ do_rebalance_discretization(const Core::LinAlg::Graph& graph,
       if (!Core::Communication::my_mpi_rank(comm))
         std::cout << "Redistributing using monolithic hypergraph .........\n";
 
-      rebalanceParams.set("partitioning method", "HYPERGRAPH");
+      rebalanceParams.set("algorithm", "phg");
 
       rowmap = std::make_shared<Core::LinAlg::Map>(
           -1, graph.row_map().num_my_elements(), graph.row_map().my_global_elements(), 0, comm);
@@ -109,15 +109,15 @@ void Core::Rebalance::rebalance_discretization(Core::FE::Discretization& discret
   const double imbalance_tol = parameters.mesh_partitioning_parameters.imbalance_tol;
 
   Teuchos::ParameterList rebalanceParams;
-  rebalanceParams.set<std::string>("imbalance tol", std::to_string(imbalance_tol));
+  rebalanceParams.set<std::string>("imbalance_tolerance", std::to_string(imbalance_tol));
 
   const int minele_per_proc = parameters.mesh_partitioning_parameters.min_ele_per_proc;
   const int max_global_procs = Core::Communication::num_mpi_ranks(comm);
   int min_global_procs = max_global_procs;
 
   if (minele_per_proc > 0) min_global_procs = row_elements.num_global_elements() / minele_per_proc;
   const int num_procs = std::min(max_global_procs, min_global_procs);
-  rebalanceParams.set<std::string>("num parts", std::to_string(num_procs));
+  rebalanceParams.set<std::string>("num_global_parts", std::to_string(num_procs));
 
   const auto rebalanceMethod = parameters.mesh_partitioning_parameters.rebalance_type;
 

src/core/rebalance/src/4C_rebalance.hpp

@@ -30,12 +30,11 @@ namespace Core::Rebalance
 
   enum class RebalanceType
   {
-    none,                            //< no partitioning method
-    hypergraph,                      //< hypergraph based partitioning
-    recursive_coordinate_bisection,  //< recursive coordinate bisection, geometric based
-                                     // partitioning
-    monolithic  //< hypergraph based partitioning by using a global monolithic graph constructed
-                // via a global collision search
+    none,         //< no partitioning method
+    hypergraph,   //< hypergraph based partitioning
+    multijagged,  //< multijagged, geometric based partitioning
+    monolithic    //< hypergraph based partitioning by using a global monolithic graph constructed
+                  // via a global collision search
   };
 
   struct MeshPartitioningParameters