Lineage tracker does everything automatically with signals

evo/LineageTracker.h

@@ -15,40 +15,118 @@ namespace evo{
   // Class to keep track of lineages
   // Maintains record of all genomes that ever existed, which organisms
   // they belonged to, and which organisms were the parents of which
-  template <typename GENOME>
+  template <typename ORG, typename... MANAGERS>
   class LineageTracker {
+  private:
+    using pop_manager_type = AdaptTemplate< typename SelectPopManager<MANAGERS..., PopBasic>::type, ORG>;
+    static constexpr bool separate_generations = pop_manager_type::emp_has_separate_generations;
   public:
-    std::set<GENOME> genomes;
-    std::map<int, GENOME*> org_to_genome;
+    std::set<ORG> genomes;
+    std::map<int, ORG*> org_to_genome;
     std::map<int, int> parents;
-    int next = 0; //-1 indicates no parent
-
-    LineageTracker() {
-      this->parents[-1] = 0;
+    int next = 1; //0 indicates no parent
+    int next_parent_id = -1;
+    int next_org_id = 1;
+    emp::vector<int> generation_since_update;
+    emp::vector<int> prev_generation;
+
+    LineageTracker(){;}
+
+    LineageTracker(World<ORG, MANAGERS...> * world) {
+
+      //Create std::function objects for all the callbacks. It seems like
+      //this maybe shouldn't be necessary (or at least shouldn't need to happen
+      //in the constructor), but for now it is or the compiler throws
+      //internal errors
+      std::function<void(int)> RecordParentFun = [this] (int id){
+        RecordParent(id);
+      };
+
+      std::function<void(int)> TrackPlacementFun = [this] (int pos){
+        TrackPlacement(pos);
+      };
+
+      std::function<void(ORG *)> TrackOffspringFun = [this] (ORG * org){
+        TrackOffspring(org);
+      };
+
+      std::function<void(ORG *)> TrackInjectedOffspringFun = [this] (ORG * org){
+        TrackInjectedOffspring(org);
+      };
+
+      std::function<void(int)> UpdateFun = [this] (int ud){
+        Update(ud);
+      };
+
+      world->OnBeforeRepro(RecordParentFun);
+      world->OnOffspringReady(TrackOffspringFun);
+      world->OnInjectReady(TrackInjectedOffspringFun);
+      world->OnOrgPlacement(TrackPlacementFun);
+      world->OnUpdate(UpdateFun);
     }
+
     ~LineageTracker() {
       //for (GENOME g : genomes) delete &g;
     }
 
+    //Put newly born organism into the lineage tracker
+
+    void Update(int i) {
+      prev_generation = generation_since_update;
+      if (separate_generations) {
+        //TODO: This isn't sufficient - need to add signals for any
+        //population change event
+        generation_since_update.resize(0);
+      }
+    }
+
+    void TrackOffspring(ORG * org) {
+      next_org_id = this->AddOrganism(*org, next_parent_id);
+    }
+
+    //Put newly injected organism into the lineage tracker
+    void TrackInjectedOffspring(ORG * org) {
+      next_org_id = this->AddOrganism(*org, 0);
+    }
+
+    //Keep track of location of all orgs in the population so that
+    //we can translate their ids from the World to ids within the lineage
+    //tracker
+    void TrackPlacement(int pos) {
+      if (pos >= generation_since_update.size()) {
+        generation_since_update.resize(pos+1);
+      }
+      generation_since_update[pos] = next_org_id;
+    }
+
+    //Record the org that's about to have an offspring, so we can know
+    //who the parent of the next org is.
+    void RecordParent(int id) {
+      if (separate_generations){
+        next_parent_id = prev_generation[id];
+      } else {
+        next_parent_id = generation_since_update[id];
+      }
+    }
+
     // Add an organism to the tracker - org is the genome of the organism
     // and parent is the id of the parent. The lineage tracker is in charge
     // of assigning ids, and will return an int representing the id of the
     // organism you added
-    int AddOrganism(GENOME org, int parent) {
+    int AddOrganism(ORG org, int parent) {
       int id = this->next++;
-      std::pair<typename std::set<GENOME>::iterator, bool> ret;
+      std::pair<typename std::set<ORG>::iterator, bool> ret;
       ret = genomes.insert(org);
-      typename std::set<GENOME>::iterator it = ret.first;
-      GENOME* genome = (GENOME*)&(*it);
+      typename std::set<ORG>::iterator it = ret.first;
+      ORG* genome = (ORG*)&(*it);
       this->org_to_genome[id] = genome;
       this->parents[id] = parent;
-
       return id;
     }
 
     // Return a vector containing the genomes of an organism's ancestors
-    emp::vector<GENOME*> TraceLineage(int org_id) {
-      emp::vector<GENOME*> lineage;
+    emp::vector<ORG*> TraceLineage(int org_id) {
+      emp::vector<ORG*> lineage;
 
       while(org_id) {
         lineage.push_back(this->org_to_genome[org_id]);
@@ -61,7 +139,7 @@ namespace evo{
 
     //Return a vector containing the IDs of an oraganism's ancestors
     emp::vector<int> TraceLineageIDs(int org_id) {
-      emp::vector<GENOME*> lineage;
+      emp::vector<ORG*> lineage;
 
       while(org_id) {
         lineage.push_back(org_id);

evo/OEE.h

@@ -33,25 +33,19 @@ namespace evo{
     static constexpr bool separate_generations = pop_manager_type::emp_has_separate_generations;
     static constexpr bool emp_is_stats_manager = true;
     //TODO: Make this use existing lineage tracker if there is one
-    LineageTracker<ORG> lineage;
-    std::set<skeleton_type > novel;
 
-    // The generation we're currently working with - we need this to
-    // track lineage
-    emp::vector<int> generation_since_update;
+    std::set<skeleton_type > novel;
 
     // Historical generations needed to count stats. We only need these in
     // proportion to resolution.
     int generations = 50; //How far back do we look for persistance?
     int resolution = 10; //With what frequency do we record data?
     std::deque<emp::vector<int> > past_snapshots;
 
-    //int update = 0;
-    int next_parent_id = -1;
-    int next_org_id;
-
   public:
 
+    LineageTracker<ORG, MANAGERS...> * lineage;
+
     OEEStatsManager(World<ORG, MANAGERS...>* world){
       // This isn't going to work if generations aren't a multiple of resolution
       emp_assert(generations % resolution == 0 &&
@@ -63,70 +57,20 @@ namespace evo{
       //this maybe shouldn't be necessary (or at least shouldn't need to happen
       //in the constructor), but for now it is or the compiler throws
       //internal errors
-      std::function<void(int)> RecordParentFun = [this] (int id){
-        RecordParent(id);
-      };
-
-      std::function<void(int)> TrackPlacementFun = [this] (int pos){
-        TrackPlacement(pos);
-      };
-
-      std::function<void(ORG *)> TrackOffspringFun = [this] (ORG * org){
-        TrackOffspring(org);
-      };
-
-      std::function<void(ORG *)> TrackInjectedOffspringFun = [this] (ORG * org){
-        TrackInjectedOffspring(org);
-      };
-
       std::function<void(int)> UpdateFun = [this] (int ud){
         Update(ud);
       };
 
+
       //Setup signal callbacks
-      world->OnBeforeRepro(RecordParentFun);
-      world->OnOffspringReady(TrackOffspringFun);
-      world->OnInjectReady(TrackInjectedOffspringFun);
       world->OnUpdate(UpdateFun);
-      world->OnOrgPlacement(TrackPlacementFun);
+      //lineage = LineageTracker<ORG, MANAGERS...>(world);
 
       //TODO: Figure out how to make this work automatically
       //fit_fun = world->GetFitFun();
     }
 
-    //Put newly born organism into the lineage tracker
     std::function<double(ORG * org)> fit_fun;
-    void TrackOffspring(ORG * org) {
-      next_org_id = lineage.AddOrganism(*org, next_parent_id);
-
-    }
-
-    //Put newly injected organism into the lineage tracker
-    void TrackInjectedOffspring(ORG * org) {
-      //std::cout << "Track Injected" << std::endl;
-      next_org_id = lineage.AddOrganism(*org, -1);
-
-    }
-
-    //Keep track of location of all orgs in the population so that
-    //we can translate their ids from the World to ids within the lineage
-    //tracker
-    void TrackPlacement(int pos) {
-      if (pos >= generation_since_update.size()) {
-        generation_since_update.resize(pos+1);
-      }
-      generation_since_update[pos] = next_org_id;
-    }
-
-    //Record the org that's about to have an offspring, so we can know
-    //who the parent of the next org is.
-    void RecordParent(int id) {
-      if (separate_generations){
-        next_parent_id = past_snapshots.back()[id];
-      } else {
-        next_parent_id = generation_since_update[id];
-      }
-    }
 
     //Update callback function handles calculating stats
     void Update(int update) {
@@ -138,11 +82,11 @@ namespace evo{
       if (update % resolution == 0) {
 
         emp::vector<skeleton_type > persist_skeletons = Skeletonize(
-                                              GetPersistLineage(&lineage,
+                                              GetPersistLineage(lineage,
                                               past_snapshots[0],
                                               past_snapshots[generations/resolution]));
         emp::vector<skeleton_type > prev_persist_skeletons = Skeletonize(
-                                              GetPersistLineage(&lineage,
+                                              GetPersistLineage(lineage,
                                               past_snapshots[generations/resolution],
                                               past_snapshots[2*generations/resolution]));
 
@@ -158,17 +102,11 @@ namespace evo{
                                 int nulls = std::count(skel.begin(), skel.end(), -1);
                                 return (double)(skel.size() - nulls);
                               });
-          fittest = MaxFitness(fit_fun, IDsToGenomes(&lineage, past_snapshots[0]));
+          fittest = MaxFitness(fit_fun, IDsToGenomes(lineage, past_snapshots[0]));
         }
         std::cout << "Update: " << update << ", Change: " << change << ", Novelty: " << novelty << ", Ecology: " << ecology << ", Complexity: " << complexity << ", MaxFitness: " << fittest << std::endl;
         past_snapshots.pop_back();
-        past_snapshots.push_front(generation_since_update);
-      }
-
-      if (separate_generations) {
-        //TODO: This isn't sufficient - need to add signals for any
-        //population change event
-        generation_since_update.resize(0);
+        past_snapshots.push_front(lineage->generation_since_update);
       }
     }
 

examples/evo/NK_OEE.cc

@@ -14,10 +14,10 @@
 #include "../../tools/Random.h"
 
 constexpr int K = 3;
-constexpr int N = 20;
+constexpr int N = 10;
 
-constexpr int POP_SIZE = 200;
-constexpr int UD_COUNT = 5000;
+constexpr int POP_SIZE = 20;
+constexpr int UD_COUNT = 500;
 constexpr int TOURNAMENT_SIZE = 15;
 
 using BitOrg = emp::BitSet<N>;
@@ -29,6 +29,8 @@ int main()
   emp::evo::NKLandscapeConst<N,K> landscape(random);
   emp::evo::World<BitOrg> pop(random);
   emp::evo::OEEStatsManager<BitOrg, N> oee_stats(&pop);
+  emp::evo::LineageTracker<BitOrg> lineage(&pop);
+  oee_stats.lineage = &lineage;
 
   // Build a random initial population
   for (int i = 0; i < POP_SIZE; i++) {