Merge pull request #274 from K-Johnson-Horrigan/complex-syms-clean

Const bitset references + stress escapee data nodes

Author: anyaevostinar

source/default_mode/DataNodes.h

@@ -195,16 +195,13 @@ void SymWorld::WritePhylogenyFile(const std::string & filename) {
 
 
 /**
- * Input: The address of the string representing the suffixes for the files to be created.
+ * Input: The reference of the datafile which is being constructed.
  *
  * Output: None.
  *
- * Purpose: To setup and write to the files that track the counts of attempted
- * tranmissions.
+ * Purpose: To setup the columns tracking symbiont transmission.
  */
-
-emp::DataFile & SymWorld::SetUpTransmissionFile(const std::string & filename){
-  auto & file = SetupFile(filename);
+void SymWorld::SetupTransmissionFileColumns(emp::DataFile& file){
   auto & node1 = GetHorizontalTransmissionAttemptCount();
   auto & node2 = GetHorizontalTransmissionSuccessCount();
   auto & node3 = GetVerticalTransmissionAttemptCount();
@@ -219,9 +216,20 @@ emp::DataFile & SymWorld::SetUpTransmissionFile(const std::string & filename){
   //vertical transmission
   file.AddTotal(node3, "attempts_verttrans", "Total number of vertical transmission attempts", true);
   file.AddTotal(node4, "successes_verttrans", "Total number of vertical transmission successes", true);
+}
 
+/**
+ * Input: The address of the string representing the file to be
+ * created's name
+ *
+ * Output: The address of the DataFile that has been created.
+ *
+ * Purpose: To set up the file that will be used to track symbiont transmission
+ */
+emp::DataFile& SymWorld::SetUpTransmissionFile(const std::string& filename) {
+  auto& file = SetupFile(filename);
+  SetupTransmissionFileColumns(file);
   file.PrintHeaderKeys();
-
   return file;
 }
 

source/default_mode/SymWorld.h

@@ -505,6 +505,7 @@ class SymWorld : public emp::World<Organism>{
   emp::DataFile & SetupHostIntValFile(const std::string & filename);
   emp::DataFile & SetUpFreeLivingSymFile(const std::string & filename);
   emp::DataFile & SetUpTransmissionFile(const std::string & filename);
+  virtual void SetupTransmissionFileColumns(emp::DataFile& file);
   virtual void SetupHostFileColumns(emp::DataFile & file);
   emp::DataMonitor<int>& GetHostCountDataNode();
   emp::DataMonitor<int>& GetSymCountDataNode();

source/native/symbulation_sgp.cc

@@ -36,12 +36,15 @@ int symbulation_main(int argc, char *argv[]) {
   config.Write(std::cout);
   emp::Random random(config.SEED());
 
-  TaskSet task_set = LogicTasks;
+  const TaskSet* task_set;
   if(config.DIFFERENT_TASK_VALUES()) {
-    task_set = LogicTasksDiff;
+    task_set = &LogicTasksDiff;
+  }
+  else {
+    task_set = &LogicTasks;
   }
 
-  SGPWorld world(random, &config, task_set);
+  SGPWorld world(random, &config, *task_set);
 
   world.Setup();
   world.CreateDataFiles();

source/sgp_mode/SGPDataNodes.h

@@ -89,6 +89,25 @@ emp::DataFile &SGPWorld::SetupSymInstFile(const std::string &filename) {
   return file;
 }
 
+/**
+ * Input: The address of the file object
+ *
+ * Output: None
+ *
+ * Purpose: To add the stress repro escapee attempts and successes 
+ * as columns in the transmission file.
+ */
+void SGPWorld::SetupTransmissionFileColumns(emp::DataFile& file) {
+  SymWorld::SetupTransmissionFileColumns(file);
+  if (sgp_config->INTERACTION_MECHANISM() == STRESS && sgp_config->SYMBIONT_TYPE() == PARASITE && sgp_config->PARASITE_NUM_OFFSPRING_ON_STRESS_INTERACTION() > 0) {
+    emp::DataMonitor<size_t>& escapee_attempts = GetStressEscapeeOffspringAttemptCount();
+    emp::DataMonitor<size_t>& escapee_successes = GetStressEscapeeOffspringSuccessCount();
+
+    file.AddTotal(escapee_attempts, "stress_escapee_offspring_attempts", "Total number of stress offspring who attempted to escape", true);
+    file.AddTotal(escapee_successes, "stress_escapee_offspring_successes", "Total number of stress offspring who succeeded in escaping (they were validly placed)", true);
+  }
+}
+
 /**
  * Input: The address of the string representing the file to be
  * created's name
@@ -107,9 +126,7 @@ void SGPWorld::WriteTaskCombinationsFile(const std::string& filename) {
   for (size_t i = 0; i < pop.size(); i++) {
     if (!IsOccupied(i)) continue;
     emp::Ptr<SGPHost> host = pop[i].DynamicCast<SGPHost>();
-    std::string host_matching_tasks = (sgp_config->TRACK_PARENT_TASKS()) ? 
-                                    host->GetCPU().state.parent_tasks_performed->ToBinaryString() : 
-                                    host->GetCPU().state.tasks_performed->ToBinaryString();
+    std::string host_matching_tasks = host->GetCPU().state.parent_tasks_performed->ToBinaryString();
     if (emp::Has(matching_task_counts, host_matching_tasks)) {
       matching_task_counts[host_matching_tasks][0]++;
     }
@@ -119,9 +136,7 @@ void SGPWorld::WriteTaskCombinationsFile(const std::string& filename) {
     }
     emp::vector<emp::Ptr<Organism>> syms = host->GetSymbionts();
     for (size_t j = 0; j < syms.size(); j++) {
-      std::string sym_matching_tasks = (sgp_config->TRACK_PARENT_TASKS()) ?
-        syms[j].DynamicCast<SGPSymbiont>()->GetCPU().state.parent_tasks_performed->ToBinaryString() :
-        syms[j].DynamicCast<SGPSymbiont>()->GetCPU().state.tasks_performed->ToBinaryString();
+      std::string sym_matching_tasks = syms[j].DynamicCast<SGPSymbiont>()->GetCPU().state.parent_tasks_performed->ToBinaryString();
       if (emp::Has(matching_task_counts, sym_matching_tasks)) {
         matching_task_counts[sym_matching_tasks][1]++;
       }
@@ -247,4 +262,35 @@ emp::DataMonitor<int> &SGPWorld::GetDonateCount() {
   return *data_node_donate_count;
 }
 
+/**
+ * Input: None
+ *
+ * Output: A reference to the data node storing the count of
+ * stress escapee offspring (successful or not)
+ *
+ * Purpose: To set up and return the data node storing the count
+ * of attempted stress escapee offspring
+ */
+emp::DataMonitor<size_t>& SGPWorld::GetStressEscapeeOffspringAttemptCount() {
+  if (!data_node_stress_escapee_offspring_attempt_count) {
+    data_node_stress_escapee_offspring_attempt_count.New();
+  }
+  return *data_node_stress_escapee_offspring_attempt_count;
+}
+
+/**
+ * Input: None
+ *
+ * Output: A reference to the data node storing the count of successful
+ * stress escapee offspring
+ *
+ * Purpose: To set up and return the data node storing the count
+ * of successful stress escapee offspring
+ */
+emp::DataMonitor<size_t>& SGPWorld::GetStressEscapeeOffspringSuccessCount() {
+  if (!data_node_stress_escapee_offspring_success_count) {
+    data_node_stress_escapee_offspring_success_count.New();
+  }
+  return *data_node_stress_escapee_offspring_success_count;
+}
 #endif

source/sgp_mode/SGPHost.cc

@@ -17,9 +17,9 @@ emp::Ptr<Organism> SGPHost::Reproduce() {
   host_baby->SetReproCount(reproductions + 1);
   // This organism is reproducing, so it must have gotten off the queue
   cpu.state.in_progress_repro = -1;
-  if (sgp_config->TRACK_PARENT_TASKS()) {
-    host_baby->GetCPU().state.parent_tasks_performed->Import(*GetCPU().state.tasks_performed);
 
+  host_baby->GetCPU().state.parent_tasks_performed->Import(*GetCPU().state.tasks_performed);
+  if (sgp_config->TRACK_PARENT_TASKS()) {
     for (int i = 0; i < CPU_BITSET_LENGTH; i++) {
       host_baby->GetCPU().state.task_change_lose[i] = cpu.state.task_change_lose[i];
       host_baby->GetCPU().state.task_change_gain[i] = cpu.state.task_change_gain[i];

source/sgp_mode/SGPSymbiont.h

@@ -201,8 +201,8 @@ class SGPSymbiont : public Symbiont {
     sym_baby->SetReproCount(reproductions + 1);
     // This organism is reproducing, so it must have gotten off the queue
     cpu.state.in_progress_repro = -1;
+    sym_baby->GetCPU().state.parent_tasks_performed->Import(*GetCPU().state.tasks_performed);
     if (sgp_config->TRACK_PARENT_TASKS()) {
-      sym_baby->GetCPU().state.parent_tasks_performed->Import(*GetCPU().state.tasks_performed);
       //inherit towards-from tracking
       for (int i = 0; i < CPU_BITSET_LENGTH; i++) {
 

source/sgp_mode/SGPWorld.h

@@ -10,12 +10,12 @@
 struct StressEscapeeOffspring{
   emp::Ptr<Organism> escapee_offspring;
   size_t parent_pos;
-  emp::BitSet<CPU_BITSET_LENGTH> infection_tasks;
+  const emp::BitSet<CPU_BITSET_LENGTH> infection_tasks;
 
   StressEscapeeOffspring(
     emp::Ptr<Organism> sym,
     size_t loc,
-    emp::BitSet<CPU_BITSET_LENGTH> _tasks
+    const emp::BitSet<CPU_BITSET_LENGTH> _tasks
   ) :
     escapee_offspring(sym),
     parent_pos(loc),
@@ -30,6 +30,8 @@ class SGPWorld : public SymWorld {
 
   emp::Ptr<emp::DataMonitor<int>> data_node_steal_count;
   emp::Ptr<emp::DataMonitor<int>> data_node_donate_count;
+  emp::Ptr<emp::DataMonitor<size_t>> data_node_stress_escapee_offspring_attempt_count;
+  emp::Ptr<emp::DataMonitor<size_t>> data_node_stress_escapee_offspring_success_count;
   emp::vector<emp::DataMonitor<size_t>> data_node_host_tasks;
   emp::vector<emp::DataMonitor<size_t>> data_node_sym_tasks;
 
@@ -45,7 +47,7 @@ class SGPWorld : public SymWorld {
   emp::vector<StressEscapeeOffspring> symbiont_stress_escapee_offspring;
 
   // The task profile retriever function
-  std::function< emp::BitSet<CPU_BITSET_LENGTH>& (const emp::Ptr<Organism>)> fun_get_task_profile;
+  std::function<const emp::BitSet<CPU_BITSET_LENGTH>& (const emp::Ptr<Organism>)> fun_get_task_profile;
 
   SGPWorld(emp::Random &r, emp::Ptr<SymConfigSGP> _config, TaskSet task_set)
       : SymWorld(r, _config),
@@ -59,6 +61,8 @@ class SGPWorld : public SymWorld {
     // data node deletes 
     if (data_node_steal_count) data_node_steal_count.Delete();
     if (data_node_donate_count) data_node_donate_count.Delete();
+    if (data_node_stress_escapee_offspring_attempt_count) data_node_stress_escapee_offspring_attempt_count.Delete();
+    if (data_node_stress_escapee_offspring_success_count) data_node_stress_escapee_offspring_success_count.Delete();
 
     // The vectors will delete themselves automatically
     for (auto escapee_data : symbiont_stress_escapee_offspring) {
@@ -138,12 +142,12 @@ class SGPWorld : public SymWorld {
 
   // Prototypes for reproduction handling methods
   emp::WorldPosition SymDoBirth(emp::Ptr<Organism> sym_baby, emp::WorldPosition parent_pos) override;
-  int GetNeighborHost(size_t source_id, emp::BitSet<CPU_BITSET_LENGTH>& symbiont_tasks);
-  bool TaskMatchCheck(emp::BitSet<CPU_BITSET_LENGTH>& symbiont_tasks, emp::BitSet<CPU_BITSET_LENGTH>& host_tasks);
-  bool PreferentialOustingAllowed(emp::BitSet<CPU_BITSET_LENGTH>& incoming_sym_tasks, emp::Ptr<Organism> host);
+  int GetNeighborHost(size_t source_id, const emp::BitSet<CPU_BITSET_LENGTH>& symbiont_tasks);
+  bool TaskMatchCheck(const emp::BitSet<CPU_BITSET_LENGTH>& symbiont_tasks, const emp::BitSet<CPU_BITSET_LENGTH>& host_tasks);
+  bool PreferentialOustingAllowed(const emp::BitSet<CPU_BITSET_LENGTH>& incoming_sym_tasks, emp::Ptr<Organism> host);
 
   // Prototypes for symbiont placement
-  emp::WorldPosition PlaceSymbiontInHost(emp::Ptr<Organism> symbiont, emp::BitSet<CPU_BITSET_LENGTH>& symbiont_infection_tasks, size_t source_pos);
+  emp::WorldPosition PlaceSymbiontInHost(emp::Ptr<Organism> symbiont, const emp::BitSet<CPU_BITSET_LENGTH>& symbiont_infection_tasks, size_t source_pos);
 
   // Prototypes for sym transferring
   emp::WorldPosition SymFindHost(emp::Ptr<Organism> symbiont, emp::WorldPosition cur_pos);
@@ -155,13 +159,15 @@ class SGPWorld : public SymWorld {
   // Prototypes for data node methods
   emp::DataMonitor<int> &GetStealCount();
   emp::DataMonitor<int> &GetDonateCount();
+  emp::DataMonitor<size_t>& GetStressEscapeeOffspringAttemptCount();
+  emp::DataMonitor<size_t>& GetStressEscapeeOffspringSuccessCount();
 
   void SetupTasksNodes();
 
   emp::DataFile &SetUpOrgCountFile(const std::string &filename);
   emp::DataFile &SetupSymInstFile(const std::string &filename);
-
   emp::DataFile &SetupTasksFile(const std::string &filename);
+  void SetupTransmissionFileColumns(emp::DataFile& file);
   void WriteTaskCombinationsFile(const std::string& filename);
   void WriteOrgReproHistFile(const std::string& filename);
 

source/sgp_mode/SGPWorldSetup.cc

@@ -65,7 +65,7 @@ void SGPWorld::SetupSymbionts(unsigned long *total_syms) {
   */
 void SGPWorld::SetupTaskProfileFun() {
   if (sgp_config->TRACK_PARENT_TASKS()) {
-    fun_get_task_profile = [](const emp::Ptr<Organism> org) ->  emp::BitSet<CPU_BITSET_LENGTH>&{
+    fun_get_task_profile = [](const emp::Ptr<Organism> org) ->  const emp::BitSet<CPU_BITSET_LENGTH>&{
       if (org->IsHost()) {
         return *org.DynamicCast<SGPHost>()->GetCPU().state.parent_tasks_performed;
       }
@@ -147,7 +147,7 @@ void SGPWorld::ProcessReproductionQueue() {
  *
  * Purpose: Searches through up to 10 hosts in the world to find a host that the symbiont can infect. 
  */
-int SGPWorld::GetNeighborHost (size_t source_id, emp::BitSet<CPU_BITSET_LENGTH>& symbiont_tasks){
+int SGPWorld::GetNeighborHost (size_t source_id, const emp::BitSet<CPU_BITSET_LENGTH>& symbiont_tasks){
   // Attempt to find host that matches some tasks
   for (int i = 0; i < 10; i++) {
     emp::WorldPosition neighbor = GetRandomNeighborPos(source_id);
@@ -170,7 +170,7 @@ int SGPWorld::GetNeighborHost (size_t source_id, emp::BitSet<CPU_BITSET_LENGTH>&
   *
   * Purpose: To check for task matching before transmission
   */
-bool SGPWorld::TaskMatchCheck(emp::BitSet<CPU_BITSET_LENGTH>& symbiont_tasks, emp::BitSet<CPU_BITSET_LENGTH>& host_tasks) {
+bool SGPWorld::TaskMatchCheck(const emp::BitSet<CPU_BITSET_LENGTH>& symbiont_tasks, const emp::BitSet<CPU_BITSET_LENGTH>& host_tasks) {
   if (sgp_config->INTERACTION_MECHANISM() == NUTRIENT) {
     return true;
   }
@@ -230,10 +230,15 @@ emp::WorldPosition SGPWorld::SymDoBirth(emp::Ptr<Organism> sym_baby, emp::WorldP
     std::iota(e.begin(), e.end(), 0);
     emp::Shuffle(*random_ptr, e);
 
+    emp::DataMonitor<size_t>& escapee_sucess_data_node = GetStressEscapeeOffspringSuccessCount();
+
     for (size_t escapee_i : e) {
       StressEscapeeOffspring& escapee_data = symbiont_stress_escapee_offspring[escapee_i];
       // TODO:stress escape data nodes
-      PlaceSymbiontInHost(escapee_data.escapee_offspring, escapee_data.infection_tasks, escapee_data.parent_pos);
+      emp::WorldPosition new_pos = PlaceSymbiontInHost(escapee_data.escapee_offspring, escapee_data.infection_tasks, escapee_data.parent_pos);
+      if (new_pos.IsValid()) {
+        escapee_sucess_data_node.AddDatum(1);
+      }
     }
 
     symbiont_stress_escapee_offspring.clear();
@@ -246,11 +251,11 @@ emp::WorldPosition SGPWorld::SymDoBirth(emp::Ptr<Organism> sym_baby, emp::WorldP
   *
   * Purpose: Calculate preferential ousting success
   */
-  bool SGPWorld::PreferentialOustingAllowed(emp::BitSet<CPU_BITSET_LENGTH>& incoming_sym_tasks, emp::Ptr<Organism> host){
-    emp::BitSet<CPU_BITSET_LENGTH>& host_tasks = fun_get_task_profile(host);
+  bool SGPWorld::PreferentialOustingAllowed(const emp::BitSet<CPU_BITSET_LENGTH>& incoming_sym_tasks, emp::Ptr<Organism> host){
+    const emp::BitSet<CPU_BITSET_LENGTH>& host_tasks = fun_get_task_profile(host);
 
     for(emp::Ptr<Organism> sym : host->GetSymbionts()){
-      emp::BitSet<CPU_BITSET_LENGTH>& target_sym_tasks = fun_get_task_profile(sym);
+      const emp::BitSet<CPU_BITSET_LENGTH>& target_sym_tasks = fun_get_task_profile(sym);
 
       if(sgp_config->PREFERENTIAL_OUSTING() == 1){
         // if has worse task match with any hosted sym, fail
@@ -276,7 +281,7 @@ emp::WorldPosition SGPWorld::SymDoBirth(emp::Ptr<Organism> sym_baby, emp::WorldP
   *
   * Purpose: Place a symbiont based on the passed task set
   */
-  emp::WorldPosition SGPWorld::PlaceSymbiontInHost(emp::Ptr<Organism> symbiont, emp::BitSet<CPU_BITSET_LENGTH>& symbiont_infection_tasks, size_t source_pos) {
+  emp::WorldPosition SGPWorld::PlaceSymbiontInHost(emp::Ptr<Organism> symbiont, const emp::BitSet<CPU_BITSET_LENGTH>& symbiont_infection_tasks, size_t source_pos) {
     int new_host_pos = GetNeighborHost(source_pos, symbiont_infection_tasks);
     if (new_host_pos > -1) { //-1 means no living neighbors
       if (sgp_config->OUSTING() && sgp_config->PREFERENTIAL_OUSTING() && (int)pop[new_host_pos]->GetSymbionts().size() == sgp_config->SYM_LIMIT()) {

source/sgp_mode/StressHost.h

@@ -103,8 +103,9 @@ class StressHost : public SGPHost {
         }
         else if (sgp_config->SYMBIONT_TYPE() == PARASITE && sgp_config->PARASITE_NUM_OFFSPRING_ON_STRESS_INTERACTION() > 0) {
           for (size_t j = 0; j < syms.size(); j++) {
-            emp::BitSet<CPU_BITSET_LENGTH>& sym_infection_tasks = my_world->fun_get_task_profile(syms[j]);
+            const emp::BitSet<CPU_BITSET_LENGTH>& sym_infection_tasks = my_world->fun_get_task_profile(syms[j]);
             if (my_world->TaskMatchCheck(sym_infection_tasks, my_world->fun_get_task_profile(this))) {
+              my_world->GetStressEscapeeOffspringAttemptCount().AddDatum(sgp_config->PARASITE_NUM_OFFSPRING_ON_STRESS_INTERACTION());
               for (size_t k = 0; k < sgp_config->PARASITE_NUM_OFFSPRING_ON_STRESS_INTERACTION(); k++) {
                 my_world->symbiont_stress_escapee_offspring.emplace_back(StressEscapeeOffspring(syms[j]->Reproduce(), pos.GetIndex(), sym_infection_tasks));
               }