diff --git a/README.md b/README.md index 5b53b432c..c6cc79b5e 100644 --- a/README.md +++ b/README.md @@ -17,7 +17,7 @@ A demo of the model can be found [here](src/SEIRSAgeModel_demo.ipynb). This note ### Model dynamics We use an extended version of the SEIR model to model the disease at a higher resolution. This classic SEIR model splits the population into different categories, i.e. susceptible, exposed, infected and removed. We break down the latter two categories in super mild (asymptotic), mild, heavy and critical for the infected part of the population, whereas the removed population indicates the immune and dead fraction. Parameters values are (for now) based on Chinese covid-19 literature but we are seeking to closer collaborate with Belgian hospitals as more data becomes available. The dynamics are modeled using two frameworks: 1) deterministic and 2) stochastic. The deterministic model can fluently run age-structured (metapopulation) simulations naturally by changing the initial conditions. The stochastic model class is under construction but will be updated soon. -drawing +drawing ### Additional capabilities As of now (20/04/2020), the *SEIRSAgeModel* (deterministic model implementation with inherent age-structuring) contains 7 functions which can be grouped into three parts: 1) functions to run and visualise simulations, 2) functions to perform parameter estimations and visualise the results and 3) functions to optimize future policies using model predictive control (MPC). Also, scenario specific functions will be added over the course of next week. diff --git a/figs/flowchartAll.jpg b/figs/flowchartAll.jpg index 561254a92..9c0a3c4a7 100644 Binary files a/figs/flowchartAll.jpg and b/figs/flowchartAll.jpg differ diff --git a/figs/monteCarloProblem.png b/figs/monteCarloProblem.png new file mode 100644 index 000000000..ce9b50e02 Binary files /dev/null and b/figs/monteCarloProblem.png differ diff --git a/src/SEIRSAgeModel_demo.ipynb b/src/SEIRSAgeModel_demo.ipynb index 06205f868..3dc95c074 100644 --- a/src/SEIRSAgeModel_demo.ipynb +++ b/src/SEIRSAgeModel_demo.ipynb @@ -78,18 +78,17 @@ "source": [ "#### General\n", "\n", - "In this work, we extended the compartmental SEIR model to model the disease spread with a higher resolution. To this end, we distinguish between three primary degrees of sickness: 1) asymptomatic, patients with no symptoms 2) mild, patients with mild symptoms, these patients recover at home 3) hospitalised patients. The ’removed’ pool from the classical SEIR model is explicitly split into an immune and dead pool. People from the susceptible, exposed, asymptomatic, mildly infected and immune pool can be quarantined after having tested positive for covid-19. Note that for individuals in the susceptible and immune pools, this corresponds to a false positive test. The dynamics of our extended SEIR model are presented below. The quarantine states are not shown for the sake of clarity.\n", + "The SEIR model was first proposed in 1929 by two Scottish scientists. It is a compartmental model that subdivides the human population in four types of people : 1) healthy individuals susceptible to the infectious disease, 2) exposed individuals in a latent phase (partially the incubation period), 3) infectious individuals able to transmit the disease and 4) individuals removed from the population either through immunisation or death. Despite being a simple and idealised reality, the SEIR model is used extensively to predict the outbreak of infectious diseases and this was no different during the outbreak in China earlier this year. In this work, we extended the SEIR model to incorporate more expert knowledge on SARS-Cov-2 into the model. The infectious pool is split into four parts. The first is a period of pre-symptomatic infectiousness. Several studies have shown that pre-symptomatic transmission is a dominant transmission mechanism of SARS-Cov-2. After the period of pre-symptomatic transmission, three possible infectious outcomes are modelled. 1) asymptomatic outcome, for patients who show no symptoms at all 2) mild outcome, for patients with mild symptoms, these patients recover at home 3) a mild infection can degress to the point where a hospitalision is needed. The pool of *recovered* individuals from the classical SEIR model is split into an recovered and dead pool. People from the susceptible, exposed, pre-symptomatic infectious, asymptomatic infectious, mild infectious and recovered pool can be quarantined after having tested positive for Covid-19. Note that for individuals in the susceptible and recovered pools, this corresponds to a *false positive* test. The dynamics of our extended SEIR model are presented in the flowchart below. We make the following assumptions with regard to the general SEIRS dynamics,\n", "\n", "\"drawing\"\n", "\n", "We make the following assumptions with regard to the SEIRS dynamics,\n", "\n", - "1. All deaths come from intensive care units in hospitals, meaning no patients die outside a hospital. Of the 7703 diseased (01/05/2020), 46% died in a hospital while 53% died in an elderly home. All hospital deaths are confirmed Covid-19 cases while only 16% of elderly home deaths were confirmed. Our model thus does not explicitly include deaths in elderly homes, although a prediction can be made by algebraic manipulation of the model output. When taking the elderly homes out of the model scope, the assumption that deaths only arise in hospitals can be backed by the fact that only 0.3% died at home and 0.4% died someplace else (Reference in comment). Asymptomatic and mild cases automatically lead to recovery and in no case to death.\n", - "2. Patients in critical condition can survive and recover.\n", - "3. Only exposed and asymptomatic patients can infect susceptibles.\n", - "4. It takes several days before an infection becomes severe and patients are hospitalised. To this end, a fraction of mild infections progresses towards hospitalisation with an estimated latency of approximately 3 days.\n", - "5. We implement no testing and quarantining in the hospital. Hospitalised persons are assumed to be incapable of infecting susceptibles in the first place, so the implementation of a quarantine would not change the dynamics but slow down calculations.\n", - "6. We implement the ability for recovered patients to lose *immunity* and become susceptible to Covid-19 once more. However, seasonality is considered out of scope in this work.\n", + "1. There is no connection between the severity of the disease and the infectiousness of an individual. Only the duration of infectiousness can differ.\n", + "2. All patients experience a brief pre-symptomatic, infectious period.\n", + "3. All deaths come from intensive care units in hospitals, meaning no patients die outside a hospital. Of the 7703 diseased (01/05/2020), 46\\% died in a hospital while 53\\% died in an elderly home. All hospital deaths are confirmed Covid-19 cases while only 16\\% of elderly home deaths were confirmed. When taking the elderly homes out of the model scope, the assumption that deaths only arise in hospitals is true due to the fact that only 0.3\\% died at home and 0.4\\% died someplace else. Asymptomatic and mild cases automatically lead to recovery and in no case to death (https://www.info-coronavirus.be/nl/news/trends-laatste-dagen-zetten-zich-door/).\n", + "4. We implement no testing and quarantining in the hospital. Hospitalised persons are assumed to be incapable of infecting susceptibles, so the implementation of a quarantine would not change the dynamics but slow down calculations.\n", + "5. Recovered patients are assumed to be immune, seasonality is deemed out of scope of this work.\n", "\n", "#### Hospital subystem (preliminary)\n", "\n", @@ -137,24 +136,27 @@ "The dynamics of the deterministic system are mathematically formulated as the rate of change of each population pool shown in the above flowchart. This results in the following system of ordinary differential equations (the parameters are explained in the next section):\n", "\n", "\\begin{eqnarray}\n", - "\\dot{S} &=& - \\beta N_c \\cdot S \\cdot \\Big( \\frac{E+A}{N} \\Big) - \\theta_{\\text{S}} \\psi_{\\text{FP}} \\cdot S + SQ/d_{\\text{q,FP}} + \\zeta \\cdot R,\\\\\n", - "\\dot{E} &=& \\beta \\cdot N_c \\cdot S \\Big( \\frac{E+A}{N} \\Big) - E / \\sigma - \\theta_{\\text{E}} \\psi_{\\text{PP}} \\cdot E,\\\\\n", - "\\dot{A} &=& (\\text{a}/\\sigma) \\cdot E - A/d_{\\text{a}} - \\theta_{\\text{A}} \\psi_{\\text{PP}} \\cdot A,\\\\ \n", - "\\dot{M} &=& (\\text{m} / \\sigma ) \\cdot E - M \\cdot ((1-h)/d_m) - M \\cdot h/d_{\\text{hospital}} - \\theta_{\\text{M}} \\psi_{\\text{PP}} \\cdot M,\\\\\n", - "\\dot{C} &=& c \\cdot (M+MQ) \\cdot (h/d_{\\text{hospital}}) - C \\cdot (1/d_c),\\\\\n", + "\\dot{S} &=& - \\beta N_c \\cdot S \\cdot \\Big( \\frac{I+A}{N} \\Big) - \\theta_{\\text{S}} \\psi_{\\text{FP}} \\cdot S + SQ/d_{\\text{q,FP}} + \\zeta \\cdot R,\\\\\n", + "\\dot{E} &=& \\beta \\cdot N_c \\cdot S \\Big( \\frac{I+A}{N} \\Big) - (1/\\sigma) \\cdot E - \\theta_{\\text{E}} \\psi_{\\text{PP}} \\cdot E,\\\\\n", + "\\dot{I} &=& (1/\\sigma) \\cdot E - (1/\\omega) \\cdot I - \\theta_I \\psi_{PP} \\cdot I,\\\\\n", + "\\dot{A} &=& (\\text{a}/\\omega) \\cdot I - A/d_{\\text{a}} - \\theta_{\\text{A}} \\psi_{\\text{PP}} \\cdot A,\\\\ \n", + "\\dot{M} &=& (\\text{m} / \\omega ) \\cdot I - M \\cdot ((1-h)/d_m) - M \\cdot h/d_{\\text{hospital}} - \\theta_{\\text{M}} \\psi_{\\text{PP}} \\cdot M,\\\\\n", + "\\dot{C} &=& c \\cdot (M+MQ) \\cdot (h/d_{\\text{hospital}}) - c \\cdot(1/d_c)\\cdot C,\\\\\n", "\\dot{C}_{\\text{mi,rec}} &=& Mi/d_{\\text{mi}} - C_{\\text{mi,rec}} \\cdot (1/d_{\\text{mi,rec}}),\\\\\n", "\\dot{C}_{\\text{ICU,rec}} &=& (1-m_0)/d_{\\text{ICU}} \\cdot \\text{ICU} - C_{\\text{ICU,rec}} \\cdot (1/d_{\\text{ICU,rec}}),\\\\\n", "C_{\\text{tot}} &=& C + C_{\\text{mi,rec}} + C_{\\text{ICU,rec}}, \\\\\n", - "\\dot{\\text{Mi}} &=& \\text{mi}\\cdot (M+MQ) \\cdot (h/d_{\\text{hospital}}) - \\text{Mi} / d_{\\text{mi}}\\\\ \n", - "\\dot{\\text{ICU}} &=& (1-\\text{c}-\\text{mi})\\cdot (M+MQ) \\cdot (h/d_{\\text{hospital}}) - \\text{ICU}/d_{\\text{ICU}},\\\\\n", + "\\dot{\\text{Mi}} &=& mi \\cdot (M+MQ) \\cdot (h/d_{\\text{hospital}}) - \\text{Mi} / d_{\\text{mi}}\\\\ \n", + "\\dot{\\text{ICU}} &=& (1-c-mi) \\cdot (M+MQ) \\cdot (h/d_{\\text{hospital}}) - \\text{ICU}/d_{\\text{ICU}},\\\\\n", + "H &=& C_{\\text{tot}} + \\text{Mi} + \\text{ICU},\\\\\n", "\\dot{D} &=& m_0 \\cdot \\text{ICU}/d_{\\text{ICU}},\\\\\n", "\\dot{R} &=& A/d_a + M \\cdot ((1-h)/d_m) + (1/d_c) \\cdot c \\cdot M \\cdot (h/d_{\\text{hospital}}) \\\\ && + (M_i/d_{mi}) \\cdot (1/d_{\\tiny{\\text{mi,recovery}}})+ ((1-m_0)/ d_{\\text{ICU}}) \\cdot (1/d_{\\text{\\tiny{ICU,recovery}}}) \\cdot ICU \\\\\n", "&& + AQ/d_a + MQ \\cdot ((1-h)/d_m)+ RQ/d_{\\text{q,FP}} - \\zeta \\cdot R, \\\\\n", - "\\dot{SQ} &=& \\theta_{\\text{S}} \\psi_{\\text{FP}} \\cdot S - SQ/d_{\\text{q,FP}}, \\\\\n", - "\\dot{EQ} &=& \\theta_{\\text{E}} \\psi_{\\text{PP}} \\cdot E - EQ/\\sigma, \\\\\n", - "\\dot{AQ} &=& \\theta_{\\text{A}} \\psi_{\\text{PP}} \\cdot A + (a/\\sigma) \\cdot EQ - AQ/d_a, \\\\\n", - "\\dot{MQ} &=& \\theta_{\\text{M}} \\psi_{\\text{PP}} \\cdot M + (m/\\sigma) \\cdot EQ - MQ \\cdot ((1-h)/d_m) - MQ \\cdot h/d_{\\text{hospital}}, \\\\\n", - "\\dot{RQ} &=& \\theta_{\\text{R}} \\psi_{\\text{FP}} - RQ/d_{\\text{q,FP}},\n", + "\\dot{SQ} &=& \\theta_{\\text{S}} \\psi_{\\text{FP}} \\cdot S - (1/d_{\\text{q,FP}}) \\cdot SQ, \\\\\n", + "\\dot{EQ} &=& \\theta_{\\text{E}} \\psi_{\\text{PP}} \\cdot E - (1/\\sigma) \\cdot EQ, \\\\\n", + "\\dot{IQ} &=& \\theta_{\\text{I}} \\psi_{\\text{PP}} \\cdot I + (1/\\sigma) \\cdot EQ - (1/\\omega) \\cdot IQ, \\\\\n", + "\\dot{AQ} &=& \\theta_{\\text{A}} \\psi_{\\text{PP}} \\cdot A + (a/\\omega) \\cdot EQ - AQ/d_a, \\\\\n", + "\\dot{MQ} &=& \\theta_{\\text{M}} \\psi_{\\text{PP}} \\cdot M + (m/\\omega) \\cdot EQ - MQ \\cdot ((1-h)/d_m) - MQ \\cdot h/d_{\\text{hospital}}, \\\\\n", + "\\dot{RQ} &=& \\theta_{\\text{R}} \\psi_{\\text{FP}} - (1/d_{\\text{q,FP}}) \\cdot RQ,\n", "\\end{eqnarray}" ] }, @@ -173,14 +175,18 @@ "\n", "$$ a = 0.43 .$$\n", "\n", - "Wu and McGoogan (2020) estimated that the distribution between mild, severe and critical cases is equal to 81%, 15% and 4%. " + "Wu and McGoogan (2020) estimated that the distribution between mild, severe and critical cases is equal to 81%, 15% and 4%. As a rule of thumb, one can assume that one third of all hospitalised patients ends up in an ICU. Based on interviews with Ghent University hospital staff, midcare is merged with ICU in the offical numbers. For now, it is assumed that the distribution between midcare and ICU is 50-50 %. The sum of both pools is one third of the hospitalisations. Since the average time a patient spends in midcare is equal to ICU, this corresponds to seeing midcare and ICU as 'ICU'." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "$d_{a}$ , $d_{m}$ , $d_{h}$ : the duration of infection in case of a asymptomatic or mild infection. Assumed to be 7 days.\n", + "$\\sigma$: length of the latent period. Assumed four days based on a modeling study by Davies et al. (2020) .\n", + "\n", + "$\\omega$: length of the pre-symptomatic infectious period, assumed 1.5 days (Davies et al. 2020). The sum of $\\omega$ and $\\sigma$ is the total incubation period, and is equal to 5.5 days. Several estimates of the incubation period have been published and range from 3.6 to 6.4 days, with the majority of estimates around 5 days (Park et. al 2020).\n", + "\n", + "$d_{a}$ , $d_{m}$ , $d_{h}$ : the duration of infection in case of a asymptomatic or mild infection. Assumed to be 6.5 days. Toghether with the length of the pre-symptomatic infectious period, this accounts to a total of 8 days of infectiousness. \n", "\n", "$d_{c}$ , $d_{\\text{mi}}$ , $d_{\\text{ICU}}$: average length of a Cohort, Midcare and ICU stay. Equal to one week, two weeks and two weeks respectively.\n", "\n", @@ -188,35 +194,13 @@ "\n", "Zhou et al. (2020) performed a retrospective study on 191 Chinese hospital patients and determined that the time from illness onset to discharge or death was 22.0 days (18.0-25.0, IQR) and 18.5 days (15.0-22.0, IQR) for survivors and victims respectively. Using available preliminary data, the World Health Organisation estimated the median time from onset to clinical recovery for mild cases to be approximately 2 weeks and to be 3-6 weeks for patients with severe or critical disease (WHO, 2020). Based on this report, we assume a recovery time of three weeks for heavy infections.\n", "\n", - "$d_{hospital}$ : the time before heavily or critically infected patients reach the hospital. Assumed 3 days, still waiting on hospital input here.\n", + "$d_{hospital}$ : the time before heavily or critically infected patients reach the hospital. Assumed 5-9 days (Linton et al. 2020). Still waiting on hospital input here.\n", "\n", - "$m_0$ : the mortality in case of a heavy infection, which is roughly 50\\% (Wu and McGoogan, 2020). " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "$\\sigma$: the incubation period in days. The incubation period is assumed to be Erlang distributed as reported by Li et al. (2020a). The average incubation time is 5.2 days. \n", + "$m_0$ : the mortality in ICU, which is roughly 50\\% (Wu and McGoogan, 2020). \n", "\n", "$\\zeta$: can be used to model the effect of re-susceptibility and seasonality of a disease. Throughout this demo, we assume $\\zeta = 0$ because data on seasonality is not yet available at the moment. We thus assume permanent immunity after recovering from the infection." ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The transmission rate $R_0$ of the disease in the deterministic model depends on the product of three contributions. The first contribution, $(E+A)/N$, is the probability of encountering a contagious individual. The second contribution, $N_c$, is the average number of human-to-human interactions per day. As previously explained, **in the deterministic framework, this assumes all $N_c$ contacts within the population to be random**. The third contribution, $\\beta$, is the probability of contracting SARS-Cov-2 when encoutering a contagious individual. \n", - "\n", - "In this work, we explictly split $\\beta$ and $N_c$ because this has the following advantages: 1) $\\beta$ is now a disease characteristic, independent of social interactions. 2) The goal of this work is to demonstrate the concept of social control to contain the outbreak using model predictive control. By splitting $\\beta$ and $N_c$, the controlled variable is the number of random contacts $N_c$ which is more comprehendible to the reader of this text. The number of human-human interactions per day is estimated using the Social Contact Rates (SOCRATES) Data Tool (Willem et al., 2020). The dataset on human-human interactions is based on a 2008 study by Mossong, which kept track of 7,920 participants and their interactions in 97,904 European countries (Mossong et al., 2008). From SOCRATES, it is determined that the average Belgian has 11.2 interactions with other people each day. This includes both physical and non-physical interactions of any duration.\n", - "\n", - "The testing and quarantine parameters are: $\\theta_{S}$, $\\theta_{E}$, $\\theta_{A}$, $\\theta_{M}$, $\\theta_{R}$ expressed as the number of susceptibles, exposed, supermild and mild individuals tested each day. It is difficult to model a concrete testing scenario in the deterministic framework because no back tracing can be coupled to the tests. The deterministic model only considers random testing of the population. It uses the total daily testing capacity to calculate the amount of individuals in the S, E, A, M and R pool that receive a test. \n", - "\n", - "$\\psi_{PP}$: probability of correctly identifiying and quarantining an exposed or infected person. $\\psi_{FP}$: probability of falsly identifying and quarantining a susceptible or recovered individual. Both parameters can be calculated using the reliability of the test and Bayes theorem. **For now, we assume no false positives.**\n", - "\n", - "$d_{\\text{q,FP}}$: the duration of the quarantine in the case of a false positive, assumed to be 14 days." - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -332,7 +316,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 40, "metadata": { "ExecuteTime": { "end_time": "2020-05-01T09:36:33.234177Z", @@ -342,22 +326,23 @@ "outputs": [], "source": [ "model = models.SEIRSAgeModel( initN = np.array([11.43e6]), #must be a numpy array; size of the Belgian population\n", - " beta = 0.032, # probability of infection when encountering infected person\n", - " sigma = 5.2, # incubation period (days)\n", + " beta = 0.07, # probability of infection when encountering infected person\n", + " sigma = 4.0, # latent period (days)\n", + " omega = 1.5, # pre-symptomatic infectiousness (days)\n", " Nc = np.array([11.2]), #must be a numpy array; average number of human-to-human interactions per day\n", " a = 0.43, # probability of an asymptotic (supermild) infection\n", " m = 1-0.43, # probability of a mild infection\n", " h = 0.20, # probability of hospitalisation for a mild infection\n", " c = 2/3, # probability of hospitalisation in cohort\n", " mi = 1/6, # probability of hospitalisation in midcare\n", - " da = 14, # days of infection when asymptomatic (supermild)\n", - " dm = 14, # days of infection when mild\n", + " da = 6.5, # days of infection when asymptomatic (supermild)\n", + " dm = 6.5, # days of infection when mild\n", " dc = 7,\n", " dmi = 14,\n", " dICU = 14,\n", " dICUrec = 6,\n", " dmirec = 6,\n", - " dhospital = 3, # days before reaching the hospital when heavy or critical\n", + " dhospital = 5, # days before reaching the hospital when heavy or critical\n", " m0 = 0.49, # mortality in ICU\n", " maxICU = 2000,\n", " totalTests = 0,\n", @@ -376,6 +361,7 @@ " initD = np.zeros(1),\n", " initSQ = np.zeros(1),\n", " initEQ = np.zeros(1),\n", + " initIQ = np.zeros(1),\n", " initAQ = np.zeros(1),\n", " initMQ = np.zeros(1),\n", " initRQ = np.zeros(1),\n", @@ -393,14 +379,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "(1, 52)\n" + "(1, 56)\n" ] } ], @@ -422,11 +408,11 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 42, "metadata": {}, "outputs": [], "source": [ - "model.beta = 0.032" + "model.beta = 0.079" ] }, { @@ -440,11 +426,11 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ - "y = model.sim(40)" + "y = model.sim(200)" ] }, { @@ -481,12 +467,12 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 44, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -498,7 +484,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -525,12 +511,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 45, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -542,7 +528,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -593,7 +579,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ @@ -608,27 +594,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "metadata": {}, "outputs": [], "source": [ "ageModel = models.SEIRSAgeModel(initN = initN, #16x0 numpy array\n", - " beta = 0.032, # probability of infection when encountering infected person\n", - " sigma = 5.2, # incubation period (days)\n", + " beta = 0.079, # probability of infection when encountering infected person\n", + " sigma = 4.0, # latent period\n", + " omega = 1.5, # pre-symptomatic infectious period\n", " Nc = Nc_all, #must be a numpy array; average number of human-to-human interactions per day\n", " a = 0.43, # probability of an asymptotic (supermild) infection\n", " m = 1-0.43, # probability of a mild infection\n", " h = 0.20, # probability of hospitalisation for a mild infection\n", " c = 2/3, # probability of hospitalisation in cohort\n", " mi = 1/6, # probability of hospitalisation in midcare\n", - " da = 14, # days of infection when asymptomatic (supermild)\n", - " dm = 14, # days of infection when mild\n", + " da = 6.5, # days of infection when asymptomatic (supermild)\n", + " dm = 6.5, # days of infection when mild\n", " dc = 7,\n", " dmi = 14,\n", " dICU = 14,\n", " dICUrec = 6,\n", " dmirec = 6,\n", - " dhospital = 3, # days before reaching the hospital when heavy or critical\n", + " dhospital = 5, # days before reaching the hospital when heavy or critical\n", " m0 = 0.49, # mortality in ICU\n", " maxICU = 2000,\n", " totalTests = 0,\n", @@ -636,6 +623,7 @@ " psi_PP = 1, # probability of a correct test\n", " dq = 14, # days in quarantaine \n", " initE = np.ones(16), #must be a numpy array\n", + " initI = np.zeros(16),\n", " initA = np.zeros(16), \n", " initM = np.zeros(16),\n", " initC = np.zeros(16),\n", @@ -647,6 +635,7 @@ " initD = np.zeros(16),\n", " initSQ = np.zeros(16),\n", " initEQ = np.zeros(16),\n", + " initIQ = np.zeros(16),\n", " initAQ = np.zeros(16),\n", " initMQ = np.zeros(16),\n", " initRQ = np.zeros(16),\n", @@ -657,12 +646,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 58, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -674,7 +663,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -687,11 +676,11 @@ ], "source": [ "# Create checkpoints dictionary\n", - "chk = {'t': [29,80], \n", + "chk = {'t': [48,140], \n", " 'Nc': [Nc_home,Nc_all]\n", " }\n", "# Run simulation\n", - "y = ageModel.sim(90,checkpoints=chk)\n", + "y = ageModel.sim(160,checkpoints=chk)\n", "# Visualise\n", "ageModel.plotPopulationStatus()\n", "ageModel.plotInfected()" @@ -710,7 +699,7 @@ "> sim(data, parNames, positions, bounds, weights)\n", "> - data: a list containing the dataseries (dtype=np array) to fit the model to. For now, dataseries must be of equal length.\n", "> - parNames: a list containing the names (dtype=string) of the model parameters to be fitted.\n", - "> - positions: a list containing the model states (dtype=np.array) used to calculate the sum of least squares. Each dataseries must be matched to a certain (sum of) model state(s). If multiple entries are provided these are added togheter. The order of the states is given according to the following vector, where S has index 0: (S, E, A, M, C, Mi, ICU, R, F, SQ, EQ, AQ, MQ, RQ).\n", + "> - positions: a list containing the model states (dtype=np.array) used to calculate the sum of least squares. Each dataseries must be matched to a certain (sum of) model state(s). If multiple entries are provided these are added togheter. The order of the states is given according to the following vector, where S has index 0: (S, E, I, A, M, C, Mi, ICU, R, F, SQ, EQ, IQ, AQ, MQ, RQ).\n", "\n", "\n", "The following arguments are optional,\n", @@ -726,7 +715,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 59, "metadata": {}, "outputs": [ { @@ -734,48 +723,82 @@ "output_type": "stream", "text": [ "No constraints given.\n", - "New best for swarm at iteration 1: [3.68356771e+01 3.09490575e-02] 6148.817973563867\n", - "Best after iteration 1: [3.68356771e+01 3.09490575e-02] 6148.817973563867\n", - "Best after iteration 2: [3.68356771e+01 3.09490575e-02] 6148.817973563867\n", - "New best for swarm at iteration 3: [4.60750969e+01 2.62311100e-02] 5084.127499306028\n", - "Best after iteration 3: [4.60750969e+01 2.62311100e-02] 5084.127499306028\n", - "New best for swarm at iteration 4: [4.03450696e+01 2.89037349e-02] 2659.235397472843\n", - "Best after iteration 4: [4.03450696e+01 2.89037349e-02] 2659.235397472843\n", - "Best after iteration 5: [4.03450696e+01 2.89037349e-02] 2659.235397472843\n", - "New best for swarm at iteration 6: [4.35232615e+01 2.75284016e-02] 2282.9364435488965\n", - "Best after iteration 6: [4.35232615e+01 2.75284016e-02] 2282.9364435488965\n", - "New best for swarm at iteration 7: [4.28369531e+01 2.79784991e-02] 2239.9128764024226\n", - "Best after iteration 7: [4.28369531e+01 2.79784991e-02] 2239.9128764024226\n", - "Best after iteration 8: [4.28369531e+01 2.79784991e-02] 2239.9128764024226\n", - "Best after iteration 9: [4.28369531e+01 2.79784991e-02] 2239.9128764024226\n", - "Best after iteration 10: [4.28369531e+01 2.79784991e-02] 2239.9128764024226\n", - "Best after iteration 11: [4.28369531e+01 2.79784991e-02] 2239.9128764024226\n", - "Best after iteration 12: [4.28369531e+01 2.79784991e-02] 2239.9128764024226\n", - "Best after iteration 13: [4.28369531e+01 2.79784991e-02] 2239.9128764024226\n", - "Best after iteration 14: [4.28369531e+01 2.79784991e-02] 2239.9128764024226\n", - "Best after iteration 15: [4.28369531e+01 2.79784991e-02] 2239.9128764024226\n", - "Best after iteration 16: [4.28369531e+01 2.79784991e-02] 2239.9128764024226\n", - "Best after iteration 17: [4.28369531e+01 2.79784991e-02] 2239.9128764024226\n", - "Best after iteration 18: [4.28369531e+01 2.79784991e-02] 2239.9128764024226\n", - "Best after iteration 19: [4.28369531e+01 2.79784991e-02] 2239.9128764024226\n", - "New best for swarm at iteration 20: [4.27030100e+01 2.79785447e-02] 2239.9120169698\n", - "Best after iteration 20: [4.27030100e+01 2.79785447e-02] 2239.9120169698\n", - "Best after iteration 21: [4.27030100e+01 2.79785447e-02] 2239.9120169698\n", - "Best after iteration 22: [4.27030100e+01 2.79785447e-02] 2239.9120169698\n", - "Best after iteration 23: [4.27030100e+01 2.79785447e-02] 2239.9120169698\n", - "Best after iteration 24: [4.27030100e+01 2.79785447e-02] 2239.9120169698\n", - "New best for swarm at iteration 25: [4.27569402e+01 2.79785462e-02] 2239.9119994555717\n", - "Best after iteration 25: [4.27569402e+01 2.79785462e-02] 2239.9119994555717\n", - "Best after iteration 26: [4.27569402e+01 2.79785462e-02] 2239.9119994555717\n", - "New best for swarm at iteration 27: [4.27940445e+01 2.79786117e-02] 2239.9119085065954\n", - "Best after iteration 27: [4.27940445e+01 2.79786117e-02] 2239.9119085065954\n", - "New best for swarm at iteration 28: [4.27617878e+01 2.79785720e-02] 2239.911806804906\n", - "Best after iteration 28: [4.27617878e+01 2.79785720e-02] 2239.911806804906\n", - "New best for swarm at iteration 29: [4.27648565e+01 2.79785806e-02] 2239.9117879758082\n", - "Best after iteration 29: [4.27648565e+01 2.79785806e-02] 2239.9117879758082\n", - "Best after iteration 30: [4.27648565e+01 2.79785806e-02] 2239.9117879758082\n", - "Stopping search: maximum iterations reached --> 30\n", - "[4.27648565e+01 2.79785806e-02]\n" + "Best after iteration 1: [1.52543785e+02 3.68715359e-02] 129746.9516272709\n", + "Best after iteration 2: [1.52543785e+02 3.68715359e-02] 129746.9516272709\n", + "New best for swarm at iteration 3: [1.11957245e+02 4.43994891e-02] 99274.8131986164\n", + "Best after iteration 3: [1.11957245e+02 4.43994891e-02] 99274.8131986164\n", + "New best for swarm at iteration 4: [66.92433212 0.06884325] 19987.092772199845\n", + "Best after iteration 4: [66.92433212 0.06884325] 19987.092772199845\n", + "Best after iteration 5: [66.92433212 0.06884325] 19987.092772199845\n", + "Best after iteration 6: [66.92433212 0.06884325] 19987.092772199845\n", + "Best after iteration 7: [66.92433212 0.06884325] 19987.092772199845\n", + "Best after iteration 8: [66.92433212 0.06884325] 19987.092772199845\n", + "New best for swarm at iteration 9: [6.78793328e+01 6.75305134e-02] 14576.630305337618\n", + "Best after iteration 9: [6.78793328e+01 6.75305134e-02] 14576.630305337618\n", + "New best for swarm at iteration 10: [62.83115187 0.0718445 ] 11660.662943650523\n", + "Best after iteration 10: [62.83115187 0.0718445 ] 11660.662943650523\n", + "Best after iteration 11: [62.83115187 0.0718445 ] 11660.662943650523\n", + "New best for swarm at iteration 12: [61.10103196 0.07316385] 8869.855001374142\n", + "Best after iteration 12: [61.10103196 0.07316385] 8869.855001374142\n", + "Best after iteration 13: [61.10103196 0.07316385] 8869.855001374142\n", + "Best after iteration 14: [61.10103196 0.07316385] 8869.855001374142\n", + "New best for swarm at iteration 15: [58.90451448 0.07674903] 6454.767875497337\n", + "Best after iteration 15: [58.90451448 0.07674903] 6454.767875497337\n", + "Best after iteration 16: [58.90451448 0.07674903] 6454.767875497337\n", + "Best after iteration 17: [58.90451448 0.07674903] 6454.767875497337\n", + "Best after iteration 18: [58.90451448 0.07674903] 6454.767875497337\n", + "Best after iteration 19: [58.90451448 0.07674903] 6454.767875497337\n", + "New best for swarm at iteration 20: [58.44492546 0.07700923] 6074.421385396183\n", + "Best after iteration 20: [58.44492546 0.07700923] 6074.421385396183\n", + "New best for swarm at iteration 21: [58.63462453 0.07692986] 6007.818263732601\n", + "Best after iteration 21: [58.63462453 0.07692986] 6007.818263732601\n", + "Best after iteration 22: [58.63462453 0.07692986] 6007.818263732601\n", + "Best after iteration 23: [58.63462453 0.07692986] 6007.818263732601\n", + "New best for swarm at iteration 24: [58.81949032 0.07693526] 6007.140120103018\n", + "Best after iteration 24: [58.81949032 0.07693526] 6007.140120103018\n", + "New best for swarm at iteration 25: [58.67285963 0.07693922] 6007.121657615863\n", + "Best after iteration 25: [58.67285963 0.07693922] 6007.121657615863\n", + "New best for swarm at iteration 26: [58.65781152 0.07693832] 6007.090292209534\n", + "Best after iteration 26: [58.65781152 0.07693832] 6007.090292209534\n", + "Best after iteration 27: [58.65781152 0.07693832] 6007.090292209534\n", + "Best after iteration 28: [58.65781152 0.07693832] 6007.090292209534\n", + "New best for swarm at iteration 29: [58.68619883 0.0769366 ] 6007.088594372219\n", + "Best after iteration 29: [58.68619883 0.0769366 ] 6007.088594372219\n", + "New best for swarm at iteration 30: [58.6592551 0.07693778] 6007.081554861952\n", + "Best after iteration 30: [58.6592551 0.07693778] 6007.081554861952\n", + "Best after iteration 31: [58.6592551 0.07693778] 6007.081554861952\n", + "Best after iteration 32: [58.6592551 0.07693778] 6007.081554861952\n", + "New best for swarm at iteration 33: [58.67427094 0.07693757] 6007.08023445146\n", + "Best after iteration 33: [58.67427094 0.07693757] 6007.08023445146\n", + "Best after iteration 34: [58.67427094 0.07693757] 6007.08023445146\n", + "New best for swarm at iteration 35: [58.66215713 0.07693729] 6007.080156287711\n", + "Best after iteration 35: [58.66215713 0.07693729] 6007.080156287711\n", + "New best for swarm at iteration 36: [58.66740162 0.07693743] 6007.079934362903\n", + "Best after iteration 36: [58.66740162 0.07693743] 6007.079934362903\n", + "Best after iteration 37: [58.66740162 0.07693743] 6007.079934362903\n", + "Best after iteration 38: [58.66740162 0.07693743] 6007.079934362903\n", + "Best after iteration 39: [58.66740162 0.07693743] 6007.079934362903\n", + "New best for swarm at iteration 40: [58.66572682 0.07693743] 6007.079934347321\n", + "Best after iteration 40: [58.66572682 0.07693743] 6007.079934347321\n", + "Best after iteration 41: [58.66572682 0.07693743] 6007.079934347321\n", + "Best after iteration 42: [58.66572682 0.07693743] 6007.079934347321\n", + "Best after iteration 43: [58.66572682 0.07693743] 6007.079934347321\n", + "Best after iteration 44: [58.66572682 0.07693743] 6007.079934347321\n", + "New best for swarm at iteration 45: [58.66583425 0.07693742] 6007.079934191732\n", + "Best after iteration 45: [58.66583425 0.07693742] 6007.079934191732\n", + "Best after iteration 46: [58.66583425 0.07693742] 6007.079934191732\n", + "New best for swarm at iteration 47: [58.66665798 0.07693742] 6007.079934180436\n", + "Best after iteration 47: [58.66665798 0.07693742] 6007.079934180436\n", + "New best for swarm at iteration 48: [58.6659386 0.07693742] 6007.079934176536\n", + "Best after iteration 48: [58.6659386 0.07693742] 6007.079934176536\n", + "Best after iteration 49: [58.6659386 0.07693742] 6007.079934176536\n", + "New best for swarm at iteration 50: [58.66622804 0.07693742] 6007.079934173369\n", + "Best after iteration 50: [58.66622804 0.07693742] 6007.079934173369\n", + "Best after iteration 51: [58.66622804 0.07693742] 6007.079934173369\n", + "Best after iteration 52: [58.66622804 0.07693742] 6007.079934173369\n", + "New best for swarm at iteration 53: [58.66626966 0.07693742] 6007.079934172988\n", + "Stopping search: Swarm best objective change less than 1e-09\n", + "[58.66626966 0.07693742]\n" ] } ], @@ -783,16 +806,16 @@ "# vector with dates\n", "index=pd.date_range('2020-03-15', freq='D', periods=ICUvect.size)\n", "# data series used to calibrate model must be given to function 'plotFit' as a list\n", - "idx = -42\n", + "idx = -46\n", "index = index[0:idx]\n", "data=[np.transpose(ICUvect[:,0:idx]),np.transpose(hospital[:,0:idx])]\n", "# set optimisation settings\n", "parNames = ['beta'] # must be a list!\n", "positions = [np.array([6]),np.array([4,5,6])] # must be a list!\n", - "bounds=((20,60),(0.02,0.04)) # must be a list!\n", + "bounds=((20,200),(0.01,0.10)) # must be a list!\n", "weights = np.array([1,0])\n", "# run optimisation\n", - "theta = model.fit(data,parNames,positions,bounds,weights,setvar=True,maxiter=30,popsize=60)" + "theta = model.fit(data,parNames,positions,bounds,weights,setvar=True,maxiter=60,popsize=60)" ] }, { @@ -819,12 +842,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 60, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -862,7 +885,7 @@ "> - parNames: a list containing the names (dtype=string) of the model parameters to be used as a control handle.\n", "> - bounds: A list containing the lower- and upper boundaries of each parameter to be used as a control handle. Each entry in the list should be a 1D numpy array containing the lower- and upper bound for the respective control handle.\n", "> - setpoints: A list with the numerical values of the desired model output.\n", - "> - positions: a list containing the model states (dtype=np.array) used to calculate the sum of least squares. Each modelouput in the given position is matched with a provided setpoint. If multiple position entries are provided, the output in these positions is added togheter. The order of the states is given according to the following vector, where S has index 0: (S, E, A, M, C, Mi, ICU, R, F, SQ, EQ, AQ, MQ, RQ).\n", + "> - positions: a list containing the model states (dtype=np.array) used to calculate the sum of least squares. Each modelouput in the given position is matched with a provided setpoint. If multiple position entries are provided, the output in these positions is added togheter. The order of the states is given according to the following vector, where S has index 0: (S, E, I, A, M, C, Mi, ICU, R, F, SQ, EQ, IQ, AQ, MQ, RQ).\n", "> - weights: a list containing the weighting fractions of each population pool ouput in the sum-of-squared errors.\n", "\n", "The following arguments are optional,\n", @@ -879,7 +902,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -887,104 +910,54 @@ "output_type": "stream", "text": [ "No constraints given.\n", - "Best after iteration 1: [1.08030349e+01 7.96453888e+00 1.10739011e+01 1.08936207e+01\n", - " 1.80964343e+00 6.89205377e+00 6.85807107e+05 9.35117265e+05\n", - " 3.36118038e+05 4.10665902e+05 8.60259473e+05 6.06139003e+05] 80242093.35430124\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Process ForkPoolWorker-93:\n", - "Process ForkPoolWorker-86:\n", - "Process ForkPoolWorker-91:\n", - "Process ForkPoolWorker-92:\n", - "Process ForkPoolWorker-94:\n", - "Process ForkPoolWorker-90:\n", - "Process ForkPoolWorker-88:\n", - "Process ForkPoolWorker-96:\n", - "Process ForkPoolWorker-89:\n", - "Process ForkPoolWorker-87:\n", - "Process ForkPoolWorker-95:\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "New best for swarm at iteration 2: [1.12000000e+01 1.12000000e+01 7.49254428e+00 7.34692927e+00\n", - " 0.00000000e+00 1.02029057e+01 5.12317044e+03 3.18648065e+05\n", - " 5.20148671e+05 6.52888459e+05 7.82852317e+05 0.00000000e+00] 78882880.88271818\n", - "Best after iteration 2: [1.12000000e+01 1.12000000e+01 7.49254428e+00 7.34692927e+00\n", - " 0.00000000e+00 1.02029057e+01 5.12317044e+03 3.18648065e+05\n", - " 5.20148671e+05 6.52888459e+05 7.82852317e+05 0.00000000e+00] 78882880.88271818\n" + "New best for swarm at iteration 1: [1.12000000e+01 1.12000000e+01 1.12000000e+01 1.12000000e+01\n", + " 1.12000000e+01 3.67067290e+00 4.65851770e+05 6.91622997e+05\n", + " 8.24897338e+04 9.84811701e+05 5.11709265e+05 6.42724965e+05] 115837006.94086237\n", + "Best after iteration 1: [1.12000000e+01 1.12000000e+01 1.12000000e+01 1.12000000e+01\n", + " 1.12000000e+01 3.67067290e+00 4.65851770e+05 6.91622997e+05\n", + " 8.24897338e+04 9.84811701e+05 5.11709265e+05 6.42724965e+05] 115837006.94086237\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ + "Process ForkPoolWorker-26:\n", + "Process ForkPoolWorker-30:\n", + "Process ForkPoolWorker-28:\n", + "Process ForkPoolWorker-29:\n", + "Process ForkPoolWorker-25:\n", + "Process ForkPoolWorker-31:\n", + "Process ForkPoolWorker-27:\n", + "Process ForkPoolWorker-35:\n", + "Process ForkPoolWorker-32:\n", + "Process ForkPoolWorker-33:\n", + "Process ForkPoolWorker-34:\n", + "Traceback (most recent call last):\n", + "Process ForkPoolWorker-36:\n", + "Traceback (most recent call last):\n", "Traceback (most recent call last):\n", "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mpositions\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mweights\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimizePolicy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparNames\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mbounds\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msetpoints\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpositions\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mweights\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpolicy_period\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m14\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mN\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mP\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpolish\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmaxiter\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m120\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpopsize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m144\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\u001b[0m in \u001b[0;36moptimizePolicy\u001b[0;34m(self, parNames, bounds, setpoints, positions, weights, policy_period, N, P, disp, polish, maxiter, popsize)\u001b[0m\n\u001b[1;32m 893\u001b[0m \u001b[0;31m#theta_hat = optim_out.x\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 894\u001b[0m p_hat, obj_fun_val, pars_final_swarm, obj_fun_val_final_swarm = pso.pso(self.calcMPCsse, scipy_bounds, args=(parNames,setpoints,positions,weights,policy_period,P), swarmsize=popsize, maxiter=maxiter,\n\u001b[0;32m--> 895\u001b[0;31m processes=multiprocessing.cpu_count(),minfunc=1e-9, minstep=1e-9,debug=True, particle_output=True)\n\u001b[0m\u001b[1;32m 896\u001b[0m \u001b[0mtheta_hat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mp_hat\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 897\u001b[0m \u001b[0;31m# ---------------------------------------------\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/PhD/Corona/Python/git/COVID19-Model/src/pso.py\u001b[0m in \u001b[0;36mpso\u001b[0;34m(func, bounds, ieqcons, f_ieqcons, args, kwargs, swarmsize, omega, phip, phig, maxiter, minstep, minfunc, debug, processes, particle_output, transform_pars)\u001b[0m\n\u001b[1;32m 200\u001b[0m \u001b[0;31m# Update objectives and constraints\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 201\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mprocesses\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 202\u001b[0;31m \u001b[0mfx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmp_pool\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 203\u001b[0m \u001b[0mfs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmp_pool\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mis_feasible\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 204\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/lib/python3.7/multiprocessing/pool.py\u001b[0m in \u001b[0;36mmap\u001b[0;34m(self, func, iterable, chunksize)\u001b[0m\n\u001b[1;32m 288\u001b[0m \u001b[0;32min\u001b[0m \u001b[0ma\u001b[0m \u001b[0mlist\u001b[0m \u001b[0mthat\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mreturned\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 289\u001b[0m '''\n\u001b[0;32m--> 290\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_map_async\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmapstar\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchunksize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 291\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 292\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mstarmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchunksize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/lib/python3.7/multiprocessing/pool.py\u001b[0m in \u001b[0;36mget\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 675\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 676\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 677\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 678\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mready\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 679\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mTimeoutError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/lib/python3.7/multiprocessing/pool.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 672\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 673\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 674\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_event\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 675\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 676\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/lib/python3.7/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 550\u001b[0m \u001b[0msignaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_flag\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 551\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0msignaled\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 552\u001b[0;31m \u001b[0msignaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cond\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 553\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0msignaled\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 554\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/lib/python3.7/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 294\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# restore state no matter what (e.g., KeyboardInterrupt)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 295\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mtimeout\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 296\u001b[0;31m \u001b[0mwaiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 297\u001b[0m \u001b[0mgotit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 298\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ "Traceback (most recent call last):\n", "Traceback (most recent call last):\n", "Traceback (most recent call last):\n", - " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", "Traceback (most recent call last):\n", "Traceback (most recent call last):\n", - " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", "Traceback (most recent call last):\n", - " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", " self.run()\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", " self.run()\n", - "Traceback (most recent call last):\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", " self.run()\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", " self.run()\n", - "Process ForkPoolWorker-85:\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", " self.run()\n", - "Traceback (most recent call last):\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", " self.run()\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", " self._target(*self._args, **self._kwargs)\n", - " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", " self.run()\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", @@ -995,15 +968,20 @@ " self._target(*self._args, **self._kwargs)\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n", " result = (True, func(*args, **kwds))\n", - " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n", - " result = (True, func(*args, **kwds))\n", - " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", " self._target(*self._args, **self._kwargs)\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", " self._target(*self._args, **self._kwargs)\n", - "Traceback (most recent call last):\n", + " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", " self._target(*self._args, **self._kwargs)\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n", @@ -1014,16 +992,24 @@ " result = (True, func(*args, **kwds))\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n", " result = (True, func(*args, **kwds))\n", - " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", + " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n", " result = (True, func(*args, **kwds))\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 44, in mapstar\n", " return list(map(*args))\n", + " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", " self._target(*self._args, **self._kwargs)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n", + " result = (True, func(*args, **kwds))\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 44, in mapstar\n", " return list(map(*args))\n", + " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n", + " result = (True, func(*args, **kwds))\n", + " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 44, in mapstar\n", " return list(map(*args))\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 44, in mapstar\n", @@ -1036,156 +1022,148 @@ " return list(map(*args))\n", " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/pso.py\", line 6, in _obj_wrapper\n", " return func(x, *args, **kwargs)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 44, in mapstar\n", + " return list(map(*args))\n", " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/pso.py\", line 6, in _obj_wrapper\n", " return func(x, *args, **kwargs)\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n", " result = (True, func(*args, **kwds))\n", + " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n", + " result = (True, func(*args, **kwds))\n", " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/pso.py\", line 6, in _obj_wrapper\n", " return func(x, *args, **kwargs)\n", " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/pso.py\", line 6, in _obj_wrapper\n", " return func(x, *args, **kwargs)\n", - " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n", - " result = (True, func(*args, **kwds))\n", - " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n", - " result = (True, func(*args, **kwds))\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 837, in calcMPCsse\n", - " self.sim(T,checkpoints=chk)\n", " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/pso.py\", line 6, in _obj_wrapper\n", " return func(x, *args, **kwargs)\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n", " result = (True, func(*args, **kwds))\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/pso.py\", line 6, in _obj_wrapper\n", + " return func(x, *args, **kwargs)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 885, in calcMPCsse\n", + " self.sim(T,checkpoints=chk)\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 44, in mapstar\n", " return list(map(*args))\n", - " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/pso.py\", line 6, in _obj_wrapper\n", " return func(x, *args, **kwargs)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 837, in calcMPCsse\n", - " self.sim(T,checkpoints=chk)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 469, in sim\n", - " self.run(int(T),checkpoints)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n", + " result = (True, func(*args, **kwds))\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 44, in mapstar\n", " return list(map(*args))\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 837, in calcMPCsse\n", - " self.sim(T,checkpoints=chk)\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 44, in mapstar\n", " return list(map(*args))\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 837, in calcMPCsse\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 885, in calcMPCsse\n", + " self.sim(T,checkpoints=chk)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 885, in calcMPCsse\n", " self.sim(T,checkpoints=chk)\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 44, in mapstar\n", " return list(map(*args))\n", - " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n", - " result = (True, func(*args, **kwds))\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 837, in calcMPCsse\n", - " self.sim(T,checkpoints=chk)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 469, in sim\n", - " self.run(int(T),checkpoints)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 469, in sim\n", - " self.run(int(T),checkpoints)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 407, in run\n", - " self.run_epoch(runtime=self.tmax-self.t, dt=dt)\n" + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 503, in sim\n", + " self.run(int(T),checkpoints)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 885, in calcMPCsse\n", + " self.sim(T,checkpoints=chk)\n", " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/pso.py\", line 6, in _obj_wrapper\n", " return func(x, *args, **kwargs)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 885, in calcMPCsse\n", + " self.sim(T,checkpoints=chk)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 885, in calcMPCsse\n", + " self.sim(T,checkpoints=chk)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 503, in sim\n", + " self.run(int(T),checkpoints)\n", " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/pso.py\", line 6, in _obj_wrapper\n", " return func(x, *args, **kwargs)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 885, in calcMPCsse\n", + " self.sim(T,checkpoints=chk)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 503, in sim\n", + " self.run(int(T),checkpoints)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 503, in sim\n", + " self.run(int(T),checkpoints)\n", " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 44, in mapstar\n", " return list(map(*args))\n", " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/pso.py\", line 6, in _obj_wrapper\n", " return func(x, *args, **kwargs)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 469, in sim\n", - " self.run(int(T),checkpoints)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 469, in sim\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 401, in run\n", + " self.run_epoch(runtime=checkpointTime-self.t, dt=dt)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 503, in sim\n", " self.run(int(T),checkpoints)\n", " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/pso.py\", line 6, in _obj_wrapper\n", " return func(x, *args, **kwargs)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 381, in run\n", - " self.run_epoch(runtime=checkpointTime-self.t, dt=dt)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 837, in calcMPCsse\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 885, in calcMPCsse\n", " self.sim(T,checkpoints=chk)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 837, in calcMPCsse\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 503, in sim\n", + " self.run(int(T),checkpoints)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 885, in calcMPCsse\n", " self.sim(T,checkpoints=chk)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 429, in run\n", + " self.run_epoch(runtime=self.tmax-self.t, dt=dt)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 885, in calcMPCsse\n", + " self.sim(T,checkpoints=chk)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 401, in run\n", + " self.run_epoch(runtime=checkpointTime-self.t, dt=dt)\n", " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/pso.py\", line 6, in _obj_wrapper\n", " return func(x, *args, **kwargs)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 837, in calcMPCsse\n", - " self.sim(T,checkpoints=chk)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in run_epoch\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in run_epoch\n", " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 469, in sim\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 401, in run\n", + " self.run_epoch(runtime=checkpointTime-self.t, dt=dt)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 503, in sim\n", " self.run(int(T),checkpoints)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 407, in run\n", - " self.run_epoch(runtime=self.tmax-self.t, dt=dt)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 407, in run\n", - " self.run_epoch(runtime=self.tmax-self.t, dt=dt)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 837, in calcMPCsse\n", - " self.sim(T,checkpoints=chk)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 837, in calcMPCsse\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 885, in calcMPCsse\n", " self.sim(T,checkpoints=chk)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 381, in run\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 401, in run\n", " self.run_epoch(runtime=checkpointTime-self.t, dt=dt)\n", - " File \"/home/twallema/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 44, in mapstar\n", - " return list(map(*args))\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py\", line 577, in solve_ivp\n", - " message = solver.step()\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in run_epoch\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 503, in sim\n", + " self.run(int(T),checkpoints)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in run_epoch\n", " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 849, in calcMPCsse\n", - " som = som + numpy.mean(out[j],axis=1).reshape(numpy.mean(out[j],axis=1).size,1)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 469, in sim\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 429, in run\n", + " self.run_epoch(runtime=self.tmax-self.t, dt=dt)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in run_epoch\n", + " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 503, in sim\n", " self.run(int(T),checkpoints)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in run_epoch\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in run_epoch\n", " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 469, in sim\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 503, in sim\n", " self.run(int(T),checkpoints)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 381, in run\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 401, in run\n", " self.run_epoch(runtime=checkpointTime-self.t, dt=dt)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 469, in sim\n", - " self.run(int(T),checkpoints)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in run_epoch\n", - " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 182, in step\n", - " success, message = self._step_impl()\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/pso.py\", line 6, in _obj_wrapper\n", - " return func(x, *args, **kwargs)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in run_epoch\n", - " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/numpy/core/fromnumeric.py\", line 2920, in mean\n", - " out=out, **kwargs)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in run_epoch\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in run_epoch\n", " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py\", line 577, in solve_ivp\n", " message = solver.step()\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 381, in run\n", - " self.run_epoch(runtime=checkpointTime-self.t, dt=dt)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 407, in run\n", - " self.run_epoch(runtime=self.tmax-self.t, dt=dt)\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 146, in _step_impl\n", - " self.B, self.C, self.K)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in run_epoch\n", + " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py\", line 577, in solve_ivp\n", " message = solver.step()\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py\", line 577, in solve_ivp\n", " message = solver.step()\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 503, in sim\n", + " self.run(int(T),checkpoints)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 401, in run\n", + " self.run_epoch(runtime=checkpointTime-self.t, dt=dt)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 885, in calcMPCsse\n", + " self.sim(T,checkpoints=chk)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 401, in run\n", + " self.run_epoch(runtime=checkpointTime-self.t, dt=dt)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py\", line 577, in solve_ivp\n", " message = solver.step()\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 837, in calcMPCsse\n", - " self.sim(T,checkpoints=chk)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in run_epoch\n", - " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 65, in rk_step\n", - " K[s] = fun(t + c * h, y + dy)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py\", line 635, in solve_ivp\n", + " ys.append(sol(t_eval_step))\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 182, in step\n", " success, message = self._step_impl()\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/numpy/core/_methods.py\", line 75, in _mean\n", - " ret = umr_sum(arr, axis, dtype, out, keepdims)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 319, in run_epoch\n", - " self.numRQ = numpy.append(self.numRQ, numpy.transpose(RQ),axis=1)\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py\", line 577, in solve_ivp\n", - " message = solver.step()\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in run_epoch\n", + " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 401, in run\n", + " self.run_epoch(runtime=checkpointTime-self.t, dt=dt)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 182, in step\n", " success, message = self._step_impl()\n" ] @@ -1196,179 +1174,231 @@ "text": [ " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 182, in step\n", " success, message = self._step_impl()\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 469, in sim\n", - " self.run(int(T),checkpoints)\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 139, in fun\n", - " return self.fun_single(t, y)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 401, in run\n", + " self.run_epoch(runtime=checkpointTime-self.t, dt=dt)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 253, in __call__\n", + " return self._call_impl(t)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py\", line 577, in solve_ivp\n", + " message = solver.step()\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py\", line 577, in solve_ivp\n", + " message = solver.step()\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 182, in step\n", + " success, message = self._step_impl()\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in run_epoch\n", + " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 146, in _step_impl\n", " self.B, self.C, self.K)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in run_epoch\n", + " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 182, in step\n", " success, message = self._step_impl()\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/numpy/lib/function_base.py\", line 4528, in append\n", - " return concatenate((arr, values), axis=axis)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 182, in step\n", " success, message = self._step_impl()\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 146, in _step_impl\n", " self.B, self.C, self.K)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 146, in _step_impl\n", " self.B, self.C, self.K)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 469, in sim\n", - " self.run(int(T),checkpoints)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 381, in run\n", - " self.run_epoch(runtime=checkpointTime-self.t, dt=dt)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 146, in _step_impl\n", " self.B, self.C, self.K)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 65, in rk_step\n", " K[s] = fun(t + c * h, y + dy)\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in run_epoch\n", + " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 536, in _call_impl\n", + " x = (t - self.t_old) / self.h\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in run_epoch\n", + " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py\", line 577, in solve_ivp\n", + " message = solver.step()\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 146, in _step_impl\n", " self.B, self.C, self.K)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py\", line 577, in solve_ivp\n", + " message = solver.step()\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 503, in sim\n", + " self.run(int(T),checkpoints)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 68, in rk_step\n", + " f_new = fun(t + h, y_new)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 65, in rk_step\n", " K[s] = fun(t + c * h, y + dy)\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 21, in fun_wrapped\n", - " return np.asarray(fun(t, y), dtype=dtype)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in run_epoch\n", - " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 68, in rk_step\n", " f_new = fun(t + h, y_new)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 146, in _step_impl\n", + " self.B, self.C, self.K)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 139, in fun\n", " return self.fun_single(t, y)\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 65, in rk_step\n", - " K[s] = fun(t + c * h, y + dy)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 182, in step\n", + " success, message = self._step_impl()\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py\", line 577, in solve_ivp\n", " message = solver.step()\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 68, in rk_step\n", - " f_new = fun(t + h, y_new)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in \n", - " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 21, in fun_wrapped\n", - " return np.asarray(fun(t, y), dtype=dtype)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 401, in run\n", + " self.run_epoch(runtime=checkpointTime-self.t, dt=dt)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py\", line 577, in solve_ivp\n", + " message = solver.step()\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 182, in step\n", + " success, message = self._step_impl()\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 146, in _step_impl\n", + " self.B, self.C, self.K)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 65, in rk_step\n", + " K[s] = fun(t + c * h, y + dy)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 139, in fun\n", " return self.fun_single(t, y)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 236, in system_dfes\n", - " theta_S[theta_S > 1] = 1\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 182, in step\n", " success, message = self._step_impl()\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in \n", - " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 68, in rk_step\n", + " f_new = fun(t + h, y_new)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 139, in fun\n", + " return self.fun_single(t, y)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 139, in fun\n", " return self.fun_single(t, y)\n", - "KeyboardInterrupt\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 21, in fun_wrapped\n", " return np.asarray(fun(t, y), dtype=dtype)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in run_epoch\n", + " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 182, in step\n", + " success, message = self._step_impl()\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 146, in _step_impl\n", " self.B, self.C, self.K)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 381, in run\n", - " self.run_epoch(runtime=checkpointTime-self.t, dt=dt)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 139, in fun\n", " return self.fun_single(t, y)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 215, in system_dfes\n", - " E = numpy.reshape(E,[Nc.shape[0],1])\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 381, in run\n", - " self.run_epoch(runtime=checkpointTime-self.t, dt=dt)\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 21, in fun_wrapped\n", - " return np.asarray(fun(t, y), dtype=dtype)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 65, in rk_step\n", " K[s] = fun(t + c * h, y + dy)\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 139, in fun\n", - " return self.fun_single(t, y)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in run_epoch\n", - " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in \n", - " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 21, in fun_wrapped\n", - " return np.asarray(fun(t, y), dtype=dtype)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 21, in fun_wrapped\n", " return np.asarray(fun(t, y), dtype=dtype)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 139, in fun\n", " return self.fun_single(t, y)\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py\", line 577, in solve_ivp\n", - " message = solver.step()\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 255, in system_dfes\n", - " dR = A/da + ((1-h)/dm)*M + C*(1/dc) + Cmirec*(1/dmirec) + Cicurec*(1/dICUrec) + AQ/dq + MQ*((1-h)/dm) + RQ/dq - zeta*R\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py\", line 577, in solve_ivp\n", - " message = solver.step()\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in \n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 21, in fun_wrapped\n", + " return np.asarray(fun(t, y), dtype=dtype)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in \n", " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in run_epoch\n", - " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n" + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 146, in _step_impl\n", + " self.B, self.C, self.K)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "KeyboardInterrupt\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in \n", - " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 21, in fun_wrapped\n", " return np.asarray(fun(t, y), dtype=dtype)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in \n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 65, in rk_step\n", + " K[s] = fun(t + c * h, y + dy)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in \n", " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", - "KeyboardInterrupt\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 21, in fun_wrapped\n", + " return np.asarray(fun(t, y), dtype=dtype)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py\", line 577, in solve_ivp\n", " message = solver.step()\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 254, in system_dfes\n", - " dICUstar = (1-c-mi)*(M+MQ)*(h/dhospital) - ICU/dICU\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in \n", - " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", - "KeyboardInterrupt\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 182, in step\n", - " success, message = self._step_impl()\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 261, in system_dfes\n", - " dRQ = theta_R*psi_FP*R - RQ/dq\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 182, in step\n", - " success, message = self._step_impl()\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 146, in _step_impl\n", - " self.B, self.C, self.K)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 146, in _step_impl\n", " self.B, self.C, self.K)\n", - "KeyboardInterrupt\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in \n", + " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 274, in system_dfes\n", + " dEQ = theta_E*psi_PP*E - EQ/sigma\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 139, in fun\n", + " return self.fun_single(t, y)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 21, in fun_wrapped\n", + " return np.asarray(fun(t, y), dtype=dtype)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 65, in rk_step\n", " K[s] = fun(t + c * h, y + dy)\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 139, in fun\n", + " return self.fun_single(t, y)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in \n", + " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in \n", + " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 276, in system_dfes\n", + " dAQ = theta_A*psi_PP*A + (a/omega)*IQ - AQ/dq\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 182, in step\n", + " success, message = self._step_impl()\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 65, in rk_step\n", " K[s] = fun(t + c * h, y + dy)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 251, in system_dfes\n", + " theta_E[theta_E > 1] = 1\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in \n", + " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 139, in fun\n", " return self.fun_single(t, y)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 263, in system_dfes\n", - " out = numpy.array([dS,dE,dA,dM,dC,dCmirec,dCicurec,dMi,dICUstar,dR,dD,dSQ,dEQ,dAQ,dMQ,dRQ])\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 146, in _step_impl\n", + " self.B, self.C, self.K)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 281, in system_dfes\n", + " out = numpy.reshape(out,18*Nc.shape[0])\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 21, in fun_wrapped\n", " return np.asarray(fun(t, y), dtype=dtype)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 139, in fun\n", " return self.fun_single(t, y)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 255, in system_dfes\n", - " dR = A/da + ((1-h)/dm)*M + C*(1/dc) + Cmirec*(1/dmirec) + Cicurec*(1/dICUrec) + AQ/dq + MQ*((1-h)/dm) + RQ/dq - zeta*R\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in \n", - " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", + "KeyboardInterrupt\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 21, in fun_wrapped\n", + " return np.asarray(fun(t, y), dtype=dtype)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 253, in system_dfes\n", + " theta_I[theta_I > 1] = 1\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 266, in system_dfes\n", + " dC = c*(M+MQ)*(h/dhospital) - C*(1/dc)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 21, in fun_wrapped\n", " return np.asarray(fun(t, y), dtype=dtype)\n", "KeyboardInterrupt\n", + " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 21, in fun_wrapped\n", + " return np.asarray(fun(t, y), dtype=dtype)\n", "KeyboardInterrupt\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 249, in system_dfes\n", - " dM = m/sigma*E - M*((1-h)/dm) - M*h/dhospital - theta_M*psi_PP*M\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in \n", - " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 263, in system_dfes\n", - " out = numpy.array([dS,dE,dA,dM,dC,dCmirec,dCicurec,dMi,dICUstar,dR,dD,dSQ,dEQ,dAQ,dMQ,dRQ])\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 182, in step\n", - " success, message = self._step_impl()\n", - "KeyboardInterrupt\n", - " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 146, in _step_impl\n", - " self.B, self.C, self.K)\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/rk.py\", line 68, in rk_step\n", " f_new = fun(t + h, y_new)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in \n", + " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in \n", + " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 252, in system_dfes\n", + " theta_I = totalTests/nT\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in \n", + " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in \n", + " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 271, in system_dfes\n", + " dR = A/da + ((1-h)/dm)*M + C*(1/dc) + Cmirec*(1/dmirec) + Cicurec*(1/dICUrec) + AQ/dq + MQ*((1-h)/dm) + RQ/dq - zeta*R\n", + "KeyboardInterrupt\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 139, in fun\n", " return self.fun_single(t, y)\n", - "KeyboardInterrupt\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 261, in system_dfes\n", + " dS = - beta*numpy.matmul(Nc,((I+A)/N)*S) - theta_S*psi_FP*S + SQ/dq + zeta*R\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 271, in system_dfes\n", + " dR = A/da + ((1-h)/dm)*M + C*(1/dc) + Cmirec*(1/dmirec) + Cicurec*(1/dICUrec) + AQ/dq + MQ*((1-h)/dm) + RQ/dq - zeta*R\n", " File \"/home/twallema/anaconda3/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py\", line 21, in fun_wrapped\n", " return np.asarray(fun(t, y), dtype=dtype)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 291, in \n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 308, in \n", " self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval)\n", - " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 224, in system_dfes\n", - " D = numpy.reshape(D,[Nc.shape[0],1])\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + " File \"/home/twallema/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\", line 265, in system_dfes\n", + " dM = (m/omega)*I - M*((1-h)/dm) - M*h/dhospital - theta_M*psi_PP*M\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "KeyboardInterrupt\n" ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mpositions\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mweights\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimizePolicy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparNames\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mbounds\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msetpoints\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpositions\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mweights\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpolicy_period\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m14\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mN\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mP\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpolish\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmaxiter\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m120\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpopsize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m144\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/Documents/PhD/Corona/Python/git/COVID19-Model/src/models.py\u001b[0m in \u001b[0;36moptimizePolicy\u001b[0;34m(self, parNames, bounds, setpoints, positions, weights, policy_period, N, P, disp, polish, maxiter, popsize)\u001b[0m\n\u001b[1;32m 941\u001b[0m \u001b[0;31m#theta_hat = optim_out.x\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 942\u001b[0m p_hat, obj_fun_val, pars_final_swarm, obj_fun_val_final_swarm = pso.pso(self.calcMPCsse, scipy_bounds, args=(parNames,setpoints,positions,weights,policy_period,P), swarmsize=popsize, maxiter=maxiter,\n\u001b[0;32m--> 943\u001b[0;31m processes=multiprocessing.cpu_count(),minfunc=1e-9, minstep=1e-9,debug=True, particle_output=True)\n\u001b[0m\u001b[1;32m 944\u001b[0m \u001b[0mtheta_hat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mp_hat\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 945\u001b[0m \u001b[0;31m# ---------------------------------------------\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/PhD/Corona/Python/git/COVID19-Model/src/pso.py\u001b[0m in \u001b[0;36mpso\u001b[0;34m(func, bounds, ieqcons, f_ieqcons, args, kwargs, swarmsize, omega, phip, phig, maxiter, minstep, minfunc, debug, processes, particle_output, transform_pars)\u001b[0m\n\u001b[1;32m 200\u001b[0m \u001b[0;31m# Update objectives and constraints\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 201\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mprocesses\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 202\u001b[0;31m \u001b[0mfx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmp_pool\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 203\u001b[0m \u001b[0mfs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmp_pool\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mis_feasible\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 204\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/lib/python3.7/multiprocessing/pool.py\u001b[0m in \u001b[0;36mmap\u001b[0;34m(self, func, iterable, chunksize)\u001b[0m\n\u001b[1;32m 288\u001b[0m \u001b[0;32min\u001b[0m \u001b[0ma\u001b[0m \u001b[0mlist\u001b[0m \u001b[0mthat\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mreturned\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 289\u001b[0m '''\n\u001b[0;32m--> 290\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_map_async\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmapstar\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchunksize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 291\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 292\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mstarmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchunksize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/lib/python3.7/multiprocessing/pool.py\u001b[0m in \u001b[0;36mget\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 675\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 676\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 677\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 678\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mready\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 679\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mTimeoutError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/lib/python3.7/multiprocessing/pool.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 672\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 673\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 674\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_event\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 675\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 676\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/lib/python3.7/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 550\u001b[0m \u001b[0msignaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_flag\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 551\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0msignaled\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 552\u001b[0;31m \u001b[0msignaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cond\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 553\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0msignaled\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 554\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/lib/python3.7/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 294\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# restore state no matter what (e.g., KeyboardInterrupt)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 295\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mtimeout\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 296\u001b[0;31m \u001b[0mwaiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 297\u001b[0m \u001b[0mgotit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 298\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] } ], "source": [ @@ -1439,7 +1469,7 @@ "realTimeScenario(startDate, data, positions, pastPolicy)\n", "> - startDate: a string with the date corresponding to the first entry of the dataseries (format: 'YYYY-MM-DD'). \n", "> - data: a list containing the dataseries (dtype=np array) to fit the model to. For now, dataseries must be of equal length and start on the same day.\n", - "> - positions: a list containing the model states (dtype=np.array) used to calculate the sum of least squares. Each dataseries must be matched to a certain (sum of) model state(s). If multiple entries are provided these are added togheter. The order of the states is given according to the following vector, where S has index 0: (S, E, A, M, C, Mi, ICU, R, F, SQ, EQ, AQ, MQ, RQ).\n", + "> - positions: a list containing the model states (dtype=np.array) used to calculate the sum of least squares. Each dataseries must be matched to a certain (sum of) model state(s). If multiple entries are provided these are added togheter. The order of the states is given according to the following vector, where S has index 0: (S, E, I, A, M, C, Mi, ICU, R, F, SQ, EQ, IQ, AQ, MQ, RQ).\n", "> - pastPolicy: a checkpoints dictionary containing past government actions.\n", "\n", "The following (simulation) arguments are optional,\n", @@ -1457,12 +1487,12 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 61, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgYAAAE8CAYAAAC7Nnn2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xd4VFX6wPHvmUkmFQIESAYChJIEEjCUUI0KKEoHBUSxRlRg14a6y1qCglJcO2vDn1hQRFzFsnYUEWwoiLQkhE4IVUpISE/O7487k0z6BDKZlPfzPPeZuee2NwPJfefcU5TWGiGEEEIIAJO7AxBCCCFE3SGJgRBCCCGKSGIghBBCiCKSGAghhBCiiCQGQgghhCgiiYEQQgghikhiIMR5UkrtU0qtOY/jb1ZKaaXU4JqLSgghzo0kBqJRUEoNtt18HZdspdQepdQbSqlu7o5RCCHqAg93ByBELVsOfGF77wNcANwKTFBK9dBa73dDTG8D7wG5bri2EEKUIImBaGz+0Fq/41iglNoJPA9cBTxb2wFprQuAgtq+rhBClEceJQgBh2yvJb6xK6UmK6V+VEqlK6UylVLrlVITnT2pUmqGUmqH7ZFFslLqjvLaE1RQ9qitLLSc85Zp02Db902l1FCl1C+2eA8qpWbZtjdXSi1RSh2zbftMKdXG2Z9FCNF4SI2BaGx8lVItbe99gO7APOAv4EP7Tkqpx4GHgK+AeKAQuBL4r1LqDq31i5VdxHZDXgj8ATwI+AL/AI7X6E9TUi9gDPAqsBS4GliolMoGbgL2AY8CXYC7bPtc5sJ4hBD1kCQGorGZY1scJQAXaa2PACilemMkBQu01g867LdIKfUxsEAptVRrnV7eBZRSLTBuwFuBC7XW2bby14AdNfnDlNIDGKi1Xm+73hJgP8bjkRe01nc5xAgwUykVobV2ZUxCiHpGHiWIxuZVYJhtGQPMAloCXyilOtj2uQ7QwFtKqZaOC/Ap0AQYWMk1hgHewMv2pADAlngsq+kfyMEv9qTAdr1c4DdAAYtK7bvO9hrmwniEEPWQ1BiIxman1vpbh/XPlFI/AL8CTwDXAN0wbqZJlZwnqJJtHW2v5X0Td+W38z3llJ2yve6toDzQdeEIIeojSQxEo6e1Xq+USgOG2ooURo3BCCruLbC9klOqmgirkm0V/d5W2LPB1vOhPDURqxCiAZHEQAiDB+Ble78TGA4c0FonnsO57N/OI4DVpbZFOHmOk7bXFhiNBgFQSnkDVmDXOcQlhBBVkjYGotFTSg0D/ICNtqK3ba/zlVLmcvZvXcUpVwE5wAzbjdx+XDBG+wVnJNteS/camIn83gohXEhqDERj01spdb3tvRcQBdwG5AEPA2itf1dKPYLRe+FPpdR/McY6sAJ9gJGApaILaK1PKKXmAPOBn5RS72B0V7wd44YfQ+WPCgC+xWjjMFcpFYhRCxELDMDoWimEEC4hiYFobK61LWCMTXAC4xv+Aq317/adtNZzlVIbMfr734NRo3AM2AbcXdVFtNYLlFJnbPsuBA4AT2I8048Bsqo4vkApNQ6jN8GdGIMvfQNcAvzk7A8rhBDVpbSu6ouLEKKmKKX+A9wBtNFaH3Z3PEIIUZokBkK4gFLK23EMA1uZFePxwAGtdQ/3RCaEEJWTRwlCuMZgpdSTwErgIBCK0ZbBH/iXG+MSQohKSWIghGvsAnZjJAOBQDawAaMtw7eVHSiEEO4kjxKEEEIIUaRB9ocePny4xugO5vTyyy+/VPsYWeQzlc+0fi/yeZZZhGiYicFff1W/m3dOTo4LImnc5DOtefKZ1iz5PIUoq0EmBkIIIYQ4N5IYCCGEEKKIJAZCCCGEKCLdFYUQQlRo48aNrT08PF4DuiNfJhuKQmBbfn7+rX369DlWeqMkBkIIISrk4eHxWnBwcLdWrVqdMplM0nOhASgsLFTHjx+PPHLkyGvA2NLbJfsTQghRme6tWrU6I0lBw2EymXSrVq3SMGqBym6v5XiEEELULyZJChoe279puTmAPEoQtauwAI6vg/3vwYnfIecYRM+HDtdAYS6YfUCZIPklOLMDWl0IbUeDh6+7IxdCiEZBEgNRO05uhL1vw4H3IavUbMMnfoOAyJJle98yypMXgYc/hIyH0CkQfBmYPGsvbiGEaGTkUYJwrZwT8GscfBUDO54vmxQAKA9o0cdYmvUE/06QmVq8PT8D9r0Da0bCx+1hxwtQkFt7P4MQwq18fX172d9v2bLF65JLLunSvn377p06dYoaOXJkp5SUFI9FixYF3njjje0dj+vXr1/E2rVry61uHD58eKeEhARLTcda2TXL22fQoEHhx48fN9d0HOdDEgPhGlrTOms1fNYN9rxZcpt3awi/A4Z+B2P3Go8S7ExmsDSHmP9A93hoGlHy2OwjsPFO+CzCqIEoLHD5jyKEqBsyMzPVmDFjwqZNm3b8wIED2/bs2bN9xowZx48cOVKt2u8NGzZ4FxQUqMjISLd/w7j22mtPPPXUU63cHYcjSQyEaxz5lshTj0HO8eKykCth6LcwPtW48QcPBf9Q8PApe3y7K+GCuTAqEYb/Ad3uBx9r8faz++CXG+HLnuXXQgghXOPee9ugVB+nlmuv7VDm+Guv7VBin3vvbePspV999dUWvXv3zpgyZUqavWzMmDHpffv2za7Oj/Dmm28Gjhkz5rR93dfXt9eMGTPaRkVFdRs0aFD4999/79uvX7+IkJCQHsuWLQsAIymZOHFiaHh4eGS3bt0i//e//zUByMjIUKNHj+4UHh4eOWrUqE7Z2dnKft6VK1c27dmzZ9fIyMhuI0aM6JSWllbmnnvNNdecXrlyZWB14nc1SQyEa1gCOWmx1f75tIWLP4GLV0LwpWCqRnKvFLToBb2ehLF7oNfTYHH4HfJsCh5NazZ2IUSdtG3bNp/evXtnnu951q9f7z9gwICi82RlZZmGDBmSvn379kQ/P7+Chx9+uO26deuS//vf/+567LHH2gI88cQTrQGSk5MT3n333T233357aGZmpnrqqada+/j4FCYnJyfMnj37cEJCgh/A4cOHPebPn29du3ZtckJCQmLv3r0zH3vssaDSsbRq1aogNzdXHTlypM48TpDGh6LmndwICpKb3ceAZr9B9GPGDfx8mb2h273Q5VZIfBr2vAHdH4b0JOPxg3+n87+GEKJeUko5XX78+HHP4ODgPPu6p6ennjhx4hmAqKioLC8vr0IvLy/dr1+/rNTUVAvAzz//7H/nnXceA+jVq1d2mzZtcrdu3er9448/+t91113HAPr3758VHh6eCbBmzRq/3bt3e/fr168rQF5enurTp09GeTEGBgbmHzhwwBIcHJx1Pp9BTZHEQNSM7GNgaQmnNxnrAd3J9kiHmOdr/lqeTeGCOUYbBJOHce3MFCMh8Q+DA+9B59uM2gYhRM165plDPPPMoXM+fvny/Sxfvv9cDo2Kispeu3atf3nbWrZsmX/69OkS37pPnz5tDgoKyi+9r5eXV2FWVlZRjbmHh4c2mYxVk8mEl5eXBjCbzRQUFCgArSseyqG85ENrTWxs7Jn//e9/e6v6uXJycpSvr29hVfvVFnmUIM7f6W3wxQXw+3RjvdkFYPZy/XXtjyS8W0OzaOP9H/fAb9Pgx0mQV25yLoSop2677bYTGzdu9H/vvfcC7GUffPBB099++80nNjb27MaNG/0PHDjgAbB27Vrf3NxcU+fOncs0MAwLC8tOTEys1h+p2NjYjHfeeacFGD0jDh8+bLnggguyHct///137+TkZF+AwYMHn92wYYP/tm3bvADS09NNW7ZsKXPNwsJCjh8/7hkREZFTnXhcSRIDcX6yj8P3wyH7KOz+PzjynXvGGTB5gDLDnreM9ZQPYdUgyKgyWRdC1BP+/v76k08+2fXiiy+27tChQ/fOnTtHvfnmmy2tVmteu3bt8p944omU4cOHh3Xt2jVy5syZ7d555509ZnPZR/cjRow4vXr16ibVufY///nPYwUFBSo8PDxy8uTJnRcvXrzPx8dH33///cfOnj1rDg8Pj5w/f35wjx49zgK0adMmf/HixfuuueaaTuHh4ZF9+vTpunXrVu/S5/3xxx99e/XqddbTs+6Mz6Iqqx6pr2JiYvSGDRuqdcyaNWsYPHiwawJqqAoLYM0IOLLKWPdoAkO+NEYrxA2faWEe/HEfJP+nuMzSAmLfNxo9NgDy/7RmyedZRpk68c2bN++Ljo7+yx3BuEpGRoa68MILIzZu3Jjk4eHeJ+pxcXHtxo8ff3rcuHHptX3tzZs3t4yOjg4tXS41BuLcbX+8OCkAiF1RlBS4hckTYhZB/9fBZBu3JPekUaOx7133xSWEqFP8/f317NmzD+3du7fGBziqru7du2e5IymojEsTA6VUM6XUB0qpJKVUolJqoFKqhVJqlVJqp+21uW1fpZRapJTapZTaopTq7XCem2z771RK3eTKmIWTDq+CrXOK16MehDYj3BePo85xcNkPxeMe6Hz4+TrY8Z/KjxNCNBoTJkw4ExYW5vYBju677746Vxvj6hqD54GvtNZdgWggEfgX8J3WOgz4zrYOMAIIsy23Ay8DKKVaAI8A/YF+wCP2ZEK4SeZB+HkKYHsMFTQEesyp9JBa13IAXPE7BEQVl228C7bMhgb4+EwIIWqKyxIDpVRT4GJgCYDWOldrfRoYB9haiPEWMN72fhywVBt+BZoppazAFcAqrfVJrfUpYBUw3FVxiyoUFsBP10COLcn1DoZB71Zv0KLa4tsWLlsLLQcWl217DLY87L6YhBCijnNljUEn4DjwhlJqk1LqNaWUHxCktT4MYHttbdu/LZDicPxBW1lF5cIddr8Kx38y3isTXPge+AS7N6bKeLWAoavAanvM4eEHrS5xb0xCCFGHufJrngfQG7hTa71eKfU8xY8NylPeaDS6kvKSByt1O8YjCIKCglizZk21gs3IyKj2MY2NuTCLAUdnYe9Us8/vBvYlakhcU+7+dekzVdxLuC8c8b6UtMR8SFpVL6dvrkufaUMgn2dJdbWHhq+vb6/MzMxN9vVFixYFbtiwwW/p0qUHauoavXr16rpp06akHTt2WL7//nv/6dOnn6xs/x07dlhGjx4dtnPnzu2lt+3fv9/z5ptv7vD999/vqqn4qrpmefv89ttvPk888UTQhx9+uK8613FlYnAQOKi1Xm9b/wAjMTiqlLJqrQ/bHhUcc9i/ncPxIcAhW/ngUuVrSl9Ma/0q8CoY3RWr+x9cui05afdzsH0eAKGjXiHUXKZbbpG695lehhWMSZeyDoG3FXydnr+lTqh7n2n9Jp+nsNu0aVMSwM6dO71WrFjRoqrEoDLz588Pmjp1qtsbFfbr1y/r8OHDlp07d1qq09DSZY8StNZHgBSllH3e3EuBBOBTwN6z4CbgE9v7T4Ebbb0TBgBptkcNXwOXK6Wa2xodXm4rE7UtPwuaR8Plv8KQb4y5C+ojH6uRFGQfhqNrYdM/QdeZ0UiFENWQnJxsGThwYHh4eHjkwIEDw3fu3GkBeP3115uHhYVFRURERMbExESAUdNw6aWXdr7ooovCQkNDu993331FU7b6+vr2AnjooYfabtiwwb9r166Rc+bMab1jxw5Lnz59IiIjI7tFRkZ2W7VqlV9VMX3++efNJ0yYkGa/5mWXXdZ56NChXdq2bdtj/vz5rR599NGgbt26RUZHR3c9evSoGeDnn3/2iY6O7hoeHh45bNiwzsePHzcDrFu3zjciIiKyZ8+eXZ955hn7o3fy8/OZNm1aSPfu3buFh4dHPvnkky3Li2XEiBGn33rrrWo12Hd1i7E7gWVKKQuwB4jDSEbeV0pNBQ4Ak2z7fgGMBHYBmbZ90VqfVEo9Bvxu22+u1vqcMzlxHs4kGK/erYylPvNtA+m7YN1VkHsC8s5A35dlfgUhqrLx3jbseNZa9Y5Ah2v+4sJS8yL8dG0H9r9XfBOLmHmYPpXPvZCTk2Pq2rVrpH09LS3NPGzYsDSA6dOnt58yZcqJO++888Rzzz0XOGPGjHbffvvt7oULF1q/+eab5I4dO+b99ddfRcMfbtmyxW/r1q3b/f39C3v16hU5bty4tIsvvrhopsV58+alPv3000H2xwDp6emmdevWJfv6+uqtW7d6XXvttZ22bduWWFGsSUlJloCAgHwfH5+iR97Jyck+mzdvTsjKyjJFRER0j4+PT01MTEyYOnVqu8WLFwfOnj372M0339zx2WefPTBq1KiMe+65p82sWbPavP766ylTp04NtZdPmzYtxH7O5557rmVAQEDBtm3bErOyslTfvn27jhkz5kzpeRv69+9/duHChVbgaGWfsSOXJgZa6z+BmHI2lRmGThtDMP69gvO8Drxes9EJp2ltTFQExjwI1RASEkJqamqZ8rZt23Lw4MGaiO7cpX5qJAUAuxYbMzT2XODemIQQZXh5eRUmJSUl2NftbQwANm3a5Pfll1/uBpgxY8bJOXPmhADExMRkXHfddaETJkw4dd11152yHxsbG3smODi4AGDUqFGn1qxZ4++YGJSWm5urpk6d2iEhIcHHZDKxf//+SudYSElJ8WzRokWJiZsGDRqU3rx588LmzZsX+vv7F0yaNOk0QI8ePTK3bNnie+LECXN6erp51KhRGWDMCTFp0qROpctvueWWE6tXrw4A+Pbbb5smJSX5fvrpp80B0tPTzQkJCd5RUVHZjte2Wq35R48erVaDKhn5UFQu9xR82dOYB8EjoNoN9saOHYvFUnZwsdTUVJRSRUtISEg5R7tYr39D6HXF6wkLIeHftR+HEKLGvfvuuwcef/zxQykpKZaePXtGHTlyxAxlZ0KsaLpmu3nz5gW1bt06LzExMWHr1q0JeXl5ld43fX19C3NyckrsY7FYimoPTCYT3t7e2v4+Pz+/wgC01hXGp7VWTz/99IGkpKSEpKSkhNTU1K1XXXXVmdL7ZWVlmby9vav1rLQOdj4XdUri03B6i7GkJcKFy6p1eHx8PG+88Ual+1gsFsaNG3c+UZ4bZYIBbxiPEVL/Z5T9OQsszaDL7bUfjxD1QZ9nDlVV9V+pC5fvL/N44Tz06tXr7Guvvdb873//+8nFixe3iImJyQDYvn2719ChQ88OHTr07Ndff91sz549FoAff/yx6dGjR81+fn6FX3zxRbPXXnttn+P5AgICCjIyMooePaSlpZlDQkJyzWYzL7zwQmBBQUGl8fTo0SMnNTW1WkMtBwYGFjRt2rTgq6++8h8+fHjGkiVLAgcOHJjRsmXLAn9//4Kvv/7a/4orrsh48803W9iPGTZsWNrLL7/cavTo0eleXl56y5YtXqGhoXmlz52QkOAVERGRVZ14pMZAVCz3dMkJidqOrvYprFYrcXFxRbUGnp6elJ7tzGw2Ex8fX+E5QkJCStQu1Ggtg8nTmGSp9eDist+mw/4V539uIYTLvfzyywfefvvtluHh4ZHLly8PfOmll1IAZs6cGRIeHh4ZFhYWNWDAgPQBAwZkgfGIYfLkyR27d+8eNWbMmFOlHyP069cvy8PDQ0dERETOmTOn9T333HNs+fLlgdHR0V2Tk5O9fXx8Kv323bRp08L27dvn2KdbdtYbb7yxd9asWSHh4eGRW7Zs8Vm4cOEhgCVLluy766672vfs2bOrY7uFmTNn/tW1a9fsHj16dAsLC4u67bbbOuTl5ZWpXli9enXT0aNHp1UnFpld0Ua6LZVj2+OwxXbDbhoBI7eDqewUpo4c2xQ89dRT3H///SW2+/j4cPXVV7N8+XJyc3OxWCx4enpy9uzZaoVmsVi49dZbefHFF6t1XIXy0uG7oXDS9v/G5AlDvjaGe65D5P9pzZLPs4wGPbuiK8Y/KM/SpUubbdiwwXfRokXnXrNSA7KystSAAQMiNmzYkFTetM4yu6KonrwMSHq2eD3ywSqTAii/TYHFYiEqKgqTyURcXBwLFizAZDL+65nNZiZOnFhuO4TKVFXLUG2eTWDwl9C0m7FemAdrx8PprTV3DSFEo3DjjTeeDg0NdfsETbt27bLMmzcvtbykoDKSGIjy7XrFmLIYwK8jhF7r1GHx8fFFN307s9nMsmXLCA0NJT4+vujxQnmJQkXMZnNR8mCxWIiLiyM4uOKhmM/p8YN3SxjyFfjYBj3KOyMzMgrRgNx1110nXF1bYHfvvfe6vZalR48eOaNHj672lM6SGIiy8rMg8ani9ah/gcmzwput49KmTRuys4t7y9hv4tHR0ezevbvoZh4fH18mUXC88UdFRZVYv/7660vUMlRVW3DOvSH82sPgL8CjCbS7CjpPrfbHJ4QQ9ZkkBqKs3Usg2zYWhm8IdDQGqizvZmsymcp823dsYFjRTdxqtZZJFBxv/MuWLSuxvnDhwhK1DJXVFpQ+X0Uq7A3RPBpGboaBy4xZI+VxghCiEZHEQJRUkAOJTxSvd/snmI3GteXdbC0WS5lkwcPDg+uvvx7AqZs4UObxQnR0dJlEwLGWwdnznXNvCP+O4OENTSKgMBcy9lZ5TSGEaAgkMRAl7X0bMm0jEnq1hs63Fm0qr8r/lltuKVNmbzfg5eVVrQaCpW/8pdfttQwxMTFVPtJQSvHRRx8VJTL2ZKU67RQA8PQH3w6Q8xdsvE8GQBJCNHiSGIiSWl0I7SaC2Y95K7NRnr4lbrYvv/wyublGY1v7N+7SjwHs7Qa6d+/uVG2BXenHC6XX7SpqP+DIYrFw1VVXVdjIsVq9Gjz8YOsc2PEM/PkvSPnI6Z9JCCHqG0kMREk+VqOx4ZWpHGt+dZVdD4ODg8s8BqhOMnAunGk/4Ji0VNQbwuk4lRny7Q17Nfx8PZzcVOkhQoiaY5/5EGDLli1el1xySZf27dt379SpU9TIkSM7paSkeCxatCjwxhtvbO94XL9+/SLWrl3rW945hw8f3ikhIaHMN4zyzlPaZ5991sSZWRaXL18eMHPmzPo1tzuSGIjSMnYbr5YA/vXQ3Cq7HtpV5/n/+XKmF4Nj0lJeb4iVK1c6353RbIHYD8G/s7FekAk/jIFMt45dIkSd9Morr7Ro06ZND5PJ1KdNmzY9XnnllRZVH+WczMxMNWbMmLBp06YdP3DgwLY9e/ZsnzFjxvEjR45Ua3j/DRs2eBcUFKjIyMhzGmtg9erVTdatW+df1X6TJ09O++qrr5qlp6fXq3ttvQpWuFihbUKwJuFA+Tfg8roe2vctr9rfVarqxVBRgmKP88orryy3NqTCORu8W8Iln4FngLGelQprx0J+hZOyCdHovPLKKy1mzpzZ4fDhwxatNYcPH7bMnDmzQ00lB6+++mqL3r17Z0yZMqVoiN8xY8ak9+3bN7uy40p78803A8eMGXPavv78888HhoaGdu/bt2/Ezz//XHTDf/fddwMuuOCCrt26dYscNGhQeEpKiseOHTssS5cubfXKK68Ede3aNfKrr77yL28/MHptDRo0KH3FihUBNfHz1xZJDIThr/XFwwF7NikqLq/9QF3gTC+GylQ0EFOlP19AV7joA+PRAsDJjfDLjaCrNXGZEA3W3Llz22ZnZ5f4xcrOzjbNnTu3bU2cf9u2bT69e/c+72x8/fr1/gMGDMgE2L9/v+fChQvb/Pzzz0nr1q1LTk5O9rHvN2zYsIw///wzKTExMWHixIkn586dGxwREZF74403Hp8+ffrRpKSkhOHDh2eUt5/9HDExMWedqV2oSyQxEMaN7adryftiICsfiyG4WckBi8xmc621H6iOqnoxVKai2pAqf77gyyDmheL1lA+L55MQopE7cuRIua2CKyqvSRVNT1xe+fHjxz2Dg4PzANauXes3YMCA9DZt2uR7e3vrq6666qR9v71791ouuuiisPDw8MhFixYFJyUl+ZQ5WRX7BQcH59fGz1+TJDEQcPgbOLsXTw8Y3A3SHPJxi8XCxIkTa639QHU424uhIudcGxI2HSLuLl7fPt/o5ilEIxccHFzuM/uKyqsrKioq+48//ii3MWHLli3zT58+XWKwktOnT5uDgoLyS+/r5eVVmJWVVXT/qyipuOOOO9r/7W9/O5acnJzwwgsv7M/JySn3nlnZfllZWcrb27teVStKYiBg58tFb9/52Uy2w4ze9lEHa7P9QG1xfBxhMpmwWq3Oz63Q62loM7J4/Y/7jImnhGjEZs+enVr6Jujt7V04e/bs1Jo4/2233XZi48aN/u+9917RM/sPPvig6W+//eYTGxt7duPGjf4HDhzwAFi7dq1vbm6uqXPnzmWSkrCwsOzExEQvgIsvvvjsr7/+2uTIkSPmnJwc9dFHHzW375eenm5u3759HhjtEuzlTZo0KUhPTzdXtR/Ajh07vKOiorJq4uevLZIYNHZnU+DQZ0WrJwMnVb96vR6zP34ob4bHShsjmsxw4XII6G5MuhTzgjHegRCN2PTp008+++yz+61Wa65SCqvVmvvss8/unz59+smqj66av7+//uSTT3a9+OKLrTt06NC9c+fOUW+++WZLq9Wa165du/wnnngiZfjw4WFdu3aNnDlzZrt33nlnT+kRTwFGjBhxevXq1U0AOnTokDdr1qxDAwYM6BYbGxt+wQUXFNWZPvTQQ4euvfbazn369IkIDAwsqnmYMGHC6c8//7yZvfFhRfsBrF27tsn48ePTqEeU1trdMdS4mJgYvWHDhmod02jnZd8yG7Y9ZrwPGsrhyHfo1KkT2dnZ+Pj4sGfPnnNODOrTZ3r48OGin7sqbdu25eBB2+iQZw+AyRuyUoz1Fn1cGGX9+kzrA/k8yyhTp7558+Z90dHRbp8psCZlZGSoCy+8MGLjxo1JHh7V6ulYLSkpKR5XX311p19++SXZZRc5D5s3b24ZHR0dWrpcagwas8IC2P168XrYjFofrKiuqGpsBLsytQh+7cGntVFzAHCmTv7+CyEc+Pv769mzZx/au3evSxsF7tmzx/L000+nuPIariCJQWN27AejPz6AVysIMW54tTlYUV1S2dgIdhU2UjR7GQMg5afD4e9gx39qI2QhxDmaMGHCmbCwsBppFFmRSy65JHPQoEH1qn0BSGLQuO1bVvy+w2QweQK1P1hRXVHR2AjOtrkI6dSdaZNiyPpiO2IHAAAgAElEQVT6Mth4FxP6VdGAUQgh6iBJDBqrgmzObH+jaLX/NS9U3RK/EShvbARnuzSOHTuGif0VPrbKyaUzIKazR8UNGIUQog5yXasLUbelfk5TH6Ph6a4j8Jt9ioTKWuI3AvbaEsf1uLg4Fi9eXKa2ICQkhNTUkr2w3vOD9XMhLBj8vODDuwvwHjej1uIXQojzJTUGjURISEiJ/vneXSbyz3fhu+3w+g/F+9WlYY/rioomXiqdFACkZZkY/6wqGiSqfaCm9Y7pUODSR5lCNGiOsyuCczMgVlevXr26AuzYscPizNwOO3bssISFhUWVt23//v2eQ4YM6VLetspmfLSbO3dua2cmXho9enSnrVu3elW1X3VJYtBIjB07tkQL+/wCWJvswazPu/H0V41n3IJzUdnES6VZLBb2/OXFtS9AoX2Yl+M/wYa/QQPsGixEQ7Fp06YkgJ07d3qtWLHivCZ9mj9/ftDUqVPPuYvn4sWLgzIyMqq8P8+YMePYvHnzavwPtiQGjUTpSYPaBxq1A0veWl4nJ0mqiyqaeMmxceItt9xCXFwcX2818fH+gcU77l4CydJTQTRsQUFBFyil+pRegoKCLnDVNZOTky0DBw4MDw8Pjxw4cGD4zp07LQCvv/5687CwsKiIiIjImJiYCDBqGi699NLOF110UVhoaGj3++67z2o/j71W4qGHHmq7YcMG/65du0bOmTOn9Y4dOyx9+vSJiIyM7BYZGdlt1apVVY5k9vnnnzefMGFCGhhjJowePbpTeHh45KhRozplZ2cXjRVx3XXXte/evXu3Ll26RM2cObMNwOOPP9762LFjnpdcckl4//79wyvaD2D48OEZ69ata5qXl1c6hPMiiUEjUbqffutmHlw+ckK1ZyVszMob6+D6668vk1jZHz0MuuVDCL2h+AR/zITDq9wRuhC1YtiwYac9PT1LVI15enrqyy+//HRFxzgjJyfH1LVr10j7smDBgqKb4/Tp09tPmTLlRHJycsLkyZNPzJgxox3AwoULrd98803yjh07Er766qtd9v23bNni99///nfPtm3btn/66actSlfrz5s3LzUmJiYjKSkp4ZFHHjnWpk2b/HXr1iUnJCQkrlixYs/MmTMrfYSRlJRkCQgIyPfxMRpxPfXUU619fHwKk5OTE2bPnn04ISGhKLF45plnUrdt25aYlJS0/aeffmqyfv16n4cffvhY69at83744Yfk9evXJ1e0Hxh/czp06JD966+/VvpoorokMWhE4uPjadtCMa4PWDxNTLtvYVF5Yxy34FyU7qWwcOHCMolVUXdPq5XOU77jV/ufJF3Iqc8up22Lxt3zQzRc8+bNO1y6Vs1kMjFv3rxD53NeLy+vwqSkpAT78sADDxSdb9OmTX633377SYAZM2ac3Lhxoz9ATExMxnXXXRf69NNPt8zPLx6lODY29kxwcHCBv7+/HjVq1Kk1a9ZUOiVybm6umjJlSmh4eHjkpEmTOu/evdu7sv1TUlI8W7RoUXTBH3/80f+GG244AdC/f/+s8PDwoiGX33rrrRa2mojInTt3em/evLncc1e2X8uWLfNTUlI8K4upuiQxaESsVivP3NmTj++Fr2ZB8NnPisob47gF56K8kSErS6yuGDmOyS94ctA2Uvyyn+Cvs56NuueHaLg6dOiQN3HixL/stQaenp560qRJf7Vv377MDIeu9u677x54/PHHD6WkpFh69uwZdeTIETOUnUmxopkV7ebNmxfUunXrvMTExIStW7cm5OXlVXrf9PX1LSw9C2N510hKSrK88MILQT/88ENycnJywtChQ9Oys7PLnLuq/XJycky+vr41OnujJAaNzKgoYy4PX49cMMukP+eidCJQWWIVHx/PsXQz45+Bic/DGz9AmNUktTOiwXKsNaiJ2oKq9OrV6+xrr73WHGDx4sUtYmJiMgC2b9/uNXTo0LPPPffcoebNm+fv2bPHAvDjjz82PXr0qDkjI0N98cUXzS655JIS06IGBAQUZGRkFM28lJaWZrZarXlms5mXXnopsKCgoNJ4evTokZOamlrUSjk2NjbjnXfeaQHw+++/eycnJ/sCnDp1yuzj41PYokWLgpSUFI81a9YUzRjp5+dXkJaWZqpqP4C9e/d69erVq+pJXqpBxjFoTNIS8DybZLw3+0C7K90bTz1VeqyDqvaNi4tjyZIlbNybS1BzT+65dQzBzeRXTzRM9lqDd999t1Vt1Ba8/PLLB2666abQ559/PjgwMDB/6dKl+wBmzpwZsm/fPi+ttYqNjT0zYMCArA0bNvjGxMRkTJ48ueO+ffu8J0yYcOLiiy/OdDxfv379sjw8PHRERETklClT/rrnnnuOTZgwofPHH3/cPDY2Nt3Hx6fSb+dNmzYtbN++fc62bdu8unfvnnP//fcfu+aaazqGh4dHRkVFZfbo0eMswMCBA7O6d++eGRYWFtW+ffucPn36FCUoN910018jRowIa926dd769euTK9ovJSXFw8vLS3fo0KFGWx/K7Io2jWKWtW2PwxbbN9V2E+Gi/7r0co3iM3WC48yNPj4+7N++hlYBZvDrAme2Q6tBTp9LPtOaJZ9nGTUyu+L+/fs9Y2NjI3766ackdzxGqMiiRYsCN2zY4Ld06dIDrrzO0qVLm23YsMF30aJFLq0tmTNnTuumTZsWzpw585y6Rp7z7IpKqX8rpZoqpTyVUt8ppf5SSl1/LkEIN0tZWfy+3QT3xdHIlG6X0KpjP8g9BauHwHdD4K9f3R2iEDWqQ4cOeSkpKdvqUlJQm2688cbToaGhLh/VrFmzZgV33HFHjU+J7Uwbg8u11meA0cBBIBz4R00HIlwsYw+c2mS8N1mg7Uj3xtPIlGmgmPSc8e9RmAtrr4TMg+4NUIhG4K677jrh6toCu3vvvbfGb9il3X333Sc8PWu0QwLgXGJgv+pIYLnW+mSNRyFcL+Wj4vfBw8CzqftiaYTKNFCMWQQW2+Bq2Udg7XjIz6z4BEK4T2FhYWHlTfdFvWP7Ny23vYQzicH/lFJJQAzwnVKqFVCjLSBFLSjxGOEq98XRyBXNWdGkM0MeOUmevaL15EZYP1WGTRZ10bbjx48HSHLQcBQWFqrjx48HANvK2+5M0+hHgCeAM1rrAqVUJjC2BmMULuA4819wMzj8olFeUAjmtvLP5y5jx45lyZIl5ObmsiYB7loKL99i27j/PWjWA6IedGuMQjjKz8+/9ciRI68dOXKkO9LFvaEoBLbl5+ffWt5GZxKDX7TWve0rWuuzSql1QO9KjhFu5ngDGt+nuHzXmbZEeLd0X2CNXHx8PG+88UbR+ivfQe9OZm4bbOsbvfkhCIiCEBkASdQNffr0OYZ8GWxUKsz+lFLBSqk+gI9SqpdSqrdtGQzU6LjMouY5Dt376R/w5Gfw+x5FcL873BxZ41befAtbLLdC68HFO/18PZze6p4AhRCNXmXVQlcATwEhwDPA07blXkDqOus4xxvQ0TT4cIMH7xy5nYCYf7k7tEav9HwLDz38KMT+F/w6GjvkZ8AP4yDb5Y2ahRCijAoTA631W1rrIcDNWushDstYrfXKio4TdYf9BtTONsXyAw8/6u6QBCXHNTCZTFitVpRPK7rfsZf0LGOfpF0pUJjj3kCFEI2SMw1JPlNKTVFKPaiUmm1fXB6ZOG/2G1DLJorho66USZLqEPu4BhMnTix6rLD9IFz/Mny8UfHZsdFgrnQSNyGEcAlnGh9+AqQBGwH5ClOf5J9lzj0TuHXrJ9w2c567oxEO7OMaHD58mBUrVhSVf7oRViV4s3/bLDi7D8y+4OHjvkCFEI2OMzUGIVrryVrrf2utn7YvLo9MnL9DX9Jqw2V8cp8HwRlfuDsaUY7yGiPGxcXRqtMAY4czCVBYAHkZlZxFCCFqjjOJwc9KqR4uj0TUvEOfG6+ZByDnmHtjERUq3RixaNjk5r2NAY+2PAT/62IMay2EEC7mTGIQC2xUSu1QSm1RSm1VSm1xdWDiPOlCOORQS9BmlPtiEZUqtzGiUiiTiQV/6wsJT0D2UfhhLObCs+4OVwjRwDmTGIwAwoDLgTEYkymNcWVQogac3AjZtloCr1YQ2Ne98YhKldcYEeCTPyDHPtN62na6nZpvJH1CCOEiVSYGWuv9QDtgqO19pjPHCTcrUVswApT8k9Vl9saICxYsKHqsALB+F/x9afHsaS1zfoYt8e4IUQjRSFR5t1BKPQLMAh6wFXkC77gyKFF9RZPz2JbfPn60eKM8Rqg3ymuM6NX1Nuh2f/FO2+fDvuVuilAI0dA58zXySoxxss8CaK0PAU1cGZSovrFjxxbdTFo3hX6djfICrcB6uRsjE9VVbmPE6IVgHVG80/pb4MQGN0UohGjInEkMcrXWGtAASim/6lxAKWVWSm1SSn1mW++olFqvlNqplFqhlLLYyr1s67ts20MdzvGArXyHUuqK6ly/sXC8mYzoWVxe0Lw/WJq5KSpxLhwbI8bFxRkDU5nMcOFyMj3aGTsVZMPa8ZB12L3BCiEaHGcSg/eVUouBZkqp24Bvgf+rxjXuBhId1p8AntVahwGngKm28qnAKa11F+BZ234opSKBa4AoYDjwklLKXI3rNwqOVdAjo4vLLaFXui8occ7sjRGLui4CWALY2mI+eNoSvaxUWHslXULblniMZF9CQkLcE7wQol5zpvHhU8AHwIdABDBba/0fZ06ulAoBRgGv2dYVMNR2PoC3gPG29+Ns69i2X2rbfxzwntY6R2u9F9gF9HPm+o1NfHw8Fk/FFRc4FEr7gnrJ3hgxODi4RPuRHzcfZdjc0xTYOibkHFlPsNehMsdbLBbGjZOpm4UQ1edUU3Wt9Sqt9T+01vdrrVdV4/zPAf8E7P2rAoHTWut82/pBoK3tfVsgxXa9fIxhmAMdy8s5RjiwWq3cFncdy3+Bv7KbgG97CIh0d1jiPDm2HwH4dhvMfAdOZMCM12HX0bLHlBgoSQghqkEZzQfK2aDUj1rrWKVUOrb2BfZNgNZaN630xEqNBkZqrf+mlBoM3A/EAb/YHheglGoHfKG17qGU2g5cobU+aNu2G6NmYK7tmHds5Utsx3xY6nq3A7cDBAUF9Xnvvfeq8zmQkZGBv79/tY6pi/Ly8jiwJ5EOoR3x9lTkm9z3MzWUz9Td8vLy2Lp1K1prQkJCOHjwIKDxMWWQb2qCpwly8qFQK7TWKKVo2bIl7du3d3fodZ78Hy1p8ODByt0xCPercBIlrXWs7fVceyBcCIxVSo0EvIGmGDUIzZRSHrZagRDAXg96EGO8hINKKQ8gADjpUG7neIxjvK8CrwLExMTowYMHVyvYNWvWUN1j6qyTLcAvFLwC3RpGg/pM3eyjjz5iyZIlzJ8/nwcffJCwsDB27txJbm4uF3TwZPyYK3juzVWcycjBx8eHPXv2yGyaTpD/o0KU5cw4Bm87U1aa1voBrXWI1joUo/Hgaq31dcD3wETbbjdhzN4I8KltHdv21bbeEJ8C19h6LXTEGIXxt6qu32jlnjZe3ZwUiJpVugvjsmXLitZ3HvPgzjvvYOFdQ/hjHsy+Y7QkBUKIc+ZMG4MoxxXbt/k+53HNWcC9SqldGG0IltjKlwCBtvJ7gX8BaK23A+8DCcBXwN+11gXncf2GSxfC2f3ujkK4gL3XCUBcXBzR0dElujS2bNGMadG/0CsU/tFvLZw94N6AhRD1VoWJgW3sgHTgAqXUGduSDhyl+Fu+U7TWa7TWo23v92it+2mtu2itJ2mtc2zl2bb1LrbtexyOn6e17qy1jtBaf3lOP2ljsPZK+PUWOPAhZB93dzSihsXHx+Pl5VXUqLBEl0bPJphsT4fNuUdhzSjITXNjtEKI+qrCxEBrvcDWvuBJrXVT29JEax2otX6gouOEm+RnwpFv4NQfkLAA8jPcHZGoYVarle7duxc9JnDs0khAJFz8EZhs8yqkbWPVI83w9JBxDYQQ1ePMOAYPKKWaK6X6KaUuti+1EZyohqPfG6PhATTtBv4d3RuPqH1BQ6D/kqLVYT1g8S3GexnXQAjhLGcaH94KrAW+BubYXh91bViiKqUnTXrp4dHFG9vKoEaNVscbSA8tnnDplsEw+yoZ10AI4TxnGh/eDfQF9muthwC9AHmA7WalB70Z1cthY5uRtR+QqDOaDPw3vxyNKFqfMwGWPNBXeioIIZziTGKQrbXOBmOiI611EsbQyMKNHLuvRbaFDi2N8kJzE2gV68bIhNspRejVX/Pt9uJf78kd1zKhn8ynIISomjOJwUGlVDPgY2CVUuoTyhlgSNQux0mTHGsLTG2uKG6AJhota9sOfH4mjt9tfXtMJpjYv+SgdtLuQAhRHmcaH16ptT6ttX4UiMcYb2B85UeJ2mCvNRjlMM2ytC8Qdv988DH+tqID+b6dyWo1mhe/9UA55AbS7kAIUZ4Kh0R2pJTqDcRizJnwk9Y616VRCadYrVb+dusULgx/3aFwuPsCEnWK1Wrl9637IPcUHh4BjBo9mfyCj1m/Mx+LxUJcXJy0OxBClOFMr4TZGNMhBwItgTeUUg+7OjDhnIen9sXDbFtpEQM+8odelGJpDiYTN9/zDCaTid6hYDabmP3ATHdHJoSog5xpY3At0Fdr/YjW+hFgAHCda8MSzmruB3gGGCtt5DGCqJi1bTtiLr0ZsxnWLgghaMtEGR1RCFGGM48S9mHMjmgbPQcvYLerAhLV1GUaNO8FeWnQVDqLiMo98PCj/Oa/jJhWu+A0sHYcDPkKzN7uDk0IUUc4U2OQA2xXSr2plHoD2AZkKKUWKaUWuTY8UaWcE2DyAOvl4NfB3dGIOs5qtTJu2gvFBcd+4KP7ffAwS/dFIYTBmcTgI+BBjOmS1wAPAV8CG22LcKdMmUVPVFOnm1m5d0DR6pV94c1p4O3lKd0XhRBVP0rQWr9VG4GIc6XBO8jdQYh6ZuAtK3l2VjtmDjdmML8+FvIKCxnx8ENujkwI4W7O1BiIuijrCPx4DRz6EpSl6v2FcGC1Wtnpfxuvri7+ExB3cQHBqQtAazdGJoRwN0kM6qtDX8KBFbAlHn6a7O5oRD0UHz+be9715M21DoXJL8CfsyQ5EKIRqzAxUEq9bXu9u/bCEU479Hnxe5k0SZwDq9XKzTffwm2vKTYc71K8IfFJSHjCfYEJIdyqshqDPkqpDsAtSqnmSqkWjkttBSjKUZALh78pXpdhkMU5io+Pp32HjoRMWg0htoaHns2gtUzEJURjVVnjw1eAr4BOGL0PHGdg0bZy4Q5//QT56cZ7v1Bo2s2t4Yj6y2q1snu3bViSoBXw2zRoNwHMPpCXDp5N3BugEKLWVZgYaK0XAYuUUi9rrWfUYkyiKqmlHiMoVfG+QjghJCSE1NRU29pbRLYFb09IV1aS98hkqkI0Js7MrjhDKRWtlLrDtlxQG4GJYiEhISilipbE754u3ijDIIsaMHbsWCyW4t4tCamQWwBN9GEGhCmuu7DsAEil/1/aFxkkSYj6zZlJlO4ClgGtbcsypdSdrg5MFHP8o92xFXRra5TnFnhA0BA3RiYaCvsU3o62pUBEG/h6Frw9A24dAqmpqUUJQHENQzGLxSKDJAlRzznTXfFWoL/WerbWejbGJEq3uTYs4cjxj/bInsXlha0Hg4ePe4ISDYrVaiUuLq4oAfX09MRsNnH7EAjwBZMJ/u9W+Nuw4mOMfcwlzmM2m4mPj6/N0IUQNcyZxEABBQ7rBZRsiChczPGP9qhexeXeHa90X1CiwXFMQD08PLj++hu45iVPfneYMu3Fm+Ge4Tjsc31RMmGxWIiLiyM4WKb+FqI+cyYxeANYr5R6VCn1KPArsMSlUYky4uPj8fJUxIY7FEo3RVGD7AmoyWQiLi6OBQsWkJZl5rIFsH538XeBZ2+AB8ebi/axJxNSWyBEw+BM48NngDjgJHAKiNNaP+fqwERJVquV62+8hf6PwMf7+kPkLJlNUdS4+Ph4QkNDiY+PL0oUMnJMrDg+ldyAfkX7zZtUwMLr/cokE1JbIET959SQyFrrP7TWi7TWz2utN7k6KFG++Ph4wjq2JXbSXOi50N3hiAbIPq6B/QZvTxT++eBjWK5YzY7TbYr2bbL3Sdj8MPEPP0xoaCgrV66UXgpCNAAyV0I9YrVa+eSTT2jZrlfVOwtRA0okCh5+NB27lrU7HRq8bp+H9eiz7N61iyuvvLJEl0eQXgpC1EeSGNQneWeMV6+W7o1DNFrWkM5c/PDJkuNn5BmjcJbX5VHaHQhR/1SaGCilzEqpb2srGFGJQ1/B/hVQmC8jHQr3MnvDRSshZDyEXg+db4Xso2W6PEovBSHqp0oTA611AZCplAqopXhERTY/CL/dDt9fAX/96u5oRGNntkDs+zDwLfAJhqxUOHugRK2B1BYIUT858yghG9iqlFqilFpkX1wdWGNWeqjZDq0UnLK1+SzIhIBI9wYoBIDJE5QJfEPAtx3kHMfqe5pP5nSlVVMltQVC1FPOJAafA/HAWoxZFu2LcJHS49aP7e2wMehS8Gxa+0EJURnv1sZMn5v+weUhf/LLXA9++/6/0ktBiHrImXEM3gLeB37VWr9lX1wfWuNVuhHX+D4OG0PG135AQjjjzA449AUAnVvl8c0/MokOLTmBq/RSEKLuc2YSpTHAn8BXtvWeSqlPXR1YY+bYiKu5H1zSzWFj2zFui0uISrUaBLErwGTUdjX3Osv3D+YzyGG0Tml3IETd58yjhEeBfsBpAK31n0BHF8YkKK41GNkTPOzz1AT2B982lR4nhFu1nwSDvwSPJgA094NvH4BRvaSXghD1hTOJQb7WOq1UmXZFMKKYvdbgyhiHQnmMIOqD4KFw2Rrwag2AjwU+ngk3XpjLSy+9JG0OhKjjnEkMtimlpgBmpVSYUuo/wM8ujksA8Q/+g+HRDmMWhMizWVFPtOgNl/8E/p0Ao9br/26FZ24wYXL4Ly1tDoSoe5xJDO4EooAcYDlwBrjHlUEJg1Ul4Odlq5xpEg5Nu7o3ICGqo0kXGPYTef49iopmDi9k3tXFu0ibAyHqHmd6JWRqrR8CLgWGaK0f0lpnuz40wcGPi9+HjJMRD0X94xOM58hfih6Dncn14cstRk8FaXMgRN3kUdUOSqm+wOtAE9t6GnCL1lrGMnC1qIfAMwBOrIeQK90djRDnxsMPLvoQtswm17MXeYVT6BUKSUeltkCIusiZRwlLgL9prUO11qHA34E3XBqVMHg2hdBrYdg6aDXQ3dEIce6UCaIfp2XkBPpediNmk2L2HaPo17cPoa1kECQh6hJnEoN0rfU6+4rW+kcg3XUhiSJn97o7AiFq3L8emkuaKZRbb72Vf9/WiZ3PwL/GFm+XBolCuFeFjxKUUvaBeH9TSi3GaHiogcnAGteHJgBjmFkhGhCr1Uryzj2QlsDVEX9gKoAFk6FbG5i2BJQ0SBTCrSprY/B0qfVHHN7LOAaudHo7ZB0CS3PwCnR3NEK4hncQpsC+cOwHAG68CHq0V3x0fII0SBTCjSpMDLTWQ2ozEOFg+3zY/65RW9D//yD4MndHJETN8wqEId+QufZmfA8vB6BXB01058/g0JfQZoSbAxSicXJmroRmSqm7lFLPyLTLtSAvo7ib4tl94NXSreEI4VJmC76Dl7F818Xk5htFpvzTFK4eySMTFCaTNEYUorY50/jwCyAU2IpMu+x6qZ9CQabxPiASmkW7Nx4hXE0pBt/2HtcsacOJbF8ATCaYMwH+dx8ENfeUxohC1KIqxzEAvLXW97o8EmHYt6z4fYcpMqiRaBSsVisrf0jl6P6trHmtJ4O7FQLG5Eur/pVPqxsedHOEQjQeztQYvK2Uuk0pZVVKtbAvLo+sEQkJCUEpRaumivyUL4rKB177HzdGJUTtC+rQgw9O3MZTXxT/adqd34/goCA3RiVE4+JMYpALPAn8QvFjhA2uDKqxGTt2LBaLhUn9i6dY/mWXovfFE9wbmBBu8FD8I8R/aOGqZ+GJz8zETpwDpzdD7ml3hyZEo+BMYnAv0MU28mFH29LJ1YE1JvHx8ZhMJqYMKi57f72H9OUWjZJ9yvFP/jBxoPk0WoZfAWY/yNgNZ5Lh5EY49ae7wxSiwXImMdgOZLo6kMbMarVy3/QJxEYY6/kFYOlyvfTlFo1WfHw8oaGhxclxQFfw6whZh+GHsfB1f9jxH9AypIoQNc2ZxKAA+FMptbg63RWVUu2UUt8rpRKVUtuVUnfbylsopVYppXbaXpvbypXt3LuUUlscRl5EKXWTbf+dSqmbzvWHrctmXd226P13CSZmPjDfjdEI4V5Wq5Xdu3eXTI69WsCe143BvwpzYeNd8MMYyDrivkCFaICcSQw+BuYBP1O97or5wH1a627AAODvSqlI4F/Ad1rrMOA72zrACCDMttwOvAxGIoEx6mJ/oB/wiD2ZaDC0psmx94tWD1mGSm2BEOWJehCa9yxeP/Q5fN4dDnzgvpiEaGCqTAy01m+Vtzhx3GGt9R+29+lAItAWGAfYj38LGG97Pw5Yqg2/As2UUlbgCmCV1vqk1voUsAoYXs2fs25TCi58n8zgq0k+5smIaa+5OyIh6qamEXD5rxBxT3FZ7gn4cRL8fD3knnJfbEI0EEpX8YxOKbWXcuZGqE4DRKVUKLAW6A4c0Fo3c9h2SmvdXCn1GbDQNnsjSqnvgFnAYIyxFB63lccDWVrrp0pd43aMmgaCgoL6vPfee86GB0BGRgb+/v7VOuZcbdmyhby8vBJlvhYwe3gQ3vWCBjN2QW1+po2FfKbFmuX8QdfTT+BdcKyoLMcUyM6AO/nL+2Knfo/k8yxp8ODBDeOPjzgvzgxwFOPw3huYBDg9joFSyh/4ELhHa31GVfzLWt4GXUl5yQKtXwVeBYiJidGDBw92NkQA1qxZQ3WPOVfvv/8+S5YsITc3FwBvT4gO9aD/5WAVxlQAACAASURBVFO5fcbdtRJDbajNz7SxkM/U0WDInQob74a9RiWkV+EJup96FDreBAPfrPIM8nkKUZYzjxJOOCypWuvngKHOnFwp5YmRFCzTWq+0FR+1PSLA9mpP9w8C7RwODwEOVVJeb9m7J9p1bQNms5kHHn7UfUEJUR9ZAowE4KKPwNuhXY5vWygscFtYQtRnzkyi1NthiVFKTQeaOHGcApYAiVrrZxw2fQrYexbcBHziUH6jrXfCACBNa30Y+Bq4XCnV3Nbo8HJbWb1l76fdvIkncydC+1ZmLrz8OmlwKMS5ajceRidCl9uhVSyEjIfTf0Jmvf4OIYRbOPMo4WmH9/nAPuBqJ467ELgB2KqUso9G8iCwEHhfKTUVOIDxaAKMyZpGArswxk2IA9Ban1RKPQb8bttvrtb6pBPXr9Pi4+Mx7fk/4q+EgsICsts700FECFEhSzPotxgKcsFsgYy9kH3YthyHPW9AryfBr727IxWiTqsyMdBaDzmXE9saEVbUoODScvbXwN8rONfrwOvnEkddZQ0O5oEJTYGTmE3g1zrK3SEJ0TCYLcarf0cobAenNhntENKTjdlLw++CyH+CV6B74xSijqoyMVBKeQETMKZeLtpfaz3XdWE1Asd/pK2fUfFRaPLB1Olm98YjRENk8oC8NCMpACjIhsR/w65XoOv9mAv7uDc+IeogZ+qvP8EYYyAfOOuwiPORXDxzoqnTDUY1qBCi5gVfBpetgxYOSUDeGdg6m/7HpsD2BTJBkxAOnGljEKK1blgDCtWikJAQUlNTS5R1awvbFkJRx4Swv9V+YEI0Jq1j4YrfIWUlbHkYziQBYClMg80PGslB2DRj4CTftlWcTIiGzZkag5+VUj1cHkkDZZ9S2dHsq0zFSUGbUdA8uvYDE6KxUQraT4CRW2HAm+DXoXhbfjokPgUJT7gtPCHqCmcSg1hgo1Jqh21yo61KqS2uDqyhKG/Mgqv7FRbv0OMRN0QlRCNm8oBON8HoZBKbzYKASKNcmcF6hTGtc25a8f75We6JUwg3ceZRwgiXR9GA2ccssI90aNQW2BKDNiMhsK97AxSisTJbOOo7nG6XzIfUzyFtO7S+2GiomLHL2CcvHdaMMn5XQ681Xs3e7o1bCBdzprvi/toIpCGLj4/njTfeIMIKk/s71BZ0l9oCIdxOmSBkjLGA0UhRF8LZfbDjP1CQCSkfGItnU2PwpLZjwHq5sS5EAyOj6tQCe61BU1/F0WzbjNHW4dCyn3sDE0KUT5nAvxNklRo5Me8M7F1qzOb4YUv47lJIfAZO/lE/h2DOz4Rja42aESFsnHmUIGpAfHw8Q7/7Es+LXgafDGjSxd0hCSGqMvQbSEuAfcth/7uQsad4W2EeHF1tLAAxL0B4uWO01Q35mXB6izHg06k/jWTm1J+g843YWw4o2aVTNFqSGNQSq9VK4i8fGCstpPenEPVGQCREPwYXzIUTv0Pq/+DQ58YN1pFXoNFwUXmCdyv+v707j4+qPBc4/ntmMtnYCQghIQkCisoOUq224oIbii23dSlWwK0i7rWLVW57rVjburSlIqKgKFGvRUu5lqpXe0FtFVG0LgVElCD7EkCQNclz/3jPJJPJhCzMcDIzz/fzeT8zec8szxyGM895z7sQ6ggvDYFWPaD9cdC6lzshaNMLcrq5VolEWvtX2PAKfLncDc/8ahUxFqZ1yt91HS+NwRKDuIs1bwFAz+JufLpkHrQ5yoeojDGHTMRd/us0zCUKu9fBuvmw8VXY/qEberx3ExzY7i5BbH3bdWjc8TGseyHqtTIguwvkdHWrQrbuAUOn1H7Mrs9g/f+690Wgar8766/c48r+7bBviyt5Q906EFUVUPEVVOyCVU+5Vo6GtD3GJT/Wimk8lhjE2ahRo6pHIID7Pz32m0GOGXaCe0CowYUpjTHJILcb9LrSlbDI/9+7Pq//uVoBe9a6ApB1BISnRZega3XY8DIsuaVxsVR85c76a8UXNVGTBNyJSYdBXhkIHQfbmhGmDksM4iw8AiFs7Dfgsasrqch+B/Zt9TEyY8xhVfgtOPcj2P4v2LkCdn7qyq4VdY8FGa0hkOn6LWilK5V7G/9elbvdmX8wx2thwL1eqB207eNKm14QzIrf5zMpyxKDOIuctyAnYz+/vsTVZ+xdDZsWuiFOKaa0tJTbb7+d1atXU1RUxLnnnsv8+fO5/vrrGTduHJMnT2bMmDH1Pn7y5MkA1XVHFxYy5sQTeee119i8YQNdu3Th6yeeyJtvvsm6jRtpl5/PhFtuYdRFF0Hr1tChg18f3Zj6BTJc34L2MVZOrdwLezfCnvWwZ4Orax81wWx4yKRWuRLMcj/8wVzIyIGMtq4vQ1YeZOdDRm7t57fvV/c1jWkEcasdp5ahQ4fqO++806TnLFiwgOHDh8fl/devX8+RRx7Jry/cyw3h/jy5hXDeMshoFZf38EusJGDWrFns3r27zmPvvfdebr31VkKhEB3atKFteTmD2rSh2+7dlFRWUgxUAZeEQogIFfv3EwLOwq3c1RhbgSFFRZw7ciTz589n9erVnJKfz7TjjuPo006D7t2hsNDdFhRAVnKfMcXze2psf8Ygfgdg/GctBgmQn5/PHRNHMXHgszWVg+9PyqQgMhHo2LEjO3furO4/UVZWxrRp04hOLgPAAKDfW2/xEDD4wAH6l5eTDbCz9njpvUC/Awdq1XVsQnxfAXmrV7PooYfIA/KAIevWcfS6dfC//1vn8ZsDAVZWVbG2VSt6jhzJwHHj4Byb3NMYY8IsMUgEVW49tYxgeLr1LqdD9+/4GlJzlJaWcvXVV1e3BmzdWrePRKwWp6HAIoA5cxp8j2xgo1cqvLrdwMfebThlUK+EgJyIsgJYAmRFlNYHeb/OVVV0BvjqK3j2Wd5/7jnOqKykXVERd959t7vksXgxLFsGAwdCnz4QCjX4OYwxJlVYYpAIK6aStWORuy8ZMPQPNR2CWrjIFoJAIEBlZezZ3AK41bW+BUzy/i4AcnE/4Luo+wO9FvdD/qlXPgM2AJuoSQoAlgF9mxj3Pq8A/Bn4Eij0SnfvthsQjHreKu+SBqtX84dx45g5cSLf37GDceEHZGZC374wYIBLFAYOdPfbtWtihMYYkxwsMThE0fMWHFMA794FOeGVlvvcXLN6WwsX3UIQKykYClwOfAfcmTfux/0V7/4uYB3w38DJ/fvz2Acf8C7wHq4/QCyhUIhMkepLFIfqA69ECwL5QC/gaKAP8AauxUGAthUVtN+xg+LIJ+3fD0uWuBKpZ08YNgzGjoWzbGIYY0zqsLUSDtGoUaPIzHRZQGYGPDUxIilo39/NltaClZaWUlJSQiAQYOzYsTE7EXYCbsL92C4GJlCTFABc3KMHW4uKeE+EfcXFfH/CBH5ZXMwLl13Go3l5vJaZWSspCIVC5OXlISIUFxfz2GOPMXPmTIqLi6vrJkyYUO/feXl51fu8PhKjhaYSWAMsAB4Gbgae87YpsAMoA+YAc4FVB3uDlSvh6af52223cXz37oREKCkp4dprr+WSLl3oK8KRxcWUlpYeNE5jjGlxVDXlypAhQ7Sp/u///q/Jz1FVXbdunWZnZyug145AtdSVqqezVLd91KzXPFxmz56tubm54cv3dcqxoI+C7gXVGGVDMKjLTz9dtZ59F96ns2fP1uLiYhURLS4u1tmzZ8cl9sjXnDBhQp2/D/bZGlvag54CeiPoTNAloPsi9sGloIOjynpv2w7QBYGAfnTeearPP6+6fv0hf+7mfk9NbLY/6/D9+G3F/+J7AIkohzMxUFWdMGGCZmZmauts9MHxAa14UlSX/aHZr5co0T+meXl59f4gjqknGTiQmak6bpzqwoWqlZUHfT+/D7oHSx7y8vI0MzOzWclCJuhQ0ImgIa8uANoZ9NR69lu4lGVk6GcnnaQ6darq+++rVlQ06TP5vU9Tje3POnw/flvxv/geQCLK4U4MXKtBlg4uQU88Oks3fbpQtaqq2a+XCA21DkSfJZ8GuifyR+3441UffVT1yy8b/Z4t/aAbmTjEShREpMlJQ2/QuRGtBgcrlaB9CwvrtHYcrEWlpe/TZGP7sw7fj99W/C/WxyAO8vPzmXTdKAIBYdDpl9O55zdbxCiExvQfADgF12O/HTAY6B0IsA14rnVrVh9/PPzjH7BoEVxxBbRJnbUexowZw6pVq6iqqmLLli11+jlcc8015ObmNvxCEVbgRmrkA0W4Tpq/AV4D9kQ9diWQuWYNix56iI5lZeSr0rOsjL6XXsqM7GwuFeHkwkJKZ88+9A9rjDGN5Xdmkohy2FoMqqpUP52pun2Zblr+ovbtU6Lr43AdOR4a00JwDOh87+z1We/6+AnZ2Vr6+OPuRRq4VNCQVDgba6hVoSklBHo86E3e/v4laDZocUT/hKkxWhbWiei7Rx6pd3booLNvuEF7FRU1qZXB1C8VvqNx5vvx24r/xfcAElEOW2Lw7/tcZ8O/9lfd9nHTn59AxcXF9f5A5YH+EfRAxI/PftBvdOsW1x+YVDzoNqbTY2P7ccQqf2vEJYjdoAtAL4lMOkIhzcvLs0ShiVLxO3qIfD9+W/G/+B5AIkoiE4OCggIF9LxBaOWTVI9CeOjq1k1+z3iL/NGK9aMTAL0BdFv0j00goDp+vOratXGNxw66TevbAWgb0DNAfw76Em5kQ30Jwn2gBdR0gAT0G6B9QFvl5Fhy0Aj2Ha3D9+O3Ff+LTXDURKNGjWLxy4/w1MQKAl4PjX98IiwNjTn4ExMsenKiaP2AR4Fh0RtOPx3uvx/6909whOkpvKpkfetNRNuJmywqPGFUADcL5NeBk4DzOnakfXk5AP8Cungl7EmgGNi2Zw//uvJKN9/CCSfA175mszUaYxrH78wkESWRLQabPnlVN02juqVg5QNo987ZvvQtiGwhCAaDMc9As7xr2fujzziPOkp13ryEjp6ws7HYmjqMMrIF6N5779V80NERLQWCGyp5ykFaF6pEVI87TvXKK1VnzFD9978PuQ9JKrDvaB2+H7+t+F9sVEJTbP+Qzh9cRGevY/6O3TD69xmc/93L6dq162ENJdxCUFZWhqrWu6bBJcAduMWHADf3/y9/CR9+COef3yJGT6SbyNEQq1atYurUqU0aHbEeeJ7aC0xtxq1F8Rfc2hPRRBU+/hgefdSNLjn2WH541VXVo1ZKSkpslkZjDGBTIjfe9g/h1dNg3xbAJQVn3gOfbAwxadKkwx7O7bffXu9lg7D2wNYuXWouE5x8MvzrX3DHHS5BMC1SrMRh+vTpFBcXA9Q7RfSnuKGSXYCewKXAg7i1ICqi3uNzYMHMmeSVldFXlb1lZTxx+eVsLyyEK6+Ehx9260NELYltjEl9lhg0RlRSQKgtD38ymnc+DzB+/PjD0loQOSdBSUkJZWVlMR/XCrcg0GDg2OxsrrrlFnjqKZg6FRYudMsIm6QTThaGDBnSYCsDuJUrS4HrgCG4OSqGA7cB83AtDitw60OEcCtjnrd/P+3XroUZM+Caa2DIEPZmZfGmCI+1bcs/J0yA5cuhquqwf35jzGHk97WMRJR49jEoKCjQJydQ3adg+yPosJ5o165d9cgjjzwsfQti9WyPHnnQBfS/cXP5Hw86smtXffrRRxMe28HY9dv4a8w+PdhQ1YOVuY0YKqmg20Hva9dOZ8+enZB1MA4n+47W4fvx24r/xVoMGjD6gnOZ+VqQT9bXXD54/4tMRo8ezcqVKxPWWtDQrIWqWn12OB5YClwIDALe/tnPeGH9ei6+4oqExGZatsmTJ9eZsTHWapPRvoebBfNHwLPUv7pkOyCwYwd/GDeOn48fz0avn8slZWWsHzeO12+4AT791FoWjElSNlzxYPZvY9KN/8EFr85ixD2VdGwF75dBTk4wof0Kooce1texsIcqT2Rnc9LevbU37NiRsNhMyxc9RLKoqIhzzz2XWbNmHbRfym7c1M2vRdR1BoYCx+OGuh4PHAG8BVRUVNAOlyiAW467qKICpkyBKVPYKcLuo4+my1lnwaBBMHiwu5QVCmGMabksMYi2ey2sfQG6nQP7NtM5vycDT7uCd2fMYPWW/WRmZia8X0FDHQuDwM3AnSLkRCYFRx7pOo2dcUbCYjPJYcyYMdUJQthJJ51UJ1mYP38+q1evJhAIxExANwN/80pYEbAR2BdRF14bIlIbVdosWwbLllXXVYZCBAcMgCeftP4uxrRQdikh0uo5ML8fLL4GPn0EcgqhTS8mTZpEwJvNKBhMbGsBwOrVq+vdNhBYBPwWyFF1lYEA3HqrG4JoSYGpx8GGSc6aNavRC0atpnZSALAddynrHuAlXEIRS/DAAXjnHVi3DpYuhU2boKICysvh7LPhRz+CJ56A996D6JYwY8xhYS0GAPt30Gfbr+CNl6ur9r1/F71Ou4s15VBQUMD48eN5+OGHD8sohKKiopijDu4S4ScaNV3lgAGuF/mQIQmNyaS2+i4/hFsUYs3YGAqFEBH279/PHuBPXgkrwPV5GezdDsLNyvgFMPL00ynq2pWJEycCsPCBB7invBxeeqn6+RXA56EQmYMHU3zeedC3r2tl6NnTLkcYk0h+935MRGn0qISqKtUv5qrOLa4edaClaNnv0VOOcT21MzMz9dprr9V169YldBRCQ6v45ebk6PLTTtPq3uFZWaq/+pXq/v0JiScerMd3/Pm5T2ONQGjM7JuRpSNo/6jFn7JCIf1RI0dEKKj261c3uPJy1a1bm/yZ7Dtah+/Hbyv+l/RtMdixDN69ETa8XKv66TcDTJhZxQ7vEn/40kHXrl1ZuXJlQkKJ7my4detWQqEQeXl5lJeX07+ggF/94AccNXy4G0feqxc88gj07p2QeIyJJVa/hXA9NLxeB0C5V8IOeBMozcbNvdAft65HP+BI6rnW2akTvPuuuy8C7dvDrFlw553QubNrVejTB44+2v0f6dHDldatm/qRjUlL6ZcY7CuHj++G5b8HrZkP7oC0JfT16bz+xkL2VMwAEtvRsLS0tLrZNrrjVwnw8wMHeC4U4n8WL3aVrVq5A92bb0JhoU1lbFqcpi4YFWk98JxXwnKB43BJQn/gxjPPdB0Zhw2DoiLYtg127nS3773nnrR5syuvv173TTp3dh10r7kGxo2rve3AAbs8YYwn/RKDzx6HZfdV/1lZBdNeBfr9kOtKLq710ER1NKxvOGI+cDtwFZAJFG/Y4J7Qty9kZbn73bvHPR5j4iW6VeFgCXBDdgOLvVJcXMyN4f4Hqi4x7ty55sHt20N29sE7LIaThhNPdC0Obdq4hODLL+Hb33ZTQBcW1pSCAnebnw9HHFFTcnKatE+MSTbpkxhoFXy5HPKGQWYH2L+NFTvy+d59m3lnZQX33tsKgMzMTHr37s3SpUvj1loQeXAsKipi165dtZpbjwFuAr4PRB5yTgXIza1JCoxJMpGJQqxLDZEdGOuTm5vL5MmTaypitZY98QQ8/jisXu0ut4WHSX72mStlZTXrPvTs6W537nR1K1a45am3b3flo48O/qFeeAFGjqxd94tfuP+n7dtDhw51b9u0cYmLtfSZJJC6icGmN2DFVOgxFlp1h8o9rr5Nbxj8Owhm0Tr0DT66pSeRS8wEg0FKS0sZPXp0s1sLIhOB6ObU8GgDAUbg5iM4O8Zr/CMQYPfPfsaIY45pVgzGtDSxRj6Ef/DrGw0Rfkysvg11BAJQUuLKWWfV3lZZCWvXwuefw3HHuX4KAAsWuBE9O3c2/oNs2VLTxwFcC8Zdd7n3aCi+Vq3cKpeRLX87drhLG1lZrmRmxr4NBt3ljltuqf26GzbA88/XfM6Kirq34fsdO7qhzZFeew0efNC1tvzlL43fDyZlpWZisOPf8Mo33P0962DwfZDbncJeg1m7dm29Twv3KRgwYECzOxrG6kgY7ce4WeJKYjx/MfDHI47gzPvuY8yllzYrBmNaqoY6MCZMMOj6JRRFT8Pk2bzZ/eCvWVO3bNrkysaN7vaEE9wlhb17Xdm6teGkANwU0Tt3wiefuNcJW78e5s5t3OfIzIQRI1ySEfbee+AN+2xQ9+5w6qm1615/HZ59tnHPN2khNRODcOsAwKbXIacAso9g1KhRzJgxo85Y7CpvTvfm9iloynXUbOAkaicFVcALwSDZt93GmXfeySxrbjTm8AoEavoQDB5c/+PUm1Qs8v/oEUfAr37lLkNs2+ZK+H74dtcu2OdNCzVggEtUwmfy27c3Pk4RiL7s0pSJoCor3XsHAq4Eg9CuXcPPM2klNRMDgGAulIyBo66FHNdPYNKkSTz22GO1HpaRkcGFF14I0Kw+BbE6EgZwk7mMBFoDk3ATu4QHS80HRgHbAwGeqKpiTrdu/OA3v2FUos+ajDGHJlbS3qoV/PSnDT+3ogK++gratq39Orm58NxzLnHYvz/27b59rsUhGKw7mVnbtm6khSpkZLgSDNa+Dd/v0AEGDqz9/DZtXEdO68tkwvyeSCERZUjfItV92zSWCRMmVE8eFDl50ZQpUxo9eVH0pC4CeizotaDPgW6NmIxlD+jXQQeD9gLNAG2Vk6MLbr5Zde/eRr1fsrLJY+LP9ml82f6sw/fjtxX/S2qulZDVGTLbx9wUa92D/Px8+vbtW29rQeQSyJ06deLy8eM5tqyMX6gyv7KSbcDHwIPAaKBjxHOzgfxAgLK8PFaKUFBczMOPPMIp999vGboxxpgWJzUTg4PIz89n/PjxBAKBmJcOwklAUIQTCwv53QUXcNeVV1LmrTm/detWAgcOMB34T+BMapadjbQeN5vbxE6d+O60aWzZsqV68ZqEd7Qyxhhjmil1+xjUo7S0lHnz5lFVVcXrf/4zk7dsYfmCBXz/5JN58Jxz6L5vH39VpSeQvXYtrF3LXmovDgOwEiiM+Hsj8E/gVeDN7GxueeQRLr30UmxcgTHGmGSSmonB7t3wyituKdfycjdEZ+TIWh0FHwBuWr++ZpjO888zop6X640bOVAObAW+AmYB7wNvAm8BawIBqlSbNu7aGGOMaWGSJjEQkbOB3wNB4FFVvafeBy9d6sb6hp18MnTtytO33kofb/RAsBHvuRlYAbyNSwIiRY5tyM3NZdb06ZYMGGOMSXpJkRiISBDXt28EsAZYLCLzVPXfjXqBzZshM5PlGzbwFbAH90O/HdcXYB3QdcgQnn73XT7FJQMrgR01718zfhk390Hbtm0pLy+3FgJjjDEpJSkSA2AY8KmqfgYgIs8AFwCxE4OcHDc7WceOrvToAf36caC4mPXelMQzvRJ27yWXMDlymlNPbm4uY8eObd4UrcYYY0ySEY04E26pROQ7wNmqeqX39/eBr6nqdRGPuRq4GqBLly5DnnnmmTqvU15eTllZWfVMh5EKCwtZs2YNIkIwGKSiooLMzEwKCgro2LFjncebhu3atYvWrVs3/EDTaLZP48v2Z23Dhw+3aVdN0rQYxPqy1spoVHU6MB1g6NChOnz48JgvFL3SYXjBluuvv54pU6ZYa0AcLViwgPr+HUzz2D6NL9ufxtSVLInBGiBiOTIKcV0Dmqy+RVwWLFjAqlWrmhWcMcYYkyqSZYKjxUBvEekhIpnAxcA8n2MyxhhjUk5StBioaoWIXAe8hBtpOFNVP/Y5LGOMMSblJEViAKCq83ELExpjjDEmQZLlUoIxxhhjDgNLDIwxxhhTzRIDY4wxxlSzxMAYY4wx1ZJi5sOmEpHNQFkTn9YJ2JKAcNKZ7dP4s30aX7Y/a9uiqmf7HYTxV0omBs0hIu+o6lC/40gltk/jz/ZpfNn+NKYuu5RgjDHGmGqWGBhjjDGmmiUGNab7HUAKsn0af7ZP48v2pzFRrI+BMcYYY6pZi4ExxhhjqlliYIwxxphqlhgYY4wxppolBsa0cCLSUUQ6+B2HMSY9pH1iYAfdQyci7UTkHhFZJiJbvbLUq2vvd3zJSESKROQZbxbPRcBiEdnk1ZX4G50xJpWlZWJgB924exbYBgxX1TxVzQNO9er+5Gtkyeu/gT8DXVW1t6r2AvKBucAzvkaW5ESki4gMFpFBItLF73iMaWnScriiiLwJ/A6Yo6qVXl0Q+C5wk6qe4Gd8yUZElqvq0U3dZuonIitUtXdTt5n6ichAYBrQDljrVRcC24FrVXWJX7EZ05Kka2JgB904EpGXgVeAWaq60avrAowDRqjqGT6Gl5RE5BmgHJgFfOFVdwfGAp1U9UK/YktWIvI+8ANVXRRVfwLwsKoO8CcyY1qWdE0M7KAbR14fjZ8CFwBHeNUbgXnAr1W13K/YkpWIZAJX4PZpASC47+r/ADNUdZ+P4SWlBk4IPvUu1xiT9tI1MbCDrjFpRkT+APQEnqD2CcFlwOeqep1fsRnTkqRlYmDiT0T64JKst1T1q4j6s1X1Rf8iS14ichbuGvgrqloWUX+5qs70L7LkJSLnUPuEYA0wT1Xn+xqYMS1I2iYGdtCNHxG5AZgILAUGAjeq6l+8bUtUdbCf8SUjEbkbOBlYApwP/E5Vp3jbbJ8aYxImXYcr3g3cDvQD/i4i10dstubEprsKGKKq3wKGA5NE5EZvm/gWVXI7HzhNVW8ChgDniMgD3jbbp80gIkER+YGI/FJEvh617Q6/4jKmpUnLxAA76MZbUFV3AajqKlxycI6I3I/tz+bKUNUKAFXdjvvOthWRPwGZvkaWvB4GTgG2AlO872fYaH9CMqblSdfEwA668bXBGyMOgJcknAd0wrXKmKZbKSKnhP9Q1UpVvQJYDhzjX1hJbZiqfk9Vfwd8DWgtIs+LSBaWwBpTLV0TAzvoxtdlwIbIClWtUNXLgG/6E1LS+y7wdnSlqt6B60lvmq466fe+n1cD7wN/B1r7FpUxLUxadj4UkRwAVd0TY1uBqq6t+yxzMCIiwDBcb28F1gFvazp+weJERNoBZ1N7n77ktXKZJhKR2cDsDFojpQAACe5JREFU6FEyInIl8JCqhvyJzJiWJS0TA7CDbjyJyJnAVGAFtaea7YWbavZlv2JLViJyGfBz4GVq79MRwH+p6hN+xWaMSW1pmRjYQTe+RGQpcI7X8TCyvgcwX1Xt8kwTichy4GvRiao3y+QiVT3Kn8iSmzffRngeg/AJwTxVXeprYMa0IBl+B+CT23HD62IedHEzo5nGy8BNFBNtLWDNs80juB+uaFVYR7lmEZGfAJfgVqcM998oBJ4WkWdU9R7fgjOmBUnXxMAOuvE1E7d09TPUnmr2YmCGb1Elt8nAEm+BqvA+LcK1av3St6iS2xXAcap6ILLSG7b4MWCJgTGk76WEscB/4i4l1DnoqurjPoWWtETkWGAUdaea/bevgSUxrwXrLGrv05dUdZuvgSUpEVkGnBU506lXXwy8bMuDG+OkZWIAdtA1Jt2IyNnAH3GdZCNPCHoB19maHsY4aZsYmPgRkbbAbbjrtfNV9emIbVNV9VrfgktSItId+C0ucf0b8NtwE7iIzPWmnzZNJCIBaobVhk8IFqtqpa+BGdOCpOUERyLSXUSeEZHXReRnIhKK2DbXz9iS1GO4g+xzwCUi8pw3mxzACf6FldRmAguA64F8YKGI5Hnbiv0KKtmpapWqvqWqz6nqHO++JQXGREjLxAA76MZbT1X9qarOVdVRuBUB/x6xT03TdVbVaar6vqpej5sn4jUR6UnsjrOmASLSX0TeEpEvRGS6dzkxvK3OLJPGpKt0HZXQWVWnefevF5FLcQfdUdhBtzmyRCSgqlUAqjpZRNYAr2FTzTZXSESyVXUvgKrOFpENwEtAK39DS1pTgV8AbwFXAm+IyChVXYkNqzWmWrq2GIREJDv8h6rOBm7EHXTzfYsqef0PcFpkharOAn4I7PclouT3KG6hn2qq+gpuDYWPfIko+bVW1RdVdbuq3otbYv1FETkBOyEwplpadj4UkZuBJaq6MKp+EPAbVR3hT2TGmEQRkX8B31TVHRF1/XF9Yzqqql36MoY0TQxM4onIC6p6nt9xpBIRWaKqg/2OI1mJyPeAz1T1raj6ImCSql7lT2TGtCyWGHjsoBtfIvKeqg7yO45UYvs0/kSkq6puaPiRxqSPdO1jEItNhRxf7/kdQAr6q98BpKD5fgdgTEtjiUENO+jG1x/9DiAF2ZC6+LMTAmOipOtwxVju9zuAZCUi0ZdgBPiLiJyPu1y1xIewkpqIjI6uAh4UkQwAVX3+8EeVkh7xOwBjWpq07GMgIifhhoNVAZcDdwE9cWOZL1TVN30ML+mISBVubPi+iOoTvDpV1dNiPtHUS0QqgBeBTdSc1X4HmIPbp5f7FVsqEZGOqlrudxzGtCTpmhi8jVuCtTVuDP63VPUN78x3iqqe5GuASUZEvoObRfLXqjrfq/tcVXv4G1nyEpHjccsAzwGmqaraPj00InKHqt7l3T8WmIs7GRDgIlVd5Gd8xrQU6drHIKSqH3otA5tV9Q0Ar8k7x9/Qko+qzgFGAiNE5E/e8K/0yzjjSFUX45YBz8RNLz0M26eHKvLyzG+BG71E60LgAX9CMqblSdc+BpEJ0W1R2zIPZyCpQlV3ATd7k0TNAtr4HFLS86aY/r2IzMF+uOKtm6r+DUBV3xYROyEwxpOulxJGAa+o6u6o+p7Af6jqb/yJLDWIiABtVPVLv2MxJkxEtuPW7xBcH5ji8DFARD5S1b5+xmdMS5GWiYGJL6+n/BXAt4FuuCbvdcBfgBmqesDH8JKSiLTDtWZ9C+jsVW/C7dN7VHW7X7ElKxE5JapqiaruFJEuwHdU9UE/4jKmpUnLxMAOuvElIk8D23GXENZ41YXAWNwc9Bf5FVuyEpGXgL8Ds8Iz84lIV9w+PcPW8zDGJEq6JgZ20I0jEVmuqkfXs+0TVT3qcMeU7BrYp/VuM/WzEwJjGiddRyWUqOqvI+dIV9UNqvproMjHuJLVNhH5rohUf59EJCAiFwHbfIwrmZWJyI+9Zm4ARKSLiPwE+MLHuJLZs7jv43BVzfNWUzzVq/uTr5EZ04Kka2JgB934uhg3+c5GEflERD4BNuKGh13sa2TJ6yIgD1goIuUiUg4sADrihteZprMTAmMaIV0vJXQAfgpcABzhVW8E5uEm6bGZ0JpJRPJw36stfsdiTCQReRl4BXcJcaNX1wUYB4xQ1TN8DM+YFiMtEwOTeCIyXVWv9juOVCIiL6jqeX7HkazshMCYxrHEwGMH3fgSkSWqGr24kjkEIvKeqg7yOw5jTGpL1z4GsRT4HUCK2eR3ACnoPb8DSDUi8oLfMRjT0lhiUMMOunGkqmf7HUOqsRUVE8JOCIyJYolBjR/5HUCyEpH+EfdDInKHiMwTkbtFJNfP2JKViJwdcb+diMwQkQ9E5KnI0TTmkNkJgTFR0jIxEJF7RKSTd3+oiHwGvCUiZTGmTTUNezzi/j1AL+A+3EqV0/wIKAXcHXH/PmA9cD6wGHjYl4hSkLXCGFNXWiYGwMiI4XS/xa3F3hu3zO19/oWVtCTi/unAVaq6ELgFGOhPSCllqKreoaplqvoAUOJ3QMnIWmGMaZx0XXY5JCIZqloB5KjqYgBV/UREsnyOLRm1E5Fv4xLNrPCiSaqqImLDXprnCBG5BZd0tRUR0ZohROma0B+qu4EXvfuRrTCjca0w3/IpLmNalHRNDB4E5ovIPcCLIvI74Hnc2e77vkaWnBYCo7z7b4pIF1Xd6K0/YRMdNc8jQBvv/iygE7DZ26f2HT10Q1U13Jr1gIiM9TUaY1qQtJ3HQESGAxOAo3AJ0hfAXGCm15JgmkBEjsFNHFMAVOGWXZ6nqkt9DSyJiUgf3P5cpKq7IurPVtUX63+miUVE1gD341phJgI9w60wIvKBqvY/2PONSRdp2ySpqgtU9SJVHaSq/VT1XFWdDnzf79iSjYj8GHgKUGARroOcAE+LyE/9jC1Zicj1uFX/rgc+EpELIjbfHftZpgHhVpjW1LTCYK0wxtSWti0G9RGR1apqC6o0gbdo0nHhvgUR9ZnAx17HTtMEIvIhcKKq7hKREmAO8KSq/t5mQIw/ERmvqo/5HYcxLUFa9jEQkQ/q2wRY7+SmqwK6AWVR9fneNtN0wfDlA1Vd5V36miMixdQeBWLi478ASwyMIU0TA9yP/1m4ddgjCfDPwx9O0rsJeFVEVlCzbHURbj6D63yLKrltEJGBqvo+gNdycB4wE+jnb2jJyU4IjGmcdE0MXgBahw+6kURkweEPJ7mp6osichQwDNdZToA1wGJVrfQ1uOR1GVCrE6zXKfYyEbEJjprHTgiMaQTrY2CMSQsiMgN4TFXfiLHtKVX9ng9hGdPiWGJgjDHGmGppO1zRGGOMMXVZYmCMMcaYapYYGGOMMaaaJQbGGGOMqfb/7HVVOrd9ftwAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -1477,8 +1507,8 @@ "# Define data as a list containing data timeseries\n", "data=[np.transpose(ICUvect),np.transpose(hospital)]\n", "# Create a dictionary of past policies\n", - "pastPolicy = {'t': [7], \n", - " 'Nc': [np.array([1.6])]\n", + "pastPolicy = {'t': [10], \n", + " 'Nc': [np.array([1.3])]\n", " }\n", "# Create a dictionary of future policies\n", "futurePolicy = {'t': [1], \n", @@ -1503,7 +1533,7 @@ "realTimeMPC(startDate, data, positions, pastPolicy,parNames,bounds,setpoints,weights)\n", "> - startDate: a string with the date corresponding to the first entry of the dataseries (format: 'YYYY-MM-DD'). \n", "> - data: a list containing the dataseries (dtype=np array) to fit the model to. For now, dataseries must be of equal length and start on the same day.\n", - "> - positions: a list containing the model states (dtype=np.array) used to calculate the sum of least squares. Each dataseries must be matched to a certain (sum of) model state(s). If multiple entries are provided these are added togheter. The order of the states is given according to the following vector, where S has index 0: (S, E, A, M, C, Mi, ICU, R, F, SQ, EQ, AQ, MQ, RQ).\n", + "> - positions: a list containing the model states (dtype=np.array) used to calculate the sum of least squares. Each dataseries must be matched to a certain (sum of) model state(s). If multiple entries are provided these are added togheter. The order of the states is given according to the following vector, where S has index 0: (S, E, I, A, M, C, Mi, ICU, R, F, SQ, EQ, IQ, AQ, MQ, RQ).\n", "> - pastPolicy: a checkpoints dictionary containing past government actions.\n", "> - parNames: a list containing the names (dtype=string) of the model parameters to be used as a control handle.\n", "> - bounds: A list containing the lower- and upper boundaries of each parameter to be used as a control handle. Each entry in the list should be a 1D numpy array containing the lower- and upper bound for the respective control handle.\n", diff --git a/src/SEIRSNetworkModel_demo.ipynb b/src/SEIRSNetworkModel_demo.ipynb index 1fbcd3741..cf349c03b 100644 --- a/src/SEIRSNetworkModel_demo.ipynb +++ b/src/SEIRSNetworkModel_demo.ipynb @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -42,24 +42,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Introduction\n", - "\n", - "### Model Dynamics\n", - "\n", "#### General\n", "\n", - "In this work, we extended the compartmental SEIR model to model the disease spread with a higher resolution. To this end, we distinguish between three primary degrees of sickness: 1) asymptomatic, patients with no symptoms 2) mild, patients with mild symptoms, these patients recover at home 3) hospitalised patients. The ’removed’ pool from the classical SEIR model is explicitly split into an immune and dead pool. People from the susceptible, exposed, asymptomatic, mildly infected and immune pool can be quarantined after having tested positive for covid-19. Note that for individuals in the susceptible and immune pools, this corresponds to a false positive test. The dynamics of our extended SEIR model are presented below. The quarantine states are not shown for the sake of clarity.\n", + "The SEIR model was first proposed in 1929 by two Scottish scientists. It is a compartmental model that subdivides the human population in four types of people : 1) healthy individuals susceptible to the infectious disease, 2) exposed individuals in a latent phase (partially the incubation period), 3) infectious individuals able to transmit the disease and 4) individuals removed from the population either through immunisation or death. Despite being a simple and idealised reality, the SEIR model is used extensively to predict the outbreak of infectious diseases and this was no different during the outbreak in China earlier this year. In this work, we extended the SEIR model to incorporate more expert knowledge on SARS-Cov-2 into the model. The infectious pool is split into four parts. The first is a period of pre-symptomatic infectiousness. Several studies have shown that pre-symptomatic transmission is a dominant transmission mechanism of SARS-Cov-2. After the period of pre-symptomatic transmission, three possible infectious outcomes are modelled. 1) asymptomatic outcome, for patients who show no symptoms at all 2) mild outcome, for patients with mild symptoms, these patients recover at home 3) a mild infection can degress to the point where a hospitalision is needed. The pool of *recovered* individuals from the classical SEIR model is split into an recovered and dead pool. People from the susceptible, exposed, pre-symptomatic infectious, asymptomatic infectious, mild infectious and recovered pool can be quarantined after having tested positive for Covid-19. Note that for individuals in the susceptible and recovered pools, this corresponds to a *false positive* test. The dynamics of our extended SEIR model are presented in the flowchart below. We make the following assumptions with regard to the general SEIRS dynamics,\n", "\n", "\"drawing\"\n", "\n", "We make the following assumptions with regard to the SEIRS dynamics,\n", "\n", - "1. All deaths come from intensive care units in hospitals, meaning no patients die outside a hospital. Of the 7703 diseased (01/05/2020), 46% died in a hospital while 53% died in an elderly home. All hospital deaths are confirmed Covid-19 cases while only 16% of elderly home deaths were confirmed. Our model thus does not explicitly include deaths in elderly homes, although a prediction can be made by algebraic manipulation of the model output. When taking the elderly homes out of the model scope, the assumption that deaths only arise in hospitals can be backed by the fact that only 0.3% died at home and 0.4% died someplace else (Reference in comment). Asymptomatic and mild cases automatically lead to recovery and in no case to death.\n", - "2. Patients in critical condition can survive and recover.\n", - "3. Only exposed and asymptomatic patients can infect susceptibles.\n", - "4. It takes several days before an infection becomes severe and patients are hospitalised. To this end, a fraction of mild infections progresses towards hospitalisation with an estimated latency of approximately 3 days.\n", - "5. We implement no testing and quarantining in the hospital. Hospitalised persons are assumed to be incapable of infecting susceptibles in the first place, so the implementation of a quarantine would not change the dynamics but slow down calculations.\n", - "6. We implement the ability for recovered patients to lose *immunity* and become susceptible to Covid-19 once more. However, seasonality is considered out of scope in this work.\n", + "1. There is no connection between the severity of the disease and the infectiousness of an individual. Only the duration of infectiousness can differ.\n", + "2. All patients experience a brief pre-symptomatic, infectious period.\n", + "3. All deaths come from intensive care units in hospitals, meaning no patients die outside a hospital. Of the 7703 diseased (01/05/2020), 46\\% died in a hospital while 53\\% died in an elderly home. All hospital deaths are confirmed Covid-19 cases while only 16\\% of elderly home deaths were confirmed. When taking the elderly homes out of the model scope, the assumption that deaths only arise in hospitals is true due to the fact that only 0.3\\% died at home and 0.4\\% died someplace else. Asymptomatic and mild cases automatically lead to recovery and in no case to death (https://www.info-coronavirus.be/nl/news/trends-laatste-dagen-zetten-zich-door/).\n", + "4. We implement no testing and quarantining in the hospital. Hospitalised persons are assumed to be incapable of infecting susceptibles, so the implementation of a quarantine would not change the dynamics but slow down calculations.\n", + "5. Recovered patients are assumed to be immune, seasonality is deemed out of scope of this work.\n", "\n", "#### Hospital subystem (preliminary)\n", "\n", @@ -74,74 +69,47 @@ "2. Merge ventilator and non-ventilator ICU.\n", "3. Assume deaths can only arise in ICU.\n", "4. Assume all patients in midcare and ICU pass via Cohort on their way to recovery.\n", - "5. Assume that the 10% of the patients that come from hospital actually come from the population.\n", - "\n", - "### Deterministic vs. Stochastic framework\n", - "\n", - "The extended SEIR model is implemented using two frameworks: a deterministic and a stochastic (network based) framework. **This Jupyter Notebooks is a demo of the stochastic network model,** a demo of the stochastic network simulator is available in *SEIRSNetworkModel_Demo*. A deterministic implementation of the extended SEIRS model captures important features of infectious disease dynamics, but it assumes uniform mixing of the population (i.e. every individual in the population is equally likely to interact with every other individual). The deterministic approach results in a set of N ordinary differential equations, one for every of the N ’population pools’ considered. The main advantage of a deterministic model is that a low amount of computational resources are required while still maintaining an acceptable accuracy. The deterministic framework allows to rapidly explore scenarios and perform optimisations which require thousands of function evaluations. \n", - "\n", - "However, it is often important to consider the structure of contact networks when studying disease transmission and the effect of interventions such as social distancing and contact tracing. The main drawback of the deterministic approach is the inability to simulate contact tracing, which is one of the most promising measures against the spread of SARS-Cov-2. For this reason, the SEIRS dynamics depicted in on the above flowchart can be simulated on a Barabasi-Albert network. This advantages include a more detailed analysis of the relationship between social network structure and effective transmission rates, including the effect of network-based interventions such as social distancing, quarantining, and contact tracing. The added value comes at a high price in terms of computational resources. It is not possible to perform optimisations of parameters in the stochastic network model on a personal computer. Instead, high performance computing infrastructure is needed. The second drawback is the need for more data and/or assumptions on social interactions and how government measures affect these social interactions.\n", - "\n", - "### Stochastic equations\n", - "\n", - "\\begin{eqnarray}\n", - "\\text{Pr}(X_i = S \\rightarrow E) &=& \\Big[ \\underbrace{p \\cdot \\frac{\\beta (E + A)}{N}}_{\\text{infection by random encounter}} \\\\ \n", - "&& + \\underbrace{(1-p) \\cdot \\frac{\\beta \\sum_{j \\in C_G(i)} (\\delta_{X_j = E}+\\delta_{X_j = A})}{C_G (i)}}_{\\text{infection through inner circle}} \\Big] \\delta_{X_i=S},\\\\\n", - "\\text{Pr}(X_i = E \\rightarrow A) &=& (a/\\sigma) \\cdot \\delta_{X_i = E},\\\\\n", - "\\text{Pr}(X_i = E \\rightarrow M) &=& (m/\\sigma) \\cdot \\delta_{X_i = E},\\\\\n", - "\\text{Pr}(X_i = M \\rightarrow C) &=& (h \\cdot c/d_{\\text{hospital}}) \\cdot \\delta_{X_i = M},\\\\\n", - "\\text{Pr}(X_i = M \\rightarrow Mi) &=& (h \\cdot mi /d_{\\text{hospital}}) \\cdot \\delta_{X_i = M},\\\\\n", - "\\text{Pr}(X_i = M \\rightarrow ICU) &=& (h \\cdot (1-c-mi)/d_{\\text{hospital}}) \\cdot \\delta_{X_i = M},\\\\\n", - "\\text{Pr}(X_i = A \\rightarrow R) &=& (1/d_a) \\cdot \\delta_{X_i = A},\\\\\n", - "\\text{Pr}(X_i = M \\rightarrow R) &=& ((1-h)/d_m) \\cdot \\delta_{X_i = M},\\\\\n", - "\\text{Pr}(X_i = Mi \\rightarrow C_{\\text{Mi}}) &=& (1/d_{\\text{mi}}) \\cdot \\delta_{X_i = Mi},\\\\\n", - "\\text{Pr}(X_i = ICU \\rightarrow C_{\\text{ICU}}) &=& ((1-m_0)/d_{\\text{ICU}}) \\cdot \\delta_{X_i = ICU},\\\\\n", - "\\text{Pr}(X_i = ICU \\rightarrow F) &=& (m_0/d_{\\text{ICU}}) \\cdot \\delta_{X_i = ICU},\\\\\n", - "\\text{Pr}(X_i = C \\rightarrow R) &=& (1/d_c) \\cdot \\delta_{X_i = C},\\\\\n", - "\\text{Pr}(X_i = C_{\\text{Mi}} \\rightarrow R) &=& (1/d_{\\text{mi,recovery}}) \\cdot \\delta_{X_i = C_{\\text{Mi}}},\\\\\n", - "\\text{Pr}(X_i = C_{\\text{ICU}} \\rightarrow R) &=& (1/d_{\\text{ICU,recovery}}) \\cdot \\delta_{X_i = C_{\\text{ICU}}},\\\\\n", - "C_{\\text{tot}} = C + C_{\\text{Mi}} + C_{\\text{ICU}}\n", - "\\end{eqnarray}\n", - "\n", - "\\begin{eqnarray}\n", - "\\text{Pr}(X_i = S \\rightarrow SQ) &=& \\Big[\\theta_S + \\phi_S \\big[ \\sum_{j \\in C_G(i)} (\\delta_{X_j = SQ}+\\delta_{X_j = EQ}+\\delta_{X_j = AQ} \\\\\n", - "&&+\\delta_{X_j = MQ}+\\delta_{X_j = RQ}+\\delta_{X_j = C}+\\delta_{X_j = \\text{Mi}} +\\delta_{X_j = \\text{ICU}}) \\big] \\Big] \\\\\n", - "&&\\cdot \\psi_{\\text{FP}} \\cdot \\delta_{X_i = S},\\\\\n", - "\\text{Pr}(X_i = E \\rightarrow EQ) &=& \\Big[\\theta_E + \\phi_E \\big[ \\sum_{j \\in C_G(i)} (\\delta_{X_j = SQ}+\\delta_{X_j = EQ}+\\delta_{X_j = AQ} \\\\\n", - "&&+\\delta_{X_j = MQ}+\\delta_{X_j = RQ}+\\delta_{X_j = C}+\\delta_{X_j = \\text{Mi}} +\\delta_{X_j = \\text{ICU}}) \\big] \\Big] \\\\\n", - "&&\\cdot \\psi_{\\text{PP}} \\cdot \\delta_{X_i = E},\\\\\n", - "\\text{Pr}(X_i = A \\rightarrow AQ) &=& \\Big[\\theta_A + \\phi_A \\big[ \\sum_{j \\in C_G(i)} (\\delta_{X_j = SQ}+\\delta_{X_j = EQ}+\\delta_{X_j = AQ} \\\\\n", - "&&+\\delta_{X_j = MQ}+\\delta_{X_j = RQ}+\\delta_{X_j = C}+\\delta_{X_j = \\text{Mi}} +\\delta_{X_j = \\text{ICU}}) \\big] \\Big] \\\\\n", - "&&\\cdot \\psi_{\\text{PP}} \\cdot \\delta_{X_i = A},\\\\\n", - "\\text{Pr}(X_i = M \\rightarrow MQ) &=& \\Big[\\theta_M + \\phi_M \\big[ \\sum_{j \\in C_G(i)} (\\delta_{X_j = SQ}+\\delta_{X_j = EQ}+\\delta_{X_j = AQ} \\\\\n", - "&&+\\delta_{X_j = MQ}+\\delta_{X_j = RQ}+\\delta_{X_j = C}+\\delta_{X_j = \\text{Mi}} +\\delta_{X_j = \\text{ICU}}) \\big] \\Big] \\\\\n", - "&&\\cdot \\psi_{\\text{PP}} \\cdot \\delta_{X_i = M},\\\\\n", - "\\text{Pr}(X_i = R \\rightarrow RQ) &=& \\Big[\\theta_R + \\phi_R \\big[ \\sum_{j \\in C_G(i)} (\\delta_{X_j = SQ}+\\delta_{X_j = EQ}+\\delta_{X_j = AQ} \\\\\n", - "&&+\\delta_{X_j = MQ}+\\delta_{X_j = RQ}+\\delta_{X_j = C}+\\delta_{X_j = \\text{Mi}} +\\delta_{X_j = \\text{ICU}}) \\big] \\Big] \\\\\n", - "&&\\cdot \\psi_{\\text{FP}} \\cdot \\delta_{X_i = R},\\\\\n", - "\\text{Pr}(X_i = SQ \\rightarrow S) &=& (1/d_{q,FP}) \\cdot \\delta_{X_i = SQ},\\\\\n", - "\\text{Pr}(X_i = EQ \\rightarrow AQ) &=& (a/\\sigma) \\cdot \\delta_{X_i = EQ},\\\\\n", - "\\text{Pr}(X_i = EQ \\rightarrow MQ) &=& (m/\\sigma) \\cdot \\delta_{X_i = EQ},\\\\\n", - "\\text{Pr}(X_i = MQ \\rightarrow C) &=& (h \\cdot c / d_{\\text{hospital}}) \\delta_{X_i = MQ},\\\\\n", - "\\text{Pr}(X_i = MQ \\rightarrow Mi) &=& (h \\cdot mi / d_{\\text{hospital}}) \\cdot \\delta_{X_i = MQ},\\\\\n", - "\\text{Pr}(X_i = MQ \\rightarrow ICU) &=& (h \\cdot (1-c-mi) / d_{\\text{hospital}}) \\cdot \\delta_{X_i = MQ},\\\\\n", - "\\text{Pr}(X_i = MQ \\rightarrow R) &=& ((1-h)/d_m) \\cdot \\delta_{X_i = MQ},\\\\\n", - "\\text{Pr}(X_i = AQ \\rightarrow R) &=& (1/d_{q,FP}) \\cdot \\delta_{X_i = AQ},\\\\\n", - "\\text{Pr}(X_i = RQ \\rightarrow R) &=& (1/d_{q,FP}) \\cdot \\delta_{X_i = RQ},\\\\\n", - "\\text{Pr}(X_i = R \\rightarrow S) &=& \\zeta \\cdot \\delta_{X_i = R},\\\\\n", - "\\end{eqnarray}\n", - "\n", - "\n", - "### Model parameters\n", + "5. Assume that the 10% of the patients that come from hospital actually come from the population." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Deterministic vs. Stochastic framework" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The extended SEIR model is implemented using two frameworks: a deterministic and a stochastic (network based) framework. **This Jupyter Notebooks is a demo of the deterministic model,** a demo of the stochastic network simulator is available in *SEIRSNetworkModel_Demo*. A deterministic implementation of the extended SEIRS model captures important features of infectious disease dynamics, but it assumes uniform mixing of the population (i.e. every individual in the population is equally likely to interact with every other individual). The deterministic approach results in a set of N ordinary differential equations, one for every of the N ’population pools’ considered. The main advantage of a deterministic model is that a low amount of computational resources are required while still maintaining an acceptable accuracy. The deterministic framework allows to rapidly explore scenarios and perform optimisations which require thousands of function evaluations. \n", "\n", + "However, it is often important to consider the structure of contact networks when studying disease transmission and the effect of interventions such as social distancing and contact tracing. The main drawback of the deterministic approach is the inability to simulate contact tracing, which is one of the most promising measures against the spread of SARS-Cov-2. For this reason, the SEIRS dynamics depicted in on the above flowchart can be simulated on a Barabasi-Albert network. This advantages include a more detailed analysis of the relationship between social network structure and effective transmission rates, including the effect of network-based interventions such as social distancing, quarantining, and contact tracing. The added value comes at a high price in terms of computational resources. It is not possible to perform optimisations of parameters in the stochastic network model on a personal computer. Instead, high performance computing infrastructure is needed. The second drawback is the need for more data and/or assumptions on social interactions and how government measures affect these social interactions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Model parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ "In the above equations, S stands for susceptible, E for exposed, A for asymptomatic, M for mild, H for hospitalised, C for cohort, Mi for midcare, ICU for intensive care unit, D for dead, R for recovered. The quarantined states are denoted with a Q suffix, for instance AQ stands for asymptomatic and quarantined. The states S, E, A, M and R can be quarantined. The disease dynamics when quarantined are identical to the non quarantined dynamics. For instance, EQ will evolve into AQ or MQ with the same probability as E evolves into A or M. Individuals from the MQ pool can end up in the hospital. N stands for the total population. The clinical parameters are: a, m: the chance of having an asymptomatic or mild infection. h: the fraction of mildly infected which require hospitalisation. c: fraction of the hospitalised which remain in Cohort, mi: fraction of hospitalised which end up in midcare. Based on reported cases in China and travel data, Li et al. (2020b) estimated that 86 % of coronavirus infections in the country were \"undocumented\" in the weeks before officials instituted stringent quarantines. This figure thus includes the asymptomatic cases and an unknown number of mildly symptomatic cases and is thus an overestimation of the asymptotic fraction. In Iceland, citizens were invited for testing regardless of symptoms. Of all people with positive test results, 43% were asymptomatic (Gudbjartsson et al., 2020). The actual number of asymptomatic infections might be even higher since it seemed that symptomatic persons were more likely to respond to the invitation (Sciensano, 2020). In this work it is assumed that 43 % of all infected cases are asymptomatic. This figure can later be corrected in light of large scale immunity testing in the Belgian population. Hence,\n", "\n", "$$ a = 0.43 .$$\n", "\n", - "Wu and McGoogan (2020) estimated that the distribution between mild, severe and critical cases is equal to 81%, 15% and 4%. \n", + "Wu and McGoogan (2020) estimated that the distribution between mild, severe and critical cases is equal to 81%, 15% and 4%. As a rule of thumb, one can assume that one third of all hospitalised patients ends up in an ICU. Based on interviews with Ghent University hospital staff, midcare is merged with ICU in the offical numbers. For now, it is assumed that the distribution between midcare and ICU is 50-50 %. The sum of both pools is one third of the hospitalisations. Since the average time a patient spends in midcare is equal to ICU, this corresponds to seeing midcare and ICU as 'ICU'.\n", + "\n", + "$\\sigma$: length of the latent period. Assumed four days based on a modeling study by Davies et al. (2020) .\n", "\n", + "$\\omega$: length of the pre-symptomatic infectious period, assumed 1.5 days (Davies et al. 2020). The sum of $\\omega$ and $\\sigma$ is the total incubation period, and is equal to 5.5 days. Several estimates of the incubation period have been published and range from 3.6 to 6.4 days, with the majority of estimates around 5 days (Park et. al 2020).\n", "\n", - "$d_{a}$ , $d_{m}$ , $d_{h}$ : the duration of infection in case of a asymptomatic or mild infection. Assumed to be 7 days.\n", + "$d_{a}$ , $d_{m}$ , $d_{h}$ : the duration of infection in case of a asymptomatic or mild infection. Assumed to be 6.5 days. Toghether with the length of the pre-symptomatic infectious period, this accounts to a total of 8 days of infectiousness. \n", "\n", "$d_{c}$ , $d_{\\text{mi}}$ , $d_{\\text{ICU}}$: average length of a Cohort, Midcare and ICU stay. Equal to one week, two weeks and two weeks respectively.\n", "\n", @@ -149,43 +117,11 @@ "\n", "Zhou et al. (2020) performed a retrospective study on 191 Chinese hospital patients and determined that the time from illness onset to discharge or death was 22.0 days (18.0-25.0, IQR) and 18.5 days (15.0-22.0, IQR) for survivors and victims respectively. Using available preliminary data, the World Health Organisation estimated the median time from onset to clinical recovery for mild cases to be approximately 2 weeks and to be 3-6 weeks for patients with severe or critical disease (WHO, 2020). Based on this report, we assume a recovery time of three weeks for heavy infections.\n", "\n", - "$d_{hospital}$ : the time before heavily or critically infected patients reach the hospital. Assumed 3 days, still waiting on hospital input here.\n", + "$d_{hospital}$ : the time before heavily or critically infected patients reach the hospital. Assumed 5-9 days (Linton et al. 2020). Still waiting on hospital input here.\n", "\n", - "$m_0$ : the mortality in case of a heavy infection, which is roughly 50\\% (Wu and McGoogan, 2020). \n", + "$m_0$ : the mortality in ICU, which is roughly 50\\% (Wu and McGoogan, 2020). \n", "\n", - "$\\sigma$: the incubation period in days. The incubation period is assumed to be Erlang distributed as reported by Li et al. (2020a). The average incubation time is 5.2 days. \n", - "\n", - "$\\zeta$: can be used to model the effect of re-susceptibility and seasonality of a disease. Throughout this demo, we assume $\\zeta = 0$ because data on seasonality is not yet available at the moment. We thus assume permanent immunity after recovering from the infection.\n", - "\n", - "The transmission rate $R_0$ of the disease in the deterministic model depends on the product of three contributions. The first contribution, $(E+A)/N$, is the probability of encountering a contagious individual. The second contribution, $N_c$, is the average number of human-to-human interactions per day. As previously explained, **in the deterministic framework, this assumes all $N_c$ contacts within the population to be random**. The third contribution, $\\beta$, is the probability of contracting SARS-Cov-2 when encoutering a contagious individual. \n", - "\n", - "In this work, we explictly split $\\beta$ and $N_c$ because this has the following advantages: 1) $\\beta$ is now a disease characteristic, independent of social interactions. 2) The goal of this work is to demonstrate the concept of social control to contain the outbreak using model predictive control. By splitting $\\beta$ and $N_c$, the controlled variable is the number of random contacts $N_c$ which is more comprehendible to the reader of this text. The number of human-human interactions per day is estimated using the Social Contact Rates (SOCRATES) Data Tool (Willem et al., 2020). The dataset on human-human interactions is based on a 2008 study by Mossong, which kept track of 7,920 participants and their interactions in 97,904 European countries (Mossong et al., 2008). From SOCRATES, it is determined that the average Belgian has 11.2 interactions with other people each day. This includes both physical and non-physical interactions of any duration.\n", - "\n", - "The testing and quarantine parameters are: $\\theta_{S}$, $\\theta_{E}$, $\\theta_{A}$, $\\theta_{M}$, $\\theta_{R}$ expressed as the number of susceptibles, exposed, supermild and mild individuals tested each day. It is difficult to model a concrete testing scenario in the deterministic framework because no back tracing can be coupled to the tests. The deterministic model only considers random testing of the population. It uses the total daily testing capacity to calculate the amount of individuals in the S, E, A, M and R pool that receive a test. \n", - "\n", - "$\\psi_{PP}$: probability of correctly identifiying and quarantining an exposed or infected person. $\\psi_{FP}$: probability of falsly identifying and quarantining a susceptible or recovered individual. Both parameters can be calculated using the reliability of the test and Bayes theorem. **For now, we assume no false positives.**\n", - "\n", - "$d_{\\text{q,FP}}$: the duration of the quarantine in the case of a false positive, assumed to be 14 days.\n", - "\n", - "### Social interaction data\n", - "\n", - "#### Social Contact Rates (SOCRATES) Data Tool\n", - "\n", - "https://lwillem.shinyapps.io/socrates_rshiny/\n", - "\n", - "1. What is the average number of daily human-to-human contacts of the Belgian population? Include all ages, all genders and both physical and non-physical interactions of any duration. To include all ages, type: *0,60+* in the *Age Breaks* dialog box.\n", - "2. What is the average number of physical human-to-human contacts of the Belgian population? Include all ages, all genders and all durations of physical contact.\n", - "3. What is the average number of physical human-to-human contacts of at least 1 hour of the Belgian population?\n", - "4. Based on the above results, how would you estimate $N_c$ in the deterministic model?\n", - "5. Based on the above results, how would you estimate $p$ in the stochastic model? Recall that $p$ is the fraction of *random contacts* a person has on a daily basis, while $(1-p)$ is the fraction of *inner circle contacts* a person has on a daily basis.\n", - "\n", - "#### Google COVID-19 Community Mobility Reports\n", - "\n", - "https://www.google.com/covid19/mobility/\n", - "\n", - "#### London School of Hygiene\n", - "\n", - "https://www.thelancet.com/journals/lanpub/article/PIIS2468-2667(20)30073-6/fulltext" + "$\\zeta$: can be used to model the effect of re-susceptibility and seasonality of a disease. Throughout this demo, we assume $\\zeta = 0$ because data on seasonality is not yet available at the moment. We thus assume permanent immunity after recovering from the infection." ] }, { @@ -219,12 +155,12 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -234,7 +170,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -246,46 +182,47 @@ "source": [ "# Construct the network G\n", "numNodes = 10000\n", - "baseGraph = networkx.barabasi_albert_graph(n=numNodes, m=4)\n", + "baseGraph = networkx.barabasi_albert_graph(n=numNodes, m=3)\n", "# Baseline normal interactions:\n", - "G_norm = models.custom_exponential_graph(baseGraph, scale=100)\n", + "G_norm = models.custom_exponential_graph(baseGraph, scale=500)\n", "models.plot_degree_distn(G_norm, max_degree=40)\n", "\n", "# Construct the network G under social distancing\n", "numNodes = 10000\n", "baseGraph = networkx.barabasi_albert_graph(n=numNodes, m=1)\n", "# Baseline normal interactions:\n", - "G_dist = models.custom_exponential_graph(baseGraph, scale=20000000000)\n", + "G_dist = models.custom_exponential_graph(baseGraph, scale=200000)\n", "models.plot_degree_distn(G_dist, max_degree=40)" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "model = models.SEIRSNetworkModel(\n", " # network connectivty\n", " G = G_norm,\n", - " p = 0.6,\n", + " p = 0.51,\n", " # clinical parameters\n", " beta = 0.03, \n", - " sigma = 5.2,\n", + " sigma = 4.0,\n", + " omega = 1.5,\n", " zeta = 0,\n", " a = 0.43, # probability of an asymptotic (supermild) infection\n", " m = 1-0.43, # probability of a mild infection\n", " h = 0.20, # probability of hospitalisation for a mild infection\n", " c = 2/3, # probability of hospitalisation in cohort\n", " mi = 1/6, # probability of hospitalisation in midcare\n", - " da = 14, # days of infection when asymptomatic (supermild)\n", - " dm = 14, # days of infection when mild\n", + " da = 6.5, # days of infection when asymptomatic (supermild)\n", + " dm = 6.5, # days of infection when mild\n", " dc = 7,\n", " dmi = 14,\n", " dICU = 14,\n", " dICUrec = 6,\n", " dmirec = 6,\n", - " dhospital = 3, # days before reaching the hospital when heavy or critical\n", + " dhospital = 5, # days before reaching the hospital when heavy or critical\n", " m0 = 0.49, # mortality in ICU\n", " maxICU = 2000,\n", " # testing\n", @@ -300,11 +237,13 @@ " # back-tracking\n", " phi_S = 0,\n", " phi_E = 0,\n", + " phi_I = 0,\n", " phi_A = 0,\n", " phi_R = 0,\n", " # initial condition\n", " initN = 11.43e6, #results are extrapolated to entire population\n", - " initE = 10,\n", + " initE = 1,\n", + " initI = 0,\n", " initA = 0, \n", " initM = 0,\n", " initC = 0,\n", @@ -314,6 +253,7 @@ " initD = 0,\n", " initSQ = 0,\n", " initEQ = 0,\n", + " initIQ = 0,\n", " initAQ = 0,\n", " initMQ = 0,\n", " initRQ = 0,\n", @@ -332,14 +272,14 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "(1, 51)\n" + "(1, 57)\n" ] } ], @@ -361,7 +301,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -379,123 +319,33 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "t = 0.40\n", - "t = 10.06\n", - "t = 20.03\n", - "t = 30.00\n", - "t = 40.00\n", - "t = 50.00\n", - "t = 60.00\n", - "t = 70.00\n", - "t = 80.00\n", - "t = 90.01\n", - "t = 100.02\n", - "t = 0.14\n", - "t = 10.04\n", + "t = 10.94\n", "t = 20.01\n", - "t = 30.00\n", - "t = 40.00\n", - "t = 50.01\n", - "t = 60.00\n", - "t = 70.00\n", - "t = 80.00\n", - "t = 90.00\n", - "t = 100.00\n", - "t = 0.06\n", - "t = 10.02\n", - "t = 20.03\n", - "t = 30.00\n", + "t = 30.01\n", "t = 40.00\n", - "t = 50.00\n", - "t = 60.00\n", - "t = 70.00\n", - "t = 80.01\n", - "t = 90.07\n", + "t = 50.02\n", + "t = 60.10\n", + "t = 70.24\n", + "t = 80.11\n", + "t = 90.04\n", "t = 100.04\n", - "t = 0.03\n", - "t = 10.04\n", - "t = 20.01\n", - "t = 30.00\n", - "t = 40.00\n", - "t = 50.00\n", - "t = 60.00\n", - "t = 70.01\n", - "t = 80.00\n", - "t = 90.01\n", - "t = 100.01\n", - "t = 0.34\n", - "t = 10.05\n", - "t = 20.01\n", - "t = 30.00\n", - "t = 40.00\n", - "t = 50.00\n", - "t = 60.00\n", - "t = 70.00\n", - "t = 80.02\n", - "t = 90.00\n", - "t = 100.02\n", - "t = 0.05\n", - "t = 10.04\n", - "t = 20.01\n", - "t = 30.00\n", - "t = 40.00\n", - "t = 50.00\n", - "t = 60.00\n", - "t = 70.00\n", - "t = 80.00\n", - "t = 90.01\n", - "t = 100.03\n", - "t = 0.03\n", - "t = 10.00\n", + "t = 0.30\n", "t = 20.01\n", - "t = 30.00\n", - "t = 40.00\n", - "t = 50.00\n", - "t = 60.00\n", - "t = 70.00\n", - "t = 80.00\n", - "t = 90.01\n", - "t = 100.01\n", - "t = 0.14\n", - "t = 10.01\n", - "t = 20.02\n", - "t = 30.00\n", - "t = 40.00\n", - "t = 50.00\n", - "t = 60.00\n", - "t = 70.00\n", - "t = 80.00\n", - "t = 90.01\n", - "t = 100.00\n", - "t = 0.31\n", - "t = 10.00\n", - "t = 20.00\n", - "t = 30.01\n", - "t = 40.00\n", - "t = 50.00\n", - "t = 60.00\n", - "t = 70.00\n", - "t = 80.00\n", - "t = 90.01\n", - "t = 100.02\n", - "t = 0.00\n", - "t = 10.00\n", - "t = 20.00\n", - "t = 30.01\n", - "t = 40.00\n", - "t = 50.00\n", - "t = 60.00\n", - "t = 70.01\n", + "t = 30.24\n", + "t = 40.07\n", + "t = 50.02\n", + "t = 60.22\n", + "t = 70.19\n", "t = 80.00\n", - "t = 90.00\n", - "t = 100.03\n" + "t = 90.02\n", + "t = 100.08\n" ] } ], @@ -536,12 +386,12 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -551,7 +401,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -576,27 +426,19 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "t = 0.07\n", - "[Checkpoint: Updating parameters]\n", - "t = 10.03\n", - "t = 0.14\n", - "[Checkpoint: Updating parameters]\n", - "t = 10.03\n", - "t = 0.35\n", - "[Checkpoint: Updating parameters]\n", - "t = 10.11\n" + "t = 10.14\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -606,7 +448,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -617,12 +459,12 @@ ], "source": [ "# Create checkpoints dictionary\n", - "chk = {'t': [10], \n", + "chk = {'t': [80], \n", " 'G': [G_dist],\n", " 'p': [0.02],\n", " }\n", "# Run simulation\n", - "y = model.sim(15,checkpoints=chk)\n", + "y = model.sim(,checkpoints=chk)\n", "# Visualise\n", "model.plotPopulationStatus()\n", "model.plotInfected()" diff --git a/src/models.py b/src/models.py index f6ba447d3..08891dff0 100644 --- a/src/models.py +++ b/src/models.py @@ -52,9 +52,9 @@ class SEIRSAgeModel(): Params: """ - def __init__(self, initN, beta, sigma, Nc=0, zeta=0,a=0,m=0,h=0,c=0,mi=0,da=0,dm=0,dc=0,dmi=0,dICU=0,dICUrec=0,dmirec=0,dhospital=0,m0=0,maxICU=0,totalTests=0, - psi_FP=0,psi_PP=0,dq=14,initE=0,initA=0,initM=0,initC=0,initCmirec=0,initCicurec=0,initMi=0,initICU=0,initR=0, - initD=0,initSQ=0,initEQ=0,initAQ=0,initMQ=0,initRQ=0,monteCarlo=False,n_samples=1): + def __init__(self, initN, beta, sigma, omega, Nc=0, zeta=0,a=0,m=0,h=0,c=0,mi=0,da=0,dm=0,dc=0,dmi=0,dICU=0,dICUrec=0,dmirec=0,dhospital=0,m0=0,maxICU=0,totalTests=0, + psi_FP=0,psi_PP=0,dq=14,initE=0,initI=0,initA=0,initM=0,initC=0,initCmirec=0,initCicurec=0,initMi=0,initICU=0,initR=0, + initD=0,initSQ=0,initEQ=0,initIQ=0,initAQ=0,initMQ=0,initRQ=0,monteCarlo=False,n_samples=1): #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Initialize Model Parameters: @@ -62,6 +62,7 @@ def __init__(self, initN, beta, sigma, Nc=0, zeta=0,a=0,m=0,h=0,c=0,mi=0,da=0,dm # Clinical parameters self.beta = beta self.sigma = sigma + self.omega = omega self.Nc = Nc self.zeta = zeta self.a = a @@ -95,6 +96,7 @@ def __init__(self, initN, beta, sigma, Nc=0, zeta=0,a=0,m=0,h=0,c=0,mi=0,da=0,dm # initial condition must be an attribute of class: WAS NOT ADDED ORIGINALLY self.initN = numpy.reshape(initN,[Nc.shape[0],1]) self.initE = numpy.reshape(initE,[Nc.shape[0],1]) + self.initI = numpy.reshape(initI,[Nc.shape[0],1]) self.initA = numpy.reshape(initA,[Nc.shape[0],1]) self.initM = numpy.reshape(initM,[Nc.shape[0],1]) initCtot = initC + initCmirec + initCicurec @@ -108,6 +110,7 @@ def __init__(self, initN, beta, sigma, Nc=0, zeta=0,a=0,m=0,h=0,c=0,mi=0,da=0,dm self.initD = numpy.reshape(initD,[Nc.shape[0],1]) self.initSQ = numpy.reshape(initSQ,[Nc.shape[0],1]) self.initEQ = numpy.reshape(initEQ,[Nc.shape[0],1]) + self.initIQ = numpy.reshape(initIQ,[Nc.shape[0],1]) self.initAQ = numpy.reshape(initAQ,[Nc.shape[0],1]) self.initMQ = numpy.reshape(initMQ,[Nc.shape[0],1]) self.initRQ = numpy.reshape(initRQ,[Nc.shape[0],1]) @@ -125,6 +128,7 @@ def __init__(self, initN, beta, sigma, Nc=0, zeta=0,a=0,m=0,h=0,c=0,mi=0,da=0,dm # per age category: self.N = self.initN.astype(int) self.numE = self.initE.astype(int) + self.numI = self.initI.astype(int) self.numA = self.initA.astype(int) self.numM = self.initM.astype(int) self.numCtot = self.initCtot.astype(int) @@ -137,13 +141,14 @@ def __init__(self, initN, beta, sigma, Nc=0, zeta=0,a=0,m=0,h=0,c=0,mi=0,da=0,dm self.numD = self.initD.astype(int) self.numSQ = self.initSQ.astype(int) self.numEQ = self.initEQ.astype(int) + self.numIQ = self.initIQ.astype(int) self.numAQ = self.initAQ.astype(int) self.numMQ = self.initMQ.astype(int) self.numRQ = self.initRQ.astype(int) - self.numS = numpy.reshape(self.N[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numE[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numA[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numM[:,-1],[Nc.shape[0],1]) + self.numS = numpy.reshape(self.N[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numE[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numI[:,-1],[Nc.shape[0],1])- numpy.reshape(self.numA[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numM[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numCtot[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numMi[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numICU[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numR[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numD[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numSQ[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numEQ[:,-1],[Nc.shape[0],1]) - - numpy.reshape(self.numAQ[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numMQ[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numRQ[:,-1],[Nc.shape[0],1]) + - numpy.reshape(self.numIQ[:,-1],[Nc.shape[0],1])- numpy.reshape(self.numAQ[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numMQ[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numRQ[:,-1],[Nc.shape[0],1]) def reset(self): Nc = self.Nc @@ -154,6 +159,7 @@ def reset(self): # initial condition must be an attribute of class: WAS NOT ADDED ORIGINALLY self.initN = numpy.reshape(self.initN,[Nc.shape[0],1]) self.initE = numpy.reshape(self.initE,[Nc.shape[0],1]) + self.initI = numpy.reshape(self.initI,[Nc.shape[0],1]) self.initA = numpy.reshape(self.initA,[Nc.shape[0],1]) self.initM = numpy.reshape(self.initM,[Nc.shape[0],1]) self.initC = numpy.reshape(self.initC,[Nc.shape[0],1]) @@ -167,6 +173,7 @@ def reset(self): self.initD = numpy.reshape(self.initD,[Nc.shape[0],1]) self.initSQ = numpy.reshape(self.initSQ,[Nc.shape[0],1]) self.initEQ = numpy.reshape(self.initEQ,[Nc.shape[0],1]) + self.initIQ = numpy.reshape(self.initIQ,[Nc.shape[0],1]) self.initAQ = numpy.reshape(self.initAQ,[Nc.shape[0],1]) self.initMQ = numpy.reshape(self.initMQ,[Nc.shape[0],1]) self.initRQ = numpy.reshape(self.initRQ,[Nc.shape[0],1]) @@ -184,6 +191,7 @@ def reset(self): # per age category: self.N = self.initN.astype(int) self.numE = self.initE.astype(int) + self.numI = self.initI.astype(int) self.numA = self.initA.astype(int) self.numM = self.initM.astype(int) self.numCtot = self.initCtot.astype(int) @@ -196,25 +204,27 @@ def reset(self): self.numD = self.initD.astype(int) self.numSQ = self.initSQ.astype(int) self.numEQ = self.initEQ.astype(int) + self.numIQ = self.initIQ.astype(int) self.numAQ = self.initAQ.astype(int) self.numMQ = self.initMQ.astype(int) self.numRQ = self.initRQ.astype(int) - self.numS = numpy.reshape(self.N[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numE[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numA[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numM[:,-1],[Nc.shape[0],1]) + self.numS = numpy.reshape(self.N[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numE[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numI[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numA[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numM[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numCtot[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numMi[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numICU[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numR[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numD[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numSQ[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numEQ[:,-1],[Nc.shape[0],1]) - - numpy.reshape(self.numAQ[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numMQ[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numRQ[:,-1],[Nc.shape[0],1]) + - numpy.reshape(self.numIQ[:,-1],[Nc.shape[0],1])- numpy.reshape(self.numAQ[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numMQ[:,-1],[Nc.shape[0],1]) - numpy.reshape(self.numRQ[:,-1],[Nc.shape[0],1]) #^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ #^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @staticmethod - def system_dfes(t, variables, beta, sigma, Nc, zeta, a, m, h, c, mi, da, dm, dc, dmi, dICU, dICUrec, dmirec, dhospital, m0, ICU, totalTests, psi_FP, psi_PP, dq): + def system_dfes(t, variables, beta, sigma,omega, Nc, zeta, a, m, h, c, mi, da, dm, dc, dmi, dICU, dICUrec, dmirec, dhospital, m0, ICU, totalTests, psi_FP, psi_PP, dq): # input is a 1D-array # first extract seperate variables in 1D-array - S,E,A,M,C,Cmirec,Cicurec,Mi,ICU,R,D,SQ,EQ,AQ,MQ,RQ = variables.reshape(16,Nc.shape[0]) + S,E,I,A,M,C,Cmirec,Cicurec,Mi,ICU,R,D,SQ,EQ,IQ,AQ,MQ,RQ = variables.reshape(18,Nc.shape[0]) # reshape all variables to a Nc.shape[0]x1 2D-array S = numpy.reshape(S,[Nc.shape[0],1]) E = numpy.reshape(E,[Nc.shape[0],1]) + I = numpy.reshape(I,[Nc.shape[0],1]) A = numpy.reshape(A,[Nc.shape[0],1]) M = numpy.reshape(M,[Nc.shape[0],1]) C = numpy.reshape(C,[Nc.shape[0],1]) @@ -226,18 +236,21 @@ def system_dfes(t, variables, beta, sigma, Nc, zeta, a, m, h, c, mi, da, dm, dc, D = numpy.reshape(D,[Nc.shape[0],1]) SQ = numpy.reshape(SQ,[Nc.shape[0],1]) EQ = numpy.reshape(EQ,[Nc.shape[0],1]) + IQ = numpy.reshape(IQ,[Nc.shape[0],1]) AQ = numpy.reshape(AQ,[Nc.shape[0],1]) MQ = numpy.reshape(MQ,[Nc.shape[0],1]) RQ = numpy.reshape(RQ,[Nc.shape[0],1]) Ctot = C + Cmirec + Cicurec # calculate total population per age bin using 2D array - N = S + E + A + M + Ctot + Mi + ICU + R + SQ + EQ + AQ + MQ + RQ + N = S + E + I + A + M + Ctot + Mi + ICU + R + SQ + EQ + IQ + AQ + MQ + RQ # calculate the test rates for each pool using the total number of available tests - nT = S + E + A + M + R + nT = S + E + I + A + M + R theta_S = totalTests/nT theta_S[theta_S > 1] = 1 theta_E = totalTests/nT theta_E[theta_E > 1] = 1 + theta_I = totalTests/nT + theta_I[theta_I > 1] = 1 theta_A = totalTests/nT theta_A[theta_A > 1] = 1 theta_M = totalTests/nT @@ -245,10 +258,11 @@ def system_dfes(t, variables, beta, sigma, Nc, zeta, a, m, h, c, mi, da, dm, dc, theta_R = totalTests/nT theta_R[theta_R > 1] = 1 # calculate rates of change using the 2D arrays - dS = - beta*numpy.matmul(Nc,((E+A)/N)*S) - theta_S*psi_FP*S + SQ/dq + zeta*R - dE = beta*numpy.matmul(Nc,((E+A)/N)*S) - E/sigma - theta_E*psi_PP*E - dA = a/sigma*E - A/da - theta_A*psi_PP*A - dM = m/sigma*E - M*((1-h)/dm) - M*h/dhospital - theta_M*psi_PP*M + dS = - beta*numpy.matmul(Nc,((I+A)/N)*S) - theta_S*psi_FP*S + SQ/dq + zeta*R + dE = beta*numpy.matmul(Nc,((I+A)/N)*S) - E/sigma - theta_E*psi_PP*E + dI = (1/sigma)*E - (1/omega)*I - theta_I*psi_PP*I + dA = (a/omega)*I - A/da - theta_A*psi_PP*A + dM = (m/omega)*I - M*((1-h)/dm) - M*h/dhospital - theta_M*psi_PP*M dC = c*(M+MQ)*(h/dhospital) - C*(1/dc) dCmirec = Mi/dmi- Cmirec*(1/dmirec) dCicurec = (1-m0)/dICU*ICU - Cicurec*(1/dICUrec) @@ -258,12 +272,13 @@ def system_dfes(t, variables, beta, sigma, Nc, zeta, a, m, h, c, mi, da, dm, dc, dD = (m0/dICU)*ICU dSQ = theta_S*psi_FP*S - SQ/dq dEQ = theta_E*psi_PP*E - EQ/sigma - dAQ = theta_A*psi_PP*A + (a/sigma)*EQ - AQ/dq - dMQ = theta_M*psi_PP*M + (m/sigma)*EQ - ((1-h)/dm)*MQ - (h/dhospital)*MQ + dIQ = theta_I*psi_PP*I + (1/sigma)*EQ - (1/omega)*IQ + dAQ = theta_A*psi_PP*A + (a/omega)*IQ - AQ/dq + dMQ = theta_M*psi_PP*M + (m/omega)*IQ - ((1-h)/dm)*MQ - (h/dhospital)*MQ dRQ = theta_R*psi_FP*R - RQ/dq # reshape output back into a 1D array of similar dimension as input - out = numpy.array([dS,dE,dA,dM,dC,dCmirec,dCicurec,dMi,dICUstar,dR,dD,dSQ,dEQ,dAQ,dMQ,dRQ]) - out = numpy.reshape(out,16*Nc.shape[0]) + out = numpy.array([dS,dE,dI,dA,dM,dC,dCmirec,dCicurec,dMi,dICUstar,dR,dD,dSQ,dEQ,dIQ,dAQ,dMQ,dRQ]) + out = numpy.reshape(out,18*Nc.shape[0]) return out #^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -282,18 +297,18 @@ def run_epoch(self, runtime, dt=1): # Define the initial conditions as the system's current state: # (which will be the t=0 condition if this is the first run of this model, # else where the last sim left off) - init_cond = numpy.array([self.numS[:,-1], self.numE[:,-1], self.numA[:,-1], self.numM[:,-1], self.numC[:,-1], self.numCmirec[:,-1],self.numCicurec[:,-1], self.numMi[:,-1], self.numICU[:,-1], self.numR[:,-1], self.numD[:,-1], self.numSQ[:,-1], self.numEQ[:,-1], self.numAQ[:,-1], self.numMQ[:,-1], self.numRQ[:,-1]]) - init_cond = numpy.reshape(init_cond,16*self.Nc.shape[0]) + init_cond = numpy.array([self.numS[:,-1], self.numE[:,-1], self.numI[:,-1], self.numA[:,-1], self.numM[:,-1], self.numC[:,-1], self.numCmirec[:,-1],self.numCicurec[:,-1], self.numMi[:,-1], self.numICU[:,-1], self.numR[:,-1], self.numD[:,-1], self.numSQ[:,-1], self.numEQ[:,-1],self.numIQ[:,-1], self.numAQ[:,-1], self.numMQ[:,-1], self.numRQ[:,-1]]) + init_cond = numpy.reshape(init_cond,18*self.Nc.shape[0]) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Solve the system of differential eqns: #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - solution = scipy.integrate.solve_ivp(lambda t, X: SEIRSAgeModel.system_dfes(t, X, self.beta, self.sigma, self.Nc, self.zeta, self.a, self.m, self.h, self.c, self.mi, self.da, + solution = scipy.integrate.solve_ivp(lambda t, X: SEIRSAgeModel.system_dfes(t, X, self.beta, self.sigma, self.omega, self.Nc, self.zeta, self.a, self.m, self.h, self.c, self.mi, self.da, self.dm, self.dc,self.dmi,self.dICU,self.dICUrec,self.dmirec,self.dhospital,self.m0,self.ICU,self.totalTests,self.psi_FP,self.psi_PP,self.dq), t_span=[self.t, self.tmax], y0=init_cond, t_eval=t_eval) # output of size (nTimesteps * Nc.shape[0]) - S,E,A,M,C,Cmirec,Cicurec,Mi,ICU,R,F,SQ,EQ,AQ,MQ,RQ = numpy.split(numpy.transpose(solution['y']),16,axis=1) + S,E,I,A,M,C,Cmirec,Cicurec,Mi,ICU,R,F,SQ,EQ,IQ,AQ,MQ,RQ = numpy.split(numpy.transpose(solution['y']),18,axis=1) Ctot = C + Cmirec + Cicurec #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -304,6 +319,7 @@ def run_epoch(self, runtime, dt=1): self.tseries = numpy.append(self.tseries, solution['t']) self.numS = numpy.append(self.numS, numpy.transpose(S),axis=1) self.numE = numpy.append(self.numE, numpy.transpose(E),axis=1) + self.numI = numpy.append(self.numI, numpy.transpose(I),axis=1) self.numA = numpy.append(self.numA, numpy.transpose(A),axis=1) self.numM = numpy.append(self.numM, numpy.transpose(M),axis=1) self.numCtot = numpy.append(self.numCtot, numpy.transpose(Ctot),axis=1) @@ -363,6 +379,7 @@ def run(self, T, checkpoints, dt=1, verbose=False): if(verbose): print("\t S = " + str(self.numS[:,-1])) print("\t E = " + str(self.numE[:,-1])) + print("\t I = " + str(self.numI[:,-1])) print("\t A = " + str(self.numA[:,-1])) print("\t M = " + str(self.numM[:,-1])) print("\t C = " + str(self.numC[:,-1])) @@ -372,6 +389,7 @@ def run(self, T, checkpoints, dt=1, verbose=False): print("\t D = " + str(self.numD[:,-1])) print("\t SQ = " + str(self.numSQ[:,-1])) print("\t EQ = " + str(self.numEQ[:,-1])) + print("\t IQ = " + str(self.numIQ[:,-1])) print("\t AQ = " + str(self.numAQ[:,-1])) print("\t MQ = " + str(self.numMQ[:,-1])) print("\t RQ = " + str(self.numRQ[:,-1])) @@ -392,6 +410,7 @@ def run(self, T, checkpoints, dt=1, verbose=False): if(verbose): print("\t S = " + str(self.numS[:,-1])) print("\t E = " + str(self.numE[:,-1])) + print("\t I = " + str(self.numI[:,-1])) print("\t A = " + str(self.numA[:,-1])) print("\t M = " + str(self.numM[:,-1])) print("\t C = " + str(self.numC[:,-1])) @@ -401,6 +420,7 @@ def run(self, T, checkpoints, dt=1, verbose=False): print("\t D = " + str(self.numD[:,-1])) print("\t SQ = " + str(self.numSQ[:,-1])) print("\t EQ = " + str(self.numEQ[:,-1])) + print("\t IQ = " + str(self.numIQ[:,-1])) print("\t AQ = " + str(self.numAQ[:,-1])) print("\t MQ = " + str(self.numMQ[:,-1])) print("\t RQ = " + str(self.numRQ[:,-1])) @@ -429,6 +449,7 @@ def sim(self, T, dt=1, checkpoints=None, verbose=False): # pre-allocate a 3D matrix for the raw results self.S = numpy.zeros([self.Nc.shape[0],tN,self.n_samples]) self.E = numpy.zeros([self.Nc.shape[0],tN,self.n_samples]) + self.I = numpy.zeros([self.Nc.shape[0],tN,self.n_samples]) self.A = numpy.zeros([self.Nc.shape[0],tN,self.n_samples]) self.M = numpy.zeros([self.Nc.shape[0],tN,self.n_samples]) self.C = numpy.zeros([self.Nc.shape[0],tN,self.n_samples]) @@ -441,12 +462,18 @@ def sim(self, T, dt=1, checkpoints=None, verbose=False): self.D = numpy.zeros([self.Nc.shape[0],tN,self.n_samples]) self.SQ = numpy.zeros([self.Nc.shape[0],tN,self.n_samples]) self.EQ = numpy.zeros([self.Nc.shape[0],tN,self.n_samples]) + self.IQ = numpy.zeros([self.Nc.shape[0],tN,self.n_samples]) self.AQ = numpy.zeros([self.Nc.shape[0],tN,self.n_samples]) self.MQ = numpy.zeros([self.Nc.shape[0],tN,self.n_samples]) self.RQ = numpy.zeros([self.Nc.shape[0],tN,self.n_samples]) + # total hospitalised + self.H = numpy.zeros([self.Nc.shape[0],tN,self.n_samples]) + # total infected + self.InfTot = numpy.zeros([self.Nc.shape[0],tN,self.n_samples]) # pre-allocate a 2D matrix for the results summed over all age bins self.sumS = numpy.zeros([tN,self.n_samples]) self.sumE = numpy.zeros([tN,self.n_samples]) + self.sumI = numpy.zeros([tN,self.n_samples]) self.sumA = numpy.zeros([tN,self.n_samples]) self.sumM = numpy.zeros([tN,self.n_samples]) self.sumC = numpy.zeros([tN,self.n_samples]) @@ -459,9 +486,14 @@ def sim(self, T, dt=1, checkpoints=None, verbose=False): self.sumD = numpy.zeros([tN,self.n_samples]) self.sumSQ = numpy.zeros([tN,self.n_samples]) self.sumEQ = numpy.zeros([tN,self.n_samples]) + self.sumIQ = numpy.zeros([tN,self.n_samples]) self.sumAQ = numpy.zeros([tN,self.n_samples]) self.sumMQ = numpy.zeros([tN,self.n_samples]) self.sumRQ = numpy.zeros([tN,self.n_samples]) + # total hospitalised + self.sumH = numpy.zeros([tN,self.n_samples]) + # total infected + self.sumInfTot = numpy.zeros([tN,self.n_samples]) # simulation loop i=0 for self.sigma in sigmavect: @@ -472,6 +504,7 @@ def sim(self, T, dt=1, checkpoints=None, verbose=False): # append raw results to 3D matrix self.S[:,:,i] = self.numS self.E[:,:,i] = self.numE + self.I[:,:,i] = self.numI self.A[:,:,i] = self.numA self.M[:,:,i] = self.numM self.C[:,:,i] = self.numC @@ -484,12 +517,18 @@ def sim(self, T, dt=1, checkpoints=None, verbose=False): self.D[:,:,i] = self.numD self.SQ[:,:,i] = self.numSQ self.EQ[:,:,i] = self.numEQ + self.IQ[:,:,i] = self.numIQ self.AQ[:,:,i] = self.numAQ self.MQ[:,:,i] = self.numMQ self.RQ[:,:,i] = self.numRQ + # total hospitalised + self.H[:,:,i] = self.numCtot + self.numMi + self.numICU + # total infected + self.InfTot[:,:,i] = self.numCtot + self.numMi + self.numICU + self.numI + self.numA + self.numM # convert raw results to sums of all age categories self.sumS[:,i] = self.numS.sum(axis=0) self.sumE[:,i] = self.numE.sum(axis=0) + self.sumI[:,i] = self.numI.sum(axis=0) self.sumA[:,i] = self.numA.sum(axis=0) self.sumM[:,i] = self.numM.sum(axis=0) self.sumC[:,i] = self.numC.sum(axis=0) @@ -502,9 +541,14 @@ def sim(self, T, dt=1, checkpoints=None, verbose=False): self.sumD[:,i] = self.numD.sum(axis=0) self.sumSQ[:,i] = self.numSQ.sum(axis=0) self.sumEQ[:,i] = self.numEQ.sum(axis=0) + self.sumIQ[:,i] = self.numIQ.sum(axis=0) self.sumAQ[:,i] = self.numAQ.sum(axis=0) self.sumMQ[:,i] = self.numMQ.sum(axis=0) self.sumRQ[:,i] = self.numRQ.sum(axis=0) + # total hospitalised + self.sumH[:,i] = self.numCtot.sum(axis=0) + self.numMi.sum(axis=0) + self.numICU.sum(axis=0) + # total infected + self.sumInfTot[:,i] = self.numCtot.sum(axis=0) + self.numMi.sum(axis=0) + self.numICU.sum(axis=0)+ self.numI.sum(axis=0) + self.numA.sum(axis=0) + self.numM.sum(axis=0) i = i + 1 return self @@ -521,9 +565,9 @@ def plotPopulationStatus(self,filename=None,getfig=False): ax.fill_between(self.tseries, numpy.percentile(self.sumS,90,axis=1), numpy.percentile(self.sumS,10,axis=1),color=black,alpha=0.2) ax.plot(self.tseries,numpy.mean(self.sumE,axis=1),color=orange) ax.fill_between(self.tseries, numpy.percentile(self.sumE,90,axis=1), numpy.percentile(self.sumE,10,axis=1),color=orange,alpha=0.2) - I = self.sumA + self.sumM + self.sumCtot + self.sumMi + self.sumICU - ax.plot(self.tseries,numpy.mean(I,axis=1),color=red) - ax.fill_between(self.tseries, numpy.percentile(I,90,axis=1), numpy.percentile(I,10,axis=1),color=red,alpha=0.2) + #I = self.sumA + self.sumM + self.sumCtot + self.sumMi + self.sumICU + ax.plot(self.tseries,numpy.mean(self.sumInfTot,axis=1),color=red) + ax.fill_between(self.tseries, numpy.percentile(self.sumInfTot,90,axis=1), numpy.percentile(self.sumInfTot,10,axis=1),color=red,alpha=0.2) ax.plot(self.tseries,numpy.mean(self.sumR,axis=1),color=green) ax.fill_between(self.tseries, numpy.percentile(self.sumR,90,axis=1), numpy.percentile(self.sumR,10,axis=1),color=green,alpha=0.2) ax.legend(('susceptible','exposed','total infected','immune'), loc="upper left", bbox_to_anchor=(1,1)) @@ -556,9 +600,9 @@ def plotInfected(self,asymptomatic=False,mild=False,filename=None,getfig=False): if mild is not False: ax.plot(self.tseries,numpy.mean(self.sumM,axis=1),color=green) ax.fill_between(self.tseries, numpy.percentile(self.sumM,90,axis=1), numpy.percentile(self.sumM,10,axis=1),color=green,alpha=0.2) - H = self.sumCtot + self.sumMi + self.sumICU - ax.plot(self.tseries,numpy.mean(H,axis=1),color=orange) - ax.fill_between(self.tseries, numpy.percentile(H,90,axis=1), numpy.percentile(H,10,axis=1),color=orange,alpha=0.2) + #H = self.sumCtot + self.sumMi + self.sumICU + ax.plot(self.tseries,numpy.mean(self.sumH,axis=1),color=orange) + ax.fill_between(self.tseries, numpy.percentile(self.sumH,90,axis=1), numpy.percentile(self.sumH,10,axis=1),color=orange,alpha=0.2) icu = self.sumMi + self.sumICU ax.plot(self.tseries,numpy.mean(icu,axis=1),color=red) ax.fill_between(self.tseries, numpy.percentile(icu,90,axis=1), numpy.percentile(icu,10,axis=1),color=red,alpha=0.2) @@ -746,6 +790,7 @@ def plotFit(self,index,data,positions,dataMkr=['o','v','s','*','^'],modelClr=['g def passInitial(self): self.initE = numpy.reshape(numpy.mean(self.E[:,-1,:],axis=1),[self.Nc.shape[0],1]) + self.initI = numpy.reshape(numpy.mean(self.I[:,-1,:],axis=1),[self.Nc.shape[0],1]) self.initA = numpy.reshape(numpy.mean(self.A[:,-1,:],axis=1),[self.Nc.shape[0],1]) self.initM = numpy.reshape(numpy.mean(self.M[:,-1,:],axis=1),[self.Nc.shape[0],1]) self.initC = numpy.reshape(numpy.mean(self.C[:,-1,:],axis=1),[self.Nc.shape[0],1]) @@ -757,6 +802,7 @@ def passInitial(self): self.initD = numpy.reshape(numpy.mean(self.D[:,-1,:],axis=1),[self.Nc.shape[0],1]) self.initSQ = numpy.reshape(numpy.mean(self.SQ[:,-1,:],axis=1),[self.Nc.shape[0],1]) self.initEQ = numpy.reshape(numpy.mean(self.EQ[:,-1,:],axis=1),[self.Nc.shape[0],1]) + self.initIQ = numpy.reshape(numpy.mean(self.IQ[:,-1,:],axis=1),[self.Nc.shape[0],1]) self.initAQ = numpy.reshape(numpy.mean(self.AQ[:,-1,:],axis=1),[self.Nc.shape[0],1]) self.initMQ = numpy.reshape(numpy.mean(self.MQ[:,-1,:],axis=1),[self.Nc.shape[0],1]) self.initRQ = numpy.reshape(numpy.mean(self.RQ[:,-1,:],axis=1),[self.Nc.shape[0],1]) @@ -1250,9 +1296,9 @@ class SEIRSNetworkModel(): Params: G Network adjacency matrix (numpy array) or Networkx graph object. EXTEND LIST """ - def __init__(self, G, beta, sigma, initN,zeta=0, p=0,a=0, m=0, h=0, c=0, mi = 0, da=0, dm=0, dc=0, dmi=0, dICU=0, dICUrec=0, dmirec=0,dhospital=0, m0=0, - maxICU=0,theta_S=0, theta_E=0, theta_A=0, theta_M=0, theta_R=0,phi_S=0, phi_E=0, phi_A=0, phi_M = 0, phi_R=0,psi_FP=0, psi_PP=0,dq=0,initE=10, initA=0, - initM=0, initC=0, initCmirec=0, initCicurec=0, initMi = 0, initICU = 0, initR=0, initD=0,initSQ=0, initEQ=0, initAQ=0, initMQ=0, initRQ=0, + def __init__(self, G, beta, sigma, omega, initN,zeta=0, p=0,a=0, m=0, h=0, c=0, mi = 0, da=0, dm=0, dc=0, dmi=0, dICU=0, dICUrec=0, dmirec=0,dhospital=0, m0=0, + maxICU=0,theta_S=0, theta_E=0, theta_I=0, theta_A=0, theta_M=0, theta_R=0, phi_S=0, phi_E=0, phi_I=0, phi_A=0, phi_M = 0, phi_R=0,psi_FP=0, psi_PP=0,dq=0,initE=1, initI = 0, initA=0, + initM=0, initC=0, initCmirec=0, initCicurec=0, initMi = 0, initICU = 0, initR=0, initD=0,initSQ=0, initEQ=0, initIQ=0, initAQ=0, initMQ=0, initRQ=0, monteCarlo=False,repeats=1,node_groups=None): @@ -1265,6 +1311,7 @@ def __init__(self, G, beta, sigma, initN,zeta=0, p=0,a=0, m=0, h=0, c=0, mi = 0, # Initiate Model Parameters: #~~~~~~~~~~~~~~~~~~~~~~~~~~~ self.beta = numpy.array(beta).reshape((self.numNodes, 1)) if isinstance(beta, (list, numpy.ndarray)) else numpy.full(fill_value=beta, shape=(self.numNodes,1)) + self.omega = numpy.array(sigma).reshape((self.numNodes, 1)) if isinstance(omega, (list, numpy.ndarray)) else numpy.full(fill_value=omega, shape=(self.numNodes,1)) self.zeta = numpy.array(zeta).reshape((self.numNodes, 1)) if isinstance(zeta, (list, numpy.ndarray)) else numpy.full(fill_value=zeta, shape=(self.numNodes,1)) self.p = numpy.array(p).reshape((self.numNodes, 1)) if isinstance(p, (list, numpy.ndarray)) else numpy.full(fill_value=p, shape=(self.numNodes,1)) self.a = numpy.array(a).reshape((self.numNodes, 1)) if isinstance(a, (list, numpy.ndarray)) else numpy.full(fill_value=a, shape=(self.numNodes,1)) @@ -1284,11 +1331,13 @@ def __init__(self, G, beta, sigma, initN,zeta=0, p=0,a=0, m=0, h=0, c=0, mi = 0, self.maxICU = numpy.array(maxICU).reshape((self.numNodes, 1)) if isinstance(maxICU, (list, numpy.ndarray)) else numpy.full(fill_value=maxICU, shape=(self.numNodes,1)) self.theta_S = numpy.array(theta_S).reshape((self.numNodes, 1)) if isinstance(theta_S, (list, numpy.ndarray)) else numpy.full(fill_value=theta_S, shape=(self.numNodes,1)) self.theta_E = numpy.array(theta_E).reshape((self.numNodes, 1)) if isinstance(theta_E, (list, numpy.ndarray)) else numpy.full(fill_value=theta_E, shape=(self.numNodes,1)) + self.theta_I = numpy.array(theta_I).reshape((self.numNodes, 1)) if isinstance(theta_I, (list, numpy.ndarray)) else numpy.full(fill_value=theta_I, shape=(self.numNodes,1)) self.theta_A = numpy.array(theta_A).reshape((self.numNodes, 1)) if isinstance(theta_A, (list, numpy.ndarray)) else numpy.full(fill_value=theta_A, shape=(self.numNodes,1)) self.theta_M = numpy.array(theta_M).reshape((self.numNodes, 1)) if isinstance(theta_M, (list, numpy.ndarray)) else numpy.full(fill_value=theta_M, shape=(self.numNodes,1)) self.theta_R = numpy.array(theta_R).reshape((self.numNodes, 1)) if isinstance(theta_R, (list, numpy.ndarray)) else numpy.full(fill_value=theta_R, shape=(self.numNodes,1)) self.phi_S = numpy.array(phi_S).reshape((self.numNodes, 1)) if isinstance(phi_S, (list, numpy.ndarray)) else numpy.full(fill_value=phi_S, shape=(self.numNodes,1)) self.phi_E = numpy.array(phi_E).reshape((self.numNodes, 1)) if isinstance(phi_E, (list, numpy.ndarray)) else numpy.full(fill_value=phi_E, shape=(self.numNodes,1)) + self.phi_I = numpy.array(phi_I).reshape((self.numNodes, 1)) if isinstance(phi_I, (list, numpy.ndarray)) else numpy.full(fill_value=phi_I, shape=(self.numNodes,1)) self.phi_A = numpy.array(phi_A).reshape((self.numNodes, 1)) if isinstance(phi_A, (list, numpy.ndarray)) else numpy.full(fill_value=phi_A, shape=(self.numNodes,1)) self.phi_M = numpy.array(phi_M).reshape((self.numNodes, 1)) if isinstance(phi_M, (list, numpy.ndarray)) else numpy.full(fill_value=phi_M, shape=(self.numNodes,1)) self.phi_R = numpy.array(phi_R).reshape((self.numNodes, 1)) if isinstance(phi_R, (list, numpy.ndarray)) else numpy.full(fill_value=phi_R, shape=(self.numNodes,1)) @@ -1318,6 +1367,7 @@ def __init__(self, G, beta, sigma, initN,zeta=0, p=0,a=0, m=0, h=0, c=0, mi = 0, self.N = numpy.zeros(5*self.numNodes) self.numS = numpy.zeros(5*self.numNodes) self.numE = numpy.zeros(5*self.numNodes) + self.numI = numpy.zeros(5*self.numNodes) self.numA = numpy.zeros(5*self.numNodes) self.numM = numpy.zeros(5*self.numNodes) self.numC = numpy.zeros(5*self.numNodes) @@ -1329,6 +1379,7 @@ def __init__(self, G, beta, sigma, initN,zeta=0, p=0,a=0, m=0, h=0, c=0, mi = 0, self.numD = numpy.zeros(5*self.numNodes) self.numSQ = numpy.zeros(5*self.numNodes) self.numEQ = numpy.zeros(5*self.numNodes) + self.numIQ = numpy.zeros(5*self.numNodes) self.numAQ = numpy.zeros(5*self.numNodes) self.numMQ = numpy.zeros(5*self.numNodes) self.numRQ = numpy.zeros(5*self.numNodes) @@ -1345,6 +1396,7 @@ def __init__(self, G, beta, sigma, initN,zeta=0, p=0,a=0, m=0, h=0, c=0, mi = 0, # initial condition must be an attribute of class: WAS NOT ADDED ORIGINALLY # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ self.initE = initE + self.initI = initI self.initA = initA self.initM = initM self.initC = initC @@ -1356,6 +1408,7 @@ def __init__(self, G, beta, sigma, initN,zeta=0, p=0,a=0, m=0, h=0, c=0, mi = 0, self.initD = initD self.initSQ = initSQ self.initEQ = initEQ + self.initIQ = initIQ self.initAQ = initAQ self.initMQ = initMQ self.initRQ = initRQ @@ -1365,6 +1418,7 @@ def __init__(self, G, beta, sigma, initN,zeta=0, p=0,a=0, m=0, h=0, c=0, mi = 0, #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ self.numE[0] = int(initE) + self.numI[0] = int(initI) self.numA[0] = int(initA) self.numM[0] = int(initM) self.numC[0] = int(initC) @@ -1376,42 +1430,46 @@ def __init__(self, G, beta, sigma, initN,zeta=0, p=0,a=0, m=0, h=0, c=0, mi = 0, self.numD[0] = int(initD) self.numSQ[0] = int(initSQ) self.numEQ[0] = int(initEQ) + self.numIQ[0] = int(initIQ) self.numAQ[0] = int(initAQ) self.numMQ[0] = int(initMQ) self.numRQ[0] = int(initRQ) - self.numS[0] = self.numNodes - self.numE[0] - self.numA[0] - self.numM[0] - self.numC[0] - self.numCmirec[0] - self.numCicurec[0] - self.numMi[0] - self.numICU[0]- self.numSQ[0] - self.numEQ[0] - self.numAQ[0] - self.numMQ[0]- self.numRQ[0]- self.numR[0] - self.numD[0] - self.N[0] = self.numS[0] + self.numE[0] + self.numA[0] + self.numM[0] + self.numC[0] + self.numCmirec[0] + self.numCicurec[0] + self.numSQ[0] + self.numEQ[0] + self.numAQ[0] + self.numMQ[0] + self.numRQ[0] + self.numR[0] + self.numS[0] = self.numNodes - self.numE[0] - self.numI[0] - self.numA[0] - self.numM[0] - self.numC[0] - self.numCmirec[0] - self.numCicurec[0] - self.numMi[0] - self.numICU[0] - self.numSQ[0] - self.numEQ[0] - self.numIQ[0] - self.numAQ[0] - self.numMQ[0]- self.numRQ[0]- self.numR[0] - self.numD[0] + self.N[0] = self.numS[0] + self.numE[0] + self.numI[0] + self.numA[0] + self.numM[0] + self.numC[0] + self.numCmirec[0] + self.numCicurec[0] + self.numSQ[0] + self.numEQ[0] + self.numIQ[0] + self.numAQ[0] + self.numMQ[0] + self.numRQ[0] + self.numR[0] #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Node states: #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ self.S = 1 self.E = 2 - self.A = 3 - self.M = 4 - self.C = 5 - self.Cmirec = 6 - self.Cicurec= 7 - self.Mi = 8 - self.ICU = 9 - self.SQ = 10 - self.EQ = 11 - self.AQ = 12 - self.MQ = 13 - self.RQ = 14 - self.R = 15 - self.D = 16 - self.X = numpy.array([self.S]*int(self.numS[0]) + [self.E]*int(self.numE[0]) + [self.A]*int(self.numA[0]) + [self.M]*int(self.numM[0]) + self.I = 3 + self.A = 4 + self.M = 5 + self.C = 6 + self.Cmirec = 7 + self.Cicurec= 8 + self.Mi = 9 + self.ICU = 10 + self.SQ = 11 + self.EQ = 12 + self.IQ = 13 + self.AQ = 14 + self.MQ = 15 + self.RQ = 16 + self.R = 17 + self.D = 18 + self.X = numpy.array([self.S]*int(self.numS[0]) + [self.E]*int(self.numE[0]) + [self.I]*int(self.numI[0]) + [self.A]*int(self.numA[0]) + [self.M]*int(self.numM[0]) + [self.C]*int(self.numC[0]) + [self.Cmirec]*int(self.numCmirec[0]) + [self.Cicurec]*int(self.numCicurec[0])+ [self.Mi]*int(self.numMi[0]) - + [self.ICU]*int(self.numICU[0]) + [self.SQ]*int(self.numSQ[0]) + [self.EQ]*int(self.numEQ[0]) + [self.AQ]*int(self.numAQ[0]) + + [self.ICU]*int(self.numICU[0]) + [self.SQ]*int(self.numSQ[0]) + [self.EQ]*int(self.numEQ[0]) + [self.IQ]*int(self.numIQ[0])+ [self.AQ]*int(self.numAQ[0]) + [self.MQ]*int(self.numMQ[0]) + [self.RQ]*int(self.numRQ[0]) + [self.R]*int(self.numR[0]) + [self.D]*int(self.numD[0])).reshape((self.numNodes,1)) numpy.random.shuffle(self.X) self.transitions = { 'StoE': {'currentState':self.S, 'newState':self.E}, - 'EtoA': {'currentState':self.E, 'newState':self.A}, - 'EtoM': {'currentState':self.E, 'newState':self.M}, + 'EtoI': {'currentState':self.E, 'newState':self.I}, + 'ItoA': {'currentState':self.I, 'newState':self.A}, + 'ItoM': {'currentState':self.I, 'newState':self.M}, 'MtoC': {'currentState':self.M, 'newState':self.C}, 'MtoMi': {'currentState':self.M, 'newState':self.Mi}, 'MtoICU': {'currentState':self.M, 'newState':self.ICU}, @@ -1424,13 +1482,15 @@ def __init__(self, G, beta, sigma, initN,zeta=0, p=0,a=0, m=0, h=0, c=0, mi = 0, 'CmirectoR': {'currentState':self.Cmirec, 'newState':self.R}, 'CicurectoR': {'currentState':self.Cicurec, 'newState':self.R}, 'StoSQ': {'currentState':self.S, 'newState':self.SQ}, + 'ItoIQ': {'currentState':self.I, 'newState':self.IQ}, 'EtoEQ': {'currentState':self.E, 'newState':self.EQ}, 'AtoAQ': {'currentState':self.A, 'newState':self.AQ}, 'MtoMQ': {'currentState':self.M, 'newState':self.MQ}, 'RtoRQ': {'currentState':self.R, 'newState':self.RQ}, 'SQtoS': {'currentState':self.SQ, 'newState':self.S}, - 'EQtoAQ': {'currentState':self.EQ, 'newState':self.AQ}, - 'EQtoMQ': {'currentState':self.EQ, 'newState':self.MQ}, + 'EQtoIQ': {'currentState':self.EQ, 'newState':self.IQ}, + 'IQtoAQ': {'currentState':self.IQ, 'newState':self.AQ}, + 'IQtoMQ': {'currentState':self.IQ, 'newState':self.MQ}, 'MQtoC': {'currentState':self.MQ, 'newState':self.C}, 'MQtoMi': {'currentState':self.MQ, 'newState':self.Mi}, 'MQtoICU': {'currentState':self.MQ, 'newState':self.ICU}, @@ -1452,6 +1512,7 @@ def __init__(self, G, beta, sigma, initN,zeta=0, p=0,a=0, m=0, h=0, c=0, mi = 0, 'mask': numpy.isin(range(self.numNodes), nodeList).reshape((self.numNodes,1))} self.nodeGroupData[groupName]['numS'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numE'] = numpy.zeros(5*self.numNodes) + self.nodeGroupData[groupName]['numI'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numA'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numM'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numC'] = numpy.zeros(5*self.numNodes) @@ -1461,6 +1522,7 @@ def __init__(self, G, beta, sigma, initN,zeta=0, p=0,a=0, m=0, h=0, c=0, mi = 0, self.nodeGroupData[groupName]['numICU'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numSQ'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numEQ'] = numpy.zeros(5*self.numNodes) + self.nodeGroupData[groupName]['numIQ'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numAQ'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numMQ'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numRQ'] = numpy.zeros(5*self.numNodes) @@ -1470,6 +1532,7 @@ def __init__(self, G, beta, sigma, initN,zeta=0, p=0,a=0, m=0, h=0, c=0, mi = 0, self.nodeGroupData[groupName]['numS'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.S) self.nodeGroupData[groupName]['numE'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.E) + self.nodeGroupData[groupName]['numI'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.I) self.nodeGroupData[groupName]['numA'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.A) self.nodeGroupData[groupName]['numM'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.M) self.nodeGroupData[groupName]['numC'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.C) @@ -1479,17 +1542,16 @@ def __init__(self, G, beta, sigma, initN,zeta=0, p=0,a=0, m=0, h=0, c=0, mi = 0, self.nodeGroupData[groupName]['numICU'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.ICU) self.nodeGroupData[groupName]['numSQ'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.SQ) self.nodeGroupData[groupName]['numEQ'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.EQ) + self.nodeGroupData[groupName]['numIQ'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.IQ) self.nodeGroupData[groupName]['numAQ'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.AQ) self.nodeGroupData[groupName]['numMQ'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.MQ) self.nodeGroupData[groupName]['numRQ'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.RQ) self.nodeGroupData[groupName]['numR'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.R) self.nodeGroupData[groupName]['numD'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.D) - self.nodeGroupData[groupName]['N'][0] = self.nodeGroupData[groupName]['numS'][0] + self.nodeGroupData[groupName]['numE'][0] - + self.nodeGroupData[groupName]['numA'][0] + self.nodeGroupData[groupName]['numM'][0] + self.nodeGroupData[groupName]['numC'][0] - + self.nodeGroupData[groupName]['numCmirec'][0] + self.nodeGroupData[groupName]['numCicurec'][0] + self.nodeGroupData[groupName]['numMi'][0] - + self.nodeGroupData[groupName]['numICU'][0] + self.nodeGroupData[groupName]['numSQ'][0] + self.nodeGroupData[groupName]['numEQ'][0] - + self.nodeGroupData[groupName]['numAQ'][0] + self.nodeGroupData[groupName]['numMQ'][0] + self.nodeGroupData[groupName]['numRQ'][0] - + self.nodeGroupData[groupName]['numR'][0] + self.nodeGroupData[groupName]['N'][0] = self.nodeGroupData[groupName]['numS'][0] + self.nodeGroupData[groupName]['numE'][0] + self.nodeGroupData[groupName]['numI'][0] + + self.nodeGroupData[groupName]['numA'][0] + self.nodeGroupData[groupName]['numM'][0] + self.nodeGroupData[groupName]['numC'][0] + self.nodeGroupData[groupName]['numCmirec'][0] + self.nodeGroupData[groupName]['numCicurec'][0] + self.nodeGroupData[groupName]['numMi'][0] + + self.nodeGroupData[groupName]['numICU'][0] + self.nodeGroupData[groupName]['numSQ'][0] + self.nodeGroupData[groupName]['numEQ'][0] + self.nodeGroupData[groupName]['numIQ'][0] + + self.nodeGroupData[groupName]['numAQ'][0] + self.nodeGroupData[groupName]['numMQ'][0] + self.nodeGroupData[groupName]['numRQ'][0] + self.nodeGroupData[groupName]['numR'][0] #^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ #^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -1507,6 +1569,7 @@ def reset(self): self.N = numpy.zeros(5*self.numNodes) self.numS = numpy.zeros(5*self.numNodes) self.numE = numpy.zeros(5*self.numNodes) + self.numI = numpy.zeros(5*self.numNodes) self.numA = numpy.zeros(5*self.numNodes) self.numM = numpy.zeros(5*self.numNodes) self.numC = numpy.zeros(5*self.numNodes) @@ -1518,6 +1581,7 @@ def reset(self): self.numD = numpy.zeros(5*self.numNodes) self.numSQ = numpy.zeros(5*self.numNodes) self.numEQ = numpy.zeros(5*self.numNodes) + self.numIQ = numpy.zeros(5*self.numNodes) self.numAQ = numpy.zeros(5*self.numNodes) self.numMQ = numpy.zeros(5*self.numNodes) self.numRQ = numpy.zeros(5*self.numNodes) @@ -1534,6 +1598,7 @@ def reset(self): # Initialize Counts of inidividuals with each state: #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ self.numE[0] = int(self.initE) + self.numI[0] = int(self.initI) self.numA[0] = int(self.initA) self.numM[0] = int(self.initM) self.numC[0] = int(self.initC) @@ -1545,41 +1610,46 @@ def reset(self): self.numD[0] = int(self.initD) self.numSQ[0] = int(self.initSQ) self.numEQ[0] = int(self.initEQ) + self.numIQ[0] = int(self.initIQ) self.numAQ[0] = int(self.initAQ) self.numMQ[0] = int(self.initMQ) self.numRQ[0] = int(self.initRQ) - self.numS[0] = self.numNodes - self.numE[0] - self.numA[0] - self.numM[0] - self.numC[0] - self.numCmirec[0] - self.numCicurec[0] - self.numMi[0] - self.numICU[0]- self.numSQ[0] - self.numEQ[0] - self.numAQ[0] - self.numMQ[0]- self.numRQ[0]- self.numR[0] - self.numD[0] - self.N[0] = self.numS[0] + self.numE[0] + self.numA[0] + self.numM[0] + self.numC[0] + self.numCmirec[0] + self.numCicurec[0] + self.numSQ[0] + self.numEQ[0] + self.numAQ[0] + self.numMQ[0] + self.numRQ[0] + self.numR[0] + self.numS[0] = self.numNodes - self.numE[0] - self.numI[0] - self.numA[0] - self.numM[0] - self.numC[0] - self.numCmirec[0] - self.numCicurec[0] - self.numMi[0] - self.numICU[0]- self.numSQ[0] - self.numEQ[0] - self.numIQ[0] - self.numAQ[0] - self.numMQ[0]- self.numRQ[0]- self.numR[0] - self.numD[0] + self.N[0] = self.numS[0] + self.numE[0] + self.numI[0] + self.numA[0] + self.numM[0] + self.numC[0] + self.numCmirec[0] + self.numCicurec[0] + self.numSQ[0] + self.numEQ[0] + self.numIQ[0] + self.numAQ[0] + self.numMQ[0] + self.numRQ[0] + self.numR[0] + #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Node states: #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ self.S = 1 self.E = 2 - self.A = 3 - self.M = 4 - self.C = 5 - self.Cmirec = 6 - self.Cicurec= 7 - self.Mi = 8 - self.ICU = 9 - self.SQ = 10 - self.EQ = 11 - self.AQ = 12 - self.MQ = 13 - self.RQ = 14 - self.R = 15 - self.D = 16 - self.X = numpy.array([self.S]*int(self.numS[0]) + [self.E]*int(self.numE[0]) + [self.A]*int(self.numA[0]) + [self.M]*int(self.numM[0]) + self.I = 3 + self.A = 4 + self.M = 5 + self.C = 6 + self.Cmirec = 7 + self.Cicurec= 8 + self.Mi = 9 + self.ICU = 10 + self.SQ = 11 + self.EQ = 12 + self.IQ = 13 + self.AQ = 14 + self.MQ = 15 + self.RQ = 16 + self.R = 17 + self.D = 18 + self.X = numpy.array([self.S]*int(self.numS[0]) + [self.E]*int(self.numE[0]) + [self.I]*int(self.numI[0]) + [self.A]*int(self.numA[0]) + [self.M]*int(self.numM[0]) + [self.C]*int(self.numC[0]) + [self.Cmirec]*int(self.numCmirec[0]) + [self.Cicurec]*int(self.numCicurec[0])+ [self.Mi]*int(self.numMi[0]) - + [self.ICU]*int(self.numICU[0]) + [self.SQ]*int(self.numSQ[0]) + [self.EQ]*int(self.numEQ[0]) + [self.AQ]*int(self.numAQ[0]) + + [self.ICU]*int(self.numICU[0]) + [self.SQ]*int(self.numSQ[0]) + [self.EQ]*int(self.numEQ[0]) + [self.IQ]*int(self.numIQ[0])+ [self.AQ]*int(self.numAQ[0]) + [self.MQ]*int(self.numMQ[0]) + [self.RQ]*int(self.numRQ[0]) + [self.R]*int(self.numR[0]) + [self.D]*int(self.numD[0])).reshape((self.numNodes,1)) numpy.random.shuffle(self.X) self.transitions = { 'StoE': {'currentState':self.S, 'newState':self.E}, - 'EtoA': {'currentState':self.E, 'newState':self.A}, - 'EtoM': {'currentState':self.E, 'newState':self.M}, + 'EtoI': {'currentState':self.E, 'newState':self.I}, + 'ItoA': {'currentState':self.I, 'newState':self.A}, + 'ItoM': {'currentState':self.I, 'newState':self.M}, 'MtoC': {'currentState':self.M, 'newState':self.C}, 'MtoMi': {'currentState':self.M, 'newState':self.Mi}, 'MtoICU': {'currentState':self.M, 'newState':self.ICU}, @@ -1592,13 +1662,15 @@ def reset(self): 'CmirectoR': {'currentState':self.Cmirec, 'newState':self.R}, 'CicurectoR': {'currentState':self.Cicurec, 'newState':self.R}, 'StoSQ': {'currentState':self.S, 'newState':self.SQ}, + 'ItoIQ': {'currentState':self.I, 'newState':self.IQ}, 'EtoEQ': {'currentState':self.E, 'newState':self.EQ}, 'AtoAQ': {'currentState':self.A, 'newState':self.AQ}, 'MtoMQ': {'currentState':self.M, 'newState':self.MQ}, 'RtoRQ': {'currentState':self.R, 'newState':self.RQ}, 'SQtoS': {'currentState':self.SQ, 'newState':self.S}, - 'EQtoAQ': {'currentState':self.EQ, 'newState':self.AQ}, - 'EQtoMQ': {'currentState':self.EQ, 'newState':self.MQ}, + 'EQtoIQ': {'currentState':self.EQ, 'newState':self.IQ}, + 'IQtoAQ': {'currentState':self.IQ, 'newState':self.AQ}, + 'IQtoMQ': {'currentState':self.IQ, 'newState':self.MQ}, 'MQtoC': {'currentState':self.MQ, 'newState':self.C}, 'MQtoMi': {'currentState':self.MQ, 'newState':self.Mi}, 'MQtoICU': {'currentState':self.MQ, 'newState':self.ICU}, @@ -1620,6 +1692,7 @@ def reset(self): 'mask': numpy.isin(range(self.numNodes), nodeList).reshape((self.numNodes,1))} self.nodeGroupData[groupName]['numS'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numE'] = numpy.zeros(5*self.numNodes) + self.nodeGroupData[groupName]['numI'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numA'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numM'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numC'] = numpy.zeros(5*self.numNodes) @@ -1629,6 +1702,7 @@ def reset(self): self.nodeGroupData[groupName]['numICU'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numSQ'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numEQ'] = numpy.zeros(5*self.numNodes) + self.nodeGroupData[groupName]['numIQ'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numAQ'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numMQ'] = numpy.zeros(5*self.numNodes) self.nodeGroupData[groupName]['numRQ'] = numpy.zeros(5*self.numNodes) @@ -1638,6 +1712,7 @@ def reset(self): self.nodeGroupData[groupName]['numS'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.S) self.nodeGroupData[groupName]['numE'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.E) + self.nodeGroupData[groupName]['numI'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.I) self.nodeGroupData[groupName]['numA'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.A) self.nodeGroupData[groupName]['numM'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.M) self.nodeGroupData[groupName]['numC'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.C) @@ -1647,17 +1722,16 @@ def reset(self): self.nodeGroupData[groupName]['numICU'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.ICU) self.nodeGroupData[groupName]['numSQ'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.SQ) self.nodeGroupData[groupName]['numEQ'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.EQ) + self.nodeGroupData[groupName]['numIQ'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.IQ) self.nodeGroupData[groupName]['numAQ'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.AQ) self.nodeGroupData[groupName]['numMQ'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.MQ) self.nodeGroupData[groupName]['numRQ'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.RQ) self.nodeGroupData[groupName]['numR'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.R) self.nodeGroupData[groupName]['numD'][0] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.D) - self.nodeGroupData[groupName]['N'][0] = self.nodeGroupData[groupName]['numS'][0] + self.nodeGroupData[groupName]['numE'][0] - + self.nodeGroupData[groupName]['numA'][0] + self.nodeGroupData[groupName]['numM'][0] + self.nodeGroupData[groupName]['numC'][0] - + self.nodeGroupData[groupName]['numCmirec'][0] + self.nodeGroupData[groupName]['numCicurec'][0] + self.nodeGroupData[groupName]['numMi'][0] - + self.nodeGroupData[groupName]['numICU'][0] + self.nodeGroupData[groupName]['numSQ'][0] + self.nodeGroupData[groupName]['numEQ'][0] - + self.nodeGroupData[groupName]['numAQ'][0] + self.nodeGroupData[groupName]['numMQ'][0] + self.nodeGroupData[groupName]['numRQ'][0] - + self.nodeGroupData[groupName]['numR'][0] + self.nodeGroupData[groupName]['N'][0] = self.nodeGroupData[groupName]['numS'][0] + self.nodeGroupData[groupName]['numE'][0] + self.nodeGroupData[groupName]['numI'][0] + + self.nodeGroupData[groupName]['numA'][0] + self.nodeGroupData[groupName]['numM'][0] + self.nodeGroupData[groupName]['numC'][0] + self.nodeGroupData[groupName]['numCmirec'][0] + self.nodeGroupData[groupName]['numCicurec'][0] + self.nodeGroupData[groupName]['numMi'][0] + + self.nodeGroupData[groupName]['numICU'][0] + self.nodeGroupData[groupName]['numSQ'][0] + self.nodeGroupData[groupName]['numEQ'][0] + self.nodeGroupData[groupName]['numIQ'][0] + + self.nodeGroupData[groupName]['numAQ'][0] + self.nodeGroupData[groupName]['numMQ'][0] + self.nodeGroupData[groupName]['numRQ'][0] + self.nodeGroupData[groupName]['numR'][0] #^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ #^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -1700,6 +1774,11 @@ def calc_propensities(self): and numpy.any(self.beta!=0)): numContacts_E = numpy.asarray( scipy.sparse.csr_matrix.dot(self.Adj, self.X==self.E) ) + numContacts_I = numpy.zeros(shape=(self.numNodes,1)) + if(numpy.any(self.numI[self.tidx]) + and numpy.any(self.beta!=0)): + numContacts_I = numpy.asarray( scipy.sparse.csr_matrix.dot(self.Adj, self.X==self.I) ) + numContacts_SQ = numpy.zeros(shape=(self.numNodes,1)) if(numpy.any(self.numSQ[self.tidx]) and numpy.any(self.beta!=0)): @@ -1710,6 +1789,11 @@ def calc_propensities(self): and numpy.any(self.beta!=0)): numContacts_EQ = numpy.asarray( scipy.sparse.csr_matrix.dot(self.Adj, self.X==self.EQ) ) + numContacts_IQ = numpy.zeros(shape=(self.numNodes,1)) + if(numpy.any(self.numIQ[self.tidx]) + and numpy.any(self.beta!=0)): + numContacts_IQ = numpy.asarray( scipy.sparse.csr_matrix.dot(self.Adj, self.X==self.IQ) ) + numContacts_AQ = numpy.zeros(shape=(self.numNodes,1)) if(numpy.any(self.numAQ[self.tidx]) and numpy.any(self.beta!=0)): @@ -1751,11 +1835,12 @@ def calc_propensities(self): numContacts_Mi = numpy.asarray( scipy.sparse.csr_matrix.dot(self.Adj, self.X==self.Mi) ) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - propensities_StoE = ( self.p*((self.beta*(self.numE[self.tidx]+self.numA[self.tidx]) )/self.N[self.tidx]) - + (1-self.p)*numpy.divide((self.beta*(numContacts_E + numContacts_A)), self.degree, out=numpy.zeros_like(self.degree), where=self.degree!=0) + propensities_StoE = ( self.p*((self.beta*(self.numI[self.tidx]+self.numA[self.tidx]) )/self.N[self.tidx]) + + (1-self.p)*numpy.divide((self.beta*(numContacts_I + numContacts_A)), self.degree, out=numpy.zeros_like(self.degree), where=self.degree!=0) )*(self.X==self.S) - propensities_EtoA = (self.a/self.sigma)*(self.X==self.E) - propensities_EtoM = (self.m/self.sigma)*(self.X==self.E) + propensities_EtoI = (1/self.sigma)*(self.X==self.E) + propensities_ItoA = (self.a/self.omega)*(self.X==self.I) + propensities_ItoM = (self.m/self.omega)*(self.X==self.I) propensities_MtoC = (self.h*self.c/self.dhospital)*(self.X==self.M) propensities_MtoMi = (self.h*self.mi/self.dhospital)*(self.X==self.M) propensities_MtoICU = self.h*((1-self.c-self.mi)/self.dhospital)*(self.X==self.M) @@ -1767,14 +1852,16 @@ def calc_propensities(self): propensities_CtoR = (1/self.dc)*(self.X==self.C) propensities_CmirectoR = (1/self.dmirec)*(self.X==self.Cmirec) propensities_CicurectoR = (1/self.dICUrec)*(self.X==self.Cicurec) - propensities_StoSQ = (self.theta_S + self.phi_S*(numContacts_SQ + numContacts_EQ+ numContacts_AQ + numContacts_MQ + numContacts_RQ + numContacts_C + numContacts_Mi + numContacts_ICU + numContacts_Cmirec + numContacts_Cicurec))*self.psi_FP*(self.X==self.S) - propensities_EtoEQ = (self.theta_E + self.phi_E*(numContacts_SQ + numContacts_EQ+ numContacts_AQ + numContacts_MQ + numContacts_RQ + numContacts_C + numContacts_Mi + numContacts_ICU + numContacts_Cmirec + numContacts_Cicurec))*self.psi_PP*(self.X==self.E) - propensities_AtoAQ = (self.theta_A + self.phi_A*(numContacts_SQ + numContacts_EQ+ numContacts_AQ + numContacts_MQ + numContacts_RQ + numContacts_C + numContacts_Mi + numContacts_ICU + numContacts_Cmirec + numContacts_Cicurec))*self.psi_PP*(self.X==self.A) - propensities_MtoMQ = (self.theta_M + self.phi_M*(numContacts_SQ + numContacts_EQ+ numContacts_AQ + numContacts_MQ + numContacts_RQ + numContacts_C + numContacts_Mi + numContacts_ICU + numContacts_Cmirec + numContacts_Cicurec))*self.psi_PP*(self.X==self.M) - propensities_RtoRQ = (self.theta_R + self.phi_R*(numContacts_SQ + numContacts_EQ+ numContacts_AQ + numContacts_MQ + numContacts_RQ + numContacts_C + numContacts_Mi + numContacts_ICU + numContacts_Cmirec + numContacts_Cicurec))*self.psi_FP*(self.X==self.R) + propensities_StoSQ = (self.theta_S + self.phi_S*(numContacts_SQ + numContacts_EQ + numContacts_IQ + numContacts_AQ + numContacts_MQ + numContacts_RQ + numContacts_C + numContacts_Mi + numContacts_ICU + numContacts_Cmirec + numContacts_Cicurec))*self.psi_FP*(self.X==self.S) + propensities_EtoEQ = (self.theta_E + self.phi_E*(numContacts_SQ + numContacts_EQ + numContacts_IQ + numContacts_AQ + numContacts_MQ + numContacts_RQ + numContacts_C + numContacts_Mi + numContacts_ICU + numContacts_Cmirec + numContacts_Cicurec))*self.psi_PP*(self.X==self.E) + propensities_ItoIQ = (self.theta_I + self.phi_I*(numContacts_SQ + numContacts_EQ + numContacts_IQ + numContacts_AQ + numContacts_MQ + numContacts_RQ + numContacts_C + numContacts_Mi + numContacts_ICU + numContacts_Cmirec + numContacts_Cicurec))*self.psi_FP*(self.X==self.I) + propensities_AtoAQ = (self.theta_A + self.phi_A*(numContacts_SQ + numContacts_EQ + numContacts_IQ + numContacts_AQ + numContacts_MQ + numContacts_RQ + numContacts_C + numContacts_Mi + numContacts_ICU + numContacts_Cmirec + numContacts_Cicurec))*self.psi_PP*(self.X==self.A) + propensities_MtoMQ = (self.theta_M + self.phi_M*(numContacts_SQ + numContacts_EQ + numContacts_IQ + numContacts_AQ + numContacts_MQ + numContacts_RQ + numContacts_C + numContacts_Mi + numContacts_ICU + numContacts_Cmirec + numContacts_Cicurec))*self.psi_PP*(self.X==self.M) + propensities_RtoRQ = (self.theta_R + self.phi_R*(numContacts_SQ + numContacts_EQ + numContacts_IQ + numContacts_AQ + numContacts_MQ + numContacts_RQ + numContacts_C + numContacts_Mi + numContacts_ICU + numContacts_Cmirec + numContacts_Cicurec))*self.psi_FP*(self.X==self.R) propensities_SQtoS = (1/self.dq)*(self.X==self.SQ) - propensities_EQtoAQ = (self.a/self.sigma)*(self.X==self.EQ) - propensities_EQtoMQ = (self.m/self.sigma)*(self.X==self.EQ) + propensities_EQtoIQ = (1/self.sigma)*(self.X==self.EQ) + propensities_IQtoAQ = (self.a/self.omega)*(self.X==self.IQ) + propensities_IQtoMQ = (self.m/self.omega)*(self.X==self.IQ) propensities_MQtoC = (self.h*self.c/self.dhospital)*(self.X==self.MQ) propensities_MQtoMi = (self.h*self.mi/self.dhospital)*(self.X==self.MQ) propensities_MQtoICU = (self.h*(1-self.c-self.mi)/self.dhospital)*(self.X==self.MQ) @@ -1784,8 +1871,9 @@ def calc_propensities(self): propensities_RtoS = self.zeta*(self.X==self.R) #propensities__toS = self.nu*(self.X!=self.F) - propensities = numpy.hstack([propensities_StoE, propensities_EtoA, - propensities_EtoM, propensities_MtoC, + propensities = numpy.hstack([propensities_StoE, propensities_EtoI, + propensities_ItoA, + propensities_ItoM, propensities_MtoC, propensities_MtoMi, propensities_MtoICU, propensities_AtoR, propensities_MtoR, propensities_MitoCmirec, propensities_MitoCmirec, @@ -1793,16 +1881,18 @@ def calc_propensities(self): propensities_ICUtoD, propensities_CtoR, propensities_CmirectoR, propensities_CicurectoR, propensities_StoSQ, propensities_EtoEQ, + propensities_ItoIQ, propensities_AtoAQ, propensities_MtoMQ, propensities_RtoRQ, propensities_SQtoS, - propensities_EQtoAQ, propensities_EQtoMQ, + propensities_EQtoIQ, propensities_IQtoAQ, + propensities_IQtoMQ, propensities_MQtoC, propensities_MQtoMi, propensities_MQtoICU, propensities_MQtoR, propensities_AQtoR, propensities_MQtoR, propensities_RQtoR, propensities_RtoS]) #propensities__toS - columns = ['StoE', 'EtoA', 'EtoM', 'MtoC', 'MtoMi', 'MtoICU','AtoR','MtoR','MitoCmirec','MitoCmirec','ICUtoCicurec','ICUtoD','CtoR','CmirectoR','CicurectoR', - 'StoSQ','EtoEQ','AtoAQ','MtoMQ','RtoRQ','SQtoS','EQtoAQ','EQtoMQ','MQtoC','MQtoMi','MQtoICU','MQtoR','AQtoR','MQtoR','RQtoR','RtoS'] #'_toS' + columns = ['StoE', 'EtoI', 'ItoA', 'ItoM', 'MtoC', 'MtoMi', 'MtoICU','AtoR','MtoR','MitoCmirec','MitoCmirec','ICUtoCicurec','ICUtoD','CtoR','CmirectoR','CicurectoR', + 'StoSQ','EtoEQ', 'ItoIQ','AtoAQ','MtoMQ','RtoRQ','SQtoS','EQtoIQ','IQtoAQ','IQtoMQ','MQtoC','MQtoMi','MQtoICU','MQtoR','AQtoR','MQtoR','RQtoR','RtoS'] #'_toS' return propensities, columns #^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ #^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -1811,6 +1901,7 @@ def increase_data_series_length(self): self.tseries = numpy.pad(self.tseries, [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.numS = numpy.pad(self.numS, [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.numE = numpy.pad(self.numE, [(0, 5*self.numNodes)], mode='constant', constant_values=0) + self.numI = numpy.pad(self.numI, [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.numA = numpy.pad(self.numA, [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.numM = numpy.pad(self.numM, [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.numC = numpy.pad(self.numC, [(0, 5*self.numNodes)], mode='constant', constant_values=0) @@ -1820,6 +1911,7 @@ def increase_data_series_length(self): self.numICU = numpy.pad(self.numICU, [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.numSQ = numpy.pad(self.numSQ, [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.numEQ = numpy.pad(self.numEQ, [(0, 5*self.numNodes)], mode='constant', constant_values=0) + self.numIQ = numpy.pad(self.numIQ, [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.numAQ = numpy.pad(self.numAQ, [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.numMQ = numpy.pad(self.numMQ, [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.numRQ = numpy.pad(self.numRQ, [(0, 5*self.numNodes)], mode='constant', constant_values=0) @@ -1831,6 +1923,7 @@ def increase_data_series_length(self): for groupName in self.nodeGroupData: self.nodeGroupData[groupName]['numS'] = numpy.pad(self.nodeGroupData[groupName]['numS'], [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.nodeGroupData[groupName]['numE'] = numpy.pad(self.nodeGroupData[groupName]['numE'], [(0, 5*self.numNodes)], mode='constant', constant_values=0) + self.nodeGroupData[groupName]['numI'] = numpy.pad(self.nodeGroupData[groupName]['numI'], [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.nodeGroupData[groupName]['numA'] = numpy.pad(self.nodeGroupData[groupName]['numA'], [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.nodeGroupData[groupName]['numM'] = numpy.pad(self.nodeGroupData[groupName]['numM'], [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.nodeGroupData[groupName]['numC'] = numpy.pad(self.nodeGroupData[groupName]['numC'], [(0, 5*self.numNodes)], mode='constant', constant_values=0) @@ -1840,6 +1933,7 @@ def increase_data_series_length(self): self.nodeGroupData[groupName]['numICU'] = numpy.pad(self.nodeGroupData[groupName]['numICU'], [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.nodeGroupData[groupName]['numSQ'] = numpy.pad(self.nodeGroupData[groupName]['numSQ'], [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.nodeGroupData[groupName]['numEQ'] = numpy.pad(self.nodeGroupData[groupName]['numEQ'], [(0, 5*self.numNodes)], mode='constant', constant_values=0) + self.nodeGroupData[groupName]['numIQ'] = numpy.pad(self.nodeGroupData[groupName]['numIQ'], [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.nodeGroupData[groupName]['numAQ'] = numpy.pad(self.nodeGroupData[groupName]['numAQ'], [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.nodeGroupData[groupName]['numMQ'] = numpy.pad(self.nodeGroupData[groupName]['numMQ'], [(0, 5*self.numNodes)], mode='constant', constant_values=0) self.nodeGroupData[groupName]['numRQ'] = numpy.pad(self.nodeGroupData[groupName]['numRQ'], [(0, 5*self.numNodes)], mode='constant', constant_values=0) @@ -1853,6 +1947,7 @@ def finalize_data_series(self): self.tseries = numpy.array(self.tseries, dtype=float)[:self.tidx+1] self.numS = numpy.array(self.numS, dtype=float)[:self.tidx+1] self.numE = numpy.array(self.numE, dtype=float)[:self.tidx+1] + self.numI = numpy.array(self.numI, dtype=float)[:self.tidx+1] self.numA = numpy.array(self.numA, dtype=float)[:self.tidx+1] self.numM = numpy.array(self.numM, dtype=float)[:self.tidx+1] self.numC = numpy.array(self.numC, dtype=float)[:self.tidx+1] @@ -1862,6 +1957,7 @@ def finalize_data_series(self): self.numICU = numpy.array(self.numICU, dtype=float)[:self.tidx+1] self.numSQ = numpy.array(self.numSQ, dtype=float)[:self.tidx+1] self.numEQ = numpy.array(self.numEQ, dtype=float)[:self.tidx+1] + self.numIQ = numpy.array(self.numIQ, dtype=float)[:self.tidx+1] self.numAQ = numpy.array(self.numAQ, dtype=float)[:self.tidx+1] self.numMQ = numpy.array(self.numMQ, dtype=float)[:self.tidx+1] self.numRQ = numpy.array(self.numRQ, dtype=float)[:self.tidx+1] @@ -1873,6 +1969,7 @@ def finalize_data_series(self): for groupName in self.nodeGroupData: self.nodeGroupData[groupName]['numS'] = numpy.array(self.nodeGroupData[groupName]['numS'], dtype=float)[:self.tidx+1] self.nodeGroupData[groupName]['numE'] = numpy.array(self.nodeGroupData[groupName]['numE'], dtype=float)[:self.tidx+1] + self.nodeGroupData[groupName]['numI'] = numpy.array(self.nodeGroupData[groupName]['numI'], dtype=float)[:self.tidx+1] self.nodeGroupData[groupName]['numA'] = numpy.array(self.nodeGroupData[groupName]['numA'], dtype=float)[:self.tidx+1] self.nodeGroupData[groupName]['numM'] = numpy.array(self.nodeGroupData[groupName]['numM'], dtype=float)[:self.tidx+1] self.nodeGroupData[groupName]['numC'] = numpy.array(self.nodeGroupData[groupName]['numC'], dtype=float)[:self.tidx+1] @@ -1882,6 +1979,7 @@ def finalize_data_series(self): self.nodeGroupData[groupName]['numICU'] = numpy.array(self.nodeGroupData[groupName]['numICU'], dtype=float)[:self.tidx+1] self.nodeGroupData[groupName]['numSQ'] = numpy.array(self.nodeGroupData[groupName]['numSQ'], dtype=float)[:self.tidx+1] self.nodeGroupData[groupName]['numEQ'] = numpy.array(self.nodeGroupData[groupName]['numEQ'], dtype=float)[:self.tidx+1] + self.nodeGroupData[groupName]['numIQ'] = numpy.array(self.nodeGroupData[groupName]['numIQ'], dtype=float)[:self.tidx+1] self.nodeGroupData[groupName]['numAQ'] = numpy.array(self.nodeGroupData[groupName]['numAQ'], dtype=float)[:self.tidx+1] self.nodeGroupData[groupName]['numMQ'] = numpy.array(self.nodeGroupData[groupName]['numMQ'], dtype=float)[:self.tidx+1] self.nodeGroupData[groupName]['numRQ'] = numpy.array(self.nodeGroupData[groupName]['numRQ'], dtype=float)[:self.tidx+1] @@ -1946,6 +2044,7 @@ def run_iteration(self): self.tseries[self.tidx] = self.t self.numS[self.tidx] = numpy.clip(numpy.count_nonzero(self.X==self.S), a_min=0, a_max=self.numNodes) self.numE[self.tidx] = numpy.clip(numpy.count_nonzero(self.X==self.E), a_min=0, a_max=self.numNodes) + self.numI[self.tidx] = numpy.clip(numpy.count_nonzero(self.X==self.I), a_min=0, a_max=self.numNodes) self.numA[self.tidx] = numpy.clip(numpy.count_nonzero(self.X==self.A), a_min=0, a_max=self.numNodes) self.numM[self.tidx] = numpy.clip(numpy.count_nonzero(self.X==self.M), a_min=0, a_max=self.numNodes) self.numC[self.tidx] = numpy.clip(numpy.count_nonzero(self.X==self.C), a_min=0, a_max=self.numNodes) @@ -1955,19 +2054,21 @@ def run_iteration(self): self.numICU[self.tidx] = numpy.clip(numpy.count_nonzero(self.X==self.ICU), a_min=0, a_max=self.numNodes) self.numSQ[self.tidx] = numpy.clip(numpy.count_nonzero(self.X==self.SQ), a_min=0, a_max=self.numNodes) self.numEQ[self.tidx] = numpy.clip(numpy.count_nonzero(self.X==self.EQ), a_min=0, a_max=self.numNodes) + self.numIQ[self.tidx] = numpy.clip(numpy.count_nonzero(self.X==self.IQ), a_min=0, a_max=self.numNodes) self.numAQ[self.tidx] = numpy.clip(numpy.count_nonzero(self.X==self.AQ), a_min=0, a_max=self.numNodes) self.numMQ[self.tidx] = numpy.clip(numpy.count_nonzero(self.X==self.MQ), a_min=0, a_max=self.numNodes) self.numRQ[self.tidx] = numpy.clip(numpy.count_nonzero(self.X==self.RQ), a_min=0, a_max=self.numNodes) self.numR[self.tidx] = numpy.clip(numpy.count_nonzero(self.X==self.R), a_min=0, a_max=self.numNodes) self.numD[self.tidx] = numpy.clip(numpy.count_nonzero(self.X==self.D), a_min=0, a_max=self.numNodes) - self.N[self.tidx] = numpy.clip((self.numS[self.tidx] + self.numE[self.tidx] + self.numA[self.tidx] + self.numM[self.tidx] + self.numC[self.tidx] - + self.numCmirec[self.tidx] + self.numCicurec[self.tidx] + self.numMi[self.tidx] + self.numICU[self.tidx] + self.numSQ[self.tidx] + self.numEQ[self.tidx] + self.N[self.tidx] = numpy.clip((self.numS[self.tidx] + self.numE[self.tidx] + self.numI[self.tidx] + self.numA[self.tidx] + self.numM[self.tidx] + self.numC[self.tidx] + + self.numCmirec[self.tidx] + self.numCicurec[self.tidx] + self.numMi[self.tidx] + self.numICU[self.tidx] + self.numSQ[self.tidx] + self.numEQ[self.tidx] + self.numIQ[self.tidx] + self.numAQ[self.tidx] + self.numMQ[self.tidx] + self.numRQ[self.tidx] + self.numR[self.tidx]), a_min=0, a_max=self.numNodes) if(self.nodeGroupData): for groupName in self.nodeGroupData: self.nodeGroupData[groupName]['numS'][self.tidx] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.S) self.nodeGroupData[groupName]['numE'][self.tidx] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.E) + self.nodeGroupData[groupName]['numI'][self.tidx] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.I) self.nodeGroupData[groupName]['numA'][self.tidx] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.A) self.nodeGroupData[groupName]['numM'][self.tidx] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.M) self.nodeGroupData[groupName]['numC'][self.tidx] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.C) @@ -1977,17 +2078,18 @@ def run_iteration(self): self.nodeGroupData[groupName]['numICU'][self.tidx] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.ICU) self.nodeGroupData[groupName]['numSQ'][self.tidx] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.SQ) self.nodeGroupData[groupName]['numEQ'][self.tidx] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.EQ) + self.nodeGroupData[groupName]['numIQ'][self.tidx] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.IQ) self.nodeGroupData[groupName]['numAQ'][self.tidx] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.AQ) self.nodeGroupData[groupName]['numMQ'][self.tidx] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.MQ) self.nodeGroupData[groupName]['numRQ'][self.tidx] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.RQ) self.nodeGroupData[groupName]['numR'][self.tidx] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.R) self.nodeGroupData[groupName]['numD'][self.tidx] = numpy.count_nonzero(self.nodeGroupData[groupName]['mask']*self.X==self.D) self.nodeGroupData[groupName]['N'][self.tidx] = numpy.clip((self.nodeGroupData[groupName]['numS'][0] - + self.nodeGroupData[groupName]['numE'][0] + self.nodeGroupData[groupName]['numA'][0] + self.nodeGroupData[groupName]['numM'][0] - + self.nodeGroupData[groupName]['numC'][0] + self.nodeGroupData[groupName]['numCmirec'][0] + self.nodeGroupData[groupName]['numCicurec'][0] - + self.nodeGroupData[groupName]['numMi'][0]+ self.nodeGroupData[groupName]['numICU'][0]+ self.nodeGroupData[groupName]['numSQ'][0] - + self.nodeGroupData[groupName]['numEQ'][0] + self.nodeGroupData[groupName]['numAQ'][0] + self.nodeGroupData[groupName]['numMQ'][0] - + self.nodeGroupData[groupName]['numRQ'][0] + self.nodeGroupData[groupName]['numR'][0]), a_min=0, a_max=self.numNodes) + + self.nodeGroupData[groupName]['numE'][0] + self.nodeGroupData[groupName]['numI'][0] + self.nodeGroupData[groupName]['numA'][0] + self.nodeGroupData[groupName]['numM'][0] + + self.nodeGroupData[groupName]['numC'][0] + self.nodeGroupData[groupName]['numCmirec'][0] + self.nodeGroupData[groupName]['numCicurec'][0] + + self.nodeGroupData[groupName]['numMi'][0] + self.nodeGroupData[groupName]['numICU'][0] + self.nodeGroupData[groupName]['numSQ'][0] + + self.nodeGroupData[groupName]['numEQ'][0] + self.nodeGroupData[groupName]['numIQ'][0] + self.nodeGroupData[groupName]['numAQ'][0] + + self.nodeGroupData[groupName]['numMQ'][0] + self.nodeGroupData[groupName]['numRQ'][0] + self.nodeGroupData[groupName]['numR'][0]), a_min=0, a_max=self.numNodes) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Terminate if tmax reached or num infectious and num exposed is 0: @@ -2021,8 +2123,8 @@ def run(self, T, checkpoints=None, print_interval=10, verbose=False): if key != 't': beforeChk.append(getattr(self,key)) numCheckpoints = len(checkpoints['t']) - paramNames = ['G', 'beta', 'sigma', 'initN','zeta', 'p','a','m', 'h', 'c', 'mi', 'da', 'dm', 'dc', 'dmi', 'dICU', 'dICUrec', 'dmirec','dhospital', 'm0', - 'maxICU','theta_S', 'theta_E', 'theta_A', 'theta_M', 'theta_R','phi_S','phi_E','phi_A','phi_R','psi_FP','psi_PP'] + paramNames = ['G', 'beta', 'sigma', 'omega', 'initN','zeta', 'p','a','m', 'h', 'c', 'mi', 'da', 'dm', 'dc', 'dmi', 'dICU', 'dICUrec', 'dmirec','dhospital', 'm0', + 'maxICU','theta_S', 'theta_E', 'theta_I', 'theta_A', 'theta_M', 'theta_R','phi_S','phi_E','phi_I','phi_A','phi_R','psi_FP','psi_PP'] for chkpt_param, chkpt_values in checkpoints.items(): assert(isinstance(chkpt_values, (list, numpy.ndarray)) and len(chkpt_values)==numCheckpoints), "Expecting a list of values with length equal to number of checkpoint times ("+str(numCheckpoints)+") for each checkpoint parameter." @@ -2079,6 +2181,7 @@ def run(self, T, checkpoints=None, print_interval=10, verbose=False): if(verbose): print("\t S = " + str(self.numS[self.tidx])) print("\t E = " + str(self.numE[self.tidx])) + print("\t I = " + str(self.numI[self.tidx])) print("\t A = " + str(self.numA[self.tidx])) print("\t M = " + str(self.numM[self.tidx])) print("\t C = " + str(self.numC[self.tidx])) @@ -2088,6 +2191,7 @@ def run(self, T, checkpoints=None, print_interval=10, verbose=False): print("\t ICU = " + str(self.numICU[self.tidx])) print("\t SQ = " + str(self.numSQ[self.tidx])) print("\t EQ = " + str(self.numEQ[self.tidx])) + print("\t IQ = " + str(self.numIQ[self.tidx])) print("\t AQ = " + str(self.numAQ[self.tidx])) print("\t MQ = " + str(self.numMQ[self.tidx])) print("\t RQ = " + str(self.numRQ[self.tidx])) @@ -2112,6 +2216,7 @@ def format_numX(self,T): x=numpy.append(x,T+1) self.numS=numpy.append(self.numS,self.numS[-1]) self.numE=numpy.append(self.numE,self.numE[-1]) + self.numI=numpy.append(self.numI,self.numE[-1]) self.numA=numpy.append(self.numA,self.numA[-1]) self.numM=numpy.append(self.numM,self.numM[-1]) self.numC=numpy.append(self.numC,self.numC[-1]) @@ -2123,6 +2228,7 @@ def format_numX(self,T): self.numD=numpy.append(self.numD,self.numD[-1]) self.numSQ=numpy.append(self.numSQ,self.numSQ[-1]) self.numEQ=numpy.append(self.numEQ,self.numEQ[-1]) + self.numIQ=numpy.append(self.numIQ,self.numEQ[-1]) self.numAQ=numpy.append(self.numAQ,self.numAQ[-1]) self.numMQ=numpy.append(self.numMQ,self.numMQ[-1]) self.numRQ=numpy.append(self.numRQ,self.numRQ[-1]) @@ -2131,6 +2237,8 @@ def format_numX(self,T): self.numS = inte(t)*r inte = inter.interp1d(x,self.numE) self.numE = inte(t)*r + inte = inter.interp1d(x,self.numI) + self.numI = inte(t)*r inte = inter.interp1d(x,self.numA) self.numA = inte(t)*r inte = inter.interp1d(x,self.numM) @@ -2153,6 +2261,8 @@ def format_numX(self,T): self.numSQ = inte(t)*r inte = inter.interp1d(x,self.numEQ) self.numEQ = inte(t)*r + inte = inter.interp1d(x,self.numIQ) + self.numIQ = inte(t)*r inte = inter.interp1d(x,self.numAQ) self.numAQ = inte(t)*r inte = inter.interp1d(x,self.numMQ) @@ -2174,6 +2284,7 @@ def sim(self, T, dt=1, checkpoints=None, verbose=False): # pre-allocate a 2D matrix for the results summed over all age bins self.sumS = numpy.zeros([tN,self.repeats]) self.sumE = numpy.zeros([tN,self.repeats]) + self.sumI = numpy.zeros([tN,self.repeats]) self.sumA = numpy.zeros([tN,self.repeats]) self.sumM = numpy.zeros([tN,self.repeats]) self.sumC = numpy.zeros([tN,self.repeats]) @@ -2186,6 +2297,7 @@ def sim(self, T, dt=1, checkpoints=None, verbose=False): self.sumD = numpy.zeros([tN,self.repeats]) self.sumSQ = numpy.zeros([tN,self.repeats]) self.sumEQ = numpy.zeros([tN,self.repeats]) + self.sumIQ = numpy.zeros([tN,self.repeats]) self.sumAQ = numpy.zeros([tN,self.repeats]) self.sumMQ = numpy.zeros([tN,self.repeats]) self.sumRQ = numpy.zeros([tN,self.repeats]) @@ -2201,6 +2313,7 @@ def sim(self, T, dt=1, checkpoints=None, verbose=False): self.sumS[:,i] = self.numS self.sumE[:,i] = self.numE + self.sumI[:,i] = self.numI self.sumA[:,i] = self.numA self.sumM[:,i] = self.numM self.sumC[:,i] = self.numC @@ -2213,7 +2326,8 @@ def sim(self, T, dt=1, checkpoints=None, verbose=False): self.sumD[:,i] = self.numD self.sumSQ[:,i] = self.numSQ self.sumEQ[:,i] = self.numEQ - self.sumA[:,i] = self.numA + self.sumIQ[:,i] = self.numIQ + self.sumAQ[:,i] = self.numAQ self.sumMQ[:,i] = self.numMQ self.sumRQ[:,i] = self.numRQ i = i + 1 diff --git a/src/test.svg b/src/test.svg new file mode 100644 index 000000000..ba153f939 --- /dev/null +++ b/src/test.svg @@ -0,0 +1,1866 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +