def simulate(model, N0, N1, G0, G1, spec, s, mu, k):
'''Evolve a sim.Population using given demographic model
and observe the evolution of its allelic spectrum.
model: type of demographic model.
N0, N1, G0, G1: parameters of demographic model.
spec: initial allelic spectrum, should be a list of allele
frequencies for each allele.
s: selection pressure.
mu: mutation rate.
k: k for the k-allele model
'''
demo_func = demo_model(model, N0, N1, G0, G1)
pop = sim.Population(size=demo_func(0), loci=1, infoFields='fitness')
pop.evolve(
initOps=[
sim.InitSex(),
sim.InitGenotype(freq=spec, loci=0)
],
matingScheme=sim.RandomMating(subPopSize=demo_func),
postOps=[
sim.KAlleleMutator(k=k, rates=mu),
sim.MaSelector(loci=0, fitness=[1, 1, 1 - s], wildtype=0),
ne(loci=[0], step=100),
sim.PyEval(r'"%d: %.2f\t%.2f\n" % (gen, 1 - alleleFreq[0][0], ne[0])',
step=100),
],
gen = G0 + G1
)
global counter
for line in mutants.split('\n'):
# a trailing \n will lead to an empty string
if not line:
continue
(gen, loc, ploidy, a1, a2, id) = line.split('\t')
counter[int(loc)] += 1
pop = sim.Population(
[5000] * 3,
loci=[2, 1, 1],
infoFields='ind_id',
chromTypes=[sim.AUTOSOME, sim.CHROMOSOME_X, sim.CHROMOSOME_Y])
pop.evolve(
initOps=[
sim.InitSex(),
sim.InitGenotype(freq=[0.5, 0.5]),
sim.IdTagger(),
],
preOps=[
sim.KAlleleMutator(rates=[0.001] + [0.01] * 3,
loci=range(4),
k=100,
output=countMutants),
],
matingScheme=sim.RandomMating(
ops=[sim.IdTagger(), sim.MendelianGenoTransmitter()]),
gen=10)
print(counter.items())
import simuOpt
simuOpt.setOptions(quiet=True, alleleType='long')
import simuPOP as sim
pop = sim.Population(size=[2500]*10, loci=1)
simu = sim.Simulator(pop, rep=2)
simu.evolve(
initOps=[
sim.InitSex(),
sim.InitGenotype(genotype=20),
],
preOps=[
sim.StepwiseMutator(rates=0.0001, reps=0),
sim.KAlleleMutator(k=10000, rates=0.0001, reps=1),
],
matingScheme=sim.RandomMating(),
postOps=[
# Use vars=['alleleFreq_sp'] to calculate allele frequency for
# each subpopulation
sim.Stat(alleleFreq=0, vars=['alleleFreq_sp'], step=200),
sim.PyEval('gen', step=200, reps=0),
sim.PyEval(r"'\t%.2f' % (sum([len(subPop[x]['alleleFreq'][0]) "
"for x in range(10)])/10.)", step=200),
sim.PyOutput('\n', reps=-1, step=200)
],
gen=601
)
# 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(size=[2000], loci=1)
pop.evolve(
initOps=[
sim.InitSex(),
sim.InitGenotype(freq=[0] * 4 + [0.1, 0.2, 0.3, 0.4])
],
matingScheme=sim.RandomMating(),
postOps=[
sim.KAlleleMutator(k=4,
rates=1e-4,
mapIn=[0] * 4 + list(range(4)),
mapOut=[4, 5, 6, 7]),
sim.Stat(alleleFreq=0, step=100),
sim.PyEval(
r"', '.join(['%.2f' % alleleFreq[0][x] for x in range(8)]) + '\n'",
step=100),
],
gen=500)
pop = sim.Population(size=args.popsize, ploidy=1, loci=args.numloci)
simu = sim.Simulator(pop, rep=args.replications)
simu.evolve(
initOps=sim.InitGenotype(freq=initial_distribution),
preOps=[
sim.PyOperator(func=utils.logGenerationCount,
param=(),
step=1000,
reps=0),
],
matingScheme=sim.RandomSelection(),
postOps=[
sim.KAlleleMutator(k=simconfig.MAXALLELES,
rates=args.mutationrate,
loci=sim.ALL_AVAIL),
sim.PyOperator(func=data.sampleNumAlleles,
param=(args.samplesize, args.mutationrate, args.popsize,
sim_id, args.numloci),
step=args.stepsize,
begin=beginCollectingData),
sim.PyOperator(func=data.sampleTraitCounts,
param=(args.samplesize, args.mutationrate, args.popsize,
sim_id, args.numloci),
step=args.stepsize,
begin=beginCollectingData),
sim.PyOperator(func=data.censusTraitCounts,
param=(args.mutationrate, args.popsize, sim_id,
args.numloci),
step=args.stepsize,
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--experiment", help="provide name for experiment", required=True, type=str, default="test")
parser.add_argument("--debug", help="turn on debugging output")
parser.add_argument("--reps", help="Replicated populations per parameter set", type=int, default=3)
parser.add_argument("--networkfile", help="Name of GML file representing the network model for this simulation",
required=True, type=str, default="smallworld")
parser.add_argument("--numloci", help="Number of loci per individual (use with care)", type=int, required=True, default=1)
parser.add_argument("--maxinittraits", help="Max initial number of traits per locus for initialization", type=int,
required=True, default=50)
parser.add_argument("--innovrate", nargs='+', help="Rate(s) at which innovations occur in population as a per-locus rate", type=float, default=[])
parser.add_argument("--simlength", help="Time at which simulation and sampling end, defaults to 3000 generations",
type=int, default="20")
parser.add_argument("--popsize", help="Initial size of population for each community in the model", type=int, required=True)
parser.add_argument("--migrationfraction", nargs='+', help="Fraction of population that migrates each time step", type=float, required=True, default=[])
parser.add_argument("--seed", type=int, help="Seed for random generators to ensure replicability")
parser.add_argument( "--k_values", nargs='+', type=int, help="list of k-values to explore [e.g., 2 4 20 24]", default=[])
parser.add_argument("--sub_pops", nargs="+", help="Number of sub populations", required=True, default=[])
parser.add_argument("--maxalleles", type=int, help="Maximum number of alleles", default=50)
parser.add_argument("--save_figs", type=bool, help="Save figures or not?", default=False)
parser.add_argument("--burnintime", type=int, help="How long to wait before making measurements? ", default=2000)
parser.add_argument("--rewiringprob", type=float, help="Probability of random rewiring", default=0)
config = parser.parse_args()
# setup output directories for writing
output_path = utils.setup_output(config.experiment)
# check the k and migration rate combinations
check = utils.check_k_and_migration_rates(config)
if check is not True:
print("\nProblem(s):\t %s\n" % check)
print("Please adjust input values for k and/or migration rate and restart.\n ")
sys.exit()
else:
print("\nChecked on the migration and k values -- all looks good!\n")
# save parameters
utils.save_parameters(str(sys.argv), config, output_path)
# set up the frequencies for the alleles in each loci. Here assuming a uniform distribution as a starting point
distribution = utils.constructUniformAllelicDistribution(config.maxinittraits)
# prepare file for output
output_data_file_name = "%s/%s-rare-trait-output.csv" % (output_path, config.experiment)
with open(output_data_file_name, mode='w') as output_file:
output_writer = csv.writer(output_file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
output_writer.writerow(["Iteration", "k", "NumSubPops", "Migration", "InnovationRate", "Ones_Mean",
"Ones_95%_Lower", "Ones_95%_Upper", "Twos_Mean", "Twos_95%_Lower", "Twos_95%_Upper", "Richness_Mean",
"Richness_95%_Lower", "Richness_95%_Upper","Fst_Mean","Fst_95%_Lower","Fst_95%_Upper"])
output_file.flush()
subpop_run_values = config.sub_pops
k_run_values = config.k_values
mig_run_values = config.migrationfraction
innov_run_values = config.innovrate
iteration=-1
for subpop in subpop_run_values:
if k_run_values == [0]:
k_run_values = [2, int(float(subpop) * .1), int(float(subpop) * .2),
int(float(subpop) * .5), int(float(subpop) * .8),
int(float(subpop) * .9),
int(subpop) - 1]
for k in k_run_values:
for mig in mig_run_values:
for innov in innov_run_values:
## let us know whats happening
iteration += 1
print("Now running with subpops: %s k-value: %s mig rate: %4f innov rate: %4f" % (subpop,k,mig,innov))
## these are lists of things that simuPop will do at different stages
init_ops = OrderedDict()
pre_ops = OrderedDict()
post_ops = OrderedDict()
# Construct a demographic model
#networkmodel = NetworkModel( networkmodel="/Users/clipo/Documents/PycharmProjects/RapaNuiSim/notebooks/test_graph.gml",
networkmodel = network.NetworkModel( networkmodel=config.networkfile,
simulation_id=config.experiment,
sim_length=config.simlength,
burn_in_time=config.burnintime,
initial_subpop_size=config.popsize,
migrationfraction=mig,
sub_pops=subpop,
connectedness=k, # if 0, then distance decay
save_figs=config.save_figs,
network_iteration=iteration)
num_pops = networkmodel.get_subpopulation_number()
sub_pop_size = int(config.popsize / num_pops)
# The regional network model defines both of these, in order to configure an initial population for evolution
# Construct the initial population
pops = sp.Population(size = [sub_pop_size]*num_pops,
subPopNames = str(list(networkmodel.get_subpopulation_names())),
infoFields = 'migrate_to',
ploidy=1,
loci=config.numloci )
### now set up the activities
init_ops['acumulators'] = sp.PyOperator(utils.init_acumulators, param=['fst','alleleFreq', 'haploFreq'])
init_ops['subpop_counts'] = sp.PyOperator(utils.init_count_traits_in_subpops)
init_ops['Sex'] = sp.InitSex()
init_ops['Freq'] = sp.InitGenotype(loci=list(range(config.numloci)),freq=distribution)
post_ops['Innovate'] = sp.KAlleleMutator(k=config.maxalleles, rates=innov, loci=sp.ALL_AVAIL)
post_ops['mig']=sp.Migrator(rate=networkmodel.get_migration_matrix()) #, reps=[3])
post_ops['Stat-fst'] = sp.Stat(structure=sp.ALL_AVAIL)
post_ops['Stat-richness']=sp.Stat(alleleFreq=[0], haploFreq=[0], vars=['alleleFreq','haploFreq','alleleNum', 'genoNum'])
post_ops['fst_acumulation'] = sp.PyOperator(utils.update_acumulator, param=['fst','F_st'])
post_ops['richness_acumulation'] = sp.PyOperator(utils.update_richness_acumulator, param=('alleleFreq', 'Freq of Alleles'))
post_ops['class_richness']=sp.PyOperator(utils.calculateAlleleAndGenotypeFrequencies, param=(config.popsize,config.numloci))
post_ops['count_traits_in_subpops'] = sp.PyOperator(utils.count_traits_in_subpops, param=(config.numloci,num_pops), subPops=sp.ALL_AVAIL)
mating_scheme = sp.RandomSelection()
## go simuPop go! evolve your way to the future!
sim = sp.Simulator(pops, rep=config.reps)
sim.evolve(initOps=list(init_ops.values()), preOps=list(pre_ops.values()), postOps=list(post_ops.values()),
matingScheme=mating_scheme, gen=config.simlength)
count=0
for pop in sim.populations():
output[count] = deepcopy(pop.dvars())
count+=1
ones_point_in_time = []
twos_point_in_time = []
richness_point_in_time = []
fst_point_in_time = []
for n in range(config.reps):
list_of_ones = list(output[n].ones)
list_of_twos = list(output[n].twos)
list_of_richness = list(output[n].richness)
list_of_fst = list(output[n].fst)
ones_point_in_time.append(list_of_ones[2000])
twos_point_in_time.append(list_of_twos[2000])
richness_point_in_time.append(list_of_richness[2000])
fst_point_in_time.append(list_of_fst[2000])
(ones_ave, ones_min, ones_max) = utils.mean_confidence_interval(ones_point_in_time,
confidence=0.95)
(twos_ave, twos_min, twos_max) = utils.mean_confidence_interval(twos_point_in_time,
confidence=0.95)
(richness_ave, richness_min, richness_max) = utils.mean_confidence_interval(richness_point_in_time,
confidence=0.95)
(fst_ave, fst_min, fst_max) = utils.mean_confidence_interval(fst_point_in_time,
confidence=0.95)
output_writer.writerow([iteration,k,subpop,mig,innov,ones_ave,ones_min,ones_max,
twos_ave,twos_min,twos_max,richness_ave,richness_min,richness_max,fst_ave,fst_min,fst_max])
output_file.flush()
def main():
start = time()
MAXALLELES = 10000
parser = argparse.ArgumentParser()
parser.add_argument("--experiment",
help="provide name for experiment",
required=True,
type=str)
parser.add_argument(
"--cores",
type=int,
help=
"Number of cores to use for simuPOP, overrides devel flag and auto calculation"
)
parser.add_argument("--debug", help="turn on debugging output")
parser.add_argument("--devel",
help="Use only half of the available CPU cores",
type=int,
default=1)
parser.add_argument("--dbhost",
help="database hostname, defaults to localhost",
default="localhost")
parser.add_argument("--dbport",
help="database port, defaults to 27017",
default="27017")
parser.add_argument("--stepsize",
help="size of sample by proportion",
type=float,
default=1.0)
parser.add_argument("--reps",
help="Replicated populations per parameter set",
type=int,
default=4)
parser.add_argument(
"--networkfile",
help=
"Name of GML file representing the network model for this simulation",
required=True,
type=str)
parser.add_argument("--numloci",
help="Number of loci per individual",
type=int,
required=True)
parser.add_argument(
"--maxinittraits",
help="Max initial number of traits per locus for initialization",
type=int,
required=True)
parser.add_argument(
"--samplefraction",
help=
"Size of samples taken to calculate all statistics, as a proportion",
type=float,
required=True)
parser.add_argument(
"--innovrate",
help=
"Rate at which innovations occur in population as a per-locus rate",
type=float,
required=True)
parser.add_argument(
"--simlength",
help=
"Time at which simulation and sampling end, defaults to 3000 generations",
type=int,
default="3000")
parser.add_argument(
"--popsize",
help="Initial size of population for each community in the model",
type=int,
required=True)
parser.add_argument(
"--migrationfraction",
help="Fraction of population that migrates each time step",
type=float,
required=True,
default=0.2)
parser.add_argument(
"--seed",
type=int,
help="Seed for random generators to ensure replicability")
(config, sim_id, script, cores) = setup(parser)
log.info("config: %s", config)
beginCollectingData = cpm.expectedIAQuasiStationarityTimeHaploid(
config.popsize, config.innovrate)
log.info("Starting data collection at generation: %s", beginCollectingData)
### NOTE ###
###
### the simuPOP module is deliberately imported here because we need to process the
### command line arguments first, to understand which version of the simuPOP module (e.g.,
### long allele representation, etc, to import, and because we need to figure out how
### many cores the machine has, etc., to set it up for parallel processing. If we import
### at the top of the file as normal, the imports happen before any code is executed,
### and we can't set those options. DO NOT move these imports out of setup and main.
import simuPOP as sim
import demography as demo
log.info("Starting simulation run %s", sim_id)
log.debug("config: %s", config)
if config.seed is None:
log.info(
"No random seed given, allowing RNGs to initialize with random seed"
)
else:
log.debug("Seeding RNGs with seed: %s", config.seed)
npr.seed(config.seed)
random.seed(config.seed)
full_command_line = " ".join(sys.argv)
# Calculate the burn in time
burn_time = rapanuisim.utils.simulation_burnin_time(
config.popsize, config.innovrate)
log.info("Minimum burn in time given popsize and theta: %s", burn_time)
initial_distribution = rapanuisim.utils.constructUniformAllelicDistribution(
config.maxinittraits)
log.info("Initial allelic distribution (for each locus): %s",
initial_distribution)
#innovation_rate = pypopgen.wf_mutation_rate_from_theta(config.popsize, config.innovrate)
innovation_rate = float(config.innovrate)
log.info("Per-locus innov rate within populations: %s", innovation_rate)
# Construct a demographic model from a collection of network slices which represent a temporal network
# of changing subpopulations and interaction strengths. This object is Callable, and simply is handed
# to the mating function which applies it during the copying process
networkmodel = demo.NetworkModel(
networkmodel=config.networkfile,
simulation_id=sim_id,
sim_length=config.simlength,
burn_in_time=burn_time,
initial_subpop_size=config.popsize,
migrationfraction=config.migrationfraction)
# The regional network model defines both of these, in order to configure an initial population for evolution
# Construct the initial population
pop = sim.Population(size=networkmodel.get_initial_size(),
subPopNames=networkmodel.get_subpopulation_names(),
infoFields=networkmodel.get_info_fields(),
ploidy=1,
loci=config.numloci)
log.info("population sizes: %s names: %s", pop.subPopSizes(),
pop.subPopNames())
initial_distribution = utils.constructUniformAllelicDistribution(
config.numloci)
log.info("Initial allelic distribution: %s", initial_distribution)
# We are going to evolve the same population over several replicates, in order to measure how stochastic variation
# effects the measured copying process.
simu = sim.Simulator(pop, rep=config.reps)
# Start the simulation and evolve the population, taking samples after the burn-in time has elapsed
simu.evolve(
initOps=sim.InitGenotype(freq=initial_distribution),
preOps=[
sim.PyOperator(func=sampling.logGenerationCount,
param=(),
step=100,
reps=0)
],
matingScheme=sim.RandomSelection(subPopSize=networkmodel),
postOps=[
sim.KAlleleMutator(k=MAXALLELES,
rates=config.innovrate,
loci=sim.ALL_AVAIL),
# sim.PyOperator(func=rapanuisim.data.sampleNumAlleles,
# param=(config.samplefraction, config.innovrate, config.popsize, sim_id, config.numloci),
# step=1, begin=beginCollectingData),
# sim.PyOperator(func=rapanuisim.data.sampleTraitCounts,
# param=(config.samplefraction, config.innovrate, config.popsize, sim_id, config.numloci),
# step=1, begin=beginCollectingData),
# sim.PyOperator(func=rapanuisim.data.censusTraitCounts,
# param=(config.innovrate, config.popsize, sim_id, config.numloci), step=1,
# begin=beginCollectingData),
# sim.PyOperator(func=rapanuisim.data.censusNumAlleles,
# param=(config.innovrate, config.popsize, sim_id, config.numloci), step=1,
# begin=beginCollectingData)
# #sim.PyOperator(func=rapanuisim.data.sampleIndividuals,
# ## param=(config.samplefraction, config.innovrate, config.popsize, sim_id, config.numloci),
# # step=1, begin=beginCollectingData),
],
gen=3000)
endtime = time()
elapsed = endtime - start
#log.info("simulation complete in %s seconds with %s cores", elapsed, cores)
log.info("simulation complete,%s,%s", cores, elapsed)
log.info("Ending simulation run at generation %s",
simu.population(0).dvars().gen)
sampled_length = int(config.simlength) - burn_time
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--experiment",
help="provide name for experiment",
required=True,
type=str,
default="test")
parser.add_argument("--debug", help="turn on debugging output")
parser.add_argument("--reps",
help="Replicated populations per parameter set",
type=int,
default=1)
parser.add_argument(
"--networkfile",
help=
"Name of GML file representing the network model for this simulation",
required=True,
type=str)
parser.add_argument("--numloci",
help="Number of loci per individual",
type=int,
required=True)
parser.add_argument(
"--maxinittraits",
help="Max initial number of traits per locus for initialization",
type=int,
required=True)
parser.add_argument(
"--innovrate",
help=
"Rate at which innovations occur in population as a per-locus rate",
type=float,
default=0.001)
parser.add_argument(
"--simlength",
help=
"Time at which simulation and sampling end, defaults to 3000 generations",
type=int,
default="20")
parser.add_argument(
"--popsize",
help="Initial size of population for each community in the model",
type=int,
required=True)
parser.add_argument(
"--migrationfraction",
nargs='+',
help="Fraction of population that migrates each time step",
type=float,
required=True,
default=[])
parser.add_argument(
"--seed",
type=int,
help="Seed for random generators to ensure replicability")
parser.add_argument("--k_values",
nargs='+',
type=int,
help="list of k-values to explore [e.g., 2 4 20 24",
default=[])
parser.add_argument("--sub_pops",
nargs='+',
help="Number of sub populations",
required=True,
default=[10])
parser.add_argument("--maxalleles",
type=int,
help="Maximum number of alleles",
default=50)
parser.add_argument("--save_figs",
type=bool,
help="Save figures or not?",
default=True)
parser.add_argument("--burnintime",
type=int,
help="How long to wait before making measurements? ",
default=2000)
parser.add_argument("--rewiringprob",
type=float,
help="Probability of random rewiring",
default=0)
config = parser.parse_args()
# check the k and migration rate combinations
for kvalue in config.k_values:
if float(kvalue) * float(config.migrationfraction) >= 1.0:
print("k=%s * mig=%4f is greater than 1.0\n" %
(kvalue, config.migrationfraction))
print(
"Please adjust input values for k and/or migration rate and restart.\n "
)
sys.exit()
# setup output directories for writing
output_path = utils.setup_output(config.experiment)
# save parameters
utils.save_parameters(str(sys.argv), config, output_path)
k_run_values = config.k_values
subpop_run_values = config.sub_pops
## make sure the k values are less than # of subpops and > 1
for k in k_run_values:
for subnum in subpop_run_values:
if int(k) > int(subnum) or int(k) < 2:
print(
"k values can not be greater than the number of sub populations. k = %s subpops = %s \n"
% (k, subnum))
sys.exit()
## initialize the output dictionary
for k in k_run_values:
for sb in subpop_run_values:
output[k][sb] = {}
# set up the frequencies for the alleles in each loci. Here assuming a uniform distribution as a starting point
distribution = utils.constructUniformAllelicDistribution(
config.maxinittraits)
iteration_number = -1
for k in k_run_values:
for subnum in subpop_run_values:
iteration_number += 1
## these are lists of things that simuPop will do at different stages
init_ops = OrderedDict()
pre_ops = OrderedDict()
post_ops = OrderedDict()
# Construct a demographic model from a collection of network slices which represent a temporal network
# of changing subpopulations and interaction strengths. This object is Callable, and simply is handed
# to the mating function which applies it during the copying process
#networkmodel = NetworkModel( networkmodel="/Users/clipo/Documents/PycharmProjects/RapaNuiSim/notebooks/test_graph.gml",
networkmodel = network.NetworkModel(
networkmodel="smallworld",
simulation_id=config.experiment,
sim_length=config.simlength,
burn_in_time=config.burnintime,
initial_subpop_size=config.popsize,
migrationfraction=config.migrationfraction,
sub_pops=subnum,
connectedness=k, # if 0, then distance decay
save_figs=config.save_figs,
network_iteration=iteration_number)
num_pops = networkmodel.get_subpopulation_number()
sub_pop_size = int(config.popsize / num_pops)
# The regional network model defines both of these, in order to configure an initial population for evolution
# Construct the initial population
pops = sp.Population(
size=[sub_pop_size] * num_pops,
subPopNames=str(list(networkmodel.get_subpopulation_names())),
infoFields='migrate_to',
ploidy=1,
loci=config.numloci)
### now set up the activities
init_ops['acumulators'] = sp.PyOperator(
utils.init_acumulators,
param=['fst', 'alleleFreq', 'haploFreq'])
init_ops['Sex'] = sp.InitSex()
init_ops['Freq'] = sp.InitGenotype(loci=list(range(
config.numloci)),
freq=distribution)
post_ops['Innovate'] = sp.KAlleleMutator(k=config.maxalleles,
rates=config.innovrate,
loci=sp.ALL_AVAIL)
post_ops['mig'] = sp.Migrator(
rate=networkmodel.get_migration_matrix()) #, reps=[3])
#for i, mig in enumerate(migs):
# post_ops['mig-%d' % i] = sp.Migrator(demography.migrIslandRates(mig, num_pops), reps=[i])
post_ops['Stat-fst'] = sp.Stat(structure=sp.ALL_AVAIL)
post_ops['Stat-richness'] = sp.Stat(
alleleFreq=[0],
haploFreq=[0],
vars=['alleleFreq', 'haploFreq', 'alleleNum', 'genoNum'])
post_ops['fst_acumulation'] = sp.PyOperator(
utils.update_acumulator, param=['fst', 'F_st'])
post_ops['richness_acumulation'] = sp.PyOperator(
utils.update_richness_acumulator,
param=('alleleFreq', 'Freq of Alleles'))
post_ops['class_richness'] = sp.PyOperator(
utils.calculateAlleleAndGenotypeFrequencies,
param=(config.popsize, config.numloci))
mating_scheme = sp.RandomSelection()
#mating_scheme=sp.RandomSelection(subPopSize=sub_pop_size)
## go simuPop go! evolve your way to the future!
sim = sp.Simulator(pops, rep=config.reps)
print("now evolving... k = %s with sub_pops = %s" % (k, subnum))
sim.evolve(initOps=list(init_ops.values()),
preOps=list(pre_ops.values()),
postOps=list(post_ops.values()),
matingScheme=mating_scheme,
gen=config.simlength)
# now make a figure of the Fst results
fig = plt.figure(figsize=(16, 9))
ax = fig.add_subplot(111)
count = 0
for pop in sim.populations():
ax.plot(pop.dvars().fst, label='Replicate: %s' % count)
output[k][subnum][count] = deepcopy(pop.dvars())
count += 1
ax.legend(loc=2)
ax.set_ylabel('FST')
ax.set_xlabel('Generation')
plt.show()
sum_fig = plt.figure(figsize=(16, 9))
ax = sum_fig.add_subplot(111)
iteration = -1
for k in k_run_values:
for subnum in subpop_run_values:
iteration += 1
# only label the first one
for n in range(config.reps):
if n == 0:
ax.plot(output[k][subnum][n].fst,
color=list(
dict(mcolors.BASE_COLORS,
**mcolors.CSS4_COLORS).keys())[iteration],
label='k = %s subpops = %s' % (k, subnum))
else:
ax.plot(output[k][subnum][n].fst,
color=list(
dict(mcolors.BASE_COLORS,
**mcolors.CSS4_COLORS).keys())[iteration])
ax.legend(loc=2)
ax.set_ylabel('Fst')
ax.set_xlabel('Generations')
plt.show()
savefilename = output_path + "/sum_fig.png"
sum_fig.savefig(savefilename, bbox_inches='tight')
rich_fig = plt.figure(figsize=(16, 9))
ax = rich_fig.add_subplot(111)
iteration = -1
for k in k_run_values:
for sb in subpop_run_values:
iteration += 1
# only add a label for the first one (not all the replicates)
for n in range(config.reps):
if n == 0:
ax.plot(output[k][subnum][n].richness,
color=list(
dict(mcolors.BASE_COLORS,
**mcolors.CSS4_COLORS).keys())[iteration],
label='k = %s subpops = %s' % (k, subnum))
else:
ax.plot(output[k][subnum][n].richness,
color=list(
dict(mcolors.BASE_COLORS,
**mcolors.CSS4_COLORS).keys())[iteration])
ax.legend(loc=2)
ax.set_ylabel('Richness')
ax.set_xlabel('Generations')
plt.show()
savefilename = output_path + "/richness.png"
rich_fig.savefig(savefilename, bbox_inches='tight')
## output CI for the parameters
summary_fig = plt.figure(figsize=(16, 9))
ax = summary_fig.add_subplot(111)
iteration = -1
for k in k_run_values:
for subnum in subpop_run_values:
iteration += 1
CI_average = []
CI_min = []
CI_max = []
for t in range(len(output[k][subnum][0].fst)):
point_in_time = []
for n in range(config.reps):
list_of_points = list(output[k][subnum][n].fst)
point_in_time.append(list_of_points[t])
(ave, min,
max) = utils.mean_confidence_interval(point_in_time,
confidence=0.95)
CI_average.append(ave)
CI_min.append(min)
CI_max.append(max)
ax.plot(list(CI_average),
color=list(
dict(mcolors.BASE_COLORS,
**mcolors.CSS4_COLORS).keys())[iteration],
label='k = %s subpops = %s' % (k, subnum))
ax.plot(list(CI_min), "--", color="0.5")
ax.plot(list(CI_max), "--", color="0.5")
ax.fill_between(list(CI_average),
list(CI_max),
list(CI_min),
color="None",
linestyle="--")
ax.legend(loc=2)
ax.set_ylabel('Fst')
ax.set_xlabel('Generation')
plt.show()
savefilename = output_path + "/summary-ci.png"
summary_fig.savefig(savefilename, bbox_inches='tight')
## now the richness graph
richness_sum_fig = plt.figure(figsize=(16, 9))
ax = richness_sum_fig.add_subplot(111)
iteration = -1
for k in k_run_values:
for subnum in subpop_run_values:
iteration += 1
CI_average = []
CI_min = []
CI_max = []
for t in range(len(output[k][subnum][0].richness)):
point_in_time = []
for n in range(config.reps):
list_of_points = list(output[k][subnum][n].richness)
point_in_time.append(list_of_points[t])
(ave, min,
max) = utils.mean_confidence_interval(point_in_time,
confidence=0.95)
CI_average.append(ave)
CI_min.append(min)
CI_max.append(max)
ax.plot(list(CI_average),
color=list(
dict(mcolors.BASE_COLORS,
**mcolors.CSS4_COLORS).keys())[iteration],
label='k = %s subpops = %s' % (k, subnum))
ax.plot(list(CI_min), "--", color="0.5")
ax.plot(list(CI_max), "--", color="0.5")
ax.fill_between(list(CI_average),
list(CI_max),
list(CI_min),
color="None",
linestyle="--")
ax.legend(loc=2)
ax.set_ylabel('Richness')
ax.set_xlabel('Generation')
plt.show()
savefilename = output_path + "/richness-ci.png"
richness_sum_fig.savefig(savefilename, bbox_inches='tight')
# The regional network model defines both of these, in order to configure an initial population for evolution
# Construct the initial population
pops = sp.Population(size=networkmodel.get_initial_size(),
subPopNames=str(
list(networkmodel.get_subpopulation_names())),
infoFields='migrate_to',
ploidy=1,
loci=100)
### now set up the activities
init_ops['acumulators'] = sp.PyOperator(
init_acumulators, param=['fst', 'alleleFreq', 'haploFreq'])
init_ops['Sex'] = sp.InitSex()
init_ops['Freq'] = sp.InitGenotype(loci=0, freq=distribution)
post_ops['Innovate'] = sp.KAlleleMutator(k=MAXALLELES,
rates=innovation_rate,
loci=sp.ALL_AVAIL)
#post_ops['mig'] = sp.Migrator(demography.migrIslandRates(migration_rate, num_pops)) #, reps=[i])
post_ops['mig'] = sp.Migrator(rate=networkmodel.get_migration_matrix())
#for i, mig in enumerate(migs):
# post_ops['mig-%d' % i] = sp.Migrator(demography.migrIslandRates(mig, num_pops), reps=[i])
post_ops['Stat-fst'] = sp.Stat(structure=sp.ALL_AVAIL)
#post_ops['haploFreq']=sp.stat(pops, haploFreq=[0], vars=['haploFreq', 'haploNum'])
#post_ops['alleleFreq']=sp.stat(pops, alleleFreq=sp.ALL_AVAIL)
post_ops['Stat-richness'] = sp.Stat(
alleleFreq=[0],
haploFreq=[0],
vars=['alleleFreq', 'haploFreq', 'alleleNum', 'genoNum'])
post_ops['fst_acumulation'] = sp.PyOperator(update_acumulator,
# 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(size=[2000], loci=1 * 3)
pop.evolve(
initOps=sim.InitSex(),
matingScheme=sim.RandomMating(),
postOps=[
sim.KAlleleMutator(k=5, rates=[1e-2, 1e-3], loci=[0, 1]),
sim.Stat(alleleFreq=range(3), step=100),
sim.PyEval(
r"', '.join(['%.3f' % alleleFreq[x][0] for x in range(3)]) + '\n'",
step=100),
],
gen=500)
def evolvePop(model,
N0,
N1,
G0,
G1,
initSpec,
mu,
k,
fitness,
m=1,
migrRate=0,
logfile='',
sp_logfile='',
**kwargs):
'''Evolve a population with specified allele frequencies (parameter
initSpec) using given demographic (model, N0, N1, G0, G1, m), mutation
(a k-allele model with parameters mu and k) and natural selection models
(a multi-locus selection model with fitness vector s). Total disease
allele frequency and effective number of alleles in the population
and in all subpopulations are recorded if names of log files are provided.
This function returns a tuple of these two statistics at the end of the
evolution. Additional keyword arguments could be used to control when and
how often statisitcs are outputed.
'''
L = len(fitness) // 3
if not hasattr(mu, '__iter__'): # if a single mutation rate is given
mu = [mu] * L
# Create expressions to output f_e and ne at all loci, which are
# "%d\t%.4f\t%.4f\n" % (gen, 1-alleleFreq[x][0], ne[x])
# for locus x.
statExpr = '"%d' + r'\t%.4f\t%.4f'*L + r'\n" % (gen,' + \
', '.join(['1-alleleFreq[%d][0], ne[%d]' % (x, x) for x in range(L)]) + ')'
demo_func = demoModel(model, N0, N1, G0, G1, m)
pop = sim.Population(size=demo_func(0),
loci=[1] * L,
infoFields=['fitness', 'migrate_to'])
pop.evolve(
initOps=[sim.InitSex(), sim.InitGenotype(freq=initSpec)],
preOps=[
sim.KAlleleMutator(k=k, rates=mu, loci=range(L)),
sim.MlSelector([
sim.MaSelector(loci=i, fitness=fitness[3 * i:3 * (i + 1)])
for i in range(L)
],
mode=sim.MULTIPLICATIVE),
sim.Migrator(rate=migrIslandRates(migrRate, m), begin=G0 + 1),
],
matingScheme=sim.RandomMating(subPopSize=demo_func),
postOps=[
sim.IfElse(
logfile != '' or sp_logfile != '',
Ne(loci=sim.ALL_AVAIL,
vars=['ne'] if m == 1 else ['ne', 'ne_sp']), **kwargs),
sim.IfElse(logfile != '',
sim.PyEval(statExpr, output='>>' + logfile), **kwargs),
sim.IfElse(
m > 1 and sp_logfile != '',
sim.PyEval(
statExpr,
output='>>' + sp_logfile,
# subPops=sim.ALL_AVAIL will evalulate the expression in each
# subpopulation's local namespace (vars(sp)).
subPops=sim.ALL_AVAIL,
begin=G0),
**kwargs),
],
finalOps=Ne(loci=sim.ALL_AVAIL),
gen=G0 + G1)
return tuple([1-pop.dvars().alleleFreq[x][0] for x in range(L)] + \
[pop.dvars().ne[x] for x in range(L)])
sim_length)
pop = sim.Population(size=popsize, ploidy=1, loci=numloci)
simu = sim.Simulator(pop, rep=replications_per_paramset)
simu.evolve(
initOps=sim.InitGenotype(freq=initial_distribution),
preOps=[
sim.PyOperator(func=utils.logGenerationCount,
param=(),
step=gen_logging_interval,
reps=0),
],
matingScheme=sim.RandomSelection(),
postOps=[
sim.KAlleleMutator(k=simconfig.MAXALLELES, rates=mut),
sim.PyOperator(func=data.sampleNumAlleles,
param=(sample_size, mut, popsize, sim_id, numloci),
step=sampling_interval,
begin=time_start_stats),
sim.PyOperator(func=data.sampleTraitCounts,
param=(sample_size, mut, popsize, sim_id, numloci),
step=sampling_interval,
begin=time_start_stats),
sim.PyOperator(func=data.censusTraitCounts,
param=(mut, popsize, sim_id, numloci),
step=sampling_interval,
begin=time_start_stats),
sim.PyOperator(func=data.censusNumAlleles,
param=(mut, popsize, sim_id, numloci),
step=sampling_interval,
# the user's guide (http://simupop.sourceforge.net/manual) for a detailed
# description of this example.
#
import simuPOP as sim
pop = sim.Population(5000, loci=[1, 1])
pop.evolve(
initOps=[sim.InitSex(), sim.InitGenotype(genotype=[50, 50])],
preOps=[
# the first locus uses a pure stepwise mutation model
sim.StepwiseMutator(rates=0.001, loci=0),
# the second locus uses a mixed model
sim.MixedMutator(rates=0.001,
loci=1,
mutators=[
sim.KAlleleMutator(rates=1, k=100),
sim.StepwiseMutator(rates=1)
],
prob=[0.1, 0.9])
],
matingScheme=sim.RandomMating(),
gen=20)
# what alleles are there?
geno0 = []
geno1 = []
for ind in pop.individuals():
geno0.extend([ind.allele(0, 0), ind.allele(0, 1)])
geno1.extend([ind.allele(1, 0), ind.allele(1, 1)])
print('Locus 0 has alleles', ', '.join([str(x) for x in set(geno0)]))
print('Locus 1 has alleles', ', '.join([str(x) for x in set(geno1)]))
