Merge pull request 4C-multiphysics#436 from sebproell/input-spec-para…

…meter Rename InputSpecBuilders::entry to parameter
bgoderbauer · Feb 25, 2025 · 2f36770 · 2f36770
2 parents 2c11b41 + e779a93
commit 2f36770
Show file tree

Hide file tree

Showing 99 changed files with 3,230 additions and 3,141 deletions.
diff --git a/apps/global_full/4C_global_full_main.cpp b/apps/global_full/4C_global_full_main.cpp
@@ -374,7 +374,7 @@ int main(int argc, char* argv[])
 
         using namespace Core::IO::InputSpecBuilders;
         auto all_materials = all_of({
-            entry<int>("MAT"),
+            parameter<int>("MAT"),
             one_of(possible_materials),
         });
 

diff --git a/apps/pre_exodus/4C_pre_exodus.cpp b/apps/pre_exodus/4C_pre_exodus.cpp
@@ -336,7 +336,7 @@ int main(int argc, char** argv)
 
         using namespace Core::IO::InputSpecBuilders;
         auto all_materials = all_of({
-            entry<int>("MAT"),
+            parameter<int>("MAT"),
             one_of(possible_materials),
         });
 

diff --git a/src/ale/4C_ale_ale2.cpp b/src/ale/4C_ale_ale2.cpp
@@ -85,28 +85,28 @@ void Discret::Elements::Ale2Type::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["QUAD4"] = all_of({
-      entry<std::vector<int>>("QUAD4", {.size = 4}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("QUAD4", {.size = 4}),
+      parameter<int>("MAT"),
   });
 
   defs["QUAD8"] = all_of({
-      entry<std::vector<int>>("QUAD8", {.size = 8}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("QUAD8", {.size = 8}),
+      parameter<int>("MAT"),
   });
 
   defs["QUAD9"] = all_of({
-      entry<std::vector<int>>("QUAD9", {.size = 9}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("QUAD9", {.size = 9}),
+      parameter<int>("MAT"),
   });
 
   defs["TRI3"] = all_of({
-      entry<std::vector<int>>("TRI3", {.size = 3}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("TRI3", {.size = 3}),
+      parameter<int>("MAT"),
   });
 
   defs["TRI6"] = all_of({
-      entry<std::vector<int>>("TRI6", {.size = 6}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("TRI6", {.size = 6}),
+      parameter<int>("MAT"),
   });
 }
 

diff --git a/src/ale/4C_ale_ale3.cpp b/src/ale/4C_ale_ale3.cpp
@@ -84,43 +84,43 @@ void Discret::Elements::Ale3Type::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["HEX8"] = all_of({
-      entry<std::vector<int>>("HEX8", {.size = 8}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("HEX8", {.size = 8}),
+      parameter<int>("MAT"),
   });
 
   defs["HEX20"] = all_of({
-      entry<std::vector<int>>("HEX20", {.size = 20}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("HEX20", {.size = 20}),
+      parameter<int>("MAT"),
   });
 
   defs["HEX27"] = all_of({
-      entry<std::vector<int>>("HEX27", {.size = 27}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("HEX27", {.size = 27}),
+      parameter<int>("MAT"),
   });
 
   defs["TET4"] = all_of({
-      entry<std::vector<int>>("TET4", {.size = 4}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("TET4", {.size = 4}),
+      parameter<int>("MAT"),
   });
 
   defs["TET10"] = all_of({
-      entry<std::vector<int>>("TET10", {.size = 10}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("TET10", {.size = 10}),
+      parameter<int>("MAT"),
   });
 
   defs["WEDGE6"] = all_of({
-      entry<std::vector<int>>("WEDGE6", {.size = 6}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("WEDGE6", {.size = 6}),
+      parameter<int>("MAT"),
   });
 
   defs["WEDGE15"] = all_of({
-      entry<std::vector<int>>("WEDGE15", {.size = 15}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("WEDGE15", {.size = 15}),
+      parameter<int>("MAT"),
   });
 
   defs["PYRAMID5"] = all_of({
-      entry<std::vector<int>>("PYRAMID5", {.size = 5}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("PYRAMID5", {.size = 5}),
+      parameter<int>("MAT"),
   });
 }
 

diff --git a/src/ale/4C_ale_input.cpp b/src/ale/4C_ale_input.cpp
@@ -96,8 +96,8 @@ void ALE::set_valid_conditions(std::vector<Core::Conditions::ConditionDefinition
         {"lagrange", "heightfunction", "sphereHeightFunction", "meantangentialvelocity",
             "meantangentialvelocityscaled"},
         {.description = "", .default_value = "lagrange"}));
-    cond.add_component(entry<double>("VAL"));
-    cond.add_component(entry<int>("NODENORMALFUNCT"));
+    cond.add_component(parameter<double>("VAL"));
+    cond.add_component(parameter<int>("NODENORMALFUNCT"));
 
     condlist.emplace_back(cond);
   };

diff --git a/src/art_net/4C_art_net_artery.cpp b/src/art_net/4C_art_net_artery.cpp
@@ -59,11 +59,11 @@ void Discret::Elements::ArteryType::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["LINE2"] = all_of({
-      entry<std::vector<int>>("LINE2", {.size = 2}),
-      entry<int>("MAT"),
-      entry<int>("GP"),
-      entry<std::string>("TYPE"),
-      entry<double>("DIAM"),
+      parameter<std::vector<int>>("LINE2", {.size = 2}),
+      parameter<int>("MAT"),
+      parameter<int>("GP"),
+      parameter<std::string>("TYPE"),
+      parameter<double>("DIAM"),
   });
 }
 

diff --git a/src/beam3/4C_beam3_euler_bernoulli.cpp b/src/beam3/4C_beam3_euler_bernoulli.cpp
@@ -212,8 +212,8 @@ void Discret::Elements::Beam3ebType::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["LINE2"] = all_of({
-      entry<std::vector<int>>("LINE2", {.size = 2}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("LINE2", {.size = 2}),
+      parameter<int>("MAT"),
   });
 }
 

diff --git a/src/beam3/4C_beam3_kirchhoff.cpp b/src/beam3/4C_beam3_kirchhoff.cpp
@@ -99,30 +99,30 @@ void Discret::Elements::Beam3kType::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["LINE2"] = all_of({
-      entry<std::vector<int>>("LINE2", {.size = 2}),
-      entry<int>("WK"),
-      entry<int>("ROTVEC"),
-      entry<int>("MAT"),
-      entry<std::vector<double>>("TRIADS", {.size = 6}),
-      entry<bool>("USE_FAD", {.default_value = false}),
+      parameter<std::vector<int>>("LINE2", {.size = 2}),
+      parameter<int>("WK"),
+      parameter<int>("ROTVEC"),
+      parameter<int>("MAT"),
+      parameter<std::vector<double>>("TRIADS", {.size = 6}),
+      parameter<bool>("USE_FAD", {.default_value = false}),
   });
 
   defs["LINE3"] = all_of({
-      entry<std::vector<int>>("LINE3", {.size = 3}),
-      entry<int>("WK"),
-      entry<int>("ROTVEC"),
-      entry<int>("MAT"),
-      entry<std::vector<double>>("TRIADS", {.size = 9}),
-      entry<bool>("USE_FAD", {.default_value = false}),
+      parameter<std::vector<int>>("LINE3", {.size = 3}),
+      parameter<int>("WK"),
+      parameter<int>("ROTVEC"),
+      parameter<int>("MAT"),
+      parameter<std::vector<double>>("TRIADS", {.size = 9}),
+      parameter<bool>("USE_FAD", {.default_value = false}),
   });
 
   defs["LINE4"] = all_of({
-      entry<std::vector<int>>("LINE4", {.size = 4}),
-      entry<int>("WK"),
-      entry<int>("ROTVEC"),
-      entry<int>("MAT"),
-      entry<std::vector<double>>("TRIADS", {.size = 12}),
-      entry<bool>("USE_FAD", {.default_value = false}),
+      parameter<std::vector<int>>("LINE4", {.size = 4}),
+      parameter<int>("WK"),
+      parameter<int>("ROTVEC"),
+      parameter<int>("MAT"),
+      parameter<std::vector<double>>("TRIADS", {.size = 12}),
+      parameter<bool>("USE_FAD", {.default_value = false}),
   });
 }
 

diff --git a/src/beam3/4C_beam3_reissner.cpp b/src/beam3/4C_beam3_reissner.cpp
@@ -111,70 +111,70 @@ void Discret::Elements::Beam3rType::setup_element_definition(
 
   // note: LINE2 refers to linear Lagrange interpolation of centerline AND triad field
   defs["LINE2"] = all_of({
-      entry<std::vector<int>>("LINE2", {.size = 2}),
-      entry<int>("MAT"),
-      entry<std::vector<double>>("TRIADS", {.size = 6}),
-      entry<bool>("USE_FAD", {.default_value = false}),
+      parameter<std::vector<int>>("LINE2", {.size = 2}),
+      parameter<int>("MAT"),
+      parameter<std::vector<double>>("TRIADS", {.size = 6}),
+      parameter<bool>("USE_FAD", {.default_value = false}),
   });
 
   // note: LINE3 refers to quadratic Lagrange interpolation of centerline AND triad field
   defs["LINE3"] = all_of({
-      entry<std::vector<int>>("LINE3", {.size = 3}),
-      entry<int>("MAT"),
-      entry<std::vector<double>>("TRIADS", {.size = 9}),
-      entry<bool>("USE_FAD", {.default_value = false}),
+      parameter<std::vector<int>>("LINE3", {.size = 3}),
+      parameter<int>("MAT"),
+      parameter<std::vector<double>>("TRIADS", {.size = 9}),
+      parameter<bool>("USE_FAD", {.default_value = false}),
   });
 
   // note: LINE4 refers to cubic Lagrange interpolation of centerline AND triad field
   defs["LINE4"] = all_of({
-      entry<std::vector<int>>("LINE4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<std::vector<double>>("TRIADS", {.size = 12}),
-      entry<bool>("USE_FAD", {.default_value = false}),
+      parameter<std::vector<int>>("LINE4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<std::vector<double>>("TRIADS", {.size = 12}),
+      parameter<bool>("USE_FAD", {.default_value = false}),
   });
 
   // note: LINE5 refers to quartic Lagrange interpolation of centerline AND triad field
   defs["LINE5"] = all_of({
-      entry<std::vector<int>>("LINE5", {.size = 5}),
-      entry<int>("MAT"),
-      entry<std::vector<double>>("TRIADS", {.size = 15}),
-      entry<bool>("USE_FAD", {.default_value = false}),
+      parameter<std::vector<int>>("LINE5", {.size = 5}),
+      parameter<int>("MAT"),
+      parameter<std::vector<double>>("TRIADS", {.size = 15}),
+      parameter<bool>("USE_FAD", {.default_value = false}),
   });
 
   /* note: HERM2 refers to cubic Hermite interpolation of centerline (2 nodes)
    *       LINE2 refers to linear Lagrange interpolation of the triad field*/
   defs["HERM2LINE2"] = all_of({
-      entry<std::vector<int>>("HERM2LINE2", {.size = 2}),
-      entry<int>("MAT"),
-      entry<std::vector<double>>("TRIADS", {.size = 6}),
-      entry<bool>("USE_FAD", {.default_value = false}),
+      parameter<std::vector<int>>("HERM2LINE2", {.size = 2}),
+      parameter<int>("MAT"),
+      parameter<std::vector<double>>("TRIADS", {.size = 6}),
+      parameter<bool>("USE_FAD", {.default_value = false}),
   });
 
   /* note: HERM2 refers to cubic order Hermite interpolation of centerline (2 nodes)
    *       LINE3 refers to quadratic Lagrange interpolation of the triad field*/
   defs["HERM2LINE3"] = all_of({
-      entry<std::vector<int>>("HERM2LINE3", {.size = 3}),
-      entry<int>("MAT"),
-      entry<std::vector<double>>("TRIADS", {.size = 9}),
-      entry<bool>("USE_FAD", {.default_value = false}),
+      parameter<std::vector<int>>("HERM2LINE3", {.size = 3}),
+      parameter<int>("MAT"),
+      parameter<std::vector<double>>("TRIADS", {.size = 9}),
+      parameter<bool>("USE_FAD", {.default_value = false}),
   });
 
   /* note: HERM2 refers to cubic Hermite interpolation of centerline (2 nodes)
    *       LINE4 refers to cubic Lagrange interpolation of the triad field*/
   defs["HERM2LINE4"] = all_of({
-      entry<std::vector<int>>("HERM2LINE4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<std::vector<double>>("TRIADS", {.size = 12}),
-      entry<bool>("USE_FAD", {.default_value = false}),
+      parameter<std::vector<int>>("HERM2LINE4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<std::vector<double>>("TRIADS", {.size = 12}),
+      parameter<bool>("USE_FAD", {.default_value = false}),
   });
 
   /* note: HERM2 refers to cubic Hermite interpolation of centerline (2 nodes)
    *       LINE5 refers to quartic Lagrange interpolation of the triad field*/
   defs["HERM2LINE5"] = all_of({
-      entry<std::vector<int>>("HERM2LINE5", {.size = 5}),
-      entry<int>("MAT"),
-      entry<std::vector<double>>("TRIADS", {.size = 15}),
-      entry<bool>("USE_FAD", {.default_value = false}),
+      parameter<std::vector<int>>("HERM2LINE5", {.size = 5}),
+      parameter<int>("MAT"),
+      parameter<std::vector<double>>("TRIADS", {.size = 15}),
+      parameter<bool>("USE_FAD", {.default_value = false}),
   });
 }
 

diff --git a/src/beamcontact/4C_beamcontact_input.cpp b/src/beamcontact/4C_beamcontact_input.cpp
@@ -185,7 +185,7 @@ void BeamContact::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
         "BEAM INTERACTION/BEAM TO BEAM CONTACT CONDITIONS", condition_name,
         "Beam-to-beam contact conditions", Core::Conditions::BeamToBeamContact, true,
         Core::Conditions::geometry_type_line);
-    beam_to_beam_contact_condition.add_component(entry<int>("COUPLING_ID"));
+    beam_to_beam_contact_condition.add_component(parameter<int>("COUPLING_ID"));
     condlist.push_back(beam_to_beam_contact_condition);
   }
 }

diff --git a/src/bele/4C_bele_bele3.cpp b/src/bele/4C_bele_bele3.cpp
@@ -96,28 +96,28 @@ void Discret::Elements::Bele3Type::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs3["TRI3"] = all_of({
-      entry<std::vector<int>>("TRI3", {.size = 3}),
-      entry<int>("MAT", {.required = false}),
+      parameter<std::vector<int>>("TRI3", {.size = 3}),
+      parameter<int>("MAT", {.required = false}),
   });
 
   defs3["TRI6"] = all_of({
-      entry<std::vector<int>>("TRI6", {.size = 6}),
-      entry<int>("MAT", {.required = false}),
+      parameter<std::vector<int>>("TRI6", {.size = 6}),
+      parameter<int>("MAT", {.required = false}),
   });
 
   defs3["QUAD4"] = all_of({
-      entry<std::vector<int>>("QUAD4", {.size = 4}),
-      entry<int>("MAT", {.required = false}),
+      parameter<std::vector<int>>("QUAD4", {.size = 4}),
+      parameter<int>("MAT", {.required = false}),
   });
 
   defs3["QUAD8"] = all_of({
-      entry<std::vector<int>>("QUAD8", {.size = 8}),
-      entry<int>("MAT", {.required = false}),
+      parameter<std::vector<int>>("QUAD8", {.size = 8}),
+      parameter<int>("MAT", {.required = false}),
   });
 
   defs3["QUAD9"] = all_of({
-      entry<std::vector<int>>("QUAD9", {.size = 9}),
-      entry<int>("MAT", {.required = false}),
+      parameter<std::vector<int>>("QUAD9", {.size = 9}),
+      parameter<int>("MAT", {.required = false}),
   });
 }
 

diff --git a/src/bele/4C_bele_vele3.cpp b/src/bele/4C_bele_vele3.cpp
@@ -71,7 +71,7 @@ void Discret::Elements::Vele3Type::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["HEX8"] = all_of({
-      entry<std::vector<int>>("HEX8", {.size = 8}),
+      parameter<std::vector<int>>("HEX8", {.size = 8}),
   });
 }