moved to SymDoBirth() and streamlined horizontal_trans_compatibility_check_functions

Author: Gabe-Rose

source/sgp_mode/DevNotes.md

@@ -5,7 +5,6 @@
 * Move ProcessSymOutputBuffer into SGPSymbiont to parallel host
 * Move SymDoMutation into SGPSymbiont to parallel host
 * Look at whether can move SymDonateToHost and SymStealFromHost into SGPSym
-* Look at fun_host_sym_stress_trans_compatibility_check to try to reduce code duplication of task-profile setups, possibly with decorator pattern, but also definitely just in own file
 * Move world properties back into protected and make necessary accesssors
 * Rename "SetReproCount" to lineage length since it's confusing (or did I already?)
 * Look into what is going on with SGPHost local sgp_config not working
@@ -31,6 +30,8 @@
     - Decisions made: reproduce is shared between horizontal transmission and free-living sym reproduction. If free-living sym repro is on, then reproduce places offspring into sym pop (like in default), and then offspring can infect with Infect instruction (not yet implemented). If FLS is off, reproduce does horizontal transmission. Also decided that if HT is off, an "attempt" is not counted.
 [x] Try to fold ProcessStressEscapees into existing code/reduce duplication
     - Initially we attempted to turn ReproductionQueue into a birth queue, however this hurts performance. ReproductionQueue will skip organisms who have died and therefore should not reproduce before Reproduce() is called. With a birth queue, the children would already be constructed. This uses more memory and wastes resources on construction. Instead ProcessStressEscapees was moved into a signal. 
+[x] Look at fun_host_sym_stress_trans_compatibility_check to try to reduce  code duplication of task-profile setups, possibly with decorator pattern, but also definitely just in own file
+    - Completed with above refactor. Now does not rely on parents as they may be dead at the time of reproduction (stress escapees). This change allowed processing escapees to be streamlined
 
 # Journal
 4/15/26

source/sgp_mode/SGPW_InteractionMechanismSetup.cc

@@ -220,6 +220,7 @@ namespace sgpmode {
   struct StressEscapee {
     emp::Ptr<SGPWorld::sgp_sym_t> sym_offspring;
     emp::BitVector parent_task_profile;
+    //^^^ why are we keeping track of this and not using sym profile?
     size_t escape_location;
 
     StressEscapee() = default;
@@ -466,7 +467,6 @@ namespace sgpmode {
       exit(-1);
     }
 
-    // GABE TODO might want to put in a seperate function?
     after_reproduction_sig.AddAction(
       [this]() {
         // Process escapees in random order (to avoid strongly favoring all offspring from "late" escapee)
@@ -481,27 +481,10 @@ namespace sgpmode {
 
         for (size_t esc_i : escapee_ids) {
           auto& escapee_info = symbiont_stress_escapees[esc_i];
-          bool success = false;
-          for (size_t attempt_i = 0; attempt_i < sgp_config.FIND_NEIGHBOR_HOST_ATTEMPTS(); ++attempt_i) {
-            //test a possible location
-            emp::WorldPosition candidate_pos(GetRandomNeighborPos(escapee_info.escape_location));
-            if (candidate_pos.IsValid() && IsOccupied(candidate_pos)) {
-
-              emp::Ptr<Organism> prospective_org_ptr = GetOrgPtr(candidate_pos.GetIndex());
-              emp_assert(prospective_org_ptr->IsHost());
-              emp::Ptr<sgp_host_t> prospective_host_ptr = static_cast<sgp_host_t*>(prospective_org_ptr.Raw());
-
-              const bool can_infect = fun_host_sym_stress_trans_compatibility_check(
-                *prospective_host_ptr,
-                escapee_info.parent_task_profile
-              );
-              if (!can_infect) continue;
-              prospective_host_ptr->AddSymbiont(escapee_info.sym_offspring);
-              success = true;
-              break;
-            }
-          }
-          if (!success) {
+
+          emp::WorldPosition pos = SymDoBirth(escapee_info.sym_offspring, escapee_info.escape_location);
+
+          if (pos) {
             escapee_info.sym_offspring.Delete();
           }
         }

source/sgp_mode/SGPW_TaskProfileSetup.cc

@@ -85,57 +85,31 @@ void SGPWorld::SetupTaskProfileCompatibilityMode() {
 void SGPWorld::SetupHorizontalTransmissionCompatibilityMode() {
   // Setup function that determines horizontal transmission compatibility based on task profiles
   if (sgp_config.HORIZONTAL_TRANSMISSION_COMPATIBILITY_MODE() == "always") {
-    fun_host_sym_horizontal_trans_compatibility_check = [](
+    fun_horizontal_trans_compatibility_check = [](
       sgp_host_t& host,
-      sgp_sym_t& sym
-    ) -> bool { return true; };
-    fun_host_sym_stress_trans_compatibility_check = [](
-      sgp_host_t& host,
-      const emp::BitVector& profile
+      const emp::BitVector& sym_profile
     ) -> bool { return true; };
   } else if (sgp_config.HORIZONTAL_TRANSMISSION_COMPATIBILITY_MODE() == "task-profile-compatible") {
-    fun_host_sym_horizontal_trans_compatibility_check = [this](
+    fun_horizontal_trans_compatibility_check = [this](
       sgp_host_t& host,
-      sgp_sym_t& sym
+      const emp::BitVector& sym_profile
     ) -> bool {
       const auto& host_profile = fun_get_host_task_profile(host);
-      const auto& sym_profile = fun_get_sym_task_profile(sym);
       return fun_task_profile_compatibility_check(host_profile, sym_profile);
     };
-    fun_host_sym_stress_trans_compatibility_check = [this](
-      sgp_host_t& host,
-      const emp::BitVector& profile
-    ) -> bool {
-      const auto& host_profile = fun_get_host_task_profile(host);
-      return fun_task_profile_compatibility_check(host_profile, profile);
-    };
   } else if (sgp_config.HORIZONTAL_TRANSMISSION_COMPATIBILITY_MODE() == "task-profile-strictly-stronger-match") {
-    fun_host_sym_horizontal_trans_compatibility_check = [this](
+    fun_horizontal_trans_compatibility_check = [this](
       sgp_host_t& host,
-      sgp_sym_t& sym
+      const emp::BitVector& sym_profile
     ) -> bool {
-      const emp::BitVector& incoming_sym_task_profile = fun_get_sym_task_profile(sym);
-      return NoBetterOrEquallyMatchingSymbionts(host, incoming_sym_task_profile);
-    };
-    fun_host_sym_stress_trans_compatibility_check = [this](
-      sgp_host_t& host,
-      const emp::BitVector& profile
-    ) -> bool {
-      return NoBetterOrEquallyMatchingSymbionts(host, profile);
+      return NoBetterOrEquallyMatchingSymbionts(host, sym_profile);
     };
   } else if (sgp_config.HORIZONTAL_TRANSMISSION_COMPATIBILITY_MODE() == "task-profile-stronger-or-equal-match") {
-    fun_host_sym_horizontal_trans_compatibility_check = [this](
-      sgp_host_t& host,
-      sgp_sym_t& sym
-    ) -> bool {
-      const emp::BitVector& incoming_sym_task_profile = fun_get_sym_task_profile(sym);
-      return NoBetterMatchingSymbionts(host, incoming_sym_task_profile);
-    };
-    fun_host_sym_stress_trans_compatibility_check = [this](
+    fun_horizontal_trans_compatibility_check = [this](
       sgp_host_t& host,
-      const emp::BitVector& profile
+      const emp::BitVector& sym_profile
     ) -> bool {
-      return  NoBetterMatchingSymbionts(host, profile);
+      return NoBetterMatchingSymbionts(host, sym_profile);
     };
   } else {
     std::cout << "Unrecognized HORIZONTAL_TRANSMISSION_COMPATIBILITY_MODE: " << sgp_config.HORIZONTAL_TRANSMISSION_COMPATIBILITY_MODE() << std::endl;
@@ -146,7 +120,6 @@ void SGPWorld::SetupHorizontalTransmissionCompatibilityMode() {
 
 void SGPWorld::SetupFindHostForHorizontalTransmission() {
   // Setup function that gets host neighbor (used for symbiont)
-  // Excludes current host, since they really shouldn't be considered a neighbor
   // TODO - add different configuration options for this?
   fun_find_host_for_horizontal_trans = [this](
     size_t host_world_id,                 /* Parent's host location id in world (pops[0][id])*/
@@ -155,14 +128,15 @@ void SGPWorld::SetupFindHostForHorizontalTransmission() {
     for (size_t attempt_i = 0; attempt_i < sgp_config.FIND_NEIGHBOR_HOST_ATTEMPTS(); ++attempt_i) {
       emp::WorldPosition candidate_pos(GetRandomNeighborPos(host_world_id));
       if (candidate_pos.IsValid() && IsOccupied(candidate_pos) && candidate_pos.GetIndex() != host_world_id) {
-        emp::Ptr<Organism> neighbor_org_ptr = GetOrgPtr(candidate_pos.GetIndex());
-        emp_assert(neighbor_org_ptr->IsHost());
+        emp::Ptr<Organism> prospective_org_ptr = GetOrgPtr(candidate_pos.GetIndex());
+        emp_assert(prospective_org_ptr->IsHost());
         // Cast neighbor as sgp_host_t ptr.
-        emp::Ptr<sgp_host_t> neighbor_host_ptr = static_cast<sgp_host_t*>(neighbor_org_ptr.Raw());
+        emp::Ptr<sgp_host_t> prospective_host_ptr = static_cast<sgp_host_t*>(prospective_org_ptr.Raw());
+        const emp::BitVector& endosym_task_profile = fun_get_sym_task_profile(*sym_parent_ptr);
         //TODO: Should this check be done during AddSymbiont instead of here?
-        const bool compatible = fun_host_sym_horizontal_trans_compatibility_check(
-          *neighbor_host_ptr,
-          *sym_parent_ptr
+        const bool compatible = fun_horizontal_trans_compatibility_check(
+          *prospective_host_ptr,
+          endosym_task_profile
         );
         if (compatible) {
           return std::optional<emp::WorldPosition>{candidate_pos};

source/sgp_mode/SGPWorld.h

@@ -66,7 +66,7 @@ class SGPWorld : public SymWorld {
   // NOTE: arguments can't be const because necessary Host.h/Organism.h functions aren't const
   using fun_horizontal_transmission_compatibility_check_t = std::function<bool(
     sgp_host_t&,
-    sgp_sym_t&
+    const emp::BitVector&
   )>;
 
   // Determines whether two task profiles are "compatible" with one another.
@@ -430,13 +430,7 @@ class SGPWorld : public SymWorld {
 
   // Function to check compatibility between host and symbiont
   // - Used to check eligibility for vertical / horizontal transmission, etc.
-  fun_horizontal_transmission_compatibility_check_t fun_host_sym_horizontal_trans_compatibility_check;
-
-  // Function used to check compatibility between host and symbiont that reproduced
-  // via a stress event.
-  // - Can't use same function as when checking horizontal transmission compatibility because
-  //   we no longer have access to the symbiont parent for a stress transmission event.
-  std::function<bool(sgp_host_t&, const emp::BitVector&)> fun_host_sym_stress_trans_compatibility_check;
+  fun_horizontal_transmission_compatibility_check_t fun_horizontal_trans_compatibility_check;
 
   fun_task_profile_compatibility_t fun_task_profile_compatibility_check;