diff --git a/experiments/consumer-resource/evolving_hipp.ipynb b/experiments/consumer-resource/evolving_hipp.ipynb
new file mode 100644
index 0000000..2ff5892
--- /dev/null
+++ b/experiments/consumer-resource/evolving_hipp.ipynb
@@ -0,0 +1,534 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Evolving Hunting Interferring Predator Prey Model\n",
+ "Extension fo the Hunting Interferring Predator Prey model with predators radius mutating. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# import necessary modules\n",
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "import matplotlib.pyplot as plt\n",
+ "from scipy import integrate\n",
+ "from multiprocessing import Pool\n",
+ "from tqdm import tqdm\n",
+ "import warnings\n",
+ "import os\n",
+ "\n",
+ "# import datatime to set threads to 1\n",
+ "# allows for better multiprocessing\n",
+ "import datatable as dt\n",
+ "dt.options.nthreads = 1\n",
+ "\n",
+ "# set nice plotting style\n",
+ "plt.style.use('bmh')\n",
+ "\n",
+ "# IEBM modules\n",
+ "# point path to IEBM files\n",
+ "import sys\n",
+ "sys.path.append('../../')\n",
+ "# model population in 2-dimensions\n",
+ "from iebm.populations.population2D import Population2D\n",
+ "# import Trait classes to set up Events\n",
+ "from iebm.traits.static_trait import StaticTrait\n",
+ "from iebm.traits.linked_trait import LinkedTrait\n",
+ "from iebm.traits.mutable_trait import MutableTrait\n",
+ "# import BirthEvent for the prey\n",
+ "from iebm.events.birth import BirthEvent\n",
+ "# import DeathEvent for the predator\n",
+ "from iebm.events.death import DeathEvent\n",
+ "# movement is simulated by time to boundary (wall) events\n",
+ "from iebm.events.wall import WallEvent\n",
+ "# import 2D interaction for 2D populations\n",
+ "from iebm.events.interact2d import Interact2DEvent\n",
+ "# import class to simulate model\n",
+ "from iebm.simulation import Simulation\n",
+ "# event that pauses an individual for an alloted time\n",
+ "from iebm.events.pause import Pause2DEvent\n",
+ "# load rotate module for predators to hunt\n",
+ "from iebm.events.rotate import RotateEvent"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Parameters\n",
+ "Set parameters that are used in both the ODE and IEBM. Values selected to have small populations for faster simulations."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "r = 0.001 # prey growth rate\n",
+ "a = 1 # predator attack rate\n",
+ "c = 1 # predator conversion efficiency\n",
+ "d = 0.001 # predator death rate\n",
+ "# size of environment\n",
+ "xdim = 500\n",
+ "ydim = 500\n",
+ "A = xdim * ydim\n",
+ "init_prey = 100 # starting prey population size\n",
+ "init_pred = 100 # starting predator population size\n",
+ "h = 75\n",
+ "# set the simulation time to certain number of cycles\n",
+ "\n",
+ "time = 250000\n",
+ "\n",
+ "# for the IEBM, individuals need explicit size\n",
+ "prey_radius = 1.0\n",
+ "pred_radius = 1.0\n",
+ "\n",
+ "# metabolic constant to change death rate according to radius\n",
+ "bmet = d / (pred_radius**(-1/4))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# The predator radius starts at pred_radius and can lower to min_radius based on a mutation rate and mutation step\n",
+ "def ehirm_setup(k, stoppage, hunt_radius_factor, hunt_rate_factor, min_radius, mut_rate, mut_step):\n",
+ "\n",
+ " prey = Population2D(name='prey', init_size=init_prey, xdim=xdim, ydim=ydim, implicit_capacity=k)\n",
+ " pred = Population2D(name='pred', init_size=init_pred, xdim=xdim, ydim=ydim)\n",
+ "\n",
+ " vel = a / (2 * (prey_radius + pred_radius))\n",
+ "\n",
+ " trait_prey = [(StaticTrait, {'name' : 'birth_rate', \n",
+ " 'value' : r}), \n",
+ " (StaticTrait, {'name' : 'radius', \n",
+ " 'value' : prey_radius}),\n",
+ " (LinkedTrait, {'name' : 'predation_radius', \n",
+ " 'link_trait' : 'radius', \n",
+ " 'link_func' : lambda x : x})]\n",
+ "\n",
+ " event_prey = [(BirthEvent, {'name' : 'birth' , \n",
+ " 'is_primary' : True,\n",
+ " 'current_time' : 0}), \n",
+ " (DeathEvent, {'name' : 'death', \n",
+ " 'is_primary' : False, \n",
+ " 'current_time' : 0})]\n",
+ "\n",
+ " trait_pred = [(MutableTrait, {'name' : 'radius', \n",
+ " 'track' : True,\n",
+ " 'value' : pred_radius, \n",
+ " 'min_value' : min_radius, \n",
+ " 'mutate_rate' : mut_rate, \n",
+ " 'mutate_step' : mut_step}), \n",
+ " (LinkedTrait, {'name' : 'predation_radius', \n",
+ " 'link_trait' : 'radius', \n",
+ " 'link_func' : lambda x: x}),\n",
+ " (LinkedTrait, {'name' : 'interfer_radius',\n",
+ " 'link_trait' : 'radius', \n",
+ " 'link_func' : lambda x: x}),\n",
+ " (LinkedTrait, {'name' : 'velocity', \n",
+ " 'link_trait' : 'radius', \n",
+ " 'link_func' : lambda x : a / (2 * (prey_radius + x))}),\n",
+ " (LinkedTrait, {'name' : 'death_rate', \n",
+ " 'link_trait' : 'radius', \n",
+ " 'link_func' : lambda x : bmet * x ** (-1/4)}),\n",
+ " (StaticTrait, {'name' : 'handling', \n",
+ " 'value' : h}), \n",
+ " (StaticTrait, {'name' : 'stoppage', \n",
+ " 'value' : stoppage}), \n",
+ " (LinkedTrait, {'name' : 'hunt_radius',\n",
+ " 'link_trait' : 'radius', \n",
+ " 'link_func' : lambda x: x * hunt_radius_factor}), \n",
+ " (LinkedTrait, {'name' : 'hunt_rate', \n",
+ " 'link_trait' : 'death_rate',\n",
+ " 'link_func' : lambda x : x * hunt_rate_factor})]\n",
+ " \n",
+ " event_pred = [(DeathEvent, {'name' : 'death',\n",
+ " 'is_primary' : True,\n",
+ " 'current_time' : 0}), \n",
+ " (WallEvent, {'name' : 'wall', \n",
+ " 'is_primary' : True, \n",
+ " 'current_time' : 0, \n",
+ " 'bounce' : 'random'}), \n",
+ " (Interact2DEvent, {'name' : 'predation',\n",
+ " 'is_primary' : True,\n",
+ " 'tirgger_set_next' : True,\n",
+ " 'current_time' : 0, \n",
+ " 'other' : prey}), \n",
+ " (Pause2DEvent, {'name' : 'handling',\n",
+ " 'ignore_list' : ['death'],\n",
+ " 'is_primary' : False}),\n",
+ " (Interact2DEvent, {'name' : 'interfer',\n",
+ " 'is_primary' : True,\n",
+ " 'tirgger_set_next' : True,\n",
+ " 'current_time' : 0}), \n",
+ " (Pause2DEvent, {'name' : 'stoppage',\n",
+ " 'ignore_list' : ['death'],\n",
+ " 'is_primary' : False}),\n",
+ " (BirthEvent, {'name' : 'birth', \n",
+ " 'is_primary' : False, \n",
+ " 'current_time' : 0}), \n",
+ " (RotateEvent, {'name' : 'hunt', \n",
+ " 'is_primary' : True,\n",
+ " 'attract_population' : prey,\n",
+ " 'current_time' : 0})] \n",
+ " \n",
+ " return prey, pred, trait_prey, trait_pred, event_prey, event_pred"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# function to run am intereferring Rosenzweig-MacArthur model from the returned value of rm_setup.\n",
+ "def ehirm_model(prey, pred, trait_prey, trait_pred, event_prey, event_pred, progress_bar=True):\n",
+ " \n",
+ " prey.add_traits(trait_prey)\n",
+ " prey.add_events(event_prey)\n",
+ " pred.add_traits(trait_pred)\n",
+ " pred.add_events(event_pred) \n",
+ " \n",
+ " # list what events to stop at pause\n",
+ " # predation\n",
+ " set_list = [c for c in pred.event_list if c not in pred.event_dict['handling'].ignore_list]\n",
+ " pred.event_dict['handling'].set_list = set_list\n",
+ " # interference\n",
+ " set_list = [c for c in pred.event_list if c not in pred.event_dict['stoppage'].ignore_list]\n",
+ " pred.event_dict['stoppage'].set_list = set_list\n",
+ "\n",
+ " # add event triggers to finish setting up system\n",
+ " # when new prey is born, check and create new predation collisions\n",
+ " # and add new offspring to hunt rtree\n",
+ " def prey_birth(params):\n",
+ " new_events = []\n",
+ " new_events += pred.event_dict['predation'].set_other_next(params)\n",
+ " new_events += pred.event_dict['hunt'].add_attracted(params)\n",
+ " return new_events\n",
+ " prey.event_dict['birth'].triggers = prey_birth\n",
+ "\n",
+ " # when prey dies, remove from hunt indes\n",
+ " prey.event_dict['death'].triggers = pred.event_dict['hunt'].remove_attracted\n",
+ "\n",
+ " # set the trigger for a predation interaction event\n",
+ " # a few things occur at a predation event, so we need a function\n",
+ " def predation_trigger(params):\n",
+ " events = []\n",
+ " other_params = params.copy()\n",
+ " other_params['actor_id'] = other_params['extra']\n",
+ " # the prey is removed\n",
+ " events += prey.event_dict['death'].handle(other_params)\n",
+ " # the predator pauses to handle \n",
+ " events += pred.event_dict['handling'].set_next(params)\n",
+ " return events\n",
+ " pred.event_dict['predation'].triggers = predation_trigger\n",
+ "\n",
+ " # after handling, predator can give birth and get new settings\n",
+ " def handle_trigger(params):\n",
+ " events = []\n",
+ " # now that individual is active:\n",
+ " # set new wall times\n",
+ " pred.event_dict['wall'].set_next(params)\n",
+ " # set next predation times\n",
+ " pred.event_dict['predation'].set_next(params)\n",
+ " # set next interfer times\n",
+ " pred.event_dict['interfer'].set_next(params)\n",
+ " # possibly create offspring after handling\n",
+ " events += pred.event_dict['birth'].handle(params)\n",
+ " # get individual's next evet\n",
+ " events += [pred.get_next_event(params['actor_id'])]\n",
+ " return events\n",
+ " pred.event_dict['handling'].triggers = handle_trigger\n",
+ "\n",
+ " # set triggers when individual predators collide\n",
+ " def stoppage_trigger(params):\n",
+ " events = []\n",
+ " # stop other\n",
+ " other_params = params.copy()\n",
+ " other_params['actor_id'] = other_params['extra']\n",
+ " events += pred.event_dict['stoppage'].set_next(other_params)\n",
+ " # stop this individual\n",
+ " events += pred.event_dict['stoppage'].set_next(params)\n",
+ " return events\n",
+ " pred.event_dict['interfer'].triggers = stoppage_trigger\n",
+ "\n",
+ " # after stopping, predators can resume activity\n",
+ " def resume_trigger(params):\n",
+ " events = []\n",
+ " # set new wall times\n",
+ " pred.event_dict['wall'].set_next(params)\n",
+ " # set next predation times\n",
+ " pred.event_dict['predation'].set_next(params)\n",
+ " # set next interfer times\n",
+ " pred.event_dict['interfer'].set_next(params)\n",
+ " # get individuals next event\n",
+ " events += [pred.get_next_event(params['actor_id'])]\n",
+ " return events\n",
+ " pred.event_dict['stoppage'].triggers = resume_trigger\n",
+ "\n",
+ " # set triggers to calculate new interactions after wall collision\n",
+ " def new_interactions(params):\n",
+ " new_events = []\n",
+ " new_events += pred.event_dict['predation'].set_next(params)\n",
+ " new_events += pred.event_dict['interfer'].set_next(params)\n",
+ " return new_events\n",
+ " pred.event_dict['wall'].triggers = new_interactions\n",
+ "\n",
+ " # hunt trigger, change direction after angle change\n",
+ " # exact same as resume\n",
+ " pred.event_dict['hunt'].triggers = resume_trigger\n",
+ " \n",
+ " # add the pops to a dictionary \n",
+ " pop_dict = {str(prey) : prey, \n",
+ " str(pred) : pred}\n",
+ "\n",
+ " # create the simulation with the population dictionary\n",
+ " sim = Simulation(pop_dict)\n",
+ " \n",
+ " # run simulation\n",
+ " sim.run(time, progress_bar=progress_bar)\n",
+ "\n",
+ " # return simulation resuls\n",
+ " res = sim.get_results()\n",
+ " \n",
+ " return res"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# function to run in parallel\n",
+ "def run_parallel(k, s, hrad, hrat, min_radius, mut_rate, mut_step):\n",
+ " prey, pred, trait_prey, trait_pred, event_prey, event_pred = ehirm_setup(k, s, hrad, hrat, min_radius, mut_rate, mut_step)\n",
+ " res = ehirm_model(prey, pred, trait_prey, trait_pred, event_prey, event_pred, progress_bar=False) \n",
+ " return [k, s, hrad, hrat, min_radius, mut_rate, mut_step, res]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|█████████▉| 249982.7503/250000 [48:44<00:00, 164.23it/s] /home/jordan/miniconda3/envs/ebm/lib/python3.7/site-packages/tqdm/std.py:521: TqdmWarning: clamping frac to range [0, 1]\n",
+ " colour=colour)\n",
+ "100%|██████████| 250000.2512/250000 [48:44<00:00, 85.47it/s] "
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CPU times: user 48min 42s, sys: 10.8 s, total: 48min 53s\n",
+ "Wall time: 48min 44s\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "%%time\n",
+ "# run IEBM a few times on select carrying capacties, stoppage, and hunt_factors\n",
+ "\n",
+ "ks = [2000]\n",
+ "ss = [5]\n",
+ "hrads = [10]\n",
+ "hrats = [100]\n",
+ "min_radii = [0.2]\n",
+ "mut_rates = [0.01]\n",
+ "mut_steps = [0.01]\n",
+ "runs = 1 #99\n",
+ "\n",
+ "params = [(k, s, hrad, hrat, mri, mrt, ms) \n",
+ " for k in ks \n",
+ " for s in ss \n",
+ " for hrad in hrads \n",
+ " for hrat in hrats \n",
+ " for mri in min_radii\n",
+ " for mrt in mut_rates\n",
+ " for ms in mut_steps\n",
+ " for _ in range(runs)]\n",
+ "\n",
+ "\"\"\"\n",
+ "pbar = tqdm(total=len(params))\n",
+ "\n",
+ "res = []\n",
+ "def update(a):\n",
+ " res.append(a)\n",
+ " pbar.update()\n",
+ "\n",
+ "pool = Pool()\n",
+ "\n",
+ "for (k, s, hrad, hrat, mri, mrt, ms) in params:\n",
+ " pool.apply_async(run_parallel, (k, s, hrad, hrat, mri, mrt, ms), \n",
+ " callback=update)\n",
+ "\n",
+ "pool.close()\n",
+ "pool.join()\n",
+ "pbar.close()\n",
+ "\"\"\"\n",
+ "\n",
+ "prey, pred, trait_prey, trait_pred, event_prey, event_pred = ehirm_setup(*params[0])\n",
+ "res = ehirm_model(prey, pred, trait_prey, trait_pred, event_prey, event_pred, progress_bar=True) \n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CPU times: user 27.7 s, sys: 877 ms, total: 28.6 s\n",
+ "Wall time: 28.6 s\n"
+ ]
+ }
+ ],
+ "source": [
+ "%%time\n",
+ "\n",
+ "trait_df = []\n",
+ "for time, (vals, cnts) in zip(res['time'], res['trait'][('pred', 'radius')]):\n",
+ " cnts_sum = cnts.sum()\n",
+ " for i in range(len(vals)):\n",
+ " trait_df.append([time, vals[i], cnts[i]/cnts_sum])\n",
+ "trait_df = pd.DataFrame(trait_df, columns=['time', 'val', 'freq'])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "time_grp = 10\n",
+ "trait_df['time_grp'] = (trait_df.time // time_grp).astype(np.int64)\n",
+ "trait_grp = trait_df.groupby(['time_grp', 'val']).freq.mean().reset_index()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "