def replicate_tuson_drift_simulation(self, pop, meta_population,
meta_sample_size,
recombination_rates):
for replicate in pop.populations():
replicate.dvars().gen = 0
female_chooser = sim.RandomParentChooser(
selectionField='female_fitness')
male_chooser = sim.RandomParentChooser(selectionField='male_fitness')
print("Beginning simulation of genetic drift with parameters:")
breeding_params = {
'n_breeding_females': self.number_of_breeding_females,
'n_breeding_males': self.number_of_breeding_males,
'sample_sizes': meta_sample_size}
print("Breeding females: {n_breeding_females}, breeding males: "
"{n_breeding_males}, "
"sample sizes: {sample_sizes}".format(**breeding_params))
return pop.evolve(
initOps=[
operators.ReplicateMetaPopulation(meta_population,
meta_sample_size),
sim.PyEval(
r'"Initial: Sampled %d individuals from generation %d Replicate: %d.\n" % (ss, gen_sampled_from, rep)'),
],
preOps=[
sim.PyEval(r'"Generation: %d\n" % gen'),
sim.InfoExec('generation=gen'),
operators.ReplicateMetaPopulation(meta_population,
meta_sample_size,
at=[2, 4, 6, 8]),
# Evaluation specifying the generations should be the same as the evaluation at every generation.
sim.PyEval(
r'"Sampled %d individuals from generation %d from replicate: %d.\n" % (ss, gen_sampled_from, rep)',
at=[2, 4, 6, 8]),
operators.RandomlyAssignFemaleFitness(
self.number_of_breeding_females),
operators.RandomlyAssignMaleFitness(
self.number_of_breeding_males),
],
matingScheme=sim.HomoMating(
sim.CombinedParentsChooser(female_chooser, male_chooser,
allowSelfing=True),
sim.OffspringGenerator(ops=[
sim.ParentsTagger(),
sim.IdTagger(),
sim.PedigreeTagger(),
sim.Recombinator(rates=recombination_rates)],
),
),
finalOps=[
sim.InfoExec('generation=gen'),
operators.ReplicateMetaPopulation(meta_population,
meta_sample_size),
sim.PyEval(
r'"Final: Sampled %d individuals from generation %d\n" % (ss, gen_sampled_from)')
],
gen=self.number_of_generations)
def __init__(self,
intensity=0,
rates=0,
loci=sim.ALL_AVAIL,
convMode=sim.NO_CONVERSION,
maleIntensity=0,
maleRates=0,
maleLoci=sim.ALL_AVAIL,
maleConvMode=sim.NO_CONVERSION,
*args,
**kwargs):
# This operator is used to recombine maternal chromosomes
self.Recombinator = sim.Recombinator(rates, intensity, loci, convMode)
# This operator is used to recombine paternal chromosomes
self.maleRecombinator = sim.Recombinator(maleRates, maleIntensity,
maleLoci, maleConvMode)
sim.PyOperator.__init__(self,
func=self.transmitGenotype,
*args,
**kwargs)
def create_self_crosses(self, existing_pop, offspring_per_individual):
new_pop_size = offspring_per_individual * existing_pop.popSize()
existing_pop.evolve(
matingScheme=sim.SelfMating(
replacement=False,
numOffspring=offspring_per_individual,
subPopSize=new_pop_size,
ops=[
sim.IdTagger(),
sim.PedigreeTagger(),
sim.Recombinator(rates=0.01)
],
),
gen=1,
)
def random_mating(self, generations_of_random_mating, pop_size):
"""
Randomly mates 'pop' for 'gens_of_random_mating' generations to further
recombine founder genomes and dissolve population structure.
"""
print("Initiating random mating for {} generations.".format(
generations_of_random_mating))
self.pop.evolve(
matingScheme=sim.RandomMating(
subPopSize=pop_size,
ops=[
sim.IdTagger(),
sim.PedigreeTagger(),
sim.Recombinator(rates=self.recombination_rates)
]),
gen=generations_of_random_mating,
)
def recombinatorial_convergence(self, pop, recombination_rates):
"""
Implements the MAGIC breeding scheme of breeding single individuals
in pairs determined by the offspring of the initial population. The
initial population is given by generate_f_one.
:param pop:
:type pop:
:param recombination_rates:
:type recombination_rates:
:return:
:rtype:
"""
while pop.numSubPop() > 1:
new_parents = list(pop.indInfo('ind_id'))
new_parent_id_pairs = [(pid, pid + 1) for pid in new_parents[::2]]
if len(new_parent_id_pairs) % 2 != 0 and \
len(new_parent_id_pairs) != 1:
new_parent_id_pairs.append(random.choice(new_parent_id_pairs))
new_os_size = len(new_parent_id_pairs)
new_founder_chooser = breed.PairwiseIDChooser(new_parent_id_pairs)
pop.evolve(
preOps=[
sim.PyEval(r'"Generation: %d\t" % gen', ),
sim.Stat(popSize=True, numOfMales=True),
sim.PyEval(r'"popSize: %d\n" % popSize', ),
],
matingScheme=sim.HomoMating(
sim.PyParentsChooser(new_founder_chooser.by_id_pairs),
sim.OffspringGenerator(ops=[
sim.IdTagger(),
sim.ParentsTagger(),
sim.PedigreeTagger(),
sim.Recombinator(rates=recombination_rates)
],
numOffspring=1),
subPopSize=new_os_size,
),
gen=1,
)
def expansion_through_random_mating(self, pop, expanded_pop_size,
recombination_rates):
# The purpose of this function is to use the simuPOP pre-defined mating scheme
# RandomMating to grow the population to an arbitrary size.
# Self-pollination occurs frequently in maize so we need use HermaphroditicMating
# instead of RandomMating.
return pop.evolve(
initOps=sim.InitSex(),
preOps=[
sim.PyEval(r'"Generation: %d\n" % gen'),
sim.InfoExec('generation=gen'),
],
matingScheme=sim.HermaphroditicMating(
ops=[sim.Recombinator(rates=recombination_rates),
sim.IdTagger(),
sim.PedigreeTagger()],
subPopSize=expanded_pop_size),
gen=1)
def recombinatorial_convergence(self, multi_replicate_populations,
number_sub_populations,
offspring_per_pair):
"""
Breeds individuals from different sub-populations together until a
single hybrid sub-population is created.
:note:`number_sub_populations*offspring_per_pair should equal operating_population_size.`
:note:`For the time being only works with powers of 2.`
:param sim.Simulator multi_replicate_populations:
:param int number_sub_populations:
:param int offspring_per_pair:
:return:
"""
print("Start of recombinatorial convergence.")
while number_sub_populations > 1:
mrc = MultiRandomCross(multi_replicate_populations,
number_sub_populations, offspring_per_pair)
mothers, fathers = mrc.determine_random_cross()
multi_snd_order_chooser = MultiSecondOrderPairIDChooser(
mothers, fathers)
print("Prior to convergence: {}".format(number_sub_populations))
multi_replicate_populations.evolve(
matingScheme=sim.HomoMating(
sim.PyParentsChooser(
multi_snd_order_chooser.snd_ord_id_pairs),
sim.OffspringGenerator(ops=[
sim.IdTagger(),
sim.PedigreeTagger(),
sim.Recombinator(rates=self.recombination_rates)
],
numOffspring=1),
subPopSize=[
int(number_sub_populations * offspring_per_pair)
]),
gen=1,
)
number_sub_populations = int(number_sub_populations / 2)
offspring_per_pair = int(2 * offspring_per_pair)
self._convergence = True
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,
)
def interim_random_mating(self, pop, recombination_rates):
"""
Randomly mates 'pop' for 'gens_of_random_mating' generations to further recombine founder genomes and dissolve
population structure.
:param pop: Founder population after mate_and_merge procedure
:return: Population ready to be subjected to selection
"""
print("Initiating interim random mating for {} generations.".format(
self.generations_of_random_mating))
pop.evolve(
preOps=[
sim.PyEval(r'"Generation: %d\n" % gen'),
],
matingScheme=sim.RandomMating(
subPopSize=self.operating_population_size,
ops=[
sim.IdTagger(),
sim.PedigreeTagger(),
sim.Recombinator(rates=recombination_rates)
]),
gen=self.generations_of_random_mating,
)
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,
)
def population_structure_guided_expansion(self, pop, recombination_rates):
"""
Uses a population structure matrix to determine the probability of
selecting a second parent given the first parent's probability mass
function.
"""
ps_pc = breed.ForcedPopulationStructureParentChooser(
self.population_size)
print(
"Executing population expansion using estimated population structure.")
return pop.evolve(
initOps=sim.InitSex(),
preOps=[
sim.InfoExec('generation=gen'),
],
matingScheme=sim.HomoMating(
sim.PyParentsChooser(ps_pc.forced_structure_parent_chooser),
sim.OffspringGenerator(ops=[
sim.IdTagger(),
sim.PedigreeTagger(),
sim.Recombinator(rates=recombination_rates),
]),
subPopSize=self.population_size),
gen=1)
def main():
# Check for arguments passed
try:
opts, args = getopt.getopt(sys.argv[1:],
shortopts="vhd:p1:p2:s:n:l:e:f:i:m:g:r:",
longopts=[
"verbose", "help", "distribution=",
"parameter1=", "parameter2=", "size=",
"number=", "loci=", "effect=", "mean=",
"filename=", "heritability=", "gen=",
"rrate="
])
except getopt.GetoptError as err:
print(err)
usage()
sys.exit()
verbose = False
filename = "my"
size = 1000
number = 100
heritability = 0.2
mean = 2.0
gen = 5
rrate = 0.0
print "\n"
for o in opts:
if o[0] in ("-v", "--verbose"):
verbose = True
print("Verbose mode")
for o in opts:
if o[0] in ("-d", "--distribution"):
distribution = float(o[1])
if distribution == 0:
parameter1 = None
parameter2 = None
if verbose:
print "Simulation will occur with Normal Distribution"
elif distribution == 1:
if verbose:
print "Simulation will occur with Gamma Distribution"
for o in opts:
if o[0] in ("-p1", "--parameter1"):
parameter1 = float(o[1])
if verbose:
print "Gamma distribution will occur with alpha:", parameter1
for o in opts:
if o[0] in ("-p2", "--parameter2"):
parameter2 = float(o[1])
if verbose:
print "Gamma distribution will occur with beta:", parameter2
elif distribution != 0 or distribution != 1:
sys.exit(
"Error message: Distribution option must be either 0 or 1")
for o in opts:
if o[0] in ("-p2", "--parameter2"):
bbeta = float(o[1])
if verbose:
print "Gamma distribution will occur with beta:", bbeta
for o in opts:
if o[0] in ("-s", "--size"):
individuals = o[1].split(",")
individuals = map(int, individuals)
if verbose:
print "Population size/s is set at", individuals
for o in opts:
if o[0] in ("-h", "--help"):
usage()
sys.exit()
elif o[0] in ("-n", "--number"):
number = o[1]
if verbose:
print "Number of loci per individual is set at", number
elif o[0] in ("-l", "--loci"):
global loci
loci = o[1].split(",")
loci = map(int, loci)
if verbose:
print "Loci positions per individual are:", loci
elif o[0] in ("-e", "--effect"):
global effects
effects = o[1].split(",")
effects = map(float, effects)
if verbose:
print "Effects for loci per individual are:", effects
elif o[0] in ("-f", "--filename"):
filename = o[1]
if verbose:
print "File will be saved as:", filename
elif o[0] in ("-i", "--heritability"):
heritability = float(o[1])
if verbose:
print "Heritability for simulation specified as:", heritability
elif o[0] in ("-m", "--mean"):
mean = o[1].split(",")
mean = map(float, mean)
if len(mean) == 1 and len(individuals) > 1:
mean = numpy.array(mean)
mean = numpy.repeat(mean, len(individuals), axis=0)
mean = list(mean)
if verbose:
print "Population mean/s specified as:", mean
elif o[0] in ("-g", "--gen"):
gen = int(o[1])
if verbose:
print "Generations to evolve specified as:", gen
elif o[0] in ("-r", "--rrate"):
rrate = float(o[1])
if verbose:
print "Recombination will occur with rate:", rrate
## Start quantitative trait simulation
if verbose:
print "Creating population..."
pop = sim.Population(size=individuals,
loci=int(number),
infoFields=["qtrait"])
if verbose:
print "Evolving population..."
pop.evolve(
initOps=[sim.InitSex(),
sim.InitGenotype(prop=[0.7, 0.3])],
matingScheme=sim.RandomMating(ops=sim.Recombinator(rates=rrate)),
postOps=[
sim.PyQuanTrait(loci=loci,
func=additive_model,
infoFields=["qtrait"])
],
gen=gen)
if verbose:
print "Coalescent process complete. Population evolved with", pop.numSubPop(
), "sub-populations."
genotypes = list()
for i in pop.individuals():
genotypes.append(i.genotype())
phenotypes = list()
for i in pop.individuals():
phenotypes.append(i.qtrait)
# fun() obtains the heritability equation set to zero for various settings of sigma (standard deviation)
#NOTE: May need to tweak gamma distribution parameters to be appropriate for data!
def fun(sigma, h):
x_exact = list()
count = 0
for i in phenotypes:
current_mean = mean[pop.subPopIndPair(count)[0]]
x_exact.append(current_mean + i)
count += 1
x_random = list()
#bbeta=((sigma**2)/current_mean) #Set up approximate beta variable for gamma distribution
count = 0
for each in phenotypes:
current_mean = mean[pop.subPopIndPair(count)[0]]
x_random.append(random.normalvariate(current_mean + each, sigma))
count += 1
r = pearsonr(x_exact, x_random)[0]
return r - math.sqrt(h)
if verbose:
print "Building polynomial model for variance tuning..."
# Fits a polynomial model in numpy to the values obtained from the fun() function
points = list()
for i in drange(0, max(effects) * 10, 0.001):
points.append(i)
y_points = list()
for i in points:
y_points.append(fun(i, heritability))
z = numpy.polyfit(x=points, y=y_points, deg=3)
p = numpy.poly1d(z)
# Netwon's method finds the polynomial model's roots
def newton(p):
xn = 100
p_d = p.deriv()
count = 0
while abs(p(xn)) > 0.01:
if count > 1000:
print "Unable to converge after 1000 iterations...\nPlease choose different settings."
usage()
sys.exit()
count += 1
xn = xn - p(xn) / p_d(xn)
if xn < 0.0:
xn = 0.0
if verbose:
print "Estimated variance of phenotypes for specified heriability: ", xn
return xn
if verbose:
print "Using Newton's method to find polynomial roots..."
# Files are saved to the specified location
estimated_variance = newton(p)
new_phenotypes = list()
count = 0
for o in opts:
if o[0] in ("-d", "--distribution"):
if distribution == 0:
for each in phenotypes:
current_mean = mean[pop.subPopIndPair(count)[0]]
new_phenotypes.append(
random.normalvariate(current_mean + each,
estimated_variance))
count += 1
elif distribution == 1:
for each in phenotypes:
current_mean = mean[pop.subPopIndPair(count)[0]]
new_phenotypes.append(
random.gammavariate(
(current_mean + each) / parameter2,
((estimated_variance / parameter1)**0.5)))
count += 1
f = open(filename + "_qtrait.txt", "w")
f.write("\n".join(map(lambda x: str(x), new_phenotypes)))
f.close()
numpy.savetxt(filename + "_kt_ote2.txt",
numpy.column_stack((loci, numpy.array(effects))))
export(pop, format='ped', output=filename + '_genomes.ped')
export(pop, format='map', output=filename + '_genomes.map')
print "\n\n"
#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(
#Fixed population size (fixed at 'popsize')
subPopSize=demo,
#Recombination
ops=[sim.Recombinator(rates=0.002)]),
postOps=[
#Mutation rate 10e-6
sim.SNPMutator(u=0.000001, v=0.000001)
],
#Evolve for a number 'numgen' of generations
gen=numgen)
#Getting population informations (number of subpopulations, population size)
sim.stat(pop, popSize=True)
subsize = pop.dvars().subPopSize
numpop = len(subsize)
#Setting environmental value for all individuals in each subpopulation
for i in range(numpop):
pop.setIndInfo(vec_env[i], 'env', subPop=i)
#Sampling 20 individuals at random in each population
sample = drawRandomSample(pop, sizes=[20] * numpop)
return sz
pop1 = pop.clone()
pop1.evolve(
preOps=[
migr,
sim.InfoExec('age += 1'),
],
matingScheme=sim.HeteroMating(
[
# only adult individuals with age >=3 will mate and produce
# offspring. The age of offspring will be zero.
sim.RandomMating(ops=[
sim.MendelianGenoTransmitter(),
sim.Recombinator(intensity=0.1)
],
subPops=[(sim.ALL_AVAIL, '3 <= age < 9'),
(sim.ALL_AVAIL, '9 <= age < 17')],
weight=-0.1),
# individuals with age < 17 will be kept, but might be removed due to
# population size decline
sim.CloneMating(subPops=[(
sim.ALL_AVAIL,
'age < 3'), (sim.ALL_AVAIL,
'3 <= age < 9'), (sim.ALL_AVAIL, '9 <= age < 17')]
),
],
subPopSize=demoModel),
postOps=[
sim.Stat(popSize=True),
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
)
logfile.write("Done simulating!\n")
logfile.write(time.strftime('%X %x %Z')+"\n")
# writes out events in this form:
# offspringID parentID startingPloidy rec1 rec2 ....
infoFields=['ind_id', 'fitness', 'migrate_to'])
pop.evolve(
initOps=[
sim.InitSex(),
] + init_geno,
preOps=[
sim.SNPMutator(u=args.neut_mut_rate, v=0, loci=neutral_loci),
sim.SNPMutator(u=args.sel_mut_rate, v=0, loci=selected_loci),
sim.PyMlSelector(GammaDistributedFitness(args.gamma_alpha,
args.gamma_beta),
loci=selected_loci,
output=">>" + selloci_file),
],
matingScheme=sim.RandomMating(
ops=[sim.Recombinator(intensity=args.recomb_rate)]),
postOps=[
sim.Stat(numOfSegSites=sim.ALL_AVAIL, step=50),
sim.PyEval(r"'Gen: %2d #seg sites: %d\n' % (gen, numOfSegSites)",
step=50)
],
gen=args.generations)
logfile.write("Done simulating!\n")
logfile.write(time.strftime('%X %x %Z') + "\n")
logfile.write("----------\n")
logfile.flush()
sample = drawRandomSample(pop, sizes=args.nsamples)
if args.outfile is None:
def simuGWAS(pop,
mutaRate=1.8e-8,
recIntensity=1e-8,
migrRate=0.0001,
expandGen=500,
expandSize=[10000],
DPL=[],
curFreq=[],
fitness=[1, 1, 1],
scale=1,
logger=None):
# handling scaling...
mutaRate *= scale
recIntensity *= scale
migrRate *= scale
expandGen = int(expandGen / scale)
fitness = [1 + (x - 1) * scale for x in fitness]
pop.dvars().scale = scale
# Demographic function
demoFunc = linearExpansion(pop.subPopSizes(), expandSize, expandGen)
# define a trajectory function
trajFunc = None
introOps = []
if len(DPL) > 0:
stat(pop, alleleFreq=DPL, vars='alleleFreq_sp')
currentFreq = []
for sp in range(pop.numSubPop()):
for loc in pop.lociByNames(DPL):
currentFreq.append(pop.dvars(sp).alleleFreq[loc][1])
# if there is no existing mutants at DPL
if sum(currentFreq) == 0.:
endFreq = [(x - min(0.01, x / 5.), x + min(0.01, x / 5.,
(1 - x) / 5.))
for x in curFreq]
traj = simulateForwardTrajectory(N=demoFunc,
beginGen=0,
endGen=expandGen,
beginFreq=currentFreq,
endFreq=endFreq,
nLoci=len(DPL),
fitness=fitness,
maxAttempts=1000,
logger=logger)
introOps = []
else:
traj = simulateBackwardTrajectory(N=demoFunc,
endGen=expandGen,
endFreq=curFreq,
nLoci=len(DPL),
fitness=fitness,
minMutAge=1,
maxMutAge=expandGen,
logger=logger)
introOps = traj.mutators(loci=DPL)
if traj is None:
raise SystemError(
'Failed to generated trajectory after 1000 attempts.')
trajFunc = traj.func()
if pop.numSubPop() > 1:
pop.addInfoFields('migrate_to')
pop.dvars().scale = scale
pop.evolve(
initOps=sim.InitSex(),
preOps=[
sim.SNPMutator(u=mutaRate, v=mutaRate),
sim.IfElse(
pop.numSubPop() > 1,
sim.Migrator(
rate=migrSteppingStoneRates(migrRate, pop.numSubPop()))),
] + introOps,
matingScheme=sim.ControlledRandomMating(
loci=DPL,
alleles=[1] * len(DPL),
freqFunc=trajFunc,
ops=sim.Recombinator(intensity=recIntensity),
subPopSize=demoFunc),
postOps=[
sim.Stat(popSize=True, structure=range(pop.totNumLoci())),
sim.PyEval(
r'"After %3d generations, size=%s\n" % ((gen + 1 )* scale, subPopSize)'
),
sim.IfElse(pop.numSubPop() > 1,
sim.PyEval(r"'F_st = %.3f\n' % F_st", step=10),
step=10),
],
gen=expandGen)
return pop
def simulateBySimuPOP():
#starting variables
directory = '/data/new/javi/toxo/simulations4/'
input_path = 'Toxo20.txt'
output_path = 'SimulatedToxo.txt'
input_path = directory + input_path
output_path = directory + output_path
parents_path = directory + '/parents.txt'
pedigree_path = directory + 'pedigree.txt'
number_of_ancestors = 3
expansion_pop_size = 15
offsprings_sampled = number_of_ancestors + expansion_pop_size
gen = 3
translate_mode = 'toxoplasma'
structure_mode = 'simupop'
#parsing input
init_info = parseSNPInput(input_path, number_of_ancestors)
ancestral_genomes = init_info[0]
ancestor_names = ancestral_genomes.keys()
loci_positions = init_info[1]
chromosome_names = sorted(loci_positions.keys(),
key=lambda x: cns.getValue(x, translate_mode))
list_of_loci = [len(loci_positions[chr]) for chr in chromosome_names]
lociPos = fc.reduce(lambda x, y: x + y,
[loci_positions[x] for x in chromosome_names])
sp.turnOnDebug(code="DBG_GENERAL")
#initializing
print('Initializaing Population')
population = sp.Population(size=[number_of_ancestors], loci=list_of_loci, ancGen = 5, lociPos = lociPos, \
chromNames = chromosome_names, lociNames = [], alleleNames = ['A','T','G','C'],\
infoFields=['name', 'ind_id', 'father_id', 'mother_id'])
for individual, sample, ind_id in zip(population.individuals(),
ancestral_genomes,
range(len(ancestral_genomes))):
individual.setInfo(ancestor_names.index(sample), 'name')
individual.setInfo(ind_id, 'ind_id')
for ind, chr in enumerate(chromosome_names):
individual.setGenotype(ancestral_genomes[sample][chr],
chroms=[ind])
#Alternating rounds of recombination with clonal expansion. Clonal expansion gives + 2.
#Mutation prior to each round
simulator = sp.Simulator(population)
rate_matrix = createRateMatrix(len(ancestor_names),
0.0002) #10,000 times the mutation rate.
id_tagger = sp.IdTagger()
ped_tagger = sp.PedigreeTagger(output='>>' + pedigree_path,
outputFields=['name', 'ind_id'])
inherit_tagger = sp.InheritTagger(infoFields='name')
initOps1 = [sp.PyExec('print("Starting random selection")'), ped_tagger]
initOps2 = [sp.PyExec('print("Starting random mating")'), ped_tagger]
preOps1 = [sp.MatrixMutator(rate=rate_matrix)]
preOps2 = [sp.InitSex(sex=[sp.MALE, sp.FEMALE])]
matingScheme1 = sp.RandomSelection(
ops=[sp.CloneGenoTransmitter(), inherit_tagger, id_tagger, ped_tagger],
subPopSize=expansion_pop_size)
matingScheme2 = sp.RandomMating(
ops=[
sp.Recombinator(intensity=0.01 / 105000,
convMode=(sp.GEOMETRIC_DISTRIBUTION, 0.001,
0.01)), #10x normal
sp.PyTagger(func=addNames),
id_tagger,
ped_tagger
],
subPopSize=expansion_pop_size)
postOps = []
finalOps = []
print('Starting Evolution Cycles.')
try:
os.remove(pedigree_path)
except:
pass
simulator.evolve(
initOps=[id_tagger, ped_tagger],
matingScheme=sp.CloneMating(ops=[
sp.CloneGenoTransmitter(), ped_tagger, id_tagger, inherit_tagger
]),
gen=1)
for x in range(gen):
simulator.evolve(initOps=initOps1,
preOps=preOps1,
matingScheme=matingScheme1,
postOps=postOps,
finalOps=finalOps,
gen=1)
simulator.evolve(initOps=initOps2,
preOps=preOps2,
matingScheme=matingScheme2,
postOps=postOps,
finalOps=finalOps,
gen=1)
offsprings = {
''.join([
str(int(x.info('name'))),
generateID(3),
str(int(x.info('ind_id')))
]): x.info('ind_id')
for x in simulator.population(0).individuals()
}
sampled_ones = rand.sample(offsprings.keys(), offsprings_sampled)
#reorganizes the offspring genome. Extract info by chr.
offspring_genomes = {name: {} for name in sampled_ones}
for name in sampled_ones:
for ind, chr in enumerate(chromosome_names):
offspring_genomes[name][chr] = simulator.population(0).indByID(
offsprings[name], idField='ind_id').genotype(ploidy=0,
chroms=[ind])
offspring_genomes.update(ancestral_genomes)
print('Parent Guide:')
for ind, id in enumerate(ancestor_names):
print(" : ".join([str(ind), str(id)]))
print('Complete. Generating Output.')
with open(parents_path, 'w') as parent_output:
parent_output.write('Parent Guide:\n')
for ind, id in enumerate(ancestor_names):
parent_output.write(" : ".join([str(ind), str(id)]) + '\n')
#output
offspring_genomes = snp.restructure((offspring_genomes, loci_positions),
structure_mode)
snp.outputGriggFormat(offspring_genomes, output_path)
print('Simulation Complete.')
# 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, loci=[5]*4,
# one autosome, two sex chromosomes, and one mitochondrial chromosomes
chromTypes=[sim.AUTOSOME, sim.CHROMOSOME_X, sim.CHROMOSOME_Y, sim.MITOCHONDRIAL],
infoFields=['fitness'])
pop.evolve(
initOps=[
sim.InitSex(),
sim.InitGenotype(freq=[0.25]*4)
],
preOps=[
sim.MapSelector(loci=17, fitness={(0,): 1, (1,): 1, (2,): 1, (3,): 0.4})
],
matingScheme=sim.RandomMating(ops= [
sim.Recombinator(rates=0.1),
sim.MitochondrialGenoTransmitter(),
]),
postOps=[
sim.Stat(alleleFreq=17, step=10),
sim.PyEval(r'"%.2f %.2f %.2f %.2f\n" % (alleleNum[17][0],'
'alleleNum[17][1], alleleNum[17][2], alleleNum[17][3])', step=10),
],
gen = 100
)
# 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(10,
loci=[20],
ancGen=1,
infoFields=['father_idx', 'mother_idx'])
pop.evolve(
initOps=[sim.InitSex(),
sim.InitGenotype(genotype=[0] * 20 + [1] * 20)],
matingScheme=sim.RandomMating(
ops=[sim.Recombinator(
rates=0.01), sim.ParentsTagger()]),
gen=1)
pop.indInfo('mother_idx') # mother of all offspring
ind = pop.individual(0)
mom = pop.ancestor(ind.mother_idx, 1)
print(ind.genotype(0))
print(mom.genotype(0))
print(mom.genotype(1))
def test_generate_operating_population():
genetic_map = pd.read_csv('nam_prefounders_genetic_map.txt', index_col=None,
sep='\t')
pf_map = shelve.open('pf_map')
misc_gmap = shelve.open('misc_gmap')
uniparams = shelve.open('uniparams')
locus_names = uniparams['locus_names']
pos_column = uniparams['pos_column']
allele_names = uniparams['allele_names']
snp_to_integer = uniparams['snp_to_integer']
integer_to_snp = uniparams['integer_to_snp']
alleles = misc_gmap['alleles']
chr_cM_positions = misc_gmap['chr_cM_positions']
cM_positions = misc_gmap['cM_positions']
integral_valued_loci = misc_gmap['integral_valued_loci']
relative_integral_valued_loci = misc_gmap['relative_integral_valued_loci']
recombination_rates = misc_gmap['recombination_rates']
nam = sim.loadPopulation(uniparams['prefounder_file_name'])
sim.tagID(nam, reset=True)
nam.setSubPopName('maize_nam_prefounders', 0)
selection_statistics = {
'aggregate': {},
'selected': {},
'non-selected': {}
}
ind_names_for_gwas = {i: {} for i in range(uniparams[
'number_of_replicates'])}
uniparams['meta_pop_sample_sizes'] = {i: 100 for i in
range(0, uniparams['generations_of_selection'] + 1, 2)
}
s = simulate.Truncation(uniparams['generations_of_selection'],
uniparams['generations_of_random_mating'],
uniparams['operating_population_size'],
uniparams[
'proportion_of_individuals_saved'],
uniparams['overshoot_as_proportion'],
uniparams['individuals_per_breeding_subpop'],
uniparams['heritability'],
uniparams['meta_pop_sample_sizes'],
uniparams['number_of_replicates'])
ind_names_for_gwas = {i: {} for i in range(uniparams[
'number_of_replicates'])}
founders = uniparams['founders']
replicated_nam = sim.Simulator(nam, rep=2, stealPops=False)
pop = replicated_nam.extract(0)
assert pop.popSize() == 26, "Population is too large."
s.generate_f_one(pop, recombination_rates, founders, 100)
assert pop.popSize() == 400, "Population should have size: {} after the F_1 mating " \
"procedure." \
"".format(len(founders) * 100)
#pop.splitSubPop(0, [100] * 4)
#subpop_list = list(range(pop.numSubPop()))
intmd_os_struct = s.restructure_offspring(pop, 100, 4)
snd_order = breed.SecondOrderPairIDChooser(intmd_os_struct, 1)
pop.evolve(
preOps=[sim.MergeSubPops()],
matingScheme=sim.HomoMating(
sim.PyParentsChooser(snd_order.snd_ord_id_pairs),
sim.OffspringGenerator(ops=[
sim.IdTagger(),
sim.ParentsTagger(),
sim.PedigreeTagger(),
sim.Recombinator(rates=recombination_rates)
],
numOffspring=1),
subPopSize=[200],
),
gen=1,
)
assert pop.popSize() == 1, "Population does not have correct size after second round of mating."
second_intmd_os_struct = s.restructure_offspring(pop, 100, 2)
third_order = breed.SecondOrderPairIDChooser(second_intmd_os_struct, 1)
pop.evolve(
preOps=[sim.MergeSubPops()],
matingScheme=sim.HomoMating(
sim.PyParentsChooser(third_order.snd_ord_id_pairs),
sim.OffspringGenerator(ops=[
sim.IdTagger(),
sim.ParentsTagger(),
sim.PedigreeTagger(),
sim.Recombinator(rates=recombination_rates)
],
numOffspring=1),
subPopSize=[100],
),
gen=1,
)
assert pop.popSize() == 100, "Second merge of breeding sub-populations. Offspring population does not have " \
"correct size"
pre_ops = [sim.PyOperator(lambda pop: rc.increment_time() or True)]
mating_ops = [id_tagger]
logfile.write(time.strftime('%X %x %Z') + "\n")
logfile.write("Started simulating! Generations:\n")
post_ops = [sim.PyEval(r'" %d\n" % (gen)', step=100, output=logfile)]
nselloci = int(args.sel_mut_rate / (args.mut_rate + args.sel_mut_rate))
selected_loci = random.sample(locus_position, nselloci)
neutral_loci = list(set(locus_position) - set(selected_loci))
if args.record_neutral:
pre_ops += [
sim.SNPMutator(u=args.mut_rate, v=args.mut_rate, loci=neutral_loci)
]
mating_ops += [
sim.Recombinator(rates=args.recomb_rate, infoFields="ind_id")
]
elif not args.record_neutral:
mating_ops += [
sim.Recombinator(rates=args.recomb_rate,
output=sim.WithMode(rc.collect_recombs, 'b'),
infoFields="ind_id")
]
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,
v = Fixed_pop_size2
#print(geno[0], geno[1], v)
return v
simu = sim.Simulator(pop1,rep=Replicates)
simu.evolve(
initOps=[
],
preOps=[
],
matingScheme=sim.RandomMating(subPopSize=sizeChange,numOffspring=(sim.POISSON_DISTRIBUTION, Offspring_Poisson_dist_mean),ops=sim.Recombinator(loci=[0, 1, 2, 3, 4, 5, 6, 7], rates=[0.095162582, 0.075960076, 0.094257292, 0.154646165, 0.005, 0.104165865, 0.071328306,0.5]))
,
postOps=[
sim.PySelector(loci=[4], func=sel),
sim.Stat(alleleFreq=[0,1,2,3,4,5,6,7],numOfMales=True,popSize=True),
#Output H per replicate per generation to file
sim.PyEval(r"'%d\t%d\t%.4f\t%.4f\t%.4f\t%.4f\t%.4f\t%.4f\t%.4f\t%.4f\n' % (rep,gen, 1-sum([x*x for x in alleleFreq[0].values()]), 1-sum([x*x for x in alleleFreq[1].values()]), 1-sum([x*x for x in alleleFreq[2].values()]), 1-sum([x*x for x in alleleFreq[3].values()]), 1-sum([x*x for x in alleleFreq[4].values()]), 1-sum([x*x for x in alleleFreq[5].values()]), 1-sum([x*x for x in alleleFreq[6].values()]), 1-sum([x*x for x in alleleFreq[7].values()]))", step=1,reps=(range(0,Replicates,1)),output=Output_file),
sim.PyExec('from math import log'),
#sim.Dumper(output='!"./Simulation_output_pops/pop%d.pop"%rep',step=69,max=500,width=3),
#allelic richness for given locus
#sim.PyEval(r"'%d\n' % (len(alleleNum[0].keys()))"),
Fstsample = sample.dvars().F_st
sample.addInfoFields('order')
order = list(range(100))
fstsim = ''
for rep in range(1000):
merged = sample
merged.mergeSubPops()
np.random.shuffle(order)
merged.setIndInfo(order, field='order')
merged.sortIndividuals('order')
merged.splitSubPop(0, [50] * 2)
sim.stat(merged, structure=range(10), vars=['F_st'])
fstsim += '%s\t' % merged.dvars().F_st
sortie += '%3d\t%.6f\t%3d\t%.6f\t%s\n' % (pop.dvars().gen, Fstpop, a,
Fstsample, fstsim)
reccord(sortie, "dataout")
return True
pop = sim.Population([100000] * 2, loci=[10] * 10, infoFields='migrate_to')
pop.evolve(initOps=[
sim.InitSex(),
sim.InitGenotype(freq=[0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1])
],
preOps=sim.Migrator(rate=[[0, 0.0001], [0.0001, 0]],
mode=sim.BY_PROPORTION),
matingScheme=sim.RandomMating(ops=sim.Recombinator(rates=0.01)),
postOps=[sim.PyOperator(func=calcFst, step=50)],
gen=5000)
#
# 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, loci=[1000, 2000], infoFields='ind_id')
pop.evolve(
initOps=[
sim.InitSex(),
sim.IdTagger(),
],
matingScheme=sim.RandomMating(ops=[
sim.IdTagger(),
sim.Recombinator(rates=0.001, output='>>rec.log', infoFields='ind_id')
]),
gen=5)
rec = open('rec.log')
# print the first three lines of the log file
print(''.join(rec.readlines()[:4]))
# 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
simu = sim.Simulator(sim.Population(size=[1000], loci=[100]), rep=2)
simu.evolve(
initOps=[sim.InitSex(),
sim.InitGenotype(genotype=[0] * 100 + [1] * 100)],
matingScheme=sim.RandomMating(ops=[
sim.Recombinator(rates=0.01, reps=0),
sim.Recombinator(rates=[0.01] * 10, loci=range(50, 60), reps=1),
]),
postOps=[
sim.Stat(LD=[[40, 55], [60, 70]]),
sim.PyEval(
r'"%d:\t%.3f\t%.3f\t" % (rep, LD_prime[40][55], LD_prime[60][70])'
),
sim.PyOutput('\n', reps=-1)
],
gen=5)
import simuPOP as sim
pop = sim.Population(size=10000, loci=10, lociPos=range(5) + range(10, 15))
pop.evolve(
initOps=[
sim.InitSex(),
sim.InitGenotype(haplotypes=[[0]*10,[1]*10]),
],
matingScheme=sim.RandomMating(ops=sim.Recombinator(intensity=0.0005)),
postOps=[
sim.Stat(LD=[[1,2],[4,5],[8,9],[0,9]], step=10),
sim.PyEval(r"'gen=%d\tLD12=%.3f (%.3f)\tLD45=%.3f (%.3f)\tLD09=%.3f\n'%"
"(gen, LD[1][2], 0.25*0.9995**(gen+1), LD[4][5],"
"0.25*0.9975**(gen+1),LD[0][9])", step=10)
],
gen=100
)
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
)
logfile.write("Done simulating!\n")
logfile.write(time.strftime('%X %x %Z')+"\n")
logfile.write("----------\n")
logfile.flush()
] + 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)",
step=50)
],
gen=args.generations)
logfile.write("Done simulating!\n")
logfile.write(time.strftime('%X %x %Z') + "\n")
logfile.write("----------\n")
logfile.flush()
number_of_pairs = len(founders)
example_pop.evolve(
initOps=[
sim.InitLineage(
mode=sim.FROM_INFO
), #assigns lineage of each allele to be tracked through pop.evolve
],
preOps=[],
matingScheme=sim.HomoMating(
sim.PyParentsChooser(founder_chooser.by_id_pairs),
sim.OffspringGenerator(
ops=[
sim.IdTagger(),
sim.PedigreeTagger(output='>>pedigree0.ped'
), #outputs pedigree file for checking
sim.Recombinator(rates=recom_map)
],
numOffspring=1),
subPopSize=[offspring_per_pair * number_of_pairs],
),
gen=1,
)
### Generate Double Hybrids
#Define mothers and fathers, this case is 3 crosses between each pair of hybrid
mothers = np.array([8., 8., 8., 10., 10., 10.])
fathers = np.array([9., 9., 9., 11., 11., 11.])
second_order_chooser = breed.SecondOrderPairIDChooser(
mothers, fathers
) #Defines parental pairs, 8 mated with 9 three times,10 mated with 11 three times
example_pop.evolve(
