Line data    Source code

       1             : #include "SimulationConfigBuilder.hpp"
       2             : #include "ExceptionWithLocation.hpp"
       3             : 
       4             : namespace cell
       5             : {
       6             : 
       7          20 : void SimulationConfigBuilder::addDisc(const std::string& discType, Position position, Velocity velocity)
       8             : {
       9          40 :     simulationConfig_.discs.push_back(
      10          20 :         config::Disc{.discTypeName = discType, .x = position.x, .y = position.y, .vx = velocity.x, .vy = velocity.y});
      11          20 : }
      12             : 
      13           8 : void SimulationConfigBuilder::useDistribution(bool useDistribution)
      14             : {
      15           8 :     simulationConfig_.useDistribution = useDistribution;
      16           8 : }
      17             : 
      18           5 : void SimulationConfigBuilder::setDiscCount(std::string membraneTypeName, int count)
      19             : {
      20           5 :     auto& membraneType = findMembraneTypeByName(simulationConfig_, membraneTypeName);
      21           5 :     membraneType.discCount = count;
      22           5 : }
      23             : 
      24           5 : void SimulationConfigBuilder::setDistribution(std::string membraneTypeName,
      25             :                                               const std::unordered_map<std::string, double>& distribution)
      26             : {
      27           5 :     auto& membraneType = findMembraneTypeByName(simulationConfig_, membraneTypeName);
      28           5 :     membraneType.discTypeDistribution = distribution;
      29           5 : }
      30             : 
      31          36 : void SimulationConfigBuilder::addDiscType(const std::string& name, Radius radius, Mass mass)
      32             : {
      33          36 :     simulationConfig_.discTypes.push_back(config::DiscType{.name = name, .radius = radius.value, .mass = mass.value});
      34          36 : }
      35             : 
      36          13 : void SimulationConfigBuilder::addMembraneType(
      37             :     const std::string& name, Radius radius,
      38             :     const std::unordered_map<std::string, MembraneType::Permeability>& permeabilityMap)
      39             : {
      40          13 :     simulationConfig_.membraneTypes.push_back(
      41          26 :         config::MembraneType{.name = name, .radius = radius.value, .permeabilityMap = permeabilityMap});
      42          13 : }
      43             : 
      44          14 : void SimulationConfigBuilder::addMembrane(const std::string& membraneTypeName, Position position)
      45             : {
      46          28 :     simulationConfig_.membranes.push_back(
      47          14 :         config::Membrane{.membraneTypeName = membraneTypeName, .x = position.x, .y = position.y});
      48          14 : }
      49             : 
      50          10 : void SimulationConfigBuilder::addReaction(const std::string& educt1, const std::string& educt2,
      51             :                                           const std::string& product1, const std::string& product2,
      52             :                                           Probability probability)
      53             : {
      54          20 :     simulationConfig_.reactions.push_back(config::Reaction{.educt1 = educt1,
      55             :                                                            .educt2 = educt2,
      56             :                                                            .product1 = product1,
      57             :                                                            .product2 = product2,
      58          10 :                                                            .probability = probability.value});
      59          10 : }
      60             : 
      61           0 : void SimulationConfigBuilder::setCellMembraneType(
      62             :     Radius radius, const std::unordered_map<std::string, MembraneType::Permeability>& permeabilityMap)
      63             : {
      64           0 :     simulationConfig_.cellMembraneType.radius = radius.value;
      65           0 :     simulationConfig_.cellMembraneType.permeabilityMap = permeabilityMap;
      66           0 : }
      67             : 
      68           1 : void SimulationConfigBuilder::setTimeStep(double simulationTimeStep)
      69             : {
      70           1 :     simulationConfig_.simulationTimeStep = simulationTimeStep;
      71           1 : }
      72             : 
      73           1 : void SimulationConfigBuilder::setTimeScale(double simulationTimeScale)
      74             : {
      75           1 :     simulationConfig_.simulationTimeScale = simulationTimeScale;
      76           1 : }
      77             : 
      78           1 : void SimulationConfigBuilder::setMaxVelocity(double maxVelocity)
      79             : {
      80           1 :     simulationConfig_.maxVelocity = maxVelocity;
      81           1 : }
      82             : 
      83          11 : const SimulationConfig& SimulationConfigBuilder::getSimulationConfig() const
      84             : {
      85          11 :     return simulationConfig_;
      86             : }
      87             : 
      88             : } // namespace cell