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),
 develop.egg_dev(param.mu_egg_dev,
                 param.sig_egg_dev),
 develop.larva_dev(param.mu_larva_dev_ss,
                   param.mu_larva_dev_rr,
                   param.sig_larva_dev_ss,
                   param.sig_larva_dev_rr,
                   dominance),
 develop.pupa_dev(param.mu_pupa_dev,
                  param.sig_pupa_dev),
 forage.adlibitum(param.forage_steps),
 forage.egg(param.egg_factor),
 forage.larva(param.larva_factor),
 forage.fight(param.fight_slope),
 forage.encounter(cannib),
 forage.radius(param.cannibalism_radius),
 move.larva(param.larva_scale,
            param.larva_shape),
 move.adult(param.adult_scale,
            param.adult_shape),
 repro.mating(param.mate_encounter),
 repro.radius(param.mate_radius),
 repro.fecundity(param.fecundity_maximum,
                 param.fecundity_decay),
 repro.density(param.eta,
Exemple #2
0
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()