def runsim(args): rng = fwdpy11.GSLrng(args.seed) pdict = {'gvalue': fwdpy11.Multiplicative(FITNESS_SCALING), 'rates': (0., args.mu, None), 'nregions': [], 'sregions': [fwdpy11.GammaS(0., GENOME_LENGTH, 1.0-args.proportion, args.mean, args.shape, FITNESS_SCALING/2.0, scaling=2*args.popsize, label=1), fwdpy11.ConstantS(0, GENOME_LENGTH, args.proportion, TWONS, FITNESS_SCALING/2.0, label=2, scaling=2*args.popsize)], 'recregions': [fwdpy11.PoissonInterval(0, GENOME_LENGTH, args.recrate)], 'demography': np.array([args.popsize]*SIMLEN*args.popsize, dtype=np.uint32), # This could easily be True for these sims: 'prune_selected': False } params = fwdpy11.ModelParams(**pdict) pop = fwdpy11.DiploidPopulation(args.popsize, GENOME_LENGTH) sampler = fwdpy11.RandomAncientSamples( args.seed, args.popsize, [i for i in range(10*pop.N, SIMLEN*pop.N)]) # With a lot of ancient samples: # 1. RAM use already skyrockets # 2. Simplification slows down # So, we should do it a little less often: fwdpy11.evolvets(rng, pop, params, 1000, sampler, suppress_table_indexing=True) return pop
def set_up_standard_pop_gen_model(): """ For this sort of model, when mutations fix, they are removed from the simulation, INCLUDING THE TREE SEQUENCES. The fact of their existence gets recorded in pop.fixations and pop.fixation_times """ # TODO add neutral variants N = 1000 demography = np.array([N] * 10 * N, dtype=np.uint32) rho = 1. # theta = 100. # nreps = 500 # mu = theta/(4*N) r = rho / (4 * N) a = fwdpy11.Multiplicative(2.0) pselected = 1e-3 p = { 'nregions': [], 'sregions': [ fwdpy11.GammaS(0, 1, 1. - pselected, mean=-5, shape=1, scaling=2 * N), fwdpy11.ConstantS(0, 1, pselected, 1000, scaling=2 * N) ], 'recregions': [fwdpy11.Region(0, 1, 1)], 'rates': (0.0, 0.001, r), 'gvalue': a, 'prune_selected': True, 'demography': demography } params = fwdpy11.ModelParams(**p) rng = fwdpy11.GSLrng(666**2) pop = fwdpy11.DiploidPopulation(N, 1.0) return params, rng, pop
set_gen = (10 * Nstart) + 200 # adjust generation labels without burnin and start rec1 = neutral_div(set_gen, final=pop2.generation + len(demog) + 200, Nstart=Nstart) print("evolving from here") wf.evolve(rng2, pop2, params, rec1) print('Generation', pop2.generation) # write output write_output(rec1, out_path, 'neutral', replicate) ################## simulate BGS ############################ recregion =[fp11.Region(0,55,1., coupled=True)] sregion = [fp11.GammaS(0, 50, 1., -0.029426, 0.184, h=1.0, coupled=True)] +\ [fp11.GammaS(0, 50, 2., -0.000518, 0.0415, h=1.0, coupled=True)] # conserved non-coding DFE 2/3 of sel mutations in this region nregion = [fp11.Region(50, 55, 1., coupled=True)] # Mutation rate rec = 8.2e-10 * 40000 * 55 mu_s = mu * 40000 * 50 * 0.2 mu_n = mu * 40000 * 5 rates = [mu_n, mu_s, rec] # constant size for 10 N generations
if __name__ == "__main__": parser = parse_args() args = parser.parse_args(sys.argv[1:]) pop = fp11.SlocusPop(args.popsize) # Set up parameters with defaults recrate = args.rho / (4.0 * float(args.popsize)) mutrate_n = args.theta / (4.0 * float(args.popsize)) mutrate_s = args.pdel * mutrate_n pdict = {'rates': (mutrate_n, mutrate_s, recrate), 'nregions': [fp11.Region(0, 1, 1)], # The below is equivelent to R's -1*rgamma(1,shape=1.0,scale=5.0) # The scaling of 2N means that the DFE is with respect to 2Ns 'sregions': [fp11.GammaS(0, 1, 1, h=0.5, mean=-5.0, shape=1.0, scaling=2 * args.popsize)], 'recregions': [fp11.Region(0, 1, 1)], 'gvalue': fwdpy11.fitness.SlocusMult(1.0), 'demography': np.array([args.popsize] * args.simlen * args.popsize, dtype=np.uint32) } params = fwdpy11.model_params.SlocusParams(**pdict) # Adjust params based on user input if args.neutral is True: params.mutrate_s = 0.0 params.sregions = [] if args.neutral_mutations is False: params.mutrate_n = 0.0 params.nregions = []
def setUp(self): self.r = fwdpy11.GammaS(BEG, END, WEIGHT, -0.2, 0.5, DOM, COUPLED, LABEL)
def testBadDominance(self): with self.assertRaises(ValueError): fwdpy11.GammaS(0, 1, 1, mean=1., shape=1., h=np.nan)
def testBadMean(self): with self.assertRaises(ValueError): fwdpy11.GammaS(0, 1, 1, mean=np.nan, shape=1.0)
def runsim(args): args, repid, repseed = args rng = fwdpy11.GSLrng(repseed) locus_boundaries = [(float(i + i * 11), float(i + i * 11 + 11)) for i in range(args.nloci)] NANC = args.N # In revision, change from using gamma_hat # to (2Ngamma^2)/(2VS) >= 100. # Keep the variable name to minimize # the refactoring... # ghat = gamma_hat(1.0, args.mu) ghat = np.sqrt(100. / 5000.) sregions = None if args.gamma is None: F = generate_gaussian_function_to_minimize(ghat, args.plarge) sigma_gamma = get_gaussian_sigma(F) sregions = [[ fwdpy11.GaussianS(j[0] + 5., j[0] + 6., args.mu, sigma_gamma, coupled=False) ] for i, j in zip(range(args.nloci), locus_boundaries)] else: # Get a shape param for the gamma res = scipy.optimize.minimize_scalar(minimize_gamma_cdf, bounds=(0, 100), method='bounded', args=(args.gamma, ghat, args.plarge)) sregions = [[ fwdpy11.GammaS(j[0] + 5., j[0] + 6., args.mu, -1.0 * res.x, args.gamma, coupled=False), fwdpy11.GammaS(j[0] + 5., j[0] + 6., args.mu, res.x, args.gamma, coupled=False) ] for i, j in zip(range(args.nloci), locus_boundaries)] print(sregions) nregions = [[ fwdpy11.Region(j[0], j[1], args.theta / (4. * float(NANC)), coupled=True) ] for i, j in zip(range(args.nloci), locus_boundaries)] recregions = [[ fwdpy11.Region(j[0], j[1], args.rho / (4. * float(NANC)), coupled=True) ] for i, j in zip(range(args.nloci), locus_boundaries)] interlocus_rec = fwdpy11.multilocus.binomial_rec([0.5] * (args.nloci - 1)) nlist = np.array([NANC] * 15 * NANC, dtype=np.uint32) env = [(0, 0, 1), (10 * NANC, args.opt, 1)] mutrates_s = [args.mu / float(args.nloci)] * args.nloci mutrates_n = [10 * args.theta / float(4 * NANC)] * args.nloci recrates = [10 * args.rho / float(4 * NANC)] * args.nloci gssmo = fwdpy11.genetic_values.GSSmo(env) gv = fwdpy11.genetic_values.MlocusAdditive(2.0, gssmo) pdict = { 'nregions': nregions, 'sregions': sregions, 'recregions': recregions, 'demography': nlist, 'interlocus_rec': interlocus_rec, 'gvalue': gv, 'rates': (mutrates_n, mutrates_s, recrates), 'prune_selected': False } params = fwdpy11.model_params.ModelParams(**pdict) pop = fwdpy11.MlocusPop(args.nloci, locus_boundaries) sampler = Sampler(rng, args.nsam) fwdpy11.wright_fisher.evolve(rng, pop, params, sampler) sampler.rng = None # Cannot be pickled and is not needed return repid, pop, sampler