Emit metadata for legacy particle sections

Author: sebproell

src/global_data/4C_global_data_read.cpp

@@ -189,6 +189,8 @@ Core::IO::InputFile Global::set_up_input_file(MPI_Comm comm)
         parameter<int>("_positional_0_id"),
         one_of(std::move(all_element_specs)),
     });
+
+    legacy_partial_specs["legacy_particle_specs"] = PARTICLEENGINE::create_particle_spec();
   }
 
   return Core::IO::InputFile{std::move(valid_sections), std::move(legacy_section_names),

src/particle_engine/4C_particle_engine_enums.cpp

@@ -222,57 +222,26 @@ enum PARTICLEENGINE::ParticleState PARTICLEENGINE::enum_from_state_name(const st
   return state;
 }
 
+static std::vector<std::string> particle_type_names = {
+    "phase1", "phase2", "boundaryphase", "rigidphase", "dirichletphase", "neumannphase"};
+
 std::string PARTICLEENGINE::enum_to_type_name(const enum ParticleType& type)
 {
-  std::string name;
-
-  switch (type)
-  {
-    case Phase1:
-      name = "phase1";
-      break;
-    case Phase2:
-      name = "phase2";
-      break;
-    case BoundaryPhase:
-      name = "boundaryphase";
-      break;
-    case RigidPhase:
-      name = "rigidphase";
-      break;
-    case DirichletPhase:
-      name = "dirichletphase";
-      break;
-    case NeumannPhase:
-      name = "neumannphase";
-      break;
-    default:
-      FOUR_C_THROW("particle type unknown!");
-  }
-
-  return name;
+  FOUR_C_ASSERT(type >= 0 and type < static_cast<int>(particle_type_names.size()),
+      "particle type out of range!");
+  return particle_type_names[type];
 }
 
 enum PARTICLEENGINE::ParticleType PARTICLEENGINE::enum_from_type_name(const std::string& name)
 {
-  enum ParticleType type;
-
-  if (name == "phase1")
-    type = Phase1;
-  else if (name == "phase2")
-    type = Phase2;
-  else if (name == "boundaryphase")
-    type = BoundaryPhase;
-  else if (name == "rigidphase")
-    type = RigidPhase;
-  else if (name == "dirichletphase")
-    type = DirichletPhase;
-  else if (name == "neumannphase")
-    type = NeumannPhase;
-  else
-    FOUR_C_THROW("particle type '{}' unknown!", name.c_str());
+  auto it = std::ranges::find(particle_type_names, name);
+  FOUR_C_ASSERT(it != particle_type_names.end(), "particle type '{}' unknown!", name.c_str());
+  return static_cast<enum ParticleType>(std::distance(particle_type_names.begin(), it));
+}
 
-  return type;
+const std::vector<std::string>& PARTICLEENGINE::get_particle_type_names()
+{
+  return particle_type_names;
 }
 
 std::string PARTICLEENGINE::enum_to_status_name(const enum ParticleStatus& status)

src/particle_engine/4C_particle_engine_enums.hpp

@@ -15,6 +15,8 @@
 
 #include "4C_utils_exceptions.hpp"
 
+#include <vector>
+
 FOUR_C_NAMESPACE_OPEN
 
 /*---------------------------------------------------------------------------*
@@ -177,6 +179,8 @@ namespace PARTICLEENGINE
    */
   enum ParticleType enum_from_type_name(const std::string& name);
 
+  const std::vector<std::string>& get_particle_type_names();
+
   //! @}
 
   //! \name definition of particle status

src/particle_engine/4C_particle_engine_particlereader.cpp

@@ -9,12 +9,14 @@
 
 #include "4C_comm_mpi_utils.hpp"
 #include "4C_io_input_file.hpp"
+#include "4C_io_input_spec_builders.hpp"
 #include "4C_io_pstream.hpp"
 #include "4C_io_value_parser.hpp"
 #include "4C_particle_engine_enums.hpp"
 #include "4C_particle_engine_object.hpp"
 #include "4C_particle_engine_typedefs.hpp"
 
+#include <sys/stat.h>
 #include <Teuchos_Time.hpp>
 
 FOUR_C_NAMESPACE_OPEN
@@ -60,30 +62,43 @@ void PARTICLEENGINE::read_particles(Core::IO::InputFile& input, const std::strin
         PARTICLEENGINE::StateEnum particlestate;
         std::vector<double> state;
 
-        std::istringstream linestream(std::string(parser.get_unparsed_remainder()));
-
-        while (linestream >> statelabel)
+        while (!parser.at_end())
         {
+          auto next = parser.peek();
           // optional particle radius
-          if (statelabel == "RAD")
+          if (next == "RAD")
           {
             particlestate = PARTICLEENGINE::Radius;
-            state.resize(1);
-            linestream >> state[0];
+            parser.consume("RAD");
+
+            if (auto val = parser.read<std::optional<double>>())
+            {
+              state.resize(1);
+              state[0] = *val;
+            }
+            else
+            {
+              continue;
+            }
           }
           // optional rigid body color
-          else if (statelabel == "RIGIDCOLOR")
+          else if (next == "RIGIDCOLOR")
           {
             particlestate = PARTICLEENGINE::RigidBodyColor;
-            state.resize(1);
-            linestream >> state[0];
+            parser.consume("RIGIDCOLOR");
+
+            if (auto val = parser.read<std::optional<double>>())
+            {
+              state.resize(1);
+              state[0] = *val;
+            }
+            else
+            {
+              continue;
+            }
           }
           else
-            FOUR_C_THROW("optional particle state with label '{}' unknown!", statelabel.c_str());
-
-          if (not linestream)
-            FOUR_C_THROW("expecting values of state '{}' if label '{}' is set!",
-                PARTICLEENGINE::enum_to_state_name(particlestate).c_str(), statelabel.c_str());
+            FOUR_C_THROW("Optional particle state with label '{}' unknown!", statelabel);
 
           // allocate memory to hold optional particle state
           if (static_cast<int>(particlestates.size()) < (particlestate + 1))
@@ -113,4 +128,17 @@ void PARTICLEENGINE::read_particles(Core::IO::InputFile& input, const std::strin
 }
 
 
+Core::IO::InputSpec PARTICLEENGINE::create_particle_spec()
+{
+  using namespace Core::IO::InputSpecBuilders;
+
+  return all_of({
+      deprecated_selection<std::string>("TYPE", get_particle_type_names()),
+      parameter<std::vector<double>>("POS", {.size = 3}),
+      parameter<std::optional<double>>("RAD"),
+      parameter<std::optional<double>>("RIGIDCOLOR"),
+  });
+}
+
+
 FOUR_C_NAMESPACE_CLOSE

src/particle_engine/4C_particle_engine_particlereader.hpp

@@ -10,6 +10,7 @@
 
 #include "4C_config.hpp"
 
+#include "4C_io_input_spec.hpp"
 #include "4C_particle_engine_typedefs.hpp"
 
 #include <memory>
@@ -30,6 +31,11 @@ namespace PARTICLEENGINE
   void read_particles(Core::IO::InputFile& input, const std::string& section_name,
       std::vector<PARTICLEENGINE::ParticleObjShrdPtr>& particles);
 
+  /**
+   * The InputSpec for a single particle line.
+   */
+  [[nodiscard]] Core::IO::InputSpec create_particle_spec();
+
 }  // namespace PARTICLEENGINE
 
 FOUR_C_NAMESPACE_CLOSE