Merge pull request #660 from sebproell/mesh-cleanup-2

Unify input of discretizations

Author: sebproell

src/core/fem/src/general/utils/4C_fem_general_utils_createdis.cpp

@@ -20,8 +20,10 @@ void Core::FE::DiscretizationCreatorBase::initial_checks(
     const Core::FE::Discretization& sourcedis, const Core::FE::Discretization& targetdis) const
 {
   // are the source and target discretizations ready?
-  if (!sourcedis.filled()) FOUR_C_THROW("The source discretization is not filled!");
-  if (!targetdis.filled()) FOUR_C_THROW("The target discretization is not filled!");
+  if (!sourcedis.filled())
+    FOUR_C_THROW("The source discretization '{}' is not filled!", sourcedis.name());
+  if (!targetdis.filled())
+    FOUR_C_THROW("The target discretization '{}' is not filled!", targetdis.name());
 
   // is the target discretization really empty?
   if (targetdis.num_global_elements() or targetdis.num_global_nodes())

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

@@ -186,47 +186,80 @@ Core::IO::MeshReader::MeshReader(
 
 /*----------------------------------------------------------------------*/
 /*----------------------------------------------------------------------*/
-void Core::IO::MeshReader::add_advanced_reader(std::shared_ptr<Core::FE::Discretization> dis,
-    Core::IO::InputFile& input, const std::string& sectionname,
-    const Core::IO::GeometryType geometrysource)
+void Core::IO::MeshReader::add_advanced_reader(
+    std::shared_ptr<Core::FE::Discretization> dis, const std::string& sectionname)
 {
-  switch (geometrysource)
+  target_discretizations_.emplace_back(sectionname, dis);
+}
+
+/*----------------------------------------------------------------------*/
+/*----------------------------------------------------------------------*/
+void Core::IO::MeshReader::read_and_partition()
+{
+  // We need to track the max global node ID to offset node numbering and for sanity checks
+  int max_node_id = 0;
+
+  for (const auto& [section_name, dis] : target_discretizations_)
   {
-    case Core::IO::geometry_full:
+    // Find out which section we have available for input. We can only do this on rank zero due
+    // to large legacy sections that are not available everywhere. Communicate the result to all
+    // ranks.
+    std::map<std::string, bool> available_section;
+    const int my_rank = Core::Communication::my_mpi_rank(comm_);
+    if (my_rank == 0)
+    {
+      available_section[section_name + " ELEMENTS"] =
+          input_.has_section(section_name + " ELEMENTS");
+      available_section[section_name + " DOMAIN"] = input_.has_section(section_name + " DOMAIN");
+      available_section[section_name + " GEOMETRY"] =
+          input_.has_section(section_name + " GEOMETRY");
+      Core::Communication::broadcast(available_section, 0, comm_);
+    }
+    else
+    {
+      Core::Communication::broadcast(available_section, 0, comm_);
+    }
+
+    const int num_sections_in_file =
+        std::ranges::count_if(available_section, [](const auto& pair) { return pair.second; });
+    if (num_sections_in_file > 1)
     {
-      std::string fullsectionname(sectionname + " ELEMENTS");
-      ElementReader er = ElementReader(dis, input, fullsectionname);
-      element_readers_.emplace_back(er);
-      break;
+      std::string found_sections;
+      for (const auto& [section, exists] : available_section)
+      {
+        if (exists) found_sections += "'" + section + "' ";
+      }
+      FOUR_C_THROW(
+          "Multiple options to read mesh for discretization '{}'. Only one is allowed.\n Found "
+          "sections: {}",
+          dis->name(), found_sections);
+    }
+
+    if (num_sections_in_file == 0)
+    {
+      // This used to be the default, so we use it for backwards compatibility.
+      element_readers_.emplace_back(
+          Core::IO::ElementReader(dis, input_, section_name + " ELEMENTS"));
+      continue;
+    }
+
+    if (available_section[section_name + " ELEMENTS"])
+    {
+      element_readers_.emplace_back(
+          Core::IO::ElementReader(dis, input_, section_name + " ELEMENTS"));
     }
-    case Core::IO::geometry_box:
+    if (available_section[section_name + " DOMAIN"])
     {
-      std::string fullsectionname(sectionname + " DOMAIN");
-      DomainReader dr = DomainReader(dis, input, fullsectionname);
-      domain_readers_.emplace_back(dr);
-      break;
+      domain_readers_.emplace_back(Core::IO::DomainReader(dis, input_, section_name + " DOMAIN"));
     }
-    case Core::IO::geometry_file:
+    if (available_section[section_name + " GEOMETRY"])
     {
-      std::string fullsectionname(sectionname + " GEOMETRY");
       exodus_readers_.emplace_back(Internal::ExodusReader{
           .target_discretization = *dis,
-          .section_name = fullsectionname,
+          .section_name = section_name + " GEOMETRY",
       });
-      break;
     }
-    default:
-      FOUR_C_THROW("Unknown geometry source");
-      break;
   }
-}
-
-/*----------------------------------------------------------------------*/
-/*----------------------------------------------------------------------*/
-void Core::IO::MeshReader::read_and_partition()
-{
-  // We need to track the max global node ID to offset node numbering and for sanity checks
-  int max_node_id = 0;
 
   graph_.resize(element_readers_.size());
 

src/core/io/src/4C_io_meshreader.hpp

@@ -103,13 +103,10 @@ namespace Core::IO
      *
      * \param dis            [in] This discretization will be passed on
      * \param input          [in] The input file.
-     * \param sectionname    [in] This will be passed on element/domain readers only (not used for
-     *                            file reader)
-     * \param geometrysource [in] selects which reader will be created
+     * \param sectionname    [in] The section name in the input file.
      */
-    void add_advanced_reader(std::shared_ptr<Core::FE::Discretization> dis,
-        Core::IO::InputFile& input, const std::string& sectionname,
-        const Core::IO::GeometryType geometrysource);
+    void add_advanced_reader(
+        std::shared_ptr<Core::FE::Discretization> dis, const std::string& sectionname);
 
     /// do the actual reading
     /*!
@@ -194,6 +191,11 @@ namespace Core::IO
 
     /// Additional parameters for reading meshes.
     MeshReaderParameters parameters_;
+
+    /// The discretizations to be filled. The key is an identifier for the sections in the input.
+    /// Multiple discretizations might be filled from the same section.
+    std::vector<std::pair<std::string, std::shared_ptr<Core::FE::Discretization>>>
+        target_discretizations_;
   };
 }  // namespace Core::IO