Changeset 3632

Timestamp:

02/08/10 11:03:19 (7 months ago)

Author:

dk

Message:

Added neighborhood-based HGT conjugation.

Location:

development/source

Files:

• actions/PopulationActions.cc (modified) (2 diffs)
• main/cPopulationCell.cc (modified) (1 diff)
• main/cPopulationCell.h (modified) (1 diff)
• main/cPopulationInterface.cc (modified) (6 diffs)

development/source/actions/PopulationActions.cc

@@ -4460 +4460 @@
  would be... complications... to runtime changes to an organism's genome...
  */
-class cActionConjugate : public cAction {
+class cActionAvidianConjugation : public cAction {
 public:
         static const cString GetDescription() { return "Arguments: (prob. of donation)"; }
   
         //! Constructor.
-  cActionConjugate(cWorld* world, const cString& args) : cAction(world, args), m_donation_p(-1.0) {
+  cActionAvidianConjugation(cWorld* world, const cString& args) : cAction(world, args), m_donation_p(-1.0) {
                 cString largs(args);
                 if(largs.GetSize()) {
@@ -4688 +4688 @@
         
         action_lib->Register<cActionDiffuseHGTGenomeFragments>("DiffuseHGTGenomeFragments");
+        action_lib->Register<cActionAvidianConjugation>("AvidianConjugation");
         
   // @DMB - The following actions are DEPRECATED aliases - These will be removed in 2.7.

development/source/main/cPopulationCell.cc

@@ -159 +159 @@
 }
 
+/*! Recursively build a set of occupied cells that neighbor this one, out to the given depth.
+*/
+void cPopulationCell::GetOccupiedNeighboringCells(std::set<cPopulationCell*>& occupied_cell_set, int depth) const {
+        // we'll do this the easy way, and just filter the neighbor set.
+        std::set<cPopulationCell*> cell_set;
+        GetNeighboringCells(cell_set, depth);
+        for(std::set<cPopulationCell*>::iterator i=cell_set.begin(); i!=cell_set.end(); ++i) {
+                if((*i)->IsOccupied()) {
+                        occupied_cell_set.insert(*i);
+                }
+        }
+}
+
 /*! These values are chosen so as to make loops on the facing 'easy'.
  111 = NE

development/source/main/cPopulationCell.h

@@ -104 +104 @@
         //! Recursively build a set of cells that neighbor this one, out to the given depth.
   void GetNeighboringCells(std::set<cPopulationCell*>& cell_set, int depth) const;
+        //! Recursively build a set of occupied cells that neighbor this one, out to the given depth.
+  void GetOccupiedNeighboringCells(std::set<cPopulationCell*>& occupied_cell_set, int depth) const;
   inline cPopulationCell& GetCellFaced() { return *(m_connections.GetFirst()); }
   int GetFacing();  // Returns the facing of this cell.

development/source/main/cPopulationInterface.cc

@@ -222 +222 @@
   switch(m_world->GetConfig().NET_STYLE.Get())
   {
-                        case 1: // Receiver Facing
+                case 1: // Receiver Facing
     {
       cOrganism* cur_neighbor = cell.ConnectionList().GetFirst()->GetOrganism();
@@ -228 +228 @@
       if (cur_neighbor != NULL && (msg = cur_neighbor->NetPop()) != NULL) return msg;
     }
-                                break;
-                                
-                        case 0: // Random Next - First Available
-                        default:
+                        break;
+                        
+                case 0: // Random Next - First Available
+                default:
     {
       const int num_neighbors = cell.ConnectionList().GetSize();
@@ -242 +242 @@
       }
     }
-                                break;
+                        break;
   }
   
@@ -648 +648 @@
  */
 void cPopulationInterface::DoHGTDonation(cAvidaContext& ctx) {
+        cPopulationCell* target=0;
+        
         switch(m_world->GetConfig().HGT_CONJUGATION_METHOD.Get()) {
-                        case 0: { // faced individual
-                                cPopulationCell* faced = GetCellFaced();
-                                if(faced->IsOccupied()) {
-                                        fragment_list_type fragments;
-                                        cGenomeUtil::RandomSplit(ctx, 
-                                                                                                                                         m_world->GetConfig().HGT_FRAGMENT_SIZE_MEAN.Get(),
-                                                                                                                                         m_world->GetConfig().HGT_FRAGMENT_SIZE_VARIANCE.Get(),
-                                                                                                                                         GetOrganism()->GetGenome(),
-                                                                                                                                         fragments);
-                                        faced->GetOrganism()->GetOrgInterface().ReceiveHGTDonation(fragments[ctx.GetRandom().GetInt(fragments.size())]);
-                                }
-                                break;
-                        }
-                        default: {
-                                m_world->GetDriver().RaiseFatalException(1, "HGT_CONJUGATION_RECV_METHOD is set to an invalid value.");
-                                break;
-                        }
-        }
+                case 0: { // faced individual
+                        target = GetCellFaced();
+                        if(!target->IsOccupied()) {
+                                // nothing to do, we're facing an empty cell.
+                                return;
+                        }
+                        break;
+                }
+                case 1: { // selected at random from neighborhood
+                        std::set<cPopulationCell*> occupied_cell_set;
+                        GetCell()->GetOccupiedNeighboringCells(occupied_cell_set, 1);
+                        if(occupied_cell_set.size()==0) {
+                                // nothing to do here, there are no neighbors
+                                return;
+                        }
+                        std::set<cPopulationCell*>::iterator selected=occupied_cell_set.begin();
+                        std::advance(selected, ctx.GetRandom().GetInt(occupied_cell_set.size()));
+                        target = *selected;
+                        break;
+                }
+                default: {
+                        m_world->GetDriver().RaiseFatalException(1, "HGT_CONJUGATION_METHOD is set to an invalid value.");
+                        break;
+                }
+        }
+        assert(target != 0);
+        fragment_list_type fragments;
+        cGenomeUtil::RandomSplit(ctx, 
+                                                                                                         m_world->GetConfig().HGT_FRAGMENT_SIZE_MEAN.Get(),
+                                                                                                         m_world->GetConfig().HGT_FRAGMENT_SIZE_VARIANCE.Get(),
+                                                                                                         GetOrganism()->GetGenome(),
+                                                                                                         fragments);
+        target->GetOrganism()->GetOrgInterface().ReceiveHGTDonation(fragments[ctx.GetRandom().GetInt(fragments.size())]);
 }
 
@@ -695 +712 @@
                 // the hgt source controls where the genetic material for HGT comes from.
                 switch(m_world->GetConfig().HGT_SOURCE.Get()) {
-                                case 0: { // source is other genomes, nothing to do here (default)
-                                        break;
-                                }
-                                case 1: { // source is the parent (a control)
-                                        // this is a little hackish, but this is the cleanest way to make sure
-                                        // that all downstream stuff works right.
-                                        cell.ClearFragments();
-                                        cell.AddGenomeFragments(cell.GetOrganism()->GetGenome());
-                                        break;
-                                }
-                                default: { // error
-                                        m_world->GetDriver().RaiseFatalException(1, "HGT_SOURCE is set to an invalid value.");
-                                        break;
-                                }
+                        case 0: { // source is other genomes, nothing to do here (default)
+                                break;
+                        }
+                        case 1: { // source is the parent (a control)
+                                // this is a little hackish, but this is the cleanest way to make sure
+                                // that all downstream stuff works right.
+                                cell.ClearFragments();
+                                cell.AddGenomeFragments(cell.GetOrganism()->GetGenome());
+                                break;
+                        }
+                        default: { // error
+                                m_world->GetDriver().RaiseFatalException(1, "HGT_SOURCE is set to an invalid value.");
+                                break;
+                        }
                 }
                 
@@ -727 +744 @@
                 cGenomeUtil::substring_match location;
                 switch(m_world->GetConfig().HGT_FRAGMENT_SELECTION.Get()) {
-                                case 0: { // random selection
-                                        HGTRandomFragmentSelection(ctx, offspring, i, location);
-                                        break;
-                                }
-                                case 1: { // random selection with redundant instruction trimming
-                                        HGTTrimmedFragmentSelection(ctx, offspring, i, location);
-                                        break;
-                                }
-                                case 2: { // random selection and random placement
-                                        HGTRandomFragmentPlacement(ctx, offspring, i, location);
-                                        break;
-                                }
-                                default: { // error
-                                        m_world->GetDriver().RaiseFatalException(1, "HGT_FRAGMENT_SELECTION is set to an invalid value.");
-                                        break;
-                                }
+                        case 0: { // random selection
+                                HGTRandomFragmentSelection(ctx, offspring, i, location);
+                                break;
+                        }
+                        case 1: { // random selection with redundant instruction trimming
+                                HGTTrimmedFragmentSelection(ctx, offspring, i, location);
+                                break;
+                        }
+                        case 2: { // random selection and random placement
+                                HGTRandomFragmentPlacement(ctx, offspring, i, location);
+                                break;
+                        }
+                        default: { // error
+                                m_world->GetDriver().RaiseFatalException(1, "HGT_FRAGMENT_SELECTION is set to an invalid value.");
+                                break;
+                        }
                 }