mod: add parsing of Homogeneity and MinimumSeparationBuffer

engine/src/Utils/Spawning/SpawnSpace.cpp

@@ -31,11 +31,13 @@
 #include "ObjectTemplateSampler.h"
 #include "SpawnSpot.h"
 #include "SpawnZone.h"
+#include "SpawningDefaults.h"
 #include "StreamUtils.h"
 #include "ToEntity.h"
 #include "Transform.h"
 #include "Utils/ControllerCreator.h"
 #include "Utils/EntityCreator.h"
+#include "Utils/JsonParsing.h"
 #include "Utils/PropertyInterpretation/DistributionInterpreter.h"
 #include "Utils/PropertyInterpreter.h"
 
@@ -89,6 +91,36 @@ units::time::second_t GetTgap(
   return default_tgap;
 }
 
+units::length::meter_t GetMinimimSeparationBuffer(
+    const std::map<std::string, std::string> &parameters, units::length::meter_t default_minimum_separation_buffer)
+{
+  if (auto it = parameters.find("spawnParameter::minimumSeparationBuffer"); it != parameters.end())
+  {
+    return units::make_unit<units::length::meter_t>(std::stod(it->second));
+  }
+  return default_minimum_separation_buffer;
+}
+
+std::vector<units::dimensionless::scalar_t> GetHomogeneity(
+    const std::map<std::string, std::string> &parameters)
+{
+  if (auto it = parameters.find("spawnParameter::homogeneity"); it != parameters.end())
+  {
+    if (auto homogeneity = json::Deserialize<std::vector<double>>(it->second))
+    {
+      std::vector<units::dimensionless::scalar_t> scalars{};
+      scalars.reserve(homogeneity->size());
+      std::transform((*homogeneity).begin(),
+                     (*homogeneity).end(),
+                     std::back_inserter(scalars),
+                     [](auto v)
+                     { return units::dimensionless::scalar_t{v}; });
+      return scalars;
+    }
+  }
+  return {};
+}
+
 }  // namespace detail
 
 SpawnSpace::SpawnSpace(
@@ -178,14 +210,18 @@ SpawnParameters SpawnSpace::GetSpawnParameters(
   auto parameters = detail::GetParameters(*stochastics_.get(), properties);
   auto velocity{detail::GetVelocity(parameters, spawning_defaults::DEFAULT_VELOCITY)};
   auto time_gap{detail::GetTgap(parameters, spawning_defaults::DEFAULT_TIME_GAP)};
+  auto homogeneity{detail::GetHomogeneity(parameters)};
+  auto minimum_separation_buffer{detail::GetMinimimSeparationBuffer(parameters, spawning_defaults::MINIMUM_SEPERATION_BUFFER)};
 
   return {
       time_gap,
       velocity,
       entity_length,
-      spawning_defaults::MINIMUM_SEPERATION_BUFFER,
+      homogeneity,
+      minimum_separation_buffer,
       spawning_defaults::ttc_assumptions::REACTION_TIME,
-      spawning_defaults::ttc_assumptions::DECELERATION};
+      spawning_defaults::ttc_assumptions::DECELERATION,
+  };
 }
 
 bool SpawnSpace::Spawn(size_t entityNr)

engine/src/Utils/Spawning/SpawnSpace.h

@@ -45,6 +45,7 @@ struct SpawnParameters
   units::time::second_t t_gap;                                                                                      //!< requested time gap to next entity
   units::velocity::meters_per_second_t velocity;                                                                    //!< requested velocity (reduced in case of TTC violation)
   units::length::meter_t entity_length;                                                                             //!< length of the spawned entity
+  std::vector<units::dimensionless::scalar_t> homogeneity{};                                                        //!< adjacent lane dependent speed adjustment
   units::length::meter_t minimum_distance{spawning_defaults::MINIMUM_SEPERATION_BUFFER};                            //!< might extend distance between entites given by t_gap * velocity
   units::time::second_t reaction_time{spawning_defaults::ttc_assumptions::REACTION_TIME};                           //!< assumed reaction time for TTC caluclation
   units::acceleration::meters_per_second_squared_t deceleration{spawning_defaults::ttc_assumptions::DECELERATION};  //!< assumed decelaration for TTC calculation