def evolve_track_wrapper(popsize=1000,
rho=10000.0,
mu=1e-2,
seed=42,
gc_interval=10,
dfe=fwdpy11.ConstantS(0, 1, 1, -0.025, 1.0)):
if isinstance(dfe, fwdpy11.Sregion) is False:
raise TypeError("dfe must be a fwdpy11.Sregion")
if dfe.b != 0.0 or dfe.e != 1.0:
raise ValueError("DFE beg/end must be 0.0/1.0, repsectively")
pop = fwdpy11.SlocusPop(popsize)
recrate = float(rho) / (4.0 * float(popsize))
pdict = {
'rates': (0.0, mu, recrate),
'nregions': [],
'sregions': [dfe],
'recregions': [fwdpy11.Region(0, 1, 1)],
'gvalue': fwdpy11.fitness.SlocusMult(2.0),
'demography': np.array([popsize] * 10 * popsize, dtype=np.uint32)
}
params = fwdpy11.model_params.SlocusParams(**pdict)
rng = fwdpy11.GSLrng(seed)
ancestry = evolve_track(rng, pop, params, gc_interval)
return (pop, ancestry)
def set_up_quant_trait_model():
N = 1000
demography = np.array([N] * 10 * N, dtype=np.uint32)
rho = 1000.
r = rho / (4 * N)
timepoints = np.array([0], dtype=np.uint32)
ntraits = 4
optima = np.array(np.zeros(len(timepoints) * ntraits))
optima = optima.reshape((len(timepoints), ntraits))
GSSmo = fwdpy11.MultivariateGSSmo(timepoints, optima, 1)
cmat = np.identity(ntraits)
np.fill_diagonal(cmat, 0.1)
a = fwdpy11.StrictAdditiveMultivariateEffects(ntraits, 0, GSSmo)
p = {
'nregions': [],
'sregions': [fwdpy11.MultivariateGaussianEffects(0, 1, 1, cmat)],
'recregions': [fwdpy11.Region(0, 1, 1)],
'rates': (0.0, 0.001, r),
'gvalue': a,
'prune_selected': False,
'demography': demography
}
params = fwdpy11.ModelParams(**p)
rng = fwdpy11.GSLrng(101 * 45 * 110 * 210)
pop = fwdpy11.DiploidPopulation(N, 1.0)
return params, rng, pop, ntraits
def runsim(args):
popsizes = np.array([args.popsize] * 20 * args.popsize, dtype=np.int32)
pop = fwdpy11.DiploidPopulation(args.popsize, 1.0)
sregions = [fwdpy11.GaussianS(0, 1, 1, args.sigma)]
recregions = [fwdpy11.PoissonInterval(0, 1, args.recrate)]
optima = fwdpy11.GSSmo([(0, 0, args.VS),
(10 * args.popsize, args.opt, args.VS)])
p = {
'nregions': [], # No neutral mutations -- add them later!
'gvalue': fwdpy11.Additive(2.0, optima),
'sregions': sregions,
'recregions': recregions,
'rates': (0.0, args.mu, None),
# Keep mutations at frequency 1 in the pop if they affect fitness.
'prune_selected': False,
'demography': np.array(popsizes, dtype=np.uint32)
}
params = fwdpy11.ModelParams(**p)
rng = fwdpy11.GSLrng(args.seed)
s = Recorder(args.popsize)
fwdpy11.evolvets(rng,
pop,
params,
100,
s,
suppress_table_indexing=True,
track_mutation_counts=True)
return pop
def evolve_and_return(args):
"""
This function runs our simulation.
The input arguments come in a tuple,
which is required by many of Python's
functions for execution in separate processes.
For this function, the arguments are the population
size and a random number seed.
"""
from fwdpy11 import Multiplicative
N, seed = args
# Construct as single-deme object
# with N diploids
pop = fp11.DiploidPopulation(N)
theta = 100.0
# Initialize a random number generator
rng = fp11.GSLrng(seed)
p = fp11ez.mslike(pop,
simlen=100,
rates=(theta / float(4 * pop.N), 1e-3,
theta / float(4 * pop.N)))
p['gvalue'] = Multiplicative(2.)
params = fp11.ModelParams(**p)
fp11.evolve_genomes(rng, pop, params)
# The population is picklable, and so
# we can return it from another process
return pop
def testPopGenSim(self):
N = 1000
demography = np.array([N] * 10 * N, dtype=np.uint32)
rho = 1.
r = rho / (4 * N)
a = fwdpy11.Multiplicative(2.0)
p = {
'nregions': [],
'sregions': [fwdpy11.ExpS(0, 1, 1, 0.01)],
'recregions': [fwdpy11.Region(0, 1, 1)],
'rates': (0.0, 0.00005, r),
'gvalue': a,
'prune_selected': True,
'demography': demography
}
params = fwdpy11.ModelParams(**p)
rng = fwdpy11.GSLrng(101 * 45 * 110 * 210)
pop = fwdpy11.DiploidPopulation(N, 1.0)
fwdpy11.evolvets(rng, pop, params, 100, track_mutation_counts=True)
mc = fwdpy11.count_mutations(pop.tables, pop.mutations,
[i for i in range(2 * pop.N)])
assert len(pop.fixations) > 0, "Test is meaningless without fixations"
fixations = np.where(mc == 2 * pop.N)[0]
self.assertEqual(len(fixations), 0)
# Brute-force calculation of fixations
brute_force = np.zeros(len(pop.mutations), dtype=np.int32)
for g in pop.haploid_genomes:
if g.n > 0:
for k in g.smutations:
brute_force[k] += g.n
self.assertTrue(np.array_equal(brute_force, mc))
self.assertTrue(np.array_equal(brute_force, pop.mcounts))
def runsim(args):
popsizes = np.array([args.popsize] * 20 * args.popsize, dtype=np.int32)
locus_boundaries = [(i, i + 11) for i in range(0, 10 * 11, 11)]
sregions = [fwdpy11.GaussianS(i[0] + 5, i[0] + 6, 1, args.sigma)
for i in locus_boundaries]
recregions = [fwdpy11.PoissonInterval(
*i, args.rho / (4 * args.popsize)) for i in locus_boundaries]
recregions.extend([fwdpy11.BinomialPoint(i[1], 0.5)
for i in locus_boundaries[:-1]])
pop = fwdpy11.DiploidPopulation(args.popsize, locus_boundaries[-1][1])
optima = fwdpy11.GSSmo(
[(0, 0, args.VS), (10 * args.popsize, args.opt, args.VS)])
p = {'nregions': [], # No neutral mutations -- add them later!
'gvalue': fwdpy11.Additive(2.0, optima),
'sregions': sregions,
'recregions': recregions,
'rates': (0.0, args.mu, None),
# Keep mutations at frequency 1 in the pop if they affect fitness.
'prune_selected': False,
'demography': np.array(popsizes, dtype=np.uint32)
}
params = fwdpy11.ModelParams(**p)
rng = fwdpy11.GSLrng(args.seed)
s = Recorder(args.popsize)
fwdpy11.evolvets(rng, pop, params, 100, s,
suppress_table_indexing=True,
track_mutation_counts=True)
return pop
def setUpClass(self):
# TODO add neutral variants
self.N = 1000
self.demography = np.array([self.N] * self.N, dtype=np.uint32)
self.rho = 1.
self.theta = 100.
self.nreps = 500
self.mu = self.theta / (4 * self.N)
self.r = self.rho / (4 * self.N)
self.GSS = fwdpy11.GSS(VS=1, opt=0)
a = fwdpy11.Additive(2.0, self.GSS)
self.p = {
'nregions': [],
'sregions': [fwdpy11.GaussianS(0, 1, 1, 0.25)],
'recregions': [fwdpy11.Region(0, 1, 1)],
'rates': (0.0, 0.025, self.r),
'gvalue': a,
'prune_selected': False,
'demography': self.demography
}
self.params = fwdpy11.ModelParams(**self.p)
self.rng = fwdpy11.GSLrng(101 * 45 * 110 * 210)
self.pop = fwdpy11.DiploidPopulation(self.N, 1.0)
self.all_samples = [i for i in range(2 * self.N)]
fwdpy11.evolvets(self.rng, self.pop, self.params, 100)
self.dm = fwdpy11.data_matrix_from_tables(self.pop.tables,
self.all_samples, True, True)
self.neutral = np.array(self.dm.neutral)
self.npos = np.array(self.dm.neutral.positions)
self.selected = np.array(self.dm.selected)
self.spos = np.array(self.dm.selected.positions)
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 __init__(self,
set_gen,
final,
Nstart,
nwindows=55,
beginning=50,
replicate=1):
self.nwindows = nwindows
self.val_per_window = 4
self.beginning = beginning
self.pi = [['N'] + [
i for i in range((self.nwindows - self.beginning) *
self.val_per_window)
]]
self.singleton = [['N'] + [
i for i in range((self.nwindows - self.beginning) *
self.val_per_window)
]]
self.tajimasD = [['N'] + [
i for i in range((self.nwindows - self.beginning) *
self.val_per_window)
]]
self.counter = 1
self.final = final
self.set_gen = set_gen
self.Nstart = Nstart
self.__rng = fp11.GSLrng(np.random.randint(42 + float(replicate)))
def test_mutation_counts_with_indexing_suppressed_no_neutral_muts_in_genomes(
self):
"""
A sim w/ and w/o putting neutral variants in genomes
should give the same mutation counts.
"""
pop2 = copy.deepcopy(self.pop)
rng = fwdpy11.GSLrng(101 * 45 * 110 * 210) # Use same seed!!!
self.params.prune_selected = False
params = copy.deepcopy(self.params)
fwdpy11.evolvets(rng, pop2, params, 100, suppress_table_indexing=True)
fwdpy11.evolvets(self.rng,
self.pop,
self.params,
100,
suppress_table_indexing=True)
ti = fwdpy11.TreeIterator(self.pop.tables,
[i for i in range(2 * self.pop.N)])
mc = _count_mutations_from_diploids(self.pop)
for t in ti:
for m in t.mutations():
# Have to skip neutral mutations b/c they won't
# end up in mc b/c it is obtained from genomes
if pop2.mutations[m.key].neutral is False:
self.assertEqual(mc[m.key], self.pop.mcounts[m.key])
self.assertEqual(t.leaf_counts(m.node), pop2.mcounts[m.key])
def evolve_snowdrift(args):
"""
We write the function taking a tuple
out of habit, simplifying later
integration with multiprocessing or
concurrent.futures.
"""
N, seed = args
# Construct as single-deme object
# with N diploids
pop = fp11.DiploidPopulation(N)
# Initialize a random number generator
rng = fp11.GSLrng(seed)
p = {
'sregions': [fp11.ExpS(0, 1, 1, -0.1, 1.0)],
'recregions': [fp11.Region(0, 1, 1)],
'nregions': [],
'gvalue': snowdrift.DiploidSnowdrift(0.2, -0.2, 1, -2),
# evolve for 100 generations so that unit tests are
# fast
'demography': np.array([N] * 100, dtype=np.uint32),
'rates': (0.0, 0.0025, 0.001),
'prune_selected': False
}
params = fwdpy11.ModelParams(**p)
sampler = SamplePhenotypes(params.gvalue)
fp11.evolve_genomes(rng, pop, params, sampler)
# return our pop
return pop
def setUp(self):
self.N = 1000
self.demography = np.array([self.N] * 100, dtype=np.uint32)
self.rho = 1.
self.theta = 100.
self.nreps = 500
self.mu = self.theta / (4 * self.N)
self.r = self.rho / (4 * self.N)
self.GSS = fwdpy11.GSS(VS=1, opt=0)
a = fwdpy11.Additive(2.0, self.GSS)
self.p = {
'nregions': [],
'sregions': [fwdpy11.GaussianS(0, 1, 1, 0.25)],
'recregions': [fwdpy11.Region(0, 1, 1)],
'rates': (0.0, 0.025, self.r),
'gvalue': a,
'prune_selected': False,
'demography': self.demography
}
self.params = fwdpy11.ModelParams(**self.p)
self.rng = fwdpy11.GSLrng(101 * 45 * 110 * 210)
self.pop = fwdpy11.DiploidPopulation(self.N, 1.0)
self.recorder = fwdpy11.RandomAncientSamples(
seed=42, samplesize=10, timepoints=[i for i in range(1, 101)])
fwdpy11.evolvets(self.rng, self.pop, self.params, 100, self.recorder)
def setUp(self):
import fwdpy11
import numpy as np
self.N = 1000
self.demography = np.array([self.N] * self.N, dtype=np.uint32)
self.rho = 1.
self.theta = 100.
self.nreps = 500
self.mu = self.theta / (4 * self.N)
self.r = self.rho / (4 * self.N)
self.GSS = fwdpy11.GSS(VS=1, opt=0)
a = fwdpy11.Additive(2.0, self.GSS)
self.p = {
'nregions': [],
'sregions': [fwdpy11.GaussianS(0, 1, 1, 0.25)],
'recregions': [fwdpy11.Region(0, 1, 1)],
'rates': (0.0, 0.025, self.r),
'gvalue': a,
'prune_selected': False,
'demography': self.demography
}
self.params = fwdpy11.ModelParams(**self.p)
self.rng = fwdpy11.GSLrng(101 * 45 * 110 * 210)
self.pop = fwdpy11.DiploidPopulation(self.N, 1.0)
fwdpy11.evolvets(self.rng, self.pop, self.params, 100)
def set_up_quant_trait_model():
# 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)
GSSmo = fwdpy11.GSSmo([(0, 0, 1), (N, 1, 1)])
a = fwdpy11.Additive(2.0, GSSmo)
p = {
'nregions': [],
'sregions': [fwdpy11.GaussianS(0, 1, 1, 0.25)],
'recregions': [fwdpy11.Region(0, 1, 1)],
'rates': (0.0, 0.025, r),
'gvalue': a,
'prune_selected': False,
'demography': demography
}
params = fwdpy11.ModelParams(**p)
rng = fwdpy11.GSLrng(101 * 45 * 110 * 210)
pop = fwdpy11.DiploidPopulation(N, 1.0)
return params, rng, pop
def setUpClass(self):
class CountSamplesPerTimePoint(object):
def __init__(self):
self.sample_timepoints = []
self.sample_sizes = []
self.timepoint_seen = {}
def __call__(self, pop):
assert len(pop.tables.preserved_nodes)//2 == \
len(pop.ancient_sample_metadata)
# Get the most recent ancient samples
# and record their number. We do this
# by a "brute-force" approach
for t, n, m in pop.sample_timepoints(False):
if t not in self.timepoint_seen:
self.timepoint_seen[t] = 1
else:
self.timepoint_seen[t] += 1
if t not in self.sample_timepoints:
self.sample_timepoints.append(t)
self.sample_sizes.append(len(n) // 2)
# simplify to each time point
tables, idmap = fwdpy11.simplify_tables(pop.tables, n)
for ni in n:
assert idmap[ni] != fwdpy11.NULL_NODE
assert tables.nodes[idmap[ni]].time == t
self.N = 1000
self.demography = np.array([self.N] * 101, dtype=np.uint32)
self.rho = 1.
self.r = self.rho / (4 * self.N)
self.GSS = fwdpy11.GSS(VS=1, opt=0)
a = fwdpy11.Additive(2.0, self.GSS)
self.p = {
'nregions': [],
'sregions': [fwdpy11.GaussianS(0, 1, 1, 0.25)],
'recregions': [fwdpy11.Region(0, 1, 1)],
'rates': (0.0, 0.025, self.r),
'gvalue': a,
'prune_selected': False,
'demography': self.demography
}
self.params = fwdpy11.ModelParams(**self.p)
self.rng = fwdpy11.GSLrng(101 * 45 * 110 * 210)
self.pop = fwdpy11.DiploidPopulation(self.N, 1.0)
self.all_samples = [i for i in range(2 * self.N)]
self.ancient_sample_recorder = \
fwdpy11.RandomAncientSamples(seed=42,
samplesize=10,
timepoints=[i for i in range(1, 101)])
self.resetter = CountSamplesPerTimePoint()
fwdpy11.evolvets(self.rng,
self.pop,
self.params,
5,
recorder=self.ancient_sample_recorder,
post_simplification_recorder=self.resetter)
def setUp(self):
self.pop = fwdpy11.DiploidPopulation(1000)
self.pdict = fwdpy11.ezparams.mslike(self.pop,
dfe=fwdpy11.ExpS(0, 1, 1, -0.05),
pneutral=0.95,
simlen=10)
self.pdict['gvalue'] = ca.additive()
self.rng = fwdpy11.GSLrng(42)
self.params = fwdpy11.ModelParams(**self.pdict)
def run_replicate(argtuple):
args, repid, repseed = argtuple
rng = fp11.GSLrng(repseed)
NANC = args.N
locus_boundaries = [(float(i + i * 11), float(i + i * 11 + 11))
for i in range(args.nloci)]
nregions = [[
fp11.Region(j[0], j[1], args.theta / (4. * float(NANC)), coupled=True)
] for i, j in zip(range(args.nloci), locus_boundaries)]
recregions = [[
fp11.Region(j[0], j[1], args.rho / (4. * float(NANC)), coupled=True)
] for i, j in zip(range(args.nloci), locus_boundaries)]
sregions = [[
fp11.GaussianS(j[0] + 5.,
j[0] + 6.,
args.mu,
args.sigmu,
coupled=False)
] for i, j in zip(range(args.nloci), locus_boundaries)]
interlocus_rec = fp11ml.binomial_rec(rng, [0.5] * (args.nloci - 1))
nlist = np.array([NANC] * 20 * NANC, dtype=np.uint32)
env = [(0, 0, 1), (10 * NANC, args.opt, 1)]
pdict = {
'nregions':
nregions,
'sregions':
sregions,
'recregions':
recregions,
'demography':
nlist,
'interlocus':
interlocus_rec,
'agg':
fp11ml.AggAddTrait(),
'gvalue':
fp11ml.MultiLocusGeneticValue([fp11tv.SlocusAdditiveTrait(2.0)] *
args.nloci),
'trait2w':
fp11qt.GSSmo(env),
'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,
'prune_selected':
False
}
params = fp11.model_params.MlocusParamsQ(**pdict)
ofilename = args.stub + '.rep' + str(repid) + '.pickle.lzma'
recorder = Pickler(repid, NANC, ofilename)
pop = fp11.MlocusPop(NANC, args.nloci, locus_boundaries)
fp11qt.evolve(rng, pop, params, recorder)
#Make sure last gen got pickled!
if recorder.last_gen_recorded != pop.generation:
with open(ofilename, "ab") as f:
pickle.dump((repid, pop), f, -1)
return ofilename
def setUp(self):
self.pop = fwdpy11.DiploidPopulation(1000)
self.pdict = fwdpy11.ezparams.mslike(self.pop,
dfe=fwdpy11.ConstantS(
0, 1, 1, -0.05, 0.05),
pneutral=0.95,
simlen=10)
self.pdict['gvalue'] = general.GeneralW()
self.rng = fwdpy11.GSLrng(42)
self.params = fwdpy11.ModelParams(**self.pdict)
def setUp(self):
from fwdpy11.ezparams import mslike
from fwdpy11 import Multiplicative
from fwdpy11 import ModelParams
self.sampler = DiploidTypeSampler()
self.pop = fwdpy11.DiploidPopulation(1000)
self.params_dict = mslike(self.pop, simlen=10)
self.params_dict['gvalue'] = Multiplicative(2.)
self.params = ModelParams(**self.params_dict)
self.rng = fwdpy11.GSLrng(42)
def runsim(argtuple):
seed = argtuple
rng = fwdpy11.GSLrng(seed)
pdict = {
'gvalue':
fwdpy11.Multiplicative(2.),
'rates': (0., U / 2., R), # The U/2. is from their eqn. 2.
'nregions': [],
'sregions': [
fwdpy11.ConstantS(0, 1. / 3., 1, -0.02, 1.),
fwdpy11.ConstantS(2. / 3., 1., 1, -0.02, 1.)
],
'recregions':
[fwdpy11.Region(0, 1. / 3., 1),
fwdpy11.Region(2. / 3., 1., 1)],
'demography':
np.array([N] * 20 * N, dtype=np.uint32)
}
params = fwdpy11.ModelParams(**pdict)
pop = fwdpy11.DiploidPopulation(N, GENOME_LENGTH)
fwdpy11.evolvets(rng, pop, params, 100, suppress_table_indexing=True)
rdips = np.random.choice(N, NSAM, replace=False)
md = np.array(pop.diploid_metadata, copy=False)
rdip_nodes = md['nodes'][rdips].flatten()
nodes = np.array(pop.tables.nodes, copy=False)
# Only visit trees spanning the
# mutation-free segment of the genome
tv = fwdpy11.TreeIterator(pop.tables,
rdip_nodes,
begin=1. / 3.,
end=2. / 3.)
plist = np.zeros(len(nodes), dtype=np.int8)
sum_pairwise_tmrca = 0
for t in tv:
for i in range(len(rdip_nodes) - 1):
u = rdip_nodes[i]
while u != fwdpy11.NULL_NODE:
plist[u] = 1
u = t.parent(u)
for j in range(i + 1, len(rdip_nodes)):
u = rdip_nodes[j]
while u != fwdpy11.NULL_NODE:
if plist[u] == 1:
sum_pairwise_tmrca += 2 * \
(pop.generation-nodes['time'][u])
u = fwdpy11.NULL_NODE
else:
u = t.parent(u)
plist.fill(0)
return 2 * sum_pairwise_tmrca / (len(rdip_nodes) * (len(rdip_nodes) - 1))
def run_replicate(argtuple):
args, repid, repseed = argtuple
rng = fp11.GSLrng(repseed)
NANC = args.N
locus_boundaries = [(float(i + i * 11), float(i + i * 11 + 11))
for i in range(args.nloci)]
nregions = [[
fp11.Region(j[0], j[1], args.theta / (4. * float(NANC)), coupled=True)
] for i, j in zip(range(args.nloci), locus_boundaries)]
recregions = [[
fp11.Region(j[0], j[1], args.rho / (4. * float(NANC)), coupled=True)
] for i, j in zip(range(args.nloci), locus_boundaries)]
# Get the variance in effect sizes
sigmu = args.sigmu # default
if args.plarge is not None:
ghat = gamma_hat(1.0, args.mu)
F = generate_gaussian_function_to_minimize(ghat, args.plarge)
sigmu = get_gaussian_sigma(F)
sregions = [[
fp11.GaussianS(j[0] + 5., j[0] + 6., args.mu, sigmu, coupled=False)
] for i, j in zip(range(args.nloci), locus_boundaries)]
interlocus_rec = fp11ml.binomial_rec(rng, [0.5] * (args.nloci - 1))
nlist = np.array([NANC] * 20 * NANC, dtype=np.uint32)
env = [(0, 0, 1), (10 * NANC, args.opt, args.vsopt)]
pdict = {
'nregions':
nregions,
'sregions':
sregions,
'recregions':
recregions,
'demography':
nlist,
'interlocus':
interlocus_rec,
'agg':
fp11ml.AggAddTrait(),
'gvalue':
fp11ml.MultiLocusGeneticValue([fp11tv.SlocusAdditiveTrait(2.0)] *
args.nloci),
'trait2w':
fp11qt.GSSmo(env),
'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,
'prune_selected':
False
}
params = fp11.model_params.MlocusParamsQ(**pdict)
recorder = Recorder(repid, NANC, args.nsam)
pop = fp11.MlocusPop(NANC, args.nloci, locus_boundaries)
fp11qt.evolve(rng, pop, params, recorder)
return recorder
def test_stop(self):
rng = fwdpy11.GSLrng(42)
def generation(pop, simplified):
if pop.generation >= 50:
return True
return False
fwdpy11.evolvets(
rng, self.pop, self.params, 100,
stopping_criterion=generation)
self.assertEqual(self.pop.generation, 50)
def setUpClass(self):
self.params, self.rng, self.pop = set_up_quant_trait_model()
self.params.demography = np.array([self.pop.N] * 200, dtype=np.uint32)
self.pop2 = copy.deepcopy(self.pop)
self.rng2 = fwdpy11.GSLrng(101 * 45 * 110 * 210)
params2 = copy.deepcopy(self.params)
fwdpy11.evolvets(self.rng, self.pop, self.params, 100)
fwdpy11.evolvets(self.rng2,
self.pop2,
params2,
100,
remove_extinct_variants=False)
def setUpClass(self):
from fwdpy11 import ModelParams
from fwdpy11 import Multiplicative
self.pop = fp11.DiploidPopulation(1000)
self.rng = fp11.GSLrng(42)
self.recorder = GenerationRecorder()
self.p = ModelParams()
self.p.rates = (1e-3, 1e-3, 1e-3)
self.p.demography = np.array([1000] * 100, dtype=np.uint32)
self.p.nregions = [fp11.Region(0, 1, 1)]
self.p.sregions = [fp11.ExpS(0, 1, 1, -1e-2)]
self.p.recregions = self.p.nregions
self.p.gvalue = Multiplicative(2.0)
def run_replicate(argtuple):
args, repid, repseed = argtuple
rng = fp11.GSLrng(repseed)
NANC = args.N
locus_boundaries = [(float(i + i * 11), float(i + i * 11 + 11))
for i in range(args.nloci)]
nregions = [[
fp11.Region(j[0], j[1], args.theta / (4. * float(NANC)), coupled=True)
] for i, j in zip(range(args.nloci), locus_boundaries)]
recregions = [[
fp11.Region(j[0], j[1], args.rho / (4. * float(NANC)), coupled=True)
] for i, j in zip(range(args.nloci), locus_boundaries)]
sregions = [[
fp11.GaussianS(j[0] + 5.,
j[0] + 6.,
args.mu,
args.sigmu,
coupled=False)
] for i, j in zip(range(args.nloci), locus_boundaries)]
interlocus_rec = fp11ml.binomial_rec([0.5] * (args.nloci - 1))
nlist = np.array([NANC] * args.simlen * NANC, dtype=np.uint32)
# the tuples are (time, z_o, VS)
env = [(0, 0, 1), (10 * NANC, args.opt, 1)]
gv = fwdpy11.genetic_values.MlocusAdditive(
2.0, fwdpy11.genetic_values.GSSmo(env))
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
pdict = {
'nregions': nregions,
'sregions': sregions,
'recregions': recregions,
'demography': nlist,
'interlocus_rec': interlocus_rec,
'rates': (mutrates_n, mutrates_s, recrates),
'gvalue': gv,
'prune_selected': False
}
params = fp11.model_params.ModelParams(**pdict)
recorder = HapStatSampler(repid, NANC, args.nsam)
# sched prevents the TBB library
# from over-subscribing a node
# when running many sims in parallel
sched = None
if HAVESCHED is True:
sched = Scheduler(1)
pop = fp11.MlocusPop(NANC, locus_boundaries)
assert pop.nloci == len(locus_boundaries), "nloci != len(locus_boundaries)"
fwdpy11.wright_fisher.evolve(rng, pop, params, recorder)
return repid, recorder.data, pop
def runsim(args, simseed, npseed):
dg = demes.load(args.yaml)
final_demes = get_final_demes(dg)
demog = fwdpy11.discrete_demography.from_demes(dg, burnin=args.burnin)
final_deme_ids = sorted([
i for i in demog.metadata["deme_labels"]
if demog.metadata["deme_labels"][i] in final_demes
])
initial_sizes = [
demog.metadata["initial_sizes"][i]
for i in sorted(demog.metadata["initial_sizes"].keys())
]
recrate = RHO / (4.0 * initial_sizes[0])
pdict = {
"nregions": [],
"sregions": [],
"recregions": [fwdpy11.PoissonInterval(0, 1, recrate)],
"gvalue": fwdpy11.Multiplicative(2.0),
"rates": (0.0, 0.0, None),
"simlen": demog.metadata["total_simulation_length"],
"demography": demog,
}
params = fwdpy11.ModelParams(**pdict)
pop = fwdpy11.DiploidPopulation(initial_sizes, 1.0)
# FIXME: need seed as input argument to this fxn
rng = fwdpy11.GSLrng(simseed)
np.random.seed(npseed)
fwdpy11.evolvets(rng, pop, params, 100)
nmuts = fwdpy11.infinite_sites(rng, pop, THETA / (4.0 * initial_sizes[0]))
md = np.array(pop.diploid_metadata, copy=False)
sample_nodes = []
for i in final_deme_ids:
w = np.where(md["deme"] == i)
s = np.random.choice(w[0], args.nsam, replace=False)
sample_nodes.append(md["nodes"][s].flatten())
fs = pop.tables.fs(sample_nodes)
return fs
def setUp(self):
import numpy as np
N = 1000
demography = np.array([N] * 10 * N, dtype=np.uint32)
rho = 1.
r = rho / (4 * N)
a = fwdpy11.Multiplicative(2.0)
self.p = {
'nregions': [],
'sregions': [fwdpy11.ExpS(0, 1, 1, 0.01)],
'recregions': [fwdpy11.Region(0, 1, 1)],
'rates': (0.0, 0.00005, r),
'gvalue': a,
'demography': demography
}
self.pop = fwdpy11.DiploidPopulation(N)
self.rng = fwdpy11.GSLrng(101 * 45 * 110 * 210)
def evolve(N, rho, simlen=20, seed=42):
"""
Evolve without selection and without simplifying.
:param (int) N: Number of diploids
:param (float) rho: 4Nr
:param (int) simlen: (Default: 10) Evolve for simlen*N generations.
:param (int) seed: (Default: 42) RNG seed.
:rtype: fwdpy11_arg_example.argsimplifier.ArgSimplifier
:return: Unsimplified data
"""
pop = fp11.SlocusPop(N)
# Set up parameters with defaults
recrate = rho / (4.0 * float(N))
mutrate_n = 0.0
mutrate_s = 0.0
pdict = {'rates': (mutrate_n, mutrate_s, recrate),
'nregions': [],
'sregions': [],
'recregions': [fp11.Region(0, 1, 1)],
'gvalue': fp11w.SlocusMult(1.0),
'demography': np.array([N] * simlen * N, dtype=np.uint32)
}
params = fp11mp.SlocusParams(**pdict)
# Set the gc_interval to be so long that it never happens
gc_interval = 2 * simlen * N
simplifier = ArgSimplifier(gc_interval, None)
atracker = AncestryTracker(pop.N, False, 2*pop.N)
mm = makeMutationRegions(params.nregions, params.sregions)
rm = makeRecombinationRegions(params.recregions)
rng = fp11.GSLrng(seed)
tsim = evolve_singlepop_regions_track_ancestry(rng, pop, atracker, simplifier,
params.demography,
params.mutrate_s,
params.recrate, mm, rm,
params.gvalue, params.pself)
# Reverse time:
atracker.prep_for_gc()
return atracker
def process_replicate(argtuple):
filename, repid, seed = argtuple
with gzip.open(filename, 'rb') as f:
pop = fwdpy11.SlocusPop.load_from_pickle_file(f)
rng = fwdpy11.GSLrng(seed)
np.random.seed(seed)
# Add neutral mutations
nm = fwdpy11.ts.infinite_sites(rng, pop,
float(NLOCI) * args.theta / (4 * pop.N))
# Get the node table for the pop and the
# metadata for ancient samples
nodes = np.array(pop.tables.nodes, copy=False)
amd = np.array(pop.ancient_sample_metadata, copy=False)
# These are the times for each ancient sample
amt = nodes['time'][amd['nodes'][:, 0]]
genome_scan = []
qtraits = []
ld = []
for t in np.unique(amt):
# Get the indexes of the metadata corresponding
# to this time point
sample_indexes_at_time = np.where(amt == t)[0]
# Calc some simple stats about the overall pop'n
mean_trait_value = amd['g'][sample_indexes_at_time].mean()
vg = amd['g'][sample_indexes_at_time].var()
wbar = amd['w'][sample_indexes_at_time].mean()
qtraits.append(QtraitRecord(t, mean_trait_value, wbar, vg))
samples = amd['nodes'][sample_indexes_at_time].flatten()
tables, idmap = fwdpy11.ts.simplify(pop, samples)
ld.append(pairwise_LD(t, pop, tables, samples, idmap))
genome_scan.extend(
genome_scan_stats(t, pop.mutations, tables, idmap, amd,
sample_indexes_at_time))
return repid, genome_scan, qtraits, ld
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
