s = random.choice([-1.0, 1.0]) * self.s
self.coefMap[loc] = s
if 0 in alleles:
return max(0.0, 1. + s)
else:
return max(0.0, 1. + 2. * s)
fitness = PlusMinusFitness(args.selection_coef)
pop = sim.Population(size=[args.popsize] * npops,
loci=[args.nloci, 2],
lociPos=locus_position + [0, args.length],
infoFields=['ind_id', 'fitness', 'migrate_to'])
id_tagger = sim.IdTagger()
id_tagger.apply(pop)
# record recombinations
rc = RecombCollector(first_gen=pop.indInfo("ind_id"),
ancestor_age=args.ancestor_age,
length=2 * args.length,
locus_position=locus_position +
[args.length, 2 * args.length])
migr_mat = [[0, args.m], [args.m, 0]]
pop.evolve(initOps=[
sim.InitSex(),
] + init_geno,
preOps=[
#
# 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]))
# 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(10, infoFields='ind_id', ancGen=1)
pop.evolve(initOps=sim.IdTagger(),
matingScheme=sim.RandomSelection(ops=[
sim.CloneGenoTransmitter(),
sim.IdTagger(),
]),
gen=1)
print([int(ind.ind_id) for ind in pop.individuals()])
pop.useAncestralGen(1)
print([int(ind.ind_id) for ind in pop.individuals()])
sim.tagID(pop) # re-assign ID
print([int(ind.ind_id) for ind in pop.individuals()])
print('%s: %.3f%% (size %d)' % (pop.subPopName((0,sp)),
pop.dvars((0,sp)).propOfAffected * 100.,
pop.dvars((0,sp)).popSize))
#
return True
pop.evolve(
initOps=[
sim.InitSex(),
# random assign age
sim.InitInfo(lambda: random.randint(0, 75), infoFields='age'),
# random genotype
sim.InitGenotype(freq=[0.5, 0.5]),
# assign an unique ID to everyone.
sim.IdTagger(),
sim.PyOutput('Prevalence of disease in each age group:\n'),
],
# increase the age of everyone by 1 before mating.
preOps=sim.InfoExec('age += 1'),
matingScheme=sim.HeteroMating([
# all individuals with age < 75 will be kept. Note that
# CloneMating will keep individual sex, affection status and all
# information fields (by default).
sim.CloneMating(subPops=[(0,0), (0,1), (0,2)], weight=-1),
# only individuals with age between 20 and 50 will mate and produce
# offspring. The age of offspring will be zero.
sim.RandomMating(ops=[
sim.IdTagger(), # give new born an ID
sim.PedigreeTagger(), # track parents of each individual
sim.MendelianGenoTransmitter(), # transmit genotype
def simulation(me, iterations, generations, cro_to_slo, slo_to_cro, slo_cull, cro_cull):
x = [] # empty list to store LD Ne calculations
Ne = [] # empty list to store demographic Ne calculations
for i in range(iterations):
pop = sim.Population(size = [500, 500], loci=[1]*20,
infoFields = ["age",'ind_id', 'father_idx', 'mother_idx', "mating", "hc",'migrate_to'],
subPopNames = ["croatia", "slovenia"])
sim.initInfo(pop = pop, values = list(map(int, np.random.negative_binomial(n = 1, p = 0.25, size=500))), infoFields="age")
pop.setVirtualSplitter(sim.CombinedSplitter([
sim.ProductSplitter([
sim.SexSplitter(),
sim.InfoSplitter(field = "age", cutoff = [1,3,6,15])])],
vspMap = [[0,1], [2], [3], [4], [5,6,7,8], [9] ]))
# Age groups: from 0 to 1 - cubs, from 1 to 3 - prereproductive, from 3 to 6 - reproductive class, from 6 to 15 - dominant
pop.evolve(
initOps=[
sim.InitSex(),
# random genotype
sim.InitGenotype(freq=[0.01]*2 + [0.03]*2 + [0.23]*4),
# assign an unique ID to everyone.
sim.IdTagger(),
],
# increase the age of everyone by 1 before mating.
preOps=[sim.InfoExec('age += 1'),
sim.InfoExec('mating = 0'),
sim.PyOperator(func=popmodel.NaturalMortality),
sim.InfoExec("hc +=1 if 0 < hc < 3 else 0"), # Mother bear can't have cubs for two years after pregnancy
sim.Migrator(rate=[[cro_to_slo]],
mode=sim.BY_PROPORTION,
subPops=[(0, 0)],
toSubPops=[1]), # reproductive males migrate from Cro to Slo
sim.Migrator(rate=[[slo_to_cro]],
mode=sim.BY_PROPORTION,
subPops=[(1, 0)],
toSubPops=[0]),
sim.Stat(effectiveSize=sim.ALL_AVAIL, subPops=[(0,1),(0,2),(0,4), (1,1), (1,2), (1,4)], vars='Ne_demo_base'),
sim.Stat(effectiveSize=sim.ALL_AVAIL,subPops=[(0,1),(0,2),(0,4), (1,1), (1,2), (1,4)], vars='Ne_demo_base_sp')
#sim.PyEval(r'"Cro %d, Slo %d' ' % (Cro, Slo)', "Cro = pop.subPopSize(0)" "Slo = pop.subPopSize(1)",exposePop='pop'),
],
matingScheme=sim.HeteroMating([
# CloneMating will keep individual sex and all
# information fields (by default).
# The age of offspring will be zero.
sim.HomoMating(subPops=sim.ALL_AVAIL,
chooser=sim.CombinedParentsChooser(
fatherChooser=sim.PyParentsChooser(generator=bearFather),
motherChooser=sim.PyParentsChooser(generator=bearMother)
),
generator=sim.OffspringGenerator(ops=[
sim.InfoExec("age = 0"),
sim.IdTagger(),
#sim.PedigreeTagger(),
sim.ParentsTagger(),
sim.MendelianGenoTransmitter()
], numOffspring=(sim.UNIFORM_DISTRIBUTION, 1, 3))),
sim.CloneMating(subPops=[(0,0), (0,1), (0,2), (0,4), (1,0), (1,1), (1,2), (1,4)], weight=-1),
], subPopSize=popmodel.demoModel),
postOps = [
sim.PyOperator(func=popmodel.cullCountry,param={"slo_cull": slo_cull, "cro_cull": cro_cull}),
sim.PyOperator(func = popmodel.CalcNe, param={"me":me, "Ne":Ne}, begin=int(0.2*generations)),
sim.PyOperator(func = popmodel.CalcLDNe, param={"me":me, "x":x}, begin=int(0.2*generations))
],
gen = generations
)
x = pd.concat(x)
Ne = pd.concat(Ne)
x.loc[x["population"] ==0,"population"] = "cro"
x.loc[x["population"] ==1,"population"] = "slo"
x = x[x['cutoff'] == 0]
x = x.rename(columns={0: "Ne"})
return x, Ne
offspring_per_pair = 1 #One offspring per pair, 4 individuals total
founder_chooser = breed.PairwiseIDChooser(founders, offspring_per_pair)
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(
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"
# 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 simuOpt
simuOpt.setOptions(alleleType='lineage', quiet=True)
import simuPOP as sim
pop = sim.Population(size=10000, loci=[10] * 10, infoFields='ind_id')
# just to make sure IDs starts from 1
sim.IdTagger().reset(1)
pop.evolve(
initOps=[
sim.InitSex(),
sim.InitGenotype(freq=[0.2, 0.3, 0.4, 0.1]),
sim.IdTagger(),
sim.InitLineage(mode=sim.FROM_INFO),
],
# an extremely high mutation rate, just for demonstration
preOps=sim.AcgtMutator(rate=0.01, model='JC69'),
matingScheme=sim.RandomMating(ops=[
sim.IdTagger(),
sim.MendelianGenoTransmitter(),
]),
gen=10)
lin = pop.lineage()
simu = sim.Simulator(pop, rep=1)
simu.evolve(
initOps=[
sim.InitSex(),
sim.InitGenotype(freq=[0.9, 0.1]),
sim.InitInfo([0], infoFields='age'),
sim.InitInfo([args.a], infoFields='a'),
sim.InitInfo([args.b], infoFields='b'),
sim.InitInfo(lambda: random.random(), infoFields='luck'),
sim.InfoExec("t0 = -ind.b / ind.a", exposeInd='ind'),
sim.InfoExec(
"smurf = 1.0 if ((ind.smurf == 1) or (ind.age > ind.t0 and ind.luck < 1.0 - math.exp(-ind.a * ind.age + ind.a * ind.t0 - ind.a / 2.0))) else 0.0",
exposeInd='ind'),
sim.IdTagger()
],
# The order should be: becoming a smurf or not since previous day, dying or not, aging one day
# if lucky enough, and then mate at that age.
preOps=[
sim.InfoExec("luck = random.random()"),
sim.InfoExec(
"smurf = 1.0 if ((ind.smurf == 1) or (ind.age > ind.t0 and ind.luck < 1.0 - math.exp(-ind.a * ind.age + ind.a * ind.t0 - ind.a / 2.0))) else 0.0",
exposeInd='ind'),
sim.DiscardIf(natural_death),
sim.InfoExec("age += 1")
],
matingScheme=sim.HeteroMating([
sim.CloneMating(subPops=[(0, 0), (0, 1), (0, 2)], weight=-1),
sim.RandomMating(ops=[
sim.IdTagger(),
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.')
selDist='constant',
selCoef=None,
popFile='example.pop')
# load population
# print('Loading population example.pop')
# pop = sim.loadPopulation('example.pop')
# evolve the population for a few more generations to produce pedigrees
print('Evolving the population for three generations.')
pop.addInfoFields(['ind_id', 'father_id', 'mother_id'])
sim.tagID(pop)
# save all ancestral generations during evolution
pop.setAncestralDepth(-1)
pop.evolve(matingScheme=sim.RandomMating(
numOffspring=(sim.UNIFORM_DISTRIBUTION, 2, 4),
ops=(sim.MendelianGenoTransmitter(), sim.IdTagger(),
sim.PedigreeTagger())),
gen=3)
# what is the average number of mutants in this population?
avgMutants = (pop.popSize() * pop.totNumLoci() * 2. -
pop.genotype().count(0)) / pop.popSize()
print(('Average number of mutants is %.2f' % avgMutants))
#
# This contains marker information for the initial population
print('Mutant locations are saved to file sample.map')
markers = saveMarkerInfoToFile(pop, 'pedigree.map')
#
def myPenet(geno):
# count the number of mutants
def MutationSelection(N=1000,
generations=10000,
X_loci=100,
A_loci=0,
AgingModel='two_phases',
seed=2001,
reps=1,
InitMutFreq=0.001,
aging_a1=0.003,
aging_a2=0.05,
aging_b=-0.019,
aging_k=0.1911,
MutRate=0.001,
StatsStep=100,
OutPopPrefix='z1',
PrintFreqs=False,
debug=False):
'''Creates and evolves a population to reach mutation-selection balance.'''
if debug:
sim.turnOnDebug('DBG_ALL')
else:
sim.turnOffDebug('DBG_ALL')
sim.setRNG('mt19937', seed)
pop = sim.Population(N,
loci=[X_loci, A_loci],
ploidy=2,
chromTypes=[sim.CHROMOSOME_X, sim.AUTOSOME],
infoFields=[
'age', 'a', 'b', 'smurf', 'ind_id', 'father_id',
'mother_id', 'luck', 't0', 'fitness'
])
pop.setVirtualSplitter(
sim.CombinedSplitter(
splitters=[
sim.ProductSplitter(splitters=[
sim.InfoSplitter(field='age', cutoff=9),
sim.InfoSplitter(field='smurf', values=[0, 1])
]),
sim.SexSplitter(),
sim.InfoSplitter(field='age', values=0)
],
vspMap=[(0), (2), (1, 3), (4), (5), (6)],
names=['larvae', 'adults', 'smurfs', 'males', 'females', 'zero']))
pop.dvars().k = aging_k
pop.dvars().N = N
pop.dvars().seed = seed
pop.dvars().X_loci = X_loci
pop.dvars().A_loci = A_loci
pop.dvars().AgingModel = AgingModel
exec("import random\nrandom.seed(seed)", pop.vars(), pop.vars())
exec("import math", pop.vars(), pop.vars())
simu = sim.Simulator(pop, rep=reps)
simu.evolve(
initOps=[
sim.InitSex(),
sim.InitGenotype(freq=[1 - InitMutFreq, InitMutFreq]),
sim.InitInfo([0], infoFields='age'),
sim.InitInfo([aging_a1], infoFields='a'),
sim.InitInfo([aging_b], infoFields='b'),
sim.InitInfo(lambda: random.random(), infoFields='luck'),
sim.InfoExec('t0 = -ind.b / ind.a', exposeInd='ind'),
sim.InfoExec(
'smurf = 1.0 if AgingModel == "two_phases" and (ind.smurf == 1 or (ind.age > ind.t0 and ind.luck < 1.0 - math.exp(-ind.a * ind.age + ind.a * ind.t0 - ind.a / 2.0))) else 0.0',
exposeInd='ind'),
sim.IdTagger(),
sim.PyExec('XFreqChange={}'),
sim.PyExec('AFreqChange={}')
],
preOps=[
sim.InfoExec('luck = random.random()'),
sim.InfoExec(
'smurf = 1.0 if AgingModel == "two_phases" and (ind.smurf == 1 or (ind.age > ind.t0 and ind.luck < 1.0 - math.exp(-ind.a * ind.age + ind.a * ind.t0 - ind.a / 2.0))) else 0.0',
exposeInd='ind'),
sim.DiscardIf(natural_death(AgingModel)),
sim.InfoExec('age += 1'),
sim.PySelector(func=fitness_func1)
],
matingScheme=sim.HeteroMating([
sim.CloneMating(subPops=[(0, 0), (0, 1), (0, 2)], weight=-1),
sim.RandomMating(ops=[
sim.IdTagger(),
sim.PedigreeTagger(),
sim.InfoExec('smurf = 0.0'),
sexSpecificRecombinator(
rates=[0.75 / X_loci for x in range(X_loci)] +
[2.07 / A_loci for x in range(A_loci)],
maleRates=0.0),
sim.PyQuanTrait(loci=sim.ALL_AVAIL,
func=TweakAdditiveRecessive(
aging_a1, aging_a2, aging_b, X_loci),
infoFields=['a', 'b'])
],
weight=1,
subPops=[(0, 1)],
numOffspring=1)
],
subPopSize=demo),
postOps=[
sim.SNPMutator(u=MutRate, subPops=[(0, 5)]),
sim.Stat(alleleFreq=sim.ALL_AVAIL, step=StatsStep),
sim.IfElse(
'X_loci > 0',
ifOps=[
sim.PyExec(
'XFreqChange[gen] = [alleleFreq[x][1] for x in range(X_loci)]'
)
],
elseOps=[sim.PyExec('XFreqChange[gen] = []')],
step=StatsStep),
sim.IfElse(
'A_loci > 0',
ifOps=[
sim.PyExec(
'AFreqChange[gen] = [alleleFreq[a][1] for a in range(X_loci, pop.totNumLoci())]',
exposePop='pop')
],
elseOps=[sim.PyExec('AFreqChange[gen] = []')],
step=StatsStep),
sim.IfElse(
PrintFreqs,
ifOps=[
sim.PyEval(
r"str(rep) + '\t' + str(gen) + '\t' + '\t'.join(map('{0:.4f}'.format, XFreqChange[gen])) + '\t\t' + '\t'.join(map('{0:.4f}'.format, AFreqChange[gen])) + '\n'"
)
],
step=StatsStep),
sim.TerminateIf(
'sum([alleleFreq[x][0] * alleleFreq[x][1] for x in range(X_loci + A_loci)]) == 0'
)
],
gen=generations)
i = 0
for pop in simu.populations():
pop.save('{}_{}.pop'.format(OutPopPrefix, i))
i += 1
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)
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)
def replicate_random_mating(self, multi_pop, meta_sample_library, qtl,
allele_effects, recombination_rates):
"""
Runs recurrent truncation selection on a multi-replicate population.
:param multi_pop: Simulator object of full-sized population
:param meta_sample_library: Simulator object of meta-populations
:param qtl: Loci whose alleles have effects
:param allele_effects: Allele effect container
:param recombination_rates: Probabilities for recombination at each locus
"""
for pop_rep in multi_pop.populations():
pop_rep.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_random_mating, 2)
]
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),
],
matingScheme=sim.RandomMating(ops=[
sim.IdTagger(),
sim.PedigreeTagger(),
sim.Recombinator(rates=recombination_rates)
]),
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_random_mating)
