Changeset 3638

Timestamp:

02/10/10 16:09:19 (7 months ago)

Author:

dk

Message:

Added option to scramble HGT fragments prior to insertion or replacement.

Location:

development/source/main

Files:

• cAvidaConfig.h (modified) (1 diff)
• cGenomeUtil.cc (modified) (2 diffs)
• cGenomeUtil.h (modified) (1 diff)
• cPopulationInterface.cc (modified) (7 diffs)
• cPopulationInterface.h (modified) (1 diff)

development/source/main/cAvidaConfig.h

@@ -677 +677 @@
         CONFIG_ADD_VAR(HGT_INSERTION_MUT_P, double, 0.5, "Probability that an HGT mutation will result in an insertion (default=0.5); replacement if false.");
         CONFIG_ADD_VAR(HGT_CONJUGATION_METHOD, int, 0, "Method used to select the receiver of an HGT conjugation (0=faced [default])");
+        CONFIG_ADD_VAR(HGT_SCRAMBLE_FRAGMENT, int, 0, "Scramble each fragment after match, prior to insertion or replacment; 0=false [default], 1=true.");
         
   CONFIG_ADD_GROUP(INST_RES_GROUP, "Resource-Dependent Instructions Settings");

development/source/main/cGenomeUtil.cc

@@ -384 +384 @@
 }
 
+
+/*! Split a genome into a list of fragments, each with the given mean size and variance, and add them to the given fragment list.
+ */
 void cGenomeUtil::RandomSplit(cAvidaContext& ctx, double mean, double variance, const cGenome& genome, fragment_list_type& fragments) { 
         // rotate this genome to remove bais for the beginning and end of the genome:
@@ -405 +408 @@
 
 
+/*! Randomly shuffle the instructions within genome in-place.
+ */
+void cGenomeUtil::RandomShuffle(cAvidaContext& ctx, cGenome& genome) {
+        std::vector<int> idx(static_cast<std::size_t>(genome.GetSize()));
+        iota(idx.begin(), idx.end(), 0);
+        cRandomStdAdaptor rng(ctx.GetRandom());
+        std::random_shuffle(idx.begin(), idx.end(), rng);
+        cGenome shuffled(genome.GetSize());
+        for(int i=0; i<genome.GetSize(); ++i) {
+                shuffled[i] = genome[idx[i]];
+        }
+        genome = shuffled;
+}
+
 cGenome cGenomeUtil::Crop(const cGenome & in_genome, int start, int end)
 {

development/source/main/cGenomeUtil.h

@@ -103 +103 @@
         //! Split a genome into a list of fragments, each with the given mean size and variance, and add them to the given fragment list.
         static void RandomSplit(cAvidaContext& ctx, double mean, double variance, const cGenome& genome, fragment_list_type& fragments);
+        //! Randomly shuffle the instructions within genome in-place.
+        static void RandomShuffle(cAvidaContext& ctx, cGenome& genome);
         
   // ===== Construction methods =====

development/source/main/cPopulationInterface.cc

@@ -703 +703 @@
         fragment_list_type fragments(m_hgt_support->_pending); // these come from conjugation
         
-        // these come from natural competence (ie, eating the dead):
+        // these come from "natural" competence (ie, eating the dead):
         if((m_world->GetConfig().HGT_MUTATION_P.Get() > 0.0)
                  && (ctx.GetRandom().P(m_world->GetConfig().HGT_MUTATION_P.Get()))) {
@@ -745 +745 @@
                 switch(m_world->GetConfig().HGT_FRAGMENT_SELECTION.Get()) {
                         case 0: { // random selection
-                                HGTRandomFragmentSelection(ctx, offspring, i, location);
+                                HGTMatchPlacement(ctx, offspring, i, location);
                                 break;
                         }
                         case 1: { // random selection with redundant instruction trimming
-                                HGTTrimmedFragmentSelection(ctx, offspring, i, location);
+                                HGTTrimmedPlacement(ctx, offspring, i, location);
                                 break;
                         }
                         case 2: { // random selection and random placement
-                                HGTRandomFragmentPlacement(ctx, offspring, i, location);
+                                HGTRandomPlacement(ctx, offspring, i, location);
                                 break;
                         }
@@ -760 +760 @@
                                 break;
                         }
+                }
+                
+                // as a type of control, potentially "scramble" the genome after matching
+                // and prior to insertion to see if the fragment is contributing useful code.           
+                if(m_world->GetConfig().HGT_SCRAMBLE_FRAGMENT.Get()) {
+                        cGenomeUtil::RandomShuffle(ctx, *i);
                 }
                 
@@ -779 +785 @@
 
 
-/*! Randomly select the fragment used for HGT mutation.
- */
-void cPopulationInterface::HGTRandomFragmentSelection(cAvidaContext& ctx, const cGenome& offspring,
-                                                                                                                                                                                                                        fragment_list_type::iterator& selected,
-                                                                                                                                                                                                                        substring_match& location) {
+/*! Place the fragment at the location of best match.
+ */
+void cPopulationInterface::HGTMatchPlacement(cAvidaContext& ctx, const cGenome& offspring,
+                                                                                                                                                                                 fragment_list_type::iterator& selected,
+                                                                                                                                                                                 substring_match& location) {
         // find the location within the offspring's genome that best matches the selected fragment:
         location = cGenomeUtil::FindUnbiasedCircularMatch(ctx, offspring, *selected);
@@ -789 +795 @@
 
 
-/*! Randomly select the fragment used for HGT mutation, trimming redundant instructions.
- 
- In this fragment selection method, the fragment itself is selected randomly, but the
+/*! Place the fragment at the location of best match, with redundant instructions trimmed.
+
+ In this fragment selection method, the
  match location within the genome is calculated on a "trimmed" fragment.  Specifically,
  the trimmed fragment has all duplicate instructions at its end removed prior to the match.
@@ -798 +804 @@
  increases the insertion rate.  E.g., hgt(abcde, abcccc) -> abccccde.
  */
-void cPopulationInterface::HGTTrimmedFragmentSelection(cAvidaContext& ctx, const cGenome& offspring,
+void cPopulationInterface::HGTTrimmedPlacement(cAvidaContext& ctx, const cGenome& offspring,
                                                                                                                                                                                                                          fragment_list_type::iterator& selected,
                                                                                                                                                                                                                          substring_match& location) {
@@ -812 +818 @@
 
 
-/*! Random selection of the fragment used for HGT mutation, located at a random position.
+/*! Place the fragment at a random location.
  
- Here we select a random fragment and a random location for that fragment within the offspring.
+ Here we select a random location for the fragment within the offspring.
  The beginning of the fragment location is selected at random, while the end is selected a
  random distance (up to the length of the selected fragment * 2) instructions away.
  */
-void cPopulationInterface::HGTRandomFragmentPlacement(cAvidaContext& ctx, const cGenome& offspring,
+void cPopulationInterface::HGTRandomPlacement(cAvidaContext& ctx, const cGenome& offspring,
                                                                                                                                                                                                                         fragment_list_type::iterator& selected,
                                                                                                                                                                                                                         substring_match& location) {

development/source/main/cPopulationInterface.h

@@ -157 +157 @@
         
 protected:
-        //! Random selection of the fragment used for HGT mutation, located at the best match.
-        void HGTRandomFragmentSelection(cAvidaContext& ctx, const cGenome& offspring,
-                                                                                                                                        fragment_list_type::iterator& selected,
-                                                                                                                                        substring_match& location);
-        //! Random selection of the fragment used for HGT mutation, with redundant instructions trimmed.
-        void HGTTrimmedFragmentSelection(cAvidaContext& ctx, const cGenome& offspring,
-                                                                                                                                         fragment_list_type::iterator& selected,
-                                                                                                                                         substring_match& location);    
-        //! Random selection of the fragment used for HGT mutation, located at a random position.
-        void HGTRandomFragmentPlacement(cAvidaContext& ctx, const cGenome& offspring,
-                                                                                                                                        fragment_list_type::iterator& selected,
-                                                                                                                                        substring_match& location);
+        //! Place the fragment at the location of best match.
+        void HGTMatchPlacement(cAvidaContext& ctx, const cGenome& offspring,
+                                                                                                 fragment_list_type::iterator& selected,
+                                                                                                 substring_match& location);
+        //! Place the fragment at the location of best match, with redundant instructions trimmed.
+        void HGTTrimmedPlacement(cAvidaContext& ctx, const cGenome& offspring,
+                                                                                                         fragment_list_type::iterator& selected,
+                                                                                                         substring_match& location);    
+        //! Place the fragment at a random location.
+        void HGTRandomPlacement(cAvidaContext& ctx, const cGenome& offspring,
+                                                                                                        fragment_list_type::iterator& selected,
+                                                                                                        substring_match& location);
         //! Support for stateful HGT mutations.
         struct HGTSupport {