start of antibiotic mode prototype, functors aren't quite right

Author: anyaevostinar

Makefile

@@ -55,6 +55,9 @@ pgg-mode:	source/native/symbulation_pgg.cc
 sgp-mode:	source/native/symbulation_sgp.cc
 	$(CXX_nat) $(CFLAGS_nat) source/native/symbulation_sgp.cc -o symbulation_sgp
 
+antibiotic-mode:	source/native/symbulation_antibiotic.cc
+	$(CXX_nat) $(CFLAGS_nat) source/native/symbulation_antibiotic.cc -o symbulation_antibiotic
+
 symbulation.js: source/web/symbulation-web.cc
 	$(CXX_web) $(CFLAGS_web) source/web/symbulation-web.cc -o web/symbulation.js
 

source/Organism.h

@@ -74,6 +74,10 @@ class Organism {
     std::cout << "GetDead called from Organism" << std::endl;
     throw "Organism method called!";
   }
+  virtual void ApplyOutputPoints() { //TODO: make in SGPHost as well
+    std::cout << "ApplyOutputPoints called from Organism" << std::endl;
+    throw "Organism method called!";
+  }
   virtual void Process(emp::WorldPosition location) {
     std::cout << "Process called from Organism" << std::endl;
     throw "Organism method called!";
@@ -382,5 +386,15 @@ class Organism {
     throw "Organism method called!";
   }
 
+  //TODO: Figure out how to remove?
+  virtual bool MeetsIndependentReproRequirements() {
+    std::cout << "MeetsIndependentReproRequirements called from Organism" << std::endl;
+    throw "Organism method called!";
+  }
+  virtual void PayIndependentReproCost() {
+    std::cout << "PayIndependentReproCost called from Organism" << std::endl;
+    throw "Organism method called!";
+  }
+
 };
 #endif

source/antibiotic-mode/AntibioticConfigSetup.h

@@ -0,0 +1,16 @@
+#ifndef ANTIBIOTIC_CONFIG_H
+#define ANTIBIOTIC_CONFIG_H
+#include "../../Empirical/include/emp/config/config.hpp"
+#include "../ConfigSetup.h"
+#include "../sgp_mode/SGPConfigSetup.h"
+
+namespace antibioticmode{
+
+/*Notes: can we set different defaults for values in this config?*/
+EMP_EXTEND_CONFIG(AntibioticConfig, sgpmode::SymConfigSGP,
+  GROUP(ANTI, "Settings for antibiotic resistance"),
+  VALUE(NUM_HUMANS, size_t, 10, "Number of humans in the simulation")
+)
+}
+
+#endif

source/antibiotic-mode/Human.h

@@ -0,0 +1,41 @@
+/*
+Properties:
+* SGPWorld - microbiome
+* 
+*/
+
+#ifndef HUMAN_H
+#define HUMAN_H
+
+#include "../sgp_mode/SGPWorld.h"
+#include "AntibioticConfigSetup.h"
+
+namespace antibioticmode {
+
+class Human {
+
+protected:
+
+    /**
+     * The SGPWorld that holds the microbiome of this human.
+     */
+    emp::Ptr<sgpmode::SGPWorld> microbiome;
+
+    /**
+     * Config for all settings
+     */
+    emp::Ptr<AntibioticConfig> my_config;
+
+public:
+    Human(emp::Random& _random, emp::Ptr<AntibioticConfig> _config) :
+    my_config(_config)
+    {
+        microbiome = emp::NewPtr<sgpmode::SGPWorld>(_random, _config);
+        microbiome->Setup();
+    }
+
+    emp::Ptr<sgpmode::SGPWorld> GetMicrobiome() { return microbiome; }
+
+};
+}
+#endif //HUMAN_H    

source/default_mode/SymWorld.h

@@ -36,6 +36,12 @@ class SymWorld : public emp::World<Organism> {
   using pop_t = typename emp::World<Organism>::pop_t;
   using host_systematics_t = emp::Systematics<Organism, taxon_t::info_t, datastruct::HostTaxonData>;
   using sym_systematics_t = emp::Systematics<Organism, taxon_t::info_t, datastruct::SymbiontTaxonData>;
+  using fun_check_sym_independent_repro_reqs_t = std::function<bool(
+    Organism&  /* symbiont */
+  )>;
+  using fun_pay_sym_independent_repro_cost_t = std::function<void(
+    Organism&  /* symbiont */
+  )>;
 
   enum class SPATIAL_STRUCT_MODE { WELL_MIXED, GRID, LOAD };
   static const std::unordered_map<std::string, SPATIAL_STRUCT_MODE> spatial_struct_mode_cfg_mapping;
@@ -86,6 +92,19 @@ class SymWorld : public emp::World<Organism> {
   */
   fun_calc_info_t calc_sym_info_fun;
 
+  /**
+    *
+    * Purpose: Represents a standard function object which determines if a symbiont can reproduce independently.
+    *
+  */
+  fun_check_sym_independent_repro_reqs_t fun_check_sym_independent_repro_reqs;
+
+  /**
+    *
+    * Purpose: Represents a standard function object which pays the cost of independent reproduction for a symbiont.
+    *
+  */
+  fun_pay_sym_independent_repro_cost_t fun_pay_sym_independent_repro_cost;
 
   /**
     *
@@ -269,6 +288,18 @@ class SymWorld : public emp::World<Organism> {
     if (my_config->TAG_MATCHING()) {
       SetupTagMatching();
     }
+
+    fun_check_sym_independent_repro_reqs = [](
+      Organism& sym
+    ) {
+      return sym.MeetsIndependentReproRequirements();
+    };
+
+    fun_pay_sym_independent_repro_cost = [](
+      Organism& sym
+    ) {
+      sym.PayIndependentReproCost();
+    };
   }
 
 
@@ -330,6 +361,23 @@ class SymWorld : public emp::World<Organism> {
     }
   }
 
+  /* Allow setting functor from native file*/
+  void SetCheckSymIndependentReproReqsFunctor(fun_check_sym_independent_repro_reqs_t fun) {
+    fun_check_sym_independent_repro_reqs = fun;
+  }
+
+  bool CheckSymIndependentReproReqs(Organism& sym) {
+    return fun_check_sym_independent_repro_reqs(sym);
+  }
+
+  void SetPaySymIndependentReproCostFunctor(fun_pay_sym_independent_repro_cost_t fun) {
+    fun_pay_sym_independent_repro_cost = fun;
+  }
+
+  void PaySymIndependentReproCost(Organism& sym) {
+    fun_pay_sym_independent_repro_cost(sym);
+  }
+
   /**
    * Input: Boolean indicating whether world uses synchronous generations or not.
    *

source/default_mode/Symbiont.h

@@ -802,6 +802,22 @@ class Symbiont: public Organism {
     return GetPoints() >= required_points;
   }
 
+  /*
+  * Input: None
+  *
+  * Output: None
+  *
+  * Purpose: To pay the cost of independent reproduction, by subtracting the required resources from the symbiont's points.
+  */
+  void PayIndependentReproCost() {
+    // symbiont reproduces independently (horizontal transmission) if it has enough resources
+    //TODO: try just subtracting points to be consistent with vertical transmission
+    //points = points - my_config->SYM_HORIZ_TRANS_RES();
+    if(!my_config->TAG_MATCHING() && !my_config->FREE_HT_FAILURE()) SetPoints(0);
+    // removing the above for tag matching--sym parent points are
+    // now set to 0 in symdobirth
+  }
+
   /*
   * Input: sym_pos, world position
   *
@@ -811,18 +827,15 @@ class Symbiont: public Organism {
   */
   bool AttemptIndependentReproduction(emp::WorldPosition sym_pos) {
     if (my_config->HORIZ_TRANS()) { //non-lytic horizontal transmission enabled
-      if (MeetsIndependentReproRequirements()) {
+      if (my_world->CheckSymIndependentReproReqs(*this)) {
         emp::DataMonitor<double, emp::data::Histogram>& data_node_attempts_horiztrans = my_world->GetHorizontalTransmissionAttemptCount();
         data_node_attempts_horiztrans.AddDatum(GetIntVal());
 
-        // symbiont reproduces independently (horizontal transmission) if it has enough resources
-        //TODO: try just subtracting points to be consistent with vertical transmission
-        //points = points - my_config->SYM_HORIZ_TRANS_RES();
 
 
-        if(!my_config->TAG_MATCHING() && !my_config->FREE_HT_FAILURE()) SetPoints(0);
-        // removing the above for tag matching--sym parent points are
-        // now set to 0 in symdobirth
+        my_world->PaySymIndependentReproCost(*this);
+
+
         return true;
       }
     }

source/sgp_mode/SGPSymbiont.h

@@ -4,11 +4,13 @@
 #include "../default_mode/Symbiont.h"
 #include "hardware/SGPHardware.h"
 #include "SGPHost.h"
+#include "org_type_info.h"
 
 #include "emp/base/Ptr.hpp"
 #include "emp/Evolve/World_structure.hpp"
 
 namespace sgpmode {
+  using nutrient_sym_mode_t = typename org_info::NutrientSymbiontType;
 
 template<typename HW_SPEC_T>
 class SGPSymbiont : public Symbiont {
@@ -245,6 +247,29 @@ class SGPSymbiont : public Symbiont {
     if(my_host) my_world->TriggerAfterEndosymProcessSig(pos, *this, my_host);
   }
 
+  void ApplyOutputPoints(double points) {
+    // Calc base task value based on task environment, task requirements, and
+    // symbiont's current point value.
+    // NOTE - A little funky because task value might be a multiplier on
+    //        current sym points.
+    //        So, to get the value *added* by the task, we subtract original point value.
+
+    double task_points = points - GetPoints();
+
+    //Parasitic Nutrient symbionts receieve less rewards from completing tasks to incentivize matching tasks with hosts
+    if(my_world->GetConfig().ENABLE_NUTRIENT() && my_world->GetNutrientSymType() == nutrient_sym_mode_t::PARASITE){
+      task_points *= my_world->GetConfig().PARASITE_BASE_TASK_VALUE_PROP();
+    }
+
+    // Add earned task points to symbiont's point total
+    AddPoints(task_points);
+    // // Enforce limits on points
+    // const double max_points = sgp_config.SYM_HORIZ_TRANS_RES();
+    // if (sym.GetPoints() > (1.5 * sgp_config.SYM_HORIZ_TRANS_RES())) {
+    //   sym.SetPoints(1.5 * sgp_config.SYM_HORIZ_TRANS_RES());
+    // }
+  }
+
   /**
   * Input: emp::Ptr<Organism> to host offspring, emp::Ptr<Organism> to symbiont offspring
   *

source/sgp_mode/SGPWorld.cc

@@ -351,30 +351,13 @@ void SGPWorld::ProcessSymOutputBuffer(sgp_sym_t& sym) {
         // Track success
         ++sym_task_successes[task_id];
 
-        // Calc base task value based on task environment, task requirements, and
-        // symbiont's current point value.
-        // NOTE - A little funky because task value might be a multiplier on
-        //        current sym points.
-        //        So, to get the value *added* by the task, we subtract original point value.
         double new_points = task_req_info.fun_calc_task_val(
           task_env,
           task_req_info,
           sym.GetPoints()
         );
-        double task_points = new_points - sym.GetPoints();
-
-        //Parasitic Nutrient symbionts receieve less rewards from completing tasks to incentivize matching tasks with hosts
-        if(sgp_config.ENABLE_NUTRIENT() && GetNutrientSymType() == nutrient_sym_mode_t::PARASITE){
-          task_points *= sgp_config.PARASITE_BASE_TASK_VALUE_PROP();
-        }
-
-        // Add earned task points to symbiont's point total
-        sym.AddPoints(task_points);
-        // // Enforce limits on points
-        // const double max_points = sgp_config.SYM_HORIZ_TRANS_RES();
-        // if (sym.GetPoints() > (1.5 * sgp_config.SYM_HORIZ_TRANS_RES())) {
-        //   sym.SetPoints(1.5 * sgp_config.SYM_HORIZ_TRANS_RES());
-        // }
+      
+        ApplySymOutputPoints(sym, new_points);
       }
     }
   }

source/sgp_mode/SGPWorld.h

@@ -102,6 +102,11 @@ class SGPWorld : public SymWorld {
     size_t     /* task id */
   )>;
 
+  using fun_apply_sym_output_points_t = std::function<void(
+    sgp_sym_t&,
+    double     /* total points of sym after task, in case of multiplier */
+  )>;
+
   // using fun_process_endosym_t = std::function<void(
   //   sgp_sym_t&,                /* endosymbiont */
   //   const emp::WorldPosition&, /* sym pos */
@@ -428,6 +433,7 @@ class SGPWorld : public SymWorld {
   fun_calc_host_nutrient_interaction_t fun_calc_host_nutrient_interaction;
   fun_calc_sym_nutrient_interaction_t fun_calc_sym_nutrient_interaction;
   func_apply_host_points_t fun_apply_host_points;
+  fun_apply_sym_output_points_t fun_apply_sym_output_points;
 
   // NOTE - Don't love this being owned by the world.
   //        Not sure of better alterative. Need to know this in InitializeState
@@ -615,6 +621,13 @@ class SGPWorld : public SymWorld {
       ) {
         return 0.0;
       };
+
+      fun_apply_sym_output_points = [](
+        sgp_sym_t& sym,
+        double total_points
+      ) {
+        sym.ApplyOutputPoints(total_points);
+      };
   }
 
   ~SGPWorld() {
@@ -708,6 +721,17 @@ class SGPWorld : public SymWorld {
     fun_apply_host_points(host,task_value_before, task_id);
   }
 
+  void SetApplySymOutputPointsFunctor(fun_apply_sym_output_points_t func) {
+    fun_apply_sym_output_points = func;
+  }
+
+  void ApplySymOutputPoints(
+    sgp_sym_t& sym,
+    double total_points
+  ) {
+    fun_apply_sym_output_points(sym, total_points);
+  }
+
   const emp::BitVector& GetSymTaskProfile(
     sgp_sym_t& sym
   ) {