diff --git a/apps/global_full/4C_global_full_main.cpp b/apps/global_full/4C_global_full_main.cpp
index 48a2121b6e8..07355fbea7c 100644
--- 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
index 05f6ef07067..010efea72b1 100644
--- 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
index 87db489908c..158180d7756 100644
--- 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
index ef4a16a3c58..0f563c31f78 100644
--- 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
index 2765f98b086..6c41d2ad546 100644
--- 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
index 299c8dd5b7e..e13bf85c642 100644
--- 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
index 97ebb179726..eb31a2cc1b4 100644
--- 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
index 002da879455..f753a4830ea 100644
--- 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
index e1127bf0483..b814ce8551c 100644
--- 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
index 3566d5d3da7..ef62f182d43 100644
--- 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
index b50713150fa..974154d10bf 100644
--- 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
index c643e91761d..e2903764778 100644
--- 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}),
   });
 }
 
diff --git a/src/contact_constitutivelaw/4C_contact_constitutivelaw_valid_laws.cpp b/src/contact_constitutivelaw/4C_contact_constitutivelaw_valid_laws.cpp
index d6ee64bff60..3024c0196bd 100644
--- a/src/contact_constitutivelaw/4C_contact_constitutivelaw_valid_laws.cpp
+++ b/src/contact_constitutivelaw/4C_contact_constitutivelaw_valid_laws.cpp
@@ -29,10 +29,10 @@ Core::IO::InputSpec CONTACT::CONSTITUTIVELAW::valid_contact_constitutive_laws()
   {
     specs.emplace_back(group("CoConstLaw_brokenrational",
         {
-            entry<double>("A", {.description = "scaling factor"}),
-            entry<double>("B", {.description = "asymptote"}),
-            entry<double>("C", {.description = "y intercept"}),
-            entry<double>(
+            parameter<double>("A", {.description = "scaling factor"}),
+            parameter<double>("B", {.description = "asymptote"}),
+            parameter<double>("C", {.description = "y intercept"}),
+            parameter<double>(
                 "Offset", {.description = "offset for contact to start", .default_value = 0.0}),
         },
         {
@@ -44,9 +44,9 @@ Core::IO::InputSpec CONTACT::CONSTITUTIVELAW::valid_contact_constitutive_laws()
   {
     specs.emplace_back(group("CoConstLaw_power",
         {
-            entry<double>("A", {.description = "scaling factor"}),
-            entry<double>("B", {.description = "power coefficient"}),
-            entry<double>(
+            parameter<double>("A", {.description = "scaling factor"}),
+            parameter<double>("B", {.description = "power coefficient"}),
+            parameter<double>(
                 "Offset", {.description = "offset for contact to start", .default_value = 0.0}),
         },
         {
@@ -59,11 +59,11 @@ Core::IO::InputSpec CONTACT::CONSTITUTIVELAW::valid_contact_constitutive_laws()
   {
     specs.emplace_back(group("CoConstLaw_cubic",
         {
-            entry<double>("A", {.description = "A"}),
-            entry<double>("B", {.description = "B"}),
-            entry<double>("C", {.description = "C"}),
-            entry<double>("D", {.description = "D"}),
-            entry<double>(
+            parameter<double>("A", {.description = "A"}),
+            parameter<double>("B", {.description = "B"}),
+            parameter<double>("C", {.description = "C"}),
+            parameter<double>("D", {.description = "D"}),
+            parameter<double>(
                 "Offset", {.description = "offset for contact to start", .default_value = 0.0}),
         },
         {
@@ -76,9 +76,9 @@ Core::IO::InputSpec CONTACT::CONSTITUTIVELAW::valid_contact_constitutive_laws()
   {
     specs.emplace_back(group("CoConstLaw_linear",
         {
-            entry<double>("A", {.description = "slope"}),
-            entry<double>("B", {.description = "y intercept"}),
-            entry<double>(
+            parameter<double>("A", {.description = "slope"}),
+            parameter<double>("B", {.description = "y intercept"}),
+            parameter<double>(
                 "Offset", {.description = "offset for contact to start", .default_value = 0.0}),
         },
         {
@@ -91,41 +91,41 @@ Core::IO::InputSpec CONTACT::CONSTITUTIVELAW::valid_contact_constitutive_laws()
   {
     specs.emplace_back(group("CoConstLaw_mirco",
         {
-            entry<int>("FirstMatID", {.description = "First material ID"}),
-            entry<int>("SecondMatID", {.description = "Second material ID"}),
-            entry<double>(
+            parameter<int>("FirstMatID", {.description = "First material ID"}),
+            parameter<int>("SecondMatID", {.description = "Second material ID"}),
+            parameter<double>(
                 "LateralLength", {.description = "length of lateral side of the BEM patch"}),
-            entry<int>("Resolution", {.description = "resolution of the surface"}),
-            entry<bool>("PressureGreenFunFlag",
+            parameter<int>("Resolution", {.description = "resolution of the surface"}),
+            parameter<bool>("PressureGreenFunFlag",
                 {.description = "Use pressure-based Green function instead of a point-force-based",
                     .default_value = true}),
-            entry<int>("InitialTopologyStdDeviationFunct",
+            parameter<int>("InitialTopologyStdDeviationFunct",
                 {.description = "Function id for Initial Standard deviation for the "
                                 "random-midpoint generator",
                     .default_value = 100}),
-            entry<int>(
+            parameter<int>(
                 "HurstExponentFunct", {.description = "Function for Hurst exponent of the surface",
                                           .default_value = 100}),
-            entry<bool>("RandomTopologyFlag",
+            parameter<bool>("RandomTopologyFlag",
                 {.description = "Use random midpoint generator flag", .default_value = true}),
-            entry<bool>(
+            parameter<bool>(
                 "RandomSeedFlag", {.description = "Random seed flag", .default_value = false}),
-            entry<int>("RandomGeneratorSeed",
+            parameter<int>("RandomGeneratorSeed",
                 {.description = "Use random seed to reproduce results", .default_value = 95}),
-            entry<double>("Tolerance",
+            parameter<double>("Tolerance",
                 {.description = "Tolerance for the convergence of force", .default_value = 0.01}),
-            entry<int>("MaxIteration",
+            parameter<int>("MaxIteration",
                 {.description = "Maximum iteration of NNLS", .default_value = 1000}),
-            entry<bool>("WarmStartingFlag",
+            parameter<bool>("WarmStartingFlag",
                 {.description = "Warm-starting flag, solution accelerator", .default_value = true}),
-            entry<double>(
+            parameter<double>(
                 "Offset", {.description = "offset for contact to start", .default_value = 0.0}),
-            entry<double>("FiniteDifferenceFraction",
+            parameter<double>("FiniteDifferenceFraction",
                 {.description = "Fraction of perturbation difference compared to the actual gap",
                     .default_value = 0.001}),
-            entry<double>("ActiveGapTolerance",
+            parameter<double>("ActiveGapTolerance",
                 {.description = "Minimum gap to consider a node as active", .default_value = 1e-6}),
-            entry<std::string>("TopologyFilePath",
+            parameter<std::string>("TopologyFilePath",
                 {.description = "Path to file with micro-topology data", .default_value = ""}),
         },
         {
@@ -135,7 +135,7 @@ Core::IO::InputSpec CONTACT::CONSTITUTIVELAW::valid_contact_constitutive_laws()
   }
 
   auto valid_law = all_of({
-      entry<int>("LAW"),
+      parameter<int>("LAW"),
       one_of(specs, store_index_as("LAW_TYPE", group_index_to_type)),
   });
 
diff --git a/src/core/fem/src/condition/4C_fem_condition_definition.cpp b/src/core/fem/src/condition/4C_fem_condition_definition.cpp
index 678dc8210d5..2c9b00af828 100644
--- a/src/core/fem/src/condition/4C_fem_condition_definition.cpp
+++ b/src/core/fem/src/condition/4C_fem_condition_definition.cpp
@@ -59,8 +59,8 @@ void Core::Conditions::ConditionDefinition::read(Core::IO::InputFile& input,
 {
   using namespace Core::IO::InputSpecBuilders;
   auto condition_spec = all_of({
-      entry<int>("E", {.description = "ID of the condition. This ID refers to the respective "
-                                      "topological entity of the condition."}),
+      parameter<int>("E", {.description = "ID of the condition. This ID refers to the respective "
+                                          "topological entity of the condition."}),
       all_of(specs_),
   });
 
@@ -103,7 +103,7 @@ std::ostream& Core::Conditions::ConditionDefinition::print(std::ostream& stream)
 
   using namespace Core::IO::InputSpecBuilders;
   auto condition_spec = all_of({
-      entry<int>("E"),
+      parameter<int>("E"),
       all_of(specs_),
   });
 
diff --git a/src/core/fem/src/general/utils/4C_fem_general_utils_createdis.cpp b/src/core/fem/src/general/utils/4C_fem_general_utils_createdis.cpp
index c85e89f761b..f66fb7a628c 100644
--- a/src/core/fem/src/general/utils/4C_fem_general_utils_createdis.cpp
+++ b/src/core/fem/src/general/utils/4C_fem_general_utils_createdis.cpp
@@ -253,10 +253,10 @@ Core::IO::InputSpec Core::FE::valid_cloning_material_map()
 {
   using namespace Core::IO::InputSpecBuilders;
   return all_of({
-      entry<std::string>("SRC_FIELD"),
-      entry<int>("SRC_MAT"),
-      entry<std::string>("TAR_FIELD"),
-      entry<int>("TAR_MAT"),
+      parameter<std::string>("SRC_FIELD"),
+      parameter<int>("SRC_MAT"),
+      parameter<std::string>("TAR_FIELD"),
+      parameter<int>("TAR_MAT"),
 
   });
 }
diff --git a/src/core/io/src/4C_io_input_file.cpp b/src/core/io/src/4C_io_input_file.cpp
index 5280ce05fc7..30aad8b60e5 100644
--- a/src/core/io/src/4C_io_input_file.cpp
+++ b/src/core/io/src/4C_io_input_file.cpp
@@ -599,7 +599,7 @@ namespace Core::IO
         "Section 'INCLUDES' is a reserved section name with special meaning. Please choose a "
         "different name.");
     pimpl_->valid_sections_["INCLUDES"] =
-        InputSpecBuilders::entry<std::vector<std::filesystem::path>>("INCLUDES",
+        InputSpecBuilders::parameter<std::vector<std::filesystem::path>>("INCLUDES",
             {
                 .description = "Path to files that should be included into this file. "
                                "The paths can be either absolute or relative to the file.",
diff --git a/src/core/io/src/4C_io_input_spec_builders.cpp b/src/core/io/src/4C_io_input_spec_builders.cpp
index 8d266c40900..0c97f59543c 100644
--- a/src/core/io/src/4C_io_input_spec_builders.cpp
+++ b/src/core/io/src/4C_io_input_spec_builders.cpp
@@ -263,10 +263,10 @@ namespace
 
     switch (entry.type)
     {
-      case MatchEntry::Type::entry:
+      case MatchEntry::Type::parameter:
       {
         out << indent;
-        out << std::format("{} {} entry '{}'", state_symbol[static_cast<int>(entry.state)],
+        out << std::format("{} {} parameter '{}'", state_symbol[static_cast<int>(entry.state)],
             state_phrase[static_cast<int>(entry.state)], entry.spec->impl().name());
         if (entry.state == MatchEntry::State::partial)
         {
@@ -454,7 +454,7 @@ namespace
     {
       switch (entry.type)
       {
-        case MatchEntry::Type::entry:
+        case MatchEntry::Type::parameter:
         {
           if (entry.state == MatchEntry::State::matched)
           {
diff --git a/src/core/io/src/4C_io_input_spec_builders.hpp b/src/core/io/src/4C_io_input_spec_builders.hpp
index 519df42a1c8..27e06313049 100644
--- a/src/core/io/src/4C_io_input_spec_builders.hpp
+++ b/src/core/io/src/4C_io_input_spec_builders.hpp
@@ -236,7 +236,7 @@ namespace Core::IO
       enum class Type : std::uint8_t
       {
         unknown,
-        entry,
+        parameter,
         group,
         all_of,
         one_of,
@@ -511,8 +511,8 @@ namespace Core::IO
    * @code
    * auto input = group("params",
    *   {
-   *   entry<int>("a", {.description = "An integer value", .required = true}),
-   *   entry<std::vector<double>>("b", {.description = "A vector of doubles", .required = false,
+   *   parameter<int>("a", {.description = "An integer value", .required = true}),
+   *   parameter<std::vector<double>>("b", {.description = "A vector of doubles", .required = false,
    *     .size = 4}),
    *   }
    * );
@@ -526,7 +526,7 @@ namespace Core::IO
 
     /**
      * This constant signifies that a size is dynamic and will be determined at runtime. Pass this
-     * value to the size parameter of a vector-valued entry() or the list() function.
+     * value to the size parameter of a vector-valued parameter() or the list() function.
      *
      * @note Dynamic sizes do not work for the legacy dat file format and will throw a runtime
      * error.
@@ -545,16 +545,14 @@ namespace Core::IO
      */
     using Size = std::variant<int, SizeCallback>;
 
-
-
     /**
-     * Callback function that may be attached to entry().
+     * Callback function that may be attached to parameter().
      */
-    using EntryCallback = std::function<void(InputParameterContainer&)>;
+    using ParameterCallback = std::function<void(InputParameterContainer&)>;
 
-    //! Additional parameters for an entry().
+    //! Additional parameters for a parameter().
     template <typename T>
-    struct EntryData
+    struct ParameterData
     {
       using StoredType = T;
       /**
@@ -577,12 +575,12 @@ namespace Core::IO
        * An optional callback that is called after the value has been parsed. This can be used to
        * set additional values in the container.
        */
-      EntryCallback on_parse_callback{nullptr};
+      ParameterCallback on_parse_callback{nullptr};
     };
 
     template <typename T>
       requires(rank<T>() == 1)
-    struct EntryData<T>
+    struct ParameterData<T>
     {
       using StoredType = T;
 
@@ -592,7 +590,7 @@ namespace Core::IO
 
       std::optional<StoredType> default_value{};
 
-      EntryCallback on_parse_callback{nullptr};
+      ParameterCallback on_parse_callback{nullptr};
 
       /**
        * The size of the vector. This can be a fixed size, #dynamic_size, or a callback that
@@ -603,7 +601,7 @@ namespace Core::IO
 
     template <typename T>
       requires(rank<T>() > 1)
-    struct EntryData<T>
+    struct ParameterData<T>
     {
       using StoredType = T;
 
@@ -613,7 +611,7 @@ namespace Core::IO
 
       std::optional<StoredType> default_value{};
 
-      EntryCallback on_parse_callback{nullptr};
+      ParameterCallback on_parse_callback{nullptr};
 
       std::array<Size, rank<T>()> size;
     };
@@ -687,7 +685,7 @@ namespace Core::IO
       {
         std::string name;
         using StoredType = T;
-        EntryData<T> data;
+        ParameterData<T> data;
         void parse(ValueParser& parser, InputParameterContainer& container) const;
         bool match(ConstYamlNodeRef node, InputParameterContainer& container,
             IO::Internal::MatchEntry& match_entry) const;
@@ -707,7 +705,7 @@ namespace Core::IO
       {
         std::string name;
         using StoredType = T;
-        EntryData<T> data;
+        ParameterData<T> data;
         std::vector<std::pair<std::string, StoredType>> choices;
         void parse(ValueParser& parser, InputParameterContainer& container) const;
         bool match(ConstYamlNodeRef node, InputParameterContainer& container,
@@ -798,8 +796,8 @@ namespace Core::IO
       //! Helper to create selection() specs.
       //! Note that the type can be anything since we never read or write values of this type.
       template <typename T>
-      [[nodiscard]] InputSpec selection_internal(
-          std::string name, std::vector<std::pair<std::string, T>> choices, EntryData<T> data = {});
+      [[nodiscard]] InputSpec selection_internal(std::string name,
+          std::vector<std::pair<std::string, T>> choices, ParameterData<T> data = {});
 
 
       struct SizeChecker
@@ -825,41 +823,42 @@ namespace Core::IO
     }  // namespace Internal
 
     /**
-     * Create a normal entry with given @p name. All entries are parameterized by a struct which
-     * contains the optional `description`, `required` and `default_value` fields. The following
-     * examples demonstrate how entries can be created:
+     * Create a normal parameter with given @p name. All parameters are parameterized by a struct
+     * which contains the optional `description`, `required` and `default_value` fields. The
+     * following examples demonstrate how parameters can be created:
      *
      * @code
-     * // An entry with name and description. By default, the entry is required.
-     * entry<std::string>("my_string", {.description = "A string value."});
+     * // A parameter with name and description. By default, the parameter is required.
+     * parameter<std::string>("my_string", {.description = "A string value."});
      *
-     * // An entry with a default value. This entry is implicitly optional because a default value
-     * // is given.
-     * entry<double>("my_double", {.default_value = 3.14});
+     * // A parameter with a default value. This parameter is implicitly optional because a default
+     * // value is given.
+     * parameter<double>("my_double", {.default_value = 3.14});
      * // This is equivalent to:
-     * entry<double>("my_double", {.required = false, .default_value = 3.14});
+     * parameter<double>("my_double", {.required = false, .default_value = 3.14});
      *
-     * // An optional entry. This value does not have a default value.
-     * entry<int>("my_int", {.required = false});
+     * // An optional parameter. This value does not have a default value.
+     * parameter<int>("my_int", {.required = false});
      *
-     * // An alternative way to create this optional int entry is achieved with the Noneable type.
-     * // This value is optional and by default has an empty value represented by "none" in the
+     * // An alternative way to create this optional int parameter is achieved with the Noneable
+     * // type. This value is optional and by default has an empty value represented by "none" in
+     * the
      * // input file.
-     * entry<Noneable<int>>("my_int", .default_value = none<int>);
+     * parameter<Noneable<int>>("my_int", .default_value = none<int>);
      *
-     * // A vector entry with a fixed size of 3.
-     * entry<std::vector<double>>("my_vector", {.size = 3});
+     * // A vector parameter with a fixed size of 3.
+     * parameter<std::vector<double>>("my_vector", {.size = 3});
      *
      * // A vector may also contain Noneable values.
-     * entry<std::vector<Noneable<double>>>("my_vector", {.size = 3});
+     * parameter<std::vector<Noneable<double>>>("my_vector", {.size = 3});
      *
-     * // A vector entry with a size that is determined by the value of another parameter. The
+     * // A vector parameter with a size that is determined by the value of another parameter. The
      * // size is given as a callback.
-     * entry<int>("N");
-     * entry<std::vector<double>>("my_vector", {.size = from_parameter<int>("N")});
+     * parameter<int>("N");
+     * parameter<std::vector<double>>("my_vector", {.size = from_parameter<int>("N")});
      *
-     * // A vector entry which performs an additional action after parsing.
-     * entry<std::filesystem::path>("data_file", {.description = "A path to a file.",
+     * // A vector parameter which performs an additional action after parsing.
+     * parameter<std::filesystem::path>("data_file", {.description = "A path to a file.",
      *   .on_parse_callback = [](InputParameterContainer& container) {
      *     // Perform an action with the parsed path.
      *     std::filesystem::path path = container.get<std::filesystem::path>("my_path");
@@ -869,8 +868,9 @@ namespace Core::IO
      *   }});
      * @endcode
      *
-     * After parsing an InputSpec with fully_parse(), the value of the entry can be retrieved from
-     * an InputParameterContainer. The details depend on the `required` and `default_value` fields:
+     * After parsing an InputSpec with fully_parse(), the value of the parameter can be retrieved
+     * from an InputParameterContainer. The details depend on the `required` and `default_value`
+     * fields:
      *
      *   - `required` is used to determine whether the parameter is required in the input file. Note
      *     that by default, if `required` is not set, the parameter is implicitly required. Failing
@@ -926,12 +926,12 @@ namespace Core::IO
      *     InputParameterContainer::get(). If the parameter is not present in the input file or set
      *     to "none", the Noneable<T> value will be empty.
      *
-     * @tparam T The data type of the entry. Must be a SupportedType.
+     * @tparam T The data type of the parameter. Must be a SupportedType.
      *
      * @relatedalso InputSpec
      */
     template <SupportedType T>
-    [[nodiscard]] InputSpec entry(std::string name, EntryData<T>&& data = {});
+    [[nodiscard]] InputSpec parameter(std::string name, ParameterData<T>&& data = {});
 
     /**
      * Create a callback that returns the value of the parameter with the given @p name. Such a
@@ -941,8 +941,8 @@ namespace Core::IO
      *
      * @code
      *   auto input_spec = group({
-     *    entry<int>("N"),
-     *    entry<std::vector<double>>("data", {.size = read_from_parameter<int>("N")}),
+     *    parameter<int>("N"),
+     *    parameter<std::vector<double>>("data", {.size = read_from_parameter<int>("N")}),
      *    });
      * @endcode
      *
@@ -954,7 +954,7 @@ namespace Core::IO
     [[nodiscard]] auto from_parameter(const std::string& name);
 
     /**
-     * An entry whose value is a a selection from a list of choices. For example:
+     * A parameter whose value is a a selection from a list of choices. For example:
      *
      * @code
      * selection<int>("my_selection", {{"a", 1}, {"b", 2}, {"c", 3}});
@@ -965,7 +965,7 @@ namespace Core::IO
      * any type. This function is for convenience, as you do not need to convert parsed string
      * values to another type yourself. A frequent use case is to map strings to enum constants.
      *
-     * The remaining parameterization options follow the same rules as for the entry() function.
+     * The remaining parameterization options follow the same rules as for the parameter() function.
      *
      * @note If you want to store the choices as strings and not map them to another type, use the
      * other selection() function.
@@ -974,8 +974,8 @@ namespace Core::IO
      */
     template <typename T>
       requires(!std::same_as<T, std::string>)
-    [[nodiscard]] InputSpec selection(
-        std::string name, std::vector<std::pair<std::string, T>> choices, EntryData<T> data = {});
+    [[nodiscard]] InputSpec selection(std::string name,
+        std::vector<std::pair<std::string, T>> choices, ParameterData<T> data = {});
 
 
     /**
@@ -989,7 +989,7 @@ namespace Core::IO
      */
     template <std::same_as<std::string> T>
     [[nodiscard]] InputSpec selection(
-        std::string name, std::vector<std::string> choices, EntryData<T> data = {});
+        std::string name, std::vector<std::string> choices, ParameterData<T> data = {});
 
     /**
      * A group of InputSpecs. This groups one or more InputSpecs under a name. A group can be
@@ -1000,17 +1000,17 @@ namespace Core::IO
      * // A required group.
      * group("group",
      *    {
-     *      entry<double>("a"),
-     *      entry<int>("b"),
+     *      parameter<double>("a"),
+     *      parameter<int>("b"),
      *    });
      *
-     * // An optional group. If the group is not present in the input, none of the entries are
+     * // An optional group. If the group is not present in the input, none of the parameters are
      * // required. This is useful to require a group of parameters together.
      * group("GenAlpha",
      *   {
-     *      entry<double>("alpha_f"),
-     *      entry<double>("alpha_m"),
-     *      entry<double>("gamma"),
+     *      parameter<double>("alpha_f"),
+     *      parameter<double>("alpha_m"),
+     *      parameter<double>("gamma"),
      *   },
      *   {.required = false}
      *   );
@@ -1018,11 +1018,11 @@ namespace Core::IO
      * //Groups may be nested
      * group("outer",
      *  {
-     *    entry<int>("a"),
+     *    parameter<int>("a"),
      *    group("inner",
      *    {
-     *      entry<double>("b"),
-     *      entry<std::string>("c"),
+     *      parameter<double>("b"),
+     *      parameter<std::string>("c"),
      *    }
      *    ),
      *  });
@@ -1032,19 +1032,19 @@ namespace Core::IO
      * A group introduces a new scope in the input. This group scope is not only useful for
      * structuring the input file, but also to selectively activate a set of parameters, as
      * demonstrated in the second example. If an optional group is not present in the input, none of
-     * the entries are required. If the group is present, all entries are required. This is often
+     * its children are required. If the group is present, all children are required. This is often
      * exactly what you need: a group activates a feature which requires certain parameters to
      * be present.
      *
-     * Whether a group can have a default value is determined by the default values of its entries.
-     * If all of its entries have default values, the group can have a default value. In this case,
-     * you may set the `defaultable` option to guarantee that the default values of the entries are
+     * Whether a group can have a default value is determined by the default values of its children.
+     * If all of its children have default values, the group can have a default value. In this case,
+     * you may set the `defaultable` option to guarantee that the default values of the children are
      * stored under the group name in the container, even if the group is not present in the input.
      * Obviously, this only makes sense if the group is not required.
-     * This behavior is analogous to the behavior of the entry() function. While entries with
+     * This behavior is analogous to the behavior of the parameter() function. While parameters with
      * default values are often a good idea (if the default value is meaningful), groups with
      * default values are less common. If you follow the advice to use groups to activate features,
-     * you will usually have required entries in the group and, consequently, the group cannot be
+     * you will usually have required parameters in the group and, consequently, the group cannot be
      * `defaultable`. Put differently, if you have a group with many default values, you are likely
      * not using the InputSpecs to their full potential. Consider splitting the group into multiple
      * smaller groups or use the one_of() function to select between different groups.
@@ -1062,13 +1062,13 @@ namespace Core::IO
      *
      * @code
      * all_of({
-     *   entry<int>("a"),
-     *   entry<double>("b"),
-     *   entry<std::string>("c"),
+     *   parameter<int>("a"),
+     *   parameter<double>("b"),
+     *   parameter<std::string>("c"),
      *   });
      * @endcode
      *
-     * will require all three entries to be present in the input.
+     * will require all three parameters to be present in the input.
      *
      * The main application of this function is to gather multiple InputSpecs on the same level and
      * treat them as a single InputSpec. Nesting multiple all_of() specs is possible but does not
@@ -1079,20 +1079,20 @@ namespace Core::IO
      * group("outer",
      * {
      *   all_of({
-     *     entry<int>("a"),
+     *     parameter<int>("a"),
      *     all_of({
-     *       entry<double>("b"),
+     *       parameter<double>("b"),
      *     }),
      *   }),
-     *   entry<std::string>("c"),
+     *   parameter<std::string>("c"),
      * });
      *
      * // version 2
      * group("outer",
      * {
-     *   entry<int>("a"),
-     *   entry<double>("b"),
-     *   entry<std::string>("c"),
+     *   parameter<int>("a"),
+     *   parameter<double>("b"),
+     *   parameter<std::string>("c"),
      * });
      * @endcode
      *
@@ -1115,14 +1115,14 @@ namespace Core::IO
      * one_of({
      *  group("OneStepTheta",
      *  {
-     *    entry<double>("theta"),
+     *    parameter<double>("theta"),
      *  }),
      *  group("GenAlpha",
      *  {
-     *    entry<double>("alpha_f"),
-     *    entry<double>("alpha_m"),
-     *    entry<double>("gamma"),
-     *    entry<bool>("do_logging", {.default_value = false}),
+     *    parameter<double>("alpha_f"),
+     *    parameter<double>("alpha_m"),
+     *    parameter<double>("gamma"),
+     *    parameter<bool>("do_logging", {.default_value = false}),
      *  }),
      *  });
      * @endcode
@@ -1132,8 +1132,9 @@ namespace Core::IO
      * all InputSpecs handed to one_of() need to be `required = true`. While this could silently be
      * changed internally, you will encounter an error if any InputSpec is not required to avoid
      * confusion and stop you from constructing difficult to understand InputSpecs. You can use
-     * entries that are `required = false` nested inside other InputSpecs, see e.g. the `do_logging`
-     * entry in the example code. The return one_of() InputSpec is always treated as required.
+     * parameters that are `required = false` nested inside other InputSpecs, see e.g. the
+     * `do_logging` parameter in the example code. The return one_of() InputSpec is always treated
+     * as required.
      *
      * The optional @p on_parse_callback may be used to perform additional actions after parsing one
      * of the specs. The index of the parsed spec inside the @p specs vector is passed as an
@@ -1167,13 +1168,13 @@ namespace Core::IO
      * one_of({
      *  group("OneStepTheta",
      *  {
-     *    entry<double>("theta"),
+     *    parameter<double>("theta"),
      *  }),
      *  group("GenAlpha",
      *  {
-     *    entry<double>("alpha_f"),
-     *    entry<double>("alpha_m"),
-     *    entry<double>("gamma"),
+     *    parameter<double>("alpha_f"),
+     *    parameter<double>("alpha_m"),
+     *    parameter<double>("gamma"),
      *  }),
      *  },
      *  store_index_as<TimeIntegrationMethod>("index",
@@ -1198,7 +1199,7 @@ namespace Core::IO
      * or dynamic_size (the default). For example,
      *
      * @code
-     * list("my_list", entry<int>("a"), {.size = 3});
+     * list("my_list", parameter<int>("a"), {.size = 3});
      * @endcode
      *
      * will match the following yaml input:
@@ -1211,7 +1212,7 @@ namespace Core::IO
      * @endcode
      *
      * @note The list() function is not intended to specify an array of primitive values of type T.
-     * Use the `entry<std::vector<T>>()` function for this purpose. As a developer of a new
+     * Use the `parameter<std::vector<T>>()` function for this purpose. As a developer of a new
      * InputSpec, you should rarely need the list() function.
      */
     [[nodiscard]] InputSpec list(std::string name, InputSpec spec, ListData data = {});
@@ -1282,7 +1283,7 @@ template <Core::IO::SupportedType T>
 bool Core::IO::InputSpecBuilders::Internal::EntrySpec<T>::match(ConstYamlNodeRef node,
     InputParameterContainer& container, IO::Internal::MatchEntry& match_entry) const
 {
-  match_entry.type = IO::Internal::MatchEntry::Type::entry;
+  match_entry.type = IO::Internal::MatchEntry::Type::parameter;
   auto spec_name = ryml::to_csubstr(name);
 
   // If we are not even in a map, we refuse to do anything and let the MatchTree handle this case.
@@ -1292,7 +1293,7 @@ bool Core::IO::InputSpecBuilders::Internal::EntrySpec<T>::match(ConstYamlNodeRef
 
   if (!node.node.has_child(spec_name))
   {
-    // It is OK to not encounter an optional entry
+    // It is OK to not encounter an optional parameter
     if (data.default_value.has_value())
     {
       container.add(name, data.default_value.value());
@@ -1478,7 +1479,7 @@ template <typename T>
 bool Core::IO::InputSpecBuilders::Internal::SelectionSpec<T>::match(ConstYamlNodeRef node,
     InputParameterContainer& container, IO::Internal::MatchEntry& match_entry) const
 {
-  match_entry.type = IO::Internal::MatchEntry::Type::entry;
+  match_entry.type = IO::Internal::MatchEntry::Type::parameter;
   auto spec_name = ryml::to_csubstr(name);
 
   // If we are not even in a map, we refuse to do anything and let the MatchTree handle this case.
@@ -1488,7 +1489,7 @@ bool Core::IO::InputSpecBuilders::Internal::SelectionSpec<T>::match(ConstYamlNod
 
   if (!node.node.has_child(spec_name))
   {
-    // It is OK to not encounter an optional entry
+    // It is OK to not encounter an optional parameter
     if (data.default_value.has_value())
     {
       container.add(name, data.default_value.value());
@@ -1654,7 +1655,8 @@ auto Core::IO::InputSpecBuilders::from_parameter(const std::string& name)
 
 
 template <Core::IO::SupportedType T>
-Core::IO::InputSpec Core::IO::InputSpecBuilders::entry(std::string name, EntryData<T>&& data)
+Core::IO::InputSpec Core::IO::InputSpecBuilders::parameter(
+    std::string name, ParameterData<T>&& data)
 {
   Internal::sanitize_required_default(data);
 
@@ -1671,7 +1673,7 @@ Core::IO::InputSpec Core::IO::InputSpecBuilders::entry(std::string name, EntryDa
 
 template <typename T>
 Core::IO::InputSpec Core::IO::InputSpecBuilders::Internal::selection_internal(
-    std::string name, std::vector<std::pair<std::string, T>> choices, EntryData<T> data)
+    std::string name, std::vector<std::pair<std::string, T>> choices, ParameterData<T> data)
 {
   FOUR_C_ASSERT_ALWAYS(!choices.empty(), "Selection must have at least one choice.");
   Internal::sanitize_required_default(data);
@@ -1718,7 +1720,7 @@ Core::IO::InputSpec Core::IO::InputSpecBuilders::Internal::selection_internal(
 template <typename T>
   requires(!std::same_as<T, std::string>)
 Core::IO::InputSpec Core::IO::InputSpecBuilders::selection(
-    std::string name, std::vector<std::pair<std::string, T>> choices, EntryData<T> data)
+    std::string name, std::vector<std::pair<std::string, T>> choices, ParameterData<T> data)
 {
   return Internal::selection_internal(name, choices, data);
 }
@@ -1726,7 +1728,7 @@ Core::IO::InputSpec Core::IO::InputSpecBuilders::selection(
 
 template <std::same_as<std::string> T>
 Core::IO::InputSpec Core::IO::InputSpecBuilders::selection(
-    std::string name, std::vector<std::string> choices, EntryData<T> data)
+    std::string name, std::vector<std::string> choices, ParameterData<T> data)
 {
   std::vector<std::pair<std::string, std::string>> choices_with_strings;
   for (const auto& choice : choices)
diff --git a/src/core/io/tests/4C_io_input_file_test.cpp b/src/core/io/tests/4C_io_input_file_test.cpp
index bf8ddbc26ea..85b687cbc44 100644
--- a/src/core/io/tests/4C_io_input_file_test.cpp
+++ b/src/core/io/tests/4C_io_input_file_test.cpp
@@ -133,9 +133,9 @@ namespace
 
     MPI_Comm comm(MPI_COMM_WORLD);
     Core::IO::InputFile input{{{"INCLUDED SECTION 2", all_of({
-                                                          entry<int>("a"),
-                                                          entry<double>("b"),
-                                                          entry<bool>("c"),
+                                                          parameter<int>("a"),
+                                                          parameter<double>("b"),
+                                                          parameter<bool>("c"),
                                                       })}},
         {
             "MAIN SECTION",
@@ -152,9 +152,9 @@ namespace
     EXPECT_EQ(input.file_for_section("INCLUDED SECTION 2").filename(), "included.yaml");
 
     auto spec = Core::IO::InputSpecBuilders::all_of({
-        Core::IO::InputSpecBuilders::entry<int>("a"),
-        Core::IO::InputSpecBuilders::entry<double>("b"),
-        Core::IO::InputSpecBuilders::entry<bool>("c"),
+        Core::IO::InputSpecBuilders::parameter<int>("a"),
+        Core::IO::InputSpecBuilders::parameter<double>("b"),
+        Core::IO::InputSpecBuilders::parameter<bool>("c"),
     });
 
     Core::IO::InputParameterContainer container;
diff --git a/src/core/io/tests/4C_io_input_spec_test.cpp b/src/core/io/tests/4C_io_input_spec_test.cpp
index 4e83ae638c9..b054a66ad6f 100644
--- a/src/core/io/tests/4C_io_input_spec_test.cpp
+++ b/src/core/io/tests/4C_io_input_spec_test.cpp
@@ -21,10 +21,10 @@ namespace
   TEST(InputSpecTest, Simple)
   {
     auto spec = all_of({
-        entry<int>("a", {.description = "An integer", .default_value = 1}),
-        entry<double>("b", {.required = true}),
-        entry<std::string>("c", {.required = false}),
-        entry<bool>("d"),
+        parameter<int>("a", {.description = "An integer", .default_value = 1}),
+        parameter<double>("b", {.required = true}),
+        parameter<std::string>("c", {.required = false}),
+        parameter<bool>("d"),
     });
     InputParameterContainer container;
     std::string stream("b 2.0 d true // trailing comment");
@@ -39,9 +39,9 @@ namespace
   TEST(InputSpecTest, OptionalLeftOut)
   {
     auto spec = all_of({
-        entry<int>("a"),
-        entry<double>("b"),
-        entry<std::string>("c", {.default_value = "default"}),
+        parameter<int>("a"),
+        parameter<double>("b"),
+        parameter<std::string>("c", {.default_value = "default"}),
     });
 
     {
@@ -58,9 +58,9 @@ namespace
   TEST(InputSpecTest, RequiredLeftOut)
   {
     auto spec = all_of({
-        entry<int>("a"),
-        entry<double>("b"),
-        entry<std::string>("c"),
+        parameter<int>("a"),
+        parameter<double>("b"),
+        parameter<std::string>("c"),
     });
 
     {
@@ -103,7 +103,7 @@ namespace
   {
     // This used to be a bug where a single default dat parameter was not accepted.
     auto spec = all_of({
-        entry<double>("a", {.default_value = 1.0}),
+        parameter<double>("a", {.default_value = 1.0}),
     });
 
     {
@@ -135,8 +135,8 @@ namespace
   TEST(InputSpecTest, Vector)
   {
     auto spec = all_of({
-        entry<std::vector<std::vector<int>>>("a", {.size = {2, 2}}),
-        entry<std::vector<double>>("b", {.size = 3}),
+        parameter<std::vector<std::vector<int>>>("a", {.size = {2, 2}}),
+        parameter<std::vector<double>>("b", {.size = 3}),
     });
 
     {
@@ -171,12 +171,12 @@ namespace
   TEST(InputSpecTest, Noneable)
   {
     auto spec = all_of({
-        entry<int>("size"),
-        entry<std::vector<Noneable<int>>>("a", {.size = from_parameter<int>("size")}),
-        entry<Noneable<std::string>>("b", {.description = "b"}),
-        entry<Noneable<double>>("c", {.default_value = 1.0}),
-        entry<Noneable<bool>>("d", {.required = false}),
-        entry<Noneable<int>>("e", {.default_value = none<int>}),
+        parameter<int>("size"),
+        parameter<std::vector<Noneable<int>>>("a", {.size = from_parameter<int>("size")}),
+        parameter<Noneable<std::string>>("b", {.description = "b"}),
+        parameter<Noneable<double>>("c", {.default_value = 1.0}),
+        parameter<Noneable<bool>>("d", {.required = false}),
+        parameter<Noneable<int>>("e", {.default_value = none<int>}),
     });
 
     {
@@ -257,9 +257,9 @@ namespace
   TEST(InputSpecTest, VectorWithParsedLength)
   {
     auto spec = all_of({
-        entry<int>("a"),
-        entry<std::vector<double>>("b", {.size = from_parameter<int>("a")}),
-        entry<std::string>("c"),
+        parameter<int>("a"),
+        parameter<std::vector<double>>("b", {.size = from_parameter<int>("a")}),
+        parameter<std::string>("c"),
     });
 
     {
@@ -288,16 +288,16 @@ namespace
   TEST(InputSpecTest, EntryWithCallback)
   {
     auto spec = all_of({
-        entry<int>("a"),
-        entry<double>("b"),
-        entry<std::string>("c",
+        parameter<int>("a"),
+        parameter<double>("b"),
+        parameter<std::string>("c",
             {
                 .description = "A string",
                 .default_value = "Not found",
                 .on_parse_callback = [](InputParameterContainer& container)
                 { container.add<int>("c_as_int", std::stoi(container.get<std::string>("c"))); },
             }),
-        entry<std::string>("s"),
+        parameter<std::string>("s"),
     });
 
     {
@@ -324,10 +324,10 @@ namespace
   TEST(InputSpecTest, Selection)
   {
     auto spec = all_of({
-        entry<int>("a"),
+        parameter<int>("a"),
         selection<int>("b", {{"b1", 1}, {"b2", 2}}, {.default_value = 1}),
         selection<std::string>("c", {"c1", "c2"}, {.default_value = "c2"}),
-        entry<std::string>("d"),
+        parameter<std::string>("d"),
     });
 
     {
@@ -353,10 +353,10 @@ namespace
   TEST(InputSpecTest, Unparsed)
   {
     auto spec = all_of({
-        entry<int>("a"),
-        entry<int>("optional", {.default_value = 42}),
-        entry<double>("b"),
-        entry<std::string>("c"),
+        parameter<int>("a"),
+        parameter<int>("optional", {.default_value = 42}),
+        parameter<double>("b"),
+        parameter<std::string>("c"),
     });
     InputParameterContainer container;
     std::string stream("a 1 b 2.0 c string unparsed unparsed");
@@ -369,28 +369,28 @@ namespace
   TEST(InputSpecTest, Groups)
   {
     auto spec = all_of({
-        entry<int>("a"),
+        parameter<int>("a"),
         group("group1",
             {
-                entry<double>("b"),
+                parameter<double>("b"),
             }),
         group("group2",
             {
-                entry<double>("b", {.default_value = 3.0}),
-                entry<std::string>("c"),
+                parameter<double>("b", {.default_value = 3.0}),
+                parameter<std::string>("c"),
             },
             {
                 .required = false,
             }),
         group("group3",
             {
-                entry<std::string>("c", {.default_value = "default"}),
+                parameter<std::string>("c", {.default_value = "default"}),
             },
             {
                 .required = false,
                 .defaultable = true,
             }),
-        entry<std::string>("c"),
+        parameter<std::string>("c"),
     });
 
     {
@@ -435,10 +435,10 @@ namespace
   TEST(InputSpecTest, NestedAllOf)
   {
     auto spec = all_of({
-        entry<int>("a"),
+        parameter<int>("a"),
         all_of({
             all_of({
-                entry<double>("b"),
+                parameter<double>("b"),
             }),
             // Not useful but might happen in practice, so ensure this can be handled.
             all_of({}),
@@ -459,13 +459,13 @@ namespace
   TEST(InputSpecTest, OneOf)
   {
     auto spec = all_of({
-        entry<int>("a", {.default_value = 42}),
+        parameter<int>("a", {.default_value = 42}),
         one_of({
-            entry<double>("b"),
+            parameter<double>("b"),
             group("group",
                 {
-                    entry<std::string>("c"),
-                    entry<double>("d"),
+                    parameter<std::string>("c"),
+                    parameter<double>("d"),
                 }),
         }),
     });
@@ -522,12 +522,12 @@ namespace
     auto spec = one_of(
         {
             all_of({
-                entry<int>("a"),
-                entry<double>("b"),
+                parameter<int>("a"),
+                parameter<double>("b"),
             }),
             all_of({
-                entry<std::string>("c"),
-                entry<double>("d"),
+                parameter<std::string>("c"),
+                parameter<double>("d"),
             }),
         },
         // Additionally store the index of the parsed group but map it to a different value.
@@ -574,15 +574,15 @@ namespace
   {
     auto spec = one_of({
         one_of({
-            entry<int>("a"),
-            entry<double>("b"),
+            parameter<int>("a"),
+            parameter<double>("b"),
         }),
         one_of({
-            entry<std::string>("c"),
-            entry<double>("d"),
+            parameter<std::string>("c"),
+            parameter<double>("d"),
             one_of({
-                entry<int>("e"),
-                entry<std::string>("f"),
+                parameter<int>("e"),
+                parameter<std::string>("f"),
             }),
         }),
     });
@@ -606,20 +606,20 @@ namespace
   {
     auto spec = one_of({
         one_of({
-            entry<int>("a"),
-            entry<double>("b"),
+            parameter<int>("a"),
+            parameter<double>("b"),
         }),
         // This one_of has a callback and should not be flattened into the parent one_of.
         one_of(
             {
-                entry<std::string>("c"),
+                parameter<std::string>("c"),
                 // This one_of will not be flattened into the parent that has a callback.
                 one_of({
-                    entry<double>("d"),
+                    parameter<double>("d"),
                     // This one_of can be flattened into the parent one_of.
                     one_of({
-                        entry<int>("e"),
-                        entry<std::string>("f"),
+                        parameter<int>("e"),
+                        parameter<std::string>("f"),
                     }),
                 }),
             },
@@ -667,16 +667,16 @@ description: 'one_of {a, b, one_of {c, one_of {d, e, f}}}'
 
   TEST(InputSpecTest, PrintAsDat)
   {
-    auto spec =
-        group("g", {
-                       // Note: the all_of entries will be pulled into the parent group.
-                       all_of({
-                           entry<int>("a", {.description = "An integer"}),
-                           selection<int>("c", {{"c1", 1}, {"c2", 2}},
-                               {.description = "Selection", .default_value = 1}),
-                       }),
-                       entry<int>("d", {.description = "Another\n integer ", .default_value = 42}),
-                   });
+    auto spec = group(
+        "g", {
+                 // Note: the all_of entries will be pulled into the parent group.
+                 all_of({
+                     parameter<int>("a", {.description = "An integer"}),
+                     selection<int>("c", {{"c1", 1}, {"c2", 2}},
+                         {.description = "Selection", .default_value = 1}),
+                 }),
+                 parameter<int>("d", {.description = "Another\n integer ", .default_value = 42}),
+             });
 
     {
       std::ostringstream out;
@@ -692,35 +692,35 @@ description: 'one_of {a, b, one_of {c, one_of {d, e, f}}}'
   TEST(InputSpecTest, EmitMetadata)
   {
     auto spec = all_of({
-        entry<int>("a", {.default_value = 42}),
-        entry<std::vector<Noneable<double>>>(
+        parameter<int>("a", {.default_value = 42}),
+        parameter<std::vector<Noneable<double>>>(
             "b", {.default_value = std::vector<Noneable<double>>{1., none<double>, 3.}, .size = 3}),
         one_of({
             all_of({
-                entry<std::map<std::string, std::string>>(
+                parameter<std::map<std::string, std::string>>(
                     "b", {.default_value = std::map<std::string, std::string>{{"key", "abc"}},
                              .size = 1}),
-                entry<std::string>("c"),
+                parameter<std::string>("c"),
             }),
-            entry<std::vector<std::vector<std::vector<int>>>>(
+            parameter<std::vector<std::vector<std::vector<int>>>>(
                 "triple_vector", {.size = {dynamic_size, 2, from_parameter<int>("a")}}),
             group("group",
                 {
-                    entry<std::string>("c", {.description = "A string"}),
-                    entry<double>("d"),
+                    parameter<std::string>("c", {.description = "A string"}),
+                    parameter<double>("d"),
                 },
                 {.description = "A group"}),
         }),
         selection<int>("e", {{"e1", 1}, {"e2", 2}}, {.default_value = 1}),
         group("group2",
             {
-                entry<int>("g"),
+                parameter<int>("g"),
             },
             {.required = false}),
         list("list",
             all_of({
-                entry<int>("l1"),
-                entry<double>("l2"),
+                parameter<int>("l1"),
+                parameter<double>("l2"),
             }),
             {.size = 2}),
     });
@@ -832,14 +832,14 @@ required: true
     InputSpec spec;
     {
       auto tmp = all_of({
-          entry<int>("a"),
-          entry<std::string>("b"),
+          parameter<int>("a"),
+          parameter<std::string>("b"),
           selection<int>("c", {{"c1", 1}, {"c2", 2}}, {.default_value = 1}),
       });
 
       spec = all_of({
           tmp,
-          entry<int>("d"),
+          parameter<int>("d"),
       });
     }
 
@@ -857,7 +857,7 @@ required: true
 
   TEST(InputSpecTest, MatchYamlEntry)
   {
-    auto spec = entry<int>("a");
+    auto spec = parameter<int>("a");
 
     {
       ryml::Tree tree = init_yaml_tree_with_exceptions();
@@ -883,7 +883,7 @@ required: true
 
       InputParameterContainer container;
       FOUR_C_EXPECT_THROW_WITH_MESSAGE(
-          spec.match(node, container), Core::Exception, "Expected entry 'a'");
+          spec.match(node, container), Core::Exception, "Expected parameter 'a'");
     }
 
     {
@@ -896,15 +896,15 @@ required: true
 
       InputParameterContainer container;
       FOUR_C_EXPECT_THROW_WITH_MESSAGE(
-          spec.match(node, container), Core::Exception, "Expected entry 'a'");
+          spec.match(node, container), Core::Exception, "Expected parameter 'a'");
     }
   }
 
   TEST(InputSpecTest, MatchYamlGroup)
   {
     auto spec = group("group", {
-                                   entry<int>("a"),
-                                   entry<std::string>("b"),
+                                   parameter<int>("a"),
+                                   parameter<std::string>("b"),
                                });
 
     {
@@ -940,12 +940,12 @@ required: true
   TEST(InputSpecTest, MatchYamlAllOf)
   {
     auto spec = all_of({
-        entry<int>("a"),
-        entry<std::vector<std::string>>("b"),
+        parameter<int>("a"),
+        parameter<std::vector<std::string>>("b"),
         selection<int>("c", {{"c1", 1}, {"c2", 2}}, {.default_value = 1}),
         group("group",
             {
-                entry<int>("d"),
+                parameter<int>("d"),
             },
             {.required = false}),
     });
@@ -1006,7 +1006,7 @@ required: true
 
       InputParameterContainer container;
       FOUR_C_EXPECT_THROW_WITH_MESSAGE(
-          spec.match(node, container), Core::Exception, "Expected entry 'b'");
+          spec.match(node, container), Core::Exception, "Expected parameter 'b'");
     }
 
     // too much input
@@ -1034,12 +1034,12 @@ required: true
   {
     auto spec = one_of({
         all_of({
-            entry<int>("a"),
-            entry<std::string>("b"),
+            parameter<int>("a"),
+            parameter<std::string>("b"),
         }),
         all_of({
-            entry<std::string>("a"),
-            entry<double>("d"),
+            parameter<std::string>("a"),
+            parameter<double>("d"),
         }),
     });
 
@@ -1088,13 +1088,13 @@ required: true
           "[X] Expected exactly one but matched multiple:\n"
           "  [!] Possible match:\n"
           "    {\n"
-          "      [ ] Fully matched entry 'a'\n"
-          "      [ ] Fully matched entry 'b'\n"
+          "      [ ] Fully matched parameter 'a'\n"
+          "      [ ] Fully matched parameter 'b'\n"
           "    }\n"
           "  [!] Possible match:\n"
           "    {\n"
-          "      [ ] Fully matched entry 'a'\n"
-          "      [ ] Fully matched entry 'd'\n"
+          "      [ ] Fully matched parameter 'a'\n"
+          "      [ ] Fully matched parameter 'd'\n"
           "    }");
     }
   }
@@ -1103,8 +1103,8 @@ required: true
   {
     auto spec = list("list",
         all_of({
-            entry<int>("a"),
-            entry<std::string>("b"),
+            parameter<int>("a"),
+            parameter<std::string>("b"),
         }),
         {.size = 1});
 
@@ -1208,7 +1208,7 @@ required: true
   TEST(InputSpecTest, MatchYamlPath)
   {
     auto spec = all_of({
-        entry<std::filesystem::path>("a"),
+        parameter<std::filesystem::path>("a"),
     });
 
     {
@@ -1254,9 +1254,9 @@ required: true
   TEST(InputSpecTest, MatchYamlNoneable)
   {
     auto spec = all_of({
-        entry<Noneable<int>>("i", {.default_value = none<int>}),
-        entry<Noneable<std::string>>("s"),
-        entry<std::vector<Noneable<double>>>("v", {.size = 3}),
+        parameter<Noneable<int>>("i", {.default_value = none<int>}),
+        parameter<Noneable<std::string>>("s"),
+        parameter<std::vector<Noneable<double>>>("v", {.size = 3}),
     });
 
     {
@@ -1306,8 +1306,8 @@ v: [Null, NULL, ~] # all the other spellings that YAML supports
   {
     using ComplicatedType = std::vector<std::map<std::string, std::vector<int>>>;
     auto spec = all_of({
-        entry<int>("num"),
-        entry<ComplicatedType>("v", {.size = {2, dynamic_size, from_parameter<int>("num")}}),
+        parameter<int>("num"),
+        parameter<ComplicatedType>("v", {.size = {2, dynamic_size, from_parameter<int>("num")}}),
     });
 
     {
@@ -1358,22 +1358,22 @@ v: [Null, NULL, ~] # all the other spellings that YAML supports
 
       InputParameterContainer container;
       FOUR_C_EXPECT_THROW_WITH_MESSAGE(
-          spec.match(node, container), Core::Exception, "Partially matched entry 'v'");
+          spec.match(node, container), Core::Exception, "Partially matched parameter 'v'");
     }
   }
 
   TEST(InputSpecTest, MaterialExample)
   {
     auto mat_spec = all_of({
-        entry<int>("MAT"),
+        parameter<int>("MAT"),
         one_of({
             group("MAT_A",
                 {
-                    entry<int>("a"),
+                    parameter<int>("a"),
                 }),
             group("MAT_B",
                 {
-                    entry<int>("b"),
+                    parameter<int>("b"),
                 }),
         }),
     });
@@ -1398,9 +1398,9 @@ v: [Null, NULL, ~] # all the other spellings that YAML supports
 
   TEST(InputSpecTest, EmptyMatchesAllDefaulted)
   {
-    // This was a bug where a single defaulted entry was incorrectly reported as not matching.
+    // This was a bug where a single defaulted parameter was incorrectly reported as not matching.
     auto spec = all_of({
-        entry<int>("a", {.default_value = 42}),
+        parameter<int>("a", {.default_value = 42}),
     });
 
     {
@@ -1421,29 +1421,29 @@ v: [Null, NULL, ~] # all the other spellings that YAML supports
         // awkward one_of where the first choice partially matches
         one_of({
             all_of({
-                entry<int>("a"),
-                entry<std::string>("b"),
+                parameter<int>("a"),
+                parameter<std::string>("b"),
             }),
             all_of({
-                entry<int>("a"),
-                entry<double>("d"),
+                parameter<int>("a"),
+                parameter<double>("d"),
             }),
         }),
         // group with all defaulted entries
         group("group",
             {
-                entry<double>("c", {.default_value = 1.0}),
+                parameter<double>("c", {.default_value = 1.0}),
                 selection<int>("d", {{"d1", 1}, {"d2", 2}}, {.default_value = 2}),
             },
             {.required = false}),
         list("list",
             all_of({
-                entry<int>("l1"),
-                entry<double>("l2"),
+                parameter<int>("l1"),
+                parameter<double>("l2"),
             }),
             {.size = 2}),
-        entry<int>("i", {.default_value = 0}),
-        entry<std::vector<double>>("v", {.size = 3}),
+        parameter<int>("i", {.default_value = 0}),
+        parameter<std::vector<double>>("v", {.size = 3}),
     });
 
     std::string dat = "a 1 d 3.0 group c 1 d d2 i 42 v 1.0 2.0 3.0 list l1 1 l2 2.0 l1 3 l2 4.0";
diff --git a/src/core/utils/src/functions/4C_utils_function_library.cpp b/src/core/utils/src/functions/4C_utils_function_library.cpp
index 8fc4a3a702a..7f97b246378 100644
--- a/src/core/utils/src/functions/4C_utils_function_library.cpp
+++ b/src/core/utils/src/functions/4C_utils_function_library.cpp
@@ -66,12 +66,12 @@ void Core::Utils::add_valid_library_functions(Core::Utils::FunctionManager& func
   auto spec = one_of({
       group("FASTPOLYNOMIAL",
           {
-              entry<int>("NUMCOEFF"),
-              entry<std::vector<double>>("COEFF", {.size = from_parameter<int>("NUMCOEFF")}),
+              parameter<int>("NUMCOEFF"),
+              parameter<std::vector<double>>("COEFF", {.size = from_parameter<int>("NUMCOEFF")}),
           }),
       group("CUBIC_SPLINE_FROM_CSV",
           {
-              entry<std::filesystem::path>("CSV"),
+              parameter<std::filesystem::path>("CSV"),
           }),
   });
 
diff --git a/src/core/utils/src/functions/4C_utils_function_manager.cpp b/src/core/utils/src/functions/4C_utils_function_manager.cpp
index 9c4159e84d2..1dbfb6b83d7 100644
--- a/src/core/utils/src/functions/4C_utils_function_manager.cpp
+++ b/src/core/utils/src/functions/4C_utils_function_manager.cpp
@@ -70,58 +70,59 @@ void Core::Utils::add_valid_builtin_functions(Core::Utils::FunctionManager& func
   using namespace IO::InputSpecBuilders;
 
   auto time_info = all_of({
-      entry<int>("NUMPOINTS"),
+      parameter<int>("NUMPOINTS"),
       one_of({
           group("BYNUM",
               {
-                  entry<std::vector<double>>("TIMERANGE", {.size = 2}),
+                  parameter<std::vector<double>>("TIMERANGE", {.size = 2}),
               },
               {.description = "Linearly distribute NUMPOINTS time points in the TIMERANGE."}),
-          entry<std::vector<double>>("TIMES", {.size = from_parameter<int>("NUMPOINTS")}),
+          parameter<std::vector<double>>("TIMES", {.size = from_parameter<int>("NUMPOINTS")}),
       }),
   });
 
   auto spec = one_of({
       all_of({
-          entry<int>("COMPONENT", {.required = false}),
-          entry<std::string>("SYMBOLIC_FUNCTION_OF_SPACE_TIME"),
+          parameter<int>("COMPONENT", {.required = false}),
+          parameter<std::string>("SYMBOLIC_FUNCTION_OF_SPACE_TIME"),
       }),
 
-      entry<std::string>("SYMBOLIC_FUNCTION_OF_TIME"),
+      parameter<std::string>("SYMBOLIC_FUNCTION_OF_TIME"),
 
       all_of({
-          entry<int>("VARIABLE"),
-          entry<std::string>("NAME"),
+          parameter<int>("VARIABLE"),
+          parameter<std::string>("NAME"),
           one_of({
               all_of({
                   selection<std::string>("TYPE", {"expression"}),
-                  entry<std::string>("DESCRIPTION"),
+                  parameter<std::string>("DESCRIPTION"),
               }),
               all_of({
                   selection<std::string>("TYPE", {"linearinterpolation", "fourierinterpolation"}),
                   time_info,
-                  entry<std::vector<double>>("VALUES", {.size = from_parameter<int>("NUMPOINTS")}),
+                  parameter<std::vector<double>>(
+                      "VALUES", {.size = from_parameter<int>("NUMPOINTS")}),
               }),
               all_of({
                   selection<std::string>("TYPE", {"multifunction"}),
                   time_info,
-                  entry<std::vector<std::string>>(
+                  parameter<std::vector<std::string>>(
                       "DESCRIPTION", {.size = [](const IO::InputParameterContainer& container)
                                          { return container.get<int>("NUMPOINTS") - 1; }}),
               }),
           }),
           group("PERIODIC",
               {
-                  entry<double>("T1"),
-                  entry<double>("T2"),
+                  parameter<double>("T1"),
+                  parameter<double>("T2"),
               },
               {.required = false}),
       }),
 
       all_of({
-          entry<std::string>("VARFUNCTION"),
-          entry<int>("NUMCONSTANTS", {.required = false}),
-          entry<std::map<std::string, double>>(
+          parameter<std::string>("VARFUNCTION"),
+          parameter<int>("NUMCONSTANTS", {.required = false}),
+          parameter<std::map<std::string, double>>(
               "CONSTANTS", {.required = false, .size = from_parameter<int>("NUMCONSTANTS")}),
       }),
   });
diff --git a/src/core/utils/src/parameters/4C_utils_parameter_list.cpp b/src/core/utils/src/parameters/4C_utils_parameter_list.cpp
index eeb95f7f129..b4c2f84de30 100644
--- a/src/core/utils/src/parameters/4C_utils_parameter_list.cpp
+++ b/src/core/utils/src/parameters/4C_utils_parameter_list.cpp
@@ -23,14 +23,14 @@ namespace Core::Utils
   void bool_parameter(std::string const& paramName, bool default_value,
       std::string const& docString, SectionSpecs& section_specs)
   {
-    section_specs.specs.emplace_back(Core::IO::InputSpecBuilders::entry<bool>(
+    section_specs.specs.emplace_back(Core::IO::InputSpecBuilders::parameter<bool>(
         paramName, {.description = docString, .default_value = default_value}));
   }
 
   void int_parameter(std::string const& paramName, int const value, std::string const& docString,
       SectionSpecs& section_specs)
   {
-    section_specs.specs.emplace_back(Core::IO::InputSpecBuilders::entry<int>(
+    section_specs.specs.emplace_back(Core::IO::InputSpecBuilders::parameter<int>(
         paramName, {.description = docString, .default_value = value}));
   }
 
@@ -38,7 +38,7 @@ namespace Core::Utils
   void double_parameter(std::string const& paramName, double const& value,
       std::string const& docString, SectionSpecs& section_specs)
   {
-    section_specs.specs.emplace_back(Core::IO::InputSpecBuilders::entry<double>(
+    section_specs.specs.emplace_back(Core::IO::InputSpecBuilders::parameter<double>(
         paramName, {.description = docString, .default_value = value}));
   }
 
@@ -49,7 +49,7 @@ namespace Core::Utils
   {
     if (validParams.empty())
     {
-      section_specs.specs.emplace_back(Core::IO::InputSpecBuilders::entry<std::string>(
+      section_specs.specs.emplace_back(Core::IO::InputSpecBuilders::parameter<std::string>(
           paramName, {.description = docString, .default_value = value}));
     }
     else
diff --git a/src/core/utils/src/parameters/4C_utils_parameter_list.hpp b/src/core/utils/src/parameters/4C_utils_parameter_list.hpp
index 19825e271be..6be92ef6c9c 100644
--- a/src/core/utils/src/parameters/4C_utils_parameter_list.hpp
+++ b/src/core/utils/src/parameters/4C_utils_parameter_list.hpp
@@ -60,7 +60,7 @@ namespace Core
           Teuchos::tuple<std::string>(value_name), Teuchos::tuple<EnumType>(value), &list);
     }
 
-    /// temporary helper around InputSpecBuilders::entry<bool>
+    /// temporary helper around InputSpecBuilders::parameter<bool>
     void bool_parameter(std::string const& paramName, bool default_value,
         std::string const& docString, SectionSpecs& section_specs);
     // fail if users provide a string literal as default value
diff --git a/src/elemag/4C_elemag_diff_ele.cpp b/src/elemag/4C_elemag_diff_ele.cpp
index 5fcb8849e46..701dd06855a 100644
--- a/src/elemag/4C_elemag_diff_ele.cpp
+++ b/src/elemag/4C_elemag_diff_ele.cpp
@@ -100,39 +100,39 @@ void Discret::Elements::ElemagDiffType::setup_element_definition(
 
   // 3D elements
   defs["HEX8"] = all_of({
-      entry<std::vector<int>>("HEX8", {.size = 8}),
-      entry<int>("MAT"),
-      entry<int>("DEG"),
-      entry<int>("SPC"),
+      parameter<std::vector<int>>("HEX8", {.size = 8}),
+      parameter<int>("MAT"),
+      parameter<int>("DEG"),
+      parameter<int>("SPC"),
   });
 
   defs["TET4"] = all_of({
-      entry<std::vector<int>>("TET4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<int>("DEG"),
-      entry<int>("SPC"),
+      parameter<std::vector<int>>("TET4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<int>("DEG"),
+      parameter<int>("SPC"),
   });
 
   // 2D elements
   defs["QUAD4"] = all_of({
-      entry<std::vector<int>>("QUAD4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<int>("DEG"),
-      entry<int>("SPC"),
+      parameter<std::vector<int>>("QUAD4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<int>("DEG"),
+      parameter<int>("SPC"),
   });
 
   defs["QUAD9"] = all_of({
-      entry<std::vector<int>>("QUAD9", {.size = 9}),
-      entry<int>("MAT"),
-      entry<int>("DEG"),
-      entry<int>("SPC"),
+      parameter<std::vector<int>>("QUAD9", {.size = 9}),
+      parameter<int>("MAT"),
+      parameter<int>("DEG"),
+      parameter<int>("SPC"),
   });
 
   defs["TRI3"] = all_of({
-      entry<std::vector<int>>("TRI3", {.size = 3}),
-      entry<int>("MAT"),
-      entry<int>("DEG"),
-      entry<int>("SPC"),
+      parameter<std::vector<int>>("TRI3", {.size = 3}),
+      parameter<int>("MAT"),
+      parameter<int>("DEG"),
+      parameter<int>("SPC"),
   });
 }
 
diff --git a/src/elemag/4C_elemag_ele.cpp b/src/elemag/4C_elemag_ele.cpp
index 2e6310247b8..a9cd0250cb3 100644
--- a/src/elemag/4C_elemag_ele.cpp
+++ b/src/elemag/4C_elemag_ele.cpp
@@ -94,39 +94,39 @@ void Discret::Elements::ElemagType::setup_element_definition(
 
   // 3D elements
   defs["HEX8"] = all_of({
-      entry<std::vector<int>>("HEX8", {.size = 8}),
-      entry<int>("MAT"),
-      entry<int>("DEG"),
-      entry<int>("SPC"),
+      parameter<std::vector<int>>("HEX8", {.size = 8}),
+      parameter<int>("MAT"),
+      parameter<int>("DEG"),
+      parameter<int>("SPC"),
   });
 
   defs["TET4"] = all_of({
-      entry<std::vector<int>>("TET4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<int>("DEG"),
-      entry<int>("SPC"),
+      parameter<std::vector<int>>("TET4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<int>("DEG"),
+      parameter<int>("SPC"),
   });
 
   // 2D elements
   defs["QUAD4"] = all_of({
-      entry<std::vector<int>>("QUAD4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<int>("DEG"),
-      entry<int>("SPC"),
+      parameter<std::vector<int>>("QUAD4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<int>("DEG"),
+      parameter<int>("SPC"),
   });
 
   defs["QUAD9"] = all_of({
-      entry<std::vector<int>>("QUAD9", {.size = 9}),
-      entry<int>("MAT"),
-      entry<int>("DEG"),
-      entry<int>("SPC"),
+      parameter<std::vector<int>>("QUAD9", {.size = 9}),
+      parameter<int>("MAT"),
+      parameter<int>("DEG"),
+      parameter<int>("SPC"),
   });
 
   defs["TRI3"] = all_of({
-      entry<std::vector<int>>("TRI3", {.size = 3}),
-      entry<int>("MAT"),
-      entry<int>("DEG"),
-      entry<int>("SPC"),
+      parameter<std::vector<int>>("TRI3", {.size = 3}),
+      parameter<int>("MAT"),
+      parameter<int>("DEG"),
+      parameter<int>("SPC"),
   });
 }
 
diff --git a/src/fluid/4C_fluid_functions.cpp b/src/fluid/4C_fluid_functions.cpp
index 1d39a5437ed..ea3744544ff 100644
--- a/src/fluid/4C_fluid_functions.cpp
+++ b/src/fluid/4C_fluid_functions.cpp
@@ -338,49 +338,49 @@ void FLD::add_valid_fluid_functions(Core::Utils::FunctionManager& function_manag
   auto spec = one_of({
       all_of({
           selection<std::string>("FLUID_FUNCTION", {"BELTRAMI"}),
-          entry<double>("c1"),
+          parameter<double>("c1"),
       }),
       selection<std::string>("FLUID_FUNCTION",
           {"CHANNELWEAKLYCOMPRESSIBLE", "CORRECTIONTERMCHANNELWEAKLYCOMPRESSIBLE"}),
       all_of({
           selection<std::string>("FLUID_FUNCTION",
               {"WEAKLYCOMPRESSIBLE_POISEUILLE", "WEAKLYCOMPRESSIBLE_POISEUILLE_FORCE"}),
-          entry<int>("MAT"),
-          entry<double>("L"),
-          entry<double>("R"),
-          entry<double>("U"),
+          parameter<int>("MAT"),
+          parameter<double>("L"),
+          parameter<double>("R"),
+          parameter<double>("U"),
       }),
       all_of({
           selection<std::string>("FLUID_FUNCTION",
               {"WEAKLYCOMPRESSIBLE_MANUFACTUREDFLOW", "WEAKLYCOMPRESSIBLE_MANUFACTUREDFLOW_FORCE",
                   "WEAKLYCOMPRESSIBLE_ETIENNE_CFD", "WEAKLYCOMPRESSIBLE_ETIENNE_CFD_FORCE",
                   "WEAKLYCOMPRESSIBLE_ETIENNE_CFD_VISCOSITY"}),
-          entry<int>("MAT"),
+          parameter<int>("MAT"),
       }),
       all_of({
           selection<std::string>("FLUID_FUNCTION",
               {"WEAKLYCOMPRESSIBLE_ETIENNE_FSI_FLUID", "WEAKLYCOMPRESSIBLE_ETIENNE_FSI_FLUID_FORCE",
                   "WEAKLYCOMPRESSIBLE_ETIENNE_FSI_FLUID_VISCOSITY"}),
-          entry<int>("MAT_FLUID"),
-          entry<int>("MAT_STRUCT"),
+          parameter<int>("MAT_FLUID"),
+          parameter<int>("MAT_STRUCT"),
       }),
       all_of({
           selection<std::string>(
               "FLUID_FUNCTION", {"BELTRAMI-UP", "BELTRAMI-GRADU", "KIMMOIN-UP", "KIMMOIN-GRADU"}),
-          entry<int>("MAT"),
-          entry<int>("ISSTAT"),
+          parameter<int>("MAT"),
+          parameter<int>("ISSTAT"),
       }),
       all_of({
           selection<std::string>("FLUID_FUNCTION", {"BELTRAMI-RHS", "KIMMOIN-RHS"}),
-          entry<int>("MAT"),
-          entry<int>("ISSTAT"),
-          entry<int>("ISSTOKES"),
+          parameter<int>("MAT"),
+          parameter<int>("ISSTAT"),
+          parameter<int>("ISSTOKES"),
       }),
       all_of({
           selection<std::string>("FLUID_FUNCTION", {"KIMMOIN-STRESS"}),
-          entry<int>("MAT"),
-          entry<int>("ISSTAT"),
-          entry<double>("AMPLITUDE"),
+          parameter<int>("MAT"),
+          parameter<int>("ISSTAT"),
+          parameter<double>("AMPLITUDE"),
       }),
   });
 
diff --git a/src/fluid_ele/4C_fluid_ele.cpp b/src/fluid_ele/4C_fluid_ele.cpp
index ffcfd2fc840..c87c7f31473 100644
--- a/src/fluid_ele/4C_fluid_ele.cpp
+++ b/src/fluid_ele/4C_fluid_ele.cpp
@@ -76,106 +76,106 @@ void Discret::Elements::FluidType::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defsgeneral["HEX8"] = all_of({
-      entry<std::vector<int>>("HEX8", {.size = 8}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("HEX8", {.size = 8}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 
   defsgeneral["HEX20"] = all_of({
-      entry<std::vector<int>>("HEX20", {.size = 20}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("HEX20", {.size = 20}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 
   defsgeneral["HEX27"] = all_of({
-      entry<std::vector<int>>("HEX27", {.size = 27}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("HEX27", {.size = 27}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 
   defsgeneral["TET4"] = all_of({
-      entry<std::vector<int>>("TET4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("TET4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 
   defsgeneral["TET10"] = all_of({
-      entry<std::vector<int>>("TET10", {.size = 10}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("TET10", {.size = 10}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 
   defsgeneral["WEDGE6"] = all_of({
-      entry<std::vector<int>>("WEDGE6", {.size = 6}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("WEDGE6", {.size = 6}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 
   defsgeneral["WEDGE15"] = all_of({
-      entry<std::vector<int>>("WEDGE15", {.size = 15}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("WEDGE15", {.size = 15}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 
   defsgeneral["PYRAMID5"] = all_of({
-      entry<std::vector<int>>("PYRAMID5", {.size = 5}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("PYRAMID5", {.size = 5}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 
   defsgeneral["NURBS8"] = all_of({
-      entry<std::vector<int>>("NURBS8", {.size = 8}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("NURBS8", {.size = 8}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 
   defsgeneral["NURBS27"] = all_of({
-      entry<std::vector<int>>("NURBS27", {.size = 27}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("NURBS27", {.size = 27}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 
   // 2D elements
   defsgeneral["QUAD4"] = all_of({
-      entry<std::vector<int>>("QUAD4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("QUAD4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 
   defsgeneral["QUAD8"] = all_of({
-      entry<std::vector<int>>("QUAD8", {.size = 8}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("QUAD8", {.size = 8}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 
   defsgeneral["QUAD9"] = all_of({
-      entry<std::vector<int>>("QUAD9", {.size = 9}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("QUAD9", {.size = 9}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 
   defsgeneral["TRI3"] = all_of({
-      entry<std::vector<int>>("TRI3", {.size = 3}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("TRI3", {.size = 3}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 
   defsgeneral["TRI6"] = all_of({
-      entry<std::vector<int>>("TRI6", {.size = 6}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("TRI6", {.size = 6}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 
   defsgeneral["NURBS4"] = all_of({
-      entry<std::vector<int>>("NURBS4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("NURBS4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 
   defsgeneral["NURBS9"] = all_of({
-      entry<std::vector<int>>("NURBS9", {.size = 9}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("NURBS9", {.size = 9}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 }
 
diff --git a/src/fluid_ele/4C_fluid_ele_hdg.cpp b/src/fluid_ele/4C_fluid_ele_hdg.cpp
index c4c07884cf9..7e891f1050e 100644
--- a/src/fluid_ele/4C_fluid_ele_hdg.cpp
+++ b/src/fluid_ele/4C_fluid_ele_hdg.cpp
@@ -136,8 +136,8 @@ void Discret::Elements::FluidHDGType ::setup_element_definition(
   {
     defs_hdg[key] = all_of({
         fluid_line_def,
-        entry<int>("DEG"),
-        entry<int>("SPC", {.required = false}),
+        parameter<int>("DEG"),
+        parameter<int>("SPC", {.required = false}),
     });
   }
 }
diff --git a/src/fluid_ele/4C_fluid_ele_hdg_weak_comp.cpp b/src/fluid_ele/4C_fluid_ele_hdg_weak_comp.cpp
index 3c67ba1273d..4c753215da3 100644
--- a/src/fluid_ele/4C_fluid_ele_hdg_weak_comp.cpp
+++ b/src/fluid_ele/4C_fluid_ele_hdg_weak_comp.cpp
@@ -98,8 +98,8 @@ void Discret::Elements::FluidHDGWeakCompType ::setup_element_definition(
   {
     defs_hdg[key] = all_of({
         fluid_line_def,
-        entry<int>("DEG"),
-        entry<int>("SPC", {.required = false}),
+        parameter<int>("DEG"),
+        parameter<int>("SPC", {.required = false}),
     });
   }
 }
diff --git a/src/fluid_ele/4C_fluid_ele_xwall.cpp b/src/fluid_ele/4C_fluid_ele_xwall.cpp
index 22298aa5c1a..795489daa82 100644
--- a/src/fluid_ele/4C_fluid_ele_xwall.cpp
+++ b/src/fluid_ele/4C_fluid_ele_xwall.cpp
@@ -71,14 +71,14 @@ void Discret::Elements::FluidXWallType::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defsxwall["HEX8"] = all_of({
-      entry<std::vector<int>>("HEX8", {.size = 8}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("HEX8", {.size = 8}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
   defsxwall["TET4"] = all_of({
-      entry<std::vector<int>>("TET4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<std::string>("NA"),
+      parameter<std::vector<int>>("TET4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<std::string>("NA"),
   });
 }
 
diff --git a/src/fluid_xfluid/4C_fluid_xfluid_functions.cpp b/src/fluid_xfluid/4C_fluid_xfluid_functions.cpp
index 37983292eef..5279f7520fe 100644
--- a/src/fluid_xfluid/4C_fluid_xfluid_functions.cpp
+++ b/src/fluid_xfluid/4C_fluid_xfluid_functions.cpp
@@ -197,62 +197,62 @@ void Discret::Utils::add_valid_xfluid_functions(Core::Utils::FunctionManager& fu
       selection<std::string>("XFLUID_FUNCTION", {"FORWARDFACINGSTEP"}),
       all_of({
           selection<std::string>("XFLUID_FUNCTION", {"MOVINGLEVELSETCYLINDER"}),
-          entry<std::vector<double>>("ORIGIN", {.size = 3}),
-          entry<double>("RADIUS"),
-          entry<std::vector<double>>("DIRECTION", {.size = 3}),
-          entry<double>("DISTANCE"),
-          entry<double>("MAXSPEED"),
+          parameter<std::vector<double>>("ORIGIN", {.size = 3}),
+          parameter<double>("RADIUS"),
+          parameter<std::vector<double>>("DIRECTION", {.size = 3}),
+          parameter<double>("DISTANCE"),
+          parameter<double>("MAXSPEED"),
       }),
       all_of({
           selection<std::string>(
               "XFLUID_FUNCTION", {"MOVINGLEVELSETTORUS", "MOVINGLEVELSETTORUSVELOCITY"}),
-          entry<std::vector<double>>("ORIGIN", {.size = 3}),
-          entry<std::vector<double>>("ORIENTVEC_TORUS", {.size = 3}),
-          entry<double>("RADIUS"),
-          entry<double>("RADIUS_TUBE"),
-          entry<std::vector<double>>("DIRECTION", {.size = 3}),
-          entry<double>("DISTANCE"),
-          entry<double>("MAXSPEED"),
-          entry<std::vector<double>>("ROTATION_VEC", {.size = 3}),
-          entry<double>("ROTATION_SPEED"),
-          entry<double>("ROTATION_RAMPTIME"),
+          parameter<std::vector<double>>("ORIGIN", {.size = 3}),
+          parameter<std::vector<double>>("ORIENTVEC_TORUS", {.size = 3}),
+          parameter<double>("RADIUS"),
+          parameter<double>("RADIUS_TUBE"),
+          parameter<std::vector<double>>("DIRECTION", {.size = 3}),
+          parameter<double>("DISTANCE"),
+          parameter<double>("MAXSPEED"),
+          parameter<std::vector<double>>("ROTATION_VEC", {.size = 3}),
+          parameter<double>("ROTATION_SPEED"),
+          parameter<double>("ROTATION_RAMPTIME"),
       }),
       all_of({
           selection<std::string>("XFLUID_FUNCTION", {"MOVINGLEVELSETTORUSSLIPLENGTH"}),
-          entry<std::vector<double>>("ORIGIN", {.size = 3}),
-          entry<std::vector<double>>("ORIENTVEC_TORUS", {.size = 3}),
-          entry<double>("RADIUS"),
-          entry<double>("RADIUS_TUBE"),
-          entry<std::vector<double>>("DIRECTION", {.size = 3}),
-          entry<double>("DISTANCE"),
-          entry<double>("MAXSPEED"),
-          entry<std::vector<double>>("ROTATION_VEC", {.size = 3}),
-          entry<double>("ROTATION_SPEED"),
-          entry<double>("ROTATION_RAMPTIME"),
-          entry<int>("SLIP_FUNCT"),
+          parameter<std::vector<double>>("ORIGIN", {.size = 3}),
+          parameter<std::vector<double>>("ORIENTVEC_TORUS", {.size = 3}),
+          parameter<double>("RADIUS"),
+          parameter<double>("RADIUS_TUBE"),
+          parameter<std::vector<double>>("DIRECTION", {.size = 3}),
+          parameter<double>("DISTANCE"),
+          parameter<double>("MAXSPEED"),
+          parameter<std::vector<double>>("ROTATION_VEC", {.size = 3}),
+          parameter<double>("ROTATION_SPEED"),
+          parameter<double>("ROTATION_RAMPTIME"),
+          parameter<int>("SLIP_FUNCT"),
       }),
       all_of({
           selection<std::string>("XFLUID_FUNCTION", {"TAYLORCOUETTEFLOW"}),
-          entry<double>("RADIUS_I"),
-          entry<double>("RADIUS_O"),
-          entry<double>("VEL_THETA_I"),
-          entry<double>("VEL_THETA_O"),
-          entry<double>("SLIPLENGTH_I"),
-          entry<double>("SLIPLENGTH_O"),
-          entry<double>("TRACTION_THETA_I"),
-          entry<double>("TRACTION_THETA_O"),
-          entry<double>("VISCOSITY"),
+          parameter<double>("RADIUS_I"),
+          parameter<double>("RADIUS_O"),
+          parameter<double>("VEL_THETA_I"),
+          parameter<double>("VEL_THETA_O"),
+          parameter<double>("SLIPLENGTH_I"),
+          parameter<double>("SLIPLENGTH_O"),
+          parameter<double>("TRACTION_THETA_I"),
+          parameter<double>("TRACTION_THETA_O"),
+          parameter<double>("VISCOSITY"),
       }),
       all_of({
           selection<std::string>("XFLUID_FUNCTION",
               {"URQUIZABOXFLOW", "URQUIZABOXFLOW_TRACTION", "URQUIZABOXFLOW_FORCE"}),
-          entry<double>("LENGTHX"),
-          entry<double>("LENGTHY"),
-          entry<double>("ROTATION"),
-          entry<double>("VISCOSITY"),
-          entry<double>("DENSITY"),
-          entry<int>("CASE"),
-          entry<std::vector<double>>("COMBINATION", {.size = 2}),
+          parameter<double>("LENGTHX"),
+          parameter<double>("LENGTHY"),
+          parameter<double>("ROTATION"),
+          parameter<double>("VISCOSITY"),
+          parameter<double>("DENSITY"),
+          parameter<int>("CASE"),
+          parameter<std::vector<double>>("COMBINATION", {.size = 2}),
       }),
   });
 
diff --git a/src/global_data/4C_global_data_read.cpp b/src/global_data/4C_global_data_read.cpp
index c58ced5d5f8..5f9bba9addb 100644
--- a/src/global_data/4C_global_data_read.cpp
+++ b/src/global_data/4C_global_data_read.cpp
@@ -70,7 +70,7 @@ namespace
       }
 
       auto all_materials = all_of({
-          entry<int>("MAT"),
+          parameter<int>("MAT"),
           one_of(possible_materials),
       });
       section_specs["MATERIALS"] = all_materials;
@@ -94,8 +94,9 @@ namespace
       for (const auto& cond : valid_conditions)
       {
         auto condition_spec = all_of({
-            entry<int>("E", {.description = "ID of the condition. This ID refers to the respective "
-                                            "topological entity of the condition."}),
+            parameter<int>(
+                "E", {.description = "ID of the condition. This ID refers to the respective "
+                                     "topological entity of the condition."}),
             all_of(cond.specs()),
         });
         section_specs.emplace(cond.section_name(), std::move(condition_spec));
@@ -1954,7 +1955,8 @@ void Global::read_materials(Global::Problem& problem, Core::IO::InputFile& input
   using namespace Core::IO::InputSpecBuilders;
 
   auto all_materials = all_of({
-      entry<int>("MAT", {.description = "Material ID that may be used to refer to this material."}),
+      parameter<int>(
+          "MAT", {.description = "Material ID that may be used to refer to this material."}),
       one_of(all_specs, [&current_index](Core::IO::InputParameterContainer& container,
                             std::size_t index) { current_index = index; }),
   });
diff --git a/src/global_legacy_module/4C_global_legacy_module.cpp b/src/global_legacy_module/4C_global_legacy_module.cpp
index 0a872eb2db5..ab26264bad2 100644
--- a/src/global_legacy_module/4C_global_legacy_module.cpp
+++ b/src/global_legacy_module/4C_global_legacy_module.cpp
@@ -334,201 +334,201 @@ namespace
             {
                 one_of({
                     all_of({
-                        entry<std::string>("DIS"),
+                        parameter<std::string>("DIS"),
                         one_of({
-                            entry<int>("NODE"),
-                            entry<int>("LINE"),
-                            entry<int>("SURFACE"),
-                            entry<int>("VOLUME"),
+                            parameter<int>("NODE"),
+                            parameter<int>("LINE"),
+                            parameter<int>("SURFACE"),
+                            parameter<int>("VOLUME"),
                         }),
                     }),
-                    entry<bool>("SPECIAL"),
+                    parameter<bool>("SPECIAL"),
                 }),
-                entry<std::string>("OP", {.required = false}),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
-                entry<std::string>("NAME", {.required = false}),
+                parameter<std::string>("OP", {.required = false}),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
+                parameter<std::string>("NAME", {.required = false}),
             }),
         group("FLUID",
             {
-                entry<std::string>("DIS"),
+                parameter<std::string>("DIS"),
                 one_of({
-                    entry<int>("NODE"),
-                    entry<int>("ELEMENT"),
+                    parameter<int>("NODE"),
+                    parameter<int>("ELEMENT"),
                 }),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
-                entry<std::string>("NAME", {.required = false}),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
+                parameter<std::string>("NAME", {.required = false}),
             }),
         group("XFLUID",
             {
-                entry<std::string>("DIS"),
-                entry<int>("NODE"),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
-                entry<std::string>("NAME", {.required = false}),
+                parameter<std::string>("DIS"),
+                parameter<int>("NODE"),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
+                parameter<std::string>("NAME", {.required = false}),
             }),
         group("ALE",
             {
-                entry<std::string>("DIS"),
-                entry<int>("NODE"),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
-                entry<std::string>("NAME", {.required = false}),
+                parameter<std::string>("DIS"),
+                parameter<int>("NODE"),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
+                parameter<std::string>("NAME", {.required = false}),
             }),
         group("THERMAL",
             {
-                entry<std::string>("DIS"),
-                entry<int>("NODE"),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
-                entry<std::string>("NAME", {.required = false}),
+                parameter<std::string>("DIS"),
+                parameter<int>("NODE"),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
+                parameter<std::string>("NAME", {.required = false}),
             }),
         group("LUBRICATION",
             {
-                entry<std::string>("DIS"),
-                entry<int>("NODE"),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
-                entry<std::string>("NAME", {.required = false}),
+                parameter<std::string>("DIS"),
+                parameter<int>("NODE"),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
+                parameter<std::string>("NAME", {.required = false}),
             }),
         group("POROFLUIDMULTIPHASE",
             {
-                entry<std::string>("DIS"),
+                parameter<std::string>("DIS"),
                 one_of({
-                    entry<int>("NODE"),
-                    entry<int>("ELEMENT"),
-                    entry<bool>("SPECIAL"),
+                    parameter<int>("NODE"),
+                    parameter<int>("ELEMENT"),
+                    parameter<bool>("SPECIAL"),
                 }),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
-                entry<std::string>("NAME", {.required = false}),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
+                parameter<std::string>("NAME", {.required = false}),
             }),
         group("SCATRA",
             {
-                entry<std::string>("DIS"),
+                parameter<std::string>("DIS"),
                 one_of({
-                    entry<int>("NODE"),
-                    entry<bool>("SPECIAL"),
+                    parameter<int>("NODE"),
+                    parameter<bool>("SPECIAL"),
                 }),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
-                entry<std::string>("NAME", {.required = false}),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
+                parameter<std::string>("NAME", {.required = false}),
             }),
         group("SSI",
             {
                 one_of({
                     all_of({
-                        entry<std::string>("DIS"),
-                        entry<int>("NODE"),
+                        parameter<std::string>("DIS"),
+                        parameter<int>("NODE"),
                     }),
-                    entry<bool>("SPECIAL"),
+                    parameter<bool>("SPECIAL"),
                 }),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
-                entry<std::string>("NAME", {.required = false}),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
+                parameter<std::string>("NAME", {.required = false}),
             }),
         group("SSTI",
             {
-                entry<bool>("SPECIAL"),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
+                parameter<bool>("SPECIAL"),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
             }),
         group("STI",
             {
-                entry<bool>("SPECIAL"),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
+                parameter<bool>("SPECIAL"),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
             }),
         group("RED_AIRWAY",
             {
-                entry<std::string>("DIS"),
+                parameter<std::string>("DIS"),
                 one_of({
-                    entry<int>("NODE"),
-                    entry<int>("ELEMENT"),
+                    parameter<int>("NODE"),
+                    parameter<int>("ELEMENT"),
                 }),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
-                entry<std::string>("NAME", {.required = false}),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
+                parameter<std::string>("NAME", {.required = false}),
             }),
         group("ARTNET",
             {
-                entry<std::string>("DIS"),
+                parameter<std::string>("DIS"),
                 one_of({
-                    entry<int>("NODE"),
-                    entry<int>("ELEMENT"),
+                    parameter<int>("NODE"),
+                    parameter<int>("ELEMENT"),
                 }),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
-                entry<std::string>("NAME", {.required = false}),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
+                parameter<std::string>("NAME", {.required = false}),
             }),
         group("FSI",
             {
                 one_of({
-                    entry<int>("NODE"),
-                    entry<bool>("SPECIAL"),
+                    parameter<int>("NODE"),
+                    parameter<bool>("SPECIAL"),
                 }),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
-                entry<std::string>("NAME", {.required = false}),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
+                parameter<std::string>("NAME", {.required = false}),
             }),
         group("PARTICLE",
             {
-                entry<int>("ID"),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
+                parameter<int>("ID"),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
             }),
         group("PARTICLEWALL",
             {
-                entry<std::string>("DIS"),
+                parameter<std::string>("DIS"),
                 one_of({
-                    entry<int>("NODE"),
-                    entry<bool>("SPECIAL"),
+                    parameter<int>("NODE"),
+                    parameter<bool>("SPECIAL"),
                 }),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
-                entry<std::string>("NAME", {.required = false}),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
+                parameter<std::string>("NAME", {.required = false}),
             }),
         group("RIGIDBODY",
             {
-                entry<int>("ID"),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
+                parameter<int>("ID"),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
             }),
         group("ELECTROMAGNETIC",
             {
-                entry<std::string>("DIS"),
-                entry<int>("NODE"),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
-                entry<std::string>("NAME", {.required = false}),
+                parameter<std::string>("DIS"),
+                parameter<int>("NODE"),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
+                parameter<std::string>("NAME", {.required = false}),
             }),
         group("CARDIOVASCULAR0D",
             {
-                entry<std::string>("DIS"),
-                entry<bool>("SPECIAL"),
-                entry<std::string>("QUANTITY"),
-                entry<double>("VALUE"),
-                entry<double>("TOLERANCE"),
-                entry<std::string>("NAME", {.required = false}),
+                parameter<std::string>("DIS"),
+                parameter<bool>("SPECIAL"),
+                parameter<std::string>("QUANTITY"),
+                parameter<double>("VALUE"),
+                parameter<double>("TOLERANCE"),
+                parameter<std::string>("NAME", {.required = false}),
             }),
     });
   }
diff --git a/src/global_legacy_module/4C_global_legacy_module_validmaterials.cpp b/src/global_legacy_module/4C_global_legacy_module_validmaterials.cpp
index 6b63f916659..496ca9e2ea9 100644
--- a/src/global_legacy_module/4C_global_legacy_module_validmaterials.cpp
+++ b/src/global_legacy_module/4C_global_legacy_module_validmaterials.cpp
@@ -41,9 +41,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MAT_fluid", "Newtonian fluid", Core::Materials::m_fluid);
 
-    m->add_component(entry<double>("DYNVISCOSITY", {.description = "dynamic viscosity"}));
-    m->add_component(entry<double>("DENSITY", {.description = "spatial mass density"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>("DYNVISCOSITY", {.description = "dynamic viscosity"}));
+    m->add_component(parameter<double>("DENSITY", {.description = "spatial mass density"}));
+    m->add_component(parameter<double>(
         "GAMMA", {.description = "surface tension coefficient", .default_value = 0.0}));
 
     Mat::append_material_definition(matlist, m);
@@ -56,14 +56,15 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "Weakly compressible fluid according to Murnaghan-Tait",
         Core::Materials::m_fluid_murnaghantait);
 
-    m->add_component(entry<double>("DYNVISCOSITY", {.description = "dynamic viscosity"}));
+    m->add_component(parameter<double>("DYNVISCOSITY", {.description = "dynamic viscosity"}));
     m->add_component(
-        entry<double>("REFDENSITY", {.description = "reference spatial mass density"}));
-    m->add_component(entry<double>("REFPRESSURE", {.description = "reference pressure"}));
-    m->add_component(entry<double>("REFBULKMODULUS", {.description = "reference bulk modulus"}));
-    m->add_component(entry<double>(
+        parameter<double>("REFDENSITY", {.description = "reference spatial mass density"}));
+    m->add_component(parameter<double>("REFPRESSURE", {.description = "reference pressure"}));
+    m->add_component(
+        parameter<double>("REFBULKMODULUS", {.description = "reference bulk modulus"}));
+    m->add_component(parameter<double>(
         "MATPARAMETER", {.description = "material parameter according to Murnaghan-Tait"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "GAMMA", {.description = "surface tension coefficient", .default_value = 0.0}));
 
     Mat::append_material_definition(matlist, m);
@@ -76,14 +77,14 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "Linear law (pressure-dependent) for the density and the viscosity",
         Core::Materials::m_fluid_linear_density_viscosity);
 
-    m->add_component(entry<double>("REFDENSITY", {.description = "reference density"}));
-    m->add_component(entry<double>("REFVISCOSITY", {.description = "reference viscosity"}));
-    m->add_component(entry<double>("REFPRESSURE", {.description = "reference pressure"}));
+    m->add_component(parameter<double>("REFDENSITY", {.description = "reference density"}));
+    m->add_component(parameter<double>("REFVISCOSITY", {.description = "reference viscosity"}));
+    m->add_component(parameter<double>("REFPRESSURE", {.description = "reference pressure"}));
     m->add_component(
-        entry<double>("COEFFDENSITY", {.description = "density-pressure coefficient"}));
+        parameter<double>("COEFFDENSITY", {.description = "density-pressure coefficient"}));
     m->add_component(
-        entry<double>("COEFFVISCOSITY", {.description = "viscosity-pressure coefficient"}));
-    m->add_component(entry<double>(
+        parameter<double>("COEFFVISCOSITY", {.description = "viscosity-pressure coefficient"}));
+    m->add_component(parameter<double>(
         "GAMMA", {.description = "surface tension coefficient", .default_value = 0.0}));
 
     Mat::append_material_definition(matlist, m);
@@ -95,10 +96,11 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_fluid_weakly_compressible",
         "Weakly compressible fluid", Core::Materials::m_fluid_weakly_compressible);
 
-    m->add_component(entry<double>("VISCOSITY", {.description = "viscosity"}));
-    m->add_component(entry<double>("REFDENSITY", {.description = "reference density"}));
-    m->add_component(entry<double>("REFPRESSURE", {.description = "reference pressure"}));
-    m->add_component(entry<double>("COMPRCOEFF", {.description = "compressibility coefficient"}));
+    m->add_component(parameter<double>("VISCOSITY", {.description = "viscosity"}));
+    m->add_component(parameter<double>("REFDENSITY", {.description = "reference density"}));
+    m->add_component(parameter<double>("REFPRESSURE", {.description = "reference pressure"}));
+    m->add_component(
+        parameter<double>("COMPRCOEFF", {.description = "compressibility coefficient"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -110,12 +112,12 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "fluid with non-linear viscosity according to Carreau-Yasuda",
         Core::Materials::m_carreauyasuda);
 
-    m->add_component(entry<double>("NU_0", {.description = "zero-shear viscosity"}));
-    m->add_component(entry<double>("NU_INF", {.description = "infinite-shear viscosity"}));
-    m->add_component(entry<double>("LAMBDA", {.description = "characteristic time"}));
-    m->add_component(entry<double>("APARAM", {.description = "constant parameter"}));
-    m->add_component(entry<double>("BPARAM", {.description = "constant parameter"}));
-    m->add_component(entry<double>("DENSITY", {.description = "density"}));
+    m->add_component(parameter<double>("NU_0", {.description = "zero-shear viscosity"}));
+    m->add_component(parameter<double>("NU_INF", {.description = "infinite-shear viscosity"}));
+    m->add_component(parameter<double>("LAMBDA", {.description = "characteristic time"}));
+    m->add_component(parameter<double>("APARAM", {.description = "constant parameter"}));
+    m->add_component(parameter<double>("BPARAM", {.description = "constant parameter"}));
+    m->add_component(parameter<double>("DENSITY", {.description = "density"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -127,10 +129,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "fluid with nonlinear viscosity according to a modified power law",
         Core::Materials::m_modpowerlaw);
 
-    m->add_component(entry<double>("MCONS", {.description = "consistency"}));
-    m->add_component(entry<double>("DELTA", {.description = "safety factor"}));
-    m->add_component(entry<double>("AEXP", {.description = "exponent"}));
-    m->add_component(entry<double>("DENSITY", {.description = "density"}));
+    m->add_component(parameter<double>("MCONS", {.description = "consistency"}));
+    m->add_component(parameter<double>("DELTA", {.description = "safety factor"}));
+    m->add_component(parameter<double>("AEXP", {.description = "exponent"}));
+    m->add_component(parameter<double>("DENSITY", {.description = "density"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -142,13 +144,15 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "fluid with non-linear viscosity according to Herschel-Bulkley",
         Core::Materials::m_herschelbulkley);
 
-    m->add_component(entry<double>("TAU_0", {.description = "yield stress"}));
-    m->add_component(entry<double>("KFAC", {.description = "constant factor"}));
-    m->add_component(entry<double>("NEXP", {.description = "exponent"}));
-    m->add_component(entry<double>("MEXP", {.description = "exponent"}));
-    m->add_component(entry<double>("LOLIMSHEARRATE", {.description = "lower limit of shear rate"}));
-    m->add_component(entry<double>("UPLIMSHEARRATE", {.description = "upper limit of shear rate"}));
-    m->add_component(entry<double>("DENSITY", {.description = "density"}));
+    m->add_component(parameter<double>("TAU_0", {.description = "yield stress"}));
+    m->add_component(parameter<double>("KFAC", {.description = "constant factor"}));
+    m->add_component(parameter<double>("NEXP", {.description = "exponent"}));
+    m->add_component(parameter<double>("MEXP", {.description = "exponent"}));
+    m->add_component(
+        parameter<double>("LOLIMSHEARRATE", {.description = "lower limit of shear rate"}));
+    m->add_component(
+        parameter<double>("UPLIMSHEARRATE", {.description = "upper limit of shear rate"}));
+    m->add_component(parameter<double>("DENSITY", {.description = "density"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -159,8 +163,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MAT_lubrication", "lubrication material", Core::Materials::m_lubrication);
 
-    m->add_component(entry<int>("LUBRICATIONLAWID", {.description = "lubrication law id"}));
-    m->add_component(entry<double>("DENSITY", {.description = "lubricant density"}));
+    m->add_component(parameter<int>("LUBRICATIONLAWID", {.description = "lubrication law id"}));
+    m->add_component(parameter<double>("DENSITY", {.description = "lubricant density"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -172,7 +176,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_lubrication_law_constant",
         "constant lubrication material law", Core::Materials::m_lubrication_law_constant);
 
-    m->add_component(entry<double>("VISCOSITY", {.description = "lubricant viscosity"}));
+    m->add_component(parameter<double>("VISCOSITY", {.description = "lubricant viscosity"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -184,9 +188,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "barus lubrication material law", Core::Materials::m_lubrication_law_barus);
 
     m->add_component(
-        entry<double>("ABSViscosity", {.description = "absolute lubricant viscosity"}));
+        parameter<double>("ABSViscosity", {.description = "absolute lubricant viscosity"}));
     m->add_component(
-        entry<double>("PreVisCoeff", {.description = "pressure viscosity coefficient"}));
+        parameter<double>("PreVisCoeff", {.description = "pressure viscosity coefficient"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -198,11 +202,11 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "roeland lubrication material law", Core::Materials::m_lubrication_law_roeland);
 
     m->add_component(
-        entry<double>("ABSViscosity", {.description = "absolute lubricant viscosity"}));
+        parameter<double>("ABSViscosity", {.description = "absolute lubricant viscosity"}));
     m->add_component(
-        entry<double>("PreVisCoeff", {.description = "pressure viscosity coefficient"}));
-    m->add_component(entry<double>("RefVisc", {.description = "reference viscosity"}));
-    m->add_component(entry<double>("RefPress", {.description = "reference Pressure"}));
+        parameter<double>("PreVisCoeff", {.description = "pressure viscosity coefficient"}));
+    m->add_component(parameter<double>("RefVisc", {.description = "reference viscosity"}));
+    m->add_component(parameter<double>("RefPress", {.description = "reference Pressure"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -213,14 +217,14 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MAT_scatra", "scalar transport material", Core::Materials::m_scatra);
 
-    m->add_component(entry<double>("DIFFUSIVITY", {.description = "kinematic diffusivity"}));
-    m->add_component(
-        entry<double>("REACOEFF", {.description = "reaction coefficient", .default_value = 0.0}));
+    m->add_component(parameter<double>("DIFFUSIVITY", {.description = "kinematic diffusivity"}));
+    m->add_component(parameter<double>(
+        "REACOEFF", {.description = "reaction coefficient", .default_value = 0.0}));
     m->add_component(
-        entry<double>("SCNUM", {.description = "schmidt number", .default_value = 0.0}));
-    m->add_component(entry<double>(
+        parameter<double>("SCNUM", {.description = "schmidt number", .default_value = 0.0}));
+    m->add_component(parameter<double>(
         "DENSIFICATION", {.description = "densification coefficient", .default_value = 0.0}));
-    m->add_component(entry<bool>("REACTS_TO_EXTERNAL_FORCE",
+    m->add_component(parameter<bool>("REACTS_TO_EXTERNAL_FORCE",
         {.description = "reacts to external force", .default_value = false}));
 
     Mat::append_material_definition(matlist, m);
@@ -234,26 +238,26 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "scalar transport material", Core::Materials::m_scatra_reaction_poroECM);
 
     m->add_component(
-        entry<int>("NUMSCAL", {.description = "number of scalars for these elements"}));
-    m->add_component(entry<std::vector<int>>("STOICH",
+        parameter<int>("NUMSCAL", {.description = "number of scalars for these elements"}));
+    m->add_component(parameter<std::vector<int>>("STOICH",
         {.description = "reaction stoichometrie list", .size = from_parameter<int>("NUMSCAL")}));
-    m->add_component(entry<double>("REACCOEFF", {.description = "reaction coefficient"}));
+    m->add_component(parameter<double>("REACCOEFF", {.description = "reaction coefficient"}));
     m->add_component(
-        entry<double>("REACSCALE", {.description = "scaling for reaction coefficient"}));
+        parameter<double>("REACSCALE", {.description = "scaling for reaction coefficient"}));
     // reacscale could now be done by constant distribution function
-    m->add_component(entry<int>("DISTRFUNCT",
+    m->add_component(parameter<int>("DISTRFUNCT",
         {.description = "spatial distribution of reaction coefficient", .default_value = 0}));
-    m->add_component(entry<std::string>("COUPLING",
+    m->add_component(parameter<std::string>("COUPLING",
         {.description = "type of coupling: simple_multiplicative, power_multiplicative, "
                         "constant, michaelis_menten, by_function, no_coupling (default)",
             .default_value = "no_coupling"}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "ROLE", {.description = "role in michaelis-menten like reactions",
                     .size = from_parameter<int>("NUMSCAL")}));
     m->add_component(
-        entry<std::vector<double>>("REACSTART", {.description = "starting point of reaction",
-                                                    .required = false,
-                                                    .size = from_parameter<int>("NUMSCAL")}));
+        parameter<std::vector<double>>("REACSTART", {.description = "starting point of reaction",
+                                                        .required = false,
+                                                        .size = from_parameter<int>("NUMSCAL")}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -264,23 +268,23 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "MAT_scatra_reaction", "advanced reaction material", Core::Materials::m_scatra_reaction);
 
     m->add_component(
-        entry<int>("NUMSCAL", {.description = "number of scalars for these elements"}));
-    m->add_component(entry<std::vector<int>>("STOICH",
+        parameter<int>("NUMSCAL", {.description = "number of scalars for these elements"}));
+    m->add_component(parameter<std::vector<int>>("STOICH",
         {.description = "reaction stoichometrie list", .size = from_parameter<int>("NUMSCAL")}));
-    m->add_component(entry<double>("REACCOEFF", {.description = "reaction coefficient"}));
-    m->add_component(entry<int>("DISTRFUNCT",
+    m->add_component(parameter<double>("REACCOEFF", {.description = "reaction coefficient"}));
+    m->add_component(parameter<int>("DISTRFUNCT",
         {.description = "spatial distribution of reaction coefficient", .default_value = 0}));
-    m->add_component(entry<std::string>("COUPLING",
+    m->add_component(parameter<std::string>("COUPLING",
         {.description = "type of coupling: simple_multiplicative, power_multiplicative, "
                         "constant, michaelis_menten, by_function, no_coupling (default)",
             .default_value = "no_coupling"}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "ROLE", {.description = "role in michaelis-menten like reactions",
                     .size = from_parameter<int>("NUMSCAL")}));
     m->add_component(
-        entry<std::vector<double>>("REACSTART", {.description = "starting point of reaction",
-                                                    .required = false,
-                                                    .size = from_parameter<int>("NUMSCAL")}));
+        parameter<std::vector<double>>("REACSTART", {.description = "starting point of reaction",
+                                                        .required = false,
+                                                        .size = from_parameter<int>("NUMSCAL")}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -292,23 +296,23 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "advanced reaction material for multiphase porous flow (species in fluid)",
         Core::Materials::m_scatra_multiporo_fluid);
 
-    m->add_component(entry<double>("DIFFUSIVITY", {.description = "kinematic diffusivity"}));
+    m->add_component(parameter<double>("DIFFUSIVITY", {.description = "kinematic diffusivity"}));
+    m->add_component(parameter<int>(
+        "PHASEID", {.description = "ID of fluid phase the scalar is associated with"}));
+    m->add_component(parameter<double>(
+        "REACOEFF", {.description = "reaction coefficient", .default_value = 0.0}));
     m->add_component(
-        entry<int>("PHASEID", {.description = "ID of fluid phase the scalar is associated with"}));
-    m->add_component(
-        entry<double>("REACOEFF", {.description = "reaction coefficient", .default_value = 0.0}));
-    m->add_component(
-        entry<double>("SCNUM", {.description = "schmidt number", .default_value = 0.0}));
-    m->add_component(entry<double>(
+        parameter<double>("SCNUM", {.description = "schmidt number", .default_value = 0.0}));
+    m->add_component(parameter<double>(
         "DENSIFICATION", {.description = "densification coefficient", .default_value = 0.0}));
-    m->add_component(entry<double>("DELTA", {.description = "delta", .default_value = 0.0}));
-    m->add_component(entry<double>("MIN_SAT",
+    m->add_component(parameter<double>("DELTA", {.description = "delta", .default_value = 0.0}));
+    m->add_component(parameter<double>("MIN_SAT",
         {.description =
                 "minimum saturation under which also corresponding mass fraction is equal to zero",
             .default_value = 1.0e-9}));
-    m->add_component(entry<bool>("REACTS_TO_EXTERNAL_FORCE",
+    m->add_component(parameter<bool>("REACTS_TO_EXTERNAL_FORCE",
         {.description = "reacts to external force", .default_value = false}));
-    m->add_component(entry<int>("RELATIVE_MOBILITY_FUNCTION_ID",
+    m->add_component(parameter<int>("RELATIVE_MOBILITY_FUNCTION_ID",
         {.description = "relative mobility function ID", .default_value = 0}));
 
     Mat::append_material_definition(matlist, m);
@@ -321,19 +325,19 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "advanced reaction material for multiphase porous flow (species in volfrac)",
         Core::Materials::m_scatra_multiporo_volfrac);
 
-    m->add_component(entry<double>("DIFFUSIVITY", {.description = "kinematic diffusivity"}));
-    m->add_component(
-        entry<int>("PHASEID", {.description = "ID of fluid phase the scalar is associated with"}));
+    m->add_component(parameter<double>("DIFFUSIVITY", {.description = "kinematic diffusivity"}));
+    m->add_component(parameter<int>(
+        "PHASEID", {.description = "ID of fluid phase the scalar is associated with"}));
+    m->add_component(parameter<double>(
+        "REACOEFF", {.description = "reaction coefficient", .default_value = 0.0}));
     m->add_component(
-        entry<double>("REACOEFF", {.description = "reaction coefficient", .default_value = 0.0}));
-    m->add_component(
-        entry<double>("SCNUM", {.description = "schmidt number", .default_value = 0.0}));
-    m->add_component(entry<double>(
+        parameter<double>("SCNUM", {.description = "schmidt number", .default_value = 0.0}));
+    m->add_component(parameter<double>(
         "DENSIFICATION", {.description = "densification coefficient", .default_value = 0.0}));
-    m->add_component(entry<double>("DELTA", {.description = "delta", .default_value = 0.0}));
-    m->add_component(entry<bool>("REACTS_TO_EXTERNAL_FORCE",
+    m->add_component(parameter<double>("DELTA", {.description = "delta", .default_value = 0.0}));
+    m->add_component(parameter<bool>("REACTS_TO_EXTERNAL_FORCE",
         {.description = "reacts to external force", .default_value = false}));
-    m->add_component(entry<int>("RELATIVE_MOBILITY_FUNCTION_ID",
+    m->add_component(parameter<int>("RELATIVE_MOBILITY_FUNCTION_ID",
         {.description = "relative mobility function ID", .default_value = 0}));
 
     Mat::append_material_definition(matlist, m);
@@ -347,16 +351,16 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "porous flow (species in solid)",
         Core::Materials::m_scatra_multiporo_solid);
 
-    m->add_component(entry<double>("DIFFUSIVITY", {.description = "kinematic diffusivity"}));
+    m->add_component(parameter<double>("DIFFUSIVITY", {.description = "kinematic diffusivity"}));
     // no phaseID because only one solid phase
+    m->add_component(parameter<double>(
+        "REACOEFF", {.description = "reaction coefficient", .default_value = 0.0}));
     m->add_component(
-        entry<double>("REACOEFF", {.description = "reaction coefficient", .default_value = 0.0}));
-    m->add_component(
-        entry<double>("SCNUM", {.description = "schmidt number", .default_value = 0.0}));
-    m->add_component(entry<double>(
+        parameter<double>("SCNUM", {.description = "schmidt number", .default_value = 0.0}));
+    m->add_component(parameter<double>(
         "DENSIFICATION", {.description = "densification coefficient", .default_value = 0.0}));
-    m->add_component(entry<double>("DELTA", {.description = "delta", .default_value = 0.0}));
-    m->add_component(entry<bool>("REACTS_TO_EXTERNAL_FORCE",
+    m->add_component(parameter<double>("DELTA", {.description = "delta", .default_value = 0.0}));
+    m->add_component(parameter<bool>("REACTS_TO_EXTERNAL_FORCE",
         {.description = "reacts to external force", .default_value = false}));
 
     Mat::append_material_definition(matlist, m);
@@ -369,30 +373,30 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "advanced reaction material for multiphase porous flow (temperature)",
         Core::Materials::m_scatra_multiporo_temperature);
 
-    m->add_component(entry<int>(
+    m->add_component(parameter<int>(
         "NUMFLUIDPHASES_IN_MULTIPHASEPORESPACE", {.description = "number of fluid dofs"}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "CP_FLUID", {.description = "heat capacity fluid phases",
                         .size = from_parameter<int>("NUMFLUIDPHASES_IN_MULTIPHASEPORESPACE")}));
-    m->add_component(entry<int>("NUMVOLFRAC", {.description = "number of volfrac dofs"}));
-    m->add_component(entry<std::vector<double>>("CP_VOLFRAC",
+    m->add_component(parameter<int>("NUMVOLFRAC", {.description = "number of volfrac dofs"}));
+    m->add_component(parameter<std::vector<double>>("CP_VOLFRAC",
         {.description = "heat capacity volfrac", .size = from_parameter<int>("NUMVOLFRAC")}));
-    m->add_component(entry<double>("CP_SOLID", {.description = "heat capacity solid"}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<double>("CP_SOLID", {.description = "heat capacity solid"}));
+    m->add_component(parameter<std::vector<double>>(
         "KAPPA_FLUID", {.description = "thermal diffusivity fluid phases",
                            .size = from_parameter<int>("NUMFLUIDPHASES_IN_MULTIPHASEPORESPACE")}));
-    m->add_component(entry<std::vector<double>>("KAPPA_VOLFRAC",
+    m->add_component(parameter<std::vector<double>>("KAPPA_VOLFRAC",
         {.description = "thermal diffusivity volfrac", .size = from_parameter<int>("NUMVOLFRAC")}));
-    m->add_component(entry<double>("KAPPA_SOLID", {.description = "heat capacity solid"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>("KAPPA_SOLID", {.description = "heat capacity solid"}));
+    m->add_component(parameter<double>(
         "DIFFUSIVITY", {.description = "kinematic diffusivity", .default_value = 1.0}));
+    m->add_component(parameter<double>(
+        "REACOEFF", {.description = "reaction coefficient", .default_value = 0.0}));
     m->add_component(
-        entry<double>("REACOEFF", {.description = "reaction coefficient", .default_value = 0.0}));
-    m->add_component(
-        entry<double>("SCNUM", {.description = "schmidt number", .default_value = 0.0}));
-    m->add_component(entry<double>(
+        parameter<double>("SCNUM", {.description = "schmidt number", .default_value = 0.0}));
+    m->add_component(parameter<double>(
         "DENSIFICATION", {.description = "densification coefficient", .default_value = 0.0}));
-    m->add_component(entry<bool>("REACTS_TO_EXTERNAL_FORCE",
+    m->add_component(parameter<bool>("REACTS_TO_EXTERNAL_FORCE",
         {.description = "reacts to external force", .default_value = false}));
 
     Mat::append_material_definition(matlist, m);
@@ -404,11 +408,11 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MAT_scatra_chemotaxis", "chemotaxis material", Core::Materials::m_scatra_chemotaxis);
 
-    m->add_component(
-        entry<int>("NUMSCAL", {.description = "number of chemotactic pairs for these elements"}));
-    m->add_component(entry<std::vector<int>>(
+    m->add_component(parameter<int>(
+        "NUMSCAL", {.description = "number of chemotactic pairs for these elements"}));
+    m->add_component(parameter<std::vector<int>>(
         "PAIR", {.description = "chemotaxis pairing", .size = from_parameter<int>("NUMSCAL")}));
-    m->add_component(entry<double>("CHEMOCOEFF", {.description = "chemotaxis coefficient"}));
+    m->add_component(parameter<double>("CHEMOCOEFF", {.description = "chemotaxis coefficient"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -419,21 +423,22 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_scatra_multiscale",
         "scalar transport material for multi-scale approach", Core::Materials::m_scatra_multiscale);
 
-    m->add_component(entry<std::string>("MICROFILE",
+    m->add_component(parameter<std::string>("MICROFILE",
         {.description = "input file for micro scale", .default_value = "filename.dat"}));
     m->add_component(
-        entry<int>("MICRODIS_NUM", {.description = "number of micro-scale discretization"}));
-    m->add_component(entry<double>("POROSITY", {.description = "porosity"}));
-    m->add_component(entry<double>("TORTUOSITY", {.description = "tortuosity"}));
-    m->add_component(entry<double>("A_s", {.description = "specific micro-scale surface area"}));
-    m->add_component(entry<double>("DIFFUSIVITY", {.description = "kinematic diffusivity"}));
+        parameter<int>("MICRODIS_NUM", {.description = "number of micro-scale discretization"}));
+    m->add_component(parameter<double>("POROSITY", {.description = "porosity"}));
+    m->add_component(parameter<double>("TORTUOSITY", {.description = "tortuosity"}));
     m->add_component(
-        entry<double>("REACOEFF", {.description = "reaction coefficient", .default_value = 0.0}));
+        parameter<double>("A_s", {.description = "specific micro-scale surface area"}));
+    m->add_component(parameter<double>("DIFFUSIVITY", {.description = "kinematic diffusivity"}));
+    m->add_component(parameter<double>(
+        "REACOEFF", {.description = "reaction coefficient", .default_value = 0.0}));
     m->add_component(
-        entry<double>("SCNUM", {.description = "Schmidt number", .default_value = 0.0}));
-    m->add_component(entry<double>(
+        parameter<double>("SCNUM", {.description = "Schmidt number", .default_value = 0.0}));
+    m->add_component(parameter<double>(
         "DENSIFICATION", {.description = "densification coefficient", .default_value = 0.0}));
-    m->add_component(entry<bool>("REACTS_TO_EXTERNAL_FORCE",
+    m->add_component(parameter<bool>("REACTS_TO_EXTERNAL_FORCE",
         {.description = "reacts to external force", .default_value = false}));
 
     Mat::append_material_definition(matlist, m);
@@ -446,60 +451,61 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "Weickenmeier muscle material", Core::Materials::m_muscle_weickenmeier);
 
     m->add_component(
-        entry<double>("ALPHA", {.description = "experimentally fitted material parameter"}));
+        parameter<double>("ALPHA", {.description = "experimentally fitted material parameter"}));
     m->add_component(
-        entry<double>("BETA", {.description = "experimentally fitted material parameter"}));
+        parameter<double>("BETA", {.description = "experimentally fitted material parameter"}));
     m->add_component(
-        entry<double>("GAMMA", {.description = "experimentally fitted material parameter"}));
-    m->add_component(entry<double>(
+        parameter<double>("GAMMA", {.description = "experimentally fitted material parameter"}));
+    m->add_component(parameter<double>(
         "KAPPA", {.description = "material parameter for coupled volumetric contribution"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "OMEGA0", {.description = "weighting factor for isotropic tissue constituents"}));
-    m->add_component(entry<double>("ACTMUNUM",
+    m->add_component(parameter<double>("ACTMUNUM",
         {.description =
                 "number of active motor units per undeformed muscle cross-sectional area"}));
-    m->add_component(entry<int>("MUTYPESNUM", {.description = "number of motor unit types"}));
-    m->add_component(entry<std::vector<double>>("INTERSTIM",
+    m->add_component(parameter<int>("MUTYPESNUM", {.description = "number of motor unit types"}));
+    m->add_component(parameter<std::vector<double>>("INTERSTIM",
         {.description = "interstimulus interval", .size = from_parameter<int>("MUTYPESNUM")}));
-    m->add_component(entry<std::vector<double>>("FRACACTMU",
+    m->add_component(parameter<std::vector<double>>("FRACACTMU",
         {.description = "fraction of motor unit type", .size = from_parameter<int>("MUTYPESNUM")}));
     m->add_component(
-        entry<std::vector<double>>("FTWITCH", {.description = "twitch force of motor unit type",
-                                                  .size = from_parameter<int>("MUTYPESNUM")}));
-    m->add_component(entry<std::vector<double>>(
+        parameter<std::vector<double>>("FTWITCH", {.description = "twitch force of motor unit type",
+                                                      .size = from_parameter<int>("MUTYPESNUM")}));
+    m->add_component(parameter<std::vector<double>>(
         "TTWITCH", {.description = "twitch contraction time of motor unit type",
                        .size = from_parameter<int>("MUTYPESNUM")}));
-    m->add_component(entry<double>("LAMBDAMIN", {.description = "minimal active fiber stretch"}));
-    m->add_component(entry<double>("LAMBDAOPT",
-        {.description = "optimal active fiber stretch related to active nominal stress maximum"}));
-    m->add_component(entry<double>("DOTLAMBDAMIN", {.description = "minimal stretch rate"}));
-    m->add_component(
-        entry<double>("KE", {.description = "parameter controlling the curvature of the velocity "
-                                            "dependent activation function in the "
-                                            "eccentric case"}));
-    m->add_component(
-        entry<double>("KC", {.description = "parameter controlling the curvature of the velocity "
-                                            "dependent activation function in the "
-                                            "concentric case"}));
     m->add_component(
-        entry<double>("DE", {.description = "parameter controlling the amplitude of the velocity "
-                                            "dependent activation function in the "
-                                            "eccentric case"}));
-    m->add_component(
-        entry<double>("DC", {.description = "parameter controlling the amplitude of the velocity "
-                                            "dependent activation function in the "
-                                            "concentric case"}));
-    m->add_component(entry<int>(
+        parameter<double>("LAMBDAMIN", {.description = "minimal active fiber stretch"}));
+    m->add_component(parameter<double>("LAMBDAOPT",
+        {.description = "optimal active fiber stretch related to active nominal stress maximum"}));
+    m->add_component(parameter<double>("DOTLAMBDAMIN", {.description = "minimal stretch rate"}));
+    m->add_component(parameter<double>(
+        "KE", {.description = "parameter controlling the curvature of the velocity "
+                              "dependent activation function in the "
+                              "eccentric case"}));
+    m->add_component(parameter<double>(
+        "KC", {.description = "parameter controlling the curvature of the velocity "
+                              "dependent activation function in the "
+                              "concentric case"}));
+    m->add_component(parameter<double>(
+        "DE", {.description = "parameter controlling the amplitude of the velocity "
+                              "dependent activation function in the "
+                              "eccentric case"}));
+    m->add_component(parameter<double>(
+        "DC", {.description = "parameter controlling the amplitude of the velocity "
+                              "dependent activation function in the "
+                              "concentric case"}));
+    m->add_component(parameter<int>(
         "ACTTIMESNUM", {.description = "number of time boundaries to prescribe activation"}));
-    m->add_component(
-        entry<std::vector<double>>("ACTTIMES", {.description = "time boundaries between intervals",
-                                                   .size = from_parameter<int>("ACTTIMESNUM")}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<std::vector<double>>(
+        "ACTTIMES", {.description = "time boundaries between intervals",
+                        .size = from_parameter<int>("ACTTIMESNUM")}));
+    m->add_component(parameter<int>(
         "ACTINTERVALSNUM", {.description = "number of time intervals to prescribe activation"}));
-    m->add_component(entry<std::vector<double>>("ACTVALUES",
+    m->add_component(parameter<std::vector<double>>("ACTVALUES",
         {.description = "scaling factor in intervals (1=full activation, 0=no activation)",
             .size = from_parameter<int>("ACTINTERVALSNUM")}));
-    m->add_component(entry<double>("DENS", {.description = "density"}));
+    m->add_component(parameter<double>("DENS", {.description = "density"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -511,19 +517,20 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "MAT_Muscle_Combo", "Combo muscle material", Core::Materials::m_muscle_combo);
 
     m->add_component(
-        entry<double>("ALPHA", {.description = "experimentally fitted material parameter"}));
+        parameter<double>("ALPHA", {.description = "experimentally fitted material parameter"}));
     m->add_component(
-        entry<double>("BETA", {.description = "experimentally fitted material parameter"}));
+        parameter<double>("BETA", {.description = "experimentally fitted material parameter"}));
     m->add_component(
-        entry<double>("GAMMA", {.description = "experimentally fitted material parameter"}));
-    m->add_component(entry<double>(
+        parameter<double>("GAMMA", {.description = "experimentally fitted material parameter"}));
+    m->add_component(parameter<double>(
         "KAPPA", {.description = "material parameter for coupled volumetric contribution"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "OMEGA0", {.description = "weighting factor for isotropic tissue constituents"}));
     m->add_component(
-        entry<double>("POPT", {.description = "tetanised optimal (maximal) active stress"}));
-    m->add_component(entry<double>("LAMBDAMIN", {.description = "minimal active fiber stretch"}));
-    m->add_component(entry<double>("LAMBDAOPT",
+        parameter<double>("POPT", {.description = "tetanised optimal (maximal) active stress"}));
+    m->add_component(
+        parameter<double>("LAMBDAMIN", {.description = "minimal active fiber stretch"}));
+    m->add_component(parameter<double>("LAMBDAOPT",
         {.description = "optimal active fiber stretch related to active nominal stress maximum"}));
 
     m->add_component(selection<Inpar::Mat::ActivationType>("ACTEVALTYPE",
@@ -554,16 +561,16 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     };
 
     auto activation = one_of({
-        entry<int>("FUNCTID",
+        parameter<int>("FUNCTID",
             {.description = "function id for time- and space-dependency of muscle activation"}),
-        entry<std::filesystem::path>("MAPFILE",
+        parameter<std::filesystem::path>("MAPFILE",
             {.description = "pattern file containing a map of elementwise-defined discrete values "
                             "for time- and space-dependency of muscle activation",
                 .on_parse_callback = on_parse}),
     });
     m->add_component(std::move(activation));
 
-    m->add_component(entry<double>("DENS", {.description = "density"}));
+    m->add_component(parameter<double>("DENS", {.description = "density"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -575,60 +582,61 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "Giantesio active strain muscle material", Core::Materials::m_muscle_giantesio);
 
     m->add_component(
-        entry<double>("ALPHA", {.description = "experimentally fitted material parameter"}));
+        parameter<double>("ALPHA", {.description = "experimentally fitted material parameter"}));
     m->add_component(
-        entry<double>("BETA", {.description = "experimentally fitted material parameter"}));
+        parameter<double>("BETA", {.description = "experimentally fitted material parameter"}));
     m->add_component(
-        entry<double>("GAMMA", {.description = "experimentally fitted material parameter"}));
-    m->add_component(entry<double>(
+        parameter<double>("GAMMA", {.description = "experimentally fitted material parameter"}));
+    m->add_component(parameter<double>(
         "KAPPA", {.description = "material parameter for coupled volumetric contribution"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "OMEGA0", {.description = "weighting factor for isotropic tissue constituents"}));
-    m->add_component(entry<double>("ACTMUNUM",
+    m->add_component(parameter<double>("ACTMUNUM",
         {.description =
                 "number of active motor units per undeformed muscle cross-sectional area"}));
-    m->add_component(entry<int>("MUTYPESNUM", {.description = "number of motor unit types"}));
-    m->add_component(entry<std::vector<double>>("INTERSTIM",
+    m->add_component(parameter<int>("MUTYPESNUM", {.description = "number of motor unit types"}));
+    m->add_component(parameter<std::vector<double>>("INTERSTIM",
         {.description = "interstimulus interval", .size = from_parameter<int>("MUTYPESNUM")}));
-    m->add_component(entry<std::vector<double>>("FRACACTMU",
+    m->add_component(parameter<std::vector<double>>("FRACACTMU",
         {.description = "fraction of motor unit type", .size = from_parameter<int>("MUTYPESNUM")}));
     m->add_component(
-        entry<std::vector<double>>("FTWITCH", {.description = "twitch force of motor unit type",
-                                                  .size = from_parameter<int>("MUTYPESNUM")}));
-    m->add_component(entry<std::vector<double>>(
+        parameter<std::vector<double>>("FTWITCH", {.description = "twitch force of motor unit type",
+                                                      .size = from_parameter<int>("MUTYPESNUM")}));
+    m->add_component(parameter<std::vector<double>>(
         "TTWITCH", {.description = "twitch contraction time of motor unit type",
                        .size = from_parameter<int>("MUTYPESNUM")}));
-    m->add_component(entry<double>("LAMBDAMIN", {.description = "minimal active fiber stretch"}));
-    m->add_component(entry<double>("LAMBDAOPT",
-        {.description = "optimal active fiber stretch related to active nominal stress maximum"}));
-    m->add_component(entry<double>("DOTLAMBDAMIN", {.description = "minimal stretch rate"}));
-    m->add_component(
-        entry<double>("KE", {.description = "parameter controlling the curvature of the velocity "
-                                            "dependent activation function in the "
-                                            "eccentric case"}));
-    m->add_component(
-        entry<double>("KC", {.description = "parameter controlling the curvature of the velocity "
-                                            "dependent activation function in the "
-                                            "concentric case"}));
     m->add_component(
-        entry<double>("DE", {.description = "parameter controlling the amplitude of the velocity "
-                                            "dependent activation function in the "
-                                            "eccentric case"}));
-    m->add_component(
-        entry<double>("DC", {.description = "parameter controlling the amplitude of the velocity "
-                                            "dependent activation function in the "
-                                            "concentric case"}));
-    m->add_component(entry<int>(
+        parameter<double>("LAMBDAMIN", {.description = "minimal active fiber stretch"}));
+    m->add_component(parameter<double>("LAMBDAOPT",
+        {.description = "optimal active fiber stretch related to active nominal stress maximum"}));
+    m->add_component(parameter<double>("DOTLAMBDAMIN", {.description = "minimal stretch rate"}));
+    m->add_component(parameter<double>(
+        "KE", {.description = "parameter controlling the curvature of the velocity "
+                              "dependent activation function in the "
+                              "eccentric case"}));
+    m->add_component(parameter<double>(
+        "KC", {.description = "parameter controlling the curvature of the velocity "
+                              "dependent activation function in the "
+                              "concentric case"}));
+    m->add_component(parameter<double>(
+        "DE", {.description = "parameter controlling the amplitude of the velocity "
+                              "dependent activation function in the "
+                              "eccentric case"}));
+    m->add_component(parameter<double>(
+        "DC", {.description = "parameter controlling the amplitude of the velocity "
+                              "dependent activation function in the "
+                              "concentric case"}));
+    m->add_component(parameter<int>(
         "ACTTIMESNUM", {.description = "number of time boundaries to prescribe activation"}));
-    m->add_component(
-        entry<std::vector<double>>("ACTTIMES", {.description = "time boundaries between intervals",
-                                                   .size = from_parameter<int>("ACTTIMESNUM")}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<std::vector<double>>(
+        "ACTTIMES", {.description = "time boundaries between intervals",
+                        .size = from_parameter<int>("ACTTIMESNUM")}));
+    m->add_component(parameter<int>(
         "ACTINTERVALSNUM", {.description = "number of time intervals to prescribe activation"}));
-    m->add_component(entry<std::vector<double>>("ACTVALUES",
+    m->add_component(parameter<std::vector<double>>("ACTVALUES",
         {.description = "scaling factor in intervals (1=full activation, 0=no activation)",
             .size = from_parameter<int>("ACTINTERVALSNUM")}));
-    m->add_component(entry<double>("DENS", {.description = "density"}));
+    m->add_component(parameter<double>("DENS", {.description = "density"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -639,20 +647,21 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MAT_myocard", "Myocard muscle material", Core::Materials::m_myocard);
 
-    m->add_component(entry<double>("DIFF1", {.description = "conductivity in fiber direction"}));
-    m->add_component(
-        entry<double>("DIFF2", {.description = "conductivity perpendicular to fiber direction"}));
     m->add_component(
-        entry<double>("DIFF3", {.description = "conductivity perpendicular to fiber direction"}));
-    m->add_component(entry<double>("PERTURBATION_DERIV",
+        parameter<double>("DIFF1", {.description = "conductivity in fiber direction"}));
+    m->add_component(parameter<double>(
+        "DIFF2", {.description = "conductivity perpendicular to fiber direction"}));
+    m->add_component(parameter<double>(
+        "DIFF3", {.description = "conductivity perpendicular to fiber direction"}));
+    m->add_component(parameter<double>("PERTURBATION_DERIV",
         {.description = "perturbation for calculation of reaction coefficient derivative"}));
-    m->add_component(entry<std::string>(
+    m->add_component(parameter<std::string>(
         "MODEL", {.description = "Model type: MV (default), FHN, TNNP, SAN or INADA",
                      .default_value = "MV"}));
-    m->add_component(entry<std::string>("TISSUE",
+    m->add_component(parameter<std::string>("TISSUE",
         {.description = "Tissue type: M (default), ENDO, EPI, AN, N or NH", .default_value = "M"}));
     m->add_component(
-        entry<double>("TIME_SCALE", {.description = "Scale factor for time units of Model"}));
+        parameter<double>("TIME_SCALE", {.description = "Scale factor for time units of Model"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -664,16 +673,16 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "MAT_sutherland", "material according to Sutherland law", Core::Materials::m_sutherland);
 
     m->add_component(
-        entry<double>("REFVISC", {.description = "reference dynamic viscosity (kg/(m*s))"}));
-    m->add_component(entry<double>("REFTEMP", {.description = "reference temperature (K)"}));
-    m->add_component(entry<double>("SUTHTEMP", {.description = "Sutherland temperature (K)"}));
-    m->add_component(entry<double>(
+        parameter<double>("REFVISC", {.description = "reference dynamic viscosity (kg/(m*s))"}));
+    m->add_component(parameter<double>("REFTEMP", {.description = "reference temperature (K)"}));
+    m->add_component(parameter<double>("SUTHTEMP", {.description = "Sutherland temperature (K)"}));
+    m->add_component(parameter<double>(
         "SHC", {.description = "specific heat capacity at constant pressure (J/(kg*K))"}));
-    m->add_component(entry<double>("PRANUM", {.description = "Prandtl number"}));
+    m->add_component(parameter<double>("PRANUM", {.description = "Prandtl number"}));
+    m->add_component(parameter<double>(
+        "THERMPRESS", {.description = "(initial) thermodynamic pressure (J/m^3)"}));
     m->add_component(
-        entry<double>("THERMPRESS", {.description = "(initial) thermodynamic pressure (J/m^3)"}));
-    m->add_component(
-        entry<double>("GASCON", {.description = "specific gas constant R (J/(kg*K))"}));
+        parameter<double>("GASCON", {.description = "specific gas constant R (J/(kg*K))"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -685,15 +694,15 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_ion",
         "material parameters for ion species in electrolyte solution", Core::Materials::m_ion);
 
-    m->add_component(entry<double>("DIFFUSIVITY", {.description = "kinematic diffusivity"}));
-    m->add_component(entry<double>("VALENCE", {.description = "valence (= charge number)"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>("DIFFUSIVITY", {.description = "kinematic diffusivity"}));
+    m->add_component(parameter<double>("VALENCE", {.description = "valence (= charge number)"}));
+    m->add_component(parameter<double>(
         "DENSIFICATION", {.description = "densification coefficient", .default_value = 0.0}));
     // via these two optional parameters we can bring the material parameters
     // of one eliminated ionic species into 4C if needed
-    m->add_component(entry<double>("ELIM_DIFFUSIVITY",
+    m->add_component(parameter<double>("ELIM_DIFFUSIVITY",
         {.description = "kinematic diffusivity of elim. species", .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "ELIM_VALENCE", {.description = "valence of elim. species", .default_value = 0.0}));
 
     Mat::append_material_definition(matlist, m);
@@ -705,60 +714,60 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_newman",
         "material parameters for ion species in electrolyte solution", Core::Materials::m_newman);
 
-    m->add_component(entry<double>("VALENCE", {.description = "valence (= charge number)"}));
-    m->add_component(entry<int>("DIFF_COEF_CONC_DEP_FUNCT",
+    m->add_component(parameter<double>("VALENCE", {.description = "valence (= charge number)"}));
+    m->add_component(parameter<int>("DIFF_COEF_CONC_DEP_FUNCT",
         {.description = "function number of function describing concentration dependence of "
                         "diffusion coefficient"}));
-    m->add_component(entry<int>("DIFF_COEF_TEMP_SCALE_FUNCT",
+    m->add_component(parameter<int>("DIFF_COEF_TEMP_SCALE_FUNCT",
         {.description = "FUNCT number describing temperature scaling of diffusion coefficient"}));
     m->add_component(
-        entry<int>("TRANSNR", {.description = "curve number for transference number"}));
+        parameter<int>("TRANSNR", {.description = "curve number for transference number"}));
     m->add_component(
-        entry<int>("THERMFAC", {.description = "curve number for thermodynamic factor"}));
-    m->add_component(entry<int>(
+        parameter<int>("THERMFAC", {.description = "curve number for thermodynamic factor"}));
+    m->add_component(parameter<int>(
         "COND_CONC_DEP_FUNCT", {.description = "function number of function describing "
                                                "concentration dependence of conductivity"}));
-    m->add_component(entry<int>("COND_TEMP_SCALE_FUNCT",
+    m->add_component(parameter<int>("COND_TEMP_SCALE_FUNCT",
         {.description = "FUNCT number describing temperature scaling of conductivity"}));
     // optional parameter for implemented concentration depending function
-    m->add_component(entry<int>("DIFF_PARA_NUM",
+    m->add_component(parameter<int>("DIFF_PARA_NUM",
         {.description = "number of parameters for diffusion coefficient", .default_value = 0}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "DIFF_PARA", {.description = "parameters for diffusion coefficient",
                          .default_value = std::vector<double>{},
                          .size = from_parameter<int>("DIFF_PARA_NUM")}));
-    m->add_component(entry<int>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA_NUM",
+    m->add_component(parameter<int>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA_NUM",
         {.description = "number of parameters for scaling function describing temperature "
                         "dependence of diffusion "
                         "coefficient",
             .default_value = 0}));
-    m->add_component(entry<std::vector<double>>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA",
+    m->add_component(parameter<std::vector<double>>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA",
         {.description = "parameters for function describing temperature dependence of diffusion "
                         "coefficient",
             .default_value = std::vector<double>{},
             .size = from_parameter<int>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA_NUM")}));
-    m->add_component(entry<int>("TRANS_PARA_NUM",
+    m->add_component(parameter<int>("TRANS_PARA_NUM",
         {.description = "number of parameters for transference number", .default_value = 0}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "TRANS_PARA", {.description = "parameters for transference number",
                           .default_value = std::vector<double>{},
                           .size = from_parameter<int>("TRANS_PARA_NUM")}));
-    m->add_component(entry<int>("THERM_PARA_NUM",
+    m->add_component(parameter<int>("THERM_PARA_NUM",
         {.description = "number of parameters for thermodynamic factor", .default_value = 0}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "THERM_PARA", {.description = "parameters for thermodynamic factor",
                           .default_value = std::vector<double>{},
                           .size = from_parameter<int>("THERM_PARA_NUM")}));
-    m->add_component(entry<int>("COND_PARA_NUM",
+    m->add_component(parameter<int>("COND_PARA_NUM",
         {.description = "number of parameters for conductivity", .default_value = 0}));
-    m->add_component(
-        entry<std::vector<double>>("COND_PARA", {.description = "parameters for conductivity",
-                                                    .default_value = std::vector<double>{},
-                                                    .size = from_parameter<int>("COND_PARA_NUM")}));
-    m->add_component(entry<int>("COND_TEMP_SCALE_FUNCT_PARA_NUM",
+    m->add_component(parameter<std::vector<double>>(
+        "COND_PARA", {.description = "parameters for conductivity",
+                         .default_value = std::vector<double>{},
+                         .size = from_parameter<int>("COND_PARA_NUM")}));
+    m->add_component(parameter<int>("COND_TEMP_SCALE_FUNCT_PARA_NUM",
         {.description = "number of parameters for temperature scaling of conductivity",
             .default_value = 0}));
-    m->add_component(entry<std::vector<double>>("COND_TEMP_SCALE_FUNCT_PARA",
+    m->add_component(parameter<std::vector<double>>("COND_TEMP_SCALE_FUNCT_PARA",
         {.description = "parameters for temperature scaling of conductivity",
             .default_value = std::vector<double>{},
             .size = from_parameter<int>("COND_TEMP_SCALE_FUNCT_PARA_NUM")}));
@@ -774,69 +783,71 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "material parameters for ion species in electrolyte solution for multi-scale approach",
         Core::Materials::m_newman_multiscale);
 
-    m->add_component(entry<double>("VALENCE", {.description = "valence (= charge number)"}));
-    m->add_component(entry<int>("DIFF_COEF_CONC_DEP_FUNCT",
+    m->add_component(parameter<double>("VALENCE", {.description = "valence (= charge number)"}));
+    m->add_component(parameter<int>("DIFF_COEF_CONC_DEP_FUNCT",
         {.description = "function number of function describing concentration dependence of "
                         "diffusion coefficient"}));
-    m->add_component(entry<int>("DIFF_COEF_TEMP_SCALE_FUNCT",
+    m->add_component(parameter<int>("DIFF_COEF_TEMP_SCALE_FUNCT",
         {.description = "FUNCT number describing temperature scaling of diffusion coefficient"}));
     m->add_component(
-        entry<int>("TRANSNR", {.description = "curve number for transference number"}));
+        parameter<int>("TRANSNR", {.description = "curve number for transference number"}));
     m->add_component(
-        entry<int>("THERMFAC", {.description = "curve number for thermodynamic factor"}));
-    m->add_component(entry<int>(
+        parameter<int>("THERMFAC", {.description = "curve number for thermodynamic factor"}));
+    m->add_component(parameter<int>(
         "COND_CONC_DEP_FUNCT", {.description = "function number of function describing "
                                                "concentration dependence of conductivity"}));
-    m->add_component(entry<int>("COND_TEMP_SCALE_FUNCT",
+    m->add_component(parameter<int>("COND_TEMP_SCALE_FUNCT",
         {.description = "FUNCT number describing temperature scaling of conductivity"}));
-    m->add_component(entry<double>("ELECTRONIC_COND", {.description = "electronic conductivity"}));
-    m->add_component(entry<int>("ELECTRONIC_COND_CONC_SCALE_FUNC_NUM",
+    m->add_component(
+        parameter<double>("ELECTRONIC_COND", {.description = "electronic conductivity"}));
+    m->add_component(parameter<int>("ELECTRONIC_COND_CONC_SCALE_FUNC_NUM",
         {.description =
                 "FUNCT number describing concentration dependence of electronic conductivity"}));
-    m->add_component(entry<double>("A_s", {.description = "specific micro-scale surface area"}));
-    m->add_component(entry<std::string>("MICROFILE",
+    m->add_component(
+        parameter<double>("A_s", {.description = "specific micro-scale surface area"}));
+    m->add_component(parameter<std::string>("MICROFILE",
         {.description = "input file for micro scale", .default_value = "filename.dat"}));
     m->add_component(
-        entry<int>("MICRODIS_NUM", {.description = "number of micro-scale discretization"}));
+        parameter<int>("MICRODIS_NUM", {.description = "number of micro-scale discretization"}));
     // optional parameters for implemented concentration-depending functions
-    m->add_component(entry<int>("DIFF_PARA_NUM",
+    m->add_component(parameter<int>("DIFF_PARA_NUM",
         {.description = "number of parameters for diffusion coefficient", .default_value = 0}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "DIFF_PARA", {.description = "parameters for diffusion coefficient",
                          .default_value = std::vector<double>{},
                          .size = from_parameter<int>("DIFF_PARA_NUM")}));
-    m->add_component(entry<int>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA_NUM",
+    m->add_component(parameter<int>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA_NUM",
         {.description =
                 "number of parameters for scaling function describing temperature dependence of "
                 "diffusion coefficient",
             .default_value = 0}));
-    m->add_component(entry<std::vector<double>>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA",
+    m->add_component(parameter<std::vector<double>>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA",
         {.description = "parameters for function describing temperature dependence of diffusion "
                         "coefficient",
             .default_value = std::vector<double>{},
             .size = from_parameter<int>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA_NUM")}));
-    m->add_component(entry<int>("TRANS_PARA_NUM",
+    m->add_component(parameter<int>("TRANS_PARA_NUM",
         {.description = "number of parameters for transference number", .default_value = 0}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "TRANS_PARA", {.description = "parameters for transference number",
                           .default_value = std::vector<double>{},
                           .size = from_parameter<int>("TRANS_PARA_NUM")}));
-    m->add_component(entry<int>("THERM_PARA_NUM",
+    m->add_component(parameter<int>("THERM_PARA_NUM",
         {.description = "number of parameters for thermodynamic factor", .default_value = 0}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "THERM_PARA", {.description = "parameters for thermodynamic factor",
                           .default_value = std::vector<double>{},
                           .size = from_parameter<int>("THERM_PARA_NUM")}));
-    m->add_component(entry<int>("COND_PARA_NUM",
+    m->add_component(parameter<int>("COND_PARA_NUM",
         {.description = "number of parameters for ionic conductivity", .default_value = 0}));
-    m->add_component(
-        entry<std::vector<double>>("COND_PARA", {.description = "parameters for ionic conductivity",
-                                                    .default_value = std::vector<double>{},
-                                                    .size = from_parameter<int>("COND_PARA_NUM")}));
-    m->add_component(entry<int>("COND_TEMP_SCALE_FUNCT_PARA_NUM",
+    m->add_component(parameter<std::vector<double>>(
+        "COND_PARA", {.description = "parameters for ionic conductivity",
+                         .default_value = std::vector<double>{},
+                         .size = from_parameter<int>("COND_PARA_NUM")}));
+    m->add_component(parameter<int>("COND_TEMP_SCALE_FUNCT_PARA_NUM",
         {.description = "number of parameters for temperature scaling of conductivity",
             .default_value = 0}));
-    m->add_component(entry<std::vector<double>>("COND_TEMP_SCALE_FUNCT_PARA",
+    m->add_component(parameter<std::vector<double>>("COND_TEMP_SCALE_FUNCT_PARA",
         {.description = "parameters for temperature scaling of conductivity",
             .default_value = std::vector<double>{},
             .size = from_parameter<int>("COND_TEMP_SCALE_FUNCT_PARA_NUM")}));
@@ -847,65 +858,66 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MAT_scl", "material parameters for space charge layers", Core::Materials::m_scl);
 
-    m->add_component(entry<double>("VALENCE", {.description = "valence/charge number"}));
-    m->add_component(entry<int>("DIFF_COEF_CONC_DEP_FUNCT",
+    m->add_component(parameter<double>("VALENCE", {.description = "valence/charge number"}));
+    m->add_component(parameter<int>("DIFF_COEF_CONC_DEP_FUNCT",
         {.description = "function number of function describing concentration dependence of "
                         "diffusion coefficient"}));
-    m->add_component(entry<int>("DIFF_COEF_TEMP_SCALE_FUNCT",
+    m->add_component(parameter<int>("DIFF_COEF_TEMP_SCALE_FUNCT",
         {.description =
                 "function number describing temperature scaling of diffusion coefficient"}));
     m->add_component(
-        entry<int>("TRANSNR", {.description = "curve number for transference number"}));
-    m->add_component(entry<int>(
+        parameter<int>("TRANSNR", {.description = "curve number for transference number"}));
+    m->add_component(parameter<int>(
         "COND_CONC_DEP_FUNCT", {.description = "function number of function describing "
                                                "concentration dependence of conductivity"}));
-    m->add_component(entry<int>("COND_TEMP_SCALE_FUNCT",
+    m->add_component(parameter<int>("COND_TEMP_SCALE_FUNCT",
         {.description = "function number describing temperature scaling of conductivity"}));
-    m->add_component(entry<int>("DIFF_PARA_NUM",
+    m->add_component(parameter<int>("DIFF_PARA_NUM",
         {.description = "number of parameters for diffusion coefficient", .default_value = 0}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "DIFF_PARA", {.description = "parameters for diffusion coefficient",
                          .default_value = std::vector<double>{},
                          .size = from_parameter<int>("DIFF_PARA_NUM")}));
-    m->add_component(entry<int>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA_NUM",
+    m->add_component(parameter<int>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA_NUM",
         {.description = "number of parameters for scaling function describing temperature "
                         "dependence of diffusion "
                         "coefficient",
             .default_value = 0}));
-    m->add_component(entry<std::vector<double>>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA",
+    m->add_component(parameter<std::vector<double>>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA",
         {.description = "parameters for function describing temperature dependence of diffusion "
                         "coefficient",
             .default_value = std::vector<double>{},
             .size = from_parameter<int>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA_NUM")}));
-    m->add_component(entry<int>("TRANS_PARA_NUM",
+    m->add_component(parameter<int>("TRANS_PARA_NUM",
         {.description = "number of parameters for transference number", .default_value = 0}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "TRANS_PARA", {.description = "parameters for transference number",
                           .default_value = std::vector<double>{},
                           .size = from_parameter<int>("TRANS_PARA_NUM")}));
-    m->add_component(entry<int>("COND_PARA_NUM",
+    m->add_component(parameter<int>("COND_PARA_NUM",
         {.description = "number of parameters for conductivity", .default_value = 0}));
-    m->add_component(
-        entry<std::vector<double>>("COND_PARA", {.description = "parameters for conductivity",
-                                                    .default_value = std::vector<double>{},
-                                                    .size = from_parameter<int>("COND_PARA_NUM")}));
-    m->add_component(entry<int>("COND_TEMP_SCALE_FUNCT_PARA_NUM",
+    m->add_component(parameter<std::vector<double>>(
+        "COND_PARA", {.description = "parameters for conductivity",
+                         .default_value = std::vector<double>{},
+                         .size = from_parameter<int>("COND_PARA_NUM")}));
+    m->add_component(parameter<int>("COND_TEMP_SCALE_FUNCT_PARA_NUM",
         {.description = "number of parameters for temperature scaling of conductivity",
             .default_value = 0}));
-    m->add_component(entry<std::vector<double>>("COND_TEMP_SCALE_FUNCT_PARA",
+    m->add_component(parameter<std::vector<double>>("COND_TEMP_SCALE_FUNCT_PARA",
         {.description = "parameters for temperature scaling of conductivity",
             .default_value = std::vector<double>{},
             .size = from_parameter<int>("COND_TEMP_SCALE_FUNCT_PARA_NUM")}));
-    m->add_component(entry<double>("MAX_CONC", {.description = "maximum cation concentration"}));
     m->add_component(
-        entry<int>("EXTRAPOL_DIFF", {.description = "strategy for extrapolation of diffusion "
-                                                    "coefficient below 0 and above MAX_CONC (-1: "
-                                                    "disabled, 0: constant)"}));
-    m->add_component(entry<double>("LIM_CONC",
+        parameter<double>("MAX_CONC", {.description = "maximum cation concentration"}));
+    m->add_component(parameter<int>(
+        "EXTRAPOL_DIFF", {.description = "strategy for extrapolation of diffusion "
+                                         "coefficient below 0 and above MAX_CONC (-1: "
+                                         "disabled, 0: constant)"}));
+    m->add_component(parameter<double>("LIM_CONC",
         {.description = "limiting concentration for extrapolation", .default_value = 1.0}));
-    m->add_component(entry<double>("BULK_CONC", {.description = "bulk ion concentration"}));
-    m->add_component(entry<double>("SUSCEPT", {.description = "susceptibility"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>("BULK_CONC", {.description = "bulk ion concentration"}));
+    m->add_component(parameter<double>("SUSCEPT", {.description = "susceptibility"}));
+    m->add_component(parameter<double>(
         "DELTA_NU", {.description = "difference of partial molar volumes (vacancy & cation)"}));
 
     Mat::append_material_definition(matlist, m);
@@ -919,56 +931,56 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "MAT_electrode", "electrode material", Core::Materials::m_electrode);
 
     // diffusivity and electronic conductivity
-    matelectrode->add_component(entry<int>("DIFF_COEF_CONC_DEP_FUNCT",
+    matelectrode->add_component(parameter<int>("DIFF_COEF_CONC_DEP_FUNCT",
         {.description = "function number of function describing concentration dependence of "
                         "diffusion coefficient"}));
-    matelectrode->add_component(entry<int>("DIFF_COEF_TEMP_SCALE_FUNCT",
+    matelectrode->add_component(parameter<int>("DIFF_COEF_TEMP_SCALE_FUNCT",
         {.description = "FUNCT number describing temperature scaling of diffusion coefficient"}));
-    matelectrode->add_component(entry<int>(
+    matelectrode->add_component(parameter<int>(
         "COND_CONC_DEP_FUNCT", {.description = "function number of function describing "
                                                "concentration dependence of conductivity"}));
-    matelectrode->add_component(entry<int>("COND_TEMP_SCALE_FUNCT",
+    matelectrode->add_component(parameter<int>("COND_TEMP_SCALE_FUNCT",
         {.description = "FUNCT number describing temperature scaling of conductivity"}));
 
     // optional parameters for concentration dependency of diffusivity and electronic conductivity
-    matelectrode->add_component(entry<int>("DIFF_PARA_NUM",
+    matelectrode->add_component(parameter<int>("DIFF_PARA_NUM",
         {.description = "number of parameters for diffusion coefficient", .default_value = 0}));
-    matelectrode->add_component(entry<std::vector<double>>(
+    matelectrode->add_component(parameter<std::vector<double>>(
         "DIFF_PARA", {.description = "parameters for diffusion coefficient",
                          .default_value = std::vector<double>{},
                          .size = from_parameter<int>("DIFF_PARA_NUM")}));
-    matelectrode->add_component(entry<int>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA_NUM",
+    matelectrode->add_component(parameter<int>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA_NUM",
         {.description = "number of parameters for scaling function describing temperature "
                         "dependence of diffusion "
                         "coefficient",
             .default_value = 0}));
-    matelectrode->add_component(entry<std::vector<double>>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA",
+    matelectrode->add_component(parameter<std::vector<double>>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA",
         {.description = "parameters for function describing temperature dependence of diffusion "
                         "coefficient",
             .default_value = std::vector<double>{},
             .size = from_parameter<int>("DIFF_COEF_TEMP_SCALE_FUNCT_PARA_NUM")}));
-    matelectrode->add_component(entry<int>("COND_PARA_NUM",
+    matelectrode->add_component(parameter<int>("COND_PARA_NUM",
         {.description = "number of parameters for electronic conductivity", .default_value = 0}));
-    matelectrode->add_component(entry<std::vector<double>>(
+    matelectrode->add_component(parameter<std::vector<double>>(
         "COND_PARA", {.description = "parameters for electronic conductivity",
                          .default_value = std::vector<double>{},
                          .size = from_parameter<int>("COND_PARA_NUM")}));
-    matelectrode->add_component(entry<int>("COND_TEMP_SCALE_FUNCT_PARA_NUM",
+    matelectrode->add_component(parameter<int>("COND_TEMP_SCALE_FUNCT_PARA_NUM",
         {.description = "number of parameters for temperature scaling of conductivity",
             .default_value = 0}));
-    matelectrode->add_component(entry<std::vector<double>>("COND_TEMP_SCALE_FUNCT_PARA",
+    matelectrode->add_component(parameter<std::vector<double>>("COND_TEMP_SCALE_FUNCT_PARA",
         {.description = "parameters for temperature scaling of conductivity",
             .default_value = std::vector<double>{},
             .size = from_parameter<int>("COND_TEMP_SCALE_FUNCT_PARA_NUM")}));
     // saturation value of intercalated Lithium concentration
-    matelectrode->add_component(entry<double>(
+    matelectrode->add_component(parameter<double>(
         "C_MAX", {.description = "saturation value of intercalated Lithium concentration"}));
 
     // lithiation value corresponding to saturation value of intercalated Lithium concentration
     matelectrode->add_component(
-        entry<double>("CHI_MAX", {.description = "lithiation value corresponding to saturation "
-                                                 "value of intercalated Lithium concentration "
-                                                 "'C_MAX'"}));
+        parameter<double>("CHI_MAX", {.description = "lithiation value corresponding to saturation "
+                                                     "value of intercalated Lithium concentration "
+                                                     "'C_MAX'"}));
 
     // model for half cell open circuit potential of electrode
     using namespace Core::IO::InputSpecBuilders;
@@ -978,7 +990,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
                 {
                     group("Function",
                         {
-                            entry<int>("OCP_FUNCT_NUM",
+                            parameter<int>("OCP_FUNCT_NUM",
                                 {
                                     .description = "function number of function that is used to "
                                                    "model the open circuit potential",
@@ -986,29 +998,29 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
                         }),
                     group("Redlich-Kister",
                         {
-                            entry<int>("OCP_PARA_NUM",
+                            parameter<int>("OCP_PARA_NUM",
                                 {
                                     .description = "number of parameters underlying half "
                                                    "cell open circuit potential model",
                                 }),
-                            entry<std::vector<double>>(
+                            parameter<std::vector<double>>(
                                 "OCP_PARA", {.description = "parameters underlying half cell open "
                                                             "circuit potential model",
                                                 .size = from_parameter<int>("OCP_PARA_NUM")}),
                         }),
                     group("Taralov",
                         {
-                            entry<std::vector<double>>(
+                            parameter<std::vector<double>>(
                                 "OCP_PARA", {.description = "parameters underlying half cell open "
                                                             "circuit potential model",
                                                 .size = 13}),
                         }),
                 },
                 store_index_as<Mat::PAR::OCPModels>("OCP_MODEL")),
-            entry<double>(
+            parameter<double>(
                 "X_MIN", {.description = "lower bound of range of validity as a fraction of "
                                          "C_MAX for ocp calculation model"}),
-            entry<double>(
+            parameter<double>(
                 "X_MAX", {.description = "upper bound of range of validity as a fraction of "
                                          "C_MAX for ocp calculation model"}),
         }));
@@ -1023,10 +1035,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_matlist",
         "list/collection of materials, i.e. material IDs", Core::Materials::m_matlist);
 
-    m->add_component(entry<bool>("LOCAL",
+    m->add_component(parameter<bool>("LOCAL",
         {.description = "individual materials allocated per element or only at global scope"}));
-    m->add_component(entry<int>("NUMMAT", {.description = "number of materials in list"}));
-    m->add_component(entry<std::vector<int>>(
+    m->add_component(parameter<int>("NUMMAT", {.description = "number of materials in list"}));
+    m->add_component(parameter<std::vector<int>>(
         "MATIDS", {.description = "the list material IDs", .size = from_parameter<int>("NUMMAT")}));
 
     Mat::append_material_definition(matlist, m);
@@ -1039,17 +1051,17 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "list/collection of materials, i.e. material IDs and list of reactions",
         Core::Materials::m_matlist_reactions);
 
-    m->add_component(entry<bool>("LOCAL",
+    m->add_component(parameter<bool>("LOCAL",
         {.description = "individual materials allocated per element or only at global scope"}));
-    m->add_component(entry<int>("NUMMAT", {.description = "number of materials in list"}));
-    m->add_component(entry<std::vector<int>>(
+    m->add_component(parameter<int>("NUMMAT", {.description = "number of materials in list"}));
+    m->add_component(parameter<std::vector<int>>(
         "MATIDS", {.description = "the list material IDs", .size = from_parameter<int>("NUMMAT")}));
     m->add_component(
-        entry<int>("NUMREAC", {.description = "number of reactions for these elements"}));
+        parameter<int>("NUMREAC", {.description = "number of reactions for these elements"}));
     m->add_component(
-        entry<std::vector<int>>("REACIDS", {.description = "advanced reaction list",
-                                               .default_value = std::vector{0},
-                                               .size = from_parameter<int>("NUMREAC")}));
+        parameter<std::vector<int>>("REACIDS", {.description = "advanced reaction list",
+                                                   .default_value = std::vector{0},
+                                                   .size = from_parameter<int>("NUMREAC")}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1061,16 +1073,17 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "list/collection of materials, i.e. material IDs and list of chemotactic pairs",
         Core::Materials::m_matlist_chemotaxis);
 
-    m->add_component(entry<bool>("LOCAL",
+    m->add_component(parameter<bool>("LOCAL",
         {.description = "individual materials allocated per element or only at global scope"}));
-    m->add_component(entry<int>("NUMMAT", {.description = "number of materials in list"}));
-    m->add_component(entry<std::vector<int>>(
+    m->add_component(parameter<int>("NUMMAT", {.description = "number of materials in list"}));
+    m->add_component(parameter<std::vector<int>>(
         "MATIDS", {.description = "the list material IDs", .size = from_parameter<int>("NUMMAT")}));
-    m->add_component(entry<int>("NUMPAIR", {.description = "number of pairs for these elements"}));
     m->add_component(
-        entry<std::vector<int>>("PAIRIDS", {.description = "chemotaxis pairs list",
-                                               .default_value = std::vector{0},
-                                               .size = from_parameter<int>("NUMPAIR")}));
+        parameter<int>("NUMPAIR", {.description = "number of pairs for these elements"}));
+    m->add_component(
+        parameter<std::vector<int>>("PAIRIDS", {.description = "chemotaxis pairs list",
+                                                   .default_value = std::vector{0},
+                                                   .size = from_parameter<int>("NUMPAIR")}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1082,22 +1095,23 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "list/collection of materials, i.e. material IDs and list of reactive/chemotactic pairs",
         Core::Materials::m_matlist_chemoreac);
 
-    m->add_component(entry<bool>("LOCAL",
+    m->add_component(parameter<bool>("LOCAL",
         {.description = "individual materials allocated per element or only at global scope"}));
-    m->add_component(entry<int>("NUMMAT", {.description = "number of materials in list"}));
-    m->add_component(entry<std::vector<int>>(
+    m->add_component(parameter<int>("NUMMAT", {.description = "number of materials in list"}));
+    m->add_component(parameter<std::vector<int>>(
         "MATIDS", {.description = "the list material IDs", .size = from_parameter<int>("NUMMAT")}));
-    m->add_component(entry<int>("NUMPAIR", {.description = "number of pairs for these elements"}));
     m->add_component(
-        entry<std::vector<int>>("PAIRIDS", {.description = "chemotaxis pairs list",
-                                               .default_value = std::vector{0},
-                                               .size = from_parameter<int>("NUMPAIR")}));
+        parameter<int>("NUMPAIR", {.description = "number of pairs for these elements"}));
+    m->add_component(
+        parameter<std::vector<int>>("PAIRIDS", {.description = "chemotaxis pairs list",
+                                                   .default_value = std::vector{0},
+                                                   .size = from_parameter<int>("NUMPAIR")}));
     m->add_component(
-        entry<int>("NUMREAC", {.description = "number of reactions for these elements"}));
+        parameter<int>("NUMREAC", {.description = "number of reactions for these elements"}));
     m->add_component(
-        entry<std::vector<int>>("REACIDS", {.description = "advanced reaction list",
-                                               .default_value = std::vector{0},
-                                               .size = from_parameter<int>("NUMREAC")}));
+        parameter<std::vector<int>>("REACIDS", {.description = "advanced reaction list",
+                                                   .default_value = std::vector{0},
+                                                   .size = from_parameter<int>("NUMREAC")}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1109,14 +1123,15 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "specific list/collection of species and phases for elch applications",
         Core::Materials::m_elchmat);
 
-    m->add_component(entry<bool>("LOCAL",
+    m->add_component(parameter<bool>("LOCAL",
         {.description = "individual materials allocated per element or only at global scope",
             .default_value = false}));
-    m->add_component(entry<int>("NUMDOF", {.description = "number of dof's per node"}));
+    m->add_component(parameter<int>("NUMDOF", {.description = "number of dof's per node"}));
     m->add_component(
-        entry<int>("NUMSCAL", {.description = "number of transported scalars per node"}));
-    m->add_component(entry<int>("NUMPHASE", {.description = "number of phases in electrolyte"}));
-    m->add_component(entry<std::vector<int>>("PHASEIDS",
+        parameter<int>("NUMSCAL", {.description = "number of transported scalars per node"}));
+    m->add_component(
+        parameter<int>("NUMPHASE", {.description = "number of phases in electrolyte"}));
+    m->add_component(parameter<std::vector<int>>("PHASEIDS",
         {.description = "the list phasel IDs", .size = from_parameter<int>("NUMPHASE")}));
 
     Mat::append_material_definition(matlist, m);
@@ -1129,14 +1144,15 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "material parameters for ion species in electrolyte solution",
         Core::Materials::m_elchphase);
 
-    m->add_component(entry<bool>("LOCAL",
+    m->add_component(parameter<bool>("LOCAL",
         {.description = "individual materials allocated per element or only at global scope",
             .default_value = false}));
-    m->add_component(entry<double>("EPSILON", {.description = "phase porosity"}));
+    m->add_component(parameter<double>("EPSILON", {.description = "phase porosity"}));
+    m->add_component(
+        parameter<double>("TORTUOSITY", {.description = "inverse (!) of phase tortuosity"}));
     m->add_component(
-        entry<double>("TORTUOSITY", {.description = "inverse (!) of phase tortuosity"}));
-    m->add_component(entry<int>("NUMMAT", {.description = "number of materials in electrolyte"}));
-    m->add_component(entry<std::vector<int>>(
+        parameter<int>("NUMMAT", {.description = "number of materials in electrolyte"}));
+    m->add_component(parameter<std::vector<int>>(
         "MATIDS", {.description = "the list phasel IDs", .size = from_parameter<int>("NUMMAT")}));
 
     Mat::append_material_definition(matlist, m);
@@ -1148,9 +1164,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_Struct_StVenantKirchhoff",
         "St.Venant--Kirchhoff material", Core::Materials::m_stvenant);
 
-    m->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
-    m->add_component(entry<double>("NUE", {.description = "Poisson's ratio"}));
-    m->add_component(entry<double>("DENS", {.description = "mass density"}));
+    m->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
+    m->add_component(parameter<double>("NUE", {.description = "Poisson's ratio"}));
+    m->add_component(parameter<double>("DENS", {.description = "mass density"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1161,20 +1177,20 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_Struct_ThermoStVenantK",
         "Thermo St.Venant--Kirchhoff material", Core::Materials::m_thermostvenant);
 
-    m->add_component(
-        entry<int>("YOUNGNUM", {.description = "number of Young's modulus in list (if 1 Young is "
-                                               "const, if >1 Young is temperature) "
-                                               "dependent"}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<int>(
+        "YOUNGNUM", {.description = "number of Young's modulus in list (if 1 Young is "
+                                    "const, if >1 Young is temperature) "
+                                    "dependent"}));
+    m->add_component(parameter<std::vector<double>>(
         "YOUNG", {.description = "Young's modulus", .size = from_parameter<int>("YOUNGNUM")}));
-    m->add_component(entry<double>("NUE", {.description = "Poisson's ratio"}));
-    m->add_component(entry<double>("DENS", {.description = "mass density"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>("NUE", {.description = "Poisson's ratio"}));
+    m->add_component(parameter<double>("DENS", {.description = "mass density"}));
+    m->add_component(parameter<double>(
         "THEXPANS", {.description = "constant coefficient of linear thermal expansion"}));
-    m->add_component(entry<double>("CAPA", {.description = "capacity"}));
-    m->add_component(entry<double>("CONDUCT", {.description = "conductivity"}));
-    m->add_component(entry<double>("INITTEMP", {.description = "initial temperature"}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<double>("CAPA", {.description = "capacity"}));
+    m->add_component(parameter<double>("CONDUCT", {.description = "conductivity"}));
+    m->add_component(parameter<double>("INITTEMP", {.description = "initial temperature"}));
+    m->add_component(parameter<int>(
         "THERMOMAT", {.description = "mat id of thermal material part", .default_value = -1}));
 
     Mat::append_material_definition(matlist, m);
@@ -1185,18 +1201,19 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_Struct_DruckerPrager",
         "elastic St.Venant Kirchhoff / plastic drucker prager", Core::Materials::m_pldruckprag);
 
-    m->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
-    m->add_component(entry<double>("NUE", {.description = "Poisson's ratio"}));
-    m->add_component(entry<double>("DENS", {.description = "Density"}));
-    m->add_component(entry<double>("ISOHARD", {.description = "linear isotropic hardening"}));
-    m->add_component(entry<double>("TOL", {.description = "Local Newton iteration tolerance"}));
-    m->add_component(entry<double>("C", {.description = "cohesion"}));
-    m->add_component(entry<double>("ETA", {.description = "Drucker Prager Constant Eta"}));
-    m->add_component(entry<double>("XI", {.description = "Drucker Prager Constant Xi"}));
-    m->add_component(entry<double>("ETABAR", {.description = "Drucker Prager Constant Etabar"}));
-    m->add_component(entry<std::string>("TANG",
+    m->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
+    m->add_component(parameter<double>("NUE", {.description = "Poisson's ratio"}));
+    m->add_component(parameter<double>("DENS", {.description = "Density"}));
+    m->add_component(parameter<double>("ISOHARD", {.description = "linear isotropic hardening"}));
+    m->add_component(parameter<double>("TOL", {.description = "Local Newton iteration tolerance"}));
+    m->add_component(parameter<double>("C", {.description = "cohesion"}));
+    m->add_component(parameter<double>("ETA", {.description = "Drucker Prager Constant Eta"}));
+    m->add_component(parameter<double>("XI", {.description = "Drucker Prager Constant Xi"}));
+    m->add_component(
+        parameter<double>("ETABAR", {.description = "Drucker Prager Constant Etabar"}));
+    m->add_component(parameter<std::string>("TANG",
         {.description = "Method to compute the material tangent", .default_value = "consistent"}));
-    m->add_component(entry<int>("MAXITER",
+    m->add_component(parameter<int>("MAXITER",
         {.description = "Maximum Iterations for local Neutron Raphson", .default_value = 50}));
 
     Mat::append_material_definition(matlist, m);
@@ -1209,24 +1226,25 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "Thermo-elastic St.Venant Kirchhoff / plastic von Mises material",
         Core::Materials::m_thermopllinelast);
 
-    m->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
-    m->add_component(entry<double>("NUE", {.description = "Poisson's ratio"}));
-    m->add_component(entry<double>("DENS", {.description = "mass density"}));
+    m->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
+    m->add_component(parameter<double>("NUE", {.description = "Poisson's ratio"}));
+    m->add_component(parameter<double>("DENS", {.description = "mass density"}));
     m->add_component(
-        entry<double>("THEXPANS", {.description = "coefficient of linear thermal expansion"}));
-    m->add_component(entry<double>("INITTEMP", {.description = "initial temperature"}));
-    m->add_component(entry<double>("YIELD", {.description = "yield stress"}));
-    m->add_component(entry<double>("ISOHARD", {.description = "isotropic hardening modulus"}));
-    m->add_component(entry<double>("KINHARD", {.description = "kinematic hardening modulus"}));
+        parameter<double>("THEXPANS", {.description = "coefficient of linear thermal expansion"}));
+    m->add_component(parameter<double>("INITTEMP", {.description = "initial temperature"}));
+    m->add_component(parameter<double>("YIELD", {.description = "yield stress"}));
+    m->add_component(parameter<double>("ISOHARD", {.description = "isotropic hardening modulus"}));
+    m->add_component(parameter<double>("KINHARD", {.description = "kinematic hardening modulus"}));
     m->add_component(
-        entry<int>("SAMPLENUM", {.description = "number of stress-strain pairs in list"}));
-    m->add_component(entry<std::vector<double>>(
+        parameter<int>("SAMPLENUM", {.description = "number of stress-strain pairs in list"}));
+    m->add_component(parameter<std::vector<double>>(
         "SIGMA_Y", {.description = "yield stress", .size = from_parameter<int>("SAMPLENUM")}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "EPSBAR_P", {.description = "accumulated plastic strain corresponding to SIGMA_Y",
                         .size = from_parameter<int>("SAMPLENUM")}));
-    m->add_component(entry<double>("TOL", {.description = "tolerance for local Newton iteration"}));
-    m->add_component(entry<int>(
+    m->add_component(
+        parameter<double>("TOL", {.description = "tolerance for local Newton iteration"}));
+    m->add_component(parameter<int>(
         "THERMOMAT", {.description = "mat id of thermal material part", .default_value = -1}));
 
     Mat::append_material_definition(matlist, m);
@@ -1238,30 +1256,34 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_Struct_PlasticGTN",
         "elastic St.Venant Kirchhoff / plastic GTN", Core::Materials::m_plgtn);
 
-    m->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
-    m->add_component(entry<double>("NUE", {.description = "Poisson's ratio"}));
-    m->add_component(entry<double>("DENS", {.description = "Density"}));
-    m->add_component(entry<double>("YIELD", {.description = "yield stress"}));
-    m->add_component(entry<double>("ISOHARD", {.description = "linear isotropic hardening"}));
-    m->add_component(entry<int>("HARDENING_FUNC",
+    m->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
+    m->add_component(parameter<double>("NUE", {.description = "Poisson's ratio"}));
+    m->add_component(parameter<double>("DENS", {.description = "Density"}));
+    m->add_component(parameter<double>("YIELD", {.description = "yield stress"}));
+    m->add_component(parameter<double>("ISOHARD", {.description = "linear isotropic hardening"}));
+    m->add_component(parameter<int>("HARDENING_FUNC",
         {.description = "Function number for isotropic hardening", .default_value = 0}));
-    m->add_component(entry<double>("TOL", {.description = "Local Newton iteration tolerance"}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<double>("TOL", {.description = "Local Newton iteration tolerance"}));
+    m->add_component(parameter<int>(
         "MAXITER", {.description = "Maximum Neutron Raphson Iterations", .default_value = 50}));
-    m->add_component(entry<double>("K1", {.description = "GTN Constant k1"}));
-    m->add_component(entry<double>("K2", {.description = "GTN Constant k2"}));
-    m->add_component(entry<double>("K3", {.description = "GTN constant k3"}));
-    m->add_component(entry<double>("F0", {.description = "GTN constant f0 for initial damage"}));
-    m->add_component(entry<double>("FN", {.description = "GTN constant fN for damage nucleation"}));
-    m->add_component(entry<double>("EN", {.description = "GTN constant eN for damage nucleation"}));
-    m->add_component(entry<double>("SN", {.description = "GTN constant sN for damage nucleation"}));
+    m->add_component(parameter<double>("K1", {.description = "GTN Constant k1"}));
+    m->add_component(parameter<double>("K2", {.description = "GTN Constant k2"}));
+    m->add_component(parameter<double>("K3", {.description = "GTN constant k3"}));
+    m->add_component(
+        parameter<double>("F0", {.description = "GTN constant f0 for initial damage"}));
+    m->add_component(
+        parameter<double>("FN", {.description = "GTN constant fN for damage nucleation"}));
     m->add_component(
-        entry<double>("FC", {.description = "GTN constant fC for damage coalescence"}));
+        parameter<double>("EN", {.description = "GTN constant eN for damage nucleation"}));
     m->add_component(
-        entry<double>("KAPPA", {.description = "GTN constant kappa for damage coalescence"}));
+        parameter<double>("SN", {.description = "GTN constant sN for damage nucleation"}));
     m->add_component(
-        entry<double>("EF", {.description = "GTN stabilization parameter ef for damage coalescence",
-                                .default_value = 0.0}));
+        parameter<double>("FC", {.description = "GTN constant fC for damage coalescence"}));
+    m->add_component(
+        parameter<double>("KAPPA", {.description = "GTN constant kappa for damage coalescence"}));
+    m->add_component(parameter<double>(
+        "EF", {.description = "GTN stabilization parameter ef for damage coalescence",
+                  .default_value = 0.0}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1272,51 +1294,51 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_Struct_SuperElastSMA",
         "finite strain superelastic shape memory alloy", Core::Materials::m_superelast);
 
-    m->add_component(entry<double>("DENS", {.description = "mass density"}));
-    m->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
-    m->add_component(entry<double>("NUE", {.description = "Poisson's ratio"}));
-    m->add_component(
-        entry<double>("EPSILON_L", {.description = "parameter representing the maximum deformation "
-                                                   "obtainable only by detwinning of the "
-                                                   "multiple-variant martensite"}));
+    m->add_component(parameter<double>("DENS", {.description = "mass density"}));
+    m->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
+    m->add_component(parameter<double>("NUE", {.description = "Poisson's ratio"}));
+    m->add_component(parameter<double>(
+        "EPSILON_L", {.description = "parameter representing the maximum deformation "
+                                     "obtainable only by detwinning of the "
+                                     "multiple-variant martensite"}));
     m->add_component(
-        entry<double>("T_AS_s", {.description = "Temperature at which the phase transformation "
-                                                "from austenite to martensite starts"}));
+        parameter<double>("T_AS_s", {.description = "Temperature at which the phase transformation "
+                                                    "from austenite to martensite starts"}));
     m->add_component(
-        entry<double>("T_AS_f", {.description = "Temperature at which the phase transformation "
-                                                "from austenite to martensite finishes"}));
+        parameter<double>("T_AS_f", {.description = "Temperature at which the phase transformation "
+                                                    "from austenite to martensite finishes"}));
     m->add_component(
-        entry<double>("T_SA_s", {.description = "Temperature at which the phase transformation "
-                                                "from martensite to autenite starts"}));
+        parameter<double>("T_SA_s", {.description = "Temperature at which the phase transformation "
+                                                    "from martensite to autenite starts"}));
     m->add_component(
-        entry<double>("T_SA_f", {.description = "Temperature at which the phase transformation "
-                                                "from martensite to autenite finishes"}));
-    m->add_component(entry<double>(
+        parameter<double>("T_SA_f", {.description = "Temperature at which the phase transformation "
+                                                    "from martensite to autenite finishes"}));
+    m->add_component(parameter<double>(
         "C_AS", {.description = "Coefficient of the linear temperature dependence of T_AS"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "C_SA", {.description = "Coefficient of the linear temperature dependence of T_SA"}));
-    m->add_component(entry<double>("SIGMA_AS_s",
+    m->add_component(parameter<double>("SIGMA_AS_s",
         {.description =
                 "stress at which the phase transformation from austenite to martensite begins"}));
-    m->add_component(entry<double>("SIGMA_AS_f",
+    m->add_component(parameter<double>("SIGMA_AS_f",
         {.description =
                 "stress at which the phase transformation from austenite to martensite finishes"}));
-    m->add_component(entry<double>("SIGMA_SA_s",
+    m->add_component(parameter<double>("SIGMA_SA_s",
         {.description =
                 "stress at which the phase transformation from martensite to austenite begins"}));
-    m->add_component(entry<double>("SIGMA_SA_f",
+    m->add_component(parameter<double>("SIGMA_SA_f",
         {.description =
                 "stress at which the phase transformation from martensite to austenite finishes"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "ALPHA", {.description = "pressure dependency in the drucker-prager-type loading"}));
-    m->add_component(entry<int>("MODEL",
+    m->add_component(parameter<int>("MODEL",
         {.description =
                 "Model used for the evolution of martensitic fraction (1=exponential; 2=linear)"}));
-    m->add_component(entry<double>("BETA_AS",
+    m->add_component(parameter<double>("BETA_AS",
         {.description =
                 "parameter, measuring the speed of the transformation from austenite to martensite",
             .default_value = 0.}));
-    m->add_component(entry<double>("BETA_SA",
+    m->add_component(parameter<double>("BETA_SA",
         {.description =
                 "parameter, measuring the speed of the transformation from martensite to austenite",
             .default_value = 0.}));
@@ -1333,28 +1355,28 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "with linear and exponential isotropic hardening",
         Core::Materials::m_thermoplhyperelast);
 
-    m->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
-    m->add_component(entry<double>("NUE", {.description = "Poisson's ratio"}));
-    m->add_component(entry<double>("DENS", {.description = "mass density"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
+    m->add_component(parameter<double>("NUE", {.description = "Poisson's ratio"}));
+    m->add_component(parameter<double>("DENS", {.description = "mass density"}));
+    m->add_component(parameter<double>(
         "CTE", {.description = "coefficient of thermal expansion", .default_value = 0.}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "INITTEMP", {.description = "initial, reference temperature", .default_value = 0.}));
-    m->add_component(entry<double>("YIELD", {.description = "initial yield stress"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>("YIELD", {.description = "initial yield stress"}));
+    m->add_component(parameter<double>(
         "ISOHARD", {.description = "linear isotropic hardening modulus", .default_value = 0.}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "SATHARDENING", {.description = "saturation hardening", .default_value = 0.}));
     m->add_component(
-        entry<double>("HARDEXPO", {.description = "hardening exponent", .default_value = 0.}));
-    m->add_component(entry<double>(
+        parameter<double>("HARDEXPO", {.description = "hardening exponent", .default_value = 0.}));
+    m->add_component(parameter<double>(
         "YIELDSOFT", {.description = "thermal yield stress softening", .default_value = 0.}));
-    m->add_component(entry<double>("HARDSOFT",
+    m->add_component(parameter<double>("HARDSOFT",
         {.description = "thermal hardening softening (acting on SATHARDENING and ISOHARD)",
             .default_value = 0.}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "TOL", {.description = "tolerance for local Newton iteration", .default_value = 1.e-8}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<int>(
         "THERMOMAT", {.description = "mat id of thermal material part", .default_value = -1}));
 
     Mat::append_material_definition(matlist, m);
@@ -1370,22 +1392,23 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "(VARFUNCTION using the variable epsp)",
         Core::Materials::m_plnlnlogneohooke);
 
-    m->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
-    m->add_component(entry<double>("NUE", {.description = "Poisson's ratio"}));
-    m->add_component(entry<double>("DENS", {.description = "mass density"}));
-    m->add_component(entry<double>("YIELD", {.description = "yield stress", .default_value = 0}));
-    m->add_component(entry<double>(
-        "ISOHARD", {.description = "isotropic hardening modulus", .default_value = 0}));
+    m->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
+    m->add_component(parameter<double>("NUE", {.description = "Poisson's ratio"}));
+    m->add_component(parameter<double>("DENS", {.description = "mass density"}));
     m->add_component(
-        entry<double>("SATHARDENING", {.description = "saturation hardening", .default_value = 0}));
-    m->add_component(entry<double>(
+        parameter<double>("YIELD", {.description = "yield stress", .default_value = 0}));
+    m->add_component(parameter<double>(
+        "ISOHARD", {.description = "isotropic hardening modulus", .default_value = 0}));
+    m->add_component(parameter<double>(
+        "SATHARDENING", {.description = "saturation hardening", .default_value = 0}));
+    m->add_component(parameter<double>(
         "HARDEXPO", {.description = "linear hardening exponent", .default_value = 0}));
-    m->add_component(entry<double>("VISC", {.description = "VISCOSITY", .default_value = 0.}));
-    m->add_component(
-        entry<double>("RATE_DEPENDENCY", {.description = "rate dependency", .default_value = 0.}));
-    m->add_component(entry<double>("TOL",
+    m->add_component(parameter<double>("VISC", {.description = "VISCOSITY", .default_value = 0.}));
+    m->add_component(parameter<double>(
+        "RATE_DEPENDENCY", {.description = "rate dependency", .default_value = 0.}));
+    m->add_component(parameter<double>("TOL",
         {.description = "Tolerance for local Newton-Raphson iteration", .default_value = 1.e-08}));
-    m->add_component(entry<int>("HARDENING_FUNC",
+    m->add_component(parameter<int>("HARDENING_FUNC",
         {.description = "Function number for isotropic hardening", .default_value = 0}));
 
     Mat::append_material_definition(matlist, m);
@@ -1399,15 +1422,16 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "with linear isotropic and kineamtic hardening",
         Core::Materials::m_pllinelast);
 
-    m->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
-    m->add_component(entry<double>("NUE", {.description = "Poisson's ratio"}));
-    m->add_component(entry<double>("DENS", {.description = "mass density"}));
-    m->add_component(entry<double>("YIELD", {.description = "yield stress"}));
+    m->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
+    m->add_component(parameter<double>("NUE", {.description = "Poisson's ratio"}));
+    m->add_component(parameter<double>("DENS", {.description = "mass density"}));
+    m->add_component(parameter<double>("YIELD", {.description = "yield stress"}));
     m->add_component(
-        entry<double>("ISOHARD", {.description = "linear isotropic hardening modulus"}));
+        parameter<double>("ISOHARD", {.description = "linear isotropic hardening modulus"}));
     m->add_component(
-        entry<double>("KINHARD", {.description = "linear kinematic hardening modulus"}));
-    m->add_component(entry<double>("TOL", {.description = "tolerance for local Newton iteration"}));
+        parameter<double>("KINHARD", {.description = "linear kinematic hardening modulus"}));
+    m->add_component(
+        parameter<double>("TOL", {.description = "tolerance for local Newton iteration"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1420,26 +1444,27 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::m_vp_no_yield_surface);
 
     // elasticity parameters
-    m->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
-    m->add_component(entry<double>("NUE", {.description = "Poisson's ratio"}));
-    m->add_component(entry<double>("DENS", {.description = "material mass density"}));
+    m->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
+    m->add_component(parameter<double>("NUE", {.description = "Poisson's ratio"}));
+    m->add_component(parameter<double>("DENS", {.description = "material mass density"}));
     // visco-plasticity parameters
-    m->add_component(entry<double>("TEMPERATURE", {.description = "temperature in Kelvin"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>("TEMPERATURE", {.description = "temperature in Kelvin"}));
+    m->add_component(parameter<double>(
         "PRE_EXP_FAC", {.description = "pre-exponential factor of plastic shear strain rate 'A'"}));
-    m->add_component(entry<double>("ACTIVATION_ENERGY", {.description = "activation energy 'Q'"}));
-    m->add_component(entry<double>("GAS_CONSTANT", {.description = "gas constant 'R'"}));
-    m->add_component(
-        entry<double>("STRAIN_RATE_SENS", {.description = "strain-rate-sensitivity 'm'"}));
     m->add_component(
-        entry<double>("INIT_FLOW_RES", {.description = "initial isotropic flow resistance 'S^0'"}));
+        parameter<double>("ACTIVATION_ENERGY", {.description = "activation energy 'Q'"}));
+    m->add_component(parameter<double>("GAS_CONSTANT", {.description = "gas constant 'R'"}));
     m->add_component(
-        entry<double>("FLOW_RES_PRE_FAC", {.description = "flow resistance factor 'H_0'"}));
+        parameter<double>("STRAIN_RATE_SENS", {.description = "strain-rate-sensitivity 'm'"}));
+    m->add_component(parameter<double>(
+        "INIT_FLOW_RES", {.description = "initial isotropic flow resistance 'S^0'"}));
     m->add_component(
-        entry<double>("FLOW_RES_EXP", {.description = "flow resistance exponential value 'a'"}));
-    m->add_component(entry<double>(
+        parameter<double>("FLOW_RES_PRE_FAC", {.description = "flow resistance factor 'H_0'"}));
+    m->add_component(parameter<double>(
+        "FLOW_RES_EXP", {.description = "flow resistance exponential value 'a'"}));
+    m->add_component(parameter<double>(
         "FLOW_RES_SAT_FAC", {.description = "flow resistance saturation factor 'S_*'"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "FLOW_RES_SAT_EXP", {.description = "flow resistance saturation exponent 'b'"}));
 
     Mat::append_material_definition(matlist, m);
@@ -1451,34 +1476,36 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MAT_Struct_Robinson", "Robinson's visco-plastic material", Core::Materials::m_vp_robinson);
 
-    m->add_component(entry<std::string>(
+    m->add_component(parameter<std::string>(
         "KIND", {.description = "kind of Robinson material: "
                                 "Butler, Arya, Arya_NarloyZ (default), Arya_CrMoSteel"}));
-    m->add_component(entry<int>("YOUNGNUM", {.description = "number of Young's modulus in list"}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(
+        parameter<int>("YOUNGNUM", {.description = "number of Young's modulus in list"}));
+    m->add_component(parameter<std::vector<double>>(
         "YOUNG", {.description = "Young's modulus", .size = from_parameter<int>("YOUNGNUM")}));
-    m->add_component(entry<double>("NUE", {.description = "Poisson's ratio"}));
-    m->add_component(entry<double>("DENS", {.description = "mass density"}));
-    m->add_component(
-        entry<double>("THEXPANS", {.description = "coefficient of linear thermal expansion"}));
-    m->add_component(entry<double>("INITTEMP", {.description = "initial temperature"}));
-    m->add_component(entry<double>("HRDN_FACT", {.description = "hardening factor 'A'"}));
-    m->add_component(entry<double>("HRDN_EXPO", {.description = "hardening power 'n'"}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<double>("NUE", {.description = "Poisson's ratio"}));
+    m->add_component(parameter<double>("DENS", {.description = "mass density"}));
+    m->add_component(
+        parameter<double>("THEXPANS", {.description = "coefficient of linear thermal expansion"}));
+    m->add_component(parameter<double>("INITTEMP", {.description = "initial temperature"}));
+    m->add_component(parameter<double>("HRDN_FACT", {.description = "hardening factor 'A'"}));
+    m->add_component(parameter<double>("HRDN_EXPO", {.description = "hardening power 'n'"}));
+    m->add_component(parameter<int>(
         "SHRTHRSHLDNUM", {.description = "number of shear stress threshold 'K^2'in list"}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "SHRTHRSHLD", {.description = "Bingam-Prager shear stress threshold 'K^2'",
                           .size = from_parameter<int>("SHRTHRSHLDNUM")}));
-    m->add_component(entry<double>("RCVRY", {.description = "recovery factor 'R_0'"}));
-    m->add_component(entry<double>("ACTV_ERGY", {.description = "activation energy 'Q_0'"}));
-    m->add_component(entry<double>("ACTV_TMPR", {.description = "activation temperature 'T_0'"}));
-    m->add_component(entry<double>("G0", {.description = "'G_0'"}));
-    m->add_component(entry<double>("M_EXPO", {.description = "'m'"}));
-    m->add_component(entry<int>("BETANUM", {.description = "number of 'beta' in list"}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<double>("RCVRY", {.description = "recovery factor 'R_0'"}));
+    m->add_component(parameter<double>("ACTV_ERGY", {.description = "activation energy 'Q_0'"}));
+    m->add_component(
+        parameter<double>("ACTV_TMPR", {.description = "activation temperature 'T_0'"}));
+    m->add_component(parameter<double>("G0", {.description = "'G_0'"}));
+    m->add_component(parameter<double>("M_EXPO", {.description = "'m'"}));
+    m->add_component(parameter<int>("BETANUM", {.description = "number of 'beta' in list"}));
+    m->add_component(parameter<std::vector<double>>(
         "BETA", {.description = "beta", .size = from_parameter<int>("BETANUM")}));
-    m->add_component(entry<double>("H_FACT", {.description = "'H'"}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<double>("H_FACT", {.description = "'H'"}));
+    m->add_component(parameter<int>(
         "THERMOMAT", {.description = "mat id of thermal material part", .default_value = -1}));
 
     Mat::append_material_definition(matlist, m);
@@ -1490,28 +1517,29 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_Struct_Damage",
         "elasto-plastic von Mises material with ductile damage", Core::Materials::m_elpldamage);
 
-    m->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
-    m->add_component(entry<double>("NUE", {.description = "Poisson's ratio"}));
-    m->add_component(entry<double>("DENS", {.description = "mass density"}));
+    m->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
+    m->add_component(parameter<double>("NUE", {.description = "Poisson's ratio"}));
+    m->add_component(parameter<double>("DENS", {.description = "mass density"}));
     m->add_component(
-        entry<int>("SAMPLENUM", {.description = "number of stress-strain pairs in list"}));
-    m->add_component(entry<std::vector<double>>(
+        parameter<int>("SAMPLENUM", {.description = "number of stress-strain pairs in list"}));
+    m->add_component(parameter<std::vector<double>>(
         "SIGMA_Y", {.description = "yield stress", .size = from_parameter<int>("SAMPLENUM")}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "EPSBAR_P", {.description = "accumulated plastic strain corresponding to SIGMA_Y",
                         .size = from_parameter<int>("SAMPLENUM")}));
     m->add_component(
-        entry<double>("DAMDEN", {.description = "denominator of damage evaluations law"}));
+        parameter<double>("DAMDEN", {.description = "denominator of damage evaluations law"}));
     m->add_component(
-        entry<double>("DAMEXP", {.description = "exponent of damage evaluations law"}));
-    m->add_component(entry<double>("DAMTHRESHOLD", {.description = "damage threshold"}));
-    m->add_component(entry<double>(
+        parameter<double>("DAMEXP", {.description = "exponent of damage evaluations law"}));
+    m->add_component(parameter<double>("DAMTHRESHOLD", {.description = "damage threshold"}));
+    m->add_component(parameter<double>(
         "KINHARD", {.description = "kinematic hardening modulus, stress-like variable"}));
+    m->add_component(parameter<double>(
+        "KINHARD_REC", {.description = "recovery factor, scalar-valued variable"}));
+    m->add_component(parameter<double>("SATHARDENING", {.description = "saturation hardening"}));
+    m->add_component(parameter<double>("HARDEXPO", {.description = "hardening exponent"}));
     m->add_component(
-        entry<double>("KINHARD_REC", {.description = "recovery factor, scalar-valued variable"}));
-    m->add_component(entry<double>("SATHARDENING", {.description = "saturation hardening"}));
-    m->add_component(entry<double>("HARDEXPO", {.description = "hardening exponent"}));
-    m->add_component(entry<double>("TOL", {.description = "tolerance for local Newton iteration"}));
+        parameter<double>("TOL", {.description = "tolerance for local Newton iteration"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1523,10 +1551,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "aneurysm wall material according to Raghavan and Vorp [2000]",
         Core::Materials::m_aaaneohooke);
 
-    m->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
-    m->add_component(entry<double>("BETA", {.description = "2nd parameter"}));
-    m->add_component(entry<double>("NUE", {.description = "Poisson's ratio"}));
-    m->add_component(entry<double>("DENS", {.description = "mass density"}));
+    m->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
+    m->add_component(parameter<double>("BETA", {.description = "2nd parameter"}));
+    m->add_component(parameter<double>("NUE", {.description = "Poisson's ratio"}));
+    m->add_component(parameter<double>("DENS", {.description = "mass density"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1537,12 +1565,12 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
   {
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_VISCONEOHOOKE",
         "visco-elastic neo-Hookean material law", Core::Materials::m_visconeohooke);
-    m->add_component(entry<double>("YOUNGS_SLOW", {.description = "???"}));
-    m->add_component(entry<double>("POISSON", {.description = "???"}));
-    m->add_component(entry<double>("DENS", {.description = "???"}));
-    m->add_component(entry<double>("YOUNGS_FAST", {.description = "???"}));
-    m->add_component(entry<double>("RELAX", {.description = "???"}));
-    m->add_component(entry<double>("THETA", {.description = "???"}));
+    m->add_component(parameter<double>("YOUNGS_SLOW", {.description = "???"}));
+    m->add_component(parameter<double>("POISSON", {.description = "???"}));
+    m->add_component(parameter<double>("DENS", {.description = "???"}));
+    m->add_component(parameter<double>("YOUNGS_FAST", {.description = "???"}));
+    m->add_component(parameter<double>("RELAX", {.description = "???"}));
+    m->add_component(parameter<double>("THETA", {.description = "???"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1553,22 +1581,24 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_VISCOANISO",
         "visco-elastic anisotropic fibre material law", Core::Materials::m_viscoanisotropic);
 
-    m->add_component(entry<double>("KAPPA", {.description = "dilatation modulus"}));
-    m->add_component(entry<double>("MUE", {.description = "Shear Modulus"}));
-    m->add_component(entry<double>("DENS", {.description = "Density"}));
-    m->add_component(entry<double>("K1", {.description = "Parameter for linear fiber stiffness"}));
+    m->add_component(parameter<double>("KAPPA", {.description = "dilatation modulus"}));
+    m->add_component(parameter<double>("MUE", {.description = "Shear Modulus"}));
+    m->add_component(parameter<double>("DENS", {.description = "Density"}));
+    m->add_component(
+        parameter<double>("K1", {.description = "Parameter for linear fiber stiffness"}));
     m->add_component(
-        entry<double>("K2", {.description = "Parameter for exponential fiber stiffness"}));
-    m->add_component(entry<double>("GAMMA", {.description = "angle between fibers"}));
-    m->add_component(entry<double>(
+        parameter<double>("K2", {.description = "Parameter for exponential fiber stiffness"}));
+    m->add_component(parameter<double>("GAMMA", {.description = "angle between fibers"}));
+    m->add_component(parameter<double>(
         "BETA_ISO", {.description = "ratio between elasticities in generalized Maxweel body"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "BETA_ANISO", {.description = "ratio between elasticities in generalized Maxweel body"}));
-    m->add_component(entry<double>("RELAX_ISO", {.description = "isotropic relaxation time"}));
-    m->add_component(entry<double>("RELAX_ANISO", {.description = "anisotropic relaxation time"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>("RELAX_ISO", {.description = "isotropic relaxation time"}));
+    m->add_component(
+        parameter<double>("RELAX_ANISO", {.description = "anisotropic relaxation time"}));
+    m->add_component(parameter<double>(
         "MINSTRETCH", {.description = "minimal principal stretch fibers do respond to"}));
-    m->add_component(entry<int>("ELETHICKDIR",
+    m->add_component(parameter<int>("ELETHICKDIR",
         {.description = "Element thickness direction applies also to fibers (only sosh)"}));
 
     Mat::append_material_definition(matlist, m);
@@ -1582,12 +1612,12 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "simulation",
         Core::Materials::m_struct_multiscale);
 
-    m->add_component(entry<std::string>("MICROFILE",
+    m->add_component(parameter<std::string>("MICROFILE",
         {.description = "inputfile for microstructure", .default_value = "filename.dat"}));
     m->add_component(
-        entry<int>("MICRODIS_NUM", {.description = "Number of microscale discretization"}));
-    m->add_component(
-        entry<double>("INITVOL", {.description = "Initial volume of RVE", .default_value = 0.0}));
+        parameter<int>("MICRODIS_NUM", {.description = "Number of microscale discretization"}));
+    m->add_component(parameter<double>(
+        "INITVOL", {.description = "Initial volume of RVE", .default_value = 0.0}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1600,11 +1630,11 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::m_elasthyper);
 
     m->add_component(
-        entry<int>("NUMMAT", {.description = "number of materials/potentials in list"}));
-    m->add_component(entry<std::vector<int>>("MATIDS",
+        parameter<int>("NUMMAT", {.description = "number of materials/potentials in list"}));
+    m->add_component(parameter<std::vector<int>>("MATIDS",
         {.description = "the list material/potential IDs", .size = from_parameter<int>("NUMMAT")}));
-    m->add_component(entry<double>("DENS", {.description = "material mass density"}));
-    m->add_component(entry<int>("POLYCONVEX",
+    m->add_component(parameter<double>("DENS", {.description = "material mass density"}));
+    m->add_component(parameter<int>("POLYCONVEX",
         {.description = "1.0 if polyconvexity of system is checked", .default_value = 0.}));
 
     Mat::append_material_definition(matlist, m);
@@ -1618,11 +1648,11 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::m_viscoelasthyper);
 
     m->add_component(
-        entry<int>("NUMMAT", {.description = "number of materials/potentials in list"}));
-    m->add_component(entry<std::vector<int>>("MATIDS",
+        parameter<int>("NUMMAT", {.description = "number of materials/potentials in list"}));
+    m->add_component(parameter<std::vector<int>>("MATIDS",
         {.description = "the list material/potential IDs", .size = from_parameter<int>("NUMMAT")}));
-    m->add_component(entry<double>("DENS", {.description = "material mass density"}));
-    m->add_component(entry<int>("POLYCONVEX",
+    m->add_component(parameter<double>("DENS", {.description = "material mass density"}));
+    m->add_component(parameter<int>("POLYCONVEX",
         {.description = "1.0 if polyconvexity of system is checked", .default_value = 0.}));
 
     Mat::append_material_definition(matlist, m);
@@ -1636,67 +1666,67 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::m_plelasthyper);
 
     m->add_component(
-        entry<int>("NUMMAT", {.description = "number of materials/potentials in list"}));
-    m->add_component(entry<std::vector<int>>("MATIDS",
+        parameter<int>("NUMMAT", {.description = "number of materials/potentials in list"}));
+    m->add_component(parameter<std::vector<int>>("MATIDS",
         {.description = "the list material/potential IDs", .size = from_parameter<int>("NUMMAT")}));
-    m->add_component(entry<double>("DENS", {.description = "material mass density"}));
-    m->add_component(entry<double>("INITYIELD", {.description = "initial yield stress"}));
-    m->add_component(entry<int>("POLYCONVEX",
+    m->add_component(parameter<double>("DENS", {.description = "material mass density"}));
+    m->add_component(parameter<double>("INITYIELD", {.description = "initial yield stress"}));
+    m->add_component(parameter<int>("POLYCONVEX",
         {.description = "1.0 if polyconvexity of system is checked", .default_value = 0.}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "ISOHARD", {.description = "linear isotropic hardening modulus", .default_value = 0.}));
-    m->add_component(entry<double>("EXPISOHARD",
+    m->add_component(parameter<double>("EXPISOHARD",
         {.description = "nonlinear isotropic hardening exponent", .default_value = 0.}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "INFYIELD", {.description = "saturation yield stress for nonlinear isotropic hardening",
                         .default_value = 0.}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "KINHARD", {.description = "linear kinematic hardening modulus", .default_value = 0.}));
 
     // visco-plasticity
-    m->add_component(entry<double>("VISC",
+    m->add_component(parameter<double>("VISC",
         {.description = "Visco-Plasticity parameter 'eta' in Perzyna model", .default_value = 0.}));
-    m->add_component(entry<double>("RATE_DEPENDENCY",
+    m->add_component(parameter<double>("RATE_DEPENDENCY",
         {.description = "Visco-Plasticity parameter 'eta' in Perzyna model", .default_value = 1.}));
-    m->add_component(entry<double>("VISC_SOFT",
+    m->add_component(parameter<double>("VISC_SOFT",
         {.description = "Visco-Plasticity temperature dependency (eta = eta_0 * (1-(T-T_0)*x)",
             .default_value = 0.}));
 
     // optional pastic spin parameter
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "PL_SPIN_CHI", {.description = "Plastic spin coupling parameter chi (often called eta)",
                            .default_value = 0.0}));
 
     // optional Hill yield parameters
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "rY_11", {.description = "relative yield stress in fiber1-direction (Y_11/Y_0)",
                      .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "rY_22", {.description = "relative yield stress in fiber2-direction (Y_22/Y_0)",
                      .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "rY_33", {.description = "relative yield stress in fiber3-direction (Y_33/Y_0)",
                      .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "rY_12", {.description = "relative shear yield stress in 12-direction (Y_12/Y_0)",
                      .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "rY_23", {.description = "relative shear yield stress in 23-direction (Y_23/Y_0)",
                      .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "rY_13", {.description = "relative shear yield stress in 13-direction (Y_13/Y_0)",
                      .default_value = 0.0}));
 
     // optional TSI parameters
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "CTE", {.description = "coefficient of thermal expansion", .default_value = 0.}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "INITTEMP", {.description = "initial, reference temperature", .default_value = 0.}));
+    m->add_component(parameter<double>(
+        "YIELDSOFT", {.description = "yield stress softening", .default_value = 0.}));
     m->add_component(
-        entry<double>("YIELDSOFT", {.description = "yield stress softening", .default_value = 0.}));
-    m->add_component(
-        entry<double>("HARDSOFT", {.description = "hardening softening", .default_value = 0.}));
-    m->add_component(entry<double>("TAYLOR_QUINNEY",
+        parameter<double>("HARDSOFT", {.description = "hardening softening", .default_value = 0.}));
+    m->add_component(parameter<double>("TAYLOR_QUINNEY",
         {.description = "Taylor-Quinney factor for plastic heat conversion", .default_value = 1.}));
 
     Mat::append_material_definition(matlist, m);
@@ -1710,68 +1740,68 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::m_plelasthyperVCU);
 
     m->add_component(
-        entry<int>("NUMMAT", {.description = "number of materials/potentials in list"}));
-    m->add_component(entry<std::vector<int>>("MATIDS",
+        parameter<int>("NUMMAT", {.description = "number of materials/potentials in list"}));
+    m->add_component(parameter<std::vector<int>>("MATIDS",
         {.description = "the list material/potential IDs", .size = from_parameter<int>("NUMMAT")}));
-    m->add_component(entry<double>("DENS", {.description = "material mass density"}));
-    m->add_component(entry<double>("INITYIELD", {.description = "initial yield stress"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>("DENS", {.description = "material mass density"}));
+    m->add_component(parameter<double>("INITYIELD", {.description = "initial yield stress"}));
+    m->add_component(parameter<double>(
         "ISOHARD", {.description = "linear isotropic hardening modulus", .default_value = 0.}));
-    m->add_component(entry<double>("EXPISOHARD",
+    m->add_component(parameter<double>("EXPISOHARD",
         {.description = "nonlinear isotropic hardening exponent", .default_value = 0.}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "INFYIELD", {.description = "saturation yield stress for nonlinear isotropic hardening",
                         .default_value = 0.}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "KINHARD", {.description = "linear kinematic hardening modulus", .default_value = 0.}));
 
     // visco-plasticity
-    m->add_component(entry<double>("VISC",
+    m->add_component(parameter<double>("VISC",
         {.description = "Visco-Plasticity parameter 'eta' in Perzyna model", .default_value = 0.}));
-    m->add_component(entry<double>("RATE_DEPENDENCY",
+    m->add_component(parameter<double>("RATE_DEPENDENCY",
         {.description = "Visco-Plasticity parameter 'eta' in Perzyna model", .default_value = 1.}));
-    m->add_component(entry<double>("VISC_SOFT",
+    m->add_component(parameter<double>("VISC_SOFT",
         {.description = "Visco-Plasticity temperature dependency (eta = eta_0 * (1-(T-T_0)*x)",
             .default_value = 0.}));
 
     // optional pastic spin parameter
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "PL_SPIN_CHI", {.description = "Plastic spin coupling parameter chi (often called eta)",
                            .default_value = 0.0}));
 
     // optional Hill yield parameters
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "rY_11", {.description = "relative yield stress in fiber1-direction (Y_11/Y_0)",
                      .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "rY_22", {.description = "relative yield stress in fiber2-direction (Y_22/Y_0)",
                      .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "rY_33", {.description = "relative yield stress in fiber3-direction (Y_33/Y_0)",
                      .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "rY_12", {.description = "relative shear yield stress in 12-direction (Y_12/Y_0)",
                      .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "rY_23", {.description = "relative shear yield stress in 23-direction (Y_23/Y_0)",
                      .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "rY_13", {.description = "relative shear yield stress in 13-direction (Y_13/Y_0)",
                      .default_value = 0.0}));
 
     // optional TSI parameters
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "CTE", {.description = "coefficient of thermal expansion", .default_value = 0.}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "INITTEMP", {.description = "initial, reference temperature", .default_value = 0.}));
+    m->add_component(parameter<double>(
+        "YIELDSOFT", {.description = "yield stress softening", .default_value = 0.}));
     m->add_component(
-        entry<double>("YIELDSOFT", {.description = "yield stress softening", .default_value = 0.}));
-    m->add_component(
-        entry<double>("HARDSOFT", {.description = "hardening softening", .default_value = 0.}));
-    m->add_component(entry<double>("TAYLOR_QUINNEY",
+        parameter<double>("HARDSOFT", {.description = "hardening softening", .default_value = 0.}));
+    m->add_component(parameter<double>("TAYLOR_QUINNEY",
         {.description = "Taylor-Quinney factor for plastic heat conversion", .default_value = 1.}));
 
-    m->add_component(entry<int>("POLYCONVEX",
+    m->add_component(parameter<int>("POLYCONVEX",
         {.description = "1.0 if polyconvexity of system is checked", .default_value = 0.}));
 
 
@@ -1785,12 +1815,12 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "logarithmic neo-Hooke material acc. to Bonet and Wood",
         Core::Materials::mes_couplogneohooke);
 
-    m->add_component(
-        entry<std::string>("MODE", {.description = "parameter set: YN (Young's modulus and "
-                                                   "Poisson's ration; default) or Lame (mue and "
-                                                   "lambda)"}));
-    m->add_component(entry<double>("C1", {.description = "E or mue"}));
-    m->add_component(entry<double>("C2", {.description = "nue or lambda"}));
+    m->add_component(parameter<std::string>(
+        "MODE", {.description = "parameter set: YN (Young's modulus and "
+                                "Poisson's ration; default) or Lame (mue and "
+                                "lambda)"}));
+    m->add_component(parameter<double>("C1", {.description = "E or mue"}));
+    m->add_component(parameter<double>("C2", {.description = "nue or lambda"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1801,8 +1831,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "ELAST_CoupSVK", "Saint-Venant-Kirchhoff as elastic summand", Core::Materials::mes_coupSVK);
 
-    m->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
-    m->add_component(entry<double>("NUE", {.description = "Poisson's ratio"}));
+    m->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
+    m->add_component(parameter<double>("NUE", {.description = "Poisson's ratio"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1813,7 +1843,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "ELAST_CoupSimoPister", "Simo-Pister type material", Core::Materials::mes_coupsimopister);
 
-    m->add_component(entry<double>("MUE", {.description = "material constant"}));
+    m->add_component(parameter<double>("MUE", {.description = "material constant"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1824,12 +1854,12 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_CoupLogMixNeoHooke",
         "mixed logarithmic neo-Hooke material", Core::Materials::mes_couplogmixneohooke);
 
-    m->add_component(
-        entry<std::string>("MODE", {.description = "parameter set: YN (Young's modulus and "
-                                                   "Poisson's ration; default) or Lame (mue and "
-                                                   "lambda)"}));
-    m->add_component(entry<double>("C1", {.description = "E or mue"}));
-    m->add_component(entry<double>("C2", {.description = "nue or lambda"}));
+    m->add_component(parameter<std::string>(
+        "MODE", {.description = "parameter set: YN (Young's modulus and "
+                                "Poisson's ration; default) or Lame (mue and "
+                                "lambda)"}));
+    m->add_component(parameter<double>("C1", {.description = "E or mue"}));
+    m->add_component(parameter<double>("C2", {.description = "nue or lambda"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1840,9 +1870,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_CoupExpPol",
         "compressible, isochoric exponential material law for soft tissue",
         Core::Materials::mes_coupexppol);
-    m->add_component(entry<double>("A", {.description = "material constant"}));
-    m->add_component(entry<double>("B", {.description = "material constant linear I_1"}));
-    m->add_component(entry<double>("C", {.description = "material constant linear J"}));
+    m->add_component(parameter<double>("A", {.description = "material constant"}));
+    m->add_component(parameter<double>("B", {.description = "material constant linear I_1"}));
+    m->add_component(parameter<double>("C", {.description = "material constant linear J"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1854,9 +1884,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "compressible neo-Hooke material acc. to Holzapfel", Core::Materials::mes_coupneohooke);
 
     m->add_component(
-        entry<double>("YOUNG", {.description = "Young's modulus", .default_value = 0.0}));
+        parameter<double>("YOUNG", {.description = "Young's modulus", .default_value = 0.0}));
     m->add_component(
-        entry<double>("NUE", {.description = "Poisson's ratio", .default_value = 0.0}));
+        parameter<double>("NUE", {.description = "Poisson's ratio", .default_value = 0.0}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1866,11 +1896,11 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "Mooney - Rivlin material acc. to Holzapfel", Core::Materials::mes_coupmooneyrivlin);
 
     m->add_component(
-        entry<double>("C1", {.description = "material constant", .default_value = 0.0}));
+        parameter<double>("C1", {.description = "material constant", .default_value = 0.0}));
     m->add_component(
-        entry<double>("C2", {.description = "material constant", .default_value = 0.0}));
+        parameter<double>("C2", {.description = "material constant", .default_value = 0.0}));
     m->add_component(
-        entry<double>("C3", {.description = "material constant", .default_value = 0.0}));
+        parameter<double>("C3", {.description = "material constant", .default_value = 0.0}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1881,9 +1911,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_CoupBlatzKo",
         "Blatz and Ko material acc. to Holzapfel", Core::Materials::mes_coupblatzko);
 
-    m->add_component(entry<double>("MUE", {.description = "Shear modulus"}));
-    m->add_component(entry<double>("NUE", {.description = "Poisson's ratio"}));
-    m->add_component(entry<double>("F", {.description = "interpolation parameter"}));
+    m->add_component(parameter<double>("MUE", {.description = "Shear modulus"}));
+    m->add_component(parameter<double>("NUE", {.description = "Poisson's ratio"}));
+    m->add_component(parameter<double>("F", {.description = "interpolation parameter"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1894,7 +1924,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_IsoNeoHooke",
         "isochoric part of neo-Hooke material acc. to Holzapfel", Core::Materials::mes_isoneohooke);
 
-    m->add_component(entry<double>("MUE", {.description = "Shear modulus"}));
+    m->add_component(parameter<double>("MUE", {.description = "Shear modulus"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1905,8 +1935,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_IsoOgden",
         "isochoric part of the one-term Ogden material", Core::Materials::mes_isoogden);
 
-    m->add_component(entry<double>("MUE", {.description = "Shear modulus"}));
-    m->add_component(entry<double>("ALPHA", {.description = "Nonlinearity parameter"}));
+    m->add_component(parameter<double>("MUE", {.description = "Shear modulus"}));
+    m->add_component(parameter<double>("ALPHA", {.description = "Nonlinearity parameter"}));
     Mat::append_material_definition(matlist, m);
   }
 
@@ -1916,9 +1946,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_IsoYeoh",
         "isochoric part of  Yeoh material acc. to Holzapfel", Core::Materials::mes_isoyeoh);
 
-    m->add_component(entry<double>("C1", {.description = "Linear modulus"}));
-    m->add_component(entry<double>("C2", {.description = "Quadratic modulus"}));
-    m->add_component(entry<double>("C3", {.description = "Cubic modulus"}));
+    m->add_component(parameter<double>("C1", {.description = "Linear modulus"}));
+    m->add_component(parameter<double>("C2", {.description = "Quadratic modulus"}));
+    m->add_component(parameter<double>("C3", {.description = "Cubic modulus"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -1929,8 +1959,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "ELAST_Iso1Pow", "isochoric part of general power material", Core::Materials::mes_iso1pow);
 
-    m->add_component(entry<double>("C", {.description = "material parameter"}));
-    m->add_component(entry<int>("D", {.description = "exponent"}));
+    m->add_component(parameter<double>("C", {.description = "material parameter"}));
+    m->add_component(parameter<int>("D", {.description = "exponent"}));
     Mat::append_material_definition(matlist, m);
   }
 
@@ -1940,8 +1970,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "ELAST_Iso2Pow", "isochoric part of general power material", Core::Materials::mes_iso2pow);
 
-    m->add_component(entry<double>("C", {.description = "material parameter"}));
-    m->add_component(entry<int>("D", {.description = "exponent"}));
+    m->add_component(parameter<double>("C", {.description = "material parameter"}));
+    m->add_component(parameter<int>("D", {.description = "exponent"}));
     Mat::append_material_definition(matlist, m);
   }
 
@@ -1951,8 +1981,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "ELAST_Coup1Pow", "part of general power material", Core::Materials::mes_coup1pow);
 
-    m->add_component(entry<double>("C", {.description = "material parameter"}));
-    m->add_component(entry<int>("D", {.description = "exponent"}));
+    m->add_component(parameter<double>("C", {.description = "material parameter"}));
+    m->add_component(parameter<int>("D", {.description = "exponent"}));
     Mat::append_material_definition(matlist, m);
   }
 
@@ -1962,8 +1992,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "ELAST_Coup2Pow", "part of general power material", Core::Materials::mes_coup2pow);
 
-    m->add_component(entry<double>("C", {.description = "material parameter"}));
-    m->add_component(entry<int>("D", {.description = "exponent"}));
+    m->add_component(parameter<double>("C", {.description = "material parameter"}));
+    m->add_component(parameter<int>("D", {.description = "exponent"}));
     Mat::append_material_definition(matlist, m);
   }
 
@@ -1973,8 +2003,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "ELAST_Coup3Pow", "part of general power material", Core::Materials::mes_coup3pow);
 
-    m->add_component(entry<double>("C", {.description = "material parameter"}));
-    m->add_component(entry<int>("D", {.description = "exponent"}));
+    m->add_component(parameter<double>("C", {.description = "material parameter"}));
+    m->add_component(parameter<int>("D", {.description = "exponent"}));
     Mat::append_material_definition(matlist, m);
   }
 
@@ -1985,9 +2015,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "hyperelastic potential summand for multiplicative coupled invariants I1 and I3",
         Core::Materials::mes_coup13apow);
 
-    m->add_component(entry<double>("C", {.description = "material parameter"}));
-    m->add_component(entry<int>("D", {.description = "exponent of all"}));
-    m->add_component(entry<double>("A", {.description = "negative exponent of I3"}));
+    m->add_component(parameter<double>("C", {.description = "material parameter"}));
+    m->add_component(parameter<int>("D", {.description = "exponent of all"}));
+    m->add_component(parameter<double>("A", {.description = "negative exponent of I3"}));
     Mat::append_material_definition(matlist, m);
   }
 
@@ -1998,9 +2028,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "isochoric part of  exponential material acc. to Holzapfel",
         Core::Materials::mes_isoexpopow);
 
-    m->add_component(entry<double>("K1", {.description = "material parameter"}));
-    m->add_component(entry<double>("K2", {.description = "material parameter"}));
-    m->add_component(entry<int>("C", {.description = "exponent"}));
+    m->add_component(parameter<double>("K1", {.description = "material parameter"}));
+    m->add_component(parameter<double>("K2", {.description = "material parameter"}));
+    m->add_component(parameter<int>("C", {.description = "exponent"}));
     Mat::append_material_definition(matlist, m);
   }
 
@@ -2011,8 +2041,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "isochoric part of  Mooney-Rivlin material acc. to Holzapfel",
         Core::Materials::mes_isomooneyrivlin);
 
-    m->add_component(entry<double>("C1", {.description = "Linear modulus for first invariant"}));
-    m->add_component(entry<double>("C2", {.description = "Linear modulus for second invariant"}));
+    m->add_component(
+        parameter<double>("C1", {.description = "Linear modulus for first invariant"}));
+    m->add_component(
+        parameter<double>("C2", {.description = "Linear modulus for second invariant"}));
     Mat::append_material_definition(matlist, m);
   }
 
@@ -2022,21 +2054,22 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_IsoMuscle_Blemker",
         "anisotropic Blemker muscle material", Core::Materials::mes_isomuscleblemker);
 
-    m->add_component(entry<double>("G1", {.description = "muscle along fiber shear modulus"}));
-    m->add_component(entry<double>("G2", {.description = "muscle cross fiber shear modulus"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>("G1", {.description = "muscle along fiber shear modulus"}));
+    m->add_component(parameter<double>("G2", {.description = "muscle cross fiber shear modulus"}));
+    m->add_component(parameter<double>(
         "P1", {.description = "linear material parameter for passive along-fiber response"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "P2", {.description = "exponential material parameter for passive along-fiber response"}));
-    m->add_component(entry<double>("SIGMAMAX", {.description = "maximal active isometric stress"}));
-    m->add_component(entry<double>("LAMBDAOFL", {.description = "optimal fiber stretch"}));
-    m->add_component(entry<double>("LAMBDASTAR",
-        {.description = "stretch at which the normalized passive fiber force becomes linear"}));
-    m->add_component(entry<double>("ALPHA", {.description = "tetanised activation level,"}));
     m->add_component(
-        entry<double>("BETA", {.description = "constant scaling tanh-type activation function"}));
+        parameter<double>("SIGMAMAX", {.description = "maximal active isometric stress"}));
+    m->add_component(parameter<double>("LAMBDAOFL", {.description = "optimal fiber stretch"}));
+    m->add_component(parameter<double>("LAMBDASTAR",
+        {.description = "stretch at which the normalized passive fiber force becomes linear"}));
+    m->add_component(parameter<double>("ALPHA", {.description = "tetanised activation level,"}));
+    m->add_component(parameter<double>(
+        "BETA", {.description = "constant scaling tanh-type activation function"}));
     m->add_component(
-        entry<double>("ACTSTARTTIME", {.description = "starting time of muscle activation"}));
+        parameter<double>("ACTSTARTTIME", {.description = "starting time of muscle activation"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -2047,8 +2080,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_IsoTestMaterial",
         "test material to test elasthyper-toolbox", Core::Materials::mes_isotestmaterial);
 
-    m->add_component(entry<double>("C1", {.description = "Modulus for first invariant"}));
-    m->add_component(entry<double>("C2", {.description = "Modulus for second invariant"}));
+    m->add_component(parameter<double>("C1", {.description = "Modulus for first invariant"}));
+    m->add_component(parameter<double>("C2", {.description = "Modulus for second invariant"}));
     Mat::append_material_definition(matlist, m);
   }
 
@@ -2059,19 +2092,19 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "General fiber material for remodeling", Core::Materials::mes_remodelfiber);
 
     m->add_component(
-        entry<int>("NUMMAT", {.description = "number of materials/potentials in list"}));
-    m->add_component(entry<std::vector<int>>("MATIDS",
+        parameter<int>("NUMMAT", {.description = "number of materials/potentials in list"}));
+    m->add_component(parameter<std::vector<int>>("MATIDS",
         {.description = "the list material/potential IDs", .size = from_parameter<int>("NUMMAT")}));
-    m->add_component(
-        entry<double>("TDECAY", {.description = "decay time of Poisson (degradation) process"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
+        "TDECAY", {.description = "decay time of Poisson (degradation) process"}));
+    m->add_component(parameter<double>(
         "GROWTHFAC", {.description = "time constant for collagen growth", .default_value = 0.0}));
-    m->add_component(entry<std::vector<double>>("COLMASSFRAC",
+    m->add_component(parameter<std::vector<double>>("COLMASSFRAC",
         {.description =
                 "initial mass fraction of first collagen fiber family in constraint mixture",
             .default_value = std::vector{0.0},
             .size = from_parameter<int>("NUMMAT")}));
-    m->add_component(entry<double>("DEPOSITIONSTRETCH", {.description = "deposition stretch"}));
+    m->add_component(parameter<double>("DEPOSITIONSTRETCH", {.description = "deposition stretch"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -2082,7 +2115,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_VolSussmanBathe",
         "volumetric part of  SussmanBathe material", Core::Materials::mes_volsussmanbathe);
 
-    m->add_component(entry<double>("KAPPA", {.description = "dilatation modulus"}));
+    m->add_component(parameter<double>("KAPPA", {.description = "dilatation modulus"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -2093,8 +2126,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_VolPenalty",
         "Penalty formulation for the volumetric part", Core::Materials::mes_volpenalty);
 
-    m->add_component(entry<double>("EPSILON", {.description = "penalty parameter"}));
-    m->add_component(entry<double>("GAMMA", {.description = "penalty parameter"}));
+    m->add_component(parameter<double>("EPSILON", {.description = "penalty parameter"}));
+    m->add_component(parameter<double>("GAMMA", {.description = "penalty parameter"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -2105,8 +2138,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_VolOgden",
         "Ogden formulation for the volumetric part", Core::Materials::mes_vologden);
 
-    m->add_component(entry<double>("KAPPA", {.description = "dilatation modulus"}));
-    m->add_component(entry<double>("BETA", {.description = "empiric constant"}));
+    m->add_component(parameter<double>("KAPPA", {.description = "dilatation modulus"}));
+    m->add_component(parameter<double>("BETA", {.description = "empiric constant"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -2117,8 +2150,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_VolPow",
         "Power law formulation for the volumetric part", Core::Materials::mes_volpow);
 
-    m->add_component(entry<double>("A", {.description = "prefactor of power law"}));
-    m->add_component(entry<double>("EXPON", {.description = "exponent of power law"}));
+    m->add_component(parameter<double>("A", {.description = "prefactor of power law"}));
+    m->add_component(parameter<double>("EXPON", {.description = "exponent of power law"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -2129,23 +2162,23 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_CoupAnisoExpoActive",
         "anisotropic active fiber", Core::Materials::mes_coupanisoexpoactive);
 
-    m->add_component(entry<double>("K1", {.description = "linear constant"}));
-    m->add_component(entry<double>("K2", {.description = "exponential constant"}));
-    m->add_component(entry<double>("GAMMA", {.description = "angle"}));
-    m->add_component(entry<double>("K1COMP", {.description = "linear constant"}));
-    m->add_component(entry<double>("K2COMP", {.description = "exponential constant"}));
-    m->add_component(
-        entry<int>("STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<double>("K1", {.description = "linear constant"}));
+    m->add_component(parameter<double>("K2", {.description = "exponential constant"}));
+    m->add_component(parameter<double>("GAMMA", {.description = "angle"}));
+    m->add_component(parameter<double>("K1COMP", {.description = "linear constant"}));
+    m->add_component(parameter<double>("K2COMP", {.description = "exponential constant"}));
+    m->add_component(parameter<int>(
+        "STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
+    m->add_component(parameter<int>(
         "INIT", {.description = "initialization modus for fiber alignment", .default_value = 1}));
-    m->add_component(entry<bool>(
+    m->add_component(parameter<bool>(
         "ADAPT_ANGLE", {.description = "adapt angle during remodeling", .default_value = false}));
-    m->add_component(entry<double>("S", {.description = "maximum contractile stress"}));
+    m->add_component(parameter<double>("S", {.description = "maximum contractile stress"}));
+    m->add_component(parameter<double>(
+        "LAMBDAMAX", {.description = "stretch at maximum active force generation"}));
     m->add_component(
-        entry<double>("LAMBDAMAX", {.description = "stretch at maximum active force generation"}));
-    m->add_component(
-        entry<double>("LAMBDA0", {.description = "stretch at zero active force generation"}));
-    m->add_component(entry<double>(
+        parameter<double>("LAMBDA0", {.description = "stretch at zero active force generation"}));
+    m->add_component(parameter<double>(
         "DENS", {.description = "total reference mass density of constrained mixture"}));
 
     Mat::append_material_definition(matlist, m);
@@ -2157,18 +2190,18 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_CoupAnisoExpo",
         "anisotropic part with one exp. fiber", Core::Materials::mes_coupanisoexpo);
 
-    m->add_component(entry<double>("K1", {.description = "linear constant"}));
-    m->add_component(entry<double>("K2", {.description = "exponential constant"}));
-    m->add_component(entry<double>("GAMMA", {.description = "angle"}));
-    m->add_component(entry<double>("K1COMP", {.description = "linear constant"}));
-    m->add_component(entry<double>("K2COMP", {.description = "exponential constant"}));
-    m->add_component(
-        entry<int>("STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<double>("K1", {.description = "linear constant"}));
+    m->add_component(parameter<double>("K2", {.description = "exponential constant"}));
+    m->add_component(parameter<double>("GAMMA", {.description = "angle"}));
+    m->add_component(parameter<double>("K1COMP", {.description = "linear constant"}));
+    m->add_component(parameter<double>("K2COMP", {.description = "exponential constant"}));
+    m->add_component(parameter<int>(
+        "STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
+    m->add_component(parameter<int>(
         "INIT", {.description = "initialization modus for fiber alignment", .default_value = 1}));
-    m->add_component(entry<bool>(
+    m->add_component(parameter<bool>(
         "ADAPT_ANGLE", {.description = "adapt angle during remodeling", .default_value = false}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<int>(
         "FIBER_ID", {.description = "Id of the fiber to be used (1 for first fiber, default)",
                         .default_value = 1}));
 
@@ -2181,14 +2214,14 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_CoupAnisoExpoShear",
         "Exponential shear behavior between two fibers", Core::Materials::mes_coupanisoexposhear);
 
-    m->add_component(entry<double>("K1", {.description = "linear constant"}));
-    m->add_component(entry<double>("K2", {.description = "exponential constant"}));
-    m->add_component(entry<double>("GAMMA", {.description = "angle"}));
-    m->add_component(entry<double>("K1COMP", {.description = "linear constant"}));
-    m->add_component(entry<double>("K2COMP", {.description = "exponential constant"}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<double>("K1", {.description = "linear constant"}));
+    m->add_component(parameter<double>("K2", {.description = "exponential constant"}));
+    m->add_component(parameter<double>("GAMMA", {.description = "angle"}));
+    m->add_component(parameter<double>("K1COMP", {.description = "linear constant"}));
+    m->add_component(parameter<double>("K2COMP", {.description = "exponential constant"}));
+    m->add_component(parameter<int>(
         "INIT", {.description = "initialization modus for fiber alignment", .default_value = 1}));
-    m->add_component(entry<std::vector<int>>("FIBER_IDS",
+    m->add_component(parameter<std::vector<int>>("FIBER_IDS",
         {.description =
                 "Ids of the two fibers to be used (1 for the first fiber, 2 for the second, "
                 "default)",
@@ -2203,23 +2236,23 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_CoupAnisoPow",
         "anisotropic part with one pow-like fiber", Core::Materials::mes_coupanisopow);
 
-    m->add_component(entry<double>("K", {.description = "linear constant"}));
+    m->add_component(parameter<double>("K", {.description = "linear constant"}));
     m->add_component(
-        entry<double>("D1", {.description = "exponential constant for fiber invariant"}));
-    m->add_component(entry<double>("D2", {.description = "exponential constant for system"}));
-    m->add_component(entry<double>(
+        parameter<double>("D1", {.description = "exponential constant for fiber invariant"}));
+    m->add_component(parameter<double>("D2", {.description = "exponential constant for system"}));
+    m->add_component(parameter<double>(
         "ACTIVETHRES", {.description = "Deformation threshold for activating fibers. Default:"
                                        " 1.0 (off at compression); If 0.0 (always active)",
                            .default_value = 1.0}));
-    m->add_component(
-        entry<int>("STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
-    m->add_component(
-        entry<int>("FIBER", {.description = "Number of the fiber family contained in the element",
-                                .default_value = 1}));
-    m->add_component(entry<double>("GAMMA", {.description = "angle", .default_value = 0.0}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<int>(
+        "STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
+    m->add_component(parameter<int>(
+        "FIBER", {.description = "Number of the fiber family contained in the element",
+                     .default_value = 1}));
+    m->add_component(parameter<double>("GAMMA", {.description = "angle", .default_value = 0.0}));
+    m->add_component(parameter<int>(
         "INIT", {.description = "initialization modus for fiber alignment", .default_value = 1}));
-    m->add_component(entry<bool>(
+    m->add_component(parameter<bool>(
         "ADAPT_ANGLE", {.description = "adapt angle during remodeling", .default_value = false}));
 
     Mat::append_material_definition(matlist, m);
@@ -2232,26 +2265,26 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "anisotropic part with two exp. fibers", Core::Materials::mes_coupanisoexpotwocoup);
 
     m->add_component(
-        entry<double>("A4", {.description = "linear anisotropic constant for fiber 1"}));
+        parameter<double>("A4", {.description = "linear anisotropic constant for fiber 1"}));
     m->add_component(
-        entry<double>("B4", {.description = "exponential anisotropic constant for fiber 1"}));
+        parameter<double>("B4", {.description = "exponential anisotropic constant for fiber 1"}));
     m->add_component(
-        entry<double>("A6", {.description = "linear anisotropic constant for fiber 2"}));
+        parameter<double>("A6", {.description = "linear anisotropic constant for fiber 2"}));
     m->add_component(
-        entry<double>("B6", {.description = "exponential anisotropic constant for fiber 2"}));
-    m->add_component(entry<double>(
+        parameter<double>("B6", {.description = "exponential anisotropic constant for fiber 2"}));
+    m->add_component(parameter<double>(
         "A8", {.description = "linear anisotropic constant for fiber 1 relating fiber 2"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "B8", {.description = "exponential anisotropic constant for fiber 1 relating fiber 2"}));
-    m->add_component(entry<double>("GAMMA", {.description = "angle"}));
-    m->add_component(
-        entry<int>("STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<double>("GAMMA", {.description = "angle"}));
+    m->add_component(parameter<int>(
+        "STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
+    m->add_component(parameter<int>(
         "INIT", {.description = "initialization modus for fiber alignment", .default_value = 1}));
-    m->add_component(entry<bool>(
+    m->add_component(parameter<bool>(
         "FIB_COMP", {.description = "fibers support compression: yes (true) or no (false)",
                         .default_value = true}));
-    m->add_component(entry<bool>(
+    m->add_component(parameter<bool>(
         "ADAPT_ANGLE", {.description = "adapt angle during remodeling", .default_value = false}));
 
     Mat::append_material_definition(matlist, m);
@@ -2263,13 +2296,13 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_CoupAnisoNeoHooke",
         "anisotropic part with one neo Hookean fiber", Core::Materials::mes_coupanisoneohooke);
 
-    m->add_component(entry<double>("C", {.description = "linear constant"}));
-    m->add_component(entry<double>("GAMMA", {.description = "angle"}));
-    m->add_component(
-        entry<int>("STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<double>("C", {.description = "linear constant"}));
+    m->add_component(parameter<double>("GAMMA", {.description = "angle"}));
+    m->add_component(parameter<int>(
+        "STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
+    m->add_component(parameter<int>(
         "INIT", {.description = "initialization modus for fiber alignment", .default_value = 1}));
-    m->add_component(entry<bool>(
+    m->add_component(parameter<bool>(
         "ADAPT_ANGLE", {.description = "adapt angle during remodeling", .default_value = false}));
 
     Mat::append_material_definition(matlist, m);
@@ -2284,33 +2317,33 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "activation-contraction law of Bestel-Clement-Sorine-2001",
         Core::Materials::mes_anisoactivestress_evolution);
 
-    m->add_component(entry<double>("SIGMA", {.description = "Contractility (maximal stress)"}));
+    m->add_component(parameter<double>("SIGMA", {.description = "Contractility (maximal stress)"}));
     m->add_component(
-        entry<double>("TAUC0", {.description = "Initial value for the active stress"}));
-    m->add_component(entry<double>(
+        parameter<double>("TAUC0", {.description = "Initial value for the active stress"}));
+    m->add_component(parameter<double>(
         "MAX_ACTIVATION", {.description = "Maximal value for the rescaled activation"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "MIN_ACTIVATION", {.description = "Minimal value for the rescaled activation"}));
-    m->add_component(entry<int>("SOURCE_ACTIVATION",
+    m->add_component(parameter<int>("SOURCE_ACTIVATION",
         {.description = "Where the activation comes from: 0=scatra , >0 Id for FUNCT"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "ACTIVATION_THRES", {.description = "Threshold for activation (contraction starts when "
                                             "activation function is larger than this "
                                             "value, relaxes otherwise)"}));
-    m->add_component(entry<bool>(
+    m->add_component(parameter<bool>(
         "STRAIN_DEPENDENCY", {.description = "model strain dependency of contractility "
                                              "(Frank-Starling law): no (false) or yes (true)",
                                  .default_value = false}));
-    m->add_component(entry<double>("LAMBDA_LOWER",
+    m->add_component(parameter<double>("LAMBDA_LOWER",
         {.description = "lower fiber stretch for Frank-Starling law", .default_value = 1.0}));
-    m->add_component(entry<double>("LAMBDA_UPPER",
+    m->add_component(parameter<double>("LAMBDA_UPPER",
         {.description = "upper fiber stretch for Frank-Starling law", .default_value = 1.0}));
-    m->add_component(entry<double>("GAMMA", {.description = "angle", .default_value = 0.0}));
-    m->add_component(
-        entry<int>("STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<double>("GAMMA", {.description = "angle", .default_value = 0.0}));
+    m->add_component(parameter<int>(
+        "STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
+    m->add_component(parameter<int>(
         "INIT", {.description = "initialization mode for fiber alignment", .default_value = 1}));
-    m->add_component(entry<bool>(
+    m->add_component(parameter<bool>(
         "ADAPT_ANGLE", {.description = "adapt angle during remodeling", .default_value = false}));
 
     Mat::append_material_definition(matlist, m);
@@ -2323,17 +2356,18 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "anisotropic part with one neo Hookean fiber with variable coefficient",
         Core::Materials::mes_coupanisoneohooke_varprop);
 
-    m->add_component(entry<double>("C", {.description = "linear constant"}));
-    m->add_component(entry<int>("SOURCE_ACTIVATION",
+    m->add_component(parameter<double>("C", {.description = "linear constant"}));
+    m->add_component(parameter<int>("SOURCE_ACTIVATION",
         {.description = "Where the activation comes from: 0=scatra , >0 Id for FUNCT"}));
     m->add_component(
-        entry<double>("GAMMA", {.description = "azimuth angle", .default_value = 0.0}));
-    m->add_component(entry<double>("THETA", {.description = "polar angle", .default_value = 0.0}));
+        parameter<double>("GAMMA", {.description = "azimuth angle", .default_value = 0.0}));
     m->add_component(
-        entry<int>("STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
-    m->add_component(entry<int>(
+        parameter<double>("THETA", {.description = "polar angle", .default_value = 0.0}));
+    m->add_component(parameter<int>(
+        "STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
+    m->add_component(parameter<int>(
         "INIT", {.description = "initialization mode for fiber alignment", .default_value = 1}));
-    m->add_component(entry<bool>(
+    m->add_component(parameter<bool>(
         "ADAPT_ANGLE", {.description = "adapt angle during remodeling", .default_value = false}));
 
     Mat::append_material_definition(matlist, m);
@@ -2345,16 +2379,16 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_IsoAnisoExpo",
         "anisotropic part with one exp. fiber", Core::Materials::mes_isoanisoexpo);
 
-    m->add_component(entry<double>("K1", {.description = "linear constant"}));
-    m->add_component(entry<double>("K2", {.description = "exponential constant"}));
-    m->add_component(entry<double>("GAMMA", {.description = "angle"}));
-    m->add_component(entry<double>("K1COMP", {.description = "linear constant"}));
-    m->add_component(entry<double>("K2COMP", {.description = "exponential constant"}));
-    m->add_component(
-        entry<int>("STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<double>("K1", {.description = "linear constant"}));
+    m->add_component(parameter<double>("K2", {.description = "exponential constant"}));
+    m->add_component(parameter<double>("GAMMA", {.description = "angle"}));
+    m->add_component(parameter<double>("K1COMP", {.description = "linear constant"}));
+    m->add_component(parameter<double>("K2COMP", {.description = "exponential constant"}));
+    m->add_component(parameter<int>(
+        "STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
+    m->add_component(parameter<int>(
         "INIT", {.description = "initialization modus for fiber alignment", .default_value = 1}));
-    m->add_component(entry<bool>(
+    m->add_component(parameter<bool>(
         "ADAPT_ANGLE", {.description = "adapt angle during remodeling", .default_value = false}));
 
     Mat::append_material_definition(matlist, m);
@@ -2367,7 +2401,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "Parameter for structural tensor strategy in anisotropic materials",
         Core::Materials::mes_structuraltensorstratgy);
 
-    m->add_component(entry<std::string>("STRATEGY",
+    m->add_component(parameter<std::string>("STRATEGY",
         {.description =
                 "Strategy for evaluation of structural tensor: "
                 "Standard (default), ByDistributionFunction, DispersedTransverselyIsotropic"}));
@@ -2377,18 +2411,18 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     // "Bingham"
     // "vonMisesFisher"
     //  rauch 10/17
-    m->add_component(entry<std::string>(
+    m->add_component(parameter<std::string>(
         "DISTR", {.description = "Type of distribution function around mean direction: "
                                  "none, Bingham, vonMisesFisher",
                      .default_value = "none"}));
 
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "C1", {.description = "constant 1 for distribution function", .default_value = 1.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "C2", {.description = "constant 2 for distribution function", .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "C3", {.description = "constant 3 for distribution function", .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "C4", {.description = "constant 4 for distribution function", .default_value = 1e16}));
 
     Mat::append_material_definition(matlist, m);
@@ -2402,15 +2436,15 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "isotropic hyperelastic constitutive equation",
         Core::Materials::mes_couptransverselyisotropic);
 
-    m->add_component(entry<double>("ALPHA", {.description = "1-st constant"}));
-    m->add_component(entry<double>("BETA", {.description = "2-nd constant"}));
-    m->add_component(entry<double>("GAMMA", {.description = "3-rd constant"}));
-    m->add_component(entry<double>("ANGLE", {.description = "fiber angle"}));
-    m->add_component(
-        entry<int>("STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
+    m->add_component(parameter<double>("ALPHA", {.description = "1-st constant"}));
+    m->add_component(parameter<double>("BETA", {.description = "2-nd constant"}));
+    m->add_component(parameter<double>("GAMMA", {.description = "3-rd constant"}));
+    m->add_component(parameter<double>("ANGLE", {.description = "fiber angle"}));
+    m->add_component(parameter<int>(
+        "STR_TENS_ID", {.description = "MAT ID for definition of Structural Tensor"}));
     m->add_component(
-        entry<int>("FIBER", {.description = "exponential constant", .default_value = 1}));
-    m->add_component(entry<int>(
+        parameter<int>("FIBER", {.description = "exponential constant", .default_value = 1}));
+    m->add_component(parameter<int>(
         "INIT", {.description = "initialization modus for fiber alignment", .default_value = 1}));
 
     Mat::append_material_definition(matlist, m);
@@ -2422,8 +2456,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "ELAST_CoupVarga", "Varga material acc. to Holzapfel", Core::Materials::mes_coupvarga);
 
-    m->add_component(entry<double>("MUE", {.description = "Shear modulus"}));
-    m->add_component(entry<double>("BETA", {.description = "'Anti-modulus'"}));
+    m->add_component(parameter<double>("MUE", {.description = "Shear modulus"}));
+    m->add_component(parameter<double>("BETA", {.description = "'Anti-modulus'"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -2434,8 +2468,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("ELAST_IsoVarga",
         "Isochoric Varga material acc. to Holzapfel", Core::Materials::mes_isovarga);
 
-    m->add_component(entry<double>("MUE", {.description = "Shear modulus"}));
-    m->add_component(entry<double>("BETA", {.description = "'Anti-modulus'"}));
+    m->add_component(parameter<double>("MUE", {.description = "Shear modulus"}));
+    m->add_component(parameter<double>("BETA", {.description = "'Anti-modulus'"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -2446,7 +2480,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("VISCO_CoupMyocard",
         "Isotropic viscous contribution of myocardial matrix", Core::Materials::mes_coupmyocard);
 
-    m->add_component(entry<double>("N", {.description = "material parameter"}));
+    m->add_component(parameter<double>("N", {.description = "material parameter"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -2457,7 +2491,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("VISCO_IsoRateDep",
         "Isochoric rate dependent viscous material", Core::Materials::mes_isoratedep);
 
-    m->add_component(entry<double>("N", {.description = "material parameter"}));
+    m->add_component(parameter<double>("N", {.description = "material parameter"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -2468,9 +2502,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "VISCO_GenMax", "Viscous contribution according to SLS-Model", Core::Materials::mes_genmax);
 
-    m->add_component(entry<double>("TAU", {.description = "relaxation parameter"}));
-    m->add_component(entry<double>("BETA", {.description = "emphasis of viscous to elastic part"}));
-    m->add_component(entry<std::string>("SOLVE",
+    m->add_component(parameter<double>("TAU", {.description = "relaxation parameter"}));
+    m->add_component(
+        parameter<double>("BETA", {.description = "emphasis of viscous to elastic part"}));
+    m->add_component(parameter<std::string>("SOLVE",
         {.description = "Solution of evolution equation via: OST (default) or CONVOL (convolution "
                         "integral)"}));
 
@@ -2484,9 +2519,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "VISCO_Fract", "Viscous contribution according to FSLS-Model", Core::Materials::mes_fract);
 
-    m->add_component(entry<double>("TAU", {.description = "relaxation parameter"}));
-    m->add_component(entry<double>("ALPHA", {.description = "fractional order derivative"}));
-    m->add_component(entry<double>("BETA", {.description = "emphasis of viscous to elastic part"}));
+    m->add_component(parameter<double>("TAU", {.description = "relaxation parameter"}));
+    m->add_component(parameter<double>("ALPHA", {.description = "fractional order derivative"}));
+    m->add_component(
+        parameter<double>("BETA", {.description = "emphasis of viscous to elastic part"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -2497,7 +2533,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("VISCO_PART",
         "Viscous contribution of a viscoelastic Branch", Core::Materials::mes_viscopart);
 
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "TAU", {.description = "dynamic viscosity divided by young's modulus of the branch"}));
 
     Mat::append_material_definition(matlist, m);
@@ -2508,10 +2544,11 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("VISCO_GeneralizedGenMax",
         "Viscoelastic Branches of generalized Maxwell", Core::Materials::mes_generalizedgenmax);
 
-    m->add_component(entry<int>("NUMBRANCH", {.description = "number of viscoelastic branches"}));
-    m->add_component(entry<std::vector<int>>("MATIDS",
+    m->add_component(
+        parameter<int>("NUMBRANCH", {.description = "number of viscoelastic branches"}));
+    m->add_component(parameter<std::vector<int>>("MATIDS",
         {.description = "the list material IDs", .size = from_parameter<int>("NUMBRANCH")}));
-    m->add_component(entry<std::string>("SOLVE",
+    m->add_component(parameter<std::string>("SOLVE",
         {.description = "Solution for evolution equation: OST (default) or CONVOL (convolution "
                         "integral)"}));
 
@@ -2524,9 +2561,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("VISCO_BRANCH",
         "Viscoelastic Branch (viscous and elastic contribution)", Core::Materials::mes_viscobranch);
 
-    m->add_component(
-        entry<int>("NUMMAT", {.description = "number of materials in the viscoelastic branch"}));
-    m->add_component(entry<std::vector<int>>(
+    m->add_component(parameter<int>(
+        "NUMMAT", {.description = "number of materials in the viscoelastic branch"}));
+    m->add_component(parameter<std::vector<int>>(
         "MATIDS", {.description = "the list material IDs", .size = from_parameter<int>("NUMMAT")}));
 
     Mat::append_material_definition(matlist, m);
@@ -2538,31 +2575,33 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MAT_CNST_ART", "artery with constant properties", Core::Materials::m_cnst_art);
 
+    m->add_component(parameter<double>(
+        "VISCOSITY", {.description = "viscosity (for CONSTANT viscosity law taken as "
+                                     "blood viscosity, for BLOOD viscosity law "
+                                     "taken as the viscosity of blood plasma)"}));
+    m->add_component(parameter<double>("DENS", {.description = "density of blood"}));
     m->add_component(
-        entry<double>("VISCOSITY", {.description = "viscosity (for CONSTANT viscosity law taken as "
-                                                   "blood viscosity, for BLOOD viscosity law "
-                                                   "taken as the viscosity of blood plasma)"}));
-    m->add_component(entry<double>("DENS", {.description = "density of blood"}));
+        parameter<double>("YOUNG", {.description = "artery Youngs modulus of elasticity"}));
+    m->add_component(parameter<double>("NUE", {.description = "Poissons ratio of artery fiber"}));
+    m->add_component(parameter<double>("TH", {.description = "artery thickness"}));
     m->add_component(
-        entry<double>("YOUNG", {.description = "artery Youngs modulus of elasticity"}));
-    m->add_component(entry<double>("NUE", {.description = "Poissons ratio of artery fiber"}));
-    m->add_component(entry<double>("TH", {.description = "artery thickness"}));
-    m->add_component(entry<double>("PEXT1", {.description = "artery fixed external pressure 1"}));
-    m->add_component(entry<double>("PEXT2", {.description = "artery fixed external pressure 2"}));
-    m->add_component(entry<std::string>(
+        parameter<double>("PEXT1", {.description = "artery fixed external pressure 1"}));
+    m->add_component(
+        parameter<double>("PEXT2", {.description = "artery fixed external pressure 2"}));
+    m->add_component(parameter<std::string>(
         "VISCOSITYLAW", {.description = "type of viscosity law, CONSTANT (default) or BLOOD",
                             .default_value = "CONSTANT"}));
-    m->add_component(entry<double>("BLOOD_VISC_SCALE_DIAM_TO_MICRONS",
+    m->add_component(parameter<double>("BLOOD_VISC_SCALE_DIAM_TO_MICRONS",
         {.description = "used to scale the diameter for blood viscosity law to microns if your "
                         "problem is not "
                         "given in microns, e.g., if you use mms, set this parameter to 1.0e3",
             .default_value = 1.0}));
-    m->add_component(entry<std::string>("VARYING_DIAMETERLAW",
+    m->add_component(parameter<std::string>("VARYING_DIAMETERLAW",
         {.description = "type of varying diameter law, CONSTANT (default) or BY_FUNCTION",
             .default_value = "CONSTANT"}));
-    m->add_component(entry<int>("VARYING_DIAMETER_FUNCTION",
+    m->add_component(parameter<int>("VARYING_DIAMETER_FUNCTION",
         {.description = "function for varying diameter law", .default_value = -1}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "COLLAPSE_THRESHOLD", {.description = "Collapse threshold for diameter (below this "
                                               "diameter element is assumed to be collapsed "
                                               "with zero diameter and is not evaluated)",
@@ -2577,13 +2616,13 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_Fourier",
         "anisotropic linear Fourier's law of heat conduction", Core::Materials::m_thermo_fourier);
 
-    m->add_component(entry<double>("CAPA", {.description = "volumetric heat capacity"}));
-    m->add_component(entry<int>("CONDUCT_PARA_NUM",
+    m->add_component(parameter<double>("CAPA", {.description = "volumetric heat capacity"}));
+    m->add_component(parameter<int>("CONDUCT_PARA_NUM",
         {.description = "Parameter representing the relevant number of entries in the thermal "
                         "conductivity tensor. Setting its value to 1 resembles a scalar "
                         "conductivity, 2 or 3 a diagonal conductivity and 4 or 9 the full "
                         "conductivity tensor in two and three dimensions respectively."}));
-    m->add_component(entry<std::vector<double>>("CONDUCT",
+    m->add_component(parameter<std::vector<double>>("CONDUCT",
         {.description = "Vector of values representing the thermal conductivity tensor in a "
                         "row-wise ordering, with the vector size given by CONDUCT_PARA_NUM.",
             .size = from_parameter<int>("CONDUCT_PARA_NUM")}));
@@ -2598,17 +2637,17 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "material for heat transport due to Fourier-type thermal conduction and the Soret effect",
         Core::Materials::m_soret);
 
-    m->add_component(entry<double>("CAPA", {.description = "volumetric heat capacity"}));
-    m->add_component(entry<int>("CONDUCT_PARA_NUM",
+    m->add_component(parameter<double>("CAPA", {.description = "volumetric heat capacity"}));
+    m->add_component(parameter<int>("CONDUCT_PARA_NUM",
         {.description = "Parameter representing the relevant number of entries in the thermal "
                         "conductivity tensor. Setting its value to 1 resembles a scalar "
                         "conductivity, 2 or 3 a diagonal conductivity and 4 or 9 the full "
                         "conductivity tensor in two and three dimensions respectively."}));
-    m->add_component(entry<std::vector<double>>("CONDUCT",
+    m->add_component(parameter<std::vector<double>>("CONDUCT",
         {.description = "Vector of values representing the thermal conductivity tensor in a "
                         "row-wise ordering, with the vector size given by CONDUCT_PARA_NUM.",
             .size = from_parameter<int>("CONDUCT_PARA_NUM")}));
-    m->add_component(entry<double>("SORET", {.description = "Soret coefficient"}));
+    m->add_component(parameter<double>("SORET", {.description = "Soret coefficient"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -2621,11 +2660,11 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::m_membrane_elasthyper);
 
     m->add_component(
-        entry<int>("NUMMAT", {.description = "number of materials/potentials in list"}));
-    m->add_component(entry<std::vector<int>>("MATIDS",
+        parameter<int>("NUMMAT", {.description = "number of materials/potentials in list"}));
+    m->add_component(parameter<std::vector<int>>("MATIDS",
         {.description = "the list material/potential IDs", .size = from_parameter<int>("NUMMAT")}));
-    m->add_component(entry<double>("DENS", {.description = "material mass density"}));
-    m->add_component(entry<int>("POLYCONVEX",
+    m->add_component(parameter<double>("DENS", {.description = "material mass density"}));
+    m->add_component(parameter<int>("POLYCONVEX",
         {.description = "1.0 if polyconvexity of system is checked", .default_value = 0.}));
 
     Mat::append_material_definition(matlist, m);
@@ -2637,18 +2676,19 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_Membrane_ActiveStrain",
         "active strain membrane material", Core::Materials::m_membrane_activestrain);
 
-    m->add_component(entry<int>("MATIDPASSIVE", {.description = "MATID for the passive material"}));
-    m->add_component(entry<int>(
-        "SCALIDVOLTAGE", {.description = "ID of the scalar that represents the (SMC) voltage"}));
-    m->add_component(entry<double>("DENS", {.description = "material mass density"}));
-    m->add_component(entry<double>("BETA1", {.description = "Ca2+ dynamics"}));
-    m->add_component(entry<double>("BETA2", {.description = "opening dynamics of the VDCC"}));
     m->add_component(
-        entry<double>("VOLTHRESH", {.description = "voltage threshold for activation"}));
-    m->add_component(
-        entry<double>("ALPHA1", {.description = "intensity of contraction in fiber direction 1"}));
+        parameter<int>("MATIDPASSIVE", {.description = "MATID for the passive material"}));
+    m->add_component(parameter<int>(
+        "SCALIDVOLTAGE", {.description = "ID of the scalar that represents the (SMC) voltage"}));
+    m->add_component(parameter<double>("DENS", {.description = "material mass density"}));
+    m->add_component(parameter<double>("BETA1", {.description = "Ca2+ dynamics"}));
+    m->add_component(parameter<double>("BETA2", {.description = "opening dynamics of the VDCC"}));
     m->add_component(
-        entry<double>("ALPHA2", {.description = "intensity of contraction in fiber direction 2"}));
+        parameter<double>("VOLTHRESH", {.description = "voltage threshold for activation"}));
+    m->add_component(parameter<double>(
+        "ALPHA1", {.description = "intensity of contraction in fiber direction 1"}));
+    m->add_component(parameter<double>(
+        "ALPHA2", {.description = "intensity of contraction in fiber direction 2"}));
     Mat::append_material_definition(matlist, m);
   }
 
@@ -2659,59 +2699,59 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "growth and remodeling", Core::Materials::m_growthremodel_elasthyper);
 
     m->add_component(
-        entry<int>("NUMMATRF", {.description = "number of remodelfiber materials in list"}));
-    m->add_component(entry<int>(
+        parameter<int>("NUMMATRF", {.description = "number of remodelfiber materials in list"}));
+    m->add_component(parameter<int>(
         "NUMMATEL3D", {.description = "number of 3d elastin matrix materials/potentials in list",
                           .default_value = 0}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<int>(
         "NUMMATEL2D", {.description = "number of 2d elastin matrix materials/potentials in list"}));
-    m->add_component(
-        entry<std::vector<int>>("MATIDSRF", {.description = "the list remodelfiber material IDs",
-                                                .default_value = std::vector{0},
-                                                .size = from_parameter<int>("NUMMATRF")}));
-    m->add_component(entry<std::vector<int>>(
+    m->add_component(parameter<std::vector<int>>(
+        "MATIDSRF", {.description = "the list remodelfiber material IDs",
+                        .default_value = std::vector{0},
+                        .size = from_parameter<int>("NUMMATRF")}));
+    m->add_component(parameter<std::vector<int>>(
         "MATIDSEL3D", {.description = "the list 3d elastin matrix material/potential IDs",
                           .default_value = std::vector{-1},
                           .size = from_parameter<int>("NUMMATEL3D")}));
-    m->add_component(entry<std::vector<int>>(
+    m->add_component(parameter<std::vector<int>>(
         "MATIDSEL2D", {.description = "the list 2d elastin matrix material/potential IDs",
                           .default_value = std::vector{0},
                           .size = from_parameter<int>("NUMMATEL2D")}));
-    m->add_component(
-        entry<int>("MATIDELPENALTY", {.description = "penalty material ID", .default_value = -1}));
-    m->add_component(entry<double>("ELMASSFRAC",
+    m->add_component(parameter<int>(
+        "MATIDELPENALTY", {.description = "penalty material ID", .default_value = -1}));
+    m->add_component(parameter<double>("ELMASSFRAC",
         {.description = "initial mass fraction of elastin matrix in constraint mixture"}));
-    m->add_component(entry<double>("DENS", {.description = "material mass density"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>("DENS", {.description = "material mass density"}));
+    m->add_component(parameter<double>(
         "PRESTRETCHELASTINCIR", {.description = "circumferential prestretch of elastin matrix"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "PRESTRETCHELASTINAX", {.description = "axial prestretch of elastin matrix"}));
-    m->add_component(entry<double>("THICKNESS",
+    m->add_component(parameter<double>("THICKNESS",
         {.description = "reference wall thickness of the idealized cylindrical aneurysm [m]",
             .default_value = -1}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "MEANPRESSURE", {.description = "mean blood pressure [Pa]", .default_value = -1.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "RADIUS", {.description = "inner radius of the idealized cylindrical aneurysm [m]",
                       .default_value = -1.0}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<int>(
         "DAMAGE", {.description = "1: elastin damage after prestressing,0: no elastin damage"}));
-    m->add_component(entry<int>("GROWTHTYPE",
+    m->add_component(parameter<int>("GROWTHTYPE",
         {.description =
                 "flag to decide what type of collagen growth is used: 1: anisotropic growth; "
                 "0: isotropic growth"}));
-    m->add_component(entry<int>("LOCTIMEINT",
+    m->add_component(parameter<int>("LOCTIMEINT",
         {.description = "flag to decide what type of local time integration scheme is used: 1: "
                         "Backward Euler Method; 0: Forward Euler Method"}));
+    m->add_component(parameter<int>(
+        "MEMBRANE", {.description = "Flag whether Hex or Membrane elements are used ( "
+                                    "Membrane: 1, Hex: Everything else )",
+                        .default_value = -1}));
     m->add_component(
-        entry<int>("MEMBRANE", {.description = "Flag whether Hex or Membrane elements are used ( "
-                                               "Membrane: 1, Hex: Everything else )",
-                                   .default_value = -1}));
-    m->add_component(
-        entry<int>("CYLINDER", {.description = "Flag that geometry is a cylinder. 1: "
-                                               "aligned in x-direction; 2: y-direction; 3: "
-                                               "z-direction",
-                                   .default_value = -1}));
+        parameter<int>("CYLINDER", {.description = "Flag that geometry is a cylinder. 1: "
+                                                   "aligned in x-direction; 2: y-direction; 3: "
+                                                   "z-direction",
+                                       .default_value = -1}));
     Mat::append_material_definition(matlist, m);
   }
 
@@ -2722,19 +2762,19 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "multiplicative split of deformation gradient",
         Core::Materials::m_multiplicative_split_defgrad_elasthyper);
 
-    m->add_component(
-        entry<int>("NUMMATEL", {.description = "number of elastic materials/potentials in list"}));
-    m->add_component(entry<std::vector<int>>(
+    m->add_component(parameter<int>(
+        "NUMMATEL", {.description = "number of elastic materials/potentials in list"}));
+    m->add_component(parameter<std::vector<int>>(
         "MATIDSEL", {.description = "the list of elastic material/potential IDs",
                         .default_value = std::vector{-1},
                         .size = from_parameter<int>("NUMMATEL")}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<int>(
         "NUMFACINEL", {.description = "number of factors of inelastic deformation gradient"}));
-    m->add_component(entry<std::vector<int>>("INELDEFGRADFACIDS",
+    m->add_component(parameter<std::vector<int>>("INELDEFGRADFACIDS",
         {.description = "the list of inelastic deformation gradient factor IDs",
             .default_value = std::vector{0},
             .size = from_parameter<int>("NUMFACINEL")}));
-    m->add_component(entry<double>("DENS", {.description = "material mass density"}));
+    m->add_component(parameter<double>("DENS", {.description = "material mass density"}));
     Mat::append_material_definition(matlist, m);
   }
 
@@ -2757,10 +2797,11 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "material configuration)",
         Core::Materials::mfi_lin_scalar_iso);
 
-    m->add_component(entry<int>("SCALAR1", {.description = "number of growth inducing scalar"}));
-    m->add_component(entry<double>("SCALAR1_MolarGrowthFac",
+    m->add_component(
+        parameter<int>("SCALAR1", {.description = "number of growth inducing scalar"}));
+    m->add_component(parameter<double>("SCALAR1_MolarGrowthFac",
         {.description = "isotropic molar growth factor due to scalar 1"}));
-    m->add_component(entry<double>("SCALAR1_RefConc",
+    m->add_component(parameter<double>("SCALAR1_RefConc",
         {.description = "reference concentration of scalar 1 causing no strains"}));
 
     Mat::append_material_definition(matlist, m);
@@ -2776,14 +2817,15 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "volume change linearly dependent on scalar (in material configuration)",
         Core::Materials::mfi_lin_scalar_aniso);
 
-    m->add_component(entry<int>("SCALAR1", {.description = "number of growth inducing scalar"}));
-    m->add_component(entry<double>("SCALAR1_MolarGrowthFac",
+    m->add_component(
+        parameter<int>("SCALAR1", {.description = "number of growth inducing scalar"}));
+    m->add_component(parameter<double>("SCALAR1_MolarGrowthFac",
         {.description = "anisotropic molar growth factor due to scalar 1"}));
-    m->add_component(entry<double>("SCALAR1_RefConc",
+    m->add_component(parameter<double>("SCALAR1_RefConc",
         {.description = "reference concentration of scalar 1 causing no strains"}));
     m->add_component(
-        entry<int>("NUMSPACEDIM", {.description = "Number of space dimension (only 3 valid)"}));
-    m->add_component(entry<std::vector<double>>(
+        parameter<int>("NUMSPACEDIM", {.description = "Number of space dimension (only 3 valid)"}));
+    m->add_component(parameter<std::vector<double>>(
         "GrowthDirection", {.description = "vector that defines the growth direction",
                                .size = from_parameter<int>("NUMSPACEDIM")}));
 
@@ -2800,20 +2842,21 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "configuration)",
         Core::Materials::mfi_poly_intercal_frac_iso);
 
-    m->add_component(entry<int>("SCALAR1", {.description = "number of growth inducing scalar"}));
-    m->add_component(entry<double>("SCALAR1_RefConc",
+    m->add_component(
+        parameter<int>("SCALAR1", {.description = "number of growth inducing scalar"}));
+    m->add_component(parameter<double>("SCALAR1_RefConc",
         {.description = "reference concentration of scalar 1 causing no strains"}));
     m->add_component(
-        entry<int>("POLY_PARA_NUM", {.description = "number of polynomial coefficients"}));
-    m->add_component(entry<std::vector<double>>(
+        parameter<int>("POLY_PARA_NUM", {.description = "number of polynomial coefficients"}));
+    m->add_component(parameter<std::vector<double>>(
         "POLY_PARAMS", {.description = "coefficients of polynomial",
                            .size = from_parameter<int>("POLY_PARA_NUM")}));
     m->add_component(
-        entry<double>("X_min", {.description = "lower bound of validity of polynomial"}));
+        parameter<double>("X_min", {.description = "lower bound of validity of polynomial"}));
     m->add_component(
-        entry<double>("X_max", {.description = "upper bound of validity of polynomial"}));
-    m->add_component(
-        entry<int>("MATID", {.description = "material ID of the corresponding scatra material"}));
+        parameter<double>("X_max", {.description = "upper bound of validity of polynomial"}));
+    m->add_component(parameter<int>(
+        "MATID", {.description = "material ID of the corresponding scatra material"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -2829,25 +2872,26 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "using the scalar concentration (in material configuration)",
         Core::Materials::mfi_poly_intercal_frac_aniso);
 
-    m->add_component(entry<int>("SCALAR1", {.description = "number of growth inducing scalar"}));
-    m->add_component(entry<double>("SCALAR1_RefConc",
+    m->add_component(
+        parameter<int>("SCALAR1", {.description = "number of growth inducing scalar"}));
+    m->add_component(parameter<double>("SCALAR1_RefConc",
         {.description = "reference concentration of scalar 1 causing no strains"}));
     m->add_component(
-        entry<int>("NUMSPACEDIM", {.description = "Number of space dimension (only 3 valid)"}));
-    m->add_component(entry<std::vector<double>>(
+        parameter<int>("NUMSPACEDIM", {.description = "Number of space dimension (only 3 valid)"}));
+    m->add_component(parameter<std::vector<double>>(
         "GrowthDirection", {.description = "vector that defines the growth direction",
                                .size = from_parameter<int>("NUMSPACEDIM")}));
     m->add_component(
-        entry<int>("POLY_PARA_NUM", {.description = "number of polynomial coefficients"}));
-    m->add_component(entry<std::vector<double>>(
+        parameter<int>("POLY_PARA_NUM", {.description = "number of polynomial coefficients"}));
+    m->add_component(parameter<std::vector<double>>(
         "POLY_PARAMS", {.description = "coefficients of polynomial",
                            .size = from_parameter<int>("POLY_PARA_NUM")}));
     m->add_component(
-        entry<double>("X_min", {.description = "lower bound of validity of polynomial"}));
-    m->add_component(
-        entry<double>("X_max", {.description = "upper bound of validity of polynomial"}));
+        parameter<double>("X_min", {.description = "lower bound of validity of polynomial"}));
     m->add_component(
-        entry<int>("MATID", {.description = "material ID of the corresponding scatra material"}));
+        parameter<double>("X_max", {.description = "upper bound of validity of polynomial"}));
+    m->add_component(parameter<int>(
+        "MATID", {.description = "material ID of the corresponding scatra material"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -2858,10 +2902,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "Temperature dependent growth law. Volume change linearly dependent on temperature",
         Core::Materials::mfi_lin_temp_iso);
 
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "Temp_GrowthFac", {.description = "isotropic growth factor due to temperature"}));
     m->add_component(
-        entry<double>("RefTemp", {.description = "reference temperature causing no strains"}));
+        parameter<double>("RefTemp", {.description = "reference temperature causing no strains"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -2874,9 +2918,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "by 'FUNCT_NUM",
         Core::Materials::mfi_time_funct);
 
-    m->add_component(
-        entry<int>("FUNCT_NUM", {.description = "Time-dependent function of the determinant of the "
-                                                "inelastic deformation gradient"}));
+    m->add_component(parameter<int>(
+        "FUNCT_NUM", {.description = "Time-dependent function of the determinant of the "
+                                     "inelastic deformation gradient"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -2890,35 +2934,35 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "+ hardening model)",
         Core::Materials::mfi_transv_isotrop_elast_viscoplast);
 
-    m->add_component(entry<int>(
+    m->add_component(parameter<int>(
         "VISCOPLAST_LAW_ID", {.description = "MAT ID of the corresponding viscoplastic law"}));
-    m->add_component(entry<int>("FIBER_READER_ID",
+    m->add_component(parameter<int>("FIBER_READER_ID",
         {.description =
                 "MAT ID of the used fiber direction reader for transversely isotropic behavior"}));
-    m->add_component(entry<double>("YIELD_COND_A",
+    m->add_component(parameter<double>("YIELD_COND_A",
         {.description =
                 "transversely isotropic version of the Hill(1948) yield condition: parameter A, "
                 "following "
                 "the notation in Dafalias 1989, International Journal of Plasticity, Vol. 5"}));
-    m->add_component(entry<double>("YIELD_COND_B",
+    m->add_component(parameter<double>("YIELD_COND_B",
         {.description =
                 "transversely isotropic version of the Hill(1948) yield condition: parameter B, "
                 "following "
                 "the notation in Dafalias 1989, International Journal of Plasticity, Vol. 5"}));
-    m->add_component(entry<double>("YIELD_COND_F",
+    m->add_component(parameter<double>("YIELD_COND_F",
         {.description =
                 "transversely isotropic version of the Hill(1948) yield condition: parameter F, "
                 "following "
                 "the notation in Dafalias 1989, International Journal of Plasticity, Vol. 5"}));
-    m->add_component(entry<std::string>("ANISOTROPY",
+    m->add_component(parameter<std::string>("ANISOTROPY",
         {.description =
                 "Anisotropy type: transversely isotropic (transvisotrop; transverseisotropic; "
                 "transverselyisotropic) | isotropic (isotrop; isotropic; Default)"}));
-    m->add_component(entry<bool>(
+    m->add_component(parameter<bool>(
         "LOG_SUBSTEP", {.description = "boolean: time integration of internal variables using "
                                        "logarithmic substepping (True) or "
                                        "standard substepping (False)?"}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<int>(
         "MAX_HALVE_NUM_SUBSTEP", {.description = "maximum number of times the global time step can "
                                                  "be halved in the substepping procedure"}));
 
@@ -2934,15 +2978,15 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "law), as shown in Mareau et al. (Mechanics of Materials 143, 2020)",
         Core::Materials::mvl_reformulated_Johnson_Cook);
 
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "STRAIN_RATE_PREFAC", {.description = "reference plastic strain rate $\\dot{P}_0$ "}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "STRAIN_RATE_EXP_FAC", {.description = "exponential factor of plastic strain rate $C$"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "INIT_YIELD_STRENGTH", {.description = "initial yield strength of the material $A_0$"}));
-    m->add_component(entry<double>("ISOTROP_HARDEN_PREFAC",
+    m->add_component(parameter<double>("ISOTROP_HARDEN_PREFAC",
         {.description = "prefactor of the isotropic hardening stress $B_0$"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "ISOTROP_HARDEN_EXP", {.description = "exponent of the isotropic hardening stress $n$"}));
 
     Mat::append_material_definition(matlist, m);
@@ -2956,9 +3000,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::m_sc_dep_interp);
 
     mm->add_component(
-        entry<int>("IDMATZEROSC", {.description = "material for lambda equal to zero"}));
+        parameter<int>("IDMATZEROSC", {.description = "material for lambda equal to zero"}));
     mm->add_component(
-        entry<int>("IDMATUNITSC", {.description = "material for lambda equal to one"}));
+        parameter<int>("IDMATUNITSC", {.description = "material for lambda equal to one"}));
 
     Mat::append_material_definition(matlist, mm);
   }
@@ -2969,65 +3013,67 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_ConstraintMixture",
         "growth and remodeling of arteries", Core::Materials::m_constraintmixture);
 
-    m->add_component(entry<double>("DENS", {.description = "Density"}));
-    m->add_component(entry<double>("MUE", {.description = "Shear Modulus"}));
-    m->add_component(entry<double>("NUE", {.description = "Poisson's ratio"}));
-    m->add_component(entry<double>("PHIE", {.description = "mass fraction of elastin"}));
-    m->add_component(entry<double>("PREELA", {.description = "prestretch of elastin"}));
-    m->add_component(
-        entry<double>("K1", {.description = "Parameter for linear collagen fiber stiffness"}));
-    m->add_component(
-        entry<double>("K2", {.description = "Parameter for exponential collagen fiber stiffness"}));
-    m->add_component(entry<int>("NUMHOM", {.description = "Number of homeostatic parameters"}));
-    m->add_component(entry<std::vector<double>>("PRECOLL",
+    m->add_component(parameter<double>("DENS", {.description = "Density"}));
+    m->add_component(parameter<double>("MUE", {.description = "Shear Modulus"}));
+    m->add_component(parameter<double>("NUE", {.description = "Poisson's ratio"}));
+    m->add_component(parameter<double>("PHIE", {.description = "mass fraction of elastin"}));
+    m->add_component(parameter<double>("PREELA", {.description = "prestretch of elastin"}));
+    m->add_component(
+        parameter<double>("K1", {.description = "Parameter for linear collagen fiber stiffness"}));
+    m->add_component(parameter<double>(
+        "K2", {.description = "Parameter for exponential collagen fiber stiffness"}));
+    m->add_component(parameter<int>("NUMHOM", {.description = "Number of homeostatic parameters"}));
+    m->add_component(parameter<std::vector<double>>("PRECOLL",
         {.description = "prestretch of collagen fibers", .size = from_parameter<int>("NUMHOM")}));
-    m->add_component(entry<double>("DAMAGE", {.description = "damage stretch of collagen fibers"}));
-    m->add_component(entry<double>(
+    m->add_component(
+        parameter<double>("DAMAGE", {.description = "damage stretch of collagen fibers"}));
+    m->add_component(parameter<double>(
         "K1M", {.description = "Parameter for linear smooth muscle fiber stiffness"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "K2M", {.description = "Parameter for exponential smooth muscle fiber stiffness"}));
-    m->add_component(entry<double>("PHIM", {.description = "mass fraction of smooth muscle"}));
-    m->add_component(
-        entry<double>("PREMUS", {.description = "prestretch of smooth muscle fibers"}));
-    m->add_component(entry<double>("SMAX", {.description = "maximal active stress"}));
-    m->add_component(entry<double>("KAPPA", {.description = "dilatation modulus"}));
-    m->add_component(entry<double>("LIFETIME", {.description = "lifetime of collagen fibers"}));
-    m->add_component(entry<double>("GROWTHFAC", {.description = "growth factor for stress"}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<double>("PHIM", {.description = "mass fraction of smooth muscle"}));
+    m->add_component(
+        parameter<double>("PREMUS", {.description = "prestretch of smooth muscle fibers"}));
+    m->add_component(parameter<double>("SMAX", {.description = "maximal active stress"}));
+    m->add_component(parameter<double>("KAPPA", {.description = "dilatation modulus"}));
+    m->add_component(parameter<double>("LIFETIME", {.description = "lifetime of collagen fibers"}));
+    m->add_component(parameter<double>("GROWTHFAC", {.description = "growth factor for stress"}));
+    m->add_component(parameter<std::vector<double>>(
         "HOMSTR", {.description = "homeostatic target value of scalar stress measure",
                       .size = from_parameter<int>("NUMHOM")}));
-    m->add_component(entry<double>("SHEARGROWTHFAC", {.description = "growth factor for shear"}));
     m->add_component(
-        entry<double>("HOMRAD", {.description = "homeostatic target value of inner radius"}));
+        parameter<double>("SHEARGROWTHFAC", {.description = "growth factor for shear"}));
     m->add_component(
-        entry<double>("STARTTIME", {.description = "at this time turnover of collagen starts"}));
+        parameter<double>("HOMRAD", {.description = "homeostatic target value of inner radius"}));
+    m->add_component(parameter<double>(
+        "STARTTIME", {.description = "at this time turnover of collagen starts"}));
     m->add_component(
-        entry<std::string>("INTEGRATION", {.description = "time integration scheme: "
-                                                          "Explicit (default), or Implicit"}));
-    m->add_component(entry<double>("TOL",
+        parameter<std::string>("INTEGRATION", {.description = "time integration scheme: "
+                                                              "Explicit (default), or Implicit"}));
+    m->add_component(parameter<double>("TOL",
         {.description = "tolerance for local Newton iteration, only for implicit integration"}));
     m->add_component(
-        entry<std::string>("GROWTHFORCE", {.description = "driving force of growth: "
-                                                          "Single (default), All, ElaCol"}));
+        parameter<std::string>("GROWTHFORCE", {.description = "driving force of growth: "
+                                                              "Single (default), All, ElaCol"}));
+    m->add_component(parameter<std::string>(
+        "ELASTINDEGRAD", {.description = "how elastin is degraded: "
+                                         "None (default), Rectangle, Time"}));
     m->add_component(
-        entry<std::string>("ELASTINDEGRAD", {.description = "how elastin is degraded: "
-                                                            "None (default), Rectangle, Time"}));
-    m->add_component(
-        entry<std::string>("MASSPROD", {.description = "how mass depends on driving force: "
-                                                       "Lin (default), CosCos"}));
-    m->add_component(entry<std::string>("INITSTRETCH",
+        parameter<std::string>("MASSPROD", {.description = "how mass depends on driving force: "
+                                                           "Lin (default), CosCos"}));
+    m->add_component(parameter<std::string>("INITSTRETCH",
         {.description = "how to set stretches in the beginning (None, Homeo, UpdatePrestretch)",
             .default_value = "None"}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<int>(
         "CURVE", {.description = "number of timecurve for increase of prestretch in time"}));
     m->add_component(
-        entry<std::string>("DEGOPTION", {.description = "Type of degradation function: "
-                                                        "Lin (default), Cos, Exp, ExpVar"}));
+        parameter<std::string>("DEGOPTION", {.description = "Type of degradation function: "
+                                                            "Lin (default), Cos, Exp, ExpVar"}));
     m->add_component(
-        entry<double>("MAXMASSPRODFAC", {.description = "maximal factor of mass production"}));
-    m->add_component(entry<double>(
+        parameter<double>("MAXMASSPRODFAC", {.description = "maximal factor of mass production"}));
+    m->add_component(parameter<double>(
         "ELASTINFAC", {.description = "factor for elastin content", .default_value = 0.0}));
-    m->add_component(entry<bool>("STOREHISTORY",
+    m->add_component(parameter<bool>("STOREHISTORY",
         {.description = "store all history variables, not recommended for forward simulations",
             .default_value = false}));
 
@@ -3040,10 +3086,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_StructPoro",
         "wrapper for structure poroelastic material", Core::Materials::m_structporo);
 
-    m->add_component(entry<int>("MATID", {.description = "ID of structure material"}));
-    m->add_component(entry<int>("POROLAWID", {.description = "ID of porosity law"}));
+    m->add_component(parameter<int>("MATID", {.description = "ID of structure material"}));
+    m->add_component(parameter<int>("POROLAWID", {.description = "ID of porosity law"}));
     m->add_component(
-        entry<double>("INITPOROSITY", {.description = "initial porosity of porous medium"}));
+        parameter<double>("INITPOROSITY", {.description = "initial porosity of porous medium"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3054,7 +3100,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "linear constitutive law for porosity", Core::Materials::m_poro_law_linear);
 
     m->add_component(
-        entry<double>("BULKMODULUS", {.description = "bulk modulus of porous medium"}));
+        parameter<double>("BULKMODULUS", {.description = "bulk modulus of porous medium"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3074,9 +3120,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::m_poro_law_logNeoHooke_Penalty);
 
     m->add_component(
-        entry<double>("BULKMODULUS", {.description = "bulk modulus of porous medium"}));
-    m->add_component(
-        entry<double>("PENALTYPARAMETER", {.description = "penalty parameter of porous medium"}));
+        parameter<double>("BULKMODULUS", {.description = "bulk modulus of porous medium"}));
+    m->add_component(parameter<double>(
+        "PENALTYPARAMETER", {.description = "penalty parameter of porous medium"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3096,10 +3142,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_PoroLawLinBiot",
         "linear biot model for porosity law", Core::Materials::m_poro_law_linear_biot);
 
+    m->add_component(parameter<double>(
+        "INVBIOTMODULUS", {.description = "inverse Biot modulus of porous medium"}));
     m->add_component(
-        entry<double>("INVBIOTMODULUS", {.description = "inverse Biot modulus of porous medium"}));
-    m->add_component(
-        entry<double>("BIOTCEOFF", {.description = "Biot coefficient of porous medium"}));
+        parameter<double>("BIOTCEOFF", {.description = "Biot coefficient of porous medium"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3110,7 +3156,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_PoroLawDensityDependent",
         "porosity depending on the density", Core::Materials::m_poro_law_density_dependent);
 
-    m->add_component(entry<int>("DENSITYLAWID", {.description = "material ID of density law"}));
+    m->add_component(parameter<int>("DENSITYLAWID", {.description = "material ID of density law"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3133,7 +3179,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::m_poro_densitylaw_exp);
 
     m->add_component(
-        entry<double>("BULKMODULUS", {.description = "bulk modulus of porous medium"}));
+        parameter<double>("BULKMODULUS", {.description = "bulk modulus of porous medium"}));
     Mat::append_material_definition(matlist, m);
   }
 
@@ -3144,7 +3190,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "permeability law for constant permeability in porous multiphase medium",
         Core::Materials::m_fluidporo_relpermeabilitylaw_constant);
 
-    m->add_component(entry<double>("VALUE", {.description = "constant value of permeability"}));
+    m->add_component(parameter<double>("VALUE", {.description = "constant value of permeability"}));
     Mat::append_material_definition(matlist, m);
   }
 
@@ -3157,8 +3203,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::m_fluidporo_relpermeabilitylaw_exp);
 
     m->add_component(
-        entry<double>("EXP", {.description = "exponent of the saturation of this phase"}));
-    m->add_component(entry<double>(
+        parameter<double>("EXP", {.description = "exponent of the saturation of this phase"}));
+    m->add_component(parameter<double>(
         "MIN_SAT", {.description = "minimum saturation which is used for calculation"}));
     Mat::append_material_definition(matlist, m);
   }
@@ -3170,7 +3216,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "viscosity law for constant viscosity in porous multiphase medium",
         Core::Materials::m_fluidporo_viscositylaw_constant);
 
-    m->add_component(entry<double>("VALUE", {.description = "constant value of viscosity"}));
+    m->add_component(parameter<double>("VALUE", {.description = "constant value of viscosity"}));
     Mat::append_material_definition(matlist, m);
   }
 
@@ -3181,12 +3227,12 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "visosity law depending on pressure gradient in porous multiphase medium",
         Core::Materials::m_fluidporo_viscositylaw_celladh);
 
+    m->add_component(parameter<double>(
+        "VISC_0", {.description = "Visc0 parameter for modelling cell adherence"}));
     m->add_component(
-        entry<double>("VISC_0", {.description = "Visc0 parameter for modelling cell adherence"}));
-    m->add_component(
-        entry<double>("XI", {.description = "xi parameter for modelling cell adherence"}));
+        parameter<double>("XI", {.description = "xi parameter for modelling cell adherence"}));
     m->add_component(
-        entry<double>("PSI", {.description = "psi parameter for modelling cell adherence"}));
+        parameter<double>("PSI", {.description = "psi parameter for modelling cell adherence"}));
     Mat::append_material_definition(matlist, m);
   }
 
@@ -3197,11 +3243,11 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "wrapper for structure porelastic material with reaction",
         Core::Materials::m_structpororeaction);
 
-    m->add_component(entry<int>("MATID", {.description = "ID of structure material"}));
-    m->add_component(entry<int>("POROLAWID", {.description = "ID of porosity law"}));
+    m->add_component(parameter<int>("MATID", {.description = "ID of structure material"}));
+    m->add_component(parameter<int>("POROLAWID", {.description = "ID of porosity law"}));
     m->add_component(
-        entry<double>("INITPOROSITY", {.description = "initial porosity of porous medium"}));
-    m->add_component(entry<int>("DOFIDREACSCALAR",
+        parameter<double>("INITPOROSITY", {.description = "initial porosity of porous medium"}));
+    m->add_component(parameter<int>("DOFIDREACSCALAR",
         {.description = "Id of DOF within scalar transport problem, which controls the reaction"}));
 
     Mat::append_material_definition(matlist, m);
@@ -3214,12 +3260,12 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "wrapper for structure porelastic material with reaction",
         Core::Materials::m_structpororeactionECM);
 
-    m->add_component(entry<int>("MATID", {.description = "ID of structure material"}));
-    m->add_component(entry<int>("POROLAWID", {.description = "ID of porosity law"}));
+    m->add_component(parameter<int>("MATID", {.description = "ID of structure material"}));
+    m->add_component(parameter<int>("POROLAWID", {.description = "ID of porosity law"}));
     m->add_component(
-        entry<double>("INITPOROSITY", {.description = "initial porosity of porous medium"}));
-    m->add_component(entry<double>("DENSCOLLAGEN", {.description = "density of collagen"}));
-    m->add_component(entry<int>("DOFIDREACSCALAR",
+        parameter<double>("INITPOROSITY", {.description = "initial porosity of porous medium"}));
+    m->add_component(parameter<double>("DENSCOLLAGEN", {.description = "density of collagen"}));
+    m->add_component(parameter<int>("DOFIDREACSCALAR",
         {.description = "Id of DOF within scalar transport problem, which controls the reaction"}));
     Mat::append_material_definition(matlist, m);
   }
@@ -3230,23 +3276,23 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MAT_FluidPoro", "flow in deformable porous media", Core::Materials::m_fluidporo);
 
-    m->add_component(entry<double>("DYNVISCOSITY", {.description = "dynamic viscosity"}));
-    m->add_component(entry<double>("DENSITY", {.description = "density"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>("DYNVISCOSITY", {.description = "dynamic viscosity"}));
+    m->add_component(parameter<double>("DENSITY", {.description = "density"}));
+    m->add_component(parameter<double>(
         "PERMEABILITY", {.description = "permeability of medium", .default_value = 0.0}));
-    m->add_component(entry<double>("AXIALPERMEABILITY",
+    m->add_component(parameter<double>("AXIALPERMEABILITY",
         {.description = "axial permeability for transverse isotropy", .default_value = 0.0}));
-    m->add_component(entry<double>("ORTHOPERMEABILITY1",
+    m->add_component(parameter<double>("ORTHOPERMEABILITY1",
         {.description = "first permeability for orthotropy", .default_value = 0.0}));
-    m->add_component(entry<double>("ORTHOPERMEABILITY2",
+    m->add_component(parameter<double>("ORTHOPERMEABILITY2",
         {.description = "second permeability for orthotropy", .default_value = 0.0}));
-    m->add_component(entry<double>("ORTHOPERMEABILITY3",
+    m->add_component(parameter<double>("ORTHOPERMEABILITY3",
         {.description = "third permeability for orthotropy", .default_value = 0.0}));
-    m->add_component(entry<std::string>(
+    m->add_component(parameter<std::string>(
         "TYPE", {.description = "Problem type: Darcy (default) or Darcy-Brinkman",
                     .default_value = "Darcy"}));
     // optional parameter
-    m->add_component(entry<std::string>("PERMEABILITYFUNCTION",
+    m->add_component(parameter<std::string>("PERMEABILITYFUNCTION",
         {.description = "Permeability function: Const(Default) or Kozeny_Carman",
             .default_value = "Const"}));
 
@@ -3259,13 +3305,13 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_FluidPoroMultiPhase",
         "multi phase flow in deformable porous media", Core::Materials::m_fluidporo_multiphase);
 
-    m->add_component(entry<bool>("LOCAL",
+    m->add_component(parameter<bool>("LOCAL",
         {.description = "individual materials allocated per element or only at global scope"}));
-    m->add_component(entry<double>("PERMEABILITY", {.description = "permeability of medium"}));
-    m->add_component(entry<int>("NUMMAT", {.description = "number of materials in list"}));
-    m->add_component(entry<std::vector<int>>(
+    m->add_component(parameter<double>("PERMEABILITY", {.description = "permeability of medium"}));
+    m->add_component(parameter<int>("NUMMAT", {.description = "number of materials in list"}));
+    m->add_component(parameter<std::vector<int>>(
         "MATIDS", {.description = "the list material IDs", .size = from_parameter<int>("NUMMAT")}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<int>(
         "NUMFLUIDPHASES_IN_MULTIPHASEPORESPACE", {.description = "number of fluid phases"}));
 
     Mat::append_material_definition(matlist, m);
@@ -3278,20 +3324,20 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "multi phase flow in deformable porous media and list of reactions",
         Core::Materials::m_fluidporo_multiphase_reactions);
 
-    m->add_component(entry<bool>("LOCAL",
+    m->add_component(parameter<bool>("LOCAL",
         {.description = "individual materials allocated per element or only at global scope"}));
-    m->add_component(entry<double>("PERMEABILITY", {.description = "permeability of medium"}));
-    m->add_component(entry<int>("NUMMAT", {.description = "number of materials in list"}));
-    m->add_component(entry<std::vector<int>>(
+    m->add_component(parameter<double>("PERMEABILITY", {.description = "permeability of medium"}));
+    m->add_component(parameter<int>("NUMMAT", {.description = "number of materials in list"}));
+    m->add_component(parameter<std::vector<int>>(
         "MATIDS", {.description = "the list material IDs", .size = from_parameter<int>("NUMMAT")}));
-    m->add_component(entry<int>(
+    m->add_component(parameter<int>(
         "NUMFLUIDPHASES_IN_MULTIPHASEPORESPACE", {.description = "number of fluid phases"}));
     m->add_component(
-        entry<int>("NUMREAC", {.description = "number of reactions for these elements"}));
+        parameter<int>("NUMREAC", {.description = "number of reactions for these elements"}));
     m->add_component(
-        entry<std::vector<int>>("REACIDS", {.description = "advanced reaction list",
-                                               .default_value = std::vector{0},
-                                               .size = from_parameter<int>("NUMREAC")}));
+        parameter<std::vector<int>>("REACIDS", {.description = "advanced reaction list",
+                                                   .default_value = std::vector{0},
+                                                   .size = from_parameter<int>("NUMREAC")}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3303,16 +3349,18 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "advanced reaction material", Core::Materials::m_fluidporo_singlereaction);
 
     m->add_component(
-        entry<int>("NUMSCAL", {.description = "number of scalars coupled with this problem"}));
-    m->add_component(entry<int>("TOTALNUMDOF", {.description = "total number of multiphase-dofs"}));
-    m->add_component(entry<int>("NUMVOLFRAC", {.description = "number of volfracs"}));
-    m->add_component(entry<std::vector<int>>("SCALE",
+        parameter<int>("NUMSCAL", {.description = "number of scalars coupled with this problem"}));
+    m->add_component(
+        parameter<int>("TOTALNUMDOF", {.description = "total number of multiphase-dofs"}));
+    m->add_component(parameter<int>("NUMVOLFRAC", {.description = "number of volfracs"}));
+    m->add_component(parameter<std::vector<int>>("SCALE",
         {.description = "advanced reaction list", .size = from_parameter<int>("TOTALNUMDOF")}));
     m->add_component(
-        entry<std::string>("COUPLING", {.description = "type of coupling: "
-                                                       "scalar_by_function, no_coupling "
-                                                       "(default)"}));
-    m->add_component(entry<int>("FUNCTID", {.description = "function ID defining the reaction"}));
+        parameter<std::string>("COUPLING", {.description = "type of coupling: "
+                                                           "scalar_by_function, no_coupling "
+                                                           "(default)"}));
+    m->add_component(
+        parameter<int>("FUNCTID", {.description = "function ID defining the reaction"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3324,12 +3372,12 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "one phase for multiphase flow in deformable porous media",
         Core::Materials::m_fluidporo_singlephase);
 
-    m->add_component(entry<int>("DENSITYLAWID", {.description = "ID of density law"}));
-    m->add_component(entry<double>("DENSITY", {.description = "reference/initial density"}));
+    m->add_component(parameter<int>("DENSITYLAWID", {.description = "ID of density law"}));
+    m->add_component(parameter<double>("DENSITY", {.description = "reference/initial density"}));
     m->add_component(
-        entry<int>("RELPERMEABILITYLAWID", {.description = "ID of relative permeability law"}));
-    m->add_component(entry<int>("VISCOSITYLAWID", {.description = "ID of viscosity law"}));
-    m->add_component(entry<int>("DOFTYPEID", {.description = "ID of dof definition"}));
+        parameter<int>("RELPERMEABILITYLAWID", {.description = "ID of relative permeability law"}));
+    m->add_component(parameter<int>("VISCOSITYLAWID", {.description = "ID of viscosity law"}));
+    m->add_component(parameter<int>("DOFTYPEID", {.description = "ID of dof definition"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3341,17 +3389,17 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "one phase for multiphase flow in deformable porous media",
         Core::Materials::m_fluidporo_singlevolfrac);
 
-    m->add_component(entry<double>("DENSITY", {.description = "reference/initial density"}));
-    m->add_component(entry<double>("DIFFUSIVITY", {.description = "diffusivity of phase"}));
-    m->add_component(entry<bool>("AddScalarDependentFlux",
+    m->add_component(parameter<double>("DENSITY", {.description = "reference/initial density"}));
+    m->add_component(parameter<double>("DIFFUSIVITY", {.description = "diffusivity of phase"}));
+    m->add_component(parameter<bool>("AddScalarDependentFlux",
         {.description = "Is there additional scalar dependent flux (yes) or (no)"}));
     m->add_component(
-        entry<int>("NUMSCAL", {.description = "Number of scalars", .default_value = 0}));
-    m->add_component(entry<std::vector<double>>(
+        parameter<int>("NUMSCAL", {.description = "Number of scalars", .default_value = 0}));
+    m->add_component(parameter<std::vector<double>>(
         "SCALARDIFFS", {.description = "Diffusivities for additional scalar-dependent flux",
                            .default_value = std::vector<double>{},
                            .size = from_parameter<int>("NUMSCAL")}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "OMEGA_HALF", {.description = "Constant for receptor kinetic law",
                           .required = false,
                           .size = from_parameter<int>("NUMSCAL")}));
@@ -3366,9 +3414,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "one volume fraction pressure for multiphase flow in deformable porous media",
         Core::Materials::m_fluidporo_volfracpressure);
 
-    m->add_component(entry<double>("PERMEABILITY", {.description = "permeability of phase"}));
-    m->add_component(entry<int>("VISCOSITYLAWID", {.description = "ID of viscosity law"}));
-    m->add_component(entry<double>("MIN_VOLFRAC",
+    m->add_component(parameter<double>("PERMEABILITY", {.description = "permeability of phase"}));
+    m->add_component(parameter<int>("VISCOSITYLAWID", {.description = "ID of viscosity law"}));
+    m->add_component(parameter<double>("MIN_VOLFRAC",
         {.description =
                 "Minimum volume fraction under which we assume that VolfracPressure is zero",
             .default_value = 1.0e-3}));
@@ -3383,9 +3431,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "one degrree of freedom for multiphase flow in deformable porous media",
         Core::Materials::m_fluidporo_phasedof_diffpressure);
 
-    m->add_component(entry<int>("PHASELAWID", {.description = "ID of pressure-saturation law"}));
-    m->add_component(entry<int>("NUMDOF", {.description = "number of DoFs"}));
-    m->add_component(entry<std::vector<int>>(
+    m->add_component(
+        parameter<int>("PHASELAWID", {.description = "ID of pressure-saturation law"}));
+    m->add_component(parameter<int>("NUMDOF", {.description = "number of DoFs"}));
+    m->add_component(parameter<std::vector<int>>(
         "PRESCOEFF", {.description = "pressure IDs for differential pressure",
                          .default_value = std::vector{0},
                          .size = from_parameter<int>("NUMDOF")}));
@@ -3400,7 +3449,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "one degrree of freedom for multiphase flow in deformable porous media",
         Core::Materials::m_fluidporo_phasedof_pressure);
 
-    m->add_component(entry<int>("PHASELAWID", {.description = "ID of pressure-saturation law"}));
+    m->add_component(
+        parameter<int>("PHASELAWID", {.description = "ID of pressure-saturation law"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3412,7 +3462,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "one degrree of freedom for multiphase flow in deformable porous media",
         Core::Materials::m_fluidporo_phasedof_saturation);
 
-    m->add_component(entry<int>("PHASELAWID", {.description = "ID of pressure-saturation law"}));
+    m->add_component(
+        parameter<int>("PHASELAWID", {.description = "ID of pressure-saturation law"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3423,14 +3474,15 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_PhaseLawLinear",
         "saturated fluid phase of porous medium", Core::Materials::m_fluidporo_phaselaw_linear);
 
-    m->add_component(entry<double>("RELTENSION", {.description = "relative interface tensions"}));
     m->add_component(
-        entry<double>("SATURATION_0", {.description = "saturation at zero differential pressure"}));
-    m->add_component(entry<int>("NUMDOF", {.description = "number of DoFs"}));
-    m->add_component(
-        entry<std::vector<int>>("PRESCOEFF", {.description = "Coefficients for pressure dependence",
-                                                 .default_value = std::vector{0},
-                                                 .size = from_parameter<int>("NUMDOF")}));
+        parameter<double>("RELTENSION", {.description = "relative interface tensions"}));
+    m->add_component(parameter<double>(
+        "SATURATION_0", {.description = "saturation at zero differential pressure"}));
+    m->add_component(parameter<int>("NUMDOF", {.description = "number of DoFs"}));
+    m->add_component(parameter<std::vector<int>>(
+        "PRESCOEFF", {.description = "Coefficients for pressure dependence",
+                         .default_value = std::vector{0},
+                         .size = from_parameter<int>("NUMDOF")}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3441,15 +3493,17 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_PhaseLawTangent",
         "tangent fluid phase of porous medium", Core::Materials::m_fluidporo_phaselaw_tangent);
 
-    m->add_component(entry<double>("RELTENSION", {.description = "relative interface tensions"}));
-    m->add_component(entry<double>("EXP", {.description = "exponent in pressure-saturation law"}));
     m->add_component(
-        entry<double>("SATURATION_0", {.description = "saturation at zero differential pressure"}));
-    m->add_component(entry<int>("NUMDOF", {.description = "number of DoFs"}));
+        parameter<double>("RELTENSION", {.description = "relative interface tensions"}));
     m->add_component(
-        entry<std::vector<int>>("PRESCOEFF", {.description = "Coefficients for pressure dependence",
-                                                 .default_value = std::vector{0},
-                                                 .size = from_parameter<int>("NUMDOF")}));
+        parameter<double>("EXP", {.description = "exponent in pressure-saturation law"}));
+    m->add_component(parameter<double>(
+        "SATURATION_0", {.description = "saturation at zero differential pressure"}));
+    m->add_component(parameter<int>("NUMDOF", {.description = "number of DoFs"}));
+    m->add_component(parameter<std::vector<int>>(
+        "PRESCOEFF", {.description = "Coefficients for pressure dependence",
+                         .default_value = std::vector{0},
+                         .size = from_parameter<int>("NUMDOF")}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3472,13 +3526,13 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::m_fluidporo_phaselaw_byfunction);
 
     m->add_component(
-        entry<int>("FUNCTPRES", {.description = "ID of function for differential pressure"}));
-    m->add_component(entry<int>("FUNCTSAT", {.description = "ID of function for saturation"}));
-    m->add_component(entry<int>("NUMDOF", {.description = "number of DoFs"}));
-    m->add_component(
-        entry<std::vector<int>>("PRESCOEFF", {.description = "Coefficients for pressure dependence",
-                                                 .default_value = std::vector{0},
-                                                 .size = from_parameter<int>("NUMDOF")}));
+        parameter<int>("FUNCTPRES", {.description = "ID of function for differential pressure"}));
+    m->add_component(parameter<int>("FUNCTSAT", {.description = "ID of function for saturation"}));
+    m->add_component(parameter<int>("NUMDOF", {.description = "number of DoFs"}));
+    m->add_component(parameter<std::vector<int>>(
+        "PRESCOEFF", {.description = "Coefficients for pressure dependence",
+                         .default_value = std::vector{0},
+                         .size = from_parameter<int>("NUMDOF")}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3489,8 +3543,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MAT_Struct_Spring", "elastic spring", Core::Materials::m_spring);
 
-    m->add_component(entry<double>("STIFFNESS", {.description = "spring constant"}));
-    m->add_component(entry<double>("DENS", {.description = "density"}));
+    m->add_component(parameter<double>("STIFFNESS", {.description = "spring constant"}));
+    m->add_component(parameter<double>("DENS", {.description = "density"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3539,30 +3593,31 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::m_beam_reissner_elast_hyper);
 
 
-    matdef->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
+    matdef->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
 
     /* note: we define both of the two following (redundant) parameters to be optional.
      *       upon initialization of the material, we assure that one of them is
      *       properly defined. */
     matdef->add_component(
-        entry<double>("SHEARMOD", {.description = "shear modulus", .default_value = -1.0}));
-    matdef->add_component(
-        entry<double>("POISSONRATIO", {.description = "Poisson's ratio", .default_value = -1.0}));
+        parameter<double>("SHEARMOD", {.description = "shear modulus", .default_value = -1.0}));
+    matdef->add_component(parameter<double>(
+        "POISSONRATIO", {.description = "Poisson's ratio", .default_value = -1.0}));
 
-    matdef->add_component(entry<double>("DENS", {.description = "mass density"}));
-
-    matdef->add_component(entry<double>("CROSSAREA", {.description = "cross-section area"}));
-    matdef->add_component(entry<double>("SHEARCORR", {.description = "shear correction factor"}));
+    matdef->add_component(parameter<double>("DENS", {.description = "mass density"}));
 
+    matdef->add_component(parameter<double>("CROSSAREA", {.description = "cross-section area"}));
     matdef->add_component(
-        entry<double>("MOMINPOL", {.description = "polar/axial area moment of inertia"}));
+        parameter<double>("SHEARCORR", {.description = "shear correction factor"}));
+
     matdef->add_component(
-        entry<double>("MOMIN2", {.description = "area moment of inertia w.r.t. first principal "
-                                                "axis of inertia (i.e. second base vector)"}));
+        parameter<double>("MOMINPOL", {.description = "polar/axial area moment of inertia"}));
     matdef->add_component(
-        entry<double>("MOMIN3", {.description = "area moment of inertia w.r.t. second principal "
-                                                "axis of inertia (i.e. third base vector)"}));
-    matdef->add_component(entry<bool>("FAD",
+        parameter<double>("MOMIN2", {.description = "area moment of inertia w.r.t. first principal "
+                                                    "axis of inertia (i.e. second base vector)"}));
+    matdef->add_component(parameter<double>(
+        "MOMIN3", {.description = "area moment of inertia w.r.t. second principal "
+                                  "axis of inertia (i.e. third base vector)"}));
+    matdef->add_component(parameter<bool>("FAD",
         {.description = "Does automatic differentiation have to be used", .default_value = false}));
 
 
@@ -3572,7 +3627,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
      *
      * This should be generalized to a type of cross-section shape (circular, rectangular,
      * elliptic, ...) and corresponding necessary dimensions (radius, sizes, ...) if needed. */
-    matdef->add_component(entry<double>("INTERACTIONRADIUS",
+    matdef->add_component(parameter<double>("INTERACTIONRADIUS",
         {.description =
                 "radius of a circular cross-section which "
                 "is EXCLUSIVELY used to evaluate interactions such as contact, potentials, ...",
@@ -3589,18 +3644,18 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::m_beam_reissner_elast_plastic);
 
 
-    matdef->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
+    matdef->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
 
     // optional parameters for plasticity
-    matdef->add_component(
-        entry<double>("YIELDN", {.description = "initial yield stress N", .default_value = -1.0}));
-    matdef->add_component(
-        entry<double>("YIELDM", {.description = "initial yield stress M", .default_value = -1.0}));
-    matdef->add_component(entry<double>("ISOHARDN",
+    matdef->add_component(parameter<double>(
+        "YIELDN", {.description = "initial yield stress N", .default_value = -1.0}));
+    matdef->add_component(parameter<double>(
+        "YIELDM", {.description = "initial yield stress M", .default_value = -1.0}));
+    matdef->add_component(parameter<double>("ISOHARDN",
         {.description = "isotropic hardening modulus of forces", .default_value = -1.0}));
-    matdef->add_component(entry<double>("ISOHARDM",
+    matdef->add_component(parameter<double>("ISOHARDM",
         {.description = "isotropic hardening modulus of moments", .default_value = -1.0}));
-    matdef->add_component(entry<bool>("TORSIONPLAST",
+    matdef->add_component(parameter<bool>("TORSIONPLAST",
         {.description = "defines whether torsional moment contributes to plasticity",
             .default_value = false}));
 
@@ -3608,24 +3663,25 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
      *       upon initialization of the material, we assure that one of them is
      *       properly defined. */
     matdef->add_component(
-        entry<double>("SHEARMOD", {.description = "shear modulus", .default_value = -1.0}));
-    matdef->add_component(
-        entry<double>("POISSONRATIO", {.description = "Poisson's ratio", .default_value = -1.0}));
+        parameter<double>("SHEARMOD", {.description = "shear modulus", .default_value = -1.0}));
+    matdef->add_component(parameter<double>(
+        "POISSONRATIO", {.description = "Poisson's ratio", .default_value = -1.0}));
 
-    matdef->add_component(entry<double>("DENS", {.description = "mass density"}));
-
-    matdef->add_component(entry<double>("CROSSAREA", {.description = "cross-section area"}));
-    matdef->add_component(entry<double>("SHEARCORR", {.description = "shear correction factor"}));
+    matdef->add_component(parameter<double>("DENS", {.description = "mass density"}));
 
+    matdef->add_component(parameter<double>("CROSSAREA", {.description = "cross-section area"}));
     matdef->add_component(
-        entry<double>("MOMINPOL", {.description = "polar/axial area moment of inertia"}));
+        parameter<double>("SHEARCORR", {.description = "shear correction factor"}));
+
     matdef->add_component(
-        entry<double>("MOMIN2", {.description = "area moment of inertia w.r.t. first principal "
-                                                "axis of inertia (i.e. second base vector)"}));
+        parameter<double>("MOMINPOL", {.description = "polar/axial area moment of inertia"}));
     matdef->add_component(
-        entry<double>("MOMIN3", {.description = "area moment of inertia w.r.t. second principal "
-                                                "axis of inertia (i.e. third base vector)"}));
-    matdef->add_component(entry<bool>("FAD",
+        parameter<double>("MOMIN2", {.description = "area moment of inertia w.r.t. first principal "
+                                                    "axis of inertia (i.e. second base vector)"}));
+    matdef->add_component(parameter<double>(
+        "MOMIN3", {.description = "area moment of inertia w.r.t. second principal "
+                                  "axis of inertia (i.e. third base vector)"}));
+    matdef->add_component(parameter<bool>("FAD",
         {.description = "Does automatic differentiation have to be used", .default_value = false}));
 
 
@@ -3635,7 +3691,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
      *
      * This should be generalized to a type of cross-section shape (circular, rectangular,
      * elliptic, ...) and corresponding necessary dimensions (radius, sizes, ...) if needed. */
-    matdef->add_component(entry<double>("INTERACTIONRADIUS",
+    matdef->add_component(parameter<double>("INTERACTIONRADIUS",
         {.description =
                 "radius of a circular cross-section which "
                 "is EXCLUSIVELY used to evaluate interactions such as contact, potentials, ...",
@@ -3654,33 +3710,33 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::m_beam_reissner_elast_hyper_bymodes);
 
 
-    matdef->add_component(entry<double>("EA", {.description = "axial rigidity"}));
-    matdef->add_component(entry<double>(
+    matdef->add_component(parameter<double>("EA", {.description = "axial rigidity"}));
+    matdef->add_component(parameter<double>(
         "GA2", {.description = "shear rigidity w.r.t first principal axis of inertia"}));
-    matdef->add_component(entry<double>(
+    matdef->add_component(parameter<double>(
         "GA3", {.description = "shear rigidity w.r.t second principal axis of inertia"}));
 
-    matdef->add_component(entry<double>("GI_T", {.description = "torsional rigidity"}));
+    matdef->add_component(parameter<double>("GI_T", {.description = "torsional rigidity"}));
     matdef->add_component(
-        entry<double>("EI2", {.description = "flexural/bending rigidity w.r.t. first principal "
-                                             "axis of inertia"}));
-    matdef->add_component(
-        entry<double>("EI3", {.description = "flexural/bending rigidity w.r.t. second principal "
-                                             "axis of inertia"}));
+        parameter<double>("EI2", {.description = "flexural/bending rigidity w.r.t. first principal "
+                                                 "axis of inertia"}));
+    matdef->add_component(parameter<double>(
+        "EI3", {.description = "flexural/bending rigidity w.r.t. second principal "
+                               "axis of inertia"}));
 
-    matdef->add_component(entry<double>(
+    matdef->add_component(parameter<double>(
         "RhoA", {.description = "translational inertia: mass density * cross-section area"}));
 
-    matdef->add_component(
-        entry<double>("MASSMOMINPOL", {.description = "polar mass moment of inertia, i.e. w.r.t. "
-                                                      "rotation around beam axis"}));
-    matdef->add_component(
-        entry<double>("MASSMOMIN2", {.description = "mass moment of inertia w.r.t. first principal "
-                                                    "axis of inertia"}));
-    matdef->add_component(entry<double>(
+    matdef->add_component(parameter<double>(
+        "MASSMOMINPOL", {.description = "polar mass moment of inertia, i.e. w.r.t. "
+                                        "rotation around beam axis"}));
+    matdef->add_component(parameter<double>(
+        "MASSMOMIN2", {.description = "mass moment of inertia w.r.t. first principal "
+                                      "axis of inertia"}));
+    matdef->add_component(parameter<double>(
         "MASSMOMIN3", {.description = "mass moment of inertia w.r.t. second principal "
                                       "axis of inertia"}));
-    matdef->add_component(entry<bool>("FAD",
+    matdef->add_component(parameter<bool>("FAD",
         {.description = "Does automatic differentiation have to be used", .default_value = false}));
 
 
@@ -3690,7 +3746,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
      *
      * This should be generalized to a type of cross-section shape (circular, rectangular,
      * elliptic, ...) and corresponding necessary dimensions (radius, sizes, ...) if needed. */
-    matdef->add_component(entry<double>("INTERACTIONRADIUS",
+    matdef->add_component(parameter<double>("INTERACTIONRADIUS",
         {.description =
                 "radius of a circular cross-section which "
                 "is EXCLUSIVELY used to evaluate interactions such as contact, potentials, ...",
@@ -3708,29 +3764,29 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::m_beam_kirchhoff_elast_hyper);
 
 
-    matdef->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
+    matdef->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
 
     /* note: we define both of the two following (redundant) parameters to be optional.
      *       upon initialization of the material, we assure that one of them is
      *       properly defined. */
     matdef->add_component(
-        entry<double>("SHEARMOD", {.description = "shear modulus", .default_value = -1.0}));
-    matdef->add_component(
-        entry<double>("POISSONRATIO", {.description = "Poisson's ratio", .default_value = -1.0}));
+        parameter<double>("SHEARMOD", {.description = "shear modulus", .default_value = -1.0}));
+    matdef->add_component(parameter<double>(
+        "POISSONRATIO", {.description = "Poisson's ratio", .default_value = -1.0}));
 
-    matdef->add_component(entry<double>("DENS", {.description = "mass density"}));
+    matdef->add_component(parameter<double>("DENS", {.description = "mass density"}));
 
-    matdef->add_component(entry<double>("CROSSAREA", {.description = "cross-section area"}));
+    matdef->add_component(parameter<double>("CROSSAREA", {.description = "cross-section area"}));
 
     matdef->add_component(
-        entry<double>("MOMINPOL", {.description = "polar/axial area moment of inertia"}));
-    matdef->add_component(
-        entry<double>("MOMIN2", {.description = "area moment of inertia w.r.t. first principal "
-                                                "axis of inertia (i.e. second base vector)"}));
+        parameter<double>("MOMINPOL", {.description = "polar/axial area moment of inertia"}));
     matdef->add_component(
-        entry<double>("MOMIN3", {.description = "area moment of inertia w.r.t. second principal "
-                                                "axis of inertia (i.e. third base vector)"}));
-    matdef->add_component(entry<bool>("FAD",
+        parameter<double>("MOMIN2", {.description = "area moment of inertia w.r.t. first principal "
+                                                    "axis of inertia (i.e. second base vector)"}));
+    matdef->add_component(parameter<double>(
+        "MOMIN3", {.description = "area moment of inertia w.r.t. second principal "
+                                  "axis of inertia (i.e. third base vector)"}));
+    matdef->add_component(parameter<bool>("FAD",
         {.description = "Does automatic differentiation have to be used", .default_value = false}));
 
 
@@ -3740,7 +3796,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
      *
      * This should be generalized to a type of cross-section shape (circular, rectangular,
      * elliptic, ...) and corresponding necessary dimensions (radius, sizes, ...) if needed. */
-    matdef->add_component(entry<double>("INTERACTIONRADIUS",
+    matdef->add_component(parameter<double>("INTERACTIONRADIUS",
         {.description =
                 "radius of a circular cross-section which "
                 "is EXCLUSIVELY used to evaluate interactions such as contact, potentials, ...",
@@ -3760,29 +3816,29 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::m_beam_kirchhoff_elast_hyper_bymodes);
 
 
-    matdef->add_component(entry<double>("EA", {.description = "axial rigidity"}));
+    matdef->add_component(parameter<double>("EA", {.description = "axial rigidity"}));
 
-    matdef->add_component(entry<double>("GI_T", {.description = "torsional rigidity"}));
-    matdef->add_component(
-        entry<double>("EI2", {.description = "flexural/bending rigidity w.r.t. first principal "
-                                             "axis of inertia"}));
+    matdef->add_component(parameter<double>("GI_T", {.description = "torsional rigidity"}));
     matdef->add_component(
-        entry<double>("EI3", {.description = "flexural/bending rigidity w.r.t. second principal "
-                                             "axis of inertia"}));
+        parameter<double>("EI2", {.description = "flexural/bending rigidity w.r.t. first principal "
+                                                 "axis of inertia"}));
+    matdef->add_component(parameter<double>(
+        "EI3", {.description = "flexural/bending rigidity w.r.t. second principal "
+                               "axis of inertia"}));
 
-    matdef->add_component(entry<double>(
+    matdef->add_component(parameter<double>(
         "RhoA", {.description = "translational inertia: mass density * cross-section area"}));
 
-    matdef->add_component(
-        entry<double>("MASSMOMINPOL", {.description = "polar mass moment of inertia, i.e. w.r.t. "
-                                                      "rotation around beam axis"}));
-    matdef->add_component(
-        entry<double>("MASSMOMIN2", {.description = "mass moment of inertia w.r.t. first principal "
-                                                    "axis of inertia"}));
-    matdef->add_component(entry<double>(
+    matdef->add_component(parameter<double>(
+        "MASSMOMINPOL", {.description = "polar mass moment of inertia, i.e. w.r.t. "
+                                        "rotation around beam axis"}));
+    matdef->add_component(parameter<double>(
+        "MASSMOMIN2", {.description = "mass moment of inertia w.r.t. first principal "
+                                      "axis of inertia"}));
+    matdef->add_component(parameter<double>(
         "MASSMOMIN3", {.description = "mass moment of inertia w.r.t. second principal "
                                       "axis of inertia"}));
-    matdef->add_component(entry<bool>("FAD",
+    matdef->add_component(parameter<bool>("FAD",
         {.description = "Does automatic differentiation have to be used", .default_value = false}));
 
 
@@ -3792,7 +3848,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
      *
      * This should be generalized to a type of cross-section shape (circular, rectangular,
      * elliptic, ...) and corresponding necessary dimensions (radius, sizes, ...) if needed. */
-    matdef->add_component(entry<double>("INTERACTIONRADIUS",
+    matdef->add_component(parameter<double>("INTERACTIONRADIUS",
         {.description =
                 "radius of a circular cross-section which "
                 "is EXCLUSIVELY used to evaluate interactions such as contact, potentials, ...",
@@ -3812,14 +3868,14 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
             Core::Materials::m_beam_kirchhoff_torsionfree_elast_hyper);
 
 
-    matdef->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
+    matdef->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
 
-    matdef->add_component(entry<double>("DENS", {.description = "mass density"}));
+    matdef->add_component(parameter<double>("DENS", {.description = "mass density"}));
 
-    matdef->add_component(entry<double>("CROSSAREA", {.description = "cross-section area"}));
+    matdef->add_component(parameter<double>("CROSSAREA", {.description = "cross-section area"}));
 
-    matdef->add_component(entry<double>("MOMIN", {.description = "area moment of inertia"}));
-    matdef->add_component(entry<bool>("FAD",
+    matdef->add_component(parameter<double>("MOMIN", {.description = "area moment of inertia"}));
+    matdef->add_component(parameter<bool>("FAD",
         {.description = "Does automatic differentiation have to be used", .default_value = false}));
 
 
@@ -3829,7 +3885,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
      *
      * This should be generalized to a type of cross-section shape (circular, rectangular,
      * elliptic, ...) and corresponding necessary dimensions (radius, sizes, ...) if needed. */
-    matdef->add_component(entry<double>("INTERACTIONRADIUS",
+    matdef->add_component(parameter<double>("INTERACTIONRADIUS",
         {.description =
                 "radius of a circular cross-section which "
                 "is EXCLUSIVELY used to evaluate interactions such as contact, potentials, ...",
@@ -3851,14 +3907,14 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
             Core::Materials::m_beam_kirchhoff_torsionfree_elast_hyper_bymodes);
 
 
-    matdef->add_component(entry<double>("EA", {.description = "axial rigidity"}));
+    matdef->add_component(parameter<double>("EA", {.description = "axial rigidity"}));
 
-    matdef->add_component(entry<double>("EI", {.description = "flexural/bending rigidity"}));
+    matdef->add_component(parameter<double>("EI", {.description = "flexural/bending rigidity"}));
 
 
-    matdef->add_component(entry<double>(
+    matdef->add_component(parameter<double>(
         "RhoA", {.description = "translational inertia: mass density * cross-section area"}));
-    matdef->add_component(entry<bool>("FAD",
+    matdef->add_component(parameter<bool>("FAD",
         {.description = "Does automatic differentiation have to be used", .default_value = false}));
 
     /* The following is optional because it is only required if we evaluate interactions
@@ -3867,7 +3923,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
      *
      * This should be generalized to a type of cross-section shape (circular, rectangular,
      * elliptic, ...) and corresponding necessary dimensions (radius, sizes, ...) if needed. */
-    matdef->add_component(entry<double>("INTERACTIONRADIUS",
+    matdef->add_component(parameter<double>("INTERACTIONRADIUS",
         {.description =
                 "radius of a circular cross-section which "
                 "is EXCLUSIVELY used to evaluate interactions such as contact, potentials, ...",
@@ -3882,9 +3938,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto matdef = std::make_shared<Mat::MaterialDefinition>("MAT_Kirchhoff_Love_shell",
         "Material for an elastic Kichhhoff-Love shell ", Core::Materials::m_shell_kirchhoff_love);
 
-    matdef->add_component(entry<double>("YOUNG_MODULUS", {.description = "Young's modulus"}));
-    matdef->add_component(entry<double>("POISSON_RATIO", {.description = "Poisson's ratio"}));
-    matdef->add_component(entry<double>("THICKNESS", {.description = "Thickness of the shell"}));
+    matdef->add_component(parameter<double>("YOUNG_MODULUS", {.description = "Young's modulus"}));
+    matdef->add_component(parameter<double>("POISSON_RATIO", {.description = "Poisson's ratio"}));
+    matdef->add_component(
+        parameter<double>("THICKNESS", {.description = "Thickness of the shell"}));
 
     append_material_definition(matlist, matdef);
   }
@@ -3896,33 +3953,34 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "material for a linkage between beams", Core::Materials::m_crosslinkermat);
 
     matdef->add_component(
-        entry<double>("MATNUM", {.description = "number of beam elasthyper material"}));
-    matdef->add_component(entry<std::string>(
+        parameter<double>("MATNUM", {.description = "number of beam elasthyper material"}));
+    matdef->add_component(parameter<std::string>(
         "JOINTTYPE", {.description = "type of joint: "
                                      "beam3rline2rigid (default), beam3rline2pin or truss"}));
-    matdef->add_component(entry<double>(
+    matdef->add_component(parameter<double>(
         "LINKINGLENGTH", {.description = "distance between the two binding domains of a linker"}));
-    matdef->add_component(entry<double>("LINKINGLENGTHTOL",
+    matdef->add_component(parameter<double>("LINKINGLENGTHTOL",
         {.description = "tolerance for linker length in the sense: length +- tolerance"}));
-    matdef->add_component(entry<double>("LINKINGANGLE",
+    matdef->add_component(parameter<double>("LINKINGANGLE",
         {.description = "preferred binding angle enclosed by two filaments' axes in radians"}));
-    matdef->add_component(entry<double>(
+    matdef->add_component(parameter<double>(
         "LINKINGANGLETOL", {.description = "tolerance for preferred binding angle in radians in "
                                            "the sense of: angle +- tolerance"}));
-    matdef->add_component(entry<double>("K_ON", {.description = "chemical association-rate"}));
-    matdef->add_component(entry<double>("K_OFF", {.description = "chemical dissociation-rate"}));
+    matdef->add_component(parameter<double>("K_ON", {.description = "chemical association-rate"}));
+    matdef->add_component(
+        parameter<double>("K_OFF", {.description = "chemical dissociation-rate"}));
 
     // optional parameter
-    matdef->add_component(entry<double>(
+    matdef->add_component(parameter<double>(
         "DELTABELLEQ", {.description = "deltaD in Bell's equation for force dependent off rate",
                            .default_value = 0.0}));
-    matdef->add_component(entry<double>("NOBONDDISTSPHERE",
+    matdef->add_component(parameter<double>("NOBONDDISTSPHERE",
         {.description = "distance to sphere elements in which no double bonded linker is allowed",
             .default_value = 0.0}));
-    matdef->add_component(
-        entry<std::string>("TYPE", {.description = "type of crosslinker: "
-                                                   "arbitrary (default), actin, collagen, integrin",
-                                       .default_value = "arbitrary"}));
+    matdef->add_component(parameter<std::string>(
+        "TYPE", {.description = "type of crosslinker: "
+                                "arbitrary (default), actin, collagen, integrin",
+                    .default_value = "arbitrary"}));
 
     Mat::append_material_definition(matlist, matdef);
   }
@@ -3933,10 +3991,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MAT_0D_MAXWELL_ACINUS", "0D acinar material", Core::Materials::m_0d_maxwell_acinus);
 
-    m->add_component(entry<double>("Stiffness1", {.description = "first stiffness"}));
-    m->add_component(entry<double>("Stiffness2", {.description = "second stiffness"}));
-    m->add_component(entry<double>("Viscosity1", {.description = "first viscosity"}));
-    m->add_component(entry<double>("Viscosity2", {.description = "second viscosity"}));
+    m->add_component(parameter<double>("Stiffness1", {.description = "first stiffness"}));
+    m->add_component(parameter<double>("Stiffness2", {.description = "second stiffness"}));
+    m->add_component(parameter<double>("Viscosity1", {.description = "first viscosity"}));
+    m->add_component(parameter<double>("Viscosity2", {.description = "second viscosity"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3947,10 +4005,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_0D_MAXWELL_ACINUS_NEOHOOKEAN",
         "0D acinar material neohookean", Core::Materials::m_0d_maxwell_acinus_neohookean);
 
-    m->add_component(entry<double>("Stiffness1", {.description = "first stiffness"}));
-    m->add_component(entry<double>("Stiffness2", {.description = "second stiffness"}));
-    m->add_component(entry<double>("Viscosity1", {.description = "first viscosity"}));
-    m->add_component(entry<double>("Viscosity2", {.description = "second viscosity"}));
+    m->add_component(parameter<double>("Stiffness1", {.description = "first stiffness"}));
+    m->add_component(parameter<double>("Stiffness2", {.description = "second stiffness"}));
+    m->add_component(parameter<double>("Viscosity1", {.description = "first viscosity"}));
+    m->add_component(parameter<double>("Viscosity2", {.description = "second viscosity"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3961,10 +4019,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_0D_MAXWELL_ACINUS_EXPONENTIAL",
         "0D acinar material exponential", Core::Materials::m_0d_maxwell_acinus_exponential);
 
-    m->add_component(entry<double>("Stiffness1", {.description = "first stiffness"}));
-    m->add_component(entry<double>("Stiffness2", {.description = "second stiffness"}));
-    m->add_component(entry<double>("Viscosity1", {.description = "first viscosity"}));
-    m->add_component(entry<double>("Viscosity2", {.description = "second viscosity"}));
+    m->add_component(parameter<double>("Stiffness1", {.description = "first stiffness"}));
+    m->add_component(parameter<double>("Stiffness2", {.description = "second stiffness"}));
+    m->add_component(parameter<double>("Viscosity1", {.description = "first viscosity"}));
+    m->add_component(parameter<double>("Viscosity2", {.description = "second viscosity"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3976,10 +4034,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "0D acinar material doubleexponential",
         Core::Materials::m_0d_maxwell_acinus_doubleexponential);
 
-    m->add_component(entry<double>("Stiffness1", {.description = "first stiffness"}));
-    m->add_component(entry<double>("Stiffness2", {.description = "second stiffness"}));
-    m->add_component(entry<double>("Viscosity1", {.description = "first viscosity"}));
-    m->add_component(entry<double>("Viscosity2", {.description = "second viscosity"}));
+    m->add_component(parameter<double>("Stiffness1", {.description = "first stiffness"}));
+    m->add_component(parameter<double>("Stiffness2", {.description = "second stiffness"}));
+    m->add_component(parameter<double>("Viscosity1", {.description = "first viscosity"}));
+    m->add_component(parameter<double>("Viscosity2", {.description = "second viscosity"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -3990,10 +4048,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_0D_MAXWELL_ACINUS_OGDEN",
         "0D acinar material ogden", Core::Materials::m_0d_maxwell_acinus_ogden);
 
-    m->add_component(entry<double>("Stiffness1", {.description = "first stiffness"}));
-    m->add_component(entry<double>("Stiffness2", {.description = "second stiffness"}));
-    m->add_component(entry<double>("Viscosity1", {.description = "first viscosity"}));
-    m->add_component(entry<double>("Viscosity2", {.description = "second viscosity"}));
+    m->add_component(parameter<double>("Stiffness1", {.description = "first stiffness"}));
+    m->add_component(parameter<double>("Stiffness2", {.description = "second stiffness"}));
+    m->add_component(parameter<double>("Viscosity1", {.description = "first viscosity"}));
+    m->add_component(parameter<double>("Viscosity2", {.description = "second viscosity"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -4005,26 +4063,27 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_ParticleSPHFluid",
         "particle material for SPH fluid", Core::Materials::m_particle_sph_fluid);
 
-    m->add_component(entry<double>("INITRADIUS", {.description = "initial radius"}));
-    m->add_component(entry<double>("INITDENSITY", {.description = "initial density"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>("INITRADIUS", {.description = "initial radius"}));
+    m->add_component(parameter<double>("INITDENSITY", {.description = "initial density"}));
+    m->add_component(parameter<double>(
         "REFDENSFAC", {.description = "reference density factor in equation of state"}));
-    m->add_component(entry<double>("EXPONENT", {.description = "exponent in equation of state"}));
-    m->add_component(entry<double>("BACKGROUNDPRESSURE",
+    m->add_component(
+        parameter<double>("EXPONENT", {.description = "exponent in equation of state"}));
+    m->add_component(parameter<double>("BACKGROUNDPRESSURE",
         {.description = "background pressure for transport velocity formulation"}));
-    m->add_component(entry<double>("BULK_MODULUS", {.description = "bulk modulus"}));
+    m->add_component(parameter<double>("BULK_MODULUS", {.description = "bulk modulus"}));
     m->add_component(
-        entry<double>("DYNAMIC_VISCOSITY", {.description = "dynamic shear viscosity"}));
-    m->add_component(entry<double>("BULK_VISCOSITY", {.description = "bulk viscosity"}));
+        parameter<double>("DYNAMIC_VISCOSITY", {.description = "dynamic shear viscosity"}));
+    m->add_component(parameter<double>("BULK_VISCOSITY", {.description = "bulk viscosity"}));
     m->add_component(
-        entry<double>("ARTIFICIAL_VISCOSITY", {.description = "artificial viscosity"}));
-    m->add_component(entry<double>(
+        parameter<double>("ARTIFICIAL_VISCOSITY", {.description = "artificial viscosity"}));
+    m->add_component(parameter<double>(
         "INITTEMPERATURE", {.description = "initial temperature", .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "THERMALCAPACITY", {.description = "thermal capacity", .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "THERMALCONDUCTIVITY", {.description = "thermal conductivity", .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "THERMALABSORPTIVITY", {.description = "thermal absorptivity", .default_value = 0.0}));
 
     Mat::append_material_definition(matlist, m);
@@ -4036,15 +4095,15 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_ParticleSPHBoundary",
         "particle material for SPH boundary", Core::Materials::m_particle_sph_boundary);
 
-    m->add_component(entry<double>("INITRADIUS", {.description = "initial radius"}));
-    m->add_component(entry<double>("INITDENSITY", {.description = "initial density"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>("INITRADIUS", {.description = "initial radius"}));
+    m->add_component(parameter<double>("INITDENSITY", {.description = "initial density"}));
+    m->add_component(parameter<double>(
         "INITTEMPERATURE", {.description = "initial temperature", .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "THERMALCAPACITY", {.description = "thermal capacity", .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "THERMALCONDUCTIVITY", {.description = "thermal conductivity", .default_value = 0.0}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "THERMALABSORPTIVITY", {.description = "thermal absorptivity", .default_value = 0.0}));
 
     Mat::append_material_definition(matlist, m);
@@ -4056,8 +4115,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MAT_ParticleDEM", "particle material for DEM", Core::Materials::m_particle_dem);
 
-    m->add_component(entry<double>("INITRADIUS", {.description = "initial radius of particle"}));
-    m->add_component(entry<double>("INITDENSITY", {.description = "initial density of particle"}));
+    m->add_component(
+        parameter<double>("INITRADIUS", {.description = "initial radius of particle"}));
+    m->add_component(
+        parameter<double>("INITDENSITY", {.description = "initial density of particle"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -4068,11 +4129,11 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_ParticleWallDEM",
         "particle wall material for DEM", Core::Materials::m_particle_wall_dem);
 
-    m->add_component(entry<double>("FRICT_COEFF_TANG",
+    m->add_component(parameter<double>("FRICT_COEFF_TANG",
         {.description = "friction coefficient for tangential contact", .default_value = -1.0}));
-    m->add_component(entry<double>("FRICT_COEFF_ROLL",
+    m->add_component(parameter<double>("FRICT_COEFF_ROLL",
         {.description = "friction coefficient for rolling contact", .default_value = -1.0}));
-    m->add_component(entry<double>("ADHESION_SURFACE_ENERGY",
+    m->add_component(parameter<double>("ADHESION_SURFACE_ENERGY",
         {.description = "adhesion surface energy", .default_value = -1.0}));
 
     Mat::append_material_definition(matlist, m);
@@ -4084,9 +4145,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MAT_Electromagnetic", "Electromagnetic material", Core::Materials::m_electromagneticmat);
 
-    m->add_component(entry<double>("CONDUCTIVITY", {.description = "electrical conductivity"}));
-    m->add_component(entry<double>("PERMITTIVITY", {.description = "Permittivity"}));
-    m->add_component(entry<double>("PERMEABILITY", {.description = "Permeability"}));
+    m->add_component(parameter<double>("CONDUCTIVITY", {.description = "electrical conductivity"}));
+    m->add_component(parameter<double>("PERMITTIVITY", {.description = "Permittivity"}));
+    m->add_component(parameter<double>("PERMEABILITY", {.description = "Permeability"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -4097,10 +4158,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MAT_Mixture", "General mixture model", Core::Materials::m_mixture);
 
-    m->add_component(entry<int>("NUMCONST", {.description = "number of mixture constituents"}));
+    m->add_component(parameter<int>("NUMCONST", {.description = "number of mixture constituents"}));
     m->add_component(
-        entry<int>("MATIDMIXTURERULE", {.description = "material id of the mixturerule"}));
-    m->add_component(entry<std::vector<int>>(
+        parameter<int>("MATIDMIXTURERULE", {.description = "material id of the mixturerule"}));
+    m->add_component(parameter<std::vector<int>>(
         "MATIDSCONST", {.description = "list material IDs of the mixture constituents",
                            .size = from_parameter<int>("NUMCONST")}));
 
@@ -4113,11 +4174,11 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MIX_Constituent_ElastHyper", "ElastHyper toolbox", Core::Materials::mix_elasthyper);
 
-    m->add_component(entry<int>("NUMMAT", {.description = "number of summands"}));
+    m->add_component(parameter<int>("NUMMAT", {.description = "number of summands"}));
     m->add_component(
-        entry<std::vector<int>>("MATIDS", {.description = "list material IDs of the summands",
-                                              .size = from_parameter<int>("NUMMAT")}));
-    m->add_component(entry<int>("PRESTRESS_STRATEGY",
+        parameter<std::vector<int>>("MATIDS", {.description = "list material IDs of the summands",
+                                                  .size = from_parameter<int>("NUMMAT")}));
+    m->add_component(parameter<int>("PRESTRESS_STRATEGY",
         {.description =
                 "Material id of the prestress strategy (optional, by default no prestretch)",
             .default_value = 0}));
@@ -4131,18 +4192,18 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MIX_Constituent_ElastHyper_Damage",
         "ElastHyper toolbox with damage", Core::Materials::mix_elasthyper_damage);
 
-    m->add_component(entry<int>("NUMMAT", {.description = "number of summands"}));
-    m->add_component(entry<std::vector<int>>(
+    m->add_component(parameter<int>("NUMMAT", {.description = "number of summands"}));
+    m->add_component(parameter<std::vector<int>>(
         "MATIDS", {.description = "list material IDs of the membrane summands",
                       .size = from_parameter<int>("NUMMAT")}));
-    m->add_component(entry<int>("PRESTRESS_STRATEGY",
+    m->add_component(parameter<int>("PRESTRESS_STRATEGY",
         {.description =
                 "Material id of the prestress strategy (optional, by default no prestretch)",
             .default_value = 0}));
-    m->add_component(
-        entry<int>("DAMAGE_FUNCT", {.description = "Reference to the function that is a gain for "
-                                                   "the increase/decrease of the reference "
-                                                   "mass density."}));
+    m->add_component(parameter<int>(
+        "DAMAGE_FUNCT", {.description = "Reference to the function that is a gain for "
+                                        "the increase/decrease of the reference "
+                                        "mass density."}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -4154,22 +4215,22 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "ElastHyper toolbox with damage and 2D membrane material",
         Core::Materials::mix_elasthyper_elastin_membrane);
 
-    m->add_component(entry<int>("NUMMAT", {.description = "number of summands"}));
-    m->add_component(entry<std::vector<int>>(
+    m->add_component(parameter<int>("NUMMAT", {.description = "number of summands"}));
+    m->add_component(parameter<std::vector<int>>(
         "MATIDS", {.description = "list material IDs of the membrane summands",
                       .size = from_parameter<int>("NUMMAT")}));
-    m->add_component(entry<int>("MEMBRANENUMMAT", {.description = "number of summands"}));
-    m->add_component(entry<std::vector<int>>(
+    m->add_component(parameter<int>("MEMBRANENUMMAT", {.description = "number of summands"}));
+    m->add_component(parameter<std::vector<int>>(
         "MEMBRANEMATIDS", {.description = "list material IDs of the membrane summands",
                               .size = from_parameter<int>("MEMBRANENUMMAT")}));
-    m->add_component(entry<int>("PRESTRESS_STRATEGY",
+    m->add_component(parameter<int>("PRESTRESS_STRATEGY",
         {.description =
                 "Material id of the prestress strategy (optional, by default no prestretch)",
             .default_value = 0}));
-    m->add_component(
-        entry<int>("DAMAGE_FUNCT", {.description = "Reference to the function that is a gain for "
-                                                   "the increase/decrease of the reference "
-                                                   "mass density."}));
+    m->add_component(parameter<int>(
+        "DAMAGE_FUNCT", {.description = "Reference to the function that is a gain for "
+                                        "the increase/decrease of the reference "
+                                        "mass density."}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -4180,7 +4241,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MIX_Constituent_SolidMaterial", "Solid material", Core::Materials::mix_solid_material);
 
-    m->add_component(entry<int>("MATID", {.description = "ID of the solid material"}));
+    m->add_component(parameter<int>("MATID", {.description = "ID of the solid material"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -4201,10 +4262,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "anisotropic growth", Core::Materials::mix_growth_strategy_anisotropic);
 
 
-    m->add_component(
-        entry<int>("INIT", {.description = "initialization modus for growth direction alignment",
-                               .default_value = 1}));
-    m->add_component(entry<int>("FIBER_ID",
+    m->add_component(parameter<int>(
+        "INIT", {.description = "initialization modus for growth direction alignment",
+                    .default_value = 1}));
+    m->add_component(parameter<int>("FIBER_ID",
         {.description =
                 "Id of the fiber to point the growth direction (1 for first fiber, default)",
             .default_value = 1}));
@@ -4220,7 +4281,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "Extension of all constituents simultaneously",
         Core::Materials::mix_growth_strategy_stiffness);
 
-    m->add_component(entry<double>("KAPPA",
+    m->add_component(parameter<double>("KAPPA",
         {.description = "Penalty parameter for the modified penalty term for incompressibility"}));
 
     Mat::append_material_definition(matlist, m);
@@ -4233,8 +4294,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "General material wrapper enabling iterative pretressing for any material",
         Core::Materials::m_iterative_prestress);
 
-    m->add_component(entry<int>("MATID", {.description = "Id of the material"}));
-    m->add_component(entry<bool>("ACTIVE",
+    m->add_component(parameter<int>("MATID", {.description = "Id of the material"}));
+    m->add_component(parameter<bool>("ACTIVE",
         {.description =
                 "Set to True during prestressing and to false afterwards using a restart of the "
                 "simulation."}));
@@ -4248,7 +4309,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MIX_Prestress_Strategy_Constant",
         "Simple predefined prestress", Core::Materials::mix_prestress_strategy_constant);
 
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "PRESTRETCH", {.description = "Definition of the prestretch as a "
                                       "9x1 vector",
                           .size = 9}));
@@ -4264,15 +4325,15 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::mix_prestress_strategy_cylinder);
 
     m->add_component(
-        entry<double>("INNER_RADIUS", {.description = "Inner radius of the cylinder"}));
+        parameter<double>("INNER_RADIUS", {.description = "Inner radius of the cylinder"}));
     m->add_component(
-        entry<double>("WALL_THICKNESS", {.description = "Wall thickness of the cylinder"}));
+        parameter<double>("WALL_THICKNESS", {.description = "Wall thickness of the cylinder"}));
     m->add_component(
-        entry<double>("AXIAL_PRESTRETCH", {.description = "Prestretch in axial direction"}));
-    m->add_component(entry<double>(
+        parameter<double>("AXIAL_PRESTRETCH", {.description = "Prestretch in axial direction"}));
+    m->add_component(parameter<double>(
         "CIRCUMFERENTIAL_PRESTRETCH", {.description = "Prestretch in circumferential direction"}));
     m->add_component(
-        entry<double>("PRESSURE", {.description = "Pressure in the inner of the cylinder"}));
+        parameter<double>("PRESSURE", {.description = "Pressure in the inner of the cylinder"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -4284,9 +4345,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "Simple iterative prestress strategy for any geometry. Needed to be used within the "
         "mixture framework.",
         Core::Materials::mix_prestress_strategy_iterative);
-    m->add_component(
-        entry<bool>("ACTIVE", {.description = "Flag whether prestretch tensor should be updated"}));
-    m->add_component(entry<bool>("ISOCHORIC",
+    m->add_component(parameter<bool>(
+        "ACTIVE", {.description = "Flag whether prestretch tensor should be updated"}));
+    m->add_component(parameter<bool>("ISOCHORIC",
         {.description = "Flag whether prestretch tensor is isochoric", .default_value = false}));
 
     Mat::append_material_definition(matlist, m);
@@ -4300,29 +4361,29 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
             "A 1D constituent that grows with the full constrained mixture fiber theory",
             Core::Materials::mix_full_constrained_mixture_fiber);
 
-    m->add_component(entry<int>("FIBER_ID", {.description = "Id of the fiber"}));
-    m->add_component(entry<int>("FIBER_MATERIAL_ID", {.description = "Id of fiber material"}));
-    m->add_component(entry<bool>("ENABLE_GROWTH",
+    m->add_component(parameter<int>("FIBER_ID", {.description = "Id of the fiber"}));
+    m->add_component(parameter<int>("FIBER_MATERIAL_ID", {.description = "Id of fiber material"}));
+    m->add_component(parameter<bool>("ENABLE_GROWTH",
         {.description = "Switch for the growth (default true)", .default_value = true}));
-    m->add_component(entry<bool>("ENABLE_BASAL_MASS_PRODUCTION",
+    m->add_component(parameter<bool>("ENABLE_BASAL_MASS_PRODUCTION",
         {.description = "Switch to enable the basal mass production rate (default true)",
             .default_value = true}));
     m->add_component(
-        entry<double>("DECAY_TIME", {.description = "Decay time of deposited tissue"}));
+        parameter<double>("DECAY_TIME", {.description = "Decay time of deposited tissue"}));
     m->add_component(
-        entry<double>("GROWTH_CONSTANT", {.description = "Growth constant of the tissue"}));
-    m->add_component(entry<double>(
+        parameter<double>("GROWTH_CONSTANT", {.description = "Growth constant of the tissue"}));
+    m->add_component(parameter<double>(
         "DEPOSITION_STRETCH", {.description = "Stretch at which the fiber is deposited"}));
-    m->add_component(entry<int>("INITIAL_DEPOSITION_STRETCH_TIMEFUNCT",
+    m->add_component(parameter<int>("INITIAL_DEPOSITION_STRETCH_TIMEFUNCT",
         {.description = "Id of the time function to scale the deposition stretch (Default: 0=None)",
             .default_value = 0}));
-    m->add_component(entry<int>("INIT",
+    m->add_component(parameter<int>("INIT",
         {.description = "Initialization mode for fibers (1=element fibers, 3=nodal fibers)"}));
-    m->add_component(entry<std::string>("ADAPTIVE_HISTORY_STRATEGY",
+    m->add_component(parameter<std::string>("ADAPTIVE_HISTORY_STRATEGY",
         {.description = "Strategy for adaptive history integration (none, model_equation, "
                         "higher_order)",
             .default_value = "none"}));
-    m->add_component(entry<double>("ADAPTIVE_HISTORY_TOLERANCE",
+    m->add_component(parameter<double>("ADAPTIVE_HISTORY_TOLERANCE",
         {.description = "Tolerance of the adaptive history", .default_value = 1e-6}));
 
     Mat::append_material_definition(matlist, m);
@@ -4335,29 +4396,29 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "A 1D constituent that remodels", Core::Materials::mix_remodelfiber_expl);
 
     m->add_component(
-        entry<int>("FIBER_ID", {.description = "Id of the fiber", .default_value = 1}));
-    m->add_component(entry<int>("FIBER_MATERIAL_ID", {.description = "Id of fiber material"}));
+        parameter<int>("FIBER_ID", {.description = "Id of the fiber", .default_value = 1}));
+    m->add_component(parameter<int>("FIBER_MATERIAL_ID", {.description = "Id of fiber material"}));
 
-    m->add_component(entry<bool>("ENABLE_GROWTH",
+    m->add_component(parameter<bool>("ENABLE_GROWTH",
         {.description = "Switch for the growth (default true)", .default_value = true}));
-    m->add_component(entry<bool>("ENABLE_BASAL_MASS_PRODUCTION",
+    m->add_component(parameter<bool>("ENABLE_BASAL_MASS_PRODUCTION",
         {.description = "Switch to enable the basal mass production rate (default true)",
             .default_value = true}));
     m->add_component(
-        entry<double>("DECAY_TIME", {.description = "Decay time of deposited tissue"}));
+        parameter<double>("DECAY_TIME", {.description = "Decay time of deposited tissue"}));
     m->add_component(
-        entry<double>("GROWTH_CONSTANT", {.description = "Growth constant of the tissue"}));
-    m->add_component(entry<double>(
+        parameter<double>("GROWTH_CONSTANT", {.description = "Growth constant of the tissue"}));
+    m->add_component(parameter<double>(
         "DEPOSITION_STRETCH", {.description = "Stretch at with the fiber is deposited"}));
-    m->add_component(entry<int>("DEPOSITION_STRETCH_TIMEFUNCT",
+    m->add_component(parameter<int>("DEPOSITION_STRETCH_TIMEFUNCT",
         {.description = "Id of the time function to scale the deposition stretch (Default: 0=None)",
             .default_value = 0}));
-    m->add_component(entry<bool>(
+    m->add_component(parameter<bool>(
         "INELASTIC_GROWTH", {.description = "Mixture rule has inelastic growth (default false)",
                                 .default_value = false}));
-    m->add_component(entry<int>("INIT",
+    m->add_component(parameter<int>("INIT",
         {.description = "Initialization mode for fibers (1=element fibers, 2=nodal fibers)"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "GAMMA", {.description = "Angle of fiber alignment in degree (default = 0.0 degrees)",
                      .default_value = 0.0}));
 
@@ -4370,24 +4431,24 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MIX_Constituent_ImplicitRemodelFiber",
         "A 1D constituent that remodels", Core::Materials::mix_remodelfiber_impl);
 
-    m->add_component(entry<int>("FIBER_ID", {.description = "Id of the fiber"}));
-    m->add_component(entry<int>("FIBER_MATERIAL_ID", {.description = "Id of fiber material"}));
+    m->add_component(parameter<int>("FIBER_ID", {.description = "Id of the fiber"}));
+    m->add_component(parameter<int>("FIBER_MATERIAL_ID", {.description = "Id of fiber material"}));
 
-    m->add_component(entry<bool>("ENABLE_GROWTH",
+    m->add_component(parameter<bool>("ENABLE_GROWTH",
         {.description = "Switch for the growth (default true)", .default_value = true}));
-    m->add_component(entry<bool>("ENABLE_BASAL_MASS_PRODUCTION",
+    m->add_component(parameter<bool>("ENABLE_BASAL_MASS_PRODUCTION",
         {.description = "Switch to enable the basal mass production rate (default true)",
             .default_value = true}));
     m->add_component(
-        entry<double>("DECAY_TIME", {.description = "Decay time of deposited tissue"}));
+        parameter<double>("DECAY_TIME", {.description = "Decay time of deposited tissue"}));
     m->add_component(
-        entry<double>("GROWTH_CONSTANT", {.description = "Growth constant of the tissue"}));
-    m->add_component(entry<double>(
+        parameter<double>("GROWTH_CONSTANT", {.description = "Growth constant of the tissue"}));
+    m->add_component(parameter<double>(
         "DEPOSITION_STRETCH", {.description = "Stretch at with the fiber is deposited"}));
-    m->add_component(entry<int>("DEPOSITION_STRETCH_TIMEFUNCT",
+    m->add_component(parameter<int>("DEPOSITION_STRETCH_TIMEFUNCT",
         {.description = "Id of the time function to scale the deposition stretch (Default: 0=None)",
             .default_value = 0}));
-    m->add_component(entry<int>("INIT",
+    m->add_component(parameter<int>("INIT",
         {.description = "Initialization mode for fibers (1=element fibers, 2=nodal fibers)"}));
 
     Mat::append_material_definition(matlist, m);
@@ -4402,11 +4463,11 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::mix_remodelfiber_material_exponential);
 
 
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "K1", {.description = "First parameter of exponential strain energy function"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "K2", {.description = "Second parameter of exponential strain energy function"}));
-    m->add_component(entry<bool>("COMPRESSION",
+    m->add_component(parameter<bool>("COMPRESSION",
         {.description = "Bool, whether the fiber material also supports compressive forces."}));
 
     Mat::append_material_definition(matlist, m);
@@ -4422,20 +4483,21 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::mix_remodelfiber_material_exponential_active);
 
 
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "K1", {.description = "First parameter of exponential strain energy function"}));
-    m->add_component(entry<double>(
+    m->add_component(parameter<double>(
         "K2", {.description = "Second parameter of exponential strain energy function"}));
-    m->add_component(entry<bool>("COMPRESSION",
+    m->add_component(parameter<bool>("COMPRESSION",
         {.description = "Bool, whether the fiber material also supports compressive forces."}));
-    m->add_component(entry<double>("SIGMA_MAX", {.description = "Maximum active Cauchy-stress"}));
     m->add_component(
-        entry<double>("LAMBDAMAX", {.description = "Stretch at maximum active Cauchy-stress"}));
+        parameter<double>("SIGMA_MAX", {.description = "Maximum active Cauchy-stress"}));
     m->add_component(
-        entry<double>("LAMBDA0", {.description = "Stretch at zero active Cauchy-stress"}));
+        parameter<double>("LAMBDAMAX", {.description = "Stretch at maximum active Cauchy-stress"}));
     m->add_component(
-        entry<double>("LAMBDAACT", {.description = "Current stretch", .default_value = 1.0}));
-    m->add_component(entry<double>("DENS", {.description = "Density of the whole mixture"}));
+        parameter<double>("LAMBDA0", {.description = "Stretch at zero active Cauchy-stress"}));
+    m->add_component(
+        parameter<double>("LAMBDAACT", {.description = "Current stretch", .default_value = 1.0}));
+    m->add_component(parameter<double>("DENS", {.description = "Density of the whole mixture"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -4447,9 +4509,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "A mixture rule where the mass fractions are scaled by functions of space and time",
         Core::Materials::mix_rule_function);
 
-    m->add_component(entry<double>("DENS", {.description = ""}));
-    m->add_component(entry<int>("NUMCONST", {.description = "number of mixture constituents"}));
-    m->add_component(entry<std::vector<int>>("MASSFRACFUNCT",
+    m->add_component(parameter<double>("DENS", {.description = ""}));
+    m->add_component(parameter<int>("NUMCONST", {.description = "number of mixture constituents"}));
+    m->add_component(parameter<std::vector<int>>("MASSFRACFUNCT",
         {.description = "list of functions (their ids) defining the mass fractions of the mixture "
                         "constituents",
             .size = from_parameter<int>("NUMCONST")}));
@@ -4464,8 +4526,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "A mixture rule where the mass fractions are defined elementwise as discrete values",
         Core::Materials::mix_rule_map);
 
-    m->add_component(entry<double>("DENS", {.description = ""}));
-    m->add_component(entry<int>("NUMCONST", {.description = "number of mixture constituents"}));
+    m->add_component(parameter<double>("DENS", {.description = ""}));
+    m->add_component(parameter<int>("NUMCONST", {.description = "number of mixture constituents"}));
 
     // definition of operation and print string for post processed component "MASSFRACMAPFILE"
     using mapType = std::unordered_map<int, std::vector<double>>;
@@ -4490,7 +4552,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
           Core::IO::convert_lines<mapType, mapType>(file_stream, map_reduction_operation));
     };
 
-    m->add_component(entry<std::filesystem::path>("MASSFRACMAPFILE",
+    m->add_component(parameter<std::filesystem::path>("MASSFRACMAPFILE",
         {
             .description =
                 "file path of pattern file defining the massfractions as discrete values",
@@ -4507,9 +4569,9 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MIX_Rule_Simple", "Simple mixture rule", Core::Materials::mix_rule_simple);
 
-    m->add_component(entry<double>("DENS", {.description = ""}));
-    m->add_component(entry<int>("NUMCONST", {.description = "number of mixture constituents"}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<double>("DENS", {.description = ""}));
+    m->add_component(parameter<int>("NUMCONST", {.description = "number of mixture constituents"}));
+    m->add_component(parameter<std::vector<double>>(
         "MASSFRAC", {.description = "list mass fractions of the mixture constituents",
                         .size = from_parameter<int>("NUMCONST")}));
 
@@ -4524,10 +4586,10 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         Core::Materials::mix_rule_growthremodel);
 
     m->add_component(
-        entry<int>("GROWTH_STRATEGY", {.description = "Material id of the growth strategy"}));
-    m->add_component(entry<double>("DENS", {.description = ""}));
-    m->add_component(entry<int>("NUMCONST", {.description = "number of mixture constituents"}));
-    m->add_component(entry<std::vector<double>>(
+        parameter<int>("GROWTH_STRATEGY", {.description = "Material id of the growth strategy"}));
+    m->add_component(parameter<double>("DENS", {.description = ""}));
+    m->add_component(parameter<int>("NUMCONST", {.description = "number of mixture constituents"}));
+    m->add_component(parameter<std::vector<double>>(
         "MASSFRAC", {.description = "list mass fractions of the mixture constituents",
                         .size = from_parameter<int>("NUMCONST")}));
 
@@ -4540,104 +4602,105 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>(
         "MAT_crystal_plasticity", " Crystal plasticity ", Core::Materials::m_crystplast);
     m->add_component(
-        entry<double>("TOL", {.description = "tolerance for internal Newton iteration"}));
-    m->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
-    m->add_component(entry<double>("NUE", {.description = "Poisson's ratio"}));
-    m->add_component(entry<double>("DENS", {.description = "Mass density"}));
-    m->add_component(entry<std::string>("LAT",
+        parameter<double>("TOL", {.description = "tolerance for internal Newton iteration"}));
+    m->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
+    m->add_component(parameter<double>("NUE", {.description = "Poisson's ratio"}));
+    m->add_component(parameter<double>("DENS", {.description = "Mass density"}));
+    m->add_component(parameter<std::string>("LAT",
         {.description = "lattice type: FCC, BCC, HCP, D019 or L10", .default_value = "FCC"}));
-    m->add_component(entry<double>("CTOA", {.description = "c to a ratio of crystal unit cell"}));
     m->add_component(
-        entry<double>("ABASE", {.description = "base length a of the crystal unit cell"}));
-    m->add_component(entry<int>("NUMSLIPSYS", {.description = "number of slip systems"}));
-    m->add_component(entry<int>("NUMSLIPSETS", {.description = "number of slip system sets"}));
-    m->add_component(entry<std::vector<int>>("SLIPSETMEMBERS",
+        parameter<double>("CTOA", {.description = "c to a ratio of crystal unit cell"}));
+    m->add_component(
+        parameter<double>("ABASE", {.description = "base length a of the crystal unit cell"}));
+    m->add_component(parameter<int>("NUMSLIPSYS", {.description = "number of slip systems"}));
+    m->add_component(parameter<int>("NUMSLIPSETS", {.description = "number of slip system sets"}));
+    m->add_component(parameter<std::vector<int>>("SLIPSETMEMBERS",
         {.description = "vector of NUMSLIPSYS indices ranging from 1 to NUMSLIPSETS that indicate "
                         "to which set each slip system belongs",
             .size = from_parameter<int>("NUMSLIPSYS")}));
-    m->add_component(entry<std::vector<int>>("SLIPRATEEXP",
+    m->add_component(parameter<std::vector<int>>("SLIPRATEEXP",
         {.description = "vector containing NUMSLIPSETS entries for the rate sensitivity exponent",
             .size = from_parameter<int>("NUMSLIPSETS")}));
-    m->add_component(entry<std::vector<double>>("GAMMADOTSLIPREF",
+    m->add_component(parameter<std::vector<double>>("GAMMADOTSLIPREF",
         {.description = "vector containing NUMSLIPSETS entries for the reference slip shear rate",
             .size = from_parameter<int>("NUMSLIPSETS")}));
-    m->add_component(entry<std::vector<double>>("DISDENSINIT",
+    m->add_component(parameter<std::vector<double>>("DISDENSINIT",
         {.description = "vector containing NUMSLIPSETS entries for the initial dislocation density",
             .size = from_parameter<int>("NUMSLIPSETS")}));
-    m->add_component(entry<std::vector<double>>("DISGENCOEFF",
+    m->add_component(parameter<std::vector<double>>("DISGENCOEFF",
         {.description =
                 "vector containing NUMSLIPSETS entries for the dislocation generation coefficients",
             .size = from_parameter<int>("NUMSLIPSETS")}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "DISDYNRECCOEFF", {.description = "vector containing NUMSLIPSETS entries for "
                                           "the coefficients for dynamic dislocation "
                                           "removal",
                               .size = from_parameter<int>("NUMSLIPSETS")}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "TAUY0", {.description = "vector containing NUMSLIPSETS entries for the "
                                  "lattice resistance to slip, e.g. the "
                                  "Peierls barrier",
                      .size = from_parameter<int>("NUMSLIPSETS")}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "MFPSLIP", {.description = "vector containing NUMSLIPSETS microstructural "
                                    "parameters that are relevant for Hall-Petch "
                                    "strengthening, e.g., grain size",
                        .size = from_parameter<int>("NUMSLIPSETS")}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "SLIPHPCOEFF", {.description = "vector containing NUMSLIPSETS entries for the Hall-Petch "
                                        "coefficients corresponding to "
                                        "the microstructural parameters given in MFPSLIP",
                            .size = from_parameter<int>("NUMSLIPSETS")}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "SLIPBYTWIN", {.description = "(optional) vector containing NUMSLIPSETS entries for the "
                                       "work hardening coefficients by "
                                       "twinning on non-coplanar systems",
                           .default_value = std::vector{0.},
                           .size = from_parameter<int>("NUMSLIPSETS")}));
-    m->add_component(entry<int>("NUMTWINSYS",
+    m->add_component(parameter<int>("NUMTWINSYS",
         {.description = "(optional) number of twinning systems", .default_value = 0}));
-    m->add_component(entry<int>("NUMTWINSETS",
+    m->add_component(parameter<int>("NUMTWINSETS",
         {.description = "(optional) number of sets of twinning systems", .default_value = 0}));
-    m->add_component(entry<std::vector<int>>("TWINSETMEMBERS",
+    m->add_component(parameter<std::vector<int>>("TWINSETMEMBERS",
         {.description = "(optional) vector of NUMTWINSYS indices ranging from 1 to NUMTWINSETS "
                         "that indicate to which set each slip system belongs",
             .default_value = std::vector{0},
             .size = from_parameter<int>("NUMTWINSYS")}));
-    m->add_component(entry<std::vector<int>>("TWINRATEEXP",
+    m->add_component(parameter<std::vector<int>>("TWINRATEEXP",
         {.description = "(optional) vector containing NUMTWINSETS entries for the rate sensitivity "
                         "exponent",
             .default_value = std::vector{0},
             .size = from_parameter<int>("NUMTWINSETS")}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "GAMMADOTTWINREF", {.description = "(optional) vector containing NUMTWINSETS entries for "
                                            "the reference slip shear rate",
                                .default_value = std::vector{0.},
                                .size = from_parameter<int>("NUMTWINSETS")}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "TAUT0", {.description = "(optional) vector containing NUMTWINSETS entries for the lattice "
                                  "resistance to twinning, "
                                  "e.g. the Peierls barrier",
                      .default_value = std::vector{0.},
                      .size = from_parameter<int>("NUMTWINSETS")}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "MFPTWIN", {.description = "(optional) vector containing NUMTWINSETS microstructural "
                                    "parameters that are relevant for "
                                    "Hall-Petch strengthening of twins, e.g., grain size",
                        .default_value = std::vector{0.},
                        .size = from_parameter<int>("NUMTWINSETS")}));
-    m->add_component(entry<std::vector<double>>("TWINHPCOEFF",
+    m->add_component(parameter<std::vector<double>>("TWINHPCOEFF",
         {.description =
                 "(optional) vector containing NUMTWINSETS entries for the Hall-Petch coefficients "
                 "corresponding to the microstructural parameters given in MFPTWIN",
             .default_value = std::vector{0.},
             .size = from_parameter<int>("NUMTWINSETS")}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "TWINBYSLIP", {.description = "(optional) vector containing NUMTWINSETS entries for the "
                                       "work hardening coefficients by "
                                       "slip",
                           .default_value = std::vector{0.},
                           .size = from_parameter<int>("NUMTWINSETS")}));
-    m->add_component(entry<std::vector<double>>(
+    m->add_component(parameter<std::vector<double>>(
         "TWINBYTWIN", {.description = "(optional) vector containing NUMTWINSETS entries for the "
                                       "work hardening coefficients by "
                                       "twins on non-coplanar systems",
@@ -4652,8 +4715,8 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
     auto m = std::make_shared<Mat::MaterialDefinition>("MAT_LinElast1D",
         "linear elastic material in one direction", Core::Materials::m_linelast1D);
 
-    m->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
-    m->add_component(entry<double>("DENS", {.description = "mass density"}));
+    m->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
+    m->add_component(parameter<double>("DENS", {.description = "mass density"}));
 
     Mat::append_material_definition(matlist, m);
   }
@@ -4665,16 +4728,16 @@ std::shared_ptr<std::vector<std::shared_ptr<Mat::MaterialDefinition>>> Global::v
         "linear elastic material with growth in one direction",
         Core::Materials::m_linelast1D_growth);
 
-    m->add_component(entry<double>("YOUNG", {.description = "Young's modulus"}));
-    m->add_component(entry<double>("DENS", {.description = "mass density"}));
-    m->add_component(entry<double>("C0", {.description = "reference concentration"}));
-    m->add_component(entry<bool>(
+    m->add_component(parameter<double>("YOUNG", {.description = "Young's modulus"}));
+    m->add_component(parameter<double>("DENS", {.description = "mass density"}));
+    m->add_component(parameter<double>("C0", {.description = "reference concentration"}));
+    m->add_component(parameter<bool>(
         "AOS_PROP_GROWTH", {.description = "growth proportional to amount of substance (AOS) if "
                                            "true or proportional to concentration "
                                            "if false"}));
     m->add_component(
-        entry<int>("POLY_PARA_NUM", {.description = "number of polynomial coefficients"}));
-    m->add_component(entry<std::vector<double>>(
+        parameter<int>("POLY_PARA_NUM", {.description = "number of polynomial coefficients"}));
+    m->add_component(parameter<std::vector<double>>(
         "POLY_PARAMS", {.description = "coefficients of polynomial",
                            .size = from_parameter<int>("POLY_PARA_NUM")}));
 
diff --git a/src/inpar/4C_inpar_beam_to_solid.cpp b/src/inpar/4C_inpar_beam_to_solid.cpp
index 6689cafb51f..fe2e9c3f932 100644
--- a/src/inpar/4C_inpar_beam_to_solid.cpp
+++ b/src/inpar/4C_inpar_beam_to_solid.cpp
@@ -387,7 +387,7 @@ void Inpar::BeamToSolid::set_valid_conditions(
         "Beam-to-volume mesh tying conditions - volume definition",
         Core::Conditions::BeamToSolidVolumeMeshtyingVolume, true,
         Core::Conditions::geometry_type_volume);
-    beam_to_solid_volume_meshtying_condition.add_component(entry<int>("COUPLING_ID"));
+    beam_to_solid_volume_meshtying_condition.add_component(parameter<int>("COUPLING_ID"));
     condlist.push_back(beam_to_solid_volume_meshtying_condition);
 
     beam_to_solid_volume_meshtying_condition = Core::Conditions::ConditionDefinition(
@@ -395,7 +395,7 @@ void Inpar::BeamToSolid::set_valid_conditions(
         "Beam-to-volume mesh tying conditions - line definition",
         Core::Conditions::BeamToSolidVolumeMeshtyingLine, true,
         Core::Conditions::geometry_type_line);
-    beam_to_solid_volume_meshtying_condition.add_component(entry<int>("COUPLING_ID"));
+    beam_to_solid_volume_meshtying_condition.add_component(parameter<int>("COUPLING_ID"));
     condlist.push_back(beam_to_solid_volume_meshtying_condition);
   }
 
@@ -411,7 +411,7 @@ void Inpar::BeamToSolid::set_valid_conditions(
         "Beam-to-surface mesh tying conditions - surface definition",
         Core::Conditions::BeamToSolidSurfaceMeshtyingSurface, true,
         Core::Conditions::geometry_type_surface);
-    beam_to_solid_surface_meshtying_condition.add_component(entry<int>("COUPLING_ID"));
+    beam_to_solid_surface_meshtying_condition.add_component(parameter<int>("COUPLING_ID"));
     condlist.push_back(beam_to_solid_surface_meshtying_condition);
 
     beam_to_solid_surface_meshtying_condition = Core::Conditions::ConditionDefinition(
@@ -419,7 +419,7 @@ void Inpar::BeamToSolid::set_valid_conditions(
         "Beam-to-surface mesh tying conditions - line definition",
         Core::Conditions::BeamToSolidSurfaceMeshtyingLine, true,
         Core::Conditions::geometry_type_line);
-    beam_to_solid_surface_meshtying_condition.add_component(entry<int>("COUPLING_ID"));
+    beam_to_solid_surface_meshtying_condition.add_component(parameter<int>("COUPLING_ID"));
     condlist.push_back(beam_to_solid_surface_meshtying_condition);
   }
 
@@ -435,7 +435,7 @@ void Inpar::BeamToSolid::set_valid_conditions(
         "Beam-to-surface contact conditions - surface definition",
         Core::Conditions::BeamToSolidSurfaceContactSurface, true,
         Core::Conditions::geometry_type_surface);
-    beam_to_solid_surface_contact_condition.add_component(entry<int>("COUPLING_ID"));
+    beam_to_solid_surface_contact_condition.add_component(parameter<int>("COUPLING_ID"));
     condlist.push_back(beam_to_solid_surface_contact_condition);
 
     beam_to_solid_surface_contact_condition =
@@ -443,7 +443,7 @@ void Inpar::BeamToSolid::set_valid_conditions(
             condition_names[0], "Beam-to-surface contact conditions - line definition",
             Core::Conditions::BeamToSolidSurfaceContactLine, true,
             Core::Conditions::geometry_type_line);
-    beam_to_solid_surface_contact_condition.add_component(entry<int>("COUPLING_ID"));
+    beam_to_solid_surface_contact_condition.add_component(parameter<int>("COUPLING_ID"));
     condlist.push_back(beam_to_solid_surface_contact_condition);
   }
 }
diff --git a/src/inpar/4C_inpar_beaminteraction.cpp b/src/inpar/4C_inpar_beaminteraction.cpp
index 71a4f4c17c0..40bf9e719c4 100644
--- a/src/inpar/4C_inpar_beaminteraction.cpp
+++ b/src/inpar/4C_inpar_beaminteraction.cpp
@@ -187,7 +187,7 @@ void Inpar::BeamInteraction::set_valid_conditions(
       "Beam_Line_Filament_Condition", Core::Conditions::FilamentBeamLineCondition, false,
       Core::Conditions::geometry_type_line);
 
-  beam_filament_condition.add_component(entry<int>("ID", {.description = "filament id"}));
+  beam_filament_condition.add_component(parameter<int>("ID", {.description = "filament id"}));
   beam_filament_condition.add_component(selection<std::string>("TYPE",
       {"Arbitrary", "arbitrary", "Actin", "actin", "Collagen", "collagen"},
       {.description = "", .default_value = "Arbitrary"}));
@@ -201,8 +201,8 @@ void Inpar::BeamInteraction::set_valid_conditions(
       Core::Conditions::PenaltyPointCouplingCondition, false,
       Core::Conditions::geometry_type_point);
 
-  penalty_coupling_condition.add_component(entry<double>("POSITIONAL_PENALTY_PARAMETER"));
-  penalty_coupling_condition.add_component(entry<double>("ROTATIONAL_PENALTY_PARAMETER"));
+  penalty_coupling_condition.add_component(parameter<double>("POSITIONAL_PENALTY_PARAMETER"));
+  penalty_coupling_condition.add_component(parameter<double>("ROTATIONAL_PENALTY_PARAMETER"));
 
   condlist.push_back(penalty_coupling_condition);
 
diff --git a/src/inpar/4C_inpar_beampotential.cpp b/src/inpar/4C_inpar_beampotential.cpp
index 115ffc987fd..6315b73df52 100644
--- a/src/inpar/4C_inpar_beampotential.cpp
+++ b/src/inpar/4C_inpar_beampotential.cpp
@@ -171,15 +171,15 @@ void Inpar::BeamPotential::set_valid_conditions(
       "Beam_Potential_Line_Charge_Density", Core::Conditions::BeamPotential_LineChargeDensity,
       false, Core::Conditions::geometry_type_line);
 
-  rigidsphere_potential_charge.add_component(entry<int>("POTLAW"));
-  rigidsphere_potential_charge.add_component(entry<double>("VAL"));
+  rigidsphere_potential_charge.add_component(parameter<int>("POTLAW"));
+  rigidsphere_potential_charge.add_component(parameter<double>("VAL"));
   rigidsphere_potential_charge.add_component(
-      entry<Noneable<int>>("FUNCT", {.description = "", .default_value = 0}));
+      parameter<Noneable<int>>("FUNCT", {.description = "", .default_value = 0}));
 
-  beam_potential_line_charge.add_component(entry<int>("POTLAW"));
-  beam_potential_line_charge.add_component(entry<double>("VAL"));
+  beam_potential_line_charge.add_component(parameter<int>("POTLAW"));
+  beam_potential_line_charge.add_component(parameter<double>("VAL"));
   beam_potential_line_charge.add_component(
-      entry<Noneable<int>>("FUNCT", {.description = "", .default_value = 0}));
+      parameter<Noneable<int>>("FUNCT", {.description = "", .default_value = 0}));
 
   condlist.push_back(rigidsphere_potential_charge);
   condlist.push_back(beam_potential_line_charge);
diff --git a/src/inpar/4C_inpar_bio.cpp b/src/inpar/4C_inpar_bio.cpp
index 75e908b3eae..220b0d965b2 100644
--- a/src/inpar/4C_inpar_bio.cpp
+++ b/src/inpar/4C_inpar_bio.cpp
@@ -91,8 +91,8 @@ void Inpar::ArteryNetwork::set_valid_conditions(
       "Artery junction boundary condition", Core::Conditions::ArtJunctionCond, true,
       Core::Conditions::geometry_type_point);
 
-  art_connection_bc.add_component(entry<int>("ConditionID"));
-  art_connection_bc.add_component(entry<double>("Kr"));
+  art_connection_bc.add_component(parameter<int>("ConditionID"));
+  art_connection_bc.add_component(parameter<double>("Kr"));
 
   condlist.push_back(art_connection_bc);
 
@@ -108,9 +108,10 @@ void Inpar::ArteryNetwork::set_valid_conditions(
   art_in_bc.add_component(selection<std::string>(
       "type", {"forced", "absorbing"}, {.description = "type", .default_value = "forced"}));
 
-  art_in_bc.add_component(entry<std::vector<double>>("VAL", {.description = "values", .size = 2}));
   art_in_bc.add_component(
-      entry<std::vector<Noneable<int>>>("curve", {.description = "curve ids", .size = 2}));
+      parameter<std::vector<double>>("VAL", {.description = "values", .size = 2}));
+  art_in_bc.add_component(
+      parameter<std::vector<Noneable<int>>>("curve", {.description = "curve ids", .size = 2}));
 
   condlist.push_back(art_in_bc);
 
@@ -120,9 +121,10 @@ void Inpar::ArteryNetwork::set_valid_conditions(
       "ArtRfCond", "Artery reflection condition", Core::Conditions::ArtRfCond, true,
       Core::Conditions::geometry_type_point);
 
-  art_rf_bc.add_component(entry<std::vector<double>>("VAL", {.description = "value", .size = 1}));
   art_rf_bc.add_component(
-      entry<std::vector<Noneable<int>>>("curve", {.description = "curve", .size = 1}));
+      parameter<std::vector<double>>("VAL", {.description = "value", .size = 1}));
+  art_rf_bc.add_component(
+      parameter<std::vector<Noneable<int>>>("curve", {.description = "curve", .size = 1}));
   condlist.push_back(art_rf_bc);
 
 
@@ -147,7 +149,7 @@ void Inpar::ArteryNetwork::set_valid_conditions(
       "Artery coupling with porofluid", Core::Conditions::ArtPorofluidCouplingCondNodebased, true,
       Core::Conditions::geometry_type_point);
 
-  artcoup.add_component(entry<int>("COUPID"));
+  artcoup.add_component(parameter<int>("COUPID"));
 
   condlist.push_back(artcoup);
 
@@ -159,7 +161,7 @@ void Inpar::ArteryNetwork::set_valid_conditions(
       "Artery coupling with porofluid", Core::Conditions::ArtScatraCouplingCondNodebased, true,
       Core::Conditions::geometry_type_point);
 
-  artscatracoup.add_component(entry<int>("COUPID"));
+  artscatracoup.add_component(parameter<int>("COUPID"));
 
   condlist.push_back(artscatracoup);
 
@@ -173,13 +175,13 @@ void Inpar::ArteryNetwork::set_valid_conditions(
 
   artcoup_ntp.add_component(selection<std::string>("COUPLING_TYPE", {"ARTERY", "AIRWAY"},
       {.description = "coupling type", .default_value = "ARTERY"}));
-  artcoup_ntp.add_component(entry<int>("NUMDOF"));
-  artcoup_ntp.add_component(entry<std::vector<int>>(
+  artcoup_ntp.add_component(parameter<int>("NUMDOF"));
+  artcoup_ntp.add_component(parameter<std::vector<int>>(
       "COUPLEDDOF_REDUCED", {.description = "coupling dofs of reduced airways or arteries",
                                 .size = from_parameter<int>("NUMDOF")}));
-  artcoup_ntp.add_component(entry<std::vector<int>>("COUPLEDDOF_PORO",
+  artcoup_ntp.add_component(parameter<std::vector<int>>("COUPLEDDOF_PORO",
       {.description = "coupling dofs in porous domain", .size = from_parameter<int>("NUMDOF")}));
-  artcoup_ntp.add_component(entry<double>("PENALTY"));
+  artcoup_ntp.add_component(parameter<double>("PENALTY"));
 
   condlist.push_back(artcoup_ntp);
 
@@ -193,13 +195,13 @@ void Inpar::ArteryNetwork::set_valid_conditions(
 
   artscatracoup_ntp.add_component(selection<std::string>("COUPLING_TYPE", {"ARTERY", "AIRWAY"},
       {.description = "coupling type", .default_value = "ARTERY"}));
-  artscatracoup_ntp.add_component(entry<int>("NUMDOF"));
-  artscatracoup_ntp.add_component(entry<std::vector<int>>(
+  artscatracoup_ntp.add_component(parameter<int>("NUMDOF"));
+  artscatracoup_ntp.add_component(parameter<std::vector<int>>(
       "COUPLEDDOF_REDUCED", {.description = "coupling dofs of reduced airways or arteries",
                                 .size = from_parameter<int>("NUMDOF")}));
-  artscatracoup_ntp.add_component(entry<std::vector<int>>("COUPLEDDOF_PORO",
+  artscatracoup_ntp.add_component(parameter<std::vector<int>>("COUPLEDDOF_PORO",
       {.description = "coupling dofs in porous domain", .size = from_parameter<int>("NUMDOF")}));
-  artscatracoup_ntp.add_component(entry<double>("PENALTY"));
+  artscatracoup_ntp.add_component(parameter<double>("PENALTY"));
 
   condlist.push_back(artscatracoup_ntp);
 }
@@ -247,7 +249,7 @@ void Inpar::BioFilm::set_valid_conditions(
       "BioGrCoupling", "BioGrCoupling", Core::Conditions::BioGrCoupling, true,
       Core::Conditions::geometry_type_surface);
 
-  surfbiogr.add_component(entry<int>("coupling_id", {.description = "coupling_id"}));
+  surfbiogr.add_component(parameter<int>("coupling_id", {.description = "coupling_id"}));
   condlist.push_back(surfbiogr);
 }
 
@@ -308,13 +310,13 @@ void Inpar::ReducedLung::set_valid_conditions(
       "Artery reduced D 3D coupling condition", Core::Conditions::ArtRedTo3DCouplingCond, true,
       Core::Conditions::geometry_type_point);
 
-  art_red_to_3d_bc.add_component(entry<int>("ConditionID"));
+  art_red_to_3d_bc.add_component(parameter<int>("ConditionID"));
   art_red_to_3d_bc.add_component(selection<std::string>("CouplingType", {"forced", "absorbing"},
       {.description = "coupling type", .default_value = "forced"}));
   art_red_to_3d_bc.add_component(selection<std::string>("ReturnedVariable", {"pressure", "flow"},
       {.description = "returned variable", .default_value = "pressure"}));
-  art_red_to_3d_bc.add_component(entry<double>("Tolerance"));
-  art_red_to_3d_bc.add_component(entry<int>("MaximumIterations"));
+  art_red_to_3d_bc.add_component(parameter<double>("Tolerance"));
+  art_red_to_3d_bc.add_component(parameter<int>("MaximumIterations"));
 
   condlist.push_back(art_red_to_3d_bc);
 
@@ -325,11 +327,11 @@ void Inpar::ReducedLung::set_valid_conditions(
       "Artery 3D reduced D coupling condition", Core::Conditions::Art3DToRedCouplingCond, true,
       Core::Conditions::geometry_type_surface);
 
-  art_3d_to_red_bc.add_component(entry<int>("ConditionID"));
+  art_3d_to_red_bc.add_component(parameter<int>("ConditionID"));
   art_3d_to_red_bc.add_component(selection<std::string>("ReturnedVariable", {"pressure", "flow"},
       {.description = "returned variable", .default_value = "flow"}));
-  art_3d_to_red_bc.add_component(entry<double>("Tolerance"));
-  art_3d_to_red_bc.add_component(entry<int>("MaximumIterations"));
+  art_3d_to_red_bc.add_component(parameter<double>("Tolerance"));
+  art_3d_to_red_bc.add_component(parameter<int>("MaximumIterations"));
 
   condlist.push_back(art_3d_to_red_bc);
 
@@ -340,7 +342,7 @@ void Inpar::ReducedLung::set_valid_conditions(
       "SurfaceNeumann", "tissue RedAirway coupling surface condition",
       Core::Conditions::RedAirwayTissue, true, Core::Conditions::geometry_type_surface);
 
-  surfredairtis.add_component(entry<int>("coupling_id"));
+  surfredairtis.add_component(parameter<int>("coupling_id"));
 
   condlist.push_back(surfredairtis);
 
@@ -352,7 +354,7 @@ void Inpar::ReducedLung::set_valid_conditions(
       "RedAirwayPrescribedCond", "tissue RedAirway coupling node condition",
       Core::Conditions::RedAirwayNodeTissue, true, Core::Conditions::geometry_type_point);
 
-  noderedairtis.add_component(entry<int>("coupling_id"));
+  noderedairtis.add_component(parameter<int>("coupling_id"));
 
   condlist.push_back(noderedairtis);
 
@@ -371,10 +373,11 @@ void Inpar::ReducedLung::set_valid_conditions(
       {.description = "boundary condition type", .default_value = "flow"}));
 
   // reduced airway inlet components
-  raw_in_bc.add_component(entry<std::vector<double>>("VAL", {.description = "value", .size = 1}));
   raw_in_bc.add_component(
-      entry<std::vector<Noneable<int>>>("curve", {.description = "curve", .size = 2}));
-  raw_in_bc.add_component(entry<std::vector<Noneable<int>>>(
+      parameter<std::vector<double>>("VAL", {.description = "value", .size = 1}));
+  raw_in_bc.add_component(
+      parameter<std::vector<Noneable<int>>>("curve", {.description = "curve", .size = 2}));
+  raw_in_bc.add_component(parameter<std::vector<Noneable<int>>>(
       "funct", {.description = "function id", .default_value = std::vector{none<int>}, .size = 1}));
 
   condlist.push_back(raw_in_bc);
@@ -388,9 +391,9 @@ void Inpar::ReducedLung::set_valid_conditions(
       "RedAirwaySwitchFlowPressureCond", "Reduced d airway switch flow pressure boundary condition",
       Core::Conditions::RedAirwayPrescribedSwitchCond, true, Core::Conditions::geometry_type_point);
 
-  raw_in_switch_bc.add_component(entry<int>("FUNCT_ID_FLOW"));
-  raw_in_switch_bc.add_component(entry<int>("FUNCT_ID_PRESSURE"));
-  raw_in_switch_bc.add_component(entry<int>("FUNCT_ID_PRESSURE_ACTIVE"));
+  raw_in_switch_bc.add_component(parameter<int>("FUNCT_ID_FLOW"));
+  raw_in_switch_bc.add_component(parameter<int>("FUNCT_ID_PRESSURE"));
+  raw_in_switch_bc.add_component(parameter<int>("FUNCT_ID_PRESSURE_ACTIVE"));
 
   condlist.push_back(raw_in_switch_bc);
 
@@ -409,19 +412,19 @@ void Inpar::ReducedLung::set_valid_conditions(
           "Nonlinear_Exponential", "Nonlinear_Ogden"},
       {.description = "type", .default_value = "Linear_Exponential"}));
 
-  raw_volPpl_bc.add_component(entry<double>("TLC"));
-  raw_volPpl_bc.add_component(entry<double>("RV"));
+  raw_volPpl_bc.add_component(parameter<double>("TLC"));
+  raw_volPpl_bc.add_component(parameter<double>("RV"));
 
-  raw_volPpl_bc.add_component(entry<double>("P_PLEURAL_0"));
-  raw_volPpl_bc.add_component(entry<double>("P_PLEURAL_LIN"));
-  raw_volPpl_bc.add_component(entry<double>("P_PLEURAL_NONLIN"));
-  raw_volPpl_bc.add_component(entry<double>("TAU"));
+  raw_volPpl_bc.add_component(parameter<double>("P_PLEURAL_0"));
+  raw_volPpl_bc.add_component(parameter<double>("P_PLEURAL_LIN"));
+  raw_volPpl_bc.add_component(parameter<double>("P_PLEURAL_NONLIN"));
+  raw_volPpl_bc.add_component(parameter<double>("TAU"));
 
   // raw_volPpl_bc_components
   raw_volPpl_bc.add_component(
-      entry<std::vector<double>>("VAL", {.description = "value", .size = 1}));
+      parameter<std::vector<double>>("VAL", {.description = "value", .size = 1}));
   raw_volPpl_bc.add_component(
-      entry<std::vector<Noneable<int>>>("curve", {.description = "curve", .size = 1}));
+      parameter<std::vector<Noneable<int>>>("curve", {.description = "curve", .size = 1}));
 
   condlist.push_back(raw_volPpl_bc);
 
@@ -444,15 +447,15 @@ void Inpar::ReducedLung::set_valid_conditions(
       "ImpedanceCond", "Impedance boundary condition", Core::Conditions::ImpedanceCond, true,
       Core::Conditions::geometry_type_surface);
 
-  impedancebc.add_component(entry<int>("ConditionID"));
+  impedancebc.add_component(parameter<int>("ConditionID"));
   impedancebc.add_component(
       selection<std::string>("TYPE", {"windkessel", "resistive", "pressure_by_funct"},
           {.description = "type", .default_value = "windkessel"}));
-  impedancebc.add_component(entry<double>("R1"));
-  impedancebc.add_component(entry<double>("R2"));
-  impedancebc.add_component(entry<double>("C"));
-  impedancebc.add_component(entry<double>("TIMEPERIOD"));
-  impedancebc.add_component(entry<int>("FUNCT"));
+  impedancebc.add_component(parameter<double>("R1"));
+  impedancebc.add_component(parameter<double>("R2"));
+  impedancebc.add_component(parameter<double>("C"));
+  impedancebc.add_component(parameter<double>("TIMEPERIOD"));
+  impedancebc.add_component(parameter<int>("FUNCT"));
 
   condlist.push_back(impedancebc);
 }
diff --git a/src/inpar/4C_inpar_cardiovascular0d.cpp b/src/inpar/4C_inpar_cardiovascular0d.cpp
index 91266f08bd1..68409862a90 100644
--- a/src/inpar/4C_inpar_cardiovascular0d.cpp
+++ b/src/inpar/4C_inpar_cardiovascular0d.cpp
@@ -539,13 +539,13 @@ void Inpar::Cardiovascular0D::set_valid_conditions(
       Core::Conditions::Cardiovascular0D4ElementWindkessel_Structure, true,
       Core::Conditions::geometry_type_surface);
 
-  cardiovascular0d4elementwindkesselcondition.add_component(entry<int>("id"));
-  cardiovascular0d4elementwindkesselcondition.add_component(entry<double>("C"));
-  cardiovascular0d4elementwindkesselcondition.add_component(entry<double>("R_p"));
-  cardiovascular0d4elementwindkesselcondition.add_component(entry<double>("Z_c"));
-  cardiovascular0d4elementwindkesselcondition.add_component(entry<double>("L"));
-  cardiovascular0d4elementwindkesselcondition.add_component(entry<double>("p_ref"));
-  cardiovascular0d4elementwindkesselcondition.add_component(entry<double>("p_0"));
+  cardiovascular0d4elementwindkesselcondition.add_component(parameter<int>("id"));
+  cardiovascular0d4elementwindkesselcondition.add_component(parameter<double>("C"));
+  cardiovascular0d4elementwindkesselcondition.add_component(parameter<double>("R_p"));
+  cardiovascular0d4elementwindkesselcondition.add_component(parameter<double>("Z_c"));
+  cardiovascular0d4elementwindkesselcondition.add_component(parameter<double>("L"));
+  cardiovascular0d4elementwindkesselcondition.add_component(parameter<double>("p_ref"));
+  cardiovascular0d4elementwindkesselcondition.add_component(parameter<double>("p_0"));
 
   condlist.push_back(cardiovascular0d4elementwindkesselcondition);
 
@@ -560,25 +560,25 @@ void Inpar::Cardiovascular0D::set_valid_conditions(
       Core::Conditions::Cardiovascular0DArterialProxDist_Structure, true,
       Core::Conditions::geometry_type_surface);
 
-  cardiovascular0darterialproxdistcond.add_component(entry<int>("id"));
-  cardiovascular0darterialproxdistcond.add_component(entry<double>("R_arvalve_max"));
-  cardiovascular0darterialproxdistcond.add_component(entry<double>("R_arvalve_min"));
-  cardiovascular0darterialproxdistcond.add_component(entry<double>("R_atvalve_max"));
-  cardiovascular0darterialproxdistcond.add_component(entry<double>("R_atvalve_min"));
-  cardiovascular0darterialproxdistcond.add_component(entry<double>("k_p"));
-  cardiovascular0darterialproxdistcond.add_component(entry<double>("L_arp"));
-  cardiovascular0darterialproxdistcond.add_component(entry<double>("C_arp"));
-  cardiovascular0darterialproxdistcond.add_component(entry<double>("R_arp"));
-  cardiovascular0darterialproxdistcond.add_component(entry<double>("C_ard"));
-  cardiovascular0darterialproxdistcond.add_component(entry<double>("R_ard"));
-  cardiovascular0darterialproxdistcond.add_component(entry<double>("p_ref"));
-  cardiovascular0darterialproxdistcond.add_component(entry<double>("p_v_0"));
-  cardiovascular0darterialproxdistcond.add_component(entry<double>("p_arp_0"));
-  cardiovascular0darterialproxdistcond.add_component(entry<double>("y_arp_0"));
-  cardiovascular0darterialproxdistcond.add_component(entry<double>("p_ard_0"));
-  cardiovascular0darterialproxdistcond.add_component(entry<double>("p_at_fac"));
+  cardiovascular0darterialproxdistcond.add_component(parameter<int>("id"));
+  cardiovascular0darterialproxdistcond.add_component(parameter<double>("R_arvalve_max"));
+  cardiovascular0darterialproxdistcond.add_component(parameter<double>("R_arvalve_min"));
+  cardiovascular0darterialproxdistcond.add_component(parameter<double>("R_atvalve_max"));
+  cardiovascular0darterialproxdistcond.add_component(parameter<double>("R_atvalve_min"));
+  cardiovascular0darterialproxdistcond.add_component(parameter<double>("k_p"));
+  cardiovascular0darterialproxdistcond.add_component(parameter<double>("L_arp"));
+  cardiovascular0darterialproxdistcond.add_component(parameter<double>("C_arp"));
+  cardiovascular0darterialproxdistcond.add_component(parameter<double>("R_arp"));
+  cardiovascular0darterialproxdistcond.add_component(parameter<double>("C_ard"));
+  cardiovascular0darterialproxdistcond.add_component(parameter<double>("R_ard"));
+  cardiovascular0darterialproxdistcond.add_component(parameter<double>("p_ref"));
+  cardiovascular0darterialproxdistcond.add_component(parameter<double>("p_v_0"));
+  cardiovascular0darterialproxdistcond.add_component(parameter<double>("p_arp_0"));
+  cardiovascular0darterialproxdistcond.add_component(parameter<double>("y_arp_0"));
+  cardiovascular0darterialproxdistcond.add_component(parameter<double>("p_ard_0"));
+  cardiovascular0darterialproxdistcond.add_component(parameter<double>("p_at_fac"));
   cardiovascular0darterialproxdistcond.add_component(
-      entry<Noneable<int>>("p_at_crv", {.description = "curve"}));
+      parameter<Noneable<int>>("p_at_crv", {.description = "curve"}));
   condlist.push_back(cardiovascular0darterialproxdistcond);
 
   /*--------------------------------------------------------------------*/
@@ -592,7 +592,7 @@ void Inpar::Cardiovascular0D::set_valid_conditions(
       Core::Conditions::Cardiovascular0DSysPulCirculation_Structure, true,
       Core::Conditions::geometry_type_surface);
 
-  cardiovascular0dsyspulcirculationcond.add_component(entry<int>("id"));
+  cardiovascular0dsyspulcirculationcond.add_component(parameter<int>("id"));
   cardiovascular0dsyspulcirculationcond.add_component(selection<std::string>("TYPE",
       {"ventricle_left", "ventricle_right", "atrium_left", "atrium_right", "dummy"},
       {.description = ""}));
@@ -610,7 +610,7 @@ void Inpar::Cardiovascular0D::set_valid_conditions(
       Core::Conditions::CardiovascularRespiratory0DSysPulPeriphCirculation_Structure, true,
       Core::Conditions::geometry_type_surface);
 
-  cardiovascularrespiratory0dsyspulperiphcirculationcond.add_component(entry<int>("id"));
+  cardiovascularrespiratory0dsyspulperiphcirculationcond.add_component(parameter<int>("id"));
   cardiovascularrespiratory0dsyspulperiphcirculationcond.add_component(selection<std::string>(
       "TYPE", {"ventricle_left", "ventricle_right", "atrium_left", "atrium_right", "dummy"},
       {.description = ""}));
@@ -628,7 +628,7 @@ void Inpar::Cardiovascular0D::set_valid_conditions(
       Core::Conditions::Cardiovascular0DStructureCoupling, true,
       Core::Conditions::geometry_type_surface);
 
-  cardiovascular0dstructurecouplingcond.add_component(entry<int>("coupling_id"));
+  cardiovascular0dstructurecouplingcond.add_component(parameter<int>("coupling_id"));
 
   condlist.push_back(cardiovascular0dstructurecouplingcond);
 }
diff --git a/src/inpar/4C_inpar_ehl.cpp b/src/inpar/4C_inpar_ehl.cpp
index e401733ed9c..d9786f9cf96 100644
--- a/src/inpar/4C_inpar_ehl.cpp
+++ b/src/inpar/4C_inpar_ehl.cpp
@@ -148,12 +148,13 @@ void Inpar::EHL::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
 
   const auto make_ehl_cond = [&condlist](Core::Conditions::ConditionDefinition& cond)
   {
-    cond.add_component(entry<int>("InterfaceID"));
+    cond.add_component(parameter<int>("InterfaceID"));
     cond.add_component(
         selection<std::string>("Side", {"Master", "Slave"}, {.description = "interface side"}));
     cond.add_component(selection<std::string>("Initialization", {"Inactive", "Active"},
         {.description = "initialization", .default_value = "Active"}));
-    cond.add_component(entry<double>("FrCoeffOrBound", {.description = "", .default_value = 0.0}));
+    cond.add_component(
+        parameter<double>("FrCoeffOrBound", {.description = "", .default_value = 0.0}));
 
     condlist.push_back(cond);
   };
diff --git a/src/inpar/4C_inpar_elch.cpp b/src/inpar/4C_inpar_elch.cpp
index 864b25f5563..e2c77468ec2 100644
--- a/src/inpar/4C_inpar_elch.cpp
+++ b/src/inpar/4C_inpar_elch.cpp
@@ -188,10 +188,10 @@ void Inpar::ElCh::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
     const auto make_electrodesoc = [&condlist](Core::Conditions::ConditionDefinition& cond)
     {
       // insert input file line components into condition definitions
-      cond.add_component(entry<int>("ConditionID"));
-      cond.add_component(entry<double>("C_0%"));
-      cond.add_component(entry<double>("C_100%"));
-      cond.add_component(entry<double>("ONE_HOUR"));
+      cond.add_component(parameter<int>("ConditionID"));
+      cond.add_component(parameter<double>("C_0%"));
+      cond.add_component(parameter<double>("C_100%"));
+      cond.add_component(parameter<double>("ONE_HOUR"));
 
       // insert condition definitions into global list of valid condition definitions
       condlist.emplace_back(cond);
@@ -222,7 +222,7 @@ void Inpar::ElCh::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
     const auto make_cellvoltage = [&condlist](Core::Conditions::ConditionDefinition& cond)
     {
       // insert input file line components into condition definitions
-      cond.add_component(entry<int>("ConditionID"));
+      cond.add_component(parameter<int>("ConditionID"));
 
       // insert condition definitions into global list of valid condition definitions
       condlist.emplace_back(cond);
@@ -247,52 +247,52 @@ void Inpar::ElCh::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
                     {"Butler-Volmer-Yang1997",
                         Inpar::ElCh::ElectrodeKinetics::butler_volmer_yang1997},
                 }),
-            entry<double>("ALPHA_A"),
-            entry<double>("ALPHA_C"),
-            entry<double>("I0"),
-            entry<double>("GAMMA"),
-            entry<double>("REFCON"),
-            entry<double>("DL_SPEC_CAP"),
+            parameter<double>("ALPHA_A"),
+            parameter<double>("ALPHA_C"),
+            parameter<double>("I0"),
+            parameter<double>("GAMMA"),
+            parameter<double>("REFCON"),
+            parameter<double>("DL_SPEC_CAP"),
         }),
         all_of({
             selection<int>("KINETIC_MODEL", {{"Tafel", Inpar::ElCh::ElectrodeKinetics::tafel}}),
-            entry<double>("ALPHA"),
-            entry<double>("I0"),
-            entry<double>("GAMMA"),
-            entry<double>("REFCON"),
-            entry<double>("DL_SPEC_CAP"),
+            parameter<double>("ALPHA"),
+            parameter<double>("I0"),
+            parameter<double>("GAMMA"),
+            parameter<double>("REFCON"),
+            parameter<double>("DL_SPEC_CAP"),
         }),
         all_of({
             selection<int>("KINETIC_MODEL", {{"linear", Inpar::ElCh::ElectrodeKinetics::linear}}),
-            entry<double>("ALPHA"),
-            entry<double>("I0"),
-            entry<double>("GAMMA"),
-            entry<double>("REFCON"),
-            entry<double>("DL_SPEC_CAP"),
+            parameter<double>("ALPHA"),
+            parameter<double>("I0"),
+            parameter<double>("GAMMA"),
+            parameter<double>("REFCON"),
+            parameter<double>("DL_SPEC_CAP"),
         }),
         all_of({
             selection<int>("KINETIC_MODEL",
                 {{"Butler-Volmer-Newman", Inpar::ElCh::ElectrodeKinetics::butler_volmer_newman}}),
-            entry<double>("K_A"),
-            entry<double>("K_C"),
-            entry<double>("BETA"),
-            entry<double>("DL_SPEC_CAP"),
+            parameter<double>("K_A"),
+            parameter<double>("K_C"),
+            parameter<double>("BETA"),
+            parameter<double>("DL_SPEC_CAP"),
         }),
         all_of({
             selection<int>("KINETIC_MODEL",
                 {{"Butler-Volmer-Bard", Inpar::ElCh::ElectrodeKinetics::butler_volmer_bard}}),
-            entry<double>("E0"),
-            entry<double>("K0"),
-            entry<double>("BETA"),
-            entry<double>("C_C0"),
-            entry<double>("C_A0"),
-            entry<double>("DL_SPEC_CAP"),
+            parameter<double>("E0"),
+            parameter<double>("K0"),
+            parameter<double>("BETA"),
+            parameter<double>("C_C0"),
+            parameter<double>("C_A0"),
+            parameter<double>("DL_SPEC_CAP"),
         }),
         all_of({
             selection<int>("KINETIC_MODEL", {{"Nernst", Inpar::ElCh::ElectrodeKinetics::nernst}}),
-            entry<double>("E0"),
-            entry<double>("C0"),
-            entry<double>("DL_SPEC_CAP"),
+            parameter<double>("E0"),
+            parameter<double>("C0"),
+            parameter<double>("DL_SPEC_CAP"),
         }),
     });
 
@@ -315,17 +315,17 @@ void Inpar::ElCh::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
     const auto make_electrodeboundarykinetics = [&condlist, &reaction_model_choices](
                                                     Core::Conditions::ConditionDefinition& cond)
     {
-      cond.add_component(entry<int>("ConditionID"));
-      cond.add_component(entry<double>("POT"));
-      cond.add_component(entry<Noneable<int>>("FUNCT", {.description = ""}));
-      cond.add_component(entry<int>("NUMSCAL"));
-      cond.add_component(entry<std::vector<int>>(
+      cond.add_component(parameter<int>("ConditionID"));
+      cond.add_component(parameter<double>("POT"));
+      cond.add_component(parameter<Noneable<int>>("FUNCT", {.description = ""}));
+      cond.add_component(parameter<int>("NUMSCAL"));
+      cond.add_component(parameter<std::vector<int>>(
           "STOICH", {.description = "", .size = from_parameter<int>("NUMSCAL")}));
-      cond.add_component(entry<int>("E-"));
-      cond.add_component(
-          entry<double>("EPSILON", {.description = "porosity of electrode boundary, set to -1 if "
-                                                   "equal to porosity of electrolyte domain"}));
-      cond.add_component(entry<int>("ZERO_CUR"));
+      cond.add_component(parameter<int>("E-"));
+      cond.add_component(parameter<double>(
+          "EPSILON", {.description = "porosity of electrode boundary, set to -1 if "
+                                     "equal to porosity of electrolyte domain"}));
+      cond.add_component(parameter<int>("ZERO_CUR"));
       cond.add_component(reaction_model_choices);
       condlist.emplace_back(cond);
     };
@@ -356,24 +356,24 @@ void Inpar::ElCh::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
 
     // equip condition definition with input file line components
     auto electrodedomainkineticscomponents = all_of({
-        entry<int>("ConditionID"),
-        entry<double>("POT"),
-        entry<Core::IO::Noneable<int>>("FUNCT"),
-        entry<int>("NUMSCAL"),
-        entry<std::vector<int>>("STOICH", {.size = from_parameter<int>("NUMSCAL")}),
-        entry<int>("E-"),
-        entry<int>("ZERO_CUR"),
+        parameter<int>("ConditionID"),
+        parameter<double>("POT"),
+        parameter<Core::IO::Noneable<int>>("FUNCT"),
+        parameter<int>("NUMSCAL"),
+        parameter<std::vector<int>>("STOICH", {.size = from_parameter<int>("NUMSCAL")}),
+        parameter<int>("E-"),
+        parameter<int>("ZERO_CUR"),
         selection<int>("KINETIC_MODEL",
             {
                 {"Butler-Volmer", Inpar::ElCh::ElectrodeKinetics::butler_volmer},
             }),
-        entry<double>("A_S"),
-        entry<double>("ALPHA_A"),
-        entry<double>("ALPHA_C"),
-        entry<double>("I0"),
-        entry<double>("GAMMA"),
-        entry<double>("REFCON"),
-        entry<double>("DL_SPEC_CAP"),
+        parameter<double>("A_S"),
+        parameter<double>("ALPHA_A"),
+        parameter<double>("ALPHA_C"),
+        parameter<double>("I0"),
+        parameter<double>("GAMMA"),
+        parameter<double>("REFCON"),
+        parameter<double>("DL_SPEC_CAP"),
     });
 
     {
@@ -411,16 +411,17 @@ void Inpar::ElCh::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
   {
     // insert input file line components into condition definitions
     {
-      cond.add_component(entry<int>("NUMBER_OF_HALF_CYCLES"));
+      cond.add_component(parameter<int>("NUMBER_OF_HALF_CYCLES"));
+      cond.add_component(parameter<int>(
+          "BEGIN_WITH_CHARGING"));  // Boolean parameter represented by integer parameter
+      cond.add_component(parameter<Noneable<int>>("CONDITION_ID_FOR_CHARGE", {.description = ""}));
       cond.add_component(
-          entry<int>("BEGIN_WITH_CHARGING"));  // Boolean parameter represented by integer parameter
-      cond.add_component(entry<Noneable<int>>("CONDITION_ID_FOR_CHARGE", {.description = ""}));
-      cond.add_component(entry<Noneable<int>>("CONDITION_ID_FOR_DISCHARGE", {.description = ""}));
-      cond.add_component(entry<double>("INIT_RELAX_TIME"));
-      cond.add_component(entry<int>("ADAPTIVE_TIME_STEPPING_INIT_RELAX"));
-      cond.add_component(entry<Noneable<int>>("NUM_ADD_ADAPT_TIME_STEPS", {.description = ""}));
+          parameter<Noneable<int>>("CONDITION_ID_FOR_DISCHARGE", {.description = ""}));
+      cond.add_component(parameter<double>("INIT_RELAX_TIME"));
+      cond.add_component(parameter<int>("ADAPTIVE_TIME_STEPPING_INIT_RELAX"));
+      cond.add_component(parameter<Noneable<int>>("NUM_ADD_ADAPT_TIME_STEPS", {.description = ""}));
       cond.add_component(
-          entry<Noneable<int>>("MIN_TIME_STEPS_DURING_INIT_RELAX", {.description = ""}));
+          parameter<Noneable<int>>("MIN_TIME_STEPS_DURING_INIT_RELAX", {.description = ""}));
 
       // insert condition definitions into global list of valid condition definitions
       condlist.emplace_back(cond);
@@ -453,14 +454,14 @@ void Inpar::ElCh::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
   const auto make_cccvhalfcycle = [&condlist](Core::Conditions::ConditionDefinition& cond)
   {
     // insert input file line components into condition definitions
-    cond.add_component(entry<int>("ConditionID"));
-    cond.add_component(entry<double>("CURRENT"));
-    cond.add_component(entry<double>("CUT_OFF_VOLTAGE"));
-    cond.add_component(entry<double>("CUT_OFF_C_RATE"));
-    cond.add_component(entry<double>("RELAX_TIME"));
+    cond.add_component(parameter<int>("ConditionID"));
+    cond.add_component(parameter<double>("CURRENT"));
+    cond.add_component(parameter<double>("CUT_OFF_VOLTAGE"));
+    cond.add_component(parameter<double>("CUT_OFF_C_RATE"));
+    cond.add_component(parameter<double>("RELAX_TIME"));
     // switch adaptive time stepping on for different phases of half cycle: 1st: end of constant
     // current, 2nd: end of constant voltage, 3rd: end of relaxation
-    cond.add_component(entry<std::vector<int>>(
+    cond.add_component(parameter<std::vector<int>>(
         "ADAPTIVE_TIME_STEPPING_PHASE_ON_OFF", {.description = "", .size = 3}));
 
     // insert condition definitions into global list of valid condition definitions
diff --git a/src/inpar/4C_inpar_elemag.cpp b/src/inpar/4C_inpar_elemag.cpp
index dc29ba159ff..be8e7c13140 100644
--- a/src/inpar/4C_inpar_elemag.cpp
+++ b/src/inpar/4C_inpar_elemag.cpp
@@ -129,12 +129,12 @@ void Inpar::EleMag::set_valid_conditions(
 
   const auto make_silvermueller = [&condlist](Core::Conditions::ConditionDefinition& cond)
   {
-    cond.add_component(entry<int>("NUMDOF"));
-    cond.add_component(entry<std::vector<int>>(
+    cond.add_component(parameter<int>("NUMDOF"));
+    cond.add_component(parameter<std::vector<int>>(
         "ONOFF", {.description = "", .size = from_parameter<int>("NUMDOF")}));
-    cond.add_component(entry<std::vector<Noneable<int>>>(
+    cond.add_component(parameter<std::vector<Noneable<int>>>(
         "FUNCT", {.description = "", .required = false, .size = from_parameter<int>("NUMDOF")}));
-    cond.add_component(entry<std::vector<double>>(
+    cond.add_component(parameter<std::vector<double>>(
         "VAL", {.description = "", .size = from_parameter<int>("NUMDOF")}));
 
     condlist.push_back(cond);
diff --git a/src/inpar/4C_inpar_fluid.cpp b/src/inpar/4C_inpar_fluid.cpp
index a8bea312915..e45068d801b 100644
--- a/src/inpar/4C_inpar_fluid.cpp
+++ b/src/inpar/4C_inpar_fluid.cpp
@@ -1298,12 +1298,12 @@ void Inpar::FLUID::set_valid_conditions(
       "TransferTurbulentInflow", "TransferTurbulentInflow",
       Core::Conditions::TransferTurbulentInflow, true, Core::Conditions::geometry_type_surface);
 
-  tbc_turb_inflow.add_component(entry<int>("ID", {.description = ""}));
+  tbc_turb_inflow.add_component(parameter<int>("ID", {.description = ""}));
   tbc_turb_inflow.add_component(
       selection<std::string>("toggle", {"master", "slave"}, {.description = "toggle"}));
   tbc_turb_inflow.add_component(selection<int>("DIRECTION", {{"x", 0}, {"y", 1}, {"z", 2}},
       {.description = "transfer direction", .default_value = 0}));
-  tbc_turb_inflow.add_component(entry<Noneable<int>>(
+  tbc_turb_inflow.add_component(parameter<Noneable<int>>(
       "curve", {.description = "curve id", .default_value = Core::IO::none<int>}));
 
   condlist.push_back(tbc_turb_inflow);
@@ -1330,17 +1330,17 @@ void Inpar::FLUID::set_valid_conditions(
   // (out)flow rate or (out)flow volume (e.g., for air-cushion condition)
   surfflowdeppressure.add_component(selection<std::string>("TYPE_OF_FLOW_DEPENDENCE",
       {"flow_rate", "flow_volume", "fixed_pressure"}, {.description = "type of flow dependence"}));
-  surfflowdeppressure.add_component(entry<double>("ConstCoeff",
+  surfflowdeppressure.add_component(parameter<double>("ConstCoeff",
       {.description = "constant coefficient for (linear) flow-rate-based condition"}));
-  surfflowdeppressure.add_component(entry<double>(
+  surfflowdeppressure.add_component(parameter<double>(
       "LinCoeff", {.description = "linear coefficient for (linear) flow-rate-based condition"}));
-  surfflowdeppressure.add_component(entry<double>(
+  surfflowdeppressure.add_component(parameter<double>(
       "InitialVolume", {.description = "initial (air-cushion) volume outside of boundary"}));
-  surfflowdeppressure.add_component(entry<double>(
+  surfflowdeppressure.add_component(parameter<double>(
       "ReferencePressure", {.description = " reference pressure outside of boundary"}));
   surfflowdeppressure.add_component(
-      entry<double>("AdiabaticExponent", {.description = "adiabatic exponent"}));
-  surfflowdeppressure.add_component(entry<Noneable<int>>(
+      parameter<double>("AdiabaticExponent", {.description = "adiabatic exponent"}));
+  surfflowdeppressure.add_component(parameter<Noneable<int>>(
       "curve", {.description = "curve id", .default_value = Core::IO::none<int>}));
 
   condlist.emplace_back(surfflowdeppressure);
@@ -1360,7 +1360,7 @@ void Inpar::FLUID::set_valid_conditions(
 
   const auto make_slip_supp = [&](Core::Conditions::ConditionDefinition& cond)
   {
-    cond.add_component(entry<double>("USEUPDATEDNODEPOS"));
+    cond.add_component(parameter<double>("USEUPDATEDNODEPOS"));
     condlist.emplace_back(cond);
   };
 
@@ -1380,7 +1380,7 @@ void Inpar::FLUID::set_valid_conditions(
 
   const auto make_navierslip = [&](Core::Conditions::ConditionDefinition& cond)
   {
-    cond.add_component(entry<double>("SLIPCOEFFICIENT"));
+    cond.add_component(parameter<double>("SLIPCOEFFICIENT"));
     condlist.emplace_back(cond);
   };
 
@@ -1426,16 +1426,17 @@ void Inpar::FLUID::set_valid_conditions(
   const auto make_mixhybDirichlet = [&](Core::Conditions::ConditionDefinition& cond)
   {
     // we provide a vector of 3 values for velocities
-    cond.add_component(entry<std::vector<double>>("val", {.description = "velocity", .size = 3}));
+    cond.add_component(
+        parameter<std::vector<double>>("val", {.description = "velocity", .size = 3}));
 
     // and optional spatial functions
-    cond.add_component(entry<std::vector<Noneable<int>>>(
+    cond.add_component(parameter<std::vector<Noneable<int>>>(
         "funct", {.description = "spatial function",
                      .default_value = std::vector(3, Core::IO::none<int>),
                      .size = 3}));
 
     // characteristic velocity
-    cond.add_component(entry<double>("u_C"));
+    cond.add_component(parameter<double>("u_C"));
 
     // the penalty parameter could be computed dynamically (using Spaldings
     // law of the wall) or using a fixed value (1)
@@ -1443,7 +1444,7 @@ void Inpar::FLUID::set_valid_conditions(
         "PENTYPE", {"constant", "Spalding"}, {.description = "how penalty parameter is computed"}));
 
     // scaling factor for penalty parameter tauB
-    cond.add_component(entry<double>("hB_divided_by"));
+    cond.add_component(parameter<double>("hB_divided_by"));
 
     // if Spaldings law is used, this defines the way how the traction at y is computed from utau
     cond.add_component(selection<std::string>("utau_computation", {"at_wall", "viscous_tangent"},
@@ -1475,9 +1476,10 @@ void Inpar::FLUID::set_valid_conditions(
       "Surface LIFTDRAG", Core::Conditions::SurfLIFTDRAG, true,
       Core::Conditions::geometry_type_surface);
 
-  surfliftdrag.add_component(entry<int>("label"));
-  surfliftdrag.add_component(entry<std::vector<double>>("CENTER", {.description = "", .size = 3}));
-  surfliftdrag.add_component(entry<std::vector<double>>(
+  surfliftdrag.add_component(parameter<int>("label"));
+  surfliftdrag.add_component(
+      parameter<std::vector<double>>("CENTER", {.description = "", .size = 3}));
+  surfliftdrag.add_component(parameter<std::vector<double>>(
       "AXIS", {.description = "", .default_value = std::vector<double>{0.0, 0.0, 0.0}, .size = 3}));
 
   condlist.push_back(surfliftdrag);
@@ -1489,7 +1491,7 @@ void Inpar::FLUID::set_valid_conditions(
       "LineFlowRate", "Line Flow Rate", Core::Conditions::FlowRateThroughLine_2D, true,
       Core::Conditions::geometry_type_line);
 
-  lineflowrate.add_component(entry<int>("ConditionID"));
+  lineflowrate.add_component(parameter<int>("ConditionID"));
 
   condlist.push_back(lineflowrate);
 
@@ -1500,7 +1502,7 @@ void Inpar::FLUID::set_valid_conditions(
       "SurfFlowRate", "Surface Flow Rate", Core::Conditions::FlowRateThroughSurface_3D, true,
       Core::Conditions::geometry_type_surface);
 
-  surfflowrate.add_component(entry<int>("ConditionID"));
+  surfflowrate.add_component(parameter<int>("ConditionID"));
 
   condlist.push_back(surfflowrate);
 
@@ -1511,7 +1513,7 @@ void Inpar::FLUID::set_valid_conditions(
       "volumetric surface flow condition", Core::Conditions::VolumetricSurfaceFlowCond, true,
       Core::Conditions::geometry_type_surface);
 
-  volumetric_surface_flow_cond.add_component(entry<int>("ConditionID"));
+  volumetric_surface_flow_cond.add_component(parameter<int>("ConditionID"));
 
   volumetric_surface_flow_cond.add_component(
       selection<std::string>("ConditionType", {"POLYNOMIAL", "WOMERSLEY"},
@@ -1527,25 +1529,25 @@ void Inpar::FLUID::set_valid_conditions(
       selection<std::string>("CorrectionFlag", {"WithOutCorrection", "WithCorrection"},
           {.description = "correction flag", .default_value = "WithOutCorrection"}));
 
-  volumetric_surface_flow_cond.add_component(entry<double>("Period"));
-  volumetric_surface_flow_cond.add_component(entry<int>("Order"));
-  volumetric_surface_flow_cond.add_component(entry<int>("Harmonics"));
-  volumetric_surface_flow_cond.add_component(entry<double>("Val"));
-  volumetric_surface_flow_cond.add_component(entry<int>("Funct"));
+  volumetric_surface_flow_cond.add_component(parameter<double>("Period"));
+  volumetric_surface_flow_cond.add_component(parameter<int>("Order"));
+  volumetric_surface_flow_cond.add_component(parameter<int>("Harmonics"));
+  volumetric_surface_flow_cond.add_component(parameter<double>("Val"));
+  volumetric_surface_flow_cond.add_component(parameter<int>("Funct"));
 
   volumetric_surface_flow_cond.add_component(
       selection<std::string>("NORMAL", {"SelfEvaluateNormal", "UsePrescribedNormal"},
           {.description = "normal", .default_value = "SelfEvaluateNormal"}));
-  volumetric_surface_flow_cond.add_component(entry<double>("n1"));
-  volumetric_surface_flow_cond.add_component(entry<double>("n2"));
-  volumetric_surface_flow_cond.add_component(entry<double>("n3"));
+  volumetric_surface_flow_cond.add_component(parameter<double>("n1"));
+  volumetric_surface_flow_cond.add_component(parameter<double>("n2"));
+  volumetric_surface_flow_cond.add_component(parameter<double>("n3"));
 
   volumetric_surface_flow_cond.add_component(selection<std::string>("CenterOfMass",
       {"SelfEvaluateCenterOfMass", "UsePrescribedCenterOfMass"},
       {.description = "center of mass", .default_value = "SelfEvaluateCenterOfMass"}));
-  volumetric_surface_flow_cond.add_component(entry<double>("c1"));
-  volumetric_surface_flow_cond.add_component(entry<double>("c2"));
-  volumetric_surface_flow_cond.add_component(entry<double>("c3"));
+  volumetric_surface_flow_cond.add_component(parameter<double>("c1"));
+  volumetric_surface_flow_cond.add_component(parameter<double>("c2"));
+  volumetric_surface_flow_cond.add_component(parameter<double>("c3"));
 
   condlist.push_back(volumetric_surface_flow_cond);
 
@@ -1559,7 +1561,7 @@ void Inpar::FLUID::set_valid_conditions(
       "volumetric flow border nodes condition", Core::Conditions::VolumetricFlowBorderNodes, true,
       Core::Conditions::geometry_type_line);
 
-  volumetric_border_nodes_cond.add_component(entry<int>("ConditionID"));
+  volumetric_border_nodes_cond.add_component(parameter<int>("ConditionID"));
 
   condlist.push_back(volumetric_border_nodes_cond);
 
@@ -1570,7 +1572,7 @@ void Inpar::FLUID::set_valid_conditions(
       "total traction correction condition", Core::Conditions::TotalTractionCorrectionCond, true,
       Core::Conditions::geometry_type_surface);
 
-  total_traction_correction_cond.add_component(entry<int>("ConditionID"));
+  total_traction_correction_cond.add_component(parameter<int>("ConditionID"));
   total_traction_correction_cond.add_component(
       selection<std::string>("ConditionType", {"POLYNOMIAL", "WOMERSLEY"},
           {.description = "condition type", .default_value = "POLYNOMIAL"}));
@@ -1585,25 +1587,25 @@ void Inpar::FLUID::set_valid_conditions(
       selection<std::string>("CorrectionFlag", {"WithOutCorrection", "WithCorrection"},
           {.description = "correction flag", .default_value = "WithOutCorrection"}));
 
-  total_traction_correction_cond.add_component(entry<double>("Period"));
-  total_traction_correction_cond.add_component(entry<int>("Order"));
-  total_traction_correction_cond.add_component(entry<int>("Harmonics"));
-  total_traction_correction_cond.add_component(entry<double>("Val"));
-  total_traction_correction_cond.add_component(entry<int>("Funct"));
+  total_traction_correction_cond.add_component(parameter<double>("Period"));
+  total_traction_correction_cond.add_component(parameter<int>("Order"));
+  total_traction_correction_cond.add_component(parameter<int>("Harmonics"));
+  total_traction_correction_cond.add_component(parameter<double>("Val"));
+  total_traction_correction_cond.add_component(parameter<int>("Funct"));
 
   total_traction_correction_cond.add_component(
       selection<std::string>("NORMAL", {"SelfEvaluateNormal", "UsePrescribedNormal"},
           {.description = "normal", .default_value = "SelfEvaluateNormal"}));
-  total_traction_correction_cond.add_component(entry<double>("n1"));
-  total_traction_correction_cond.add_component(entry<double>("n2"));
-  total_traction_correction_cond.add_component(entry<double>("n3"));
+  total_traction_correction_cond.add_component(parameter<double>("n1"));
+  total_traction_correction_cond.add_component(parameter<double>("n2"));
+  total_traction_correction_cond.add_component(parameter<double>("n3"));
 
   total_traction_correction_cond.add_component(selection<std::string>("CenterOfMass",
       {"SelfEvaluateCenterOfMass", "UsePrescribedCenterOfMass"},
       {.description = "center of mass", .default_value = "SelfEvaluateCenterOfMass"}));
-  total_traction_correction_cond.add_component(entry<double>("c1"));
-  total_traction_correction_cond.add_component(entry<double>("c2"));
-  total_traction_correction_cond.add_component(entry<double>("c3"));
+  total_traction_correction_cond.add_component(parameter<double>("c1"));
+  total_traction_correction_cond.add_component(parameter<double>("c2"));
+  total_traction_correction_cond.add_component(parameter<double>("c3"));
 
   condlist.push_back(total_traction_correction_cond);
 
@@ -1616,7 +1618,7 @@ void Inpar::FLUID::set_valid_conditions(
       Core::Conditions::TotalTractionCorrectionBorderNodes, true,
       Core::Conditions::geometry_type_line);
 
-  traction_corrector_border_nodes_cond.add_component(entry<int>("ConditionID"));
+  traction_corrector_border_nodes_cond.add_component(parameter<int>("ConditionID"));
 
   condlist.push_back(traction_corrector_border_nodes_cond);
 
diff --git a/src/inpar/4C_inpar_fpsi.cpp b/src/inpar/4C_inpar_fpsi.cpp
index 86a31554aad..9396a9e8832 100644
--- a/src/inpar/4C_inpar_fpsi.cpp
+++ b/src/inpar/4C_inpar_fpsi.cpp
@@ -133,8 +133,8 @@ void Inpar::FPSI::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
       "fpsi_coupling", "FPSI Coupling", Core::Conditions::fpsi_coupling, true,
       Core::Conditions::geometry_type_surface);
 
-  linefpsi.add_component(entry<int>("coupling_id"));
-  surffpsi.add_component(entry<int>("coupling_id"));
+  linefpsi.add_component(parameter<int>("coupling_id"));
+  surffpsi.add_component(parameter<int>("coupling_id"));
 
   condlist.push_back(linefpsi);
   condlist.push_back(surffpsi);
diff --git a/src/inpar/4C_inpar_fsi.cpp b/src/inpar/4C_inpar_fsi.cpp
index 47377da56ed..ca16949d49b 100644
--- a/src/inpar/4C_inpar_fsi.cpp
+++ b/src/inpar/4C_inpar_fsi.cpp
@@ -433,8 +433,8 @@ void Inpar::FSI::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
       "FSICoupling", "FSI Coupling", Core::Conditions::FSICoupling, true,
       Core::Conditions::geometry_type_surface);
 
-  linefsi.add_component(entry<int>("coupling_id"));
-  surffsi.add_component(entry<int>("coupling_id"));
+  linefsi.add_component(parameter<int>("coupling_id"));
+  surffsi.add_component(parameter<int>("coupling_id"));
 
   condlist.push_back(linefsi);
   condlist.push_back(surffsi);
@@ -459,7 +459,7 @@ void Inpar::FSI::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
       "StructAleCoupling", "StructAleCoupling", Core::Conditions::StructAleCoupling, true,
       Core::Conditions::geometry_type_surface);
 
-  surfsac.add_component(entry<int>("coupling_id"));
+  surfsac.add_component(parameter<int>("coupling_id"));
   surfsac.add_component(selection<std::string>(
       "field", {"structure", "ale"}, {.description = "field", .default_value = "structure"}));
 
@@ -473,7 +473,7 @@ void Inpar::FSI::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
       "StructFluidVolCoupling", Core::Conditions::StructFluidVolCoupling, false,
       Core::Conditions::geometry_type_volume);
 
-  volsfv.add_component(entry<int>("coupling_id"));
+  volsfv.add_component(parameter<int>("coupling_id"));
   volsfv.add_component(selection<std::string>(
       "field", {"structure", "ale"}, {.description = "field", .default_value = "structure"}));
 
diff --git a/src/inpar/4C_inpar_mortar.cpp b/src/inpar/4C_inpar_mortar.cpp
index e0a9e2520b9..cfc81a31b29 100644
--- a/src/inpar/4C_inpar_mortar.cpp
+++ b/src/inpar/4C_inpar_mortar.cpp
@@ -177,16 +177,16 @@ void Inpar::Mortar::set_valid_conditions(
 
   const auto make_contact = [&condlist](Core::Conditions::ConditionDefinition& cond)
   {
-    cond.add_component(entry<int>("InterfaceID"));
+    cond.add_component(parameter<int>("InterfaceID"));
     cond.add_component(selection<std::string>(
         "Side", {"Master", "Slave", "Selfcontact"}, {.description = "interface side"}));
     cond.add_component(selection<std::string>("Initialization", {"Inactive", "Active"},
         {.description = "initialization", .default_value = "Inactive"}));
 
-    cond.add_component(entry<double>(
+    cond.add_component(parameter<double>(
         "FrCoeffOrBound", {.description = "friction coefficient bound", .default_value = 0.0}));
-    cond.add_component(
-        entry<double>("AdhesionBound", {.description = "adhesion bound", .default_value = 0.0}));
+    cond.add_component(parameter<double>(
+        "AdhesionBound", {.description = "adhesion bound", .default_value = 0.0}));
 
     cond.add_component(selection<std::string>("Application",
         {"Solidcontact", "Beamtosolidcontact", "Beamtosolidmeshtying"},
@@ -199,13 +199,13 @@ void Inpar::Mortar::set_valid_conditions(
                 static_cast<int>(DBCHandling::remove_dbc_nodes_from_slave_side)}},
         {.description = "DbcHandling",
             .default_value = static_cast<int>(DBCHandling::do_nothing)}));
-    cond.add_component(entry<double>(
+    cond.add_component(parameter<double>(
         "TwoHalfPass", {.description = "optional two half pass approach", .default_value = 0.0}));
-    cond.add_component(entry<double>("RefConfCheckNonSmoothSelfContactSurface",
+    cond.add_component(parameter<double>("RefConfCheckNonSmoothSelfContactSurface",
         {.description =
                 "optional reference configuration check for non-smooth self contact surfaces",
             .default_value = 0.0}));
-    cond.add_component(entry<Noneable<int>>("ConstitutiveLawID",
+    cond.add_component(parameter<Noneable<int>>("ConstitutiveLawID",
         {.description = "material id of the constitutive law", .default_value = 0}));
     condlist.push_back(cond);
   };
@@ -226,7 +226,7 @@ void Inpar::Mortar::set_valid_conditions(
 
     const auto make_mortar = [&condlist](Core::Conditions::ConditionDefinition& cond)
     {
-      cond.add_component(entry<int>("InterfaceID"));
+      cond.add_component(parameter<int>("InterfaceID"));
       cond.add_component(
           selection<std::string>("Side", {"Master", "Slave"}, {.description = "interface side"}));
       cond.add_component(selection<std::string>("Initialization", {"Inactive", "Active"},
@@ -254,7 +254,7 @@ void Inpar::Mortar::set_valid_conditions(
 
   const auto make_mrtrsym = [&condlist](Core::Conditions::ConditionDefinition& cond)
   {
-    cond.add_component(entry<std::vector<int>>("ONOFF", {.description = "", .size = 3}));
+    cond.add_component(parameter<std::vector<int>>("ONOFF", {.description = "", .size = 3}));
 
     condlist.push_back(cond);
   };
@@ -292,7 +292,7 @@ void Inpar::Mortar::set_valid_conditions(
 
     const auto make_mortar_multi = [&condlist](Core::Conditions::ConditionDefinition& cond)
     {
-      cond.add_component(entry<int>("InterfaceID"));
+      cond.add_component(parameter<int>("InterfaceID"));
       cond.add_component(
           selection<std::string>("Side", {"Master", "Slave"}, {.description = "interface side"}));
       cond.add_component(selection<std::string>("Initialization", {"Inactive", "Active"},
diff --git a/src/inpar/4C_inpar_mpc_rve.cpp b/src/inpar/4C_inpar_mpc_rve.cpp
index be082171028..7f48bf06284 100644
--- a/src/inpar/4C_inpar_mpc_rve.cpp
+++ b/src/inpar/4C_inpar_mpc_rve.cpp
@@ -85,10 +85,10 @@ void Inpar::RveMpc::set_valid_conditions(
       "2d",
       Core::Conditions::PointLinearCoupledEquation, false, Core::Conditions::geometry_type_point);
 
-  linear_ce.add_component(entry<int>("EQUATION", {.description = "EQUATION"}));
+  linear_ce.add_component(parameter<int>("EQUATION", {.description = "EQUATION"}));
   linear_ce.add_component(selection<std::string>("ADD", {"dispx", "dispy", "undefined"},
       {.description = "degrees of freedom", .default_value = "undefined"}));
-  linear_ce.add_component(entry<double>("COEFFICIENT"));
+  linear_ce.add_component(parameter<double>("COEFFICIENT"));
 
   condlist.push_back(linear_ce);
   /*--------------------------------------------------------------------*/
diff --git a/src/inpar/4C_inpar_particle.cpp b/src/inpar/4C_inpar_particle.cpp
index 3dfd255ecc0..295722e9ac1 100644
--- a/src/inpar/4C_inpar_particle.cpp
+++ b/src/inpar/4C_inpar_particle.cpp
@@ -567,7 +567,7 @@ void Inpar::PARTICLE::set_valid_conditions(
       "Wall for particle interaction with (optional) material definition",
       Core::Conditions::ParticleWall, true, Core::Conditions::geometry_type_surface);
 
-  surfpartwall.add_component(entry<int>("MAT"));
+  surfpartwall.add_component(parameter<int>("MAT"));
 
   condlist.push_back(surfpartwall);
 }
diff --git a/src/inpar/4C_inpar_poromultiphase_scatra.cpp b/src/inpar/4C_inpar_poromultiphase_scatra.cpp
index 53e2b11a4b8..595e6651707 100644
--- a/src/inpar/4C_inpar_poromultiphase_scatra.cpp
+++ b/src/inpar/4C_inpar_poromultiphase_scatra.cpp
@@ -166,13 +166,13 @@ void Inpar::PoroMultiPhaseScaTra::set_valid_conditions(
     const auto make_oxypartpress = [&condlist](Core::Conditions::ConditionDefinition& cond)
     {
       cond.add_component(
-          entry<int>("SCALARID", {.description = "scalar id of oxygen partial pressure"}));
-      cond.add_component(entry<double>("n", {.description = "n"}));
-      cond.add_component(entry<double>("Pb50", {.description = "Pb50"}));
-      cond.add_component(entry<double>("CaO2_max", {.description = "CaO2_max"}));
-      cond.add_component(entry<double>("alpha_bl_eff", {.description = "alpha_bl_eff"}));
-      cond.add_component(entry<double>("rho_oxy", {.description = "rho_oxy"}));
-      cond.add_component(entry<double>("rho_bl", {.description = "rho_bl"}));
+          parameter<int>("SCALARID", {.description = "scalar id of oxygen partial pressure"}));
+      cond.add_component(parameter<double>("n", {.description = "n"}));
+      cond.add_component(parameter<double>("Pb50", {.description = "Pb50"}));
+      cond.add_component(parameter<double>("CaO2_max", {.description = "CaO2_max"}));
+      cond.add_component(parameter<double>("alpha_bl_eff", {.description = "alpha_bl_eff"}));
+      cond.add_component(parameter<double>("rho_oxy", {.description = "rho_oxy"}));
+      cond.add_component(parameter<double>("rho_bl", {.description = "rho_bl"}));
 
       condlist.push_back(cond);
     };
diff --git a/src/inpar/4C_inpar_s2i.cpp b/src/inpar/4C_inpar_s2i.cpp
index ca2ceeaa566..2391fc3e715 100644
--- a/src/inpar/4C_inpar_s2i.cpp
+++ b/src/inpar/4C_inpar_s2i.cpp
@@ -118,12 +118,12 @@ void Inpar::S2I::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
 
     const auto make_s2imeshtying = [&condlist](Core::Conditions::ConditionDefinition& cond)
     {
-      cond.add_component(entry<int>("ConditionID"));
+      cond.add_component(parameter<int>("ConditionID"));
       cond.add_component(selection<int>("INTERFACE_SIDE",
           {{"Undefined", Inpar::S2I::side_undefined}, {"Slave", Inpar::S2I::side_slave},
               {"Master", Inpar::S2I::side_master}},
           {.description = "interface side"}));
-      cond.add_component(entry<int>("S2I_KINETICS_ID"));
+      cond.add_component(parameter<int>("S2I_KINETICS_ID"));
 
       condlist.push_back(cond);
     };
@@ -166,9 +166,10 @@ void Inpar::S2I::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
                     {"ConstantPermeability", Inpar::S2I::kinetics_constperm},
                     {"LinearPermeability", Inpar::S2I::kinetics_linearperm},
                 }),
-            entry<int>("NUMSCAL"),
-            entry<std::vector<double>>("PERMEABILITIES", {.size = from_parameter<int>("NUMSCAL")}),
-            entry<bool>("IS_PSEUDO_CONTACT"),
+            parameter<int>("NUMSCAL"),
+            parameter<std::vector<double>>(
+                "PERMEABILITIES", {.size = from_parameter<int>("NUMSCAL")}),
+            parameter<bool>("IS_PSEUDO_CONTACT"),
         });
         kinetic_model_choices.emplace_back(std::move(constlinperm));
       }
@@ -183,13 +184,14 @@ void Inpar::S2I::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
                     {"Butler-VolmerReduced_Linearized",
                         Inpar::S2I::kinetics_butlervolmerreducedlinearized},
                 }),
-            entry<int>("NUMSCAL"),
-            entry<std::vector<int>>("STOICHIOMETRIES", {.size = from_parameter<int>("NUMSCAL")}),
-            entry<int>("E-"),
-            entry<double>("K_R"),
-            entry<double>("ALPHA_A"),
-            entry<double>("ALPHA_C"),
-            entry<bool>("IS_PSEUDO_CONTACT"),
+            parameter<int>("NUMSCAL"),
+            parameter<std::vector<int>>(
+                "STOICHIOMETRIES", {.size = from_parameter<int>("NUMSCAL")}),
+            parameter<int>("E-"),
+            parameter<double>("K_R"),
+            parameter<double>("ALPHA_A"),
+            parameter<double>("ALPHA_C"),
+            parameter<bool>("IS_PSEUDO_CONTACT"),
         });
         kinetic_model_choices.emplace_back(std::move(butler_volmer));
       }
@@ -200,14 +202,15 @@ void Inpar::S2I::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
                 {
                     {"Butler-Volmer-Peltier", Inpar::S2I::kinetics_butlervolmerpeltier},
                 }),
-            entry<int>("NUMSCAL"),
-            entry<std::vector<int>>("STOICHIOMETRIES", {.size = from_parameter<int>("NUMSCAL")}),
-            entry<int>("E-"),
-            entry<double>("K_R"),
-            entry<double>("ALPHA_A"),
-            entry<double>("ALPHA_C"),
-            entry<bool>("IS_PSEUDO_CONTACT"),
-            entry<double>("PELTIER"),
+            parameter<int>("NUMSCAL"),
+            parameter<std::vector<int>>(
+                "STOICHIOMETRIES", {.size = from_parameter<int>("NUMSCAL")}),
+            parameter<int>("E-"),
+            parameter<double>("K_R"),
+            parameter<double>("ALPHA_A"),
+            parameter<double>("ALPHA_C"),
+            parameter<bool>("IS_PSEUDO_CONTACT"),
+            parameter<double>("PELTIER"),
         });
 
         kinetic_model_choices.emplace_back(std::move(butler_volmer_peltier));
@@ -220,14 +223,15 @@ void Inpar::S2I::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
                     {"Butler-VolmerReduced_Capacitance",
                         Inpar::S2I::kinetics_butlervolmerreducedcapacitance},
                 }),
-            entry<int>("NUMSCAL"),
-            entry<std::vector<int>>("STOICHIOMETRIES", {.size = from_parameter<int>("NUMSCAL")}),
-            entry<int>("E-"),
-            entry<double>("K_R"),
-            entry<double>("CAPACITANCE"),
-            entry<double>("ALPHA_A"),
-            entry<double>("ALPHA_C"),
-            entry<bool>("IS_PSEUDO_CONTACT"),
+            parameter<int>("NUMSCAL"),
+            parameter<std::vector<int>>(
+                "STOICHIOMETRIES", {.size = from_parameter<int>("NUMSCAL")}),
+            parameter<int>("E-"),
+            parameter<double>("K_R"),
+            parameter<double>("CAPACITANCE"),
+            parameter<double>("ALPHA_A"),
+            parameter<double>("ALPHA_C"),
+            parameter<bool>("IS_PSEUDO_CONTACT"),
         });
 
         kinetic_model_choices.emplace_back(std::move(butler_volmer_reduced_capacitance));
@@ -239,16 +243,17 @@ void Inpar::S2I::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
                 {
                     {"Butler-Volmer_Resistance", Inpar::S2I::kinetics_butlervolmerresistance},
                 }),
-            entry<int>("NUMSCAL"),
-            entry<std::vector<int>>("STOICHIOMETRIES", {.size = from_parameter<int>("NUMSCAL")}),
-            entry<int>("E-"),
-            entry<double>("K_R"),
-            entry<double>("ALPHA_A"),
-            entry<double>("ALPHA_C"),
-            entry<bool>("IS_PSEUDO_CONTACT"),
-            entry<double>("RESISTANCE"),
-            entry<double>("CONVTOL_IMPLBUTLERVOLMER"),
-            entry<int>("ITEMAX_IMPLBUTLERVOLMER"),
+            parameter<int>("NUMSCAL"),
+            parameter<std::vector<int>>(
+                "STOICHIOMETRIES", {.size = from_parameter<int>("NUMSCAL")}),
+            parameter<int>("E-"),
+            parameter<double>("K_R"),
+            parameter<double>("ALPHA_A"),
+            parameter<double>("ALPHA_C"),
+            parameter<bool>("IS_PSEUDO_CONTACT"),
+            parameter<double>("RESISTANCE"),
+            parameter<double>("CONVTOL_IMPLBUTLERVOLMER"),
+            parameter<int>("ITEMAX_IMPLBUTLERVOLMER"),
         });
         kinetic_model_choices.emplace_back(std::move(butler_volmer_resistance));
       }
@@ -260,16 +265,17 @@ void Inpar::S2I::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
                     {"Butler-VolmerReduced_Resistance",
                         Inpar::S2I::kinetics_butlervolmerreducedresistance},
                 }),
-            entry<int>("NUMSCAL"),
-            entry<std::vector<int>>("STOICHIOMETRIES", {.size = from_parameter<int>("NUMSCAL")}),
-            entry<int>("E-"),
-            entry<double>("K_R"),
-            entry<double>("ALPHA_A"),
-            entry<double>("ALPHA_C"),
-            entry<bool>("IS_PSEUDO_CONTACT"),
-            entry<double>("RESISTANCE"),
-            entry<double>("CONVTOL_IMPLBUTLERVOLMER"),
-            entry<int>("ITEMAX_IMPLBUTLERVOLMER"),
+            parameter<int>("NUMSCAL"),
+            parameter<std::vector<int>>(
+                "STOICHIOMETRIES", {.size = from_parameter<int>("NUMSCAL")}),
+            parameter<int>("E-"),
+            parameter<double>("K_R"),
+            parameter<double>("ALPHA_A"),
+            parameter<double>("ALPHA_C"),
+            parameter<bool>("IS_PSEUDO_CONTACT"),
+            parameter<double>("RESISTANCE"),
+            parameter<double>("CONVTOL_IMPLBUTLERVOLMER"),
+            parameter<int>("ITEMAX_IMPLBUTLERVOLMER"),
         });
 
         kinetic_model_choices.emplace_back(std::move(butler_volmer_reduced_with_resistance));
@@ -282,15 +288,16 @@ void Inpar::S2I::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
                     {"Butler-VolmerReduced_ThermoResistance",
                         Inpar::S2I::kinetics_butlervolmerreducedthermoresistance},
                 }),
-            entry<int>("NUMSCAL"),
-            entry<std::vector<int>>("STOICHIOMETRIES", {.size = from_parameter<int>("NUMSCAL")}),
-            entry<int>("E-"),
-            entry<double>("K_R"),
-            entry<double>("ALPHA_A"),
-            entry<double>("ALPHA_C"),
-            entry<bool>("IS_PSEUDO_CONTACT"),
-            entry<double>("THERMOPERM"),
-            entry<double>("MOLAR_HEAT_CAPACITY"),
+            parameter<int>("NUMSCAL"),
+            parameter<std::vector<int>>(
+                "STOICHIOMETRIES", {.size = from_parameter<int>("NUMSCAL")}),
+            parameter<int>("E-"),
+            parameter<double>("K_R"),
+            parameter<double>("ALPHA_A"),
+            parameter<double>("ALPHA_C"),
+            parameter<bool>("IS_PSEUDO_CONTACT"),
+            parameter<double>("THERMOPERM"),
+            parameter<double>("MOLAR_HEAT_CAPACITY"),
         });
 
         kinetic_model_choices.emplace_back(std::move(butler_volmer_reduced_thermo));
@@ -303,10 +310,10 @@ void Inpar::S2I::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
                     {"ConstantInterfaceResistance",
                         Inpar::S2I::kinetics_constantinterfaceresistance},
                 }),
-            entry<std::vector<int>>("ONOFF", {.size = 2}),
-            entry<double>("RESISTANCE"),
-            entry<int>("E-"),
-            entry<bool>("IS_PSEUDO_CONTACT"),
+            parameter<std::vector<int>>("ONOFF", {.size = 2}),
+            parameter<double>("RESISTANCE"),
+            parameter<int>("E-"),
+            parameter<bool>("IS_PSEUDO_CONTACT"),
         });
 
         kinetic_model_choices.emplace_back(std::move(constant_interface_resistance));
@@ -336,7 +343,7 @@ void Inpar::S2I::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
     const auto make_s2ikinetics = [&condlist, &interface_side_options](
                                       Core::Conditions::ConditionDefinition& cond)
     {
-      cond.add_component(entry<int>("ConditionID"));
+      cond.add_component(parameter<int>("ConditionID"));
       cond.add_component(interface_side_options);
 
       condlist.push_back(cond);
@@ -370,15 +377,15 @@ void Inpar::S2I::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
         Core::Conditions::S2IKineticsGrowth, true, Core::Conditions::geometry_type_surface);
 
     auto butler_volmer = all_of({
-        entry<int>("NUMSCAL"),
-        entry<std::vector<int>>("STOICHIOMETRIES", {.size = from_parameter<int>("NUMSCAL")}),
-        entry<int>("E-"),
-        entry<double>("K_R"),
-        entry<double>("ALPHA_A"),
-        entry<double>("ALPHA_C"),
-        entry<double>("MOLMASS"),
-        entry<double>("DENSITY"),
-        entry<double>("CONDUCTIVITY"),
+        parameter<int>("NUMSCAL"),
+        parameter<std::vector<int>>("STOICHIOMETRIES", {.size = from_parameter<int>("NUMSCAL")}),
+        parameter<int>("E-"),
+        parameter<double>("K_R"),
+        parameter<double>("ALPHA_A"),
+        parameter<double>("ALPHA_C"),
+        parameter<double>("MOLMASS"),
+        parameter<double>("DENSITY"),
+        parameter<double>("CONDUCTIVITY"),
         selection<int>("REGTYPE",
             {
                 {"none", Inpar::S2I::regularization_none},
@@ -386,14 +393,14 @@ void Inpar::S2I::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
                 {"Hein", Inpar::S2I::regularization_hein},
                 {"trigonometrical", Inpar::S2I::regularization_trigonometrical},
             }),
-        entry<double>("REGPAR"),
-        entry<double>("INITTHICKNESS"),
+        parameter<double>("REGPAR"),
+        parameter<double>("INITTHICKNESS"),
     });
 
     const auto make_s2igrowth = [&condlist, &butler_volmer](
                                     Core::Conditions::ConditionDefinition& cond)
     {
-      cond.add_component(entry<int>("ConditionID"));
+      cond.add_component(parameter<int>("ConditionID"));
       cond.add_component(
           selection<int>("KINETIC_MODEL", {{"Butler-Volmer", growth_kinetics_butlervolmer}}));
       cond.add_component(butler_volmer);
diff --git a/src/inpar/4C_inpar_scatra.cpp b/src/inpar/4C_inpar_scatra.cpp
index 2f665d88d5b..5314fec3443 100644
--- a/src/inpar/4C_inpar_scatra.cpp
+++ b/src/inpar/4C_inpar_scatra.cpp
@@ -509,7 +509,7 @@ void Inpar::ScaTra::set_valid_conditions(
   const auto make_totalandmeanscalar = [&condlist](Core::Conditions::ConditionDefinition& cond)
   {
     // insert input file line components into condition definitions
-    cond.add_component(entry<int>("ConditionID"));
+    cond.add_component(parameter<int>("ConditionID"));
 
     // insert condition definitions into global list of valid condition definitions
     condlist.emplace_back(cond);
@@ -534,8 +534,8 @@ void Inpar::ScaTra::set_valid_conditions(
   const auto make_relerror = [&condlist](Core::Conditions::ConditionDefinition& cond)
   {
     // insert input file line components into condition definitions
-    cond.add_component(entry<int>("ConditionID"));
-    cond.add_component(entry<int>("Function"));
+    cond.add_component(parameter<int>("ConditionID"));
+    cond.add_component(parameter<int>("Function"));
 
     // insert condition definitions into global list of valid condition definitions
     condlist.emplace_back(cond);
@@ -552,17 +552,17 @@ void Inpar::ScaTra::set_valid_conditions(
       "ScaTraCoupling", "ScaTra Coupling", Core::Conditions::ScaTraCoupling, true,
       Core::Conditions::geometry_type_surface);
 
-  surfscatracoup.add_component(entry<int>("NUMSCAL"));
-  surfscatracoup.add_component(entry<std::vector<int>>(
+  surfscatracoup.add_component(parameter<int>("NUMSCAL"));
+  surfscatracoup.add_component(parameter<std::vector<int>>(
       "ONOFF", {.description = "", .size = from_parameter<int>("NUMSCAL")}));
-  surfscatracoup.add_component(entry<int>("COUPID"));
-  surfscatracoup.add_component(entry<double>("PERMCOEF"));
-  surfscatracoup.add_component(entry<double>("CONDUCT"));
-  surfscatracoup.add_component(entry<double>("FILTR"));
+  surfscatracoup.add_component(parameter<int>("COUPID"));
+  surfscatracoup.add_component(parameter<double>("PERMCOEF"));
+  surfscatracoup.add_component(parameter<double>("CONDUCT"));
+  surfscatracoup.add_component(parameter<double>("FILTR"));
   surfscatracoup.add_component(
-      entry<bool>("WSSON", {.description = "flag if wall shear stress coupling is on"}));
+      parameter<bool>("WSSON", {.description = "flag if wall shear stress coupling is on"}));
   surfscatracoup.add_component(
-      entry<std::vector<double>>("WSSCOEFFS", {.description = "", .size = 2}));
+      parameter<std::vector<double>>("WSSCOEFFS", {.description = "", .size = 2}));
 
   condlist.emplace_back(surfscatracoup);
 
@@ -579,11 +579,11 @@ void Inpar::ScaTra::set_valid_conditions(
 
   const auto make_scatrarobin = [&condlist](Core::Conditions::ConditionDefinition& cond)
   {
-    cond.add_component(entry<int>("NUMSCAL"));
-    cond.add_component(entry<std::vector<int>>(
+    cond.add_component(parameter<int>("NUMSCAL"));
+    cond.add_component(parameter<std::vector<int>>(
         "ONOFF", {.description = "", .size = from_parameter<int>("NUMSCAL")}));
-    cond.add_component(entry<double>("PREFACTOR"));
-    cond.add_component(entry<double>("REFVALUE"));
+    cond.add_component(parameter<double>("PREFACTOR"));
+    cond.add_component(parameter<double>("REFVALUE"));
 
     condlist.emplace_back(cond);
   };
@@ -625,13 +625,13 @@ void Inpar::ScaTra::set_valid_conditions(
     // --> Tempnp (current temperature solution T_n+1) with linearisation
     cond.add_component(selection<std::string>(
         "temperature_state", {"Tempnp", "Tempn"}, {.description = "temperature state"}));
-    cond.add_component(entry<double>("coeff", {.description = "heat transfer coefficient h"}));
+    cond.add_component(parameter<double>("coeff", {.description = "heat transfer coefficient h"}));
     cond.add_component(
-        entry<double>("surtemp", {.description = "surrounding (fluid) temperature T_oo"}));
-    cond.add_component(entry<Noneable<int>>("surtempfunct",
+        parameter<double>("surtemp", {.description = "surrounding (fluid) temperature T_oo"}));
+    cond.add_component(parameter<Noneable<int>>("surtempfunct",
         {.description =
                 "time curve to increase the surrounding (fluid) temperature T_oo in time"}));
-    cond.add_component(entry<Noneable<int>>("funct",
+    cond.add_component(parameter<Noneable<int>>("funct",
         {.description =
                 "time curve to increase the complete boundary condition, i.e., the heat flux"}));
 
diff --git a/src/inpar/4C_inpar_solver.cpp b/src/inpar/4C_inpar_solver.cpp
index da7561a8351..00f4b1066ae 100644
--- a/src/inpar/4C_inpar_solver.cpp
+++ b/src/inpar/4C_inpar_solver.cpp
@@ -102,7 +102,7 @@ namespace Inpar::SOLVER
           list);
 
       list.specs.emplace_back(
-          Core::IO::InputSpecBuilders::entry<Core::IO::Noneable<std::filesystem::path>>(
+          Core::IO::InputSpecBuilders::parameter<Core::IO::Noneable<std::filesystem::path>>(
               "SOLVER_XML_FILE",
               {.description = "xml file defining any iterative solver",
                   .default_value = Core::IO::Noneable<std::filesystem::path>()}));
@@ -111,7 +111,7 @@ namespace Inpar::SOLVER
     // MueLu options
     {
       list.specs.emplace_back(
-          Core::IO::InputSpecBuilders::entry<Core::IO::Noneable<std::filesystem::path>>(
+          Core::IO::InputSpecBuilders::parameter<Core::IO::Noneable<std::filesystem::path>>(
               "MUELU_XML_FILE", {.description = "xml file defining any MueLu preconditioner",
                                     .default_value = Core::IO::Noneable<std::filesystem::path>()}));
     }
@@ -119,7 +119,7 @@ namespace Inpar::SOLVER
     // Teko options
     {
       list.specs.emplace_back(
-          Core::IO::InputSpecBuilders::entry<Core::IO::Noneable<std::filesystem::path>>(
+          Core::IO::InputSpecBuilders::parameter<Core::IO::Noneable<std::filesystem::path>>(
               "TEKO_XML_FILE", {.description = "xml file defining any Teko preconditioner",
                                    .default_value = Core::IO::Noneable<std::filesystem::path>()}));
     }
@@ -134,7 +134,7 @@ namespace Inpar::SOLVER
           "is defined using a xml file",
           list);
       list.specs.emplace_back(
-          Core::IO::InputSpecBuilders::entry<Core::IO::Noneable<std::filesystem::path>>(
+          Core::IO::InputSpecBuilders::parameter<Core::IO::Noneable<std::filesystem::path>>(
               "AMGNXN_XML_FILE",
               {.description = "xml file defining the AMGnxn preconditioner",
                   .default_value = Core::IO::Noneable<std::filesystem::path>()}));
diff --git a/src/inpar/4C_inpar_solver_nonlin.cpp b/src/inpar/4C_inpar_solver_nonlin.cpp
index 0e06f7d434a..d67ee1167ae 100644
--- a/src/inpar/4C_inpar_solver_nonlin.cpp
+++ b/src/inpar/4C_inpar_solver_nonlin.cpp
@@ -327,7 +327,8 @@ void Inpar::NlnSol::set_valid_parameters(std::map<std::string, Core::IO::InputSp
 
   {
     statusTest.specs.emplace_back(
-        Core::IO::InputSpecBuilders::entry<Core::IO::Noneable<std::filesystem::path>>("XML File",
+        Core::IO::InputSpecBuilders::parameter<Core::IO::Noneable<std::filesystem::path>>(
+            "XML File",
             {.description = "Filename of XML file with configuration of nox status test",
                 .default_value = Core::IO::Noneable<std::filesystem::path>()}));
   }
diff --git a/src/inpar/4C_inpar_ssi.cpp b/src/inpar/4C_inpar_ssi.cpp
index 8c0c0e3d83a..c77f70a4248 100644
--- a/src/inpar/4C_inpar_ssi.cpp
+++ b/src/inpar/4C_inpar_ssi.cpp
@@ -256,7 +256,7 @@ void Inpar::SSI::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
   // insert input file line components into condition definitions
   const auto make_ssiplain = [&condlist](Core::Conditions::ConditionDefinition& cond)
   {
-    cond.add_component(entry<int>("coupling_id"));
+    cond.add_component(parameter<int>("coupling_id"));
     condlist.push_back(cond);
   };
 
@@ -278,7 +278,7 @@ void Inpar::SSI::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
   // insert input file line components into condition definitions
   const auto make_ssi = [&condlist](Core::Conditions::ConditionDefinition& cond)
   {
-    cond.add_component(entry<int>("coupling_id"));
+    cond.add_component(parameter<int>("coupling_id"));
     condlist.push_back(cond);
   };
 
@@ -303,7 +303,7 @@ void Inpar::SSI::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
   // insert input file line components into condition definitions
   const auto make_ssi2 = [&condlist](Core::Conditions::ConditionDefinition& cond)
   {
-    cond.add_component(entry<int>("coupling_id"));
+    cond.add_component(parameter<int>("coupling_id"));
     condlist.push_back(cond);
   };
 
@@ -338,12 +338,12 @@ void Inpar::SSI::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
   // insert input file line components into condition definitions
   const auto make_ssiinterfacemeshtying = [&condlist](Core::Conditions::ConditionDefinition& cond)
   {
-    cond.add_component(entry<int>("ConditionID"));
+    cond.add_component(parameter<int>("ConditionID"));
     cond.add_component(selection<int>("INTERFACE_SIDE",
         {{"Undefined", Inpar::S2I::side_undefined}, {"Slave", Inpar::S2I::side_slave},
             {"Master", Inpar::S2I::side_master}},
         {.description = "interface_side"}));
-    cond.add_component(entry<int>("S2I_KINETICS_ID"));
+    cond.add_component(parameter<int>("S2I_KINETICS_ID"));
 
     condlist.push_back(cond);
   };
@@ -358,13 +358,13 @@ void Inpar::SSI::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
       "SSISurfaceManifold", "scalar transport on manifold", Core::Conditions::SSISurfaceManifold,
       true, Core::Conditions::geometry_type_surface);
 
-  ssisurfacemanifold.add_component(entry<int>("ConditionID"));
+  ssisurfacemanifold.add_component(parameter<int>("ConditionID"));
   ssisurfacemanifold.add_component(selection<int>("ImplType",
       {{"Undefined", Inpar::ScaTra::impltype_undefined}, {"Standard", Inpar::ScaTra::impltype_std},
           {"ElchElectrode", Inpar::ScaTra::impltype_elch_electrode},
           {"ElchDiffCond", Inpar::ScaTra::impltype_elch_diffcond}},
       {.description = "implementation type"}));
-  ssisurfacemanifold.add_component(entry<double>("thickness"));
+  ssisurfacemanifold.add_component(parameter<double>("thickness"));
 
   condlist.emplace_back(ssisurfacemanifold);
 
@@ -377,7 +377,7 @@ void Inpar::SSI::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
 
   surfmanifoldinitfields.add_component(
       selection<std::string>("FIELD", {"ScaTra"}, {.description = "init field"}));
-  surfmanifoldinitfields.add_component(entry<int>("FUNCT"));
+  surfmanifoldinitfields.add_component(parameter<int>("FUNCT"));
 
   condlist.emplace_back(surfmanifoldinitfields);
 
@@ -389,8 +389,8 @@ void Inpar::SSI::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
       Core::Conditions::SSISurfaceManifoldKinetics, true, Core::Conditions::geometry_type_surface);
 
   {
-    surfmanifoldkinetics.add_component(entry<int>("ConditionID"));
-    surfmanifoldkinetics.add_component(entry<int>("ManifoldConditionID"));
+    surfmanifoldkinetics.add_component(parameter<int>("ConditionID"));
+    surfmanifoldkinetics.add_component(parameter<int>("ManifoldConditionID"));
 
     using namespace Core::IO::InputSpecBuilders;
 
@@ -398,19 +398,20 @@ void Inpar::SSI::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
         all_of({
             selection<int>("KINETIC_MODEL", {{"ConstantInterfaceResistance",
                                                 Inpar::S2I::kinetics_constantinterfaceresistance}}),
-            entry<std::vector<int>>("ONOFF", {.size = 2}),
-            entry<double>("RESISTANCE"),
-            entry<int>("E-"),
+            parameter<std::vector<int>>("ONOFF", {.size = 2}),
+            parameter<double>("RESISTANCE"),
+            parameter<int>("E-"),
         }),
         all_of({
             selection<int>("KINETIC_MODEL",
                 {{"Butler-VolmerReduced", Inpar::S2I::kinetics_butlervolmerreduced}}),
-            entry<int>("NUMSCAL"),
-            entry<std::vector<int>>("STOICHIOMETRIES", {.size = from_parameter<int>("NUMSCAL")}),
-            entry<int>("E-"),
-            entry<double>("K_R"),
-            entry<double>("ALPHA_A"),
-            entry<double>("ALPHA_C"),
+            parameter<int>("NUMSCAL"),
+            parameter<std::vector<int>>(
+                "STOICHIOMETRIES", {.size = from_parameter<int>("NUMSCAL")}),
+            parameter<int>("E-"),
+            parameter<double>("K_R"),
+            parameter<double>("ALPHA_A"),
+            parameter<double>("ALPHA_C"),
         }),
         selection<int>(
             "KINETIC_MODEL", {{"NoInterfaceFlux", Inpar::S2I::kinetics_nointerfaceflux}}),
@@ -434,12 +435,12 @@ void Inpar::SSI::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
   const auto add_dirichlet_manifold_components =
       [](Core::Conditions::ConditionDefinition& definition)
   {
-    definition.add_component(entry<int>("NUMDOF"));
-    definition.add_component(entry<std::vector<int>>(
+    definition.add_component(parameter<int>("NUMDOF"));
+    definition.add_component(parameter<std::vector<int>>(
         "ONOFF", {.description = "", .size = from_parameter<int>("NUMDOF")}));
-    definition.add_component(entry<std::vector<double>>(
+    definition.add_component(parameter<std::vector<double>>(
         "VAL", {.description = "", .size = from_parameter<int>("NUMDOF")}));
-    definition.add_component(entry<std::vector<Noneable<int>>>(
+    definition.add_component(parameter<std::vector<Noneable<int>>>(
         "FUNCT", {.description = "", .size = from_parameter<int>("NUMDOF")}));
   };
 
@@ -467,13 +468,13 @@ void Inpar::SSI::set_valid_conditions(std::vector<Core::Conditions::ConditionDef
   // insert input file line components into condition definitions
   const auto make_ssiinterfacecontact = [&condlist](Core::Conditions::ConditionDefinition& cond)
   {
-    cond.add_component(entry<int>("ConditionID"));
+    cond.add_component(parameter<int>("ConditionID"));
     cond.add_component(selection<int>("INTERFACE_SIDE",
         {{"Undefined", Inpar::S2I::side_undefined}, {"Slave", Inpar::S2I::side_slave},
             {"Master", Inpar::S2I::side_master}},
         {.description = "interface_side"}));
-    cond.add_component(entry<int>("S2I_KINETICS_ID"));
-    cond.add_component(entry<int>("CONTACT_CONDITION_ID"));
+    cond.add_component(parameter<int>("S2I_KINETICS_ID"));
+    cond.add_component(parameter<int>("CONTACT_CONDITION_ID"));
 
     condlist.push_back(cond);
   };
diff --git a/src/inpar/4C_inpar_ssti.cpp b/src/inpar/4C_inpar_ssti.cpp
index c8e5c38aabd..099f1e3c590 100644
--- a/src/inpar/4C_inpar_ssti.cpp
+++ b/src/inpar/4C_inpar_ssti.cpp
@@ -152,12 +152,12 @@ void Inpar::SSTI::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
 
   const auto make_sstiinterfacemeshtying = [&condlist](Core::Conditions::ConditionDefinition& cond)
   {
-    cond.add_component(entry<int>("ConditionID"));
+    cond.add_component(parameter<int>("ConditionID"));
     cond.add_component(selection<int>("INTERFACE_SIDE",
         {{"Undefined", Inpar::S2I::side_undefined}, {"Slave", Inpar::S2I::side_slave},
             {"Master", Inpar::S2I::side_master}},
         {.description = "interface side"}));
-    cond.add_component(entry<int>("S2I_KINETICS_ID"));
+    cond.add_component(parameter<int>("S2I_KINETICS_ID"));
     condlist.push_back(cond);
   };
 
diff --git a/src/inpar/4C_inpar_structure.cpp b/src/inpar/4C_inpar_structure.cpp
index b150ace087f..eee52b5e6c1 100644
--- a/src/inpar/4C_inpar_structure.cpp
+++ b/src/inpar/4C_inpar_structure.cpp
@@ -401,22 +401,22 @@ namespace Inpar
       const auto make_robin_spring_dashpot = [&condlist](
                                                  Core::Conditions::ConditionDefinition& cond)
       {
-        cond.add_component(entry<int>("NUMDOF"));
-        cond.add_component(entry<std::vector<int>>(
+        cond.add_component(parameter<int>("NUMDOF"));
+        cond.add_component(parameter<std::vector<int>>(
             "ONOFF", {.description = "", .size = from_parameter<int>("NUMDOF")}));
-        cond.add_component(entry<std::vector<double>>(
+        cond.add_component(parameter<std::vector<double>>(
             "STIFF", {.description = "", .size = from_parameter<int>("NUMDOF")}));
-        cond.add_component(entry<std::vector<int>>(
+        cond.add_component(parameter<std::vector<int>>(
             "TIMEFUNCTSTIFF", {.description = "", .size = from_parameter<int>("NUMDOF")}));
-        cond.add_component(entry<std::vector<double>>(
+        cond.add_component(parameter<std::vector<double>>(
             "VISCO", {.description = "", .size = from_parameter<int>("NUMDOF")}));
-        cond.add_component(entry<std::vector<int>>(
+        cond.add_component(parameter<std::vector<int>>(
             "TIMEFUNCTVISCO", {.description = "", .size = from_parameter<int>("NUMDOF")}));
-        cond.add_component(entry<std::vector<double>>(
+        cond.add_component(parameter<std::vector<double>>(
             "DISPLOFFSET", {.description = "", .size = from_parameter<int>("NUMDOF")}));
-        cond.add_component(entry<std::vector<int>>(
+        cond.add_component(parameter<std::vector<int>>(
             "TIMEFUNCTDISPLOFFSET", {.description = "", .size = from_parameter<int>("NUMDOF")}));
-        cond.add_component(entry<std::vector<int>>(
+        cond.add_component(parameter<std::vector<int>>(
             "FUNCTNONLINSTIFF", {.description = "", .size = from_parameter<int>("NUMDOF")}));
         cond.add_component(
             selection<CONSTRAINTS::SpringDashpot::RobinSpringDashpotType>("DIRECTION",
@@ -426,7 +426,7 @@ namespace Inpar
                     {"cursurfnormal",
                         CONSTRAINTS::SpringDashpot::RobinSpringDashpotType::cursurfnormal}},
                 {.description = "Direction of the spring-dashpot boundary conditions"}));
-        cond.add_component(entry<Noneable<int>>("COUPLING", {.description = ""}));
+        cond.add_component(parameter<Noneable<int>>("COUPLING", {.description = ""}));
         condlist.emplace_back(cond);
       };
 
@@ -442,7 +442,7 @@ namespace Inpar
           "RobinSpring Dashpot Coupling", Core::Conditions::RobinSpringDashpotCoupling, true,
           Core::Conditions::geometry_type_surface);
 
-      springdashpotcoupcond.add_component(entry<int>("COUPLING"));
+      springdashpotcoupcond.add_component(parameter<int>("COUPLING"));
 
       condlist.push_back(springdashpotcoupcond);
     }
diff --git a/src/inpar/4C_inpar_validconditions.cpp b/src/inpar/4C_inpar_validconditions.cpp
index b2d39bc642f..6af2ffb5f2f 100644
--- a/src/inpar/4C_inpar_validconditions.cpp
+++ b/src/inpar/4C_inpar_validconditions.cpp
@@ -79,7 +79,7 @@ namespace Input
         "Layer for Multilayered STC", Core::Conditions::VolSTCLayer, true,
         Core::Conditions::geometry_type_volume);
 
-    stclayer.add_component(entry<int>("ConditionID"));
+    stclayer.add_component(parameter<int>("ConditionID"));
 
     condlist.push_back(stclayer);
   }
@@ -154,12 +154,12 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
 
   const auto make_neumann_condition = [&condlist](auto& cond)
   {
-    cond.add_component(entry<int>("NUMDOF"));
-    cond.add_component(entry<std::vector<int>>(
+    cond.add_component(parameter<int>("NUMDOF"));
+    cond.add_component(parameter<std::vector<int>>(
         "ONOFF", {.description = "onoff", .size = from_parameter<int>("NUMDOF")}));
-    cond.add_component(entry<std::vector<double>>(
+    cond.add_component(parameter<std::vector<double>>(
         "VAL", {.description = "values", .size = from_parameter<int>("NUMDOF")}));
-    cond.add_component(entry<std::vector<Noneable<int>>>(
+    cond.add_component(parameter<std::vector<Noneable<int>>>(
         "FUNCT", {.description = "function ids", .size = from_parameter<int>("NUMDOF")}));
     cond.add_component(selection<std::string>("TYPE",
         {"Live", "Dead", "pseudo_orthopressure", "orthopressure", "PressureGrad"},
@@ -275,12 +275,12 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
 
   const auto make_dirichlet_condition = [&condlist](auto& cond)
   {
-    cond.add_component(entry<int>("NUMDOF"));
-    cond.add_component(entry<std::vector<int>>(
+    cond.add_component(parameter<int>("NUMDOF"));
+    cond.add_component(parameter<std::vector<int>>(
         "ONOFF", {.description = "", .size = from_parameter<int>("NUMDOF")}));
-    cond.add_component(entry<std::vector<double>>(
+    cond.add_component(parameter<std::vector<double>>(
         "VAL", {.description = "", .size = from_parameter<int>("NUMDOF")}));
-    cond.add_component(entry<std::vector<Noneable<int>>>(
+    cond.add_component(parameter<std::vector<Noneable<int>>>(
         "FUNCT", {.description = "", .size = from_parameter<int>("NUMDOF")}));
 
     // optional
@@ -333,8 +333,8 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
 
   const auto make_point_coupling_condition = [&condlist](auto& cond)
   {
-    cond.add_component(entry<int>("NUMDOF"));
-    cond.add_component(entry<std::vector<int>>(
+    cond.add_component(parameter<int>("NUMDOF"));
+    cond.add_component(parameter<std::vector<int>>(
         "ONOFF", {.description = "", .size = from_parameter<int>("NUMDOF")}));
 
     condlist.emplace_back(cond);
@@ -368,7 +368,7 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
         {.description = "init field"}));
 
     // for initial vector fields, use the COMPONENT option of our functions
-    cond.add_component(entry<int>("FUNCT"));
+    cond.add_component(parameter<int>("FUNCT"));
 
     condlist.emplace_back(cond);
   };
@@ -409,7 +409,7 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
   {
     cond.add_component(
         selection<std::string>("FIELD", {"Undefined", "ScaTra"}, {.description = "init field"}));
-    cond.add_component(entry<int>("FUNCT"));
+    cond.add_component(parameter<int>("FUNCT"));
 
     condlist.emplace_back(cond);
   };
@@ -435,7 +435,7 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
 
   const auto make_domain_integral_condition = [&condlist](auto& cond)
   {
-    cond.add_component(entry<int>("ConditionID"));
+    cond.add_component(parameter<int>("ConditionID"));
 
     condlist.emplace_back(cond);
   };
@@ -453,7 +453,7 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
       Core::Conditions::BoundaryIntegral, true, Core::Conditions::geometry_type_surface);
 
   // add input file line components to condition definition
-  boundaryintegralsurf.add_component(entry<int>("ConditionID"));
+  boundaryintegralsurf.add_component(parameter<int>("ConditionID"));
 
   // insert condition definition into global list of valid condition definitions
   condlist.push_back(boundaryintegralsurf);
@@ -488,14 +488,15 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
 
   const auto make_locsys_condition = [&condlist](auto& cond)
   {
-    cond.add_component(entry<std::vector<double>>("ROTANGLE", {.description = "", .size = 3}));
-    cond.add_component(entry<std::vector<Noneable<int>>>("FUNCT", {.description = "", .size = 3}));
-    cond.add_component(entry<int>("USEUPDATEDNODEPOS"));
+    cond.add_component(parameter<std::vector<double>>("ROTANGLE", {.description = "", .size = 3}));
+    cond.add_component(
+        parameter<std::vector<Noneable<int>>>("FUNCT", {.description = "", .size = 3}));
+    cond.add_component(parameter<int>("USEUPDATEDNODEPOS"));
 
     if (cond.geometry_type() == Core::Conditions::geometry_type_line ||
         cond.geometry_type() == Core::Conditions::geometry_type_surface)
     {
-      cond.add_component(entry<int>("USECONSISTENTNODENORMAL"));
+      cond.add_component(parameter<int>("USECONSISTENTNODENORMAL"));
     }
 
     condlist.emplace_back(cond);
@@ -518,16 +519,16 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
 
   const auto make_periodic_condition = [&condlist](auto& cond)
   {
-    cond.add_component(entry<int>("ID", {.description = "periodic boundary condition id"}));
+    cond.add_component(parameter<int>("ID", {.description = "periodic boundary condition id"}));
     cond.add_component(selection<std::string>(
         "MASTER_OR_SLAVE", {"Master", "Slave"}, {.description = "master-slave toggle"}));
     cond.add_component(selection<std::string>("PLANE", {"xy", "yz", "xz", "xyz"},
         {.description = "degrees of freedom for the pbc plane"}));
     cond.add_component(
-        entry<int>("LAYER", {.description = "layer of periodic boundary condition"}));
-    cond.add_component(entry<double>("ANGLE", {.description = "angle of rotation"}));
+        parameter<int>("LAYER", {.description = "layer of periodic boundary condition"}));
+    cond.add_component(parameter<double>("ANGLE", {.description = "angle of rotation"}));
     cond.add_component(
-        entry<double>("ABSTREETOL", {.description = "tolerance for nodematching in octree"}));
+        parameter<double>("ABSTREETOL", {.description = "tolerance for nodematching in octree"}));
 
     condlist.emplace_back(cond);
   };
@@ -564,7 +565,7 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
     // scaling factor for penalty parameter tauB or
     // stabilization parameter alpha for Nitsche term
     // (SCATRA: if stabilization parameter negative -> mixed-hybrid formulation)
-    cond.add_component(entry<double>("TauBscaling"));
+    cond.add_component(parameter<double>("TauBscaling"));
 
     // linearisation strategies --- the linearisation (i.e. the matrix
     // contribution) of the convective term on the inflow could be
@@ -575,10 +576,10 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
         "LINEARISATION", {"lin_all", "no_lin_conv_inflow"}, {.description = "Linearisation"}));
 
     // we provide a vector of 3 values for velocities
-    cond.add_component(entry<std::vector<double>>("VAL", {.description = "values", .size = 3}));
+    cond.add_component(parameter<std::vector<double>>("VAL", {.description = "values", .size = 3}));
 
     // and optional spatial functions
-    cond.add_component(entry<std::vector<int>>("FUNCT",
+    cond.add_component(parameter<std::vector<int>>("FUNCT",
         {.description = "function ids", .default_value = std::vector<int>{0, 0, 0}, .size = 3}));
     // append the condition to the list of all conditions
     condlist.push_back(cond);
@@ -607,9 +608,10 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
       "VolumeConstraint_3D", "Surface Volume Constraint", Core::Conditions::VolumeConstraint_3D,
       true, Core::Conditions::geometry_type_surface);
 
-  volumeconstraint.add_component(entry<int>("ConditionID"));
-  volumeconstraint.add_component(entry<Noneable<int>>("curve", {.description = "id of the curve"}));
-  volumeconstraint.add_component(entry<double>("activeTime"));
+  volumeconstraint.add_component(parameter<int>("ConditionID"));
+  volumeconstraint.add_component(
+      parameter<Noneable<int>>("curve", {.description = "id of the curve"}));
+  volumeconstraint.add_component(parameter<double>("activeTime"));
   volumeconstraint.add_component(selection<std::string>("projection", {"none", "xy", "yz", "xz"},
       {.description = "projection", .default_value = "none"}));
 
@@ -624,12 +626,12 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
       "Surface Volume Constraint Penalty", Core::Conditions::VolumeConstraint_3D_pen, true,
       Core::Conditions::geometry_type_surface);
 
-  volumeconstraintpen.add_component(entry<int>("ConditionID"));
+  volumeconstraintpen.add_component(parameter<int>("ConditionID"));
   volumeconstraintpen.add_component(
-      entry<Noneable<int>>("curve", {.description = "id of the curve"}));
-  volumeconstraintpen.add_component(entry<double>("activeTime"));
-  volumeconstraintpen.add_component(entry<double>("penalty"));
-  volumeconstraintpen.add_component(entry<double>("rho"));
+      parameter<Noneable<int>>("curve", {.description = "id of the curve"}));
+  volumeconstraintpen.add_component(parameter<double>("activeTime"));
+  volumeconstraintpen.add_component(parameter<double>("penalty"));
+  volumeconstraintpen.add_component(parameter<double>("rho"));
   volumeconstraintpen.add_component(selection<std::string>("projection", {"none", "xy", "yz", "xz"},
       {.description = "projection", .default_value = "none"}));
 
@@ -642,9 +644,10 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
       "AreaConstraint_3D", "Surface Area Constraint", Core::Conditions::AreaConstraint_3D, true,
       Core::Conditions::geometry_type_surface);
 
-  areaconstraint.add_component(entry<int>("ConditionID"));
-  areaconstraint.add_component(entry<Noneable<int>>("curve", {.description = "id of the curve"}));
-  areaconstraint.add_component(entry<double>("activeTime"));
+  areaconstraint.add_component(parameter<int>("ConditionID"));
+  areaconstraint.add_component(
+      parameter<Noneable<int>>("curve", {.description = "id of the curve"}));
+  areaconstraint.add_component(parameter<double>("activeTime"));
 
   condlist.push_back(areaconstraint);
 
@@ -656,7 +659,7 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
       "VolumeMonitor_3D", "Surface Volume Monitor", Core::Conditions::VolumeMonitor_3D, true,
       Core::Conditions::geometry_type_surface);
 
-  volumemonitor.add_component(entry<int>("ConditionID"));
+  volumemonitor.add_component(parameter<int>("ConditionID"));
 
   condlist.push_back(volumemonitor);
 
@@ -667,7 +670,7 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
       "AreaMonitor_3D", "Surface Area Monitor", Core::Conditions::AreaMonitor_3D, true,
       Core::Conditions::geometry_type_surface);
 
-  areamonitor.add_component(entry<int>("ConditionID"));
+  areamonitor.add_component(parameter<int>("ConditionID"));
   areamonitor.add_component(selection<std::string>("projection", {"none", "xy", "yz", "xz"},
       {.description = "projection", .default_value = "none"}));
 
@@ -680,9 +683,9 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
       "AreaConstraint_2D", "Line Area Constraint", Core::Conditions::AreaConstraint_2D, true,
       Core::Conditions::geometry_type_line);
 
-  areaconstraint2D.add_component(entry<int>("ConditionID"));
-  areaconstraint2D.add_component(entry<Noneable<int>>("curve", {.description = {}}));
-  areaconstraint2D.add_component(entry<double>("activeTime"));
+  areaconstraint2D.add_component(parameter<int>("ConditionID"));
+  areaconstraint2D.add_component(parameter<Noneable<int>>("curve", {.description = {}}));
+  areaconstraint2D.add_component(parameter<double>("activeTime"));
 
   condlist.push_back(areaconstraint2D);
 
@@ -693,7 +696,7 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
       "AreaMonitor_2D", "Line Area Monitor", Core::Conditions::AreaMonitor_2D, true,
       Core::Conditions::geometry_type_line);
 
-  areamonitor2D.add_component(entry<int>("ConditionID"));
+  areamonitor2D.add_component(parameter<int>("ConditionID"));
 
   condlist.push_back(areamonitor2D);
 
@@ -704,11 +707,11 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
       "MPC_NodeOnPlane_3D", "Node on Plane Constraint", Core::Conditions::MPC_NodeOnPlane_3D, false,
       Core::Conditions::geometry_type_surface);
 
-  nodeonplaneconst3D.add_component(entry<int>("ConditionID"));
-  nodeonplaneconst3D.add_component(entry<double>("amplitude"));
-  nodeonplaneconst3D.add_component(entry<Noneable<int>>("curve", {.description = {}}));
-  nodeonplaneconst3D.add_component(entry<double>("activeTime"));
-  nodeonplaneconst3D.add_component(entry<std::vector<int>>(
+  nodeonplaneconst3D.add_component(parameter<int>("ConditionID"));
+  nodeonplaneconst3D.add_component(parameter<double>("amplitude"));
+  nodeonplaneconst3D.add_component(parameter<Noneable<int>>("curve", {.description = {}}));
+  nodeonplaneconst3D.add_component(parameter<double>("activeTime"));
+  nodeonplaneconst3D.add_component(parameter<std::vector<int>>(
       "planeNodes", {.description = "ids of the nodes spanning the plane", .size = 3}));
   nodeonplaneconst3D.add_component(selection<std::string>("control", {"rel", "abs"},
       {.description = "relative or absolute control", .default_value = "rel"}));
@@ -723,13 +726,13 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
       "Node on Plane Constraint", Core::Conditions::MPC_NormalComponent_3D, false,
       Core::Conditions::geometry_type_surface);
 
-  nodemasterconst3D.add_component(entry<int>("ConditionID"));
-  nodemasterconst3D.add_component(entry<double>("amplitude"));
-  nodemasterconst3D.add_component(entry<Noneable<int>>("curve", {.description = {}}));
-  nodemasterconst3D.add_component(entry<double>("activeTime"));
-  nodemasterconst3D.add_component(entry<int>("masterNode"));
+  nodemasterconst3D.add_component(parameter<int>("ConditionID"));
+  nodemasterconst3D.add_component(parameter<double>("amplitude"));
+  nodemasterconst3D.add_component(parameter<Noneable<int>>("curve", {.description = {}}));
+  nodemasterconst3D.add_component(parameter<double>("activeTime"));
+  nodemasterconst3D.add_component(parameter<int>("masterNode"));
   nodemasterconst3D.add_component(
-      entry<std::vector<double>>("direction", {.description = "direction", .size = 3}));
+      parameter<std::vector<double>>("direction", {.description = "direction", .size = 3}));
   nodemasterconst3D.add_component(selection<std::string>(
       "value", {"disp", "x"}, {.description = "value", .default_value = "disp"}));
   nodemasterconst3D.add_component(selection<std::string>("control", {"rel", "abs"},
@@ -746,14 +749,14 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
       Core::Conditions::geometry_type_surface);
 
 
-  nodemasterconst3Dpen.add_component(entry<int>("ConditionID"));
-  nodemasterconst3Dpen.add_component(entry<double>("amplitude"));
-  nodemasterconst3Dpen.add_component(entry<Noneable<int>>("curve", {.description = {}}));
-  nodemasterconst3Dpen.add_component(entry<double>("activeTime"));
-  nodemasterconst3Dpen.add_component(entry<double>("penalty"));
-  nodemasterconst3Dpen.add_component(entry<int>("masterNode"));
+  nodemasterconst3Dpen.add_component(parameter<int>("ConditionID"));
+  nodemasterconst3Dpen.add_component(parameter<double>("amplitude"));
+  nodemasterconst3Dpen.add_component(parameter<Noneable<int>>("curve", {.description = {}}));
+  nodemasterconst3Dpen.add_component(parameter<double>("activeTime"));
+  nodemasterconst3Dpen.add_component(parameter<double>("penalty"));
+  nodemasterconst3Dpen.add_component(parameter<int>("masterNode"));
   nodemasterconst3Dpen.add_component(
-      entry<std::vector<int>>("direction", {.description = "direction", .size = 3}));
+      parameter<std::vector<int>>("direction", {.description = "direction", .size = 3}));
   nodemasterconst3Dpen.add_component(selection<std::string>(
       "value", {"disp", "x"}, {.description = "value", .default_value = "disp"}));
   nodemasterconst3Dpen.add_component(selection<std::string>("control", {"rel", "abs"},
@@ -766,15 +769,15 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
       "MPC_NodeOnLine_2D", "Node on Line Constraint", Core::Conditions::MPC_NodeOnLine_2D, false,
       Core::Conditions::geometry_type_line);
 
-  nodeonlineconst2D.add_component(entry<int>("ConditionID"));
-  nodeonlineconst2D.add_component(entry<double>("amplitude"));
-  nodeonlineconst2D.add_component(entry<Noneable<int>>("curve", {.description = {}}));
-  nodeonlineconst2D.add_component(entry<int>("constrNode1"));
-  nodeonlineconst2D.add_component(entry<int>("constrNode2"));
-  nodeonlineconst2D.add_component(entry<int>("constrNode3"));
+  nodeonlineconst2D.add_component(parameter<int>("ConditionID"));
+  nodeonlineconst2D.add_component(parameter<double>("amplitude"));
+  nodeonlineconst2D.add_component(parameter<Noneable<int>>("curve", {.description = {}}));
+  nodeonlineconst2D.add_component(parameter<int>("constrNode1"));
+  nodeonlineconst2D.add_component(parameter<int>("constrNode2"));
+  nodeonlineconst2D.add_component(parameter<int>("constrNode3"));
   nodeonlineconst2D.add_component(selection<std::string>("control", {"dist", "angle"},
       {.description = "distance or angle control", .default_value = "dist"}));
-  nodeonlineconst2D.add_component(entry<double>("activeTime"));
+  nodeonlineconst2D.add_component(parameter<double>("activeTime"));
 
   condlist.push_back(nodeonlineconst2D);
 
@@ -813,8 +816,8 @@ std::vector<Core::Conditions::ConditionDefinition> Input::valid_conditions()
   {
     cond.add_component(selection<std::string>(
         "DIS", {"fluid", "scatra", "solid"}, {.description = "discretization"}));
-    cond.add_component(entry<int>("NUMMODES"));
-    cond.add_component(entry<std::vector<int>>(
+    cond.add_component(parameter<int>("NUMMODES"));
+    cond.add_component(parameter<std::vector<int>>(
         "ONOFF", {.description = "", .size = from_parameter<int>("NUMMODES")}));
     cond.add_component(selection<std::string>("WEIGHTVECDEF", {"integration", "pointvalues"},
         {.description = "weight vector definition"}));
diff --git a/src/inpar/4C_inpar_xfem.cpp b/src/inpar/4C_inpar_xfem.cpp
index d0b92230593..9314d459f95 100644
--- a/src/inpar/4C_inpar_xfem.cpp
+++ b/src/inpar/4C_inpar_xfem.cpp
@@ -392,18 +392,18 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
   using namespace Core::IO::InputSpecBuilders;
 
   auto dirichletbundcomponents = all_of({
-      entry<int>("NUMDOF"),
-      entry<std::vector<int>>("ONOFF", {.size = from_parameter<int>("NUMDOF")}),
-      entry<std::vector<double>>("VAL", {.size = from_parameter<int>("NUMDOF")}),
-      entry<std::vector<Noneable<int>>>("FUNCT", {.size = from_parameter<int>("NUMDOF")}),
+      parameter<int>("NUMDOF"),
+      parameter<std::vector<int>>("ONOFF", {.size = from_parameter<int>("NUMDOF")}),
+      parameter<std::vector<double>>("VAL", {.size = from_parameter<int>("NUMDOF")}),
+      parameter<std::vector<Noneable<int>>>("FUNCT", {.size = from_parameter<int>("NUMDOF")}),
       selection<std::string>("TAG", {"none", "monitor_reaction"}, {.required = false}),
   });
 
   auto neumanncomponents = all_of({
-      entry<int>("NUMDOF"),
-      entry<std::vector<int>>("ONOFF", {.size = from_parameter<int>("NUMDOF")}),
-      entry<std::vector<double>>("VAL", {.size = from_parameter<int>("NUMDOF")}),
-      entry<std::vector<Noneable<int>>>("FUNCT", {.size = from_parameter<int>("NUMDOF")}),
+      parameter<int>("NUMDOF"),
+      parameter<std::vector<int>>("ONOFF", {.size = from_parameter<int>("NUMDOF")}),
+      parameter<std::vector<double>>("VAL", {.size = from_parameter<int>("NUMDOF")}),
+      parameter<std::vector<Noneable<int>>>("FUNCT", {.size = from_parameter<int>("NUMDOF")}),
       selection<std::string>("TYPE",
           {"Live", "Dead", "pseudo_orthopressure", "orthopressure", "PressureGrad"},
           {.default_value = "Live"}),
@@ -420,7 +420,7 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
 
   const auto make_fluid_cond = [&condlist](Core::Conditions::ConditionDefinition& cond)
   {
-    cond.add_component(entry<int>("COUPLINGID"));
+    cond.add_component(parameter<int>("COUPLINGID"));
 
     condlist.emplace_back(cond);
   };
@@ -439,7 +439,7 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
       "DESIGN XFEM DISPLACEMENT SURF CONDITIONS", "XFEMSurfDisplacement", "XFEM Surf Displacement",
       Core::Conditions::XFEM_Surf_Displacement, true, Core::Conditions::geometry_type_surface);
 
-  xfem_surf_displacement.add_component(entry<int>("COUPLINGID"));
+  xfem_surf_displacement.add_component(parameter<int>("COUPLINGID"));
   xfem_surf_displacement.add_component(selection<std::string>("EVALTYPE",
       {"zero", "funct", "implementation"}, {.description = "", .default_value = "funct"}));
 
@@ -451,14 +451,14 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
   // Levelset field condition components
 
   auto levelsetfield_components = all_of({
-      entry<int>("COUPLINGID"),
-      entry<int>("LEVELSETFIELDNO"),
+      parameter<int>("COUPLINGID"),
+      parameter<int>("LEVELSETFIELDNO"),
       selection<std::string>("BOOLEANTYPE",
           {"none", "cut", "union", "difference", "sym_difference"},
           {.description = "define which boolean operator is used for combining this level-set "
                           "field with the previous one with smaller coupling id",
               .required = false}),
-      entry<bool>(
+      parameter<bool>(
           "COMPLEMENTARY", {.description = "define which complementary operator is applied "
                                            "after combining the level-set field with a boolean "
                                            "operator with the previous one"}),
@@ -477,7 +477,7 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
   xfem_levelset_wdbc.add_component(dirichletbundcomponents);
 
   // optional: allow for random noise, set percentage used in uniform random distribution
-  xfem_levelset_wdbc.add_component(entry<double>("RANDNOISE",
+  xfem_levelset_wdbc.add_component(parameter<double>("RANDNOISE",
       {.description = "set percentage of random noise used in uniform random distribution",
           .default_value = 0.0}));
 
@@ -496,7 +496,7 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
 
   // define if we use inflow stabilization on the xfem neumann surf condition
   xfem_levelset_neumann.add_component(
-      entry<bool>("INFLOW_STAB", {.description = "", .default_value = false}));
+      parameter<bool>("INFLOW_STAB", {.description = "", .default_value = false}));
   condlist.push_back(xfem_levelset_neumann);
 
   //*----------------*/
@@ -514,16 +514,17 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
           {"proj_normal_smoothed_comb", Inpar::XFEM::Proj_normal_smoothed_comb},
           {"proj_normal_phi", Inpar::XFEM::Proj_normal_phi}},
       {.description = "", .default_value = Inpar::XFEM::Proj_normal}));
-  xfem_levelset_navier_slip.add_component(entry<int>("L2_PROJECTION_SOLVER", {.description = ""}));
   xfem_levelset_navier_slip.add_component(
-      entry<Noneable<int>>("ROBIN_DIRICHLET_ID", {.description = ""}));
+      parameter<int>("L2_PROJECTION_SOLVER", {.description = ""}));
   xfem_levelset_navier_slip.add_component(
-      entry<Noneable<int>>("ROBIN_NEUMANN_ID", {.description = ""}));
-  xfem_levelset_navier_slip.add_component(entry<double>("SLIPCOEFFICIENT"));
+      parameter<Noneable<int>>("ROBIN_DIRICHLET_ID", {.description = ""}));
   xfem_levelset_navier_slip.add_component(
-      entry<int>("FUNCT", {.description = "slip function id", .default_value = 0}));
+      parameter<Noneable<int>>("ROBIN_NEUMANN_ID", {.description = ""}));
+  xfem_levelset_navier_slip.add_component(parameter<double>("SLIPCOEFFICIENT"));
   xfem_levelset_navier_slip.add_component(
-      entry<bool>("FORCE_ONLY_TANG_VEL", {.description = "", .default_value = false}));
+      parameter<int>("FUNCT", {.description = "slip function id", .default_value = 0}));
+  xfem_levelset_navier_slip.add_component(
+      parameter<bool>("FORCE_ONLY_TANG_VEL", {.description = "", .default_value = false}));
 
   condlist.push_back(xfem_levelset_navier_slip);
 
@@ -535,7 +536,7 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
       Core::Conditions::geometry_type_volume);
 
   xfem_navier_slip_robin_dirch.add_component(
-      entry<Noneable<int>>("ROBIN_ID", {.description = "robin id"}));
+      parameter<Noneable<int>>("ROBIN_ID", {.description = "robin id"}));
 
   xfem_navier_slip_robin_dirch.add_component(dirichletbundcomponents);
 
@@ -547,7 +548,7 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
       Core::Conditions::geometry_type_volume);
 
   xfem_navier_slip_robin_neumann.add_component(
-      entry<Noneable<int>>("ROBIN_ID", {.description = "robin id"}));
+      parameter<Noneable<int>>("ROBIN_ID", {.description = "robin id"}));
 
   xfem_navier_slip_robin_neumann.add_component(neumanncomponents);
 
@@ -573,7 +574,7 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
       "DESIGN XFEM FLUIDFLUID SURF CONDITIONS", "XFEMSurfFluidFluid", "XFEM Surf FluidFluid",
       Core::Conditions::XFEM_Surf_FluidFluid, true, Core::Conditions::geometry_type_surface);
 
-  xfem_surf_fluidfluid.add_component(entry<int>("COUPLINGID"));
+  xfem_surf_fluidfluid.add_component(parameter<int>("COUPLINGID"));
   xfem_surf_fluidfluid.add_component(selection<int>("COUPSTRATEGY",
       {{"xfluid", Inpar::XFEM::Xfluid_Sided}, {"embedded", Inpar::XFEM::Embedded_Sided},
           {"mean", Inpar::XFEM::Mean}},
@@ -588,7 +589,7 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
       "DESIGN XFEM FSI PARTITIONED SURF CONDITIONS", "XFEMSurfFSIPart", "XFEM Surf FSI Part",
       Core::Conditions::XFEM_Surf_FSIPart, true, Core::Conditions::geometry_type_surface);
 
-  xfem_surf_fsi_part.add_component(entry<int>("COUPLINGID"));
+  xfem_surf_fsi_part.add_component(parameter<int>("COUPLINGID"));
 
   // COUPSTRATEGY IS FLUID SIDED
   xfem_surf_fsi_part.add_component(selection<int>("INTLAW",
@@ -596,9 +597,9 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
           {"slip", Inpar::XFEM::slip}, {"navslip", Inpar::XFEM::navierslip}},
       {.description = "", .default_value = Inpar::XFEM::noslip}));
   xfem_surf_fsi_part.add_component(
-      entry<double>("SLIPCOEFFICIENT", {.description = "", .default_value = 0.0}));
+      parameter<double>("SLIPCOEFFICIENT", {.description = "", .default_value = 0.0}));
   xfem_surf_fsi_part.add_component(
-      entry<int>("SLIP_FUNCT", {.description = "slip function id", .default_value = 0}));
+      parameter<int>("SLIP_FUNCT", {.description = "slip function id", .default_value = 0}));
 
   condlist.push_back(xfem_surf_fsi_part);
 
@@ -609,7 +610,7 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
       "DESIGN XFEM FSI MONOLITHIC SURF CONDITIONS", "XFEMSurfFSIMono", "XFEM Surf FSI Mono",
       Core::Conditions::XFEM_Surf_FSIMono, true, Core::Conditions::geometry_type_surface);
 
-  xfem_surf_fsi_mono.add_component(entry<int>("COUPLINGID"));
+  xfem_surf_fsi_mono.add_component(parameter<int>("COUPLINGID"));
   xfem_surf_fsi_mono.add_component(selection<int>("COUPSTRATEGY",
       {{"xfluid", Inpar::XFEM::Xfluid_Sided}, {"solid", Inpar::XFEM::Embedded_Sided},
           {"mean", Inpar::XFEM::Mean}, {"harmonic", Inpar::XFEM::Harmonic}},
@@ -620,9 +621,9 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
           {"navslip_contact", Inpar::XFEM::navierslip_contact}},
       {.description = "", .default_value = Inpar::XFEM::noslip}));
   xfem_surf_fsi_mono.add_component(
-      entry<double>("SLIPCOEFFICIENT", {.description = "", .default_value = 0.0}));
+      parameter<double>("SLIPCOEFFICIENT", {.description = "", .default_value = 0.0}));
   xfem_surf_fsi_mono.add_component(
-      entry<int>("SLIP_FUNCT", {.description = "slip function id", .default_value = 0}));
+      parameter<int>("SLIP_FUNCT", {.description = "slip function id", .default_value = 0}));
 
   condlist.push_back(xfem_surf_fsi_mono);
 
@@ -633,15 +634,15 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
       "DESIGN XFEM FPI MONOLITHIC SURF CONDITIONS", "XFEMSurfFPIMono", "XFEM Surf FPI Mono",
       Core::Conditions::XFEM_Surf_FPIMono, true, Core::Conditions::geometry_type_surface);
 
-  xfem_surf_fpi_mono.add_component(entry<int>("COUPLINGID"));
+  xfem_surf_fpi_mono.add_component(parameter<int>("COUPLINGID"));
   xfem_surf_fpi_mono.add_component(
-      entry<double>("BJ_COEFF", {.description = "", .default_value = 0}));
+      parameter<double>("BJ_COEFF", {.description = "", .default_value = 0}));
   xfem_surf_fpi_mono.add_component(selection<std::string>(
       "Variant", {"BJ", "BJS"}, {.description = "variant", .default_value = "BJ"}));
   xfem_surf_fpi_mono.add_component(selection<std::string>(
       "Method", {"NIT", "SUB"}, {.description = "method", .default_value = "NIT"}));
   xfem_surf_fpi_mono.add_component(
-      entry<bool>("Contact", {.description = "contact", .default_value = false}));
+      parameter<bool>("Contact", {.description = "contact", .default_value = false}));
 
   condlist.push_back(xfem_surf_fpi_mono);
 
@@ -653,7 +654,7 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
       "XFEMSurfWeakDirichlet", "XFEM Surf Weak Dirichlet",
       Core::Conditions::XFEM_Surf_Weak_Dirichlet, true, Core::Conditions::geometry_type_surface);
 
-  xfem_surf_wdbc.add_component(entry<int>("COUPLINGID"));
+  xfem_surf_wdbc.add_component(parameter<int>("COUPLINGID"));
   xfem_surf_wdbc.add_component(selection<std::string>("EVALTYPE",
       {"zero", "funct_interpolated", "funct_gausspoint", "displacement_1storder_wo_initfunct",
           "displacement_2ndorder_wo_initfunct", "displacement_1storder_with_initfunct",
@@ -663,7 +664,7 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
   xfem_surf_wdbc.add_component(dirichletbundcomponents);
 
   // optional: allow for random noise, set percentage used in uniform random distribution
-  xfem_surf_wdbc.add_component(entry<double>("RANDNOISE",
+  xfem_surf_wdbc.add_component(parameter<double>("RANDNOISE",
       {.description = "set percentage of random noise used in uniform random distribution",
           .default_value = 0.0}));
 
@@ -677,12 +678,12 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
       "XFEMSurfNeumann", "XFEM Surf Neumann", Core::Conditions::XFEM_Surf_Neumann, true,
       Core::Conditions::geometry_type_surface);
 
-  xfem_surf_neumann.add_component(entry<int>("COUPLINGID"));
+  xfem_surf_neumann.add_component(parameter<int>("COUPLINGID"));
 
   xfem_surf_neumann.add_component(neumanncomponents);
 
   // define if we use inflow stabilization on the xfem neumann surf condition
-  xfem_surf_neumann.add_component(entry<bool>(
+  xfem_surf_neumann.add_component(parameter<bool>(
       "INFLOW_STAB", {.description = "toggle inflow stabilization", .default_value = false}));
 
   condlist.push_back(xfem_surf_neumann);
@@ -694,21 +695,21 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
       "DESIGN XFEM NAVIER SLIP SURF CONDITIONS", "XFEMSurfNavierSlip", "XFEM Surf Navier Slip",
       Core::Conditions::XFEM_Surf_Navier_Slip, true, Core::Conditions::geometry_type_surface);
 
-  xfem_surf_navier_slip.add_component(entry<int>("COUPLINGID"));
+  xfem_surf_navier_slip.add_component(parameter<int>("COUPLINGID"));
   xfem_surf_navier_slip.add_component(selection<std::string>("EVALTYPE",
       {"zero", "funct_interpolated", "funct_gausspoint", "displacement_1storder_wo_initfunct",
           "displacement_2ndorder_wo_initfunct", "displacement_1storder_with_initfunct",
           "displacement_2ndorder_with_initfunct"},
       {.description = "", .default_value = "funct_interpolated"}));
   xfem_surf_navier_slip.add_component(
-      entry<Noneable<int>>("ROBIN_DIRICHLET_ID", {.description = ""}));
+      parameter<Noneable<int>>("ROBIN_DIRICHLET_ID", {.description = ""}));
   xfem_surf_navier_slip.add_component(
-      entry<Noneable<int>>("ROBIN_NEUMANN_ID", {.description = ""}));
-  xfem_surf_navier_slip.add_component(entry<double>("SLIPCOEFFICIENT"));
+      parameter<Noneable<int>>("ROBIN_NEUMANN_ID", {.description = ""}));
+  xfem_surf_navier_slip.add_component(parameter<double>("SLIPCOEFFICIENT"));
   xfem_surf_navier_slip.add_component(
-      entry<int>("FUNCT", {.description = "slip function id", .default_value = 0}));
+      parameter<int>("FUNCT", {.description = "slip function id", .default_value = 0}));
   xfem_surf_navier_slip.add_component(
-      entry<bool>("FORCE_ONLY_TANG_VEL", {.description = "", .default_value = false}));
+      parameter<bool>("FORCE_ONLY_TANG_VEL", {.description = "", .default_value = false}));
 
   condlist.push_back(xfem_surf_navier_slip);
 
@@ -719,9 +720,9 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
 
   // this implementation should be reviewed at some point as it requires these conditions
   //  to have a couplingID. In theory this should not be necessary.
-  xfem_navier_slip_robin_dirch_surf.add_component(entry<int>("COUPLINGID"));
+  xfem_navier_slip_robin_dirch_surf.add_component(parameter<int>("COUPLINGID"));
   xfem_navier_slip_robin_dirch_surf.add_component(
-      entry<Noneable<int>>("ROBIN_ID", {.description = "robin id"}));
+      parameter<Noneable<int>>("ROBIN_ID", {.description = "robin id"}));
 
   // Likely, not necessary. But needed for the current structure.
   xfem_navier_slip_robin_dirch_surf.add_component(selection<std::string>("EVALTYPE",
@@ -741,9 +742,9 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
 
   // this implementation should be reviewed at some point as it requires these conditions
   //  to have a couplingID. In theory this should not be necessary.
-  xfem_navier_slip_robin_neumann_surf.add_component(entry<int>("COUPLINGID"));
+  xfem_navier_slip_robin_neumann_surf.add_component(parameter<int>("COUPLINGID"));
   xfem_navier_slip_robin_neumann_surf.add_component(
-      entry<Noneable<int>>("ROBIN_ID", {.description = "robin id"}));
+      parameter<Noneable<int>>("ROBIN_ID", {.description = "robin id"}));
 
   xfem_navier_slip_robin_neumann_surf.add_component(neumanncomponents);
 
@@ -756,7 +757,7 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
       "Embedded Mesh Solid Surface Coupling", Core::Conditions::Embedded_Mesh_Solid_Surf_Coupling,
       true, Core::Conditions::geometry_type_surface);
 
-  solid_surf_coupling.add_component(entry<int>("COUPLINGID"));
+  solid_surf_coupling.add_component(parameter<int>("COUPLINGID"));
 
   condlist.push_back(solid_surf_coupling);
 
@@ -767,7 +768,7 @@ void Inpar::XFEM::set_valid_conditions(std::vector<Core::Conditions::ConditionDe
       Core::Conditions::Embedded_Mesh_Solid_Volume_Background, true,
       Core::Conditions::geometry_type_volume);
 
-  solid_vol_background_coupling.add_component(entry<int>("COUPLINGID"));
+  solid_vol_background_coupling.add_component(parameter<int>("COUPLINGID"));
   condlist.push_back(solid_vol_background_coupling);
 }
 
diff --git a/src/lubrication/src/4C_lubrication_ele.cpp b/src/lubrication/src/4C_lubrication_ele.cpp
index 27ee0232832..bf6e2a1e3b4 100644
--- a/src/lubrication/src/4C_lubrication_ele.cpp
+++ b/src/lubrication/src/4C_lubrication_ele.cpp
@@ -76,38 +76,38 @@ void Discret::Elements::LubricationType::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"),
   });
 
   defs["LINE2"] = all_of({
-      entry<std::vector<int>>("LINE2", {.size = 2}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("LINE2", {.size = 2}),
+      parameter<int>("MAT"),
   });
 
   defs["LINE3"] = all_of({
-      entry<std::vector<int>>("LINE3", {.size = 3}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("LINE3", {.size = 3}),
+      parameter<int>("MAT"),
   });
 }
 
diff --git a/src/membrane/4C_membrane_eletypes.cpp b/src/membrane/4C_membrane_eletypes.cpp
index b7da722c6f9..69bc50566d8 100644
--- a/src/membrane/4C_membrane_eletypes.cpp
+++ b/src/membrane/4C_membrane_eletypes.cpp
@@ -74,17 +74,17 @@ void Discret::Elements::MembraneTri3Type::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["TRI3"] = all_of({
-      entry<std::vector<int>>("TRI3", {.size = 3}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<double>("THICK"),
-      entry<std::string>("STRESS_STRAIN"),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("TRI3", {.size = 3}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<double>("THICK"),
+      parameter<std::string>("STRESS_STRAIN"),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
   });
 }
 
@@ -149,17 +149,17 @@ void Discret::Elements::MembraneTri6Type::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["TRI6"] = all_of({
-      entry<std::vector<int>>("TRI6", {.size = 6}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<double>("THICK"),
-      entry<std::string>("STRESS_STRAIN"),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("TRI6", {.size = 6}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<double>("THICK"),
+      parameter<std::string>("STRESS_STRAIN"),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
   });
 }
 
@@ -224,17 +224,17 @@ void Discret::Elements::MembraneQuad4Type::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["QUAD4"] = all_of({
-      entry<std::vector<int>>("QUAD4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<double>("THICK"),
-      entry<std::string>("STRESS_STRAIN"),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("QUAD4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<double>("THICK"),
+      parameter<std::string>("STRESS_STRAIN"),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
   });
 }
 
@@ -299,17 +299,17 @@ void Discret::Elements::MembraneQuad9Type::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["QUAD9"] = all_of({
-      entry<std::vector<int>>("QUAD9", {.size = 9}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<double>("THICK"),
-      entry<std::string>("STRESS_STRAIN"),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("QUAD9", {.size = 9}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<double>("THICK"),
+      parameter<std::string>("STRESS_STRAIN"),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
   });
 }
 
diff --git a/src/membrane/4C_membrane_scatra_eletypes.cpp b/src/membrane/4C_membrane_scatra_eletypes.cpp
index 13858f79175..3612f054efd 100644
--- a/src/membrane/4C_membrane_scatra_eletypes.cpp
+++ b/src/membrane/4C_membrane_scatra_eletypes.cpp
@@ -64,7 +64,7 @@ void Discret::Elements::MembraneScatraTri3Type::setup_element_definition(
 
   defs["TRI3"] = all_of({
       defs_membrane["TRI3"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
@@ -121,7 +121,7 @@ void Discret::Elements::MembraneScatraTri6Type::setup_element_definition(
 
   defs["TRI6"] = all_of({
       defs_membrane["TRI6"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
@@ -178,7 +178,7 @@ void Discret::Elements::MembraneScatraQuad4Type::setup_element_definition(
 
   defs["QUAD4"] = all_of({
       defs_membrane["QUAD4"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
@@ -235,7 +235,7 @@ void Discret::Elements::MembraneScatraQuad9Type::setup_element_definition(
 
   defs["QUAD9"] = all_of({
       defs_membrane["QUAD9"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
diff --git a/src/module_registry/4C_module_registry_callbacks.hpp b/src/module_registry/4C_module_registry_callbacks.hpp
index 890b7839829..9d5b0cdcbe5 100644
--- a/src/module_registry/4C_module_registry_callbacks.hpp
+++ b/src/module_registry/4C_module_registry_callbacks.hpp
@@ -57,7 +57,8 @@ struct ModuleCallbacks
    * Nested groups are allowed.
    *
    * @note The materials from various modules are gathered in a shared section. The input mechanism
-   * automatically adds an `entry<int>("MAT")` to the InputSpec to allow enumeration of materials.
+   * automatically adds an `parameter<int>("MAT")` to the InputSpec to allow enumeration of
+   * materials.
    */
   std::function<std::unordered_map<Core::Materials::MaterialType, Core::IO::InputSpec>()> materials;
 };
diff --git a/src/porofluidmultiphase_ele/4C_porofluidmultiphase_ele.cpp b/src/porofluidmultiphase_ele/4C_porofluidmultiphase_ele.cpp
index 82a5a185747..48b87465696 100644
--- a/src/porofluidmultiphase_ele/4C_porofluidmultiphase_ele.cpp
+++ b/src/porofluidmultiphase_ele/4C_porofluidmultiphase_ele.cpp
@@ -80,53 +80,53 @@ void Discret::Elements::PoroFluidMultiPhaseType::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"),
   });
 
   defs["LINE2"] = all_of({
-      entry<std::vector<int>>("LINE2", {.size = 2}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("LINE2", {.size = 2}),
+      parameter<int>("MAT"),
   });
 
   defs["LINE3"] = all_of({
-      entry<std::vector<int>>("LINE3", {.size = 3}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("LINE3", {.size = 3}),
+      parameter<int>("MAT"),
   });
 
   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["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"),
   });
 }
 
diff --git a/src/poromultiphase_scatra/4C_poromultiphase_scatra_function.cpp b/src/poromultiphase_scatra/4C_poromultiphase_scatra_function.cpp
index 8cc5f169204..e53450bae85 100644
--- a/src/poromultiphase_scatra/4C_poromultiphase_scatra_function.cpp
+++ b/src/poromultiphase_scatra/4C_poromultiphase_scatra_function.cpp
@@ -117,9 +117,9 @@ void PoroMultiPhaseScaTra::add_valid_poro_functions(Core::Utils::FunctionManager
 
   function_manager.add_function_definition(
       all_of({
-          entry<std::string>("POROMULTIPHASESCATRA_FUNCTION"),
-          entry<int>("NUMPARAMS", {.required = false}),
-          entry<std::map<std::string, double>>(
+          parameter<std::string>("POROMULTIPHASESCATRA_FUNCTION"),
+          parameter<int>("NUMPARAMS", {.required = false}),
+          parameter<std::map<std::string, double>>(
               "PARAMS", {.required = false, .size = from_parameter<int>("NUMPARAMS")}),
       }),
       try_create_poro_function_dispatch);
diff --git a/src/red_airways/4C_red_airways_acinus.cpp b/src/red_airways/4C_red_airways_acinus.cpp
index c2442420382..582b94fcb15 100644
--- a/src/red_airways/4C_red_airways_acinus.cpp
+++ b/src/red_airways/4C_red_airways_acinus.cpp
@@ -65,26 +65,26 @@ void Discret::Elements::RedAcinusType::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["LINE2"] = all_of({
-      entry<std::vector<int>>("LINE2", {.size = 2}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<double>("AcinusVolume"),
-      entry<double>("AlveolarDuctVolume"),
-      entry<double>("E1_0", {.required = false}),
-      entry<double>("E1_LIN", {.required = false}),
-      entry<double>("E1_EXP", {.required = false}),
-      entry<double>("TAU", {.required = false}),
-      entry<double>("E1_01", {.required = false}),
-      entry<double>("E1_LIN1", {.required = false}),
-      entry<double>("E1_EXP1", {.required = false}),
-      entry<double>("TAU1", {.required = false}),
-      entry<double>("E1_02", {.required = false}),
-      entry<double>("E1_LIN2", {.required = false}),
-      entry<double>("E1_EXP2", {.required = false}),
-      entry<double>("TAU2", {.required = false}),
-      entry<double>("KAPPA", {.required = false}),
-      entry<double>("BETA", {.required = false}),
-      entry<double>("Area", {.required = false}),
+      parameter<std::vector<int>>("LINE2", {.size = 2}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<double>("AcinusVolume"),
+      parameter<double>("AlveolarDuctVolume"),
+      parameter<double>("E1_0", {.required = false}),
+      parameter<double>("E1_LIN", {.required = false}),
+      parameter<double>("E1_EXP", {.required = false}),
+      parameter<double>("TAU", {.required = false}),
+      parameter<double>("E1_01", {.required = false}),
+      parameter<double>("E1_LIN1", {.required = false}),
+      parameter<double>("E1_EXP1", {.required = false}),
+      parameter<double>("TAU1", {.required = false}),
+      parameter<double>("E1_02", {.required = false}),
+      parameter<double>("E1_LIN2", {.required = false}),
+      parameter<double>("E1_EXP2", {.required = false}),
+      parameter<double>("TAU2", {.required = false}),
+      parameter<double>("KAPPA", {.required = false}),
+      parameter<double>("BETA", {.required = false}),
+      parameter<double>("Area", {.required = false}),
   });
 }
 
diff --git a/src/red_airways/4C_red_airways_airway.cpp b/src/red_airways/4C_red_airways_airway.cpp
index ea9a13b2dc0..5de8466fd32 100644
--- a/src/red_airways/4C_red_airways_airway.cpp
+++ b/src/red_airways/4C_red_airways_airway.cpp
@@ -66,26 +66,26 @@ void Discret::Elements::RedAirwayType::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["LINE2"] = all_of({
-      entry<std::vector<int>>("LINE2", {.size = 2}),
-      entry<int>("MAT"),
-      entry<std::string>("ElemSolvingType"),
-      entry<std::string>("TYPE"),
-      entry<std::string>("Resistance"),
-      entry<double>("PowerOfVelocityProfile"),
-      entry<double>("WallElasticity"),
-      entry<double>("PoissonsRatio"),
-      entry<double>("ViscousTs"),
-      entry<double>("ViscousPhaseShift"),
-      entry<double>("WallThickness"),
-      entry<double>("Area"),
-      entry<int>("Generation"),
-      entry<double>("AirwayColl", {.required = false}),
-      entry<double>("S_Close", {.required = false}),
-      entry<double>("S_Open", {.required = false}),
-      entry<double>("Pcrit_Open", {.required = false}),
-      entry<double>("Pcrit_Close", {.required = false}),
-      entry<double>("Open_Init", {.required = false}),
-      entry<double>("BranchLength", {.required = false}),
+      parameter<std::vector<int>>("LINE2", {.size = 2}),
+      parameter<int>("MAT"),
+      parameter<std::string>("ElemSolvingType"),
+      parameter<std::string>("TYPE"),
+      parameter<std::string>("Resistance"),
+      parameter<double>("PowerOfVelocityProfile"),
+      parameter<double>("WallElasticity"),
+      parameter<double>("PoissonsRatio"),
+      parameter<double>("ViscousTs"),
+      parameter<double>("ViscousPhaseShift"),
+      parameter<double>("WallThickness"),
+      parameter<double>("Area"),
+      parameter<int>("Generation"),
+      parameter<double>("AirwayColl", {.required = false}),
+      parameter<double>("S_Close", {.required = false}),
+      parameter<double>("S_Open", {.required = false}),
+      parameter<double>("Pcrit_Open", {.required = false}),
+      parameter<double>("Pcrit_Close", {.required = false}),
+      parameter<double>("Open_Init", {.required = false}),
+      parameter<double>("BranchLength", {.required = false}),
   });
 }
 
diff --git a/src/red_airways/4C_red_airways_interacinardep.cpp b/src/red_airways/4C_red_airways_interacinardep.cpp
index 1579a748762..55b75c84070 100644
--- a/src/red_airways/4C_red_airways_interacinardep.cpp
+++ b/src/red_airways/4C_red_airways_interacinardep.cpp
@@ -73,8 +73,8 @@ void Discret::Elements::RedInterAcinarDepType::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/rigidsphere/4C_rigidsphere.cpp b/src/rigidsphere/4C_rigidsphere.cpp
index 6a341364dc6..23ea35e2094 100644
--- a/src/rigidsphere/4C_rigidsphere.cpp
+++ b/src/rigidsphere/4C_rigidsphere.cpp
@@ -97,9 +97,9 @@ void Discret::Elements::RigidsphereType::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["POINT1"] = all_of({
-      entry<std::vector<int>>("POINT1", {.size = 1}),
-      entry<double>("RADIUS"),
-      entry<double>("DENSITY"),
+      parameter<std::vector<int>>("POINT1", {.size = 1}),
+      parameter<double>("RADIUS"),
+      parameter<double>("DENSITY"),
   });
 }
 
diff --git a/src/scatra_ele/4C_scatra_ele.cpp b/src/scatra_ele/4C_scatra_ele.cpp
index 68a98606fed..c66ecf40b89 100644
--- a/src/scatra_ele/4C_scatra_ele.cpp
+++ b/src/scatra_ele/4C_scatra_ele.cpp
@@ -95,150 +95,150 @@ void Discret::Elements::TransportType::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["HEX8"] = all_of({
-      entry<std::vector<int>>("HEX8", {.size = 8}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("HEX8", {.size = 8}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["HEX20"] = all_of({
-      entry<std::vector<int>>("HEX20", {.size = 20}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("HEX20", {.size = 20}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["HEX27"] = all_of({
-      entry<std::vector<int>>("HEX27", {.size = 27}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("HEX27", {.size = 27}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["NURBS27"] = all_of({
-      entry<std::vector<int>>("NURBS27", {.size = 27}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("NURBS27", {.size = 27}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["NURBS8"] = all_of({
-      entry<std::vector<int>>("NURBS8", {.size = 8}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("NURBS8", {.size = 8}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["TET4"] = all_of({
-      entry<std::vector<int>>("TET4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("TET4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["TET10"] = all_of({
-      entry<std::vector<int>>("TET10", {.size = 10}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("TET10", {.size = 10}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["WEDGE6"] = all_of({
-      entry<std::vector<int>>("WEDGE6", {.size = 6}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("WEDGE6", {.size = 6}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["WEDGE15"] = all_of({
-      entry<std::vector<int>>("WEDGE15", {.size = 15}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("WEDGE15", {.size = 15}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["PYRAMID5"] = all_of({
-      entry<std::vector<int>>("PYRAMID5", {.size = 5}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("PYRAMID5", {.size = 5}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["QUAD4"] = all_of({
-      entry<std::vector<int>>("QUAD4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("QUAD4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["QUAD8"] = all_of({
-      entry<std::vector<int>>("QUAD8", {.size = 8}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("QUAD8", {.size = 8}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["QUAD9"] = all_of({
-      entry<std::vector<int>>("QUAD9", {.size = 9}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("QUAD9", {.size = 9}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["TRI3"] = all_of({
-      entry<std::vector<int>>("TRI3", {.size = 3}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("TRI3", {.size = 3}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["TRI6"] = all_of({
-      entry<std::vector<int>>("TRI6", {.size = 6}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("TRI6", {.size = 6}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["NURBS4"] = all_of({
-      entry<std::vector<int>>("NURBS4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("NURBS4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["NURBS9"] = all_of({
-      entry<std::vector<int>>("NURBS9", {.size = 9}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("NURBS9", {.size = 9}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["LINE2"] = all_of({
-      entry<std::vector<int>>("LINE2", {.size = 2}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("LINE2", {.size = 2}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["LINE3"] = all_of({
-      entry<std::vector<int>>("LINE3", {.size = 3}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("LINE3", {.size = 3}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["NURBS2"] = all_of({
-      entry<std::vector<int>>("NURBS2", {.size = 2}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("NURBS2", {.size = 2}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 
   defs["NURBS3"] = all_of({
-      entry<std::vector<int>>("NURBS3", {.size = 3}),
-      entry<int>("MAT"),
-      entry<std::string>("TYPE"),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("NURBS3", {.size = 3}),
+      parameter<int>("MAT"),
+      parameter<std::string>("TYPE"),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
   });
 }
 
diff --git a/src/scatra_ele/4C_scatra_ele_hdg.cpp b/src/scatra_ele/4C_scatra_ele_hdg.cpp
index a49acc27f80..56d4b289cb1 100644
--- a/src/scatra_ele/4C_scatra_ele_hdg.cpp
+++ b/src/scatra_ele/4C_scatra_ele_hdg.cpp
@@ -137,8 +137,8 @@ void Discret::Elements::ScaTraHDGType ::setup_element_definition(
   {
     defs[key] = all_of({
         scatra_line_def,
-        entry<int>("DEG"),
-        entry<int>("SPC", {.required = false}),
+        parameter<int>("DEG"),
+        parameter<int>("SPC", {.required = false}),
     });
   }
 }
diff --git a/src/shell7p/4C_shell7p_ele.cpp b/src/shell7p/4C_shell7p_ele.cpp
index 30686371806..8437c2c858f 100644
--- a/src/shell7p/4C_shell7p_ele.cpp
+++ b/src/shell7p/4C_shell7p_ele.cpp
@@ -84,74 +84,74 @@ void Discret::Elements::Shell7pType::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defsgeneral["QUAD4"] = all_of({
-      entry<std::vector<int>>("QUAD4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<double>("THICK"),
-      entry<std::vector<std::string>>("EAS", {.size = 5}),
-      entry<double>("SDC"),
-      entry<bool>("USE_ANS", {.default_value = false}),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("QUAD4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<double>("THICK"),
+      parameter<std::vector<std::string>>("EAS", {.size = 5}),
+      parameter<double>("SDC"),
+      parameter<bool>("USE_ANS", {.default_value = false}),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
   });
 
   defsgeneral["QUAD8"] = all_of({
-      entry<std::vector<int>>("QUAD8", {.size = 8}),
-      entry<int>("MAT"),
-      entry<double>("THICK"),
-      entry<std::vector<std::string>>("EAS", {.size = 5}),
-      entry<double>("SDC"),
-      entry<bool>("USE_ANS", {.default_value = false}),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("QUAD8", {.size = 8}),
+      parameter<int>("MAT"),
+      parameter<double>("THICK"),
+      parameter<std::vector<std::string>>("EAS", {.size = 5}),
+      parameter<double>("SDC"),
+      parameter<bool>("USE_ANS", {.default_value = false}),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
   });
 
   defsgeneral["QUAD9"] = all_of({
-      entry<std::vector<int>>("QUAD9", {.size = 9}),
-      entry<int>("MAT"),
-      entry<double>("THICK"),
-      entry<std::vector<std::string>>("EAS", {.size = 5}),
-      entry<double>("SDC"),
-      entry<bool>("USE_ANS", {.default_value = false}),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("QUAD9", {.size = 9}),
+      parameter<int>("MAT"),
+      parameter<double>("THICK"),
+      parameter<std::vector<std::string>>("EAS", {.size = 5}),
+      parameter<double>("SDC"),
+      parameter<bool>("USE_ANS", {.default_value = false}),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
   });
 
   defsgeneral["TRI3"] = all_of({
-      entry<std::vector<int>>("TRI3", {.size = 3}),
-      entry<int>("MAT"),
-      entry<double>("THICK"),
-      entry<double>("SDC"),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("TRI3", {.size = 3}),
+      parameter<int>("MAT"),
+      parameter<double>("THICK"),
+      parameter<double>("SDC"),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
   });
 
   defsgeneral["TRI6"] = all_of({
-      entry<std::vector<int>>("TRI6", {.size = 6}),
-      entry<int>("MAT"),
-      entry<double>("THICK"),
-      entry<double>("SDC"),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<std::vector<int>>("TRI6", {.size = 6}),
+      parameter<int>("MAT"),
+      parameter<double>("THICK"),
+      parameter<double>("SDC"),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
   });
 }
 
diff --git a/src/shell7p/4C_shell7p_ele_scatra.cpp b/src/shell7p/4C_shell7p_ele_scatra.cpp
index 762d44400d4..a64b5516008 100644
--- a/src/shell7p/4C_shell7p_ele_scatra.cpp
+++ b/src/shell7p/4C_shell7p_ele_scatra.cpp
@@ -79,79 +79,79 @@ void Discret::Elements::Shell7pScatraType::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defsgeneral["QUAD4"] = all_of({
-      entry<std::vector<int>>("QUAD4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<double>("THICK"),
-      entry<std::vector<std::string>>("EAS", {.size = 5}),
-      entry<double>("SDC"),
-      entry<bool>("USE_ANS", {.default_value = false}),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
-      entry<std::string>("TYPE", {.required = false}),
+      parameter<std::vector<int>>("QUAD4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<double>("THICK"),
+      parameter<std::vector<std::string>>("EAS", {.size = 5}),
+      parameter<double>("SDC"),
+      parameter<bool>("USE_ANS", {.default_value = false}),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<std::string>("TYPE", {.required = false}),
   });
 
   defsgeneral["QUAD8"] = all_of({
-      entry<std::vector<int>>("QUAD8", {.size = 8}),
-      entry<int>("MAT"),
-      entry<double>("THICK"),
-      entry<std::vector<std::string>>("EAS", {.size = 5}),
-      entry<double>("SDC"),
-      entry<bool>("USE_ANS", {.default_value = false}),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
-      entry<std::string>("TYPE", {.required = false}),
+      parameter<std::vector<int>>("QUAD8", {.size = 8}),
+      parameter<int>("MAT"),
+      parameter<double>("THICK"),
+      parameter<std::vector<std::string>>("EAS", {.size = 5}),
+      parameter<double>("SDC"),
+      parameter<bool>("USE_ANS", {.default_value = false}),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<std::string>("TYPE", {.required = false}),
   });
 
   defsgeneral["QUAD9"] = all_of({
-      entry<std::vector<int>>("QUAD9", {.size = 9}),
-      entry<int>("MAT"),
-      entry<double>("THICK"),
-      entry<std::vector<std::string>>("EAS", {.size = 5}),
-      entry<double>("SDC"),
-      entry<bool>("USE_ANS", {.default_value = false}),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
-      entry<std::string>("TYPE", {.required = false}),
+      parameter<std::vector<int>>("QUAD9", {.size = 9}),
+      parameter<int>("MAT"),
+      parameter<double>("THICK"),
+      parameter<std::vector<std::string>>("EAS", {.size = 5}),
+      parameter<double>("SDC"),
+      parameter<bool>("USE_ANS", {.default_value = false}),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<std::string>("TYPE", {.required = false}),
   });
 
   defsgeneral["TRI3"] = all_of({
-      entry<std::vector<int>>("TRI3", {.size = 3}),
-      entry<int>("MAT"),
-      entry<double>("THICK"),
-      entry<double>("SDC"),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
-      entry<std::string>("TYPE", {.required = false}),
+      parameter<std::vector<int>>("TRI3", {.size = 3}),
+      parameter<int>("MAT"),
+      parameter<double>("THICK"),
+      parameter<double>("SDC"),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<std::string>("TYPE", {.required = false}),
   });
 
   defsgeneral["TRI6"] = all_of({
-      entry<std::vector<int>>("TRI6", {.size = 6}),
-      entry<int>("MAT"),
-      entry<double>("THICK"),
-      entry<double>("SDC"),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
-      entry<std::string>("TYPE", {.required = false}),
+      parameter<std::vector<int>>("TRI6", {.size = 6}),
+      parameter<int>("MAT"),
+      parameter<double>("THICK"),
+      parameter<double>("SDC"),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<std::string>("TYPE", {.required = false}),
   });
 }
 
diff --git a/src/shell_kl_nurbs/src/4C_shell_kl_nurbs.cpp b/src/shell_kl_nurbs/src/4C_shell_kl_nurbs.cpp
index 4b5cdacf86e..bedfff45159 100644
--- a/src/shell_kl_nurbs/src/4C_shell_kl_nurbs.cpp
+++ b/src/shell_kl_nurbs/src/4C_shell_kl_nurbs.cpp
@@ -97,9 +97,9 @@ void Discret::Elements::KirchhoffLoveShellNurbsType::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["NURBS9"] = all_of({
-      entry<std::vector<int>>("NURBS9", {.size = 9}),
-      entry<int>("MAT"),
-      entry<std::vector<int>>("GP", {.size = 2}),
+      parameter<std::vector<int>>("NURBS9", {.size = 9}),
+      parameter<int>("MAT"),
+      parameter<std::vector<int>>("GP", {.size = 2}),
   });
 }
 
diff --git a/src/so3/4C_so3_hex27.cpp b/src/so3/4C_so3_hex27.cpp
index dce84042b4f..4a3b7551cb9 100644
--- a/src/so3/4C_so3_hex27.cpp
+++ b/src/so3/4C_so3_hex27.cpp
@@ -82,17 +82,17 @@ void Discret::Elements::SoHex27Type::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["HEX27"] = all_of({
-      entry<std::vector<int>>("HEX27", {.size = 27}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
-      entry<double>("STRENGTH", {.required = false}),
-      entry<double>("GROWTHTRIG", {.required = false}),
+      parameter<std::vector<int>>("HEX27", {.size = 27}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<double>("STRENGTH", {.required = false}),
+      parameter<double>("GROWTHTRIG", {.required = false}),
   });
 }
 
diff --git a/src/so3/4C_so3_hex8.cpp b/src/so3/4C_so3_hex8.cpp
index aa765e89200..1cc046ed9ad 100644
--- a/src/so3/4C_so3_hex8.cpp
+++ b/src/so3/4C_so3_hex8.cpp
@@ -92,18 +92,18 @@ void Discret::Elements::SoHex8Type::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["HEX8"] = all_of({
-      entry<std::vector<int>>("HEX8", {.size = 8}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<std::string>("EAS"),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
-      entry<double>("STRENGTH", {.required = false}),
-      entry<double>("GROWTHTRIG", {.required = false}),
+      parameter<std::vector<int>>("HEX8", {.size = 8}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<std::string>("EAS"),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<double>("STRENGTH", {.required = false}),
+      parameter<double>("GROWTHTRIG", {.required = false}),
   });
 }
 
diff --git a/src/so3/4C_so3_nurbs27.cpp b/src/so3/4C_so3_nurbs27.cpp
index b427516e034..bd09c325533 100644
--- a/src/so3/4C_so3_nurbs27.cpp
+++ b/src/so3/4C_so3_nurbs27.cpp
@@ -80,9 +80,9 @@ void Discret::Elements::Nurbs::SoNurbs27Type::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["NURBS27"] = all_of({
-      entry<std::vector<int>>("NURBS27", {.size = 27}),
-      entry<int>("MAT"),
-      entry<std::vector<int>>("GP", {.size = 3}),
+      parameter<std::vector<int>>("NURBS27", {.size = 27}),
+      parameter<int>("MAT"),
+      parameter<std::vector<int>>("GP", {.size = 3}),
   });
 }
 
diff --git a/src/so3/4C_so3_poro_eletypes.cpp b/src/so3/4C_so3_poro_eletypes.cpp
index b34492d2939..c5bd9f8a624 100644
--- a/src/so3/4C_so3_poro_eletypes.cpp
+++ b/src/so3/4C_so3_poro_eletypes.cpp
@@ -69,12 +69,12 @@ void Discret::Elements::SoHex8PoroType::setup_element_definition(
 
   defs["HEX8"] = all_of({
       defs_hex8["HEX8"],
-      entry<std::vector<double>>("POROANISODIR1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("POROANISODIR2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("POROANISODIR3", {.required = false, .size = 3}),
-      entry<std::vector<double>>("POROANISONODALCOEFFS1", {.required = false, .size = 8}),
-      entry<std::vector<double>>("POROANISONODALCOEFFS2", {.required = false, .size = 8}),
-      entry<std::vector<double>>("POROANISONODALCOEFFS3", {.required = false, .size = 8}),
+      parameter<std::vector<double>>("POROANISODIR1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("POROANISODIR2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("POROANISODIR3", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("POROANISONODALCOEFFS1", {.required = false, .size = 8}),
+      parameter<std::vector<double>>("POROANISONODALCOEFFS2", {.required = false, .size = 8}),
+      parameter<std::vector<double>>("POROANISONODALCOEFFS3", {.required = false, .size = 8}),
   });
 }
 
@@ -149,12 +149,12 @@ void Discret::Elements::SoTet4PoroType::setup_element_definition(
 
   defs["TET4"] = all_of({
       defs_tet4["TET4"],
-      entry<std::vector<double>>("POROANISODIR1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("POROANISODIR2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("POROANISODIR3", {.required = false, .size = 3}),
-      entry<std::vector<double>>("POROANISONODALCOEFFS1", {.required = false, .size = 4}),
-      entry<std::vector<double>>("POROANISONODALCOEFFS2", {.required = false, .size = 4}),
-      entry<std::vector<double>>("POROANISONODALCOEFFS3", {.required = false, .size = 4}),
+      parameter<std::vector<double>>("POROANISODIR1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("POROANISODIR2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("POROANISODIR3", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("POROANISONODALCOEFFS1", {.required = false, .size = 4}),
+      parameter<std::vector<double>>("POROANISONODALCOEFFS2", {.required = false, .size = 4}),
+      parameter<std::vector<double>>("POROANISONODALCOEFFS3", {.required = false, .size = 4}),
   });
 }
 
@@ -228,9 +228,9 @@ void Discret::Elements::SoHex27PoroType::setup_element_definition(
 
   defs["HEX27"] = all_of({
       defs_hex27["HEX27"],
-      entry<std::vector<double>>("POROANISODIR1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("POROANISODIR2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("POROANISODIR3", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("POROANISODIR1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("POROANISODIR2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("POROANISODIR3", {.required = false, .size = 3}),
   });
 }
 
@@ -304,9 +304,9 @@ void Discret::Elements::SoTet10PoroType::setup_element_definition(
 
   defs["TET10"] = all_of({
       defs_tet10["TET10"],
-      entry<std::vector<double>>("POROANISODIR1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("POROANISODIR2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("POROANISODIR3", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("POROANISODIR1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("POROANISODIR2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("POROANISODIR3", {.required = false, .size = 3}),
   });
 }
 
@@ -378,9 +378,9 @@ void Discret::Elements::SoNurbs27PoroType::setup_element_definition(
 
   defs["NURBS27"] = all_of({
       defs_nurbs27["NURBS27"],
-      entry<std::vector<double>>("POROANISODIR1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("POROANISODIR2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("POROANISODIR3", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("POROANISODIR1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("POROANISODIR2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("POROANISODIR3", {.required = false, .size = 3}),
   });
 }
 
diff --git a/src/so3/4C_so3_poro_p1_scatra_eletypes.cpp b/src/so3/4C_so3_poro_p1_scatra_eletypes.cpp
index cc0125d8d04..462aca3c96c 100644
--- a/src/so3/4C_so3_poro_p1_scatra_eletypes.cpp
+++ b/src/so3/4C_so3_poro_p1_scatra_eletypes.cpp
@@ -70,7 +70,7 @@ void Discret::Elements::SoHex8PoroP1ScatraType::setup_element_definition(
 
   defs["HEX8"] = all_of({
       defs_hex8["HEX8"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
@@ -130,7 +130,7 @@ void Discret::Elements::SoTet4PoroP1ScatraType::setup_element_definition(
 
   defs["TET4"] = all_of({
       defs_tet4["TET4"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
diff --git a/src/so3/4C_so3_poro_scatra_eletypes.cpp b/src/so3/4C_so3_poro_scatra_eletypes.cpp
index 61d529cc7ed..6c189eb2869 100644
--- a/src/so3/4C_so3_poro_scatra_eletypes.cpp
+++ b/src/so3/4C_so3_poro_scatra_eletypes.cpp
@@ -71,7 +71,7 @@ void Discret::Elements::SoHex8PoroScatraType::setup_element_definition(
 
   defs["HEX8"] = all_of({
       defs_hex8["HEX8"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
@@ -133,7 +133,7 @@ void Discret::Elements::SoTet4PoroScatraType::setup_element_definition(
 
   defs["TET4"] = all_of({
       defs_tet4["TET4"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
@@ -195,7 +195,7 @@ void Discret::Elements::SoHex27PoroScatraType::setup_element_definition(
 
   defs["HEX27"] = all_of({
       defs_hex27["HEX27"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
@@ -258,7 +258,7 @@ void Discret::Elements::SoTet10PoroScatraType::setup_element_definition(
 
   defs["TET10"] = all_of({
       defs_tet10["TET10"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
@@ -319,7 +319,7 @@ void Discret::Elements::SoNurbs27PoroScatraType::setup_element_definition(
 
   defs["NURBS27"] = all_of({
       defs_nurbs27["NURBS27"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
diff --git a/src/so3/4C_so3_sh8.cpp b/src/so3/4C_so3_sh8.cpp
index b9ab83c1dfe..fdb031949b3 100644
--- a/src/so3/4C_so3_sh8.cpp
+++ b/src/so3/4C_so3_sh8.cpp
@@ -75,20 +75,20 @@ void Discret::Elements::SoSh8Type::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["HEX8"] = all_of({
-      entry<std::vector<int>>("HEX8", {.size = 8}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<std::string>("EAS"),
-      entry<std::string>("ANS"),
-      entry<std::string>("THICKDIR"),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
-      entry<double>("STRENGTH", {.required = false}),
-      entry<double>("GROWTHTRIG", {.required = false}),
+      parameter<std::vector<int>>("HEX8", {.size = 8}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<std::string>("EAS"),
+      parameter<std::string>("ANS"),
+      parameter<std::string>("THICKDIR"),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<double>("STRENGTH", {.required = false}),
+      parameter<double>("GROWTHTRIG", {.required = false}),
   });
 }
 
diff --git a/src/so3/4C_so3_tet10.cpp b/src/so3/4C_so3_tet10.cpp
index 7f73bf11d09..d0188640494 100644
--- a/src/so3/4C_so3_tet10.cpp
+++ b/src/so3/4C_so3_tet10.cpp
@@ -87,17 +87,17 @@ void Discret::Elements::SoTet10Type::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["TET10"] = all_of({
-      entry<std::vector<int>>("TET10", {.size = 10}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
-      entry<double>("STRENGTH", {.required = false}),
-      entry<double>("GROWTHTRIG", {.required = false}),
+      parameter<std::vector<int>>("TET10", {.size = 10}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<double>("STRENGTH", {.required = false}),
+      parameter<double>("GROWTHTRIG", {.required = false}),
   });
 }
 
diff --git a/src/so3/4C_so3_tet4.cpp b/src/so3/4C_so3_tet4.cpp
index 52e512c2a86..ff06d5cda30 100644
--- a/src/so3/4C_so3_tet4.cpp
+++ b/src/so3/4C_so3_tet4.cpp
@@ -93,16 +93,16 @@ void Discret::Elements::SoTet4Type::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["TET4"] = all_of({
-      entry<std::vector<int>>("TET4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-      entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-      entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-      entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
-      entry<double>("GROWTHTRIG", {.required = false}),
+      parameter<std::vector<int>>("TET4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+      parameter<double>("GROWTHTRIG", {.required = false}),
   });
 }
 
diff --git a/src/solid_3D_ele/4C_solid_3D_ele.cpp b/src/solid_3D_ele/4C_solid_3D_ele.cpp
index 8189c03bd6e..c8fdb6ca2ac 100644
--- a/src/solid_3D_ele/4C_solid_3D_ele.cpp
+++ b/src/solid_3D_ele/4C_solid_3D_ele.cpp
@@ -47,9 +47,9 @@ namespace
   auto get_default_input_spec()
   {
     return all_of({
-        entry<std::vector<int>>(
+        parameter<std::vector<int>>(
             Core::FE::cell_type_to_string(celltype), {.size = Core::FE::num_nodes<celltype>}),
-        entry<int>("MAT"),
+        parameter<int>("MAT"),
         get_kinem_type_input_spec(),
         selection<Discret::Elements::PrestressTechnology>("PRESTRESS_TECH",
             {
@@ -62,12 +62,12 @@ namespace
             },
             {.description = "The technology used for prestressing",
                 .default_value = Discret::Elements::PrestressTechnology::none}),
-        entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-        entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-        entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-        entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-        entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-        entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+        parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+        parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+        parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+        parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+        parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+        parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
     });
   }
 }  // namespace
@@ -139,8 +139,8 @@ void Discret::Elements::SolidType::setup_element_definition(
   });
 
   defsgeneral["NURBS27"] = all_of({
-      entry<std::vector<int>>("NURBS27", {.size = 27}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("NURBS27", {.size = 27}),
+      parameter<int>("MAT"),
       get_kinem_type_input_spec(),
   });
 }
diff --git a/src/solid_poro_3D_ele/4C_solid_poro_3D_ele_pressure_based.cpp b/src/solid_poro_3D_ele/4C_solid_poro_3D_ele_pressure_based.cpp
index e89e1c71b43..047afb207dd 100644
--- a/src/solid_poro_3D_ele/4C_solid_poro_3D_ele_pressure_based.cpp
+++ b/src/solid_poro_3D_ele/4C_solid_poro_3D_ele_pressure_based.cpp
@@ -38,9 +38,9 @@ namespace Discret::Elements::SolidPoroPressureBasedInternal
     auto get_default_input_spec()
     {
       return all_of({
-          entry<std::vector<int>>(
+          parameter<std::vector<int>>(
               Core::FE::cell_type_to_string(celltype), {.size = Core::FE::num_nodes<celltype>}),
-          entry<int>("MAT"),
+          parameter<int>("MAT"),
           selection<Inpar::Solid::KinemType>("KINEM",
               {
                   {kinem_type_string(Inpar::Solid::KinemType::linear),
diff --git a/src/solid_poro_3D_ele/4C_solid_poro_3D_ele_pressure_velocity_based.cpp b/src/solid_poro_3D_ele/4C_solid_poro_3D_ele_pressure_velocity_based.cpp
index 8a087b3a692..784ba2d8df1 100644
--- a/src/solid_poro_3D_ele/4C_solid_poro_3D_ele_pressure_velocity_based.cpp
+++ b/src/solid_poro_3D_ele/4C_solid_poro_3D_ele_pressure_velocity_based.cpp
@@ -39,9 +39,9 @@ namespace Discret::Elements::SolidPoroPressureVelocityBasedInternal
     auto get_default_input_spec()
     {
       return all_of({
-          entry<std::vector<int>>(
+          parameter<std::vector<int>>(
               Core::FE::cell_type_to_string(celltype), {.size = Core::FE::num_nodes<celltype>}),
-          entry<int>("MAT"),
+          parameter<int>("MAT"),
           selection<Inpar::Solid::KinemType>("KINEM",
               {
                   {kinem_type_string(Inpar::Solid::KinemType::linear),
@@ -51,9 +51,9 @@ namespace Discret::Elements::SolidPoroPressureVelocityBasedInternal
               },
               {.description = "Whether to use linear kinematics (small displacements) or nonlinear "
                               "kinematics (large displacements)"}),
-          entry<std::vector<double>>("POROANISODIR1", {.required = false, .size = 3}),
-          entry<std::vector<double>>("POROANISODIR2", {.required = false, .size = 3}),
-          entry<std::vector<double>>("POROANISODIR3", {.required = false, .size = 3}),
+          parameter<std::vector<double>>("POROANISODIR1", {.required = false, .size = 3}),
+          parameter<std::vector<double>>("POROANISODIR2", {.required = false, .size = 3}),
+          parameter<std::vector<double>>("POROANISODIR3", {.required = false, .size = 3}),
           selection<Inpar::ScaTra::ImplType>("TYPE", Discret::Elements::get_impltype_inpar_pairs(),
               {.description = "Scalar transport implementation type",
                   .default_value = Inpar::ScaTra::ImplType::impltype_undefined}),
@@ -79,9 +79,9 @@ void Discret::Elements::SolidPoroPressureVelocityBasedType::setup_element_defini
   defsgeneral[Core::FE::cell_type_to_string(Core::FE::CellType::hex8)] = all_of({
       Discret::Elements::SolidPoroPressureVelocityBasedInternal::get_default_input_spec<
           Core::FE::CellType::hex8>(),
-      entry<std::vector<double>>("POROANISONODALCOEFFS1", {.required = false, .size = 8}),
-      entry<std::vector<double>>("POROANISONODALCOEFFS2", {.required = false, .size = 8}),
-      entry<std::vector<double>>("POROANISONODALCOEFFS3", {.required = false, .size = 8}),
+      parameter<std::vector<double>>("POROANISONODALCOEFFS1", {.required = false, .size = 8}),
+      parameter<std::vector<double>>("POROANISONODALCOEFFS2", {.required = false, .size = 8}),
+      parameter<std::vector<double>>("POROANISONODALCOEFFS3", {.required = false, .size = 8}),
   });
 
   defsgeneral[Core::FE::cell_type_to_string(Core::FE::CellType::hex27)] =
@@ -92,9 +92,9 @@ void Discret::Elements::SolidPoroPressureVelocityBasedType::setup_element_defini
   defsgeneral[Core::FE::cell_type_to_string(Core::FE::CellType::tet4)] = all_of({
       Discret::Elements::SolidPoroPressureVelocityBasedInternal::get_default_input_spec<
           Core::FE::CellType::tet4>(),
-      entry<std::vector<double>>("POROANISONODALCOEFFS1", {.required = false, .size = 8}),
-      entry<std::vector<double>>("POROANISONODALCOEFFS2", {.required = false, .size = 8}),
-      entry<std::vector<double>>("POROANISONODALCOEFFS3", {.required = false, .size = 8}),
+      parameter<std::vector<double>>("POROANISONODALCOEFFS1", {.required = false, .size = 8}),
+      parameter<std::vector<double>>("POROANISONODALCOEFFS2", {.required = false, .size = 8}),
+      parameter<std::vector<double>>("POROANISONODALCOEFFS3", {.required = false, .size = 8}),
   });
 
 
diff --git a/src/solid_scatra_3D_ele/4C_solid_scatra_3D_ele.cpp b/src/solid_scatra_3D_ele/4C_solid_scatra_3D_ele.cpp
index 5d6310573b1..27c8fb12725 100644
--- a/src/solid_scatra_3D_ele/4C_solid_scatra_3D_ele.cpp
+++ b/src/solid_scatra_3D_ele/4C_solid_scatra_3D_ele.cpp
@@ -30,9 +30,9 @@ namespace
   auto get_default_input_spec()
   {
     return all_of({
-        entry<std::vector<int>>(
+        parameter<std::vector<int>>(
             Core::FE::cell_type_to_string(celltype), {.size = Core::FE::num_nodes<celltype>}),
-        entry<int>("MAT"),
+        parameter<int>("MAT"),
         selection<Inpar::Solid::KinemType>("KINEM",
             {
                 {kinem_type_string(Inpar::Solid::KinemType::linear),
@@ -42,7 +42,7 @@ namespace
             },
             {.description = "Whether to use linear kinematics (small displacements) or nonlinear "
                             "kinematics (large displacements)"}),
-        entry<std::string>("TYPE"),
+        parameter<std::string>("TYPE"),
         selection<Discret::Elements::PrestressTechnology>("PRESTRESS_TECH",
             {
                 {Discret::Elements::prestress_technology_string(
@@ -54,12 +54,12 @@ namespace
             },
             {.description = "The technology used for prestressing",
                 .default_value = Discret::Elements::PrestressTechnology::none}),
-        entry<std::vector<double>>("RAD", {.required = false, .size = 3}),
-        entry<std::vector<double>>("AXI", {.required = false, .size = 3}),
-        entry<std::vector<double>>("CIR", {.required = false, .size = 3}),
-        entry<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
-        entry<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
-        entry<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
+        parameter<std::vector<double>>("RAD", {.required = false, .size = 3}),
+        parameter<std::vector<double>>("AXI", {.required = false, .size = 3}),
+        parameter<std::vector<double>>("CIR", {.required = false, .size = 3}),
+        parameter<std::vector<double>>("FIBER1", {.required = false, .size = 3}),
+        parameter<std::vector<double>>("FIBER2", {.required = false, .size = 3}),
+        parameter<std::vector<double>>("FIBER3", {.required = false, .size = 3}),
 
     });
   }
diff --git a/src/structure_new/src/utils/4C_structure_new_functions.cpp b/src/structure_new/src/utils/4C_structure_new_functions.cpp
index 379a4120ebf..c2265e1efb4 100644
--- a/src/structure_new/src/utils/4C_structure_new_functions.cpp
+++ b/src/structure_new/src/utils/4C_structure_new_functions.cpp
@@ -87,11 +87,11 @@ void Solid::add_valid_structure_functions(Core::Utils::FunctionManager& function
   auto spec = one_of({
       group("WEAKLYCOMPRESSIBLE_ETIENNE_FSI_STRUCTURE",
           {
-              entry<int>("MAT_STRUCT"),
+              parameter<int>("MAT_STRUCT"),
           }),
       group("WEAKLYCOMPRESSIBLE_ETIENNE_FSI_STRUCTURE_FORCE",
           {
-              entry<int>("MAT_STRUCT"),
+              parameter<int>("MAT_STRUCT"),
           }),
   });
 
diff --git a/src/thermo/src/element/4C_thermo_element.cpp b/src/thermo/src/element/4C_thermo_element.cpp
index c205fc12b82..8d932ec6d56 100644
--- a/src/thermo/src/element/4C_thermo_element.cpp
+++ b/src/thermo/src/element/4C_thermo_element.cpp
@@ -109,93 +109,93 @@ void Thermo::ElementType::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"),
   });
 
   defs["NURBS27"] = all_of({
-      entry<std::vector<int>>("NURBS27", {.size = 27}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("NURBS27", {.size = 27}),
+      parameter<int>("MAT"),
   });
 
   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"),
   });
 
   defs["NURBS4"] = all_of({
-      entry<std::vector<int>>("NURBS4", {.size = 4}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("NURBS4", {.size = 4}),
+      parameter<int>("MAT"),
   });
 
   defs["NURBS9"] = all_of({
-      entry<std::vector<int>>("NURBS9", {.size = 9}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("NURBS9", {.size = 9}),
+      parameter<int>("MAT"),
   });
 
   defs["LINE2"] = all_of({
-      entry<std::vector<int>>("LINE2", {.size = 2}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("LINE2", {.size = 2}),
+      parameter<int>("MAT"),
   });
 
   defs["LINE3"] = all_of({
-      entry<std::vector<int>>("LINE3", {.size = 3}),
-      entry<int>("MAT"),
+      parameter<std::vector<int>>("LINE3", {.size = 3}),
+      parameter<int>("MAT"),
   });
 }  // setup_element_definition()
 
diff --git a/src/thermo/src/utils/4C_thermo_input.cpp b/src/thermo/src/utils/4C_thermo_input.cpp
index cb74dba97d3..27f02249c65 100644
--- a/src/thermo/src/utils/4C_thermo_input.cpp
+++ b/src/thermo/src/utils/4C_thermo_input.cpp
@@ -216,13 +216,13 @@ void Thermo::set_valid_conditions(std::vector<Core::Conditions::ConditionDefinit
     // --> Tempnp (current temperature solution T_n+1) with linearisation
     cond.add_component(selection<std::string>(
         "temperature_state", {"Tempnp", "Tempn"}, {.description = "temperature state"}));
-    cond.add_component(entry<double>("coeff", {.description = "heat transfer coefficient h"}));
+    cond.add_component(parameter<double>("coeff", {.description = "heat transfer coefficient h"}));
     cond.add_component(
-        entry<double>("surtemp", {.description = "surrounding (fluid) temperature T_oo"}));
-    cond.add_component(entry<Noneable<int>>("surtempfunct",
+        parameter<double>("surtemp", {.description = "surrounding (fluid) temperature T_oo"}));
+    cond.add_component(parameter<Noneable<int>>("surtempfunct",
         {.description =
                 "time curve to increase the surrounding (fluid) temperature T_oo in time"}));
-    cond.add_component(entry<Noneable<int>>("funct",
+    cond.add_component(parameter<Noneable<int>>("funct",
         {.description =
                 "time curve to increase the complete boundary condition, i.e., the heat flux"}));
     condlist.push_back(cond);
@@ -243,11 +243,11 @@ void Thermo::set_valid_conditions(std::vector<Core::Conditions::ConditionDefinit
 
   const auto make_thermorobin = [&condlist](Core::Conditions::ConditionDefinition& cond)
   {
-    cond.add_component(entry<int>("NUMSCAL"));
-    cond.add_component(entry<std::vector<int>>(
+    cond.add_component(parameter<int>("NUMSCAL"));
+    cond.add_component(parameter<std::vector<int>>(
         "ONOFF", {.description = "", .size = from_parameter<int>("NUMSCAL")}));
-    cond.add_component(entry<double>("PREFACTOR"));
-    cond.add_component(entry<double>("REFVALUE"));
+    cond.add_component(parameter<double>("PREFACTOR"));
+    cond.add_component(parameter<double>("REFVALUE"));
 
     condlist.push_back(cond);
   };
diff --git a/src/torsion3/4C_torsion3.cpp b/src/torsion3/4C_torsion3.cpp
index 41b77c51889..fd990414055 100644
--- a/src/torsion3/4C_torsion3.cpp
+++ b/src/torsion3/4C_torsion3.cpp
@@ -74,9 +74,9 @@ void Discret::Elements::Torsion3Type::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["LINE3"] = all_of({
-      entry<std::vector<int>>("LINE3", {.size = 3}),
-      entry<int>("MAT"),
-      entry<std::string>("BENDINGPOTENTIAL"),
+      parameter<std::vector<int>>("LINE3", {.size = 3}),
+      parameter<int>("MAT"),
+      parameter<std::string>("BENDINGPOTENTIAL"),
   });
 }
 
diff --git a/src/truss3/4C_truss3.cpp b/src/truss3/4C_truss3.cpp
index 6dcfe16d1e0..58d8d810de1 100644
--- a/src/truss3/4C_truss3.cpp
+++ b/src/truss3/4C_truss3.cpp
@@ -75,10 +75,10 @@ void Discret::Elements::Truss3Type::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["LINE2"] = all_of({
-      entry<std::vector<int>>("LINE2", {.size = 2}),
-      entry<int>("MAT"),
-      entry<double>("CROSS"),
-      entry<std::string>("KINEM"),
+      parameter<std::vector<int>>("LINE2", {.size = 2}),
+      parameter<int>("MAT"),
+      parameter<double>("CROSS"),
+      parameter<std::string>("KINEM"),
   });
 }
 
diff --git a/src/truss3/4C_truss3_scatra.cpp b/src/truss3/4C_truss3_scatra.cpp
index 8bfb0248a4f..9e9a8fb7412 100644
--- a/src/truss3/4C_truss3_scatra.cpp
+++ b/src/truss3/4C_truss3_scatra.cpp
@@ -81,7 +81,7 @@ void Discret::Elements::Truss3ScatraType::setup_element_definition(
   // copy definitions of standard truss element to truss element for scalar transport coupling
   defs["LINE2"] = all_of({
       defs_truss["LINE2"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
diff --git a/src/w1/4C_w1.cpp b/src/w1/4C_w1.cpp
index bc9974720f4..9de8cf63b8a 100644
--- a/src/w1/4C_w1.cpp
+++ b/src/w1/4C_w1.cpp
@@ -72,73 +72,73 @@ void Discret::Elements::Wall1Type::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["QUAD4"] = all_of({
-      entry<std::vector<int>>("QUAD4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<std::string>("EAS"),
-      entry<double>("THICK"),
-      entry<std::string>("STRESS_STRAIN"),
-      entry<std::vector<int>>("GP", {.size = 2}),
+      parameter<std::vector<int>>("QUAD4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<std::string>("EAS"),
+      parameter<double>("THICK"),
+      parameter<std::string>("STRESS_STRAIN"),
+      parameter<std::vector<int>>("GP", {.size = 2}),
   });
 
   defs["QUAD8"] = all_of({
-      entry<std::vector<int>>("QUAD8", {.size = 8}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<std::string>("EAS"),
-      entry<double>("THICK"),
-      entry<std::string>("STRESS_STRAIN"),
-      entry<std::vector<int>>("GP", {.size = 2}),
+      parameter<std::vector<int>>("QUAD8", {.size = 8}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<std::string>("EAS"),
+      parameter<double>("THICK"),
+      parameter<std::string>("STRESS_STRAIN"),
+      parameter<std::vector<int>>("GP", {.size = 2}),
   });
 
   defs["QUAD9"] = all_of({
-      entry<std::vector<int>>("QUAD9", {.size = 9}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<std::string>("EAS"),
-      entry<double>("THICK"),
-      entry<std::string>("STRESS_STRAIN"),
-      entry<std::vector<int>>("GP", {.size = 2}),
+      parameter<std::vector<int>>("QUAD9", {.size = 9}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<std::string>("EAS"),
+      parameter<double>("THICK"),
+      parameter<std::string>("STRESS_STRAIN"),
+      parameter<std::vector<int>>("GP", {.size = 2}),
   });
 
   defs["TRI3"] = all_of({
-      entry<std::vector<int>>("TRI3", {.size = 3}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<std::string>("EAS"),
-      entry<double>("THICK"),
-      entry<std::string>("STRESS_STRAIN"),
-      entry<std::vector<int>>("GP", {.size = 2}),
+      parameter<std::vector<int>>("TRI3", {.size = 3}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<std::string>("EAS"),
+      parameter<double>("THICK"),
+      parameter<std::string>("STRESS_STRAIN"),
+      parameter<std::vector<int>>("GP", {.size = 2}),
   });
 
   defs["TRI6"] = all_of({
-      entry<std::vector<int>>("TRI6", {.size = 6}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<std::string>("EAS"),
-      entry<double>("THICK"),
-      entry<std::string>("STRESS_STRAIN"),
-      entry<std::vector<int>>("GP", {.size = 2}),
+      parameter<std::vector<int>>("TRI6", {.size = 6}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<std::string>("EAS"),
+      parameter<double>("THICK"),
+      parameter<std::string>("STRESS_STRAIN"),
+      parameter<std::vector<int>>("GP", {.size = 2}),
   });
 
   defs["NURBS4"] = all_of({
-      entry<std::vector<int>>("NURBS4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<std::string>("EAS"),
-      entry<double>("THICK"),
-      entry<std::string>("STRESS_STRAIN"),
-      entry<std::vector<int>>("GP", {.size = 2}),
+      parameter<std::vector<int>>("NURBS4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<std::string>("EAS"),
+      parameter<double>("THICK"),
+      parameter<std::string>("STRESS_STRAIN"),
+      parameter<std::vector<int>>("GP", {.size = 2}),
   });
 
   defs["NURBS9"] = all_of({
-      entry<std::vector<int>>("NURBS9", {.size = 9}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<std::string>("EAS"),
-      entry<double>("THICK"),
-      entry<std::string>("STRESS_STRAIN"),
-      entry<std::vector<int>>("GP", {.size = 2}),
+      parameter<std::vector<int>>("NURBS9", {.size = 9}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<std::string>("EAS"),
+      parameter<double>("THICK"),
+      parameter<std::string>("STRESS_STRAIN"),
+      parameter<std::vector<int>>("GP", {.size = 2}),
   });
 }
 
diff --git a/src/w1/4C_w1_nurbs.cpp b/src/w1/4C_w1_nurbs.cpp
index 58a5d3a3c9b..ed952699eab 100644
--- a/src/w1/4C_w1_nurbs.cpp
+++ b/src/w1/4C_w1_nurbs.cpp
@@ -71,23 +71,23 @@ void Discret::Elements::Nurbs::Wall1NurbsType::setup_element_definition(
   using namespace Core::IO::InputSpecBuilders;
 
   defs["NURBS4"] = all_of({
-      entry<std::vector<int>>("NURBS4", {.size = 4}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<std::string>("EAS"),
-      entry<double>("THICK"),
-      entry<std::string>("STRESS_STRAIN"),
-      entry<std::vector<int>>("GP", {.size = 2}),
+      parameter<std::vector<int>>("NURBS4", {.size = 4}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<std::string>("EAS"),
+      parameter<double>("THICK"),
+      parameter<std::string>("STRESS_STRAIN"),
+      parameter<std::vector<int>>("GP", {.size = 2}),
   });
 
   defs["NURBS9"] = all_of({
-      entry<std::vector<int>>("NURBS9", {.size = 9}),
-      entry<int>("MAT"),
-      entry<std::string>("KINEM"),
-      entry<std::string>("EAS"),
-      entry<double>("THICK"),
-      entry<std::string>("STRESS_STRAIN"),
-      entry<std::vector<int>>("GP", {.size = 2}),
+      parameter<std::vector<int>>("NURBS9", {.size = 9}),
+      parameter<int>("MAT"),
+      parameter<std::string>("KINEM"),
+      parameter<std::string>("EAS"),
+      parameter<double>("THICK"),
+      parameter<std::string>("STRESS_STRAIN"),
+      parameter<std::vector<int>>("GP", {.size = 2}),
   });
 }
 
diff --git a/src/w1/4C_w1_poro_eletypes.cpp b/src/w1/4C_w1_poro_eletypes.cpp
index 50b9c620884..880674506fc 100644
--- a/src/w1/4C_w1_poro_eletypes.cpp
+++ b/src/w1/4C_w1_poro_eletypes.cpp
@@ -66,10 +66,10 @@ void Discret::Elements::WallQuad4PoroType::setup_element_definition(
 
   defs["QUAD4"] = all_of({
       defs_wall["QUAD4"],
-      entry<std::vector<double>>("POROANISODIR1", {.required = false, .size = 2}),
-      entry<std::vector<double>>("POROANISODIR2", {.required = false, .size = 2}),
-      entry<std::vector<double>>("POROANISONODALCOEFFS1", {.required = false, .size = 4}),
-      entry<std::vector<double>>("POROANISONODALCOEFFS2", {.required = false, .size = 4}),
+      parameter<std::vector<double>>("POROANISODIR1", {.required = false, .size = 2}),
+      parameter<std::vector<double>>("POROANISODIR2", {.required = false, .size = 2}),
+      parameter<std::vector<double>>("POROANISONODALCOEFFS1", {.required = false, .size = 4}),
+      parameter<std::vector<double>>("POROANISONODALCOEFFS2", {.required = false, .size = 4}),
   });
 }
 
@@ -139,8 +139,8 @@ void Discret::Elements::WallQuad9PoroType::setup_element_definition(
 
   defs["QUAD9"] = all_of({
       defs_wall["QUAD9"],
-      entry<std::vector<double>>("POROANISODIR1", {.required = false, .size = 2}),
-      entry<std::vector<double>>("POROANISODIR2", {.required = false, .size = 2}),
+      parameter<std::vector<double>>("POROANISODIR1", {.required = false, .size = 2}),
+      parameter<std::vector<double>>("POROANISODIR2", {.required = false, .size = 2}),
   });
 }
 
@@ -211,8 +211,8 @@ void Discret::Elements::WallNurbs4PoroType::setup_element_definition(
 
   defs["NURBS4"] = all_of({
       defs_wall["NURBS4"],
-      entry<std::vector<double>>("POROANISODIR1", {.required = false, .size = 2}),
-      entry<std::vector<double>>("POROANISODIR2", {.required = false, .size = 2}),
+      parameter<std::vector<double>>("POROANISODIR1", {.required = false, .size = 2}),
+      parameter<std::vector<double>>("POROANISODIR2", {.required = false, .size = 2}),
   });
 }
 
@@ -283,8 +283,8 @@ void Discret::Elements::WallNurbs9PoroType::setup_element_definition(
 
   defs["NURBS9"] = all_of({
       defs_wall["NURBS9"],
-      entry<std::vector<double>>("POROANISODIR1", {.required = false, .size = 2}),
-      entry<std::vector<double>>("POROANISODIR2", {.required = false, .size = 2}),
+      parameter<std::vector<double>>("POROANISODIR1", {.required = false, .size = 2}),
+      parameter<std::vector<double>>("POROANISODIR2", {.required = false, .size = 2}),
   });
 }
 
@@ -355,10 +355,10 @@ void Discret::Elements::WallTri3PoroType::setup_element_definition(
 
   defs["TRI3"] = all_of({
       defs_wall["TRI3"],
-      entry<std::vector<double>>("POROANISODIR1", {.required = false, .size = 2}),
-      entry<std::vector<double>>("POROANISODIR2", {.required = false, .size = 2}),
-      entry<std::vector<double>>("POROANISONODALCOEFFS1", {.required = false, .size = 3}),
-      entry<std::vector<double>>("POROANISONODALCOEFFS2", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("POROANISODIR1", {.required = false, .size = 2}),
+      parameter<std::vector<double>>("POROANISODIR2", {.required = false, .size = 2}),
+      parameter<std::vector<double>>("POROANISONODALCOEFFS1", {.required = false, .size = 3}),
+      parameter<std::vector<double>>("POROANISONODALCOEFFS2", {.required = false, .size = 3}),
   });
 }
 
diff --git a/src/w1/4C_w1_poro_p1_scatra_eletypes.cpp b/src/w1/4C_w1_poro_p1_scatra_eletypes.cpp
index 1afbe3a6c85..5d1a6f02522 100644
--- a/src/w1/4C_w1_poro_p1_scatra_eletypes.cpp
+++ b/src/w1/4C_w1_poro_p1_scatra_eletypes.cpp
@@ -78,7 +78,7 @@ void Discret::Elements::WallQuad4PoroP1ScatraType::setup_element_definition(
 
   defs["QUAD4"] = all_of({
       defs_wallporo["QUAD4"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
@@ -148,7 +148,7 @@ void Discret::Elements::WallQuad9PoroP1ScatraType::setup_element_definition(
 
   defs["QUAD9"] = all_of({
       defs_wallporo["QUAD9"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
@@ -215,7 +215,7 @@ void Discret::Elements::WallTri3PoroP1ScatraType::setup_element_definition(
 
   defs["TRI3"] = all_of({
       defs_wallporo["TRI3"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
diff --git a/src/w1/4C_w1_poro_scatra_eletypes.cpp b/src/w1/4C_w1_poro_scatra_eletypes.cpp
index c09e3969663..308ae7a172a 100644
--- a/src/w1/4C_w1_poro_scatra_eletypes.cpp
+++ b/src/w1/4C_w1_poro_scatra_eletypes.cpp
@@ -75,7 +75,7 @@ void Discret::Elements::WallQuad4PoroScatraType::setup_element_definition(
 
   defs["QUAD4"] = all_of({
       defs_wall["QUAD4"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
@@ -142,7 +142,7 @@ void Discret::Elements::WallQuad9PoroScatraType::setup_element_definition(
 
   defs["QUAD9"] = all_of({
       defs_wall["QUAD9"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
@@ -209,7 +209,7 @@ void Discret::Elements::WallNurbs4PoroScatraType::setup_element_definition(
 
   defs["NURBS4"] = all_of({
       defs_wall["NURBS4"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
@@ -276,7 +276,7 @@ void Discret::Elements::WallNurbs9PoroScatraType::setup_element_definition(
 
   defs["NURBS9"] = all_of({
       defs_wall["NURBS9"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
@@ -343,7 +343,7 @@ void Discret::Elements::WallTri3PoroScatraType::setup_element_definition(
 
   defs["TRI3"] = all_of({
       defs_wall["TRI3"],
-      entry<std::string>("TYPE"),
+      parameter<std::string>("TYPE"),
   });
 }
 
diff --git a/src/w1/4C_w1_scatra.cpp b/src/w1/4C_w1_scatra.cpp
index 3823a853683..f58c6b0524a 100644
--- a/src/w1/4C_w1_scatra.cpp
+++ b/src/w1/4C_w1_scatra.cpp
@@ -63,7 +63,7 @@ void Discret::Elements::Wall1ScatraType::setup_element_definition(
   {
     defs[key] = all_of({
         wall_line_def,
-        entry<std::string>("TYPE"),
+        parameter<std::string>("TYPE"),
     });
   }
 }