Esempio n. 1
0
 def expand_by_selfing(self, pop, recombination_rates):
     """
     Specific for plant populations capable of selfing.
     Creates an F2 subpopulations generation by selfing the individuals of
     'pop'. Works on a population with one or more subpopulations.
     :param pop:
     """
     # self.odd_to_even(pop)
     num_sub_pops = pop.numSubPop()
     progeny_per_individual = int(self.operating_population_size / 2)
     return pop.evolve(
         preOps=[
             sim.MergeSubPops(),
             sim.PyEval(r'"Generation: %d\n" % gen'),
             sim.SplitSubPops(sizes=[1] * num_sub_pops, randomize=False),
         ],
         matingScheme=sim.SelfMating(
             subPopSize=[progeny_per_individual] * num_sub_pops,
             numOffspring=progeny_per_individual,
             ops=[
                 sim.Recombinator(rates=recombination_rates),
                 sim.IdTagger(),
                 sim.PedigreeTagger()
             ],
         ),
         gen=1,
     )
Esempio n. 2
0
 def generate_f_one(self, pop: sim.Population):
     """
     A very basic implementation of the F_1 cross between pairs of individuals. Relies on
     pre-formatting of desired mating pairs into an ordered list.
     [1, 3, 5, 11, 12, 9, 22, 2]
     The mating pattern would be:
     1x3, 5x11, 12x9, 22x2. Rearranging the order of the indices would change the mating
     pairs.
     :param pop:
     :type pop:
     :return:
     :rtype:
     """
     pop.dvars().generations[1] = 'F_1'
     pop.dvars().gen = 1
     pairs_of_founders = int(pop.popSize() / 2)
     self.odd_to_even(pop)
     print("Creating the F_one population from selected founders.")
     return pop.evolve(
         preOps=[
             sim.PyEval(r'"Generation: %d\n" % gen'),
             operators.CalcTripletFrequencies(),
             sim.PyExec('triplet_freq[gen]=tripletFreq'),
             sim.SplitSubPops(sizes=[2] * pairs_of_founders, randomize=False),
         ],
         matingScheme=sim.RandomMating(subPopSize=[1] * pairs_of_founders,
                                       ops=[sim.Recombinator(rates=0.01), sim.IdTagger(), sim.PedigreeTagger()]),
         gen=1,
     )
Esempio n. 3
0
 def _mate_and_merge(self, pop: sim.Population):
     starting_gen = pop.vars()['gen']
     print("Initiating recombinatorial convergence at generation: %d" % pop.dvars().gen)
     while pop.numSubPop() > 1:
         pop.vars()['generations'][pop.vars()['gen']] = 'IG'+str(pop.vars()['gen'] - starting_gen)
         self.pop_halver(pop)
         self.odd_to_even(pop)
         self.pairwise_merge_protocol(pop)
         sub_pop_sizes = list(pop.subPopSizes())
         pop.evolve(
             preOps=[
                 sim.MergeSubPops(),
                 sim.PyEval(r'"Generation: %d\n" % gen'),
                 operators.CalcTripletFreq(),
                 sim.PyExec('triplet_freq[gen]=tripletFreq'),
                 sim.SplitSubPops(sizes=sub_pop_sizes, randomize=False),
             ],
             matingScheme=sim.RandomMating(ops=[sim.Recombinator(rates=0.01),
                                                sim.IdTagger(), sim.PedigreeTagger()]),
             gen=1,
         )
Esempio n. 4
0
 def _generate_f_two(self, pop: sim.Population) -> sim.Population:
     """
     Creates an F2 subpopulations generation by selfing the individuals of 'pop'. Works on a population with one
     or more subpopulations.
     """
     pop.vars()['generations'][2] = 'F_2'
     self.odd_to_even(pop)
     num_sub_pops = pop.numSubPop()
     progeny_per_individual = int(self.selected_population_size/2)
     print("Creating the F_two population.")
     return pop.evolve(
         preOps=[
             sim.MergeSubPops(),
             sim.PyEval(r'"Generation: %d\n" % gen'),
             operators.CalcTripletFreq(),
             sim.PyExec('triplet_freq[gen]=tripletFreq'),
             sim.SplitSubPops(sizes=[1]*num_sub_pops, randomize=False),
         ],
         matingScheme=sim.SelfMating(subPopSize=[progeny_per_individual] * num_sub_pops,
                                     numOffspring=progeny_per_individual,
                                     ops=[sim.Recombinator(rates=0.01), sim.IdTagger(), sim.PedigreeTagger()],
                                     ),
         gen=1,
     )
Esempio n. 5
0
 vec_env = [uniform(-1, 1), uniform(-1, 1)]
 #Creating initial population of size popsize and "caryotype" vecloc
 pop = sim.Population(size=[popsize],
                      loci=vecloc,
                      infoFields=['migrate_to', 'fitness', 'env'],
                      lociNames=allele_naming(numchrom, numloc))
 #--------------------------Main evolving process------------------------
 pop.evolve(
     #Initializing sex and genotype
     initOps=[
         sim.InitSex(),
         sim.InitGenotype(freq=[0.5, 0.5]),
     ],
     preOps=[
         #Splitting each population into two at 'atgen' generations
         sim.SplitSubPops(proportions=[0.5, 0.5], at=atgen),
         #Calling function 'migration' for individuals migration
         #(Operator Migrator does not allow for varying number of subpopulations)
         sim.PyOperator(migration, begin=atgen[0]),
         #Selection process
         #Create new environmental values for new daughter populations
         #Only takes place when fission takes place (atgen)
         sim.PyOperator(env_update, at=atgen),
         #Set environmental value (env infoField) for each individual in the population
         #Takes place at each generation after the first fission
         sim.PyOperator(env_set, begin=atgen[1]),
         #Selection occures at selected loci according to env information field
         sim.PySelector(fit_env, loci=locisel, begin=atgen[1]),
     ],
     #Mating at random (pangamy)
     matingScheme=sim.RandomMating(
Esempio n. 6
0
 print('Simulation number ' + str(k))
 #Creating initial population of size popsize and "caryotype" vecloc
 pop = sim.Population(size=[popsize],
                      loci=vecloc,
                      infoFields=['migrate_to', 'fitness', 'env'],
                      lociNames=allele_naming(numchrom, numloc))
 #--------------------------Main evolving process------------------------
 pop.evolve(
     #Initializing sex and genotype
     initOps=[
         sim.InitSex(),
         sim.InitGenotype(freq=[0.5, 0.5]),
     ],
     preOps=[
         #Fisson of population into 16 at 'atgen' generation
         sim.SplitSubPops(proportions=[0.0625] * 16, at=atgen),
         #Migration using a simple stepping stone model
         sim.Migrator(rate=migrSteppingStoneRates(m, 16, circular=False),
                      begin=atgen),
         #Selection process
         #Set environmental value (env infoField) for each individual in the population
         #Takes place at each generation after the first fission
         sim.PyOperator(env_set, begin=atgen),
         #Selection occures at selected loci according to env information field
         sim.PySelector(fit_env, loci=locisel, begin=atgen),
     ],
     #Mating at random (pangamy)
     matingScheme=sim.RandomMating(
         #Fixed population size (fixed at 'popsize')
         subPopSize=demo,
         #Recombination
Esempio n. 7
0
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#

# This script is an example in the simuPOP user's guide. Please refer to
# the user's guide (http://simupop.sourceforge.net/manual) for a detailed
# description of this example.
#

import simuPOP as sim


def demo(gen, pop):
    if gen < 2:
        return 1000 + 100 * gen
    else:
        return [x + 50 * gen for x in pop.subPopSizes()]


pop = sim.Population(1000)
pop.evolve(preOps=[
    sim.SplitSubPops(subPops=0, proportions=[.5] * 2, at=2),
    sim.Stat(popSize=True),
    sim.PyEval(r'"Gen %d:\t%s\n" % (gen, subPopSize)')
],
           matingScheme=sim.RandomSelection(subPopSize=demo),
           gen=4)
Esempio n. 8
0
def simulate(NA, N1, N2, Tbeforesplit, Taftersplit, r2loci, numLoci, K_sel,
             Mu_sel, S_sel, L_neut, Mu_neut, Nsample1, Nsample2):
    pop = Population(size=NA,
                     ploidy=2,
                     loci=[L_neut + 1],
                     infoFields='fitness')

    def getfitness(geno):
        #  returns fitness of genotype geno at the overdominant locus with selection coeff S_sel
        # geno is (A1 A2)
        if geno[0] == geno[1]:
            return 1 - S_sel  # homozygote
        else:
            return 1  # heterozygote

    if useRPy:
        plotter = VarPlotter(
            'alleleFreq[0][0],alleleFreq[0][1],alleleFreq[0][2],alleleFreq[0][3],alleleFreq[0][4]',
            ylim=[0, 1],
            ylab='allele frequency',
            update=Tbeforesplit + Taftersplit - 1,
            saveAs='slocus.png')
    else:
        plotter = NoneOp()
    g = pop.evolve(
        initOps=[
            InitSex(),
            #initially put 5 alleles at the selected locus with equal frequencies
            InitGenotype(loci=0, freq=[.1] * 10)
            #			InitGenotype(loci=0, freq=[0.01, 0.1, 0.4, 0.2, 0.29])
        ],
        preOps=[
            #Resize the ancestral population at the time immediatly before the split
            sim.ResizeSubPops([0], sizes=[N1 + N2], at=Tbeforesplit - 1),
            # split ancestral population in 3 subpopulations only works if NA>N1+N2
            sim.SplitSubPops(subPops=0, sizes=[N1, N2], at=Tbeforesplit),
            # apply overdominant selection by invoking function getfitness
            PySelector(loci=0, func=getfitness),
        ],
        matingScheme=RandomMating(ops=[
            #apply recombination between the selected locus and the neutral locus at rate r2loci
            Recombinator(rates=r2loci, loci=0),
        ]),
        postOps=[
            # apply mutation to the selected locus according to K allele model
            KAlleleMutator(k=K_sel, rates=[Mu_sel], loci=[0]),
            # apply mutation to the neutral sequence
            SNPMutator(u=Mu_neut, v=0, loci=range(1, L_neut)),
            #Computes the frequency of each allele at selected locus at the last generation
            Stat(alleleFreq=0, step=1),
            #output to the screen the frequency of the 4 first alleles at the selected locus
            PyEval(
                r'"%.0f\t %.3f\t %.3f\t %.3f\t %.3f\t %.3f\n" % (gen, alleleFreq[0][0], alleleFreq[0][1], alleleFreq[0][2], alleleFreq[0][3], alleleFreq[0][4])',
                step=100),
            plotter,
        ],
        # sets the last generation = Tbeforesplit+Taftersplit
        gen=Tbeforesplit + Taftersplit)
    #draw two random samples from species 1 and 2 with size Nsample1 and Nsample2
    sample = drawRandomSample(pop, sizes=[Nsample1, Nsample2])
    #write to file the content of the two random samples
    sim.utils.saveCSV(sample, filename='output.txt')
    return g
Esempio n. 9
0
    def replicate_recurrent_drift(self, multi_pop, meta_sample_library, qtl,
                                  allele_effects, recombination_rates):
        """

        :param multi_pop:
        :param meta_pop_sample_library:
        :param qtl:
        :param allele_effects:
        :param recombination_rates:
        :return:
        """

        for pop in multi_pop.populations():
            pop.dvars().gen = 0

        sizes = [self.individuals_per_breeding_subpop] \
                * self.number_of_breeding_subpops + \
                [self.number_of_nonbreeding_individuals]


        offspring_pops = [self.offspring_per_breeding_subpop] \
                 * self.number_of_breeding_subpops + [0]

        assert len(sizes) == len(offspring_pops), "Number of parental " \
                                          "subpopulations must equal " \
                                          "the number of offspring " \
                                          "subpopulations"

        sampling_generations = [
            i for i in range(2, self.generations_of_drift, 2)
        ]

        pc = breed.HalfSibBulkBalanceChooser(
            self.individuals_per_breeding_subpop, self.offspring_per_female)

        multi_pop.evolve(
            initOps=[
                sim.InitInfo(0, infoFields=['generation']),
                sim.InfoExec('replicate=rep'),
                operators.GenoAdditiveArray(qtl, allele_effects),
                operators.CalculateErrorVariance(self.heritability),
                operators.PhenotypeCalculator(
                    self.proportion_of_individuals_saved),
                operators.ReplicateMetaPopulation(meta_sample_library,
                                                  self.meta_pop_sample_sizes),
                sim.PyEval(r'"Initial: Sampled %d individuals from generation '
                           r'%d Replicate: %d.\n" % (ss, gen_sampled_from, '
                           r'rep)'),
            ],
            preOps=[
                sim.PyEval(r'"Generation: %d\n" % gen'),
                operators.GenoAdditiveArray(qtl, allele_effects, begin=1),
                sim.InfoExec('generation=gen'),
                sim.InfoExec('replicate=rep'),
                operators.PhenotypeCalculator(
                    self.proportion_of_individuals_saved, begin=1),
                operators.ReplicateMetaPopulation(meta_sample_library,
                                                  self.meta_pop_sample_sizes,
                                                  at=sampling_generations),
                sim.SplitSubPops(sizes=sizes, randomize=False),
            ],
            matingScheme=sim.HomoMating(
                sim.PyParentsChooser(pc.recursive_pairwise_parent_chooser),
                sim.OffspringGenerator(ops=[
                    sim.IdTagger(),
                    sim.PedigreeTagger(),
                    sim.Recombinator(rates=recombination_rates)
                ],
                                       numOffspring=1),
                subPopSize=offspring_pops,
                subPops=list(range(1, self.number_of_breeding_subpops, 1))),
            postOps=[
                sim.MergeSubPops(),
                operators.DiscardRandomOffspring(
                    self.number_of_offspring_discarded),
            ],
            finalOps=[
                sim.InfoExec('generation=gen'),
                sim.InfoExec('replicate=rep'),
                operators.GenoAdditiveArray(qtl, allele_effects),
                operators.PhenotypeCalculator(
                    self.proportion_of_individuals_saved),
                operators.ReplicateMetaPopulation(meta_sample_library,
                                                  self.meta_pop_sample_sizes),
                sim.PyEval(
                    r'"Final: Sampled %d individuals from generation %d\n" '
                    r'% (ss, gen_sampled_from)'),
            ],
            gen=self.generations_of_drift)
Esempio n. 10
0
    def recurrent_drift(self, pop, meta_pop, qtl, aes, recombination_rates):
        """
        Sets up and runs recurrent selection for a number of generations for a
        single replicate population. Samples individuals at specified
        intervals to make a ``meta_pop``.
        :param pop: Population which undergoes selection.
        :param meta_pop: Population into which sampled individuals are
        deposited
        :param qtl: List of loci to which allele effects have been assigned
        :param aes: Dictionary of allele effects
        """
        pop.dvars().gen = 0
        meta_pop.dvars().gen = 0

        sizes = [self.individuals_per_breeding_subpop] \
                * self.number_of_breeding_subpops + \
                [self.number_of_nonbreeding_individuals]
        offspring_pops = [self.offspring_per_breeding_subpop] \
                         * self.number_of_breeding_subpops + [0]

        assert len(sizes) == len(offspring_pops), "Number of parental " \
                                                  "subpopulations must equal " \
                                                  "the number of offspring " \
                                                  "subpopulations"

        sampling_generations = [
            i for i in range(2, self.generations_of_drift, 2)
        ]

        pc = breed.HalfSibBulkBalanceChooser(
            self.individuals_per_breeding_subpop, self.offspring_per_female)

        pop.evolve(
            initOps=[
                sim.InitInfo(0, infoFields=['generation']),
                operators.GenoAdditiveArray(qtl, aes),
                operators.CalculateErrorVariance(self.heritability),
                operators.PhenotypeCalculator(
                    self.proportion_of_individuals_saved),
                operators.MetaPopulation(meta_pop, self.meta_pop_sample_sizes),
                sim.PyEval(r'"Initial: Sampled %d individuals from generation '
                           r'%d Replicate: %d.\n" % (ss, gen_sampled_from, '
                           r'rep)'),
            ],
            preOps=[
                sim.PyEval(r'"Generation: %d\n" % gen'),
                operators.GenoAdditiveArray(qtl, aes, begin=1),
                sim.InfoExec('generation=gen'),
                operators.PhenotypeCalculator(
                    self.proportion_of_individuals_saved, begin=1),
                operators.MetaPopulation(meta_pop,
                                         self.meta_pop_sample_sizes,
                                         at=sampling_generations),
                sim.SplitSubPops(sizes=sizes, randomize=True),
            ],
            matingScheme=sim.HomoMating(
                sim.PyParentsChooser(pc.recursive_pairwise_parent_chooser),
                sim.OffspringGenerator(ops=[
                    sim.IdTagger(),
                    sim.PedigreeTagger(),
                    sim.Recombinator(rates=recombination_rates)
                ],
                                       numOffspring=1),
                subPopSize=offspring_pops,
                subPops=list(range(1, self.number_of_breeding_subpops, 1))),
            postOps=[
                sim.MergeSubPops(),
                operators.DiscardRandomOffspring(
                    self.number_of_offspring_discarded),
            ],
            finalOps=[
                sim.InfoExec('generation=gen'),
                operators.GenoAdditive(qtl, aes),
                operators.PhenotypeCalculator(
                    self.proportion_of_individuals_saved),
                operators.MetaPopulation(meta_pop, self.meta_pop_sample_sizes),
                sim.PyEval(
                    r'"Final: Sampled %d individuals from generation %d\n" '
                    r'% (ss, gen_sampled_from)'),
            ],
            gen=self.generations_of_drift)
Esempio n. 11
0
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#

# This script is an example in the simuPOP user's guide. Please refer to
# the user's guide (http://simupop.sourceforge.net/manual) for a detailed
# description of this example.
#

import simuPOP as sim

pop = sim.Population(1000)
pop.evolve(preOps=[
    sim.SplitSubPops(subPops=0, sizes=[300, 300, 400], at=2),
    sim.Stat(popSize=True),
    sim.PyEval(r'"Gen %d:\t%s\n" % (gen, subPopSize)')
],
           matingScheme=sim.RandomSelection(),
           gen=4)