rc = RecombCollector(first_gen=pop.indInfo("ind_id"),
                     ancestor_age=args.ancestor_age,
                     length=args.length,
                     locus_position=locus_position)

migr_mat = [[0, args.m, 0], [args.m, 0, args.m], [0, args.m, 0]]

pop.evolve(initOps=[
    sim.InitSex(),
] + init_geno,
           preOps=[
               sim.PyOperator(lambda pop: rc.increment_time() or True),
               sim.Migrator(rate=migr_mat, mode=sim.BY_PROBABILITY),
               sim.SNPMutator(u=args.sel_mut_rate, v=args.sel_mut_rate),
               sim.PyMlSelector(fitness.AB,
                                subPops=fitness.AB_subpops,
                                output=">>" + selloci_file),
               sim.PyMlSelector(fitness.Ab,
                                subPops=fitness.Ab_subpops,
                                output=">>" + selloci_file),
               sim.PyMlSelector(fitness.ab,
                                subPops=fitness.ab_subpops,
                                output=">>" + selloci_file),
           ],
           matingScheme=sim.RandomMating(ops=[
               id_tagger,
               sim.Recombinator(intensity=args.recomb_rate,
                                output=rc.collect_recombs,
                                infoFields="ind_id"),
           ]),
           postOps=[
                     ancestor_age=args.ancestor_age,
                     length=2 * args.length,
                     locus_position=locus_position +
                     [args.length, 2 * args.length])

migr_mat = [[0, args.m, 0], [args.m, 0, args.M], [0, args.M, 0]]

pop.evolve(initOps=[
    sim.InitSex(),
] + init_geno,
           preOps=[
               sim.PyOperator(lambda pop: rc.increment_time() or True),
               sim.Migrator(rate=migr_mat, mode=sim.BY_PROBABILITY),
               sim.SNPMutator(u=args.sel_mut_rate, v=args.sel_mut_rate),
               sim.PyMlSelector(fitness.left,
                                subPops=fitness.left_subpops,
                                output=">>" + selloci_file),
               sim.PyMlSelector(fitness.right,
                                subPops=fitness.right_subpops,
                                output=">>" + selloci_file),
           ],
           matingScheme=sim.RandomMating(ops=[
               id_tagger,
               sim.Recombinator(intensity=args.recomb_rate,
                                output=rc.collect_recombs,
                                infoFields="ind_id"),
           ]),
           postOps=[
               sim.Stat(numOfSegSites=sim.ALL_AVAIL, step=50),
               sim.PyEval(
                   r"'Gen: %2d #seg sites: %d\n' % (gen, numOfSegSites)",
Exemple #3
0
        args.migr, n=max(args.gridwidth,args.gridheight), circular=False)
else:
    migr_rates=migr2DSteppingStoneRates(
        args.migr, m=args.gridwidth, n=args.gridheight, diagonal=False, circular=False)

pop.evolve(
    initOps=[
        sim.InitSex(),
    ]+init_geno,
    preOps=[
        sim.PyOperator(lambda pop: rc.increment_time() or True),
        sim.Migrator(
            rate=migr_rates,
            mode=sim.BY_PROBABILITY),
        sim.SNPMutator(u=args.sel_mut_rate, v=args.sel_mut_rate),
        sim.PyMlSelector(GammaDistributedFitness(args.gamma_alpha, args.gamma_beta),
            output=">>"+selloci_file),
    ],
    matingScheme=sim.RandomMating(
        ops=[
            id_tagger,
            sim.Recombinator(intensity=args.recomb_rate,
                output=rc.collect_recombs,
                infoFields="ind_id"),
        ] ),
    postOps=[
        sim.Stat(numOfSegSites=sim.ALL_AVAIL, step=50),
        sim.PyEval(r"'Gen: %2d #seg sites: %d\n' % (gen, numOfSegSites)", step=50),
        sim.PyOperator(lambda pop: rc.simplify(pop.indInfo("ind_id")) or True, 
                       step=args.simplify_interval),
    ],
    gen = args.generations
        loci=[nloci], 
        lociPos=locus_position,
        infoFields=['ind_id','fitness','migrate_to'])

pop.evolve(
    initOps=[
        sim.InitSex(),
        sim.IdTagger(),
    ]+init_geno,
    preOps=[
        sim.Migrator(
            rate=migr2DSteppingStoneRates(
                migr, m=width, n=width, diagonal=False, circular=False),
            mode=sim.BY_PROBABILITY),
        sim.AcgtMutator(rate=[mut_rate], model='JC69'),
        sim.PyMlSelector(GammaDistributedFitness(alpha, beta),
            output='>>'+selloci_file),
    ],
    matingScheme=sim.RandomMating(
        ops=[
            sim.IdTagger(),
            sim.Recombinator(intensity=recomb_rate,
                output=outfile,
                infoFields="ind_id"),
        ] ),
    postOps=[
        sim.Stat(numOfSegSites=sim.ALL_AVAIL, step=50),
        sim.PyEval(r"'Gen: %2d #seg sites: %d\n' % (gen, numOfSegSites)", step=50)
    ],
    gen = generations
)
Exemple #5
0
         rate=migr_rates,
         mode=sim.BY_PROBABILITY,
         begin=0, 
         end=args.pre_generations),
     sim.Migrator(
         rate=barrier_rates,
         mode=sim.BY_PROBABILITY,
         begin=1 + args.pre_generations, 
         end=args.split_generations + args.pre_generations),
     sim.Migrator(
         rate=migr_rates,
         mode=sim.BY_PROBABILITY,
         begin=1 + args.split_generations + args.pre_generations,
         end=args.split_generations + args.pre_generations + args.post_generations),
     sim.SNPMutator(u=args.sel_mut_rate, v=args.sel_mut_rate),
     sim.PyMlSelector(fitness_fun,
         output=">>"+selloci_file),
 ],
 matingScheme=sim.RandomMating(
     ops=[
         id_tagger,
         sim.Recombinator(intensity=args.recomb_rate,
             output=rc.collect_recombs,
             infoFields="ind_id"),
     ] ),
 postOps=[
     sim.Stat(numOfSegSites=sim.ALL_AVAIL, step=50),
     sim.PyEval(r"'Gen: %2d #seg sites: %d\n' % (gen, numOfSegSites)", step=50),
     sim.PyOperator(lambda pop: rc.simplify(pop.indInfo("ind_id")) or True, 
                    step=args.simplify_interval),
 ],
 gen = args.split_generations + args.pre_generations + args.post_generations
pop = sim.Population(
        size=args.popsize,
        loci=[args.nloci], 
        lociPos=locus_position,
        infoFields=['ind_id','fitness','migrate_to'])


pop.evolve(
    initOps=[
        sim.InitSex(),
        sim.IdTagger(),
    ]+init_geno,
    preOps=[
        sim.SNPMutator(u=args.sel_mut_rate, v=args.sel_mut_rate),
        sim.PyMlSelector(FixedFitness(args.selection_coef),
            output=">>"+args.selloci_file),
    ],
    matingScheme=sim.RandomMating(
        ops=[
            sim.IdTagger(),
            sim.Recombinator(intensity=args.recomb_rate,
                output=">>" + args.treefile,
                infoFields="ind_id"),
        ] ),
    postOps=[
        sim.Stat(numOfSegSites=sim.ALL_AVAIL, step=10),
        sim.PyEval(r"'Gen: %2d #seg sites: %d\n' % (gen, numOfSegSites)", step=50)
    ],
    gen = args.generations
)
Exemple #7
0
    ]
    post_ops += [
        sim.PyOperator(lambda pop: rc.simplify(pop.indInfo("ind_id")) or True,
                       step=args.simplify_interval)
    ]
pop.evolve(
    initOps=[
        sim.InitSex(),
    ] + init_geno,
    preOps=pre_ops + [
        sim.SNPMutator(u=args.sel_mut_rate, v=args.sel_mut_rate),
        #                   loci=selected_loci),
        # so that selector returns, for f_i fitness values, \prod_i f_i
        sim.PyMlSelector(GammaDistributedFitness(shape=args.gamma_shape,
                                                 scale=args.gamma_scale,
                                                 popsize=args.popsize),
                         mode=sim.MULTIPLICATIVE,
                         loci=selected_loci),
    ],
    matingScheme=sim.RandomMating(ops=mating_ops),
    postOps=post_ops,
    gen=args.generations)

tsim = time.process_time() - before_time

logfile.write("Done simulating!\n")
logfile.write(time.strftime('%X %x %Z') + "\n")
logfile.write("----------\n")
logfile.flush()

logfile.write("Collecting samples:\n")
            s = self.coefMap[loc]
        else:
            s = random.gammavariate(self.alpha, self.beta)
            self.coefMap[loc] = s
        # print(str(loc)+":"+str(alleles)+"\n")
        # needn't return fitness for alleles=(0,0) as simupop knows that's 1
        if 0 in alleles:
            return 1. - s
        else:
            return 1. - 2. * s


simu.evolve(initOps=[sim.InitSex(), meioser] + init_geno,
            preOps=[
                sim.AcgtMutator(rate=[0.0001], model='JC69'),
                sim.PyMlSelector(GammaDistributedFitness(alpha, beta),
                                 output='>>sel_loci.txt'),
                sim.PyOperator(func=step_gen, param=(1, )),
            ],
            matingScheme=reproduction,
            postOps=[
                sim.Stat(numOfSegSites=sim.ALL_AVAIL, step=50),
                sim.PyEval(
                    r"'Gen: %2d #seg sites: %d\n' % (gen, numOfSegSites)",
                    step=50)
            ],
            gen=generations)

pop = simu.population(0)

pop_ids = [ind.info('ind_id') for ind in pop.individuals()]
Exemple #9
0
        # because s is assigned for each locus, we need to make sure the
        # same s is used for fitness of genotypes 01 (1-s) and 11 (1-2s)
        # at each locus
        if loc in self.coefMap:
            s = self.coefMap[loc]
        else:
            s = random.gammavariate(self.alpha, self.beta)
            self.coefMap[loc] = s
        #
        if 0 in alleles:
            return 1. - s
        else:
            return 1. - 2. * s


pop.evolve(initOps=sim.InitSex(),
           preOps=[
               sim.AcgtMutator(rate=[0.00001], model='JC69'),
               sim.PyMlSelector(GammaDistributedFitness(0.23, 0.185),
                                output='>>sel.txt'),
           ],
           matingScheme=sim.RandomMating(),
           postOps=[
               sim.Stat(numOfSegSites=sim.ALL_AVAIL, step=50),
               sim.PyEval(
                   r"'Gen: %2d #seg sites: %d\n' % (gen, numOfSegSites)",
                   step=50)
           ],
           gen=201)
print(''.join(open('sel.txt').readlines()[:5]))