Borlase CWCO MDA.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6b5e9010",
   "metadata": {},
   "source": [
    "# Adaptation of Borlase model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee39a3c1",
   "metadata": {},
   "source": [
    "This model will mimic the approach of the translation of the Borlase R code. At each timestep, the age, infective status, bacterial load etc. of each person (represented by the indices) is stored, and we may retrieve the number of infectives at each time for plotting. Time is in weeks (multiply by 7 to retrieve days) and people are split into three general age groups: young children, old children, and adults\n",
    "\n",
    "The treatment matrix keeps track of who receives MDA treatment and when, allowing for SNC\n",
    "Vaccination treatment should use a different matrix (when incorporated)\n",
    "\n",
    "Simulation parameters: simulation time, burn-in (time until MDA starts), MDA (soon to include vax) frequency, number of rounds of MDA (and vax)\n",
    "\n",
    "Population parametes: N, duration of infection/disease, reduction of infection/diseaes, durations of infection and disease, parameters for lambda function, MDA (soon vax) coverage and efficiency, and rho (ommitted, related to SNC) \n",
    "\n",
    "Demographic parameters: tau (death rate), max age, mean age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e4c6a05c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# importing relevant libraries\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df07503f",
   "metadata": {},
   "source": [
    "## Calculating infection rate and resetting individuals who die or reach maximum age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "49459471",
   "metadata": {},
   "outputs": [],
   "source": [
    "# rate depends on parameters and diseased individuals\n",
    "def lambda_rate(params, Age, demog, bact_load, IndD, bet):\n",
    "    v_1, v_2, phi, epsilon = params['v_1'], params['v_2'], params['phi'], params['epsilon']\n",
    "    N, max_age = params['N'], demog['max_age']\n",
    "    \n",
    "    totalLoad = [0,0,0]\n",
    "    y_children = np.where((Age >= 0) & (Age < 9*52))[0] # young children = 0-9\n",
    "    totalLoad[0] = np.sum(bact_load[y_children]) / len(y_children) # average bacterial load?\n",
    "    o_children = np.where((Age >= 9*52) & (Age < 15*52))[0] # older children = 9-15\n",
    "    totalLoad[1] = np.sum(bact_load[o_children]) / len(o_children)\n",
    "    adults = np.where(Age >= 15*52)[0]\n",
    "    totalLoad[2] = np.sum(bact_load[adults]) / len(adults)\n",
    "    \n",
    "    prevLambda = bet * (v_1 * np.array(totalLoad) + v_2 * np.array(totalLoad) ** (phi + 1))\n",
    "    \n",
    "    # tile function repeats proportions, forming 3 identical rows\n",
    "    demog_matrix = np.transpose(np.tile(np.array([len(y_children), len(o_children), len(adults)]) / N, (3, 1)))\n",
    "    social_mixing = (epsilon * np.eye(3) + (1 - epsilon)) * demog_matrix\n",
    "    \n",
    "    lambda_ = np.dot(social_mixing, prevLambda)\n",
    "    \n",
    "    # adjust lambda based on disease status\n",
    "    age_intervals = np.searchsorted([0, 9*52, 15*52, max_age*52], Age)\n",
    "    adjusted_lambda = lambda_[age_intervals - 1] * (0.5 + 0.5 * (1 - IndD))\n",
    "    \n",
    "    return adjusted_lambda # relates to force of infection across the population\n",
    "\n",
    "def reset_age(Age, demog, params):\n",
    "    tau, max_age, N = demog['tau'], demog['max_age'], params['N']\n",
    "    # individuals who die or reach the maximum age will be recorded and reset later\n",
    "    reset_indivs = np.where((np.random.uniform(size=N) < 1 - np.exp(-tau)) | (Age > max_age))[0]\n",
    "    return reset_indivs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8008ebce",
   "metadata": {},
   "source": [
    "## Treatment matrix. Child-only matrix is ignored for now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e0797f59",
   "metadata": {},
   "outputs": [],
   "source": [
    "# decide who gets treatment when\n",
    "def tx_matrix(params, sim_params):\n",
    "    N, N_MDA, MDA_Cov, rho = params['N'], sim_params['N_MDA'], params['MDA_Cov'], params['rho']\n",
    "    ind_treat = np.zeros((N, N_MDA)) # must be an N by N_MDA matrix\n",
    "    \n",
    "    for i in range(N): # work through each individual\n",
    "        z = np.random.uniform(size = N)\n",
    "        ind_treat[:, 0] = z < MDA_Cov # chosen so roughly MDA_Cov% of people get the first treatment\n",
    "        for k in range(1, N_MDA): # determine which rounds each person receives\n",
    "            prob = (MDA_Cov * (1 - rho) + (rho * np.sum(ind_treat[i, :k]))) / (1 + (k - 1) * rho) # decrease with rho, k\n",
    "            ind_treat[i, k] = np.random.binomial(1, prob) # determine if individual i receives round k\n",
    "    \n",
    "    return ind_treat"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0689a0b",
   "metadata": {},
   "source": [
    "## Timesteps for MDA and indexing who is cured"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3261fa56",
   "metadata": {},
   "outputs": [],
   "source": [
    "# return the timestamps of when MDA occurs\n",
    "def set_t_MDA(sim_params):\n",
    "    burnin, N_MDA, freq_MDA = sim_params['burnin'], sim_params['N_MDA'], sim_params['freq_MDA']\n",
    "    MDA_times = []\n",
    "    for i in range(N_MDA): # add the time of each round\n",
    "        MDA_times.append(burnin + i * 52 * freq_MDA + 52) # add 52 to start 1 year after burnin\n",
    "        \n",
    "    return MDA_times\n",
    "\n",
    "# timestamps for child-only MDA\n",
    "def set_t_MDA_kids(sim_params):\n",
    "    burnin, N_MDA_kids, freq_MDA_kids = sim_params['burnin'], sim_params['N_MDA_kids'], sim_params['freq_MDA_kids']\n",
    "    child_delay, offset = sim_params['child_delay'], sim_params['offset'] # relates child-only times to community-wide ones\n",
    "    MDA_times_kids = []\n",
    "    for i in range(N_MDA_kids):\n",
    "        MDA_times_kids.append(burnin + child_delay + i * 52 * freq_MDA_kids + 52 + offset)\n",
    "    \n",
    "    return MDA_times_kids\n",
    "\n",
    "# decide who is treated during community-wide MDA\n",
    "def doMDA(params, Age, MDA_round, tx_mat):\n",
    "    MDA_eff = params['MDA_eff']\n",
    "    \n",
    "    babies = np.where(Age < 26)[0] # identify who is a baby\n",
    "    treated_b = babies[np.where(tx_mat[babies, MDA_round-1] == 1)[0]] # identify which baby is due treatment\n",
    "    cured_b = treated_b[np.where(np.random.uniform(size = len(treated_b)) < (MDA_eff * 0.5))[0]] # multiplier due to method\n",
    "    \n",
    "    older = np.where(Age > 26)[0]\n",
    "    treated_o = older[np.where(tx_mat[older, MDA_round-1] == 1)[0]]\n",
    "    cured_o = treated_o[np.where(np.random.uniform(size = len(treated_o)) < MDA_eff)[0]]\n",
    "    \n",
    "    all_cured = np.concatenate((cured_b, cured_o))\n",
    "    \n",
    "    return all_cured # returns index of all individuals who are treated and successfully cured\n",
    "\n",
    "# decide who is treated during children-only MDA - ignore matrix and SNC due to complications with ageing/death\n",
    "def doMDAkids(params, Age, MDA_round_kids):\n",
    "    MDA_eff = params['MDA_eff']\n",
    "    MDA_Cov_kids = params['MDA_Cov_kids']\n",
    "    \n",
    "    kids = np.where((Age > 104) & (Age < 10 * 52))[0] # look at 2-10 year olds here (why not 1-9?)\n",
    "    treated_kids = kids[np.where(np.random.uniform(size = len(kids)) < MDA_Cov_kids)[0]] # randomly select enough indiv's\n",
    "    cured_kids = treated_kids[np.where(np.random.uniform(size = len(treated_kids)) < MDA_eff)[0]] # successful treatment\n",
    "    \n",
    "    return cured_kids"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b23c2f8",
   "metadata": {},
   "source": [
    "## Function which actually carries out MDA steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "085e4fe9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# carry out community-wide MDA\n",
    "def MDA_timestep(vals, params, demog, MDA_round):\n",
    "    \n",
    "    IndI = vals['IndI'] # retrieve the variables for each individual\n",
    "    IndD = vals['IndD']\n",
    "    No_Inf = vals['No_Inf']\n",
    "    T_latent = vals['T_latent']\n",
    "    T_ID = vals['T_ID']\n",
    "    T_D = vals['T_D']\n",
    "    Ind_latent = vals['Ind_latent']\n",
    "    Ind_ID_period_base = vals['Ind_ID_period_base']\n",
    "    Ind_D_period_base = vals['Ind_D_period_base']\n",
    "    bact_load = vals['bact_load']\n",
    "    Age = vals['Age']\n",
    "    \n",
    "    all_cured = doMDA(params, Age, MDA_round, tx_mat) # identify who is cured through MDA\n",
    "    \n",
    "    IndI[all_cured] = 0 # reset infection and bacterial load for scuccessfully cured individuals\n",
    "    bact_load[all_cured] = 0\n",
    "    \n",
    "    vals = { # put all the updated variables back together\n",
    "        \"IndI\": IndI,\n",
    "        \"IndD\": IndD,\n",
    "        \"No_Inf\": No_Inf,\n",
    "        \"T_latent\": T_latent,\n",
    "        \"T_ID\": T_ID,\n",
    "        \"T_D\": T_D,\n",
    "        \"Ind_latent\": Ind_latent,\n",
    "        \"Ind_ID_period_base\": Ind_ID_period_base,\n",
    "        \"Ind_D_period_base\": Ind_D_period_base,\n",
    "        \"bact_load\": bact_load,\n",
    "        \"Age\": Age\n",
    "    }\n",
    "    \n",
    "    \n",
    "    return vals\n",
    "\n",
    "# carry out child-only MDA\n",
    "def MDA_timestep_kids(vals, params, demog, MDA_round_kids):\n",
    "    \n",
    "    IndI = vals['IndI']\n",
    "    IndD = vals['IndD']\n",
    "    No_Inf = vals['No_Inf']\n",
    "    T_latent = vals['T_latent']\n",
    "    T_ID = vals['T_ID']\n",
    "    T_D = vals['T_D']\n",
    "    Ind_latent = vals['Ind_latent']\n",
    "    Ind_ID_period_base = vals['Ind_ID_period_base']\n",
    "    Ind_D_period_base = vals['Ind_D_period_base']\n",
    "    bact_load = vals['bact_load']\n",
    "    Age = vals['Age']\n",
    "    \n",
    "    all_cured_kids = doMDAkids(params, Age, MDA_round_kids) # identify which children are cured through MDA\n",
    "    \n",
    "    IndI[all_cured_kids] = 0 # reset infection and bacterial load for successfully cured children\n",
    "    bact_load[all_cured_kids] = 0\n",
    "    \n",
    "    vals = {\n",
    "        \"IndI\": IndI,\n",
    "        \"IndD\": IndD,\n",
    "        \"No_Inf\": No_Inf,\n",
    "        \"T_latent\": T_latent,\n",
    "        \"T_ID\": T_ID,\n",
    "        \"T_D\": T_D,\n",
    "        \"Ind_latent\": Ind_latent,\n",
    "        \"Ind_ID_period_base\": Ind_ID_period_base,\n",
    "        \"Ind_D_period_base\": Ind_D_period_base,\n",
    "        \"bact_load\": bact_load,\n",
    "        \"Age\": Age\n",
    "    }\n",
    "    \n",
    "    \n",
    "    return vals\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ddd8cc9",
   "metadata": {},
   "source": [
    "## Infection and disease periods, used to set duration upon acquiring disease/infection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "dfc71dc7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# give duration of active infection and disease only periods\n",
    "def ID_period_function(Ind_ID_period_base, No_Inf, parameters):\n",
    "    min_ID = parameters['min_ID']\n",
    "    inf_red = parameters['inf_red']\n",
    "    T_ID = np.round((Ind_ID_period_base - min_ID) * np.exp(-inf_red * (No_Inf - 1)) + min_ID)\n",
    "    \n",
    "    return T_ID\n",
    "    \n",
    "# give duration of diseased period\n",
    "def D_period_function(Ind_D_period_base, No_Inf, parameters):\n",
    "    min_D = parameters['min_D']\n",
    "    dis_red = parameters['dis_red']\n",
    "    T_D = np.round((Ind_D_period_base - min_D) * np.exp(-dis_red * (No_Inf - 1)) + min_D)\n",
    "    \n",
    "    return T_D"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43ce5f92",
   "metadata": {},
   "source": [
    "## Run a non-MDA timestep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c4360bd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# transitions which occur during a timestep where MDA does not occur\n",
    "def stepf_fixed(vals, params, demog, bet):\n",
    "    \n",
    "    IndI = vals['IndI']\n",
    "    IndD = vals['IndD']\n",
    "    No_Inf = vals['No_Inf']\n",
    "    T_latent = vals['T_latent']\n",
    "    T_ID = vals['T_ID']\n",
    "    T_D = vals['T_D']\n",
    "    Ind_latent = vals['Ind_latent']\n",
    "    Ind_ID_period_base = vals['Ind_ID_period_base']\n",
    "    Ind_D_period_base = vals['Ind_D_period_base']\n",
    "    bact_load = vals['bact_load']\n",
    "    Age = vals['Age']\n",
    "    \n",
    "    # new I =  Becoming infected, not yet diseased\n",
    "    Ss = np.where(IndI == 0)[0]  # susceptible individuals available for infection\n",
    "    lambda_step = 1 - np.exp(-lambda_rate(params, Age, demog, bact_load, IndD, bet)) # probability of infection\n",
    "    newInf = Ss[np.random.rand(len(Ss)) < lambda_step[Ss]]  # new infections\n",
    "    \n",
    "    # new ID = infected and becoming diseased too\n",
    "    Is = np.where((IndI == 1) & (IndD == 0))[0]\n",
    "    T_latent -= 1  # with each timestep, subtract 1\n",
    "    newDis = np.where(T_latent == 0)[0]  # designated latent period for that individual has expired\n",
    "    T_latent[T_latent < 1] = 0  # reset all not in latent period to 0 at each timestep\n",
    "    \n",
    "    # new D = infectious diseased losing infectiousness\n",
    "    IDs = np.where((IndI == 1) & (IndD == 1))[0]\n",
    "    bact_load[IDs] = bacterialLoad(No_Inf[IDs], params)\n",
    "    T_ID -= 1  # with each timestep, subtract 1\n",
    "    newClearInf = np.where(T_ID == 0)[0]  # designated infectious period for that individual has expired\n",
    "    T_ID[T_ID < 1] = 0  # reset all uninfected to 0 at each timestep\n",
    "    \n",
    "    # new S = Clear disease\n",
    "    Ds = np.where((IndI == 0) & (IndD == 1))[0]\n",
    "    bact_load[Ds] = 0\n",
    "    T_D -= 1  # subtract 1 each timestep\n",
    "    newClearDis = np.where(T_D == 0)[0]  # designated diseased period for that individual has expired\n",
    "    T_D[T_D < 1] = 0  # reset all not in diseased period to 0\n",
    "\n",
    "    No_Inf[newInf] += 1 # tracking infection history\n",
    "\n",
    "    # TRANSITION become infected\n",
    "    IndI[newInf] = 1  # if they've become infected, become I=1\n",
    "    # TRANSITION become diseased (and infected)\n",
    "    IndD[newDis] = 1  # if they've become diseased they become D=1\n",
    "    # TRANSITION Clear infection (remain diseased)\n",
    "    IndI[newClearInf] = 0  # clear infection they become I=0\n",
    "    # TRANSITION Clear disease (become susceptible again)\n",
    "    IndD[newClearDis] = 0  # clear disease they become D=0\n",
    "\n",
    "    # Setting duration of infection/disease for individuals\n",
    "    T_latent[newInf] = Ind_latent[newInf]  # When individual becomes infected, set their latent period\n",
    "    # When individual becomes diseased, set their infected+diseased period\n",
    "    T_ID[newDis] = ID_period_function(Ind_ID_period_base=Ind_ID_period_base[newDis], No_Inf=No_Inf[newDis], parameters=parameters)\n",
    "    # When indiv clears infection, their diseased only period is set\n",
    "    T_D[newClearInf] = D_period_function(Ind_D_period_base=Ind_D_period_base[newClearInf], No_Inf=No_Inf[newClearInf], parameters=parameters)\n",
    "\n",
    "    # Update age, all age by 1w at each timestep, and resetting all \"reset indivs\" age to zero\n",
    "    # Reset_indivs - Identify individuals who die in this timeset\n",
    "    Age += 1\n",
    "    reset_indivs = reset_age(Age=Age, demog=demog, params=parameters)\n",
    "    Age[reset_indivs] = 0\n",
    "\n",
    "    # Resetting new parameters for all new individuals created\n",
    "    IndI[reset_indivs] = 0\n",
    "    IndD[reset_indivs] = 0\n",
    "    No_Inf[reset_indivs] = 0\n",
    "    T_latent[reset_indivs] = 0\n",
    "    T_ID[reset_indivs] = 0\n",
    "    T_D[reset_indivs] = 0\n",
    "\n",
    "    vals = {\n",
    "        \"IndI\": IndI,\n",
    "        \"IndD\": IndD,\n",
    "        \"No_Inf\": No_Inf,\n",
    "        \"T_latent\": T_latent,\n",
    "        \"T_ID\": T_ID,\n",
    "        \"T_D\": T_D,\n",
    "        \"Ind_latent\": Ind_latent,\n",
    "        \"Ind_ID_period_base\": Ind_ID_period_base,\n",
    "        \"Ind_D_period_base\": Ind_D_period_base,\n",
    "        \"bact_load\": bact_load,\n",
    "        \"Age\": Age\n",
    "    }\n",
    "    \n",
    "    return vals"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdf78a60",
   "metadata": {},
   "source": [
    "## Formula for bacterial load and setting the initial ages and infections in the population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "96b37b78",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define bacterial load based on infection history\n",
    "def bacterialLoad(No_Inf, parameters):\n",
    "    b1, ep2 = 1, 0.114\n",
    "    bact_load = b1 * np.exp((No_Inf - 1) * -ep2)\n",
    "    \n",
    "    return bact_load\n",
    "\n",
    "# produce age sample based on exponential distribution and mean age\n",
    "def init_ages(params, demog):\n",
    "    max_age, mean_age, N = demog['max_age'], demog['mean_age'], params['N']\n",
    "    ages = np.arange(1, max_age + 1)\n",
    "    nAges = len(ages)\n",
    "    propAges = np.empty(nAges) # will store the probability of lying in each age group\n",
    "    for i in range(nAges - 1):\n",
    "        propAges[i] = np.exp(-ages[i] / mean_age) - np.exp(-ages[i + 1] / mean_age) # reflects exponential distribution\n",
    "    propAges[-1] = 1 - np.sum(propAges[:-1]) # ensures probabilities sum to 1\n",
    "    sampled_ages = np.random.choice(ages, N, replace=True, p=propAges) # now samples according to distribution\n",
    "    \n",
    "    return sampled_ages\n",
    "\n",
    "# set initial values\n",
    "def set_inits(params, demog):\n",
    "    N = params['N']\n",
    "    av_I_duration = params['av_I_duration']\n",
    "    av_ID_duration = params['av_ID_duration']\n",
    "    av_D_duration = params['av_D_duration']\n",
    "    IndI = np.zeros(N)  # infected status\n",
    "    IndD = np.zeros(N)  # disease status\n",
    "    No_Inf = np.zeros(N)  # total number of infections per individual\n",
    "    T_latent = np.zeros(N)  # duration of latent period (I)\n",
    "    T_ID = np.zeros(N)  # duration of current ID period\n",
    "    T_D = np.zeros(N)  # duration spent in diseased state (post-infection)\n",
    "    Ind_latent = np.full(N, av_I_duration)  # individual's latent period fixed for now\n",
    "    Ind_ID_period_base = np.random.poisson(av_ID_duration, N)  # baseline ID period\n",
    "    Ind_D_period_base = np.random.poisson(av_D_duration, N)  # baseline diseased period\n",
    "    bact_load = np.zeros(N)  # baseline bacterial load set to zero\n",
    "    Age = init_ages(params, demog)  # initial ages\n",
    "\n",
    "    vals = {\n",
    "        \"IndI\": IndI,\n",
    "        \"IndD\": IndD,\n",
    "        \"No_Inf\": No_Inf,\n",
    "        \"T_latent\": T_latent,\n",
    "        \"T_ID\": T_ID,\n",
    "        \"T_D\": T_D,\n",
    "        \"Ind_latent\": Ind_latent,\n",
    "        \"Ind_ID_period_base\": Ind_ID_period_base,\n",
    "        \"Ind_D_period_base\": Ind_D_period_base,\n",
    "        \"bact_load\": bact_load,\n",
    "        \"Age\": Age\n",
    "    }\n",
    "\n",
    "    return vals\n",
    "\n",
    "\n",
    "def seed_infection(params, vals):\n",
    "    N = params['N']\n",
    "    \n",
    "    initial_infected_count = round(N * 0.01) # set 1% of the population to be infected initially\n",
    "    vals['IndI'][:initial_infected_count] = 1\n",
    "    \n",
    "    init_infected = np.where(vals['IndI'] == 1)[0] # get the indices of the initially infected individuals\n",
    "    \n",
    "    vals['T_latent'][init_infected] = vals['Ind_latent'][init_infected] # set latent period for those infected at the start of simulation\n",
    "    \n",
    "    vals['No_Inf'][init_infected] = 1 # number of infections for those initially infected\n",
    "    \n",
    "    return vals"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b048e3a1",
   "metadata": {},
   "source": [
    "## Parameters (removed 'nsim' from sim_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "06cca778",
   "metadata": {},
   "outputs": [],
   "source": [
    "sim_params = {\n",
    "    'timesim': 80 * 52,  # total duration of simulation in weeks\n",
    "    'burnin': 40 * 52,   # burn-in period in weeks\n",
    "    'child_delay': 5 * 52, # begin child-only 5 years after community-wide\n",
    "    'offset': 26,        # weeks between child-only MDA and community-wide. 26 = 6 months\n",
    "    'freq_MDA': 1,       # 1 for annual, 0.5 for biannual, 2 for every 2 years, etc.\n",
    "    'freq_MDA_kids': 5, # child-only frequency\n",
    "    'N_MDA': 40,         # number of rounds of MDA to be carried out in simulation\n",
    "    'N_MDA_kids': 7,    # self-explanatory\n",
    "}\n",
    "\n",
    "parameters = {\n",
    "    'N': 3000,                    # population size\n",
    "    'av_I_duration': 2,           # average duration of infection\n",
    "    'av_ID_duration': 200 / 7,    # average duration of ID period\n",
    "    'inf_red': 0.45,              # infection reduction\n",
    "    'min_ID': 11,                 # minimum ID duration\n",
    "    'av_D_duration': 300 / 7,     # average duration of disease period\n",
    "    'dis_red': 0.3,               # disease reduction\n",
    "    'min_D': 1,                   # minimum disease duration\n",
    "    'v_1': 1,                     # parameter for lambda function\n",
    "    'v_2': 2.6,                   # parameter for lambda function\n",
    "    'phi': 1.4,                   # parameter for lambda function\n",
    "    'epsilon': 0.5,               # parameter for lambda function\n",
    "    'MDA_Cov': 0.7,               # MDA coverage, baseline = 0.8\n",
    "    'MDA_Cov_kids': 1,            # MDA coverage during child-only MDA\n",
    "    'MDA_eff': 0.85,              # efficacy of treatment, baseline = 0.85\n",
    "    'rho': 0                      # correlation parameter for systematic non-compliance function\n",
    "}\n",
    "\n",
    "demog = {\n",
    "    'tau': 1 / (40 * 52),   # death rate in weeks^-1\n",
    "    'max_age': 60 * 52,     # maximum age in population in weeks\n",
    "    'mean_age': 20 * 52     # mean age in population in weeks\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28fe3574",
   "metadata": {},
   "source": [
    "## Code to run a single simulation, with MDA times specified. Output is times, diseases, and infections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "40a9d7ca",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def sim_ind_MDA(params, vals, timesim, demog, bet):\n",
    "    \n",
    "    vals = vals\n",
    "    prev_disease = []\n",
    "    prev_infection = []\n",
    "    prev_diseases_1_9 = []\n",
    "    prev_infection_1_9 = []\n",
    "    t = []\n",
    "    MDA_round = []\n",
    "    MDA_round_kids = []\n",
    "    \n",
    "    pop_29 = []\n",
    "    pop_015 = []\n",
    "    \n",
    "    for i in range(1, timesim+1): # assume timesim is the total number of timesteps\n",
    "        if i in MDA_times:\n",
    "            MDA_round_i = MDA_times.index(i) + 1 # determine round of MDA\n",
    "            MDA_round.append(MDA_round_i)\n",
    "            vals = MDA_timestep(vals, params, demog, MDA_round_i) # update values following this MDA round\n",
    "            \n",
    "            t.append(i/52)\n",
    "            prev_disease.append(sum(vals['IndD']) / params['N']) # add the latest prevalences to each array\n",
    "            prev_infection.append(sum(vals['IndI']) / params['N'])\n",
    "        \n",
    "        elif i in MDA_times_kids:\n",
    "            MDA_round_kids_i = MDA_times_kids.index(i) + 1\n",
    "            MDA_round_kids.append(MDA_round_kids_i)\n",
    "            vals = MDA_timestep_kids(vals, params, demog, MDA_round_kids_i) # ROUND technically not needed as totally random\n",
    "            \n",
    "            t.append(i/52)\n",
    "            prev_disease.append(sum(vals['IndD']) / params['N'])\n",
    "            prev_infection.append(sum(vals['IndI']) / params['N'])\n",
    "        \n",
    "        else:\n",
    "            vals = stepf_fixed(vals, params, demog, bet)\n",
    "            \n",
    "            t.append((i-1)/52)\n",
    "            prev_disease.append(sum(vals['IndD']) / params['N'])\n",
    "            prev_infection.append(sum(vals['IndI']) / params['N'])\n",
    "            \n",
    "        Age = vals['Age']\n",
    "        kids_29 = np.where((Age > 104) & (Age < 10 * 52))[0]\n",
    "        kids_015 = np.where((Age >= 0) & (Age < 15*52))[0]\n",
    "        pop_29.append(len(kids_29) / params['N'])\n",
    "        pop_015.append(len(kids_015) / params['N'])\n",
    "            \n",
    "    output = {\n",
    "        \"times\": t,\n",
    "        \"infections\": prev_infection,\n",
    "        \"diseases\": prev_disease,\n",
    "        \"infection_1_9\": prev_infection_1_9,\n",
    "        \"diseases_1_9\": prev_diseases_1_9,\n",
    "        \"pop_29\": pop_29,\n",
    "        \"pop_015\": pop_015,\n",
    "    } \n",
    "            \n",
    "    return output"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4cdf28e",
   "metadata": {},
   "source": [
    "## Set up initial parameters before running"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "3646d2da",
   "metadata": {},
   "outputs": [],
   "source": [
    "# create matrices and times\n",
    "timesim, burnin = sim_params['timesim'], sim_params['burnin']\n",
    "delay, offset = sim_params['child_delay'], sim_params['offset']\n",
    "\n",
    "tx_mat = tx_matrix(parameters, sim_params)\n",
    "# tx_mat_kids = tx_matrix_kids(parameters, sim_params) - AVOIDED until we decide how to address the life-cycle issue\n",
    "\n",
    "bet = np.random.uniform(0.165, 0.175)\n",
    "\n",
    "MDA_times = set_t_MDA(sim_params) # determine times of MDA using simulation parameters\n",
    "\n",
    "MDA_times_kids = set_t_MDA_kids(sim_params) # do this inbetween community times for simplicity (avoids priority issues)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "277f5ef5",
   "metadata": {},
   "source": [
    "## Run the simulation once and plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "id": "ce5cc2c0",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.lines.Line2D at 0x1886d161690>"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# set initial values and infections\n",
    "def set_initial_conditions(params, demog):\n",
    "    vals1 = set_inits(params, demog)\n",
    "    vals2 = seed_infection(params, vals1)\n",
    "    return vals2\n",
    "\n",
    "vals = set_initial_conditions(parameters, demog) # set before each run to avoid re=using the previous end values\n",
    "\n",
    "# run simulation\n",
    "output = sim_ind_MDA(parameters, vals, timesim, demog, bet)\n",
    "\n",
    "# add extra for child-only prevalences\n",
    "times, infections, diseases = output['times'], output['infections'], output['diseases']\n",
    "\n",
    "# plot time against infections\n",
    "\n",
    "plt.plot(times, infections, color = 'blue', label = 'Infected')\n",
    "plt.plot(times, diseases, color = 'orange', label = 'Diseased')\n",
    "plt.xlabel('Time (years)')\n",
    "plt.ylabel('Prevalences')\n",
    "plt.title('Trachoma prevalence with added child-only MDA every 5 years')\n",
    "plt.legend()\n",
    "plt.ylim([-0.05, 1.05])\n",
    "\n",
    "# lines to indicate the start and end of community-wide intervention          \n",
    "plt.axvline(x=burnin/52, color = 'r', alpha = 0.4)\n",
    "plt.axvline(x=burnin/52 + sim_params['N_MDA']*sim_params['freq_MDA'], color = 'r', alpha = 0.4)\n",
    "\n",
    "# lines to indicate start and end of child-only intervention\n",
    "plt.axvline(x=(burnin+delay+offset)/52, color = 'c', alpha = 0.4)\n",
    "plt.axvline(x=(burnin+delay+offset)/52 + sim_params['N_MDA_kids']*sim_params['freq_MDA_kids'], color = 'c', alpha = 0.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "6e2a105b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.1, 0.6)"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plotting the proportion of the population made up by 2-9 and 0-15 year olds\n",
    "pop_29, pop_015 = output['pop_29'], output['pop_015']\n",
    "plt.plot(times, pop_29, color = 'green', label =  '2-9 y/o')\n",
    "plt.plot(times, pop_015, color = 'red', label = '0-15 y/o')\n",
    "plt.xlabel('Time (years)')\n",
    "plt.ylabel('Proportion of population')\n",
    "plt.title('Child population over time')\n",
    "plt.legend()\n",
    "plt.ylim([0.1, 0.6])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30549762",
   "metadata": {},
   "source": [
    "## Run many simulations (decide what to do with this)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "695a5c59",
   "metadata": {},
   "outputs": [],
   "source": [
    "# in place of the randomly sampled array of 'bet', just create this before each simulation"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}