def input_models(alpha_ss: float, alpha_rr: float, beta_ss: float,
beta_rr: float, dominance: float) -> list:
"""
Setup the input models
Args:
alpha_ss: growth constant ss
alpha_rr: growth constant rr
beta_ss: cost constant ss
beta_rr: cost constant rr
dominance: dominance degree
Returns:
input models
"""
return [
growth.max_gut(),
growth.growth(alpha_ss, alpha_rr, beta_ss, beta_rr, dominance),
init_bio.init_num(param.lam_0_egg),
init_bio.init_mass(param.mu_0_egg_ss, param.mu_0_egg_rr,
param.sig_0_egg_ss, param.sig_0_egg_rr,
dominance),
init_bio.init_juvenile(param.mu_0_larva_ss, param.mu_0_larva_rr,
param.sig_0_larva_ss, param.sig_0_larva_rr,
dominance),
init_bio.init_mature(param.mu_0_mature_ss, param.mu_0_mature_rr,
param.sig_0_mature_ss, param.sig_0_mature_rr,
dominance),
init_bio.init_plant(param.mu_leaf, param.sig_leaf),
repro.init_sex(param.female_prob)
]
def input_models(mate_encounter: float, mate_radius: float):
"""
Create all the input models
Args:
mate_encounter: mate encounter constant
mate_radius: mate radius
Returns:
input models
"""
return [
growth.max_gut(),
growth.growth(param.alpha_ss, param.alpha_rr, param.beta_ss,
param.beta_rr, dominance),
init_bio.init_num(param.lam_0_egg),
init_bio.init_mass(param.mu_0_egg_ss, param.mu_0_egg_rr,
param.sig_0_egg_ss, param.sig_0_egg_rr,
dominance),
init_bio.init_juvenile(param.mu_0_larva_ss, param.mu_0_larva_rr,
param.sig_0_larva_ss, param.sig_0_larva_rr,
dominance),
init_bio.init_mature(param.mu_0_mature_ss, param.mu_0_mature_rr,
param.sig_0_mature_ss, param.sig_0_mature_rr,
dominance),
init_bio.init_plant(param.mu_leaf, param.sig_leaf),
move.adult(param.adult_scale, param.adult_shape),
repro.mating(mate_encounter),
repro.radius(mate_radius),
repro.fecundity(param.fecundity_maximum, param.fecundity_decay),
repro.density(param.eta, param.gamma),
repro.init_sex(param.female_prob)
]
def input_models(fight_slope: float,
move_scale: float,
move_shape: float,
encounter_rate: float,
alpha_ss: float,
alpha_rr: float,
beta_ss: float,
beta_rr: float) -> list:
"""
Create the input models
Args:
fight_slope: slope of a fight
move_scale: movement scale parameter
move_shape: movement shape parameter
encounter_rate: encounter rate constant
alpha_ss: growth rate ss
alpha_rr: growth rate rr
beta_ss: cost ss
beta_rr: cost rr
Returns:
"""
return [
growth.max_gut(),
growth.growth(alpha_ss,
alpha_rr,
beta_ss,
beta_rr,
dominance),
init_bio.init_num(param.lam_0_egg),
init_bio.init_mass(param.mu_0_egg_ss,
param.mu_0_egg_rr,
param.sig_0_egg_ss,
param.sig_0_egg_rr,
dominance),
init_bio.init_juvenile(44.194,
18.947,
0.552,
0.17,
dominance),
init_bio.init_mature(param.mu_0_mature_ss,
param.mu_0_mature_rr,
param.sig_0_mature_ss,
param.sig_0_mature_rr,
dominance),
init_bio.init_plant(param.mu_leaf,
param.sig_leaf),
repro.init_sex(param.female_prob),
move.larva(move_scale,
move_shape),
forage.adlibitum(param.forage_steps),
forage.egg(param.egg_factor),
forage.larva(param.larva_factor),
forage.fight(fight_slope),
forage.radius(param.cannibalism_radius),
forage.encounter(encounter_rate)
]
class Fecundity(object):
"""
Class to setup and run a simulation of the female fecundity
Variables:
fecundity: the fecundity model
"""
init_num = init_bio.init_num(param.lam_0_egg)
fecundity = repro.fecundity(param.fecundity_maximum, param.fecundity_decay)
def run(self, ages: list) -> list:
"""
Run the model for each age
Args:
ages: list of ages
Returns:
list of number of eggs
"""
numbers = []
for age in ages:
number_egg_mass = self.fecundity(age, 0, 'none')
number_eggs = self.init_num('none')
numbers.append(number_egg_mass * number_eggs)
return numbers
@classmethod
def run_sim(cls, ages: list) -> list:
"""
Setup and rum the sim
Args:
ages: ages to simulate
Returns:
number of eggs produced
"""
new = cls()
return new.run(ages)
nums = (
(0, 0, 0),
(0, 0, 0),
(0, 0, 0),
(0, 0, 0),
(param.mix_preg_rr, 0, param.mix_preg_ss)
)
input_models = [
growth.max_gut(),
growth.growth(param.alpha_ss,
param.alpha_rr,
param.beta_ss,
param.beta_rr,
dominance),
init_bio.init_num(param.lam_0_egg),
init_bio.init_mass(param.mu_0_egg_ss,
param.mu_0_egg_rr,
param.sig_0_egg_ss,
param.sig_0_egg_rr,
dominance),
init_bio.init_juvenile(param.mu_0_larva_ss,
param.mu_0_larva_rr,
param.sig_0_larva_ss,
param.sig_0_larva_rr,
dominance),
init_bio.init_mature(param.mu_0_mature_ss,
param.mu_0_mature_rr,
param.sig_0_mature_ss,
param.sig_0_mature_rr,
dominance),
class Simulator(object):
"""
Class to setup and run a simulation of only biomass growth:
Variables:
nums: initial population numbers
forage: the plant forage model
"""
grid = [(keyword.hexagon, 1, 1, True),
(keyword.hexagon, 1, 1, True)]
attrs = {1: tracking.genotype_attrs}
data = (np.inf,)
emigration = []
immigration = []
input_models = [growth.max_gut(),
growth.growth(param.alpha_ss,
param.alpha_rr,
param.beta_ss,
param.beta_rr,
dominance),
init_bio.init_num(param.lam_0_egg),
init_bio.init_mass(param.mu_0_egg_ss,
param.mu_0_egg_rr,
param.sig_0_egg_ss,
param.sig_0_egg_rr,
dominance),
init_bio.init_juvenile(param.mu_0_larva_ss,
param.mu_0_larva_rr,
param.sig_0_larva_ss,
param.sig_0_larva_rr,
dominance),
init_bio.init_mature(param.mu_0_mature_ss,
param.mu_0_mature_rr,
param.sig_0_mature_ss,
param.sig_0_mature_rr,
dominance),
init_bio.init_plant(param.mu_leaf,
param.sig_leaf),
forage.adlibitum(1),
sex_model,
dev.egg_dev(param.mu_egg_dev,
param.sig_egg_dev),
dev.pupa_dev(param.mu_pupa_dev,
param.sig_pupa_dev)]
input_variables = param.repro_values
nums: hint.init_pops
bt_prop: float
steps: hint.step_tuples
offset_ss: float = 0
offset_rr: float = 0
simulation: hint.simulation = None
def __post_init__(self):
larva_dev = dev.larva_dev(param.mu_larva_dev_ss - self.offset_ss,
param.mu_larva_dev_rr - self.offset_rr,
param.sig_larva_dev_ss,
param.sig_larva_dev_rr,
dominance)
input_models = self.input_models.copy()
input_models.append(larva_dev)
self.simulation = main_simulation.Simulation. \
setup(self.nums,
self.grid,
self.attrs,
self.data,
self.bt_prop,
self.steps,
self.emigration,
self.immigration,
*input_models,
**self.input_variables)
def collect(self) -> dict:
"""
Collect a list of masses
Returns:
list of all masses in system
"""
larvae = self.simulation.agents.agents(keyword.pupa)
values = {
keyword.homo_r: [],
keyword.hetero: [],
keyword.homo_s: [],
}
for agent in larvae:
# noinspection PyUnresolvedReferences
values[agent.genotype].append(agent.mass)
return values
def run(self, times: list) -> None:
"""
Run the simulation for each time
Args:
times: the times for the simulation
Returns:
biomass data
"""
for _ in times[1:]:
self.simulation.step()
class Simulator(object):
"""
Class to setup and run a simulation of only biomass growth:
Variables:
nums: initial population numbers
forage: the plant forage model
"""
grid = [(keyword.hexagon, 1, 1, True), (keyword.hexagon, 1, 1, True)]
attrs = {1: tracking.genotype_attrs}
data = (np.inf, )
steps = [({
keyword.larva: [keyword.survive],
keyword.egg: [keyword.survive],
keyword.pupa: [keyword.survive],
keyword.female: [keyword.survive]
}, )]
emigration = []
immigration = []
input_models = [
growth.max_gut(),
growth.growth(param.alpha_ss, param.alpha_rr, param.beta_ss,
param.beta_rr, dominance),
init_bio.init_num(param.lam_0_egg),
init_bio.init_mass(param.mu_0_egg_ss, param.mu_0_egg_rr,
param.sig_0_egg_ss, param.sig_0_egg_rr, dominance),
init_bio.init_juvenile(param.mu_0_larva_ss, param.mu_0_larva_rr,
param.sig_0_larva_ss, param.sig_0_larva_rr,
dominance),
init_bio.init_mature(param.mu_0_mature_ss, param.mu_0_mature_rr,
param.sig_0_mature_ss, param.sig_0_mature_rr,
dominance),
init_bio.init_plant(param.mu_leaf, param.sig_leaf), sex_model,
sur.egg_sur(param.egg_prob),
sur.pupa_sur(param.pupa_prob),
sur.adult_sur(param.adult_prob)
]
input_variables = param.repro_values
# input_survive.larva_survival,
nums: hint.init_pops
bt_prop: float
ss_bt_sur: float = param.larva_prob_bt_low_ss
simulation: hint.simulation = None
def __post_init__(self):
larva_survive = sur.larva_sur(param.larva_prob_non_bt_rr,
param.larva_prob_non_bt_ss,
param.larva_prob_bt_rr, self.ss_bt_sur,
dominance)
input_models = self.input_models.copy()
input_models.append(larva_survive)
self.simulation = main_simulation.Simulation. \
setup(self.nums,
self.grid,
self.attrs,
self.data,
self.bt_prop,
self.steps,
self.emigration,
self.immigration,
*input_models,
**self.input_variables)
def run(self, times: list) -> None:
"""
Run the simulation for each time
Args:
times: the times for the simulation
Returns:
biomass data
"""
for _ in times[1:]:
self.simulation.step()
class Simulator(object):
"""
Class to setup and run a simulation of only biomass growth:
Variables:
nums: initial population numbers
forage: the plant forage model
"""
grid = [(keyword.hexagon, 1, 1, True), graph.graph(10)]
attrs = {1: tracking.genotype_attrs}
data = (np.inf, )
steps = [({
keyword.larva: [keyword.move, keyword.consume]
}, param.forage_steps), ({
keyword.larva: [keyword.grow, keyword.reset]
}, )]
emigration = []
immigration = []
input_models = [
growth.max_gut(),
growth.growth(param.alpha_ss, param.alpha_rr, param.beta_ss,
param.beta_rr, dominance),
init_bio.init_num(param.lam_0_egg),
init_bio.init_mass(param.mu_0_egg_ss, param.mu_0_egg_rr,
param.sig_0_egg_ss, param.sig_0_egg_rr, dominance),
init_bio.init_juvenile(44.194, 18.947, 0.552, 0.17, dominance),
init_bio.init_mature(param.mu_0_mature_ss, param.mu_0_mature_rr,
param.sig_0_mature_ss, param.sig_0_mature_rr,
dominance),
init_bio.init_plant(param.mu_leaf, param.sig_leaf),
repro.init_sex(param.female_prob),
move.larva(param.larva_scale, param.larva_shape),
forage.adlibitum(param.forage_steps),
forage.egg(param.egg_factor),
forage.larva(param.larva_factor),
forage.fight(param.fight_slope),
forage.radius(param.cannibalism_radius),
# forage.loss(param.loss_slope,
# param.mid,
# param.egg_factor,
# param.larva_factor)
]
input_variables = param.repro_values
nums: hint.init_pops
bt_prop: float
encounter: float
simulation: hint.simulation = None
def __post_init__(self):
input_models = self.input_models.copy()
input_models.append(forage.encounter(self.encounter))
self.simulation = main_simulation.Simulation. \
setup(self.nums,
self.grid,
self.attrs,
self.data,
self.bt_prop,
self.steps,
self.emigration,
self.immigration,
*input_models,
**self.input_variables)
def run_sim(self, times: list) -> None:
"""
Run the simulation for each time
Args:
times: the times for the simulation
Returns:
biomass data
"""
for _ in times[1:]:
self.simulation.step()
def get_start_data(self, data_key: str) -> int:
"""
Get the start population of larvae
Args:
data_key: the genotype table key
Returns:
the number of larvae at start
"""
dataframes = self.simulation.agents.dataframes()
larva = dataframes['(0, 0)_larva']
column = larva[data_key]
return int(column[0])
def get_final_data(self, data_key: str) -> int:
"""
Get the final population of larvae
Args:
data_key: the genotype table key
Returns:
the number of larvae at the end
"""
dataframes = self.simulation.agents.dataframes()
timestep = self.simulation.timestep
pupa = dataframes['(0, 0)_larva']
column = pupa[data_key]
value = column[timestep]
return int(value)
@classmethod
def run(cls, rho: float, times: list, data_key: str,
nums: hint.init_pops) -> tuple:
"""
Run a bunch of trials
Args:
rho: encounter constant
times: time interval
data_key: column key
nums: init_population
Returns:
value of cannibalism rate constant
"""
print(' {} Starting run for rho: {}'.format(datetime.datetime.now(),
rho))
start_data = []
end_data = []
for trial_num in range(trials):
print(' {} running trial: {}'.format(
datetime.datetime.now(), trial_num))
sim = cls(nums, 1, rho)
sim.run_sim(times)
start_data.append(sim.get_start_data(data_key))
end_data.append(sim.get_final_data(data_key))
start_pop = np.mean(start_data)
end_pop = np.mean(end_data)
start_lower = np.percentile(start_data, 2.5)
start_upper = np.percentile(start_data, 97.5)
end_lower = np.percentile(end_data, 2.5)
end_upper = np.percentile(end_data, 97.5)
prop = end_pop / start_pop
prop_lower = end_lower / start_lower
prop_upper = end_upper / start_upper
rate = 1 - prop
rate_lower = 1 - prop_lower
rate_upper = 1 - prop_upper
return prop, prop_lower, prop_upper, rate, rate_lower, rate_upper
@classmethod
def rho(cls, rhos: np.array, times: list, data_key: str,
nums: hint.init_pops) -> tuple:
"""
Run trials for each rho value
Args:
rhos: list of encounter constants
times: time interval
data_key: data key
nums: init population
Returns:
list of corresponding values for cannibalism
"""
prop = []
prop_lower = []
prop_upper = []
rate = []
rate_lower = []
rate_upper = []
for rho in rhos:
rho_prop, rho_prop_lower, rho_prop_upper, \
rho_rate, rho_rate_lower, rho_rate_upper = \
cls.run(rho, times, data_key, nums)
prop.append(rho_prop)
prop_lower.append(rho_prop_lower)
prop_upper.append(rho_prop_upper)
rate.append(rho_rate)
rate_lower.append(rho_rate_lower)
rate_upper.append(rho_rate_upper)
return prop, prop_lower, prop_upper, rate, rate_lower, rate_upper
class Simulator(object):
"""
Class to setup and run a simulation of only biomass growth:
Variables:
nums: initial population numbers
forage: the plant forage model
"""
grid = [(keyword.hexagon, 1, 1, True), (keyword.hexagon, 1, 1, True)]
attrs = {0: tracking.genotype_attrs}
data = (np.inf, )
emigration = []
immigration = []
input_models = [
growth.max_gut(),
growth.growth(param.alpha_ss, param.alpha_rr, param.beta_ss,
param.beta_rr, dominance),
init_bio.init_num(param.lam_0_egg),
init_bio.init_mass(param.mu_0_egg_ss, param.mu_0_egg_rr,
param.sig_0_egg_ss, param.sig_0_egg_rr, dominance),
init_bio.init_juvenile(param.mu_0_larva_ss, param.mu_0_larva_rr,
param.sig_0_larva_ss, param.sig_0_larva_rr,
dominance),
init_bio.init_mature(param.mu_0_mature_ss, param.mu_0_mature_rr,
param.sig_0_mature_ss, param.sig_0_mature_rr,
dominance),
init_bio.init_plant(param.mu_leaf, param.sig_leaf),
repro.init_sex(param.female_prob)
]
input_variables = param.repro_values
nums: hint.init_pops
bt_prop: float
forage: hint.forage_plant
develop: callable = None
steps: list = None
simulation: hint.simulation = None
def __post_init__(self):
input_models = self.input_models.copy()
input_models.append(self.forage)
inputs = tuple(input_models)
if self.develop is not None:
self.input_models.append(self.develop)
if self.steps is None:
self.steps = [({
keyword.larva: [keyword.consume, keyword.grow, keyword.reset]
}, )]
self.simulation = main_simulation.Simulation.\
setup(self.nums,
self.grid,
self.attrs,
self.data,
self.bt_prop,
self.steps,
self.emigration,
self.immigration,
*inputs,
**self.input_variables)
def collect(self) -> list:
"""
Collect a list of masses
Returns:
list of all masses in system
"""
larvae = self.simulation.agents.agents(keyword.larva)
values = []
for agent in larvae:
# noinspection PyUnresolvedReferences
values.append(agent.mass)
return values
def run(self, times: list) -> np.ndarray:
"""
Run the simulation for each time
Args:
times: the times for the simulation
Returns:
biomass data
"""
data = [self.collect()]
for time in times[1:]:
print(' {} Running step: {}'.format(datetime.datetime.now(),
time))
self.simulation.step()
data.append(self.collect())
return np.array(data)
class Simulator(object):
"""
Class to setup and run a simulation of only biomass growth:
Variables:
nums: initial population numbers
forage: the plant forage model
"""
attrs = {1: tracking.genotype_attrs,
2: tracking.genotype_attrs}
data = (np.inf,)
steps = [({keyword.larva: [keyword.move],
keyword.female: [keyword.move]},)]
emigration = []
immigration = []
input_models = [growth.max_gut(),
growth.growth(param.alpha_ss,
param.alpha_rr,
param.beta_ss,
param.beta_rr,
dominance),
init_bio.init_num(param.lam_0_egg),
init_bio.init_mass(param.mu_0_egg_ss,
param.mu_0_egg_rr,
param.sig_0_egg_ss,
param.sig_0_egg_rr,
dominance),
init_bio.init_juvenile(param.mu_0_larva_ss,
param.mu_0_larva_rr,
param.sig_0_larva_ss,
param.sig_0_larva_rr,
dominance),
init_bio.init_mature(param.mu_0_mature_ss,
param.mu_0_mature_rr,
param.sig_0_mature_ss,
param.sig_0_mature_rr,
dominance),
init_bio.init_plant(param.mu_leaf,
param.sig_leaf),
sex_model,
move.larva(param.larva_scale,
param.larva_shape),
move.adult(param.adult_scale,
param.adult_shape)]
input_variables = param.repro_values
nums: hint.init_pops
grid: hint.grid_generators
bt_prop: float
simulation: hint.simulation = None
def __post_init__(self):
self.simulation = main_simulation.Simulation. \
setup(self.nums,
self.grid,
self.attrs,
self.data,
self.bt_prop,
self.steps,
self.emigration,
self.immigration,
*self.input_models,
**self.input_variables)
def collect(self) -> tuple:
"""
Collect a list of locations
Returns:
tuple of locations
"""
larvae = self.simulation.agents.agents(keyword.larva)
adults = self.simulation.agents.agents(keyword.female)
larvae_values = []
for agent in larvae:
larvae_values.append(agent.location.copy())
adult_values = []
for agent in adults:
adult_values.append(agent.location.copy())
return larvae_values, adult_values
def run(self, times: list) -> tuple:
"""
Run the simulation for each time
Args:
times: the times for the simulation
Returns:
biomass data
"""
larva, adult = self.collect()
larvae = [larva]
adults = [adult]
for time in times[1:]:
print(' {} Running step: {}'.
format(datetime.datetime.now(), time))
self.simulation.step()
new_larva, new_adult = self.collect()
larvae.append(new_larva)
adults.append(new_adult)
return larvae, adults
class Simulator(object):
"""
Class to setup and run a simulation of only biomass growth:
Variables:
nums: initial population numbers
bt_prop: bt proportion
"""
grid = [graph.graph(field_grid), (keyword.hexagon, 1, 1, True)]
attrs = {0: tracking.genotype_attrs}
data = (np.inf, )
steps = [({
keyword.female: [keyword.move, keyword.reproduce],
keyword.male: [keyword.move]
}, param.forage_steps),
({
keyword.female: [keyword.advance_age, keyword.reset],
keyword.male: [keyword.advance_age, keyword.reset]
}, )]
emigration = []
immigration = []
input_models = [
growth.max_gut(),
growth.growth(param.alpha_ss, param.alpha_rr, param.beta_ss,
param.beta_rr, dominance),
init_bio.init_num(param.lam_0_egg),
init_bio.init_mass(param.mu_0_egg_ss, param.mu_0_egg_rr,
param.sig_0_egg_ss, param.sig_0_egg_rr, dominance),
init_bio.init_juvenile(param.mu_0_larva_ss, param.mu_0_larva_rr,
param.sig_0_larva_ss, param.sig_0_larva_rr,
dominance),
init_bio.init_mature(param.mu_0_mature_ss, param.mu_0_mature_rr,
param.sig_0_mature_ss, param.sig_0_mature_rr,
dominance),
init_bio.init_plant(param.mu_leaf, param.sig_leaf),
move.adult(param.adult_scale, param.adult_shape),
repro.mating(param.mate_encounter),
repro.radius(param.mate_radius),
repro.density(param.eta, param.gamma),
repro.init_sex(param.female_prob)
]
input_variables = param.repro_values
nums: hint.init_pops
bt_prop: float
simulation: hint.simulation = None
def __post_init__(self):
self.simulation = main_simulation.Simulation. \
setup(self.nums,
self.grid,
self.attrs,
self.data,
self.bt_prop,
self.steps,
self.emigration,
self.immigration,
*self.input_models,
**self.input_variables)
def collect(self) -> tuple:
"""
Collect the number of egg_masses
Returns:
number of egg_masses
"""
females = self.simulation.agents.agents(keyword.female)
mated = []
for female in females:
if female.mate is not None:
mated.append(female)
return len(females), len(mated)
def run(self, times: list) -> tuple:
"""
Run the simulation for each time
Args:
times: the times for the simulation
Returns:
num egg_mass, densities
"""
females, mated = self.collect()
data_females = [females]
data_mated = [mated]
data_prop = [mated / females]
for time in times[1:]:
print(' {} Running step: {}'.format(datetime.datetime.now(),
time))
self.simulation.step()
females, mated = self.collect()
data_females.append(females)
data_mated.append(mated)
data_prop.append(mated / females)
return data_females, data_mated, data_prop
