bass_model_parameter_phase_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import random\n",
    "import os\n",
    "from os.path import join, exists\n",
    "import pickle\n",
    "from tqdm import tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import patches\n",
    "from copy import deepcopy\n",
    "from utils import *\n",
    "import statsmodels.api as sm\n",
    "import statsmodels.formula.api as smf\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.metrics import r2_score\n",
    "from scipy import stats\n",
    "from scipy.optimize import least_squares\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This Python notebook analyzes the Bass model parameters that have been fitted. Based on the Bass model parameters, adoption phases (onset, ramp-up, ramp-down, saturation) have been derived for each block group. Intermediate results are also generated for regression analysis.\n",
    "\n",
    "Figure 2 in the paper can be produced using this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext rpy2.ipython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def LocalRegression(X_input, y_input, bandwidth):\n",
    "    \"\"\"\n",
    "    Local regression given an array of x value and an array of y value\n",
    "    \"\"\"\n",
    "    X = np.reshape(np.array(X_input), [-1])\n",
    "    y = np.reshape(np.array(y_input), [-1])\n",
    "    X_norm = (X - X.min())/(X.max() - X.min())\n",
    "    X_lin = np.linspace(0, 1, 100)\n",
    "    y_pred = np.zeros([100])\n",
    "    for i in range(100):\n",
    "        x_i = X_lin[i]\n",
    "        weights = np.exp(-np.square(x_i - X_norm)/(2*np.square(bandwidth)))\n",
    "        LR = LinearRegression()\n",
    "        LR.fit(X=X_norm.reshape(-1,1), y=y, sample_weight=weights)\n",
    "        y_pred[i] = LR.predict([[x_i]])[0]\n",
    "    X_out = X_lin * (X.max() - X.min()) + X.min()\n",
    "    return X_out, y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_str(depedent, features):\n",
    "    \"\"\"Generate the formula string given a dependent variable and a list of features\"\"\"\n",
    "    assert features\n",
    "    s = depedent + ' ~ ' + features[0]\n",
    "    for f in features[1:]:\n",
    "        s += ' + ' + f\n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_cum_installations(coefs, t):\n",
    "    \"\"\"Given Bass model coefficients, and a time array, return the array of cumulative values.\"\"\"\n",
    "    p, q, m, d = coefs\n",
    "    y = (1 - np.exp(-(p + q) * (t - d))) / (1 + q / p * np.exp(-(p + q) * (t - d)))\n",
    "    return m * y * (t >= d) + 0 * (t < d)\n",
    "\n",
    "def get_residuals_cum(coefs, t, y_true):\n",
    "    \"\"\"\n",
    "    Given Bass model coefficients, and a time array, return resididual between true cumulative\n",
    "    values and predicted cumulative values (predicted by Bass model).\n",
    "    \"\"\"\n",
    "    y_pred = get_cum_installations(coefs, t)\n",
    "    return y_pred - y_true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_cum_installations_GBM(coefs, t):\n",
    "    \"\"\"\n",
    "    Given Generalized Bass model coefficients, and a time array, return the array of \n",
    "    cumulative values.\n",
    "    \"\"\"\n",
    "    p, q, m, d, beta = coefs\n",
    "    y = (1 - np.exp(-(p + q) * (t - d + beta * log_price_trend))) / (1 + q / p * np.exp(-(p + q) * (t - d + beta * log_price_trend)))\n",
    "    return m * y * (t >= d) + 0 * (t < d)\n",
    "\n",
    "def get_residuals_cum_GBM(coefs, t, y_true):\n",
    "    \"\"\"\n",
    "    Given Generalized Bass model coefficients, and a time array, return resididual between true\n",
    "    cumulative values and predicted cumulative values (predicted by Bass model).\n",
    "    \"\"\"\n",
    "    y_pred = get_cum_installations_GBM(coefs, t)\n",
    "    return y_pred - y_true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_t_by_cum_adoption_rate(p, q, m, d, cum_adoption_rate):\n",
    "    \"\"\"\n",
    "    Given a target cumulative rate value, return the time when that this target is reached.\n",
    "    \"\"\"\n",
    "    k = (1 - cum_adoption_rate) / (1 + q/p * cum_adoption_rate)\n",
    "    t = - np.log(k) / (p + q)\n",
    "    return t + d\n",
    "\n",
    "def get_t_by_cum_adoption_amount(p, q, m, d, amount):\n",
    "    \"\"\"\n",
    "    Given a target cumulative amount value, return the time when that this target is reached.\n",
    "    \"\"\"\n",
    "    cum_adoption_rate = np.minimum(amount / m, 0.999999)\n",
    "    return get_t_by_cum_adoption_rate(p, q, m, d, cum_adoption_rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "bg = pd.read_csv('results/merged_bg.csv')\n",
    "bg['tract_FIPS'] = bg['blockgroup_FIPS'] // 10\n",
    "bg['county_FIPS'] = bg['blockgroup_FIPS'] // 10000000\n",
    "bg['state_FIPS'] = bg['blockgroup_FIPS'] // 10000000000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = bg.sort_values(['year', 'blockgroup_FIPS'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate cumulative PV installations in each year\n",
    "cumulative_pv_count_dict = {}\n",
    "cumulative_pv_count = np.array(df[df['year'] == 2005]['num_of_installations'])\n",
    "cumulative_pv_count_dict[2005] = cumulative_pv_count.copy()\n",
    "for year in range(2006, 2018):\n",
    "    cumulative_pv_count = cumulative_pv_count + np.array(df[df['year'] == year]['num_of_installations'])\n",
    "    cumulative_pv_count_dict[year] = cumulative_pv_count.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del bg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['cum_num_of_installations'] = np.concatenate([cumulative_pv_count_dict[x] for x in cumulative_pv_count_dict])\n",
    "df.sort_values(['blockgroup_FIPS', 'year'], inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create static ACS variables\n",
    "ACS_cols = [x for x in df.columns if x[:3] == 'ACS']\n",
    "ACS2016_sub = df[df['year'] == 2016][['blockgroup_FIPS'] + ACS_cols]\n",
    "rename_dict_ACS = {x: x + '_2016' for x in ACS_cols}\n",
    "ACS2016_sub.rename(columns=rename_dict_ACS, inplace=True)\n",
    "df = pd.merge(df, ACS2016_sub, how='left', on='blockgroup_FIPS')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the cumulative installations in previous year\n",
    "prev_year_cum = df[(df['year'] <= 2015) & (df['year'] >= 2005)][['blockgroup_FIPS', \n",
    "                                                                 'year',\n",
    "                                                                 'cum_num_of_installations']]\n",
    "# prev_year_cum.index = prev_year_cum['blockgroup_FIPS']\n",
    "prev_year_cum.rename(columns={'cum_num_of_installations': 'cum_num_of_installations_prev'}, inplace=True)\n",
    "prev_year_cum['year'] = prev_year_cum['year'] + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sub = df[(df['year'] <= 2016) & (df['year'] >= 2006)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sub = pd.merge(df_sub, prev_year_cum, how='left', on=['blockgroup_FIPS', 'year'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# number of installations in each year\n",
    "adoption_matrix_bg = pd.DataFrame(df_sub['num_of_installations'].to_numpy().reshape([-1, 11]))\n",
    "adoption_matrix_bg.index = df_sub[df_sub['year'] == 2016]['blockgroup_FIPS']\n",
    "adoption_matrix_bg.columns = [str(x) for x in range(2006, 2017)]\n",
    "# cumulative number of installations till previous year\n",
    "cum_adoption_matrix_prev_bg = pd.DataFrame(df_sub['cum_num_of_installations_prev'].to_numpy().reshape([-1, 11]))\n",
    "cum_adoption_matrix_prev_bg.index = df_sub[df_sub['year'] == 2016]['blockgroup_FIPS']\n",
    "cum_adoption_matrix_prev_bg.columns = [str(x) for x in range(2006, 2017)]\n",
    "# cumulative number of installations till each year\n",
    "cum_adoption_matrix_bg = pd.DataFrame(df[df['year'] <= 2016]['cum_num_of_installations'].to_numpy().reshape([-1, 12]))\n",
    "cum_adoption_matrix_bg.index = df[df['year'] == 2016]['blockgroup_FIPS']\n",
    "cum_adoption_matrix_bg.columns = [str(x) for x in range(2005, 2017)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Block groups where there are at least 2 years with new adoption\n",
    "not_step_func_adoption_bgs = adoption_matrix_bg[np.sum(adoption_matrix_bg > 0, axis=1) > 1].index\n",
    "# Block groups where there is only 1 year with new adoption\n",
    "step_func_adoption_bgs = adoption_matrix_bg[np.sum(adoption_matrix_bg > 0, axis=1) == 1].index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 Load Bass model fitted results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "adoption_params_bg = pd.read_csv('results/bass_model/adoption_bass_model_params_bg.csv')\n",
    "adoption_params_bg.rename(columns={'Unnamed: 0': 'blockgroup_FIPS'}, inplace=True)\n",
    "# adoption_params_bg.index = adoption_params_bg['blockgroup_FIPS']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD9CAYAAABX0LttAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAD/hJREFUeJzt3X+s3XV9x/Hna1SIQQ1V71jXlsG2GoNmQ7kBErfFyQaFLSssjsAf0imxGiHRZMks+kcNaILb1IxNMXU2lsRZiT9Go3W1EjKzP8C2yoCCyBUhtEGoFEXDgiu+98f9XD32c2/v7f11LvT5SE7O97y/n+/3+z7fe8Kr3x/nkKpCkqRBvzHsBiRJS4/hIEnqGA6SpI7hIEnqGA6SpI7hIEnqTBsOSVYnuT3JfUn2JXl3q38gyYEkd7XHxQPLXJtkLMkDSS4cqK9ttbEkGwfqZyS5s9U/n+TE+X6jkqSZy3Tfc0iyAlhRVd9O8lJgL3AJcBnws6r6pyPGnwl8DjgH+G3gG8Cr2uzvAX8O7Ad2A1dU1X1JbgG+VFXbknwS+J+qumm+3qQk6dhMe+RQVY9V1bfb9E+B+4GVR1lkHbCtqp6tqh8AY4wHxTnAWFU9VFU/B7YB65IEeBPwhbb8VsbDR5I0JMd0zSHJ6cDrgDtb6ZokdyfZkmR5q60EHh1YbH+rTVV/BfDjqjp8RF2SNCTLZjowyUuALwLvqaqnk9wEXA9Ue/4I8LYF6fJXPWwANgCcfPLJZ7/61a9eyM1J0gvO3r17f1RVI9ONm1E4JHkR48Hw2ar6EkBVPT4w/1PAV9rLA8DqgcVXtRpT1J8ETkmyrB09DI7/NVW1GdgMMDo6Wnv27JlJ+5KkJskjMxk3k7uVAnwauL+qPjpQXzEw7FLg3ja9Hbg8yUlJzgDWAN9i/AL0mnZn0onA5cD2Gr8ifjvw5rb8euDWmTQvSVoYMzlyeAPwFuCeJHe12vuAK5KcxfhppYeBdwBU1b5299F9wGHg6qp6DiDJNcBO4ARgS1Xta+t7L7AtyQeB7zAeRpKkIZn2VtalytNKknTskuytqtHpxvkNaUlSx3CQJHUMB0lSx3CQJHUMB0lSx3CQJHVm/PMZkqThOH3jV385/fANf7Eo2/TIQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSZ1pwyHJ6iS3J7kvyb4k7271lyfZleTB9ry81ZPkxiRjSe5O8vqBda1v4x9Msn6gfnaSe9oyNybJQrxZSdLMzOTI4TDwd1V1JnAecHWSM4GNwG1VtQa4rb0GuAhY0x4bgJtgPEyATcC5wDnApolAaWPePrDc2rm/NUnSbE0bDlX1WFV9u03/FLgfWAmsA7a2YVuBS9r0OuDmGncHcEqSFcCFwK6qOlRVTwG7gLVt3suq6o6qKuDmgXVJkobgmK45JDkdeB1wJ3BqVT3WZv0QOLVNrwQeHVhsf6sdrb5/krokaUhmHA5JXgJ8EXhPVT09OK/9i7/mubfJetiQZE+SPQcPHlzozUnScWtG4ZDkRYwHw2er6kut/Hg7JUR7fqLVDwCrBxZf1WpHq6+apN6pqs1VNVpVoyMjIzNpXZI0CzO5WynAp4H7q+qjA7O2AxN3HK0Hbh2oX9nuWjoP+Ek7/bQTuCDJ8nYh+gJgZ5v3dJLz2rauHFiXJGkIls1gzBuAtwD3JLmr1d4H3ADckuQq4BHgsjZvB3AxMAY8A7wVoKoOJbke2N3GXVdVh9r0u4DPAC8GvtYekqQhmTYcquq/gam+d3D+JOMLuHqKdW0BtkxS3wO8drpeJEmLw29IS5I6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqTNtOCTZkuSJJPcO1D6Q5ECSu9rj4oF51yYZS/JAkgsH6mtbbSzJxoH6GUnubPXPJzlxPt+gJOnYzeTI4TPA2knqH6uqs9pjB0CSM4HLgde0ZT6R5IQkJwAfBy4CzgSuaGMBPtzW9fvAU8BVc3lDkqS5mzYcquqbwKEZrm8dsK2qnq2qHwBjwDntMVZVD1XVz4FtwLokAd4EfKEtvxW45BjfgyRpns3lmsM1Se5up52Wt9pK4NGBMftbbar6K4AfV9XhI+qSpCGabTjcBPwecBbwGPCReevoKJJsSLInyZ6DBw8uxiYl6bg0q3Coqser6rmq+gXwKcZPGwEcAFYPDF3ValPVnwROSbLsiPpU291cVaNVNToyMjKb1iVJMzCrcEiyYuDlpcDEnUzbgcuTnJTkDGAN8C1gN7Cm3Zl0IuMXrbdXVQG3A29uy68Hbp1NT5Kk+bNsugFJPge8EXhlkv3AJuCNSc4CCngYeAdAVe1LcgtwH3AYuLqqnmvruQbYCZwAbKmqfW0T7wW2Jfkg8B3g0/P27iRJszJtOFTVFZOUp/wPeFV9CPjQJPUdwI5J6g/xq9NSkqQlwG9IS5I6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI6hoMkqWM4SJI604ZDki1Jnkhy70Dt5Ul2JXmwPS9v9SS5MclYkruTvH5gmfVt/INJ1g/Uz05yT1vmxiSZ7zcpSTo2Mzly+Ayw9ojaRuC2qloD3NZeA1wErGmPDcBNMB4mwCbgXOAcYNNEoLQxbx9Y7shtSZIW2bThUFXfBA4dUV4HbG3TW4FLBuo317g7gFOSrAAuBHZV1aGqegrYBaxt815WVXdUVQE3D6xLkjQks73mcGpVPdamfwic2qZXAo8OjNvfaker75+kLkkaojlfkG7/4q956GVaSTYk2ZNkz8GDBxdjk5J0XJptODzeTgnRnp9o9QPA6oFxq1rtaPVVk9QnVVWbq2q0qkZHRkZm2bokaTqzDYftwMQdR+uBWwfqV7a7ls4DftJOP+0ELkiyvF2IvgDY2eY9neS8dpfSlQPrkiQNybLpBiT5HPBG4JVJ9jN+19ENwC1JrgIeAS5rw3cAFwNjwDPAWwGq6lCS64Hdbdx1VTVxkftdjN8R9WLga+0hSRqiacOhqq6YYtb5k4wt4Oop1rMF2DJJfQ/w2un6kCQtHr8hLUnqGA6SpI7hIEnqGA6SpI7hIEnqGA6SpI7hIEnqGA6SpI7hIEnqGA6SpI7hIEnqGA6SpI7hIEnqGA6SpI7hIEnqGA6SpI7hIEnqGA6SpI7hIEnqGA6SpI7hIEnqGA6SpI7hIEnqGA6SpI7hIEnqGA6SpI7hIEnqGA6SpI7hIEnqGA6SpI7hIEnqGA6SpI7hIEnqGA6SpM6cwiHJw0nuSXJXkj2t9vIku5I82J6Xt3qS3JhkLMndSV4/sJ71bfyDSdbP7S1JkuZqPo4c/rSqzqqq0fZ6I3BbVa0BbmuvAS4C1rTHBuAmGA8TYBNwLnAOsGkiUCRJw7EQp5XWAVvb9FbgkoH6zTXuDuCUJCuAC4FdVXWoqp4CdgFrF6AvSdIMzTUcCvh6kr1JNrTaqVX1WJv+IXBqm14JPDqw7P5Wm6ouSRqSZXNc/o+q6kCS3wR2Jfnu4MyqqiQ1x238UgugDQCnnXbafK1WknSEOR05VNWB9vwE8GXGrxk83k4X0Z6faMMPAKsHFl/ValPVJ9ve5qoararRkZGRubQuSTqKWYdDkpOTvHRiGrgAuBfYDkzccbQeuLVNbweubHctnQf8pJ1+2glckGR5uxB9QatJkoZkLqeVTgW+nGRiPf9eVf+ZZDdwS5KrgEeAy9r4HcDFwBjwDPBWgKo6lOR6YHcbd11VHZpDX5KkOZp1OFTVQ8AfTlJ/Ejh/knoBV0+xri3Altn2IkmaX35DWpLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUMRwkSR3DQZLUWTbsBiYkWQv8M3AC8G9VdcOQW5KkoTl941eHuv0lceSQ5ATg48BFwJnAFUnOHG5XknT8WhLhAJwDjFXVQ1X1c2AbsG7IPUnScWupnFZaCTw68Ho/cO6QepGkBTXsU0YzsVTCYUaSbAA2tJc/S/LAMPs5Rq8EfjTsJpYA94P7YIL7YRb7IB+e8zZ/ZyaDlko4HABWD7xe1Wq/pqo2A5sXq6n5lGRPVY0Ou49hcz+4Dya4H5b2Plgq1xx2A2uSnJHkROByYPuQe5Kk49aSOHKoqsNJrgF2Mn4r65aq2jfktiTpuLUkwgGgqnYAO4bdxwJ6Xp4OWwDuB/fBBPfDEt4Hqaph9yBJWmKWyjUHSdISYjgssCT/mOS7Se5O8uUkpwzMuzbJWJIHklw4zD4XUpK/SbIvyS+SjA7UT0/yv0nuao9PDrPPhTbVfmjzjovPwqAkH0hyYODvf/Gwe1pMSda2v/dYko3D7udIhsPC2wW8tqr+APgecC1A+3mQy4HXAGuBT7SfEXkhuhf4a+Cbk8z7flWd1R7vXOS+Ftuk++E4+ywc6WMDf/8X8jXHX/N8+Mkgw2GBVdXXq+pwe3kH49/hgPGfB9lWVc9W1Q+AMcZ/RuQFp6rur6rn0xcWF8RR9sNx81nQLy35nwwyHBbX24CvtenJfjJk5aJ3NHxnJPlOkv9K8sfDbmZIjufPwjXtlOuWJMuH3cwiWvJ/8yVzK+vzWZJvAL81yaz3V9Wtbcz7gcPAZxezt8Uyk30wiceA06rqySRnA/+R5DVV9fSCNbrAZrkfXrCOtj+Am4DrgWrPH2H8H1BaAgyHeVBVf3a0+Un+FvhL4Pz61b3DM/rJkOeL6fbBFMs8Czzbpvcm+T7wKmDPPLe3aGazH3iBfRYGzXR/JPkU8JUFbmcpWfJ/c08rLbD2PzH6e+CvquqZgVnbgcuTnJTkDGAN8K1h9DgsSUYmLrwm+V3G98FDw+1qKI7Lz0KSFQMvL2X8gv3xYsn/ZJBHDgvvX4GTgF1JAO6oqndW1b4ktwD3MX666eqqem6IfS6YJJcC/wKMAF9NcldVXQj8CXBdkv8DfgG8s6oODbHVBTXVfjiePgtH+IckZzF+Wulh4B3DbWfxPB9+MshvSEuSOp5WkiR1DAdJUsdwkCR1DAdJUsdwkCR1DAdJUsdwkCR1DAdJUuf/AcfEmTS2G/mkAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "adoption_params_bg_sub = adoption_params_bg[adoption_params_bg['d'].isnull() == False]\n",
    "_ = plt.hist(adoption_params_bg_sub['r2'], bins=100)\n",
    "# _ = plt.xlim(-0.01, 0.2)\n",
    "# plt.ylim(0, 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9090682841230259 1.0\n",
      "0.9858378249089916\n"
     ]
    }
   ],
   "source": [
    "print(adoption_params_bg_sub['r2'].quantile(0.1), adoption_params_bg_sub['r2'].quantile(0.9))\n",
    "print(adoption_params_bg_sub['r2'].median())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a data frame for covariates\n",
    "selected_covariates = [x for x in df.columns if 'ACS' in x and '2016' in x]\n",
    "selected_covariates.extend(['residential_rate_inflation_adj', \n",
    "                            'avg_GHI', \n",
    "                            'sunroof_percent_qualified',\n",
    "                            'num_of_buildings_lt600',\n",
    "                            'blockgroup_FIPS'\n",
    "                           ])\n",
    "covariate_df = df[df['year'] == 2016][selected_covariates]\n",
    "# covariate_df.index = covariate_df['blockgroup_FIPS'] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged = pd.merge(adoption_params_bg, covariate_df, how='left', on='blockgroup_FIPS')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# derived variables\n",
    "merged['saturated_adoption_rate'] = merged['m'] / merged['ACS_household_count_2016']\n",
    "merged['saturated_adoption_rate'] = merged['saturated_adoption_rate'].replace(np.nan, 0.)\n",
    "merged['saturated_adoption_rate'] = np.minimum(merged['saturated_adoption_rate'], 1.0)\n",
    "\n",
    "merged['saturated_adoption_rate_housing_unit'] = merged['m'] / merged['ACS_housing_unit_count_2016']\n",
    "merged['saturated_adoption_rate_housing_unit'] = merged['saturated_adoption_rate_housing_unit'].replace(np.nan, 0.)\n",
    "merged['saturated_adoption_rate_housing_unit'] = np.minimum(merged['saturated_adoption_rate_housing_unit'], 1.0)\n",
    "\n",
    "merged['saturated_adoption_rate_building_lt600'] = merged['m'] / merged['num_of_buildings_lt600']\n",
    "merged['saturated_adoption_rate_building_lt600'] = merged['saturated_adoption_rate_building_lt600'].replace(np.nan, 0.)\n",
    "merged['saturated_adoption_rate_building_lt600'] = np.minimum(merged['saturated_adoption_rate_building_lt600'], 1.0)\n",
    "\n",
    "merged['normalized_p'] = merged['saturated_adoption_rate'] * merged['p']\n",
    "merged['normalized_q'] = merged['saturated_adoption_rate'] * merged['q']\n",
    "merged['normalized_d'] = np.maximum(merged['d'], 0)\n",
    "\n",
    "merged['state_FIPS'] = merged['blockgroup_FIPS'] // 10000000000\n",
    "merged['state_FIPS'] = merged['state_FIPS'].astype(str)\n",
    "\n",
    "merged['peak_time'] = np.log(merged['q'] / merged['p']) / (merged['q'] + merged['p']) + merged['d']\n",
    "merged['saturation_time_0.95'] = get_t_by_cum_adoption_rate(merged['p'], merged['q'], merged['m'], merged['d'], 0.95)\n",
    "merged['saturation_time_0.8'] = get_t_by_cum_adoption_rate(merged['p'], merged['q'], merged['m'], merged['d'], 0.8)\n",
    "merged['saturation_time_0.9'] = get_t_by_cum_adoption_rate(merged['p'], merged['q'], merged['m'], merged['d'], 0.9)\n",
    "\n",
    "merged['saturation_time_0.95_normalized'] = \\\n",
    "        get_t_by_cum_adoption_amount(merged['p'], merged['q'], merged['m'], merged['d'], \n",
    "                    0.95 * merged['saturated_adoption_rate_building_lt600'] * merged['num_of_buildings_lt600'])\n",
    "\n",
    "# The year when 1st PV was installed in a blockgroup, predicted by fitted Bass model\n",
    "merged['predicted_1st_adoption_time'] = \\\n",
    "        get_t_by_cum_adoption_amount(merged['p'], merged['q'], merged['m'], merged['d'], 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The year when 1st PV was installed in a blockgroup, observed in the data\n",
    "l = []\n",
    "for i in merged.index:\n",
    "    bfips = merged.loc[i, 'blockgroup_FIPS']\n",
    "    first_year = None\n",
    "    for year in range(2005, 2017):\n",
    "        if cum_adoption_matrix_bg.loc[bfips, str(year)] > 0:\n",
    "            first_year = year\n",
    "            break\n",
    "    l.append(first_year)\n",
    "merged['actual_1st_adoption_time'] = l\n",
    "merged['actual_1st_adoption_time'] -= 2006"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 Load incentive data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "incentive_type_indicator_df = pd.read_csv('data/incentives/incentive_type_indicators.csv')\n",
    "incentive_type_first_intro_year_df = pd.read_csv('data/incentives/incentive_type_first_intro_years.csv')\n",
    "incentive_type_indicator_at_onset_df = pd.read_csv('data/incentives/incentive_type_indicators_at_onset.csv')\n",
    "incentive_type_indicator_before_saturation_df = pd.read_csv(\n",
    "    'data/incentives/incentive_type_indicators_before_saturation.csv')\n",
    "incentive_type_first_intro_year_before_onset_df = pd.read_csv(\n",
    "    'data/incentives/incentive_type_first_intro_years_before_saturation.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged2 = pd.merge(merged, incentive_type_indicator_df, how='left', on='blockgroup_FIPS')\n",
    "merged2 = pd.merge(merged2, incentive_type_first_intro_year_df, how='left', on='blockgroup_FIPS')\n",
    "# extra\n",
    "merged2 = pd.merge(merged2, incentive_type_indicator_at_onset_df, how='left', on='blockgroup_FIPS')\n",
    "merged2 = pd.merge(merged2, incentive_type_indicator_before_saturation_df, how='left', on='blockgroup_FIPS')\n",
    "merged2 = pd.merge(merged2, incentive_type_first_intro_year_before_onset_df, how='left', on='blockgroup_FIPS')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged2['is_step_func_curve'] = merged2['blockgroup_FIPS'].isin(step_func_adoption_bgs).astype(int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 Income and racial group"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "income_group_df = pd.read_csv('data/socioeconomics/bg_income_racial_group_420counties_v1.csv')\n",
    "# income_group_df['blockgroup_FIPS'] = income_group_df['blockgroup_FIPS'].astype(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged3 = pd.merge(merged2, income_group_df, how='left', on='blockgroup_FIPS')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged3['adoption_time_interval'] = merged3['saturation_time_0.95_normalized'] - merged3['d']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save intermediate dataframe for regression\n",
    "merged3.to_csv('results/bass_model/merged_bg_bass.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Four-phase segmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged_sub = merged3[merged3['d'].isnull() == False]\n",
    "year_list = list(range(2006, 2021))\n",
    "x1_list = []\n",
    "x2_list = []\n",
    "x3_list = []\n",
    "x4_list = []\n",
    "for year in year_list:\n",
    "    year_idx = year - 2006\n",
    "    x1 = merged3['d'].isnull().sum()\n",
    "    x1 += np.sum(year_idx < merged_sub['d'])\n",
    "    x2 = np.sum((year_idx >= merged_sub['d']) & (year_idx < merged_sub['peak_time']))\n",
    "    x3 = np.sum((year_idx >= merged_sub['d']) & (year_idx >= merged_sub['peak_time']) &\\\n",
    "                (year_idx < merged_sub['saturation_time_0.95']))\n",
    "    x4 = np.sum(year_idx >= merged_sub['saturation_time_0.95'])\n",
    "#     print(year, (x1, x2, x3, x4), x1+x2+x3+x4)\n",
    "    x1_list.append(x1)\n",
    "    x2_list.append(x2)\n",
    "    x3_list.append(x3)\n",
    "    x4_list.append(x4)\n",
    "x1_list = np.array(x1_list) * 1. / merged.shape[0]\n",
    "x2_list = np.array(x2_list) * 1. / merged.shape[0]\n",
    "x3_list = np.array(x3_list) * 1. / merged.shape[0]\n",
    "x4_list = np.array(x4_list) * 1. / merged.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHMCAYAAABFvxmpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xl8VNX5x/HPE7YETEwgiAuFICirshStAoIii4iAKFYpoBQwLEGxIlDFBURRrKi4ICAY+GGpC6WoICoom+ICoiKCKGhArAurLCIQOL8/ZpJmkskkN0wmCfm+X6/7Gubcc895Blv79Jx7zjHnHCIiIiJSekQVdQAiIiIiEllKAEVERERKGSWAIiIiIqWMEkARERGRUkYJoIiIiEgpowRQREREpJRRAigiIiJSyigBFBERESlllACKiIiIlDJlizqA4i4xMdElJSUVdRgiIiIiefrkk092Oueq5lVPCWAekpKSWLNmTVGHISIiIpInM9uan3qaAhYREREpZZQAioiIiJQySgBFREREShklgCIiIiKljBJAERERkVJGCaCIiIhIKaNtYERERLI4fPgwu3fvZv/+/Rw7dqyowxGhTJkyxMbGUrlyZSpUqBCWNpUAioiI+B0+fJht27aRkJBAUlIS5cqVw8yKOiwpxZxzHD16lH379rFt2zZq1KgRliRQU8AiIiJ+u3fvJiEhgcTERMqXL6/kT4qcmVG+fHkSExNJSEhg9+7dYWlXCaCIiIjf/v37iYuLK+owRIKKi4tj//79YWlLCaCIiIjfsWPHKFeuXFGHIRJUuXLlwvZearFMAM2sj5k9Z2afmtkRM3NmdmkB2mloZvPNbLeZHTSzj8zsukIIWUREThKa9pXiKpz/2Syui0DGATWBX/zXWV4bMLMmwEp8v/FFYCdwDfCymd3inHs6fOGKiIiIlBzFcgQQ6A/UcM5Vw5e8FcSzQCWgi3Pur865EUATYCPwiJmdEZ5QRUREREqWYpkAOufecc59X9DnzawBcBHwjnNuSZZ29wPjgRjgLyccqIiIiISNmTFmzJjM7zNnzsTMSEtLC6j38ssv07BhQypUqICZsXfv3pDl4ZSUlETfvn3D3m6kFdcp4BPV2v+5OMi9jLI2wMTIhCMiIiXd8uXLizoEANq0aVPUIRSpzZs306tXL1q3bs3w4cMpX748lSpVyrVcgjtZE8A6/s/N2W845342swNZ6uRgZslAMkCNGjUKJcDsIvkvllD/8iiNcUDxiUVxFM84oPjEojgKN45wbrMhJ65Pnz7ccMMNARsfL1u2jPT0dCZOnEiTJk3yLA+3TZs2ERVVLCdQPSn5vyC4jE2c9uVyfx9wam4PO+emOeeaO+eaV61aNezBiYiIlDQHDx6MeJ9lypQhOjo6YPXrL7/8AkB8fHxA3dzKw61ChQonxVZBJ2sCKCIiItmMGTMGM2P9+vXcdNNNJCQkEBcXR8+ePTMTKIBLL72UOnXqsH79etq3b09sbCy9evXKvL927Vq6du1KQkICMTExNG/enPnz5+c7jn379pGcnEzlypWJi4vj2muv5ccff8xRL/s7gElJSYwePRqAWrVqYWb07ds31/KM33LppZfm+neR1dKlS7nsssuoUqUKMTEx1KxZk969ewckv8HeAdy9ezdDhgzhzDPPpEKFCtSrV49HH32U48ePB9QzMwYMGMCiRYto2rQp0dHR1KlThzlz5uT77y5cTtYp4IyRv9y2c48DCrzIREREpCTr3bs3VapUYdy4cXzzzTdMnjyZjRs38vHHH1O+fHnAl6S1b9+erl27ct111xETEwPAypUr6dChAw0aNGD06NFER0fz8ssv0717d+bMmUPPnj1D9u2co3v37rz77rv079+fpk2bsmTJEjp16pRn3E888QT//Oc/mTt3Lo8//jiJiYnUrl2bq6++Omi5Fxs3buTKK6+kQYMG3H333cTGxrJt2zZee+019u/fn+v7hIcPH6Zt27asX7+egQMH0qBBAxYtWsSIESNIS0vj6acDd51bvXo1r7/+OoMGDaJ///5Mnz6dPn360LRpU+rXr+8p5hNxsiaAGe/+5XjPz8yqAacQ5P1AERGR0qBy5cq8/fbblClTBoBGjRqRnJxMamoqAwcOBGDHjh1MnDiR22+/PfM55xzJyclccMEFLF26NPP5lJQULrnkEkaOHMkNN9wQcsPiBQsW8O6773LvvfcyduzYzOd79erF559/HjLuq6++mvXr1zN37lyuvvpqkpKSMu/lVp5fb7/9Nr///jtvvvkmWV//uv/++0M+99xzz/H5558zZcqUzL+7IUOGcP311/PMM88wePBgGjZsmFn/yy+/5LPPPqNRo0YAXHfdddSoUYPnn3+ef/zjH57jLqiTdQp4hf+zfZB77bPVERERKVVuueWWzOQNoG/fvpx66qksWLAgsywqKopBgwYFPPf555/z1Vdf0atXL/bs2cPOnTvZuXMnu3bt4sorr2T79u18/fXXIftesGABZsawYcMCym+77bYw/LKCy3h38D//+Y+n49YWLFhAQkIC/fr1yywzM0aMGAHAwoULA+q3bt06M/kDqFatGvXq1ePbb789kfA9K/EJoJnVNrN6Zpb5RqZzbgPwIXC5mbXLUjcWuAs4BER+wl1ERKQYqFu3bsD3cuXKcfbZZ/Pdd99llp1++ulUrFgxoF5Gcjdo0CCqVq0acGW8g5fxLuFPP/0UcB04cACArVu3kpiYSOXKlUPGFGnXX389bdq0YeDAgSQmJtK9e3dmzJiR5+KXtLQ06tSpk2NhSIMGDQAC/k4BatasmaONhIQEdu/efYK/wJtiOQVsZgOAVv6vzf2ffzezvv4/T3fOvef/8zv4jo2rBaRlaWYw8B7wupllHAXXHagN3OKc+2+h/QAREZESLuOdv6wyFjWMHz+eCy64IOhzGaNbZ5wReODWfffdF7DJc6SYGc65HOXZR/mio6NZunQp77//PosWLWLx4sUMGDCABx54gA8++IDTTz89LPFkHXnNKliMhalYJoD4kr+bspV1zPLnZfiSu1w55z4zs4uAB4CrgQrAeuBO59wr4QtVRESkZNm0aVPmCBXA0aNH+e6772jVqlWIp6BOHd+r9ZUqVaJdu3Yh6y5eHHgWw9lnnw34RsDefvttdu/eHTAKuGnTJk+/Ib8SEhKCTq9mP10EfMliq1ataNWqFQ8++CCLFi3iyiuvZOrUqdx3331B209KSmL16tWkp6dTtuz/0qqNGzcCvlXJxVGxnAJ2zvV1zlmIa2aWukn+srQg7ax3zl3tnEtwzlV0zl2o5E9EREq7p556KmAEbObMmezdu5fOnTuHfK5Zs2acc845TJw4Megxazt27Mj8c7t27QKujASwc+fOOOeYNGlSwLNPPPHEifykXNWpU4eNGzfy888/Z5b98MMPObat2bVrV45nmzZtChDySLkuXbqwe/duUlNTA8offfRRAK666qoCx16YiusIoIiIiBSS3bt306FDB7p3787mzZt55plnOO+88wIWMgQTFRVFampq5jYw/fr1o2bNmvz888989NFHbNiwgS1btoRso0uXLrRp04b777+fH374gWbNmrF48eIc78qFy4ABA5g4cSIdOnTg5ptvZu/evTz77LPUrVuXTz75JLPeuHHjePfdd7nqqqtISkriwIEDpKamUqZMGf785z+HbP+5555j8ODBrFu3jvr167No0SIWLFhASkpKwEhrcaIEUEREJB+aNWsW8n5sbGyEIjlxL7zwAo888gj33HMP6enpXHPNNUyaNClzD8BQWrZsyccff8y4ceOYNm0ae/fupVq1ajRu3JgHH3wwz+fNjFdffZXhw4czd+5cXn75Zdq1a8cbb7zBWWedFY6fF+Dcc8/lX//6F3fffTe33347derU4bHHHmPjxo0BCWC3bt34/vvvmT17Nr/88gvx8fE0a9aMZ555hosvvjjX9itUqMC7777L6NGjmTt3Lrt27SIpKYlHHnmE4cOHh/33hItF+qXDkqZ58+ZuzZo1hd5PST47s6THAcUnFsVRPOOA4hOL4ijcOOLi4jLfc/OqJCSAY8aMYezYsXz//fdUr169qMORAti4cWPIDaPN7BPnXPNcK/gVy3cARURERKTwKAEUERERKWWUAIqIiIiUMkoARURESokxY8bgnNP7f6IEUERERKS0UQIoIiIiUsooARQREREpZZQAioiIiJQySgBFREREShklgCIiIiKljBJAERERkVJGCaCIiIhIKaMEUERERKSUKVvUAYiIiJQEsT/EFXUIPvVcUUcgJwGNAIqIiJRiBw8eLOoQpAgoARQRESklxowZg5nxxRdf0K9fPxITE6levTpbt25l6NCh1K9fn0qVKhEXF0e7du1YtWpVwPNpaWmYGQ888ACpqanUrVuXmJgYWrRowbp16wCYPXs29evXJzo6mmbNmrF69eqANvr27UvZsmXZvn073bp1IzY2lipVqjB48GAOHDiQr9/Rt29fkpKScpTPnDkTMyMtLS2zLCkpiXbt2rFixQouvPBCYmJiSEpK4rHHHvP2l3eS0RSwiIhIKdOzZ0+qV6/O2LFjOXDgAKtXr2bp0qVcc8011KxZk507dzJjxgzatm3LmjVraNSoUcDz8+bNY9++fQwcOJD09HQefvhhOnXqxP33389DDz1EcnIyx44d4+GHH6ZHjx5s2bKFsmX/l3I45+jUqRPnnnsuEyZMYM2aNUyZMoWtW7fyxhtvhP33bt26la5du9K3b1/69OnDvHnzGD58OEePHmXUqFFh768kUAIoIiJSytSuXZv58+djZgAcOnSIHj16BNQZNGgQ9erVY9KkSTz33HMB97799ls2b95MYmIiAPHx8QwZMoSRI0fy9ddfU6VKlYDyJUuWcMUVV2Q+f/z4cZo1a8asWbMyy8444wzGjx/PW2+9RceOHcP6ezdv3szzzz/PX//6VwCGDBnCZZddxtixYxk4cCDx8fFh7a8k0BSwiIhIKTN48ODM5A8gJiYm88+HDh1i165dHD9+nAsvvJBPPvkkx/PXXnttZvIHcPHFFwNw9dVXZyZ/Wcu//fbbHG3cdtttQb8vWLCgID8ppCpVqtCnT5/M72XKlOGWW27h0KFDvPPOO2HvryTQCKCIiEgpU7t27YDvR44cYezYscyePZvvv/8+4F6tWrVyPF+jRo2A7xkjaLmV79mzJ0cbdevWDfhetWpVEhIS+O677wA4cOBAjncCTz/99Fx/Uyhnn312wBR01v4z+ittlACKiIiUMllH/ACGDRvGtGnTSElJoWXLliQkJBAVFcVDDz3Eli1bcjxfpkyZoO3mVu6c961rHn30UcaOHRu0nayjl1kdO3bMcz+llacE0MwSgKbAPufcmmz3TgcmAm2ACsCbwAjn3E9hilVEREQKwYsvvsiNN97Ik08+GVB+7733FlqfmzZtomnTppnfd+zYwZ49ezJHHG+88UZatWoV9NmEhAT27t2bozzr6t+svv32W9LT0wNGATdt2gQEH+EsDby+A5gMLAb+krXQzCoAK4AbgDOBKv46y8ysYhjiFBERkUISFRXF8ePHA8pWrlzJhx9+WGh9PvHEE0G/d+7cGfBN27Zr1y7gylCnTh1+/fVXPv3008yyAwcOBCwqyWrXrl3Mnj078/uxY8d46qmniI6Opm3btmH7TSWJ1yngjGU5/8xWfhNQB9gD3AMcAsYB5wBDgUdOIEYREREpRN26dWPWrFmccsopNGnShI0bNzJ9+nQaNmzI/v37w95fVFQUa9eu5dprr+Xyyy9nzZo1pKam0qFDh4DVwrnp2bMnf//73+nevTvDhg3j6NGjPP/881SrVi3HO4zgSxj/9re/sW7dOmrXrs28efNYuXIl48ePJyEhIey/ryTwOgKYMU66IVv5nwEH/N05N9k5lwr8FTCg+4mFKCIiIoVp0qRJDBw4kHnz5jFs2DDef/995s6dyx//+MdC6c/MWLRoEenp6YwaNYr58+eTnJzM3Llz8/V8QkICr776KvHx8YwaNYpnn32WlJQUUlJSgtavWbMmr732Gu+//z533HEHW7Zs4R//+Ad33nlnOH9WieJ1BLAq8Ktz7lBGgZmVBVoAx4FXstRdAhwD6p1okCIiIkVt/1n7Qt6PjY2NUCQFN2bMGMaMGZOjPDY2lsmTJzN58uSA8g4dOgR8T0pKCrqgw2s5QPXq1Xn11Vc9RB/osssu47PPPstR3rdv36D1W7duzccff1zg/k42XkcAo4Ds7/Q1A6KBdc65zDcyne+f+N4g9UVERESkCHlNALcD5czsvCxl3fyfK7NWNN8a7ThgR8HDExEREZFw85oALsX3Xt8zZtbUzK4EUvC9/5d96+4GQDl8SaOIiIiIFBNeE8AJwAGgJbAGeB3fKN9Hzrkl2ep2wZcYrjrRIEVEROTkMHPmTNLT0yPWX1paGkuWZE9RxFMC6Jz7FrgceB84CuwGZgNds9Yzsyh8ewYavsUgIiIiIlJMeD4Kzjm3GmidVzXgAv+fcx4AKCIiIiJFplDOAvavAN5VGG2LiIiIyIk54QTQzKrj2x8QYIdzTos+RERERIoxr4tAADCzmmY22cx+AbbiWxCyBthqZr+Y2dNmVjOcgYqIiIhIeHhOAM3sGmA9MBBIxLfQI+uVCAwG1puZjoETERERKWY8JYBm9kfgRaASsAUYAjQE4v1XA3/ZN/46L5lZ03AGLCIiIiInxus7gPf4n1kCdHXO/Z7t/j7gKzNLxbdHYDvgXkAjgSIiIiLFhNcp4Fb4tngZFCT5y+ScO4xvGhjgkgLGJiIiIpJvY8aMwXcSreTF6whgNPCrf0PokJxzW8xsr/8ZERGREi329biiDsHnL66oI5CTgNcRwG+BSmZWIa+K/jqVgM0FCUxERERECofXBHAWUA64OR91B/jrzvIalIiIiETGwYMHizoEKQJeE8DHgdeAx8zsjmAjgWZW3syGA48BrwJPnHiYIiIicqIy3pH74osv6NevH4mJiVSvXp2tW7cydOhQ6tevT6VKlYiLi6Ndu3asWrUq4Pm0tDTMjAceeIDU1FTq1q1LTEwMLVq0YN26dQDMnj2b+vXrEx0dTbNmzVi9enVAG3379qVs2bJs376dbt26ERsbS5UqVRg8eDAHDhzI929ZuHAhjRs3Jjo6mnPPPZcZM2YErXf8+HEeeeQR6tatS4UKFTjzzDNJSUlh7969mXWeffZZzIytW7dmlv373//GzGjfvn1Ae506daJx48aZ35OSkmjXrh2rV6+mZcuWxMTE8Ic//IHHHnss37+lKHh9B3AKsAM4CEwA7jGzj4Ef/PfPBC4EYoFfgZ3A1CAvZDrn3MCCBi0iIiIF17NnT6pXr87YsWM5cOAAq1evZunSpVxzzTXUrFmTnTt3MmPGDNq2bcuaNWto1KhRwPPz5s1j3759DBw4kPT0dB5++GE6derE/fffz0MPPURycjLHjh3j4YcfpkePHmzZsoWyZf+Xcjjn6NSpE+eeey4TJkxgzZo1TJkyha1bt/LGG2/kGf+7775Lt27dOPvssxk3bhy///47d911F2eccUaOukOGDGHq1KlcddVV3HrrrWzYsIEpU6bw4Ycf8sEHH1C+fHlat24NwIoVK+jTpw8Ay5cvJyoqig8++ID09HTKli3LsWPHeP/997npppsC+ti2bRtdunShT58+9O7dm5deeonhw4fTsGFDOnbs6PmfTyR4TQAH4FsFnJHRxQKX51I3HuiXpW5WDt9G0iIiIhJhtWvXZv78+ZkrZg8dOkSPHj0C6gwaNIh69eoxadIknnvuuYB73377LZs3byYxMRGA+Ph4hgwZwsiRI/n666+pUqVKQPmSJUu44oorMp8/fvw4zZo1Y9as/70ldsYZZzB+/HjeeuutPJOmESNGcOqpp/LBBx9k9tWjRw/OO++8gHrr169n6tSp9OzZkzlz5mSWN2jQgKFDhzJ9+nSGDBlCgwYNSExMZPny5ZkJ4IoVK7juuut46aWXWLNmDRdddBGffvop+/fvz0wYM3zzzTcsWrQo8zf269ePGjVqMH369JMmAXywUKIQERGRiBk8eHDAdikxMTGZfz506BC//fYbzjkuvPBCPvnkkxzPX3vttZnJH8DFF18MwNVXX52ZkGUt//bbnJuH3HbbbTm+jx8/ngULFoRMmn788UfWrl3LrbfeGtBX/fr16dixY8AI4oIFCwC44447Atq4+eabufvuu1mwYAFDhgzBzGjVqhUrVqwAYO/evXzxxRc89NBDrFq1ihUrVnDRRRdl3s+eANaqVSsgwa1QoQIXXXRR0N9dXHhKAJ1z9xRWICIiIhIZtWvXDvh+5MgRxo4dy+zZs/n+++8D7tWqVSvH8zVq1Aj4Hh8fH7J8z549OdqoW7duwPeqVauSkJDAd999B8CBAwdyvBN4+umnZ76nl/35jLKsCWBaWhoA9erVC6hXvnx56tSpk9kX+JK6+fPn8+OPP/LJJ59gZrRs2ZLWrVuzfPlyRo4cyYoVKzj33HOpVq1aQHs1a9bMEUtCQkLme5HFkeezgEVERKRkyzriBzBs2DAefvhhrr76al588UXeeustFi9eTNu2bTl+/HiO58uUKRO03dzKnfO+d+Gjjz7KGWecEXAVpqzvAa5YsYImTZoQFxdHmzZteP/990lPT+e9997LMfoH4f3dkeJ1ClhEREROMi+++CI33ngjTz75ZED5vffeW2h9btq0iaZNm2Z+37FjB3v27Mkccbzxxhtp1apVjucyRts2bdoUtM2skpKSAPjqq69o1qxZZvnRo0fZsmULF110UWZZRsK3fPly1q5dm5notW7dml9//ZU5c+awa9euoAlgSeRpBNDMWhTkKqzgRURE5MRFRUXlGOlbuXIlH374YaH1+cQTTwT93rlzZwDOPvts2rVrF3CBb7FI06ZNeeGFF9i1a1fm8xs3buStt94KaPOqq64CyLEly/Tp09mzZw9dunTJLCtTpgwtWrTgrbfeYu3atbRp0wbwTStXq1aN8ePHAznf/yupvI4AvodvBa8XrgD9iIiISIR069aNWbNmccopp9CkSRM2btzI9OnTadiwIfv37w97f1FRUaxdu5Zrr72Wyy+/nDVr1pCamkqHDh0CFlPkZsKECVxxxRVcfPHFJCcnc+jQIZ5++mkaNWrE559/nlmvUaNGDBw4kKlTp7Jv3z6uuOKKzG1gmjVrRv/+/QPabd26NW+++SZmxiWXXBJQ/sorr1CjRo2g7/uVRF4Ts/8SOgGMw7c1DMBvQM63PkVEREqg/V32hbwfGxsb8n5xNmnSJKKjo5k3bx6pqamcd955zJ07lzlz5rBs2bKw92dmLFq0iJSUFEaNGkW5cuVITk7m0Ucfzdfz7du3Z/78+YwePZrRo0dTs2ZNxo8fz/fffx+QAAJMnjyZs88+m+nTp/Pmm29SpUoVkpOTefDBBylfvnxA3YzRvYYNG1K5cuXM8jZt2vDKK6+cNKN/4H0VcPW86phZXeBO4M/A351z/yxgbCIiIhJGY8aMYcyYMTnKY2NjmTx5MpMnTw4o79ChQ8D3pKSkoAsbvJYDVK9enVdffdVD9IG6dOkSMIWbIfvvi4qKYuTIkYwcOTLPNlu2bBk03pSUFFJSUoI+k7HSOLuZM2fm2V9RCvvUrHNuE9DXzA4CqWb2rXPug3D3IyIiIiIFU5jbwIwFygB3FWIfIiIiIuJRoSWAzrlf8J0HfFFedUVEREQkcgotATSzOOBUoOIJtNHKzBab2a9mtt/MlppZWw/Pm5ndYGbvmdkv/jbWm9n9ZpZQ0LhERESkYGbOnEl6enpRh1HqFeYU8H2AAV8X5GEz6wgsAy4A5gAzgHrAYjPrms9mJgH/AqoDLwFTgYPAPcAHZlapILGJiIiIlGSeFoGY2V/yqBKNL9nqBjTBt2XMNK9BmVl5fMnaEaClc+5Lf/kE4DNgipktds4dCtHGGcBQ4CugWda6ZjYb6A1cB8z0Gp+IiIhISeZ1FfAL5G8jaPN/Pumce9ZjHwDtgJrA9IzkD8A596OZPQWMA64E/h2ijZr+OJYHSRTfwJcAJhYgNhEREZESzWsCuIrQCWA6sBf4AnjFOfdFAePK2GlxcZB7i/ElgG0InQB+g28EsY2ZxWRLAq/0fy4vYHwiIiIiJZbXjaBznspcOOr4PzcHubc5W52gnHO7zOweYAKwwcwWAIeBS4CGwC3OudXBnjWzZCAZoEaNGt6jFxERESnGiusZvXH+z2Dn7mSUnZpXI865R8zsF+BZfO8DZngFeDPEc9Pwv7vYvHlzr2cfi4iIiBRrhbkKuMiZ2Th8i0lGA2fhSxo741tZ/JGZnVOE4YmIiIgUiQIngP49+p7077G3yX+95y870anijFG+uCD3Msp+zSO+9sDd+BaiPOac+69zbp9z7g3gL0Bl4N4TjFNEREROUsuWLcPMWLZsWVGHEnaeE0Azq2JmC/EtoEgBWgDn+K8W/rLlZrbAzKoUMK5Q7/mFej8wqyv8n8EWenwI/A409R6aiIiIjBkzhtdee62owyAtLY0xY8awbt26og6lRPG6D2B54C18iZMBq4F3ge3+KtWBtvimWDsBb5pZC+fcUY9xrQBGAe2Bl7Pda5+lTigV/J/BtnqJxbdn4WGPcYmISCn1zVNdijoEAJrdtayoQwBg7Nix9O/fn65d83s2Q+FIS0tj7Nix1KlTh/PPP79IYylJvI4ADgGa4Zt+7eyc+5Nz7k7n3DP+607n3J+Aq/BN4zbzP+PVEmAb0MvMGmYU+jd3vgX4EViYpby2mdUzs3JZ2ljl//ybmZ2Srf37/J/aBkZERKQYOXjwYFGHUCp4TQBvwLcPYLJzblFulfzv2SXjGyXM6/SQYM8fAQYC5YH3zexZM3sCWItvRG9wtn393gE24lvokeFl4APgfGCTmU01s4lm9hFwO75RywleYxMRESmpDh48yKhRo6hduzbR0dFUqVKFiy66iLlz5wKwdetWhg4dSv369alUqRJxcXG0a9eOVatWZbaRlpaGme+8hxkzZmBmmBl9+/YFfFPDGfezCvY+3aWXXkqmkXTiAAAgAElEQVSdOnVYv3497du3JzY2ll69egGwcuVKbrjhBpKSkqhQoQKnnXYavXv3Zvv27ZnPz5w5k8suuwyAPn36ZMYyc+bMzDpr166la9euJCQkEBMTQ/PmzZk/f36O+DZt2kTHjh2pWLEip59+OiNGjODIkSMF+4suAbxuA1MP37RpqA2YM/zbX7ee16AAnHNvmtmlwBh8p3YYsAbo5Zx7Nx/Pp5tZO+AOoAdwI1AG+B54GnjAOfdzQWITEREpiYYMGcK//vUvhgwZQqNGjdi3bx+fffYZH330ET169GD16tUsXbqUa665hpo1a7Jz505mzJhB27ZtWbNmDY0aNaJq1arMnj2bPn36cOmll9K/f38AateuXaCY9u3bR/v27enatSvXXXcdMTExALzyyivs2rWLAQMGUK1aNb755humTp3KRx99xLp164iJiaF169bcddddjB8/nsGDB9OiRQuAzM+VK1fSoUMHGjRowOjRo4mOjubll1+me/fuzJkzh549ewLwyy+/0KZNG3777Tduv/12EhMT+b//+z8WLw52HsXJwWsCWB444pzLc28859xxMzsClMurbog23sN3LFxe9ZJyKf8NuN9/iYiIlGqvvfYaN998M0888UTQ+507d6ZHjx4BZYMGDaJevXpMmjSJ5557jkqVKtG7d2/69OlD7dq16d279wnFtGPHDiZOnMjtt98eUP7www9TsWLFgLKuXbtyySWXMG/ePHr16sXZZ59N+/btGT9+PC1atAiIxTlHcnIyF1xwAUuXLqVMmTIApKSkcMkllzBy5EhuuOEGzIwJEybw888/8+6772aOKCYnJ9O4ceMT+m3Fmdcp4G1ArJk1yauimTXFt9hiW0ECExERkfCKj4/no48+4vvvvw96P2P0DeDQoUPs2rWL48ePc+GFF/LJJ58USkxRUVEMGjQoR3nW5G///v3s3LmTevXqER8fn69YPv/8c7766it69erFnj172LlzJzt37mTXrl1ceeWVbN++na+//hqABQsWcP7552cmfxn9Jycnh+EXFk9eE8BF+KZiZ4Ta4sXMqgIz8L0v+EbBwxMREZFwmThxIhs3bqRmzZo0adKEESNGBCRTR44cYfTo0dSoUYOKFSuSmJhI1apVWbhwIXv37i2UmE4//fQcI30A//3vf+nduzfx8fHExcVRtWpVqlatyt69e/MVS0ZyN2jQoMxnM67Ro0cDvqlf8L37WLdu3RxtBCs7WXidAp6A7126JsBXZjYVWAb8gG9blRrAZUA/4BRgD/BIuIIVERGRgrvmmmto1aoVr7/+OkuWLOH5559n4sSJPPjgg9x5550MGzaMadOmkZKSQsuWLUlISCAqKoqHHnqILVu25KuPYAtAAI4dOxa0POuoY4bjx4/Tvn17fvrpJ0aMGEGDBg045ZRTMDNuuOEGjh8/nmccGXXGjx/PBRdcELROo0aN8mznZOUpAXTO/WRmnYH5wGnAnf4rOwN+Bro753464ShFREQkLE477TT69+9P//79OXToEFdeeSVjxozhjjvu4MUXX+TGG2/kySefDHjm3nvzf3BWQkICAHv37iU+Pj6zPC0tLd9tfPHFF2zYsIGZM2dy0003ZZYfOnSIPXv2BNTNLeGsU8d3bkSlSpVo1y70coKaNWuyadOmHOXByk4Wnk8Ccc59CDQAxuHbegV8CV/GP4GN+BZdNPTXFRERkSJ27Ngxfv018BTVmJgY6taty5EjRzh48CBRUVE5RtdWrlzJhx/m/J/zSpUqBZ2KzUi8li5dmlmWnp7OlClT8h1rVJQvPckey8SJE3OUVapUCSBHLM2aNeOcc85h4sSJQePcsWNH5p87d+7MunXrAmL+7bffmDZtWr5jLmm8TgED4JzbjW8z5fvMLBrIeB9wl3Pu93AFJyIiIuGxf/9+zjrrLLp3707jxo2pXLkyn376KdOnT6dTp07Ex8fTrVs3Zs2axSmnnEKTJk3YuHEj06dPp2HDhuzfvz+gvT/+8Y+8/fbbPP7445xxxhnUqlWLP/3pT3To0IGkpCQGDBjAV199RUxMDHPmzPEUa/369Tn33HMZPnw427Zto1q1aixbtoxVq1ZRpUqVHHVjYmKYPHkyMTExVKpUiT/96U/UqlWL1NTUzG1g+vXrR82aNfn555/56KOP2LBhQ+a09qhRo3jhhRfo1q0bt956a+Y2MBnJ5cnI61FwGad6/Mc59yOAP+H7IdyBiYiISPhUrFiRoUOHsmTJEhYuXMjhw4epUaMGd911FyNHjgRg0qRJREdHM2/ePFJTUznvvPOYO3cuc+bMCdjAGeDpp59m8ODBjB49mkOHDnHTTTfxpz/9ibJlyzJ//nxSUlIYM2YMVapU4eabb6Z169Z5TsVmKFu2LAsWLOC2227j8ccfxzlHmzZtWLp0KZdffnlA3UqVKjFr1izuvfdeBg0aRHp6OqmpqdSqVYuWLVvy8ccfM27cOKZNm8bevXupVq0ajRs35sEHH8xso1q1aixfvpxbb72ViRMnEhcXR58+fejQoQMdO3Y8sb/4YsrrCOBTwDF8K3xFRERKjXNueT3k/djY2AhFUjDly5dnwoTQB2DFxsYyefJkJk+eHFDeoUOHHHXPO+883nvvvaDtNG7cOOi97NsIZ08qszrnnHNYuHBhjvJg7xJed911XHfddUHbadiwIS+++GKu/WSoX79+0I2f87H1cYnkNQHcCZR1zh0ujGBEREREpPB5XQTyKXCqmSUWRjAiIiIiUvi8JoBP+Z8ZXQixiIiIiEgEeEoAnXMLgb8DQ80s1cwaFk5YIiIiIlJYvK4C/tr/xyP4TgS50cwO4Hs3MPgW3+CccyfvWSoiIiIiJYzXRSB1gpTF+q/cnJzLZ0RERERKKK8JYPtCiUJERKSYcM7leryYSFEK55Y0Xs8CfidsPYuIiBQzzjmOHTtG2bIFOihLpFAdPXqUMmXKhKUtz2cBi4iInKyOHDnCgQMHijoMkaD27dsXtg3HlQCKiIj4HTlyhB07drB3717S09NP2lMgpORwznHkyBF27tzJnj17qFy5clja9boK+C6P7R8G9gIbgTXOuSMenxcREYkY5xwHDhzgyJEjlC9f3tO7gNHR0YUYmZRmZcqUITY2lho1alChQoWwtOn1JYcHKPiq3r1m9hTwoHPuaAHbEBERKVTOOQ4fPszhw95OPW3atGkhRSQSfl4TwDn4EsDOQDxwCN/xcP/13z8DaApUBPYAi4BT/WVnAvcAF5jZVU7j6iIiIiJFwus7gH2A8vj2/bsLOM0518o592f/dQlwGnCnvw7OuS7AH4Cb8E0JX+FvR0RERESKgNcEcCjQAxjunHvYOXcwewXn3G/OuQnAHUBPMxvsfGbjO0PYUAIoIiIiUmS8JoD9gHRgWj7qTsN3PNyALGUz8U0hN/bYr4iIiIiEidcEsA5wwDn3e14V/XUOAOdkKduDb1XwqR77FREREZEw8ZoAHgHizax6XhXN7A/4FoqkZ7tVCV8SKCIiIiJFwGsC+JH/8ykzy/UsEjOLAibhm+79MEv5WfgWkfzosV8RERERCROvCeBD/s+uwMdm1tvMaplZtP+qZWZ9gNVAN3wJ4ENZnu/m/3z/hKIWERERkQLztA+gc26lmQ0ApuDb229WLlUN39TvEOfcyizllYGXgH8WIFYRERERCQOvG0HjnEs1s4/wbenSFd87fVkdBF4Dxjvnvsz27AMFDVREREREwsNzAgjgnNsA9PK/63cOkOi/tRP4xjl3PEzxiYiIiEiYFSgBzOBP9Db5LxEREREpAbwuAhERERGREk4JoIiIiEgpowRQREREpJRRAigiIiJSyigBFBERESlllACKiIiIlDJKAEVERERKGU8JoJlV8dqBmV3m9RkRERERKTxeRwDfMrNT8lvZzDoCCzz2ISIiIiKFyGsC2AxYaGbReVU0s87AfCDPuiIiIiISOV4TwNVAK2CemeV6jJyZdQf+DVQAnil4eCIiIiISbl4TwCuAjUBHYI6ZWfYKZnY98CJQHnjcOXfrCUcpIiIiImHjKQF0zu0B2gNpwLXA9Kz3zawP8AJQDnjYOTc8PGGKiIiISLh43gbGOfcj0A74CehrZo8DmNkAIBUoA9zvnLsrnIGKiIiISHjk+h5fKM6578ysPbACuNXM6uEbGYwC7nbOjQ9jjCIiIiISRgXeCNo5twHoBBwAOvjbGqHkT0RERKR4C7WSt0U+23gEGAf8C/gg2HPOuVUFC09EREREwi3UFPB7gMtnOw64wX8Fu1egqWYRERERCb9Qidl/yX8CKCIiIiIlRK4JoHOueiQDEREREZHIKPAiEBEREREpmZQAioiIiJQynhZnmNmZQF/gR+dcah51+wPVgOedcz8VOEIRERERCSuvI4B98W35UiUfdWv46/bx2IeIiIiIFCKvCWAX/+fcfNSdBRjQzWMfIiIiIlKIvCaAScBvzrm0vCo6574FDgK1vIclIiIiIoXFawKYABzxUP8I+ZsuFhEREZEI8ZoA7gTizSwxr4r+OvHAnoIEZmatzGyxmf1qZvvNbKmZtS1AO1eZ2dtmtsvMDpnZN2Y208xiCxKXiIiISEnnNQH8yP85MB91B+F7B/Bjj31gZh2BZcAFwBxgBlAPWGxmXT208wjwOlDT386TwGqgE3Cq17hERERETgZez+idAXQH7jOz7c65WcEqmdlfgXvxHSU3w0sHZlYemIpv+rilc+5Lf/kE4DNgipktds4dyqOdG4ARwCTgdufc8Sz3tP+hiIiIlFqeEkDn3Btm9hJwPfC8md0OvAFs81epiW90rRG+0b+5zrnXPMbUzt/O9Izkz9/3j2b2FL6tZa4E/p1bA2Zm/nqbgeFZkz9/W8eDPigiIiJSCngdAQS4CdgH3Aychy/Zy8r8n9OBWwrQfmv/5+Ig9xbjS+zaECIBBJoAdYCJQDkzu8b/fSfwlnNuW4hnRURERE5qnhNA59wRYKCZPQ3cCFyE78QPgJ+BD4H/c859UcCY6vg/Nwe5tzlbndz80f95HFgHnJPl3lEzG+2c+0cB4xMREREp0QoyAgiAP8EbEcZYMsT5P/cFuZdRltcCjoxVyrfjW/RxPb7ksQW+kclHzGyjc25BsIfNLBlIBqhRo0b+IxcREREpAU7WxRAZv+sw0N0596lzbr9z7i1ggP/e33J72Dk3zTnX3DnXvGrVqoUdq4iIiEhEFXgEEMDMKgPNgIwsaQew1jm3+wSazRjliwtyL6Ps1zzayLi/xjn3U7Z7i/Elhn9EREREpBQqUAJoZhcBDwCX5XL/XeBu59xHwe7nIet7fmuz3Qv1fmBWX/s/cySKzrnjZraf4AmmiIiIyEnP8xSwmQ0AVuJL/gzfXn+7/Zfzl10OvGdm/QsQ0wr/Z/sg99pnq5ObD/GN8tXPfsN/Qkki/9u6RkRERKRU8ZQAmlljYApQBl+S1RmIc85Vdc5VBWKBq/z3yuDbtLmxx5iW4EvOeplZwyx9n4FvW5kfgYVZymubWT0zK5dR5pzbD/wLqGNmfbPUNXwjlxB6GxkRERGRk5bXEcA7/M/8G7jEObfIOfdbxk3n3CHn3BtAK+A/+JLA4V46yNhmBigPvG9mz5rZE/imgxOBwdlOAXkH2Aicla2pvwNp+Dasnm9mjwLv+9veAIz3EpeIiIjIycJrAtgG3zTvsFCnafjvDfN/DfqeYCjOuTeBS4E1QG98K3c3Ae2dc6/ms42f8e1ROB24ELgVX5L4OL4j5oJtMyMiIiJy0vO6COQ0YK9z7r95VXTObTezPfxvhbAnzrn38B0Ll1e9pBD3fsa/n5+IiIiI+HgdAdwPxJpZxbwq+uvE+p8RERERkWLCawK4Ft97fUPzUfcWfCOM2bdyEREREZEi5DUBfA7fNi/jzWyMmcVmr2Bmp5nZI/hW2zpg2omHKSIiIiLh4ukdQOfcXDObA/wFuAcYaWZrgR+AaKAGUA/fCl4D/umc03YrIiIiIsVIQU4CuRH4ChgJnAK0CFLnAPCw/xIRERGRYsRzAujf4uUBM5sEdCTIWcDAm865A2GLUkRERETCpkBnAUPmaRtz/ZeIiIiIlBCezwIWERERkZJNCaCIiIhIKZPrFLCZvR2mPpxzrmOY2hIRERGRExTqHcA8j2HLJxemdkREREQkDEIlgDdHLAoRERERiZhcE0Dn3IxIBiIiIiIikaFFICIiIiKljBJAERERkVKmQAmgmUWZ2Z/N7GUz22xmv/qvzf6yHmam5FJERESkGPJ8EoiZnQO8DJwPWLbbscDZwLXAOjO7zjm3+YSjFBEREZGw8ZQAmlk1YAVQDTgK/AdYDvzgr3Im0AboDjQGlptZU+fcL2GLWEREREROiNcRwDH4kr/vgKuccxuD1JliZnWBN4Ak/zNDCh6iiIiIiIST1/f0rsK3sXO/XJI/AJxzm4B++KaIryp4eCIiIiISbl4TwETgoHNueV4V/XUOAlULEpiIiIiIFA6vCeCPHp8x/zMiIiIiUkx4TQBfB2LMrGNeFf11KgKvFiQwERERESkcXhPAscBWINXMLsytkpldADwPfAvcX/DwRERERCTccl0FbGZ/yeXWk8B9wCozWwosI+c2MJcD+4BHgE7AnDDFKyIiIiInKNQ2MC/gW/GbG8OX6LUNUg5wKvCY/89KAEVERESKiVAJ4CpCJ4AiIiIiUgLlmgA651pFMhARERERiQyvi0BEREREpIRTAigiIiJSyigBFBERESlllACKiIiIlDJKAEVERERKGSWAIiIiIqWMEkARERGRUkYJoIiIiEgpk2sCaGZHzWxrtrK/mFn3wg9LRERERApLqKPgygDlspW9APwI/KfQIhIRERGRQhVqCvgwcEqQciukWEREREQkAkIlgGlAJTO7KkKxiIiIiEgEhJoCfhG4D3jVzH4GDvjLE83saw99OOdc3YIGKCIiIiLhFSoBHA8kAb2B07M9U8dDH857WCIiIiJSWHJNAJ1zR4G/mtntQD2gIrAY2A1cH5nwRERERCTcQo0AAuCc2wN8AGBmAEecc+8UclwiIiIiUkjyTACzuRn4rTACEREREZHI8JQAOudmFFYgIiIiIhIZXkcAM5lZDaAH0Ayo6i/eAawF5jrntp14eCIiIiISbp4TQDOLBh7DNx0cRc6NoXsCE8xsKnCHc+73E45SRETEozbVLo1wj7lvenHXqEHs2pHGVVdcQJdOFzLynlR+3ed7o6pG9aqMHvFnXnhxKSs/2JD5zISxN7Ft+w6eee6NzLLe11/KJS0aMnDYM5ll5zdMIiW5M89MW8i6L9OoUjWJ8ROmhIwj3H1mmDophZWrvuSFl5aFjIMjX/PCrCmF1neGlJuvpEbtFsSf1jzk30eh9l+9KqPumwUQ+u8kwsy5/O/SYr5VIG8AHfAlfj8By4Ht/irVgTb4to1xwFvOuSvDGXCkNW/e3K1Zs6bQ+1m+fHmh95GhTZs2iiOb4hKL4iiecUDxiUVx5D8OvorwwVX1cv/f04H9rmDq+JoRCWPgXVuZ+vybQe+NvO0aHvl71aD3IhnHg/f2YfSQikUexwvP3U7vLgcjEgfAC69XovfNjxVqH2b2iXMueMabRaiTQILpC3QEjgApQHXnXE/n3Aj/1RNfEjgUOAp0NLO+HvsQERE5qdw1/LqI9TV1Ukqu9x4Z99eIxZFyc+7jP9u274hYHKH0vuGyk7q/ULwmgDfhG9kb5px71jl3PHsF59xx59xk4DZ8o4R9TzhKERERyZeVq77M9d7riz6OWBw1qkdmpPFEPPiPl0/q/kLxmgCeh29kLzUfdZ/31z3fa1AiIiInk/ETX4lYX1nfQctuwZurIxZHxntvwZwaF5npX4BLLm6Q671Ij0QWl5FP8J4AVgR+858SEpJz7ghwEIgpSGAiIiJycorkVHRxmnYtTrwmgD8Cp5pZ7bwqmlkdIN7/jIiIiAgQ2anoUNOukRyJLIr+QvGaAL6D772+Z82sQm6V/Peexfe+4JKChyciIlLyXXXFBRHrK9Tii0guRgk19RrJqehQ066RHIksiv5C8boP4ASgN3A58LmZPQosA34AooEawGX4FoD8ATgMPBKuYEVEpPiL7P57+d/KrCh16XQhHFwQkb6Ky+KLkjD1+vqij+nSOsL9/blL5DoMwdMIoHNuM3ADcAg4F5gKbAIOADvxnQIyEV8i+DvQ0/+MiIhIqTXynvysnQyPUIsvIrkYpbiseA017RrJkcii6C8Ur1PAOOdeBZoAs/ElfpbtOgD8H9DYX1dERKRUyzj1ozQJNfUayano4jTtWpwU6Cxg/6jeTf6TQc4h8Czgb5yX40VERERECklxmnYtTjyPAGblfL52zr3vv74OZ/JnZq3MbLGZ/Wpm+81sqZm1PYH2njAz579OCVecIiIioUTyvbxQiy8iuRgl1NRrJKeiQ027RnIksij6C+WEEsDCZGYd8S0wuQCYA8wA6gGLzaxrAdprCdyCb29CERGRiBk94s8R6yvU4osunS6MWByaei3eimUCaGbl8S0wOQK0dM4Nds7dBjTDt9hkipnle4NpM4vGdzLJ68CaQghZREQkVy+8uDRifYVafBHJxSiR3OuvoCI5ElkU/YVSLBNAoB1QE/incy7zUEPn3I/AU8AZQO4bHeU0DqgGDAlnkCIiIvmx8oMNEesr1OKLSC5GCTX1Gsmp6OI07VqcFNcEMGNXnsVB7mWUtclPQ2Z2IfA3YJRz7r9hiE1EREROQCSnoiW44poA1vF/BttDcHO2Ornyn0iSCrwPTAtPaCIiIsVXqMUXxWWT6EhORYeado3kSGRR9BdKcU0A4/yf+4Lcyyg7NR/t3AucDdzsZXWymSWb2RozW7NjR+5D6SIiIvkxYexNEesr1OKLSC5GCTX1Wlz2RYz0SGRxGvksrgngCTOzpsBIYJxz7msvzzrnpjnnmjvnmletWjz+35KIiJRcod7LC7dQiy8iuRilJIjkSGRR9BdKcU0AM0b54oLcyyj7NY82UoEN6CxiEREpYs8890bE+gq1+CKSi1FCTb1Gcio61LRrpEcii8vIJxTfBDDUe36h3g/MqjFwPnA0y+bPjv8tHtnvL4s/8XBFREQkvyI5FV2cpl2LkwIdBWdm5wLXAI2ABKBciOrOOdfRYxcrgFFAeyD7hkbts9QJZUYu5Z2B04FZQDpw2GNsIiIicgJeeHEpvSN0OtvIe1J55IngnUV6UUxxWYQDBUgAzewR4HbA/FdeCnI03BJgG9DLzJ7I2AvQzM7Ad5rHj8DCLDHVxpeEbnHOHQVwzg3IJf5l+BLAoc65AwWITURExJPe118KfBeRvkItvvAtRlkWkThCTb2u/GADvbvUjEgcoaZdR4/4MxxcEJE4MvsrJjwlgGY2GLjD/3Uj8CrwA/B7OINyzh0xs4HAAuB9M/sXvpG664FE4Brn3KEsj7yDb+PoWkBaOGMRESkp2lS7NIK9he3Y91LhkhYN4WBkEsBQtm3fQXytyPRVEqZeIzkSmdnfzRHsMASv7wAm4/tv/TPOuYbOubucc88452aEugoSmHPuTeBSfEe39QYGAJuA9s65VwvSpoiISFEYOOyZiPUVavFFJBejFJcVr6GmXSO5KKYo+gvF6xRwXf/n6HAHEoxz7j18x8LlVS/JQ5uXnkBIIiIikg+hpl4jORVdnKZdixOvI4C/Ab8654Jt0CwiIiKSp0jui6i9D4PzmgB+DMSZWWJhBCMiInIyOr9hUsT6CrX4wrcYJTJCTb1Gcio61LRrJE9oKYr+QvGaAD7s//x7uAMRERE5WaUkd45YX6EWX1zSomHE4igJU6+RHIksiv5C8ZQAOudW4FsIMtTMnjaz6oUTloiIyMnjmWkL864UJqEWX0RyMUpJmHqN5EhkUfQXitdtYDLO1D0KDAYGm9kvwP4QjznnXN0Q90VERE5q675Mw7dbWeErLseNrfxgA71vDn4vkvsiFqdp1+LE6yrgYEezVfNfudFmUSIiIpIpkvsibtu+g/g/RKSrEsVrAtg+7yoiIiJSVEItvvAtRin6cZmBw55h6vjIjIg+89wbTL341qD3IjkS+b/+igdPCaBz7p3CCkRERORkNXVSSsSOHAu1+CIluXPE4igJU6+RPqElkotw8uL5LGAREQmkI9gkLytXfckljSPTV6jjxp6ZtpCUXpGJoyRMvUZyJDKzv+dL5lFwOZhZHTO72H8Fe0dQRESkVHvhpWUR6yvUvne+xSiREWrFayT3RSxO067FSYESQDOrZWbTzWwPvvN53/Nfm8xsj5k9Z2YROm5aRERESpJI7otYnKZdixPPCaCZdQY+B/4KnApYtutUoB/wuZl1Cl+oIiIicjKI5L6IofY+jORIZFH0F4qnBNA/qvcycAqQBqQA9YFY/1UfGOq/dwowVyOBIiJS2qXcfGXE+gq1+GLqpJSIxRFq6jWSU9GhRHIksij6C8XrCOAoIAZYAZznnHvWObfJOXfQf21yzk0GzgNWAtHAyPCGLCIiUrKE2pol3EIdN7Zy1ZcRi6MkTL1GciSyKPoLxWsC2B7fErRk51yuW4377yXjmxLuUPDwRERESr5R982KWF+hFl9EcjFKJI+dCyXUtGukRyKLy8gneN8G5kzgV+fc13lVdM5tMrNf/c+IiIiIAJHdFzHUtOv6dZtp1XENZ1aNoU2zquw/FsuGLbv49rufAOjZsQZlK8az9qu9bPrmB9LTj9G6aVXOqVWFDzf+xn9/2s2ePQeoXf0ULmxYmV9+q8g3abvY9v0OYiqU4epLz4IK8az7Zi9fbtzGsTKnRuQ354fXBPAQUNHMyjn3/+3dd5yU5bn/8c+lUhQELFgQEIMFSyIWrNgLamJv+UViiRpElHAMYjweo2JJRGM8CgexJGowKkYiiTEhqNgOJMIxGsXYiAgCIgkoRQHL9fvjeZeTmfEAACAASURBVBaHYebZnd2Ze+7d+b5fr3kN+9Rrbsdnr72rf5Z1oJm1ImkujmNRQhEREYlCyHkRR935Bwb9sPDce7v02pYxgxswD+AxAH3W2HROycNc+/Del3uVelLFlNoE/CrQCujfgGPPBFqn54iIiNSsA/bdKdi9sgZfhByMktX0GrIpOqvZdcxPww2KiU2pCeCvSPr1jTSzswsdYGatzexC4HaS/oL3NylCERGRZq7/tw8Jdq+swRchB6PENOK1mOf/Gm5QDMANIx8Jer8spTYB/wL4NnAocI+ZDScZETyXZMRvd2AfYDOSRPGp9BwREZGadf1N47jiwg2C3CtrubHLrrov2NJnWU2vm7Vbl779Hl3987cO35nvnfwNLvrxY8xb+CkAnTt35Lejv8PlN4zn+ZcWANC2bWtu+a9v8d5773PjXS+uPv/s0/bisH26Mvjqx1m8ZBUA2/fcgl/ceCIfffh/RWMc+9tnOKAhTcAtUEkJoLt/aWbHAbeRTATdFfgOXy1OaXWHAncDQ9xdC1eKSNmFXX8XtAavNEUyNUttJRpZTa9HHnwA1363a97WVYy7Ia+JevGH/GRg37XO/8bm3Th2r7UXGv79z/ISzsUf0qnTpg2MuLaUWgNYN8XLeWZ2A3ASsDtQV6e8EHgJeNTd3y1blCIiItJi1GrN27cO61P/QYGUnADWcfd/AjeXMRYREZEWqWOHMM2/kD34YtqLr3PTDfNYvOQznvvbQr62zRYAbLLBKrbt2p4HJ86mc+eObLZpR5YvWcy+u2zEsy8tZNHSL+i5zRbM+2ARR+21Me+8v4xpMxax/XZbsWLFKnpsCht1aMWEZ+fRZcuN2ahTexYs+jLQJ268QWcdA4TrB3jsEfGMAm50AigiIiINM+Lac6KY965P7524tH/xmrdBp6xdQzXolIbf+9LcOUK6fKvhJ1bQf150atF93bt0huXhYhl2/S8ZMbpwv8jQSh0FLCIiIiX6/R9frP+gMollubHrbxtXdF9S81Z9l/0k3AotAB8vjWdq5KI1gGZ2Z/rP+e5+Vd62Uri7D2hMcCIiIi3B43+axrEHhunzljX44oC9diJUldfsecXXJA5Z83bDyEcYs8+5YW7WjGQ1AZ+Xvr8BXJWzzflqtG9DOKAEUEREpMr6n3QIzAvTFJ3lsp/c17AVOFqY7l3CzcNYn6wE8Pr0fWGBbSIiItJAb/3jXUbd8iEvzljEzPeXrR588fXu66wekFE3+GLj9VfStXMbHpw4m7ZtW9Nzmy1ou97nbN9lPZ59aSHzFn66evDF/jutv3pARt3gC7d2ReO4/rZxXHFKmAEpHTcMN/ClsULWiAJcMfi0YPeqT9EE0N2vbMg2ERERybZ9z20YdMrWJQ2oaOyAjI/aHVx0X9IsG6bmbcQV5wS5T32ypl4JXSM6dvxk+g/WIBAREREps9ADG4r5/aTiA1+SmrcwsqZeyRqoUgnPv/h60PtlKSkBNLM7zWxECcffYGZjSg9LRESk5YilOTRkHI8/Na3ovv4nhVsbedj1vyy6L2ugSktXag3geUD/eo/6yv/jq8EkIiIiNSmW5tBY4ghZ8xbT1CsxqXQTcCmjhUVERFqkrObQcstqXg0ZR5ZYat5C18zeePlZQe+XpWIJoJmtQ7JG8LJK3UNERKQ5yGoOLbes5tWQcWStwBFS1tQroWtEY0l8oZ6l4MysPdAhb/M6ZrYlxWv3DOgEnAmsD8Tx54aIlMVBmx8c8G4e8F4iLcP1t43jihFxjDQtJmTNW9bUK7+f9CLH7hwsFEbd9wRjjhgc7oYZ6qsB/CEwJ+cFSa3e+3nbc1+zgb8DQ9Pj7y5vyCIiIlJMLLVMN4x8pOi+kDVvY8dPLrovZI1obBrSBGw5L8/7udjrE2Aa8H13VwIoIiI1LZbm0FjiCNkXMaapV2KS2QQMDAeuS/9twCrgA6BbxjlfurvabUREpLpeCny/XoHvV0QsU85kefypaRy7c+0tBdf/xIOrHcJqmTWAnvgifX0O/Bp4NGdboZeSPxERkRxZzaHlltW8GjKOrBU4YhG6RvSAvQN2OKxHSaOA3b2/u19cqWBERESkaWKZ6iVrBY6QYpp6ZcCPRlU7hNVKXQmkrZntZ2a7NeDY3dNj2zQ+PBERESlFLAMbslbgCFnzljUoJmSNaGxKnQfwDOB5kile6jMwPfbbpQYlIiLSksTSHBoyjlhW4Bh13xPVDiFKpSaAdSn7/Q049i6SgSPFJ+ARERGpAbE0h8YSR63WvH2jV49qh7BaqQlgL5KRwC834Njp6bE7lhqUiIhIS5LVHFpuWc2rIePIWoEjFqFrZged/c2g98tSagK4BbCsISN93f1LYGl6joiISM2KpTk0ZBxZK3CElDX1Suga0VH3/iHo/bLUNw9gvqVAJzNr6+4rsg40s7YkS8ItaWxwIiLSDIWcfy+SufdicsPIRxizz7nVDoOx4yfTf3DhJemSmrcPg8SRNfXKsOt/yYhzwtVU/v2NWcHuVZ9SE8C/AwcDJwIP1nPsScC6wIzSwxKRfFqDV6T5iqU5NGQcz7/4Ov2L7Dv2iL1g3uNB4hjwo1GMGVs4EZ34zMu0WdGdj5et4C8z3udr3TcHoEMbo8eWG/HYc/+g8yYd6bxJR5YtWcLu22/JX16bw0fLV/G1rbdg/oJ/c9Cu3Zk1fzEvv/0B23+tCytWfkaXTm3o2L4tE//6Dl0235hOHdvzyZIl9N4jjj6YUHoC+AhwCPBzM/ubu79R6CAz2xG4heS3SG329BQREUldMfi0YAlPc4gjdM1bMbvt+g3OP/WAovv7H3dUgW0Nv/75ed0x73zyrYafXGGl9gG8B3gV2AyYbma3mlk/M9sxfR1lZreRDADZDHgdGFPekEVERJqXseMnB7tX1sCGkHFkiaVPZGjvz1tQ7RBWK3UlkM+AY0iagjcALgaeAF5LX38ABgHrkySK33T3VeUMWEREpLl5/sXXg90ra2BDyDhiWYEja+qVfffcNVwgkSm1BhB3nwvsDQwh6er7Jcl8f5b++yXgB8Be7j67fKGKiIhIfUJO9ZIlawWOkH0Rs6ZeOf34fsHiAOiwYbug98tScgII4O4r3f02d+8DtAO6pq927t7H3W9395XlDFRERETqF0vzatYKHCGniMmaeuXm0fcFiwNg+LBBQe+XpVEJYC53X+Xu89KXmntFRETyxNIcGkscIfsiZk29ErpP3h+ffiHo/bI0OQEUERGRbFnNoeWW1bwaMo4sIfsixmTi5CnVDmG1UqeBWc3MWgG7Al1ImoGt2LHu/uvG3kdERKS5G3XfE4wZvHWQe2U1r4aMI2sFjldmzOK4S2axzy7d+Mtrc9igfdI37p+zF3DCgTsya/5i5i76lM6bdOStmXPZs9eWdGzflmdfnr16/r2O67ei9/ZbMvmld9l8s41ZsfIzPly4mKP22Y5/zFrI0pVf0qlje/725gdF44ipT15oJSeAZrYBcD1wLkni1xBKAKXZ0gTMItKcZK3AEVLWChy9dujF8DOT+feaMq9eQ87/aINtiu4bPmwQS96e2vAAWpCSmoDNrA3wFDCYZKqX10lq/j4D/grM4qsRwYuBKelLREREAoileXXAj0ZVO4R6he6Td8kFZwa9X5ZS+wAOJJkC5h1gB3f/erp9kbvv5+49gZ4kq390Ah539+JTbIuIiNSArObQkGKJ49ZrhwW71y133F90X0x98kIrNQE8jaSNaqi7/7PQAe7+rrufDjwE3GBmRzYxRhERkWYtqzk0pFjimDLt5WqHUBVZyWhopSaAO6bvE/O2typw7BUkTcE/KDWoOmbW18wmmdnHZrbUzCab2aENPHcTMxtgZo+b2btmttLMPjSzCWa2f2NjEhERKVXI5tCsqV5CxpG1Ase43/05WBxSWKkJYFtgcd58f58CG+Yf6O7vAR8BezYmMDPrBzwD9CEZRHIP0AuYZGYN6TJ6KnAHyUjlZ4Fb0usdAzxvZmc0Ji4REZGYxTLVS9YKHCH1O2S/ovti6pMXWqkJ4HySwR+5PgBamVmP3I1mth5JYtix1KDMrDUwBlgF7O/uA919CLA78C/gDjPLjyPfW8C3gK3d/Wx3v9zdTwMOAj4HRqaDWkRERFqMrBU4QspagSOkow/tW+0QVstKRkMrNQGcBbQ1s64526an79/JO/YMYF3g/UbEdTiwNfCAu8+o2+ju84HbgS1JavKKcven3f0P7v5l3vYpwGSSQSpfL3iyiIhIGWU1h4YUMo6sFTjOO+OkYHH8eETxZu/QffJiSkZLTQCfTd9z++H9gqSv31Vm9t9mdo6Z3UJSg+ckI4JLdWD6PqnAvrptBzXiunXqmrA/b8I1REREGiSW5tBY4ujWZfNg91qydHmwe9UnKxkNrdSJoB8CTiCZCuZ+AHefaGZ3ABcAF+Uca8CLwLWNiGvb9P2dAvveyTumJGa2FXAYSdP1q425hoiISClG3fsHBgWaEyNrqpdvnnk9Cz94n3127krH9m15e/5SIFmBo8cWnei9/Za8PW8Jvs66vDVzLuutaxy1z3bM+/dyln0G8xf8m8UfL+eg3XoAMP/jVaxY+Rmz5y5kh+6bsmOPzsyYvZhWrVvzxnuLisZx1U2jV08EXUtiSkZLSgDd/U1gtwLbLzSzJ0gGXnQFPiapqbsnb8BIQ3VI35cU2Fe3rTF9C9cD7iPpx3ihu39R5LjvA98H6N69e6m3kTIIu/oGaAUOEamkv78xC44MswRb1lQvnTfbgtFDCyynUQF3PvlWkPvUp2tGbWNMffJCK7UJuCh3f9zdz3L3w9z9JHcf3cjkryLMzEhGBR8G/NLd7y12rLvf6e57uvuenTsXX1RbREQkNllTvZx2XLipeYcOLD4dTUhZcYTuk5eVjIZW6lJw49JX8YX1yqOulq9DgX112z4u8Zq3kaxfPA44v5FxiYiINFv79ekd7F4PT8ifMvgr++65axRxhO6TF0tSDKX3ATwB+DydTqWScvv5vZS3L6t/YEFm9nOS/om/Bc4o1vQrItKs5T8tK6lXwHu1AGN+OgjmPV7tMBhy5Yhgfe+mTn+FAUX2nX58P5a8PbXqcYTuk/fwhIkMGBpHs3OpTcALgJWVCCTPc+n7EQX2HZF3TCYzuwkYAjwOnO7uGvkrIiJBPf/XGfUfVCaxTDmT5ebR91U7hKqYOv2VaoewWqkJ4GSgg5ntUIlgcjwJzAbOMLPVvVnNbEvgYpIJqf+Qs72nmfUyszWWpDOzG4ChwJ+AU9z9swrHLSIispaxv30m2L1imeoly/vzFlQ7BCCuPnmhlZoA3gisIFlFo3UF4gEgHTwyAGgN/K+ZjTazW0kaODYFBrr7pzmnPAX8A9iqboOZnQNcTlJj+QpwuZldnffqUanPICIiUg1ZK3DsvEPPYHFcc+nAYPfKkhVHTH3yQiu1D+BikulRRgN/N7PbganAQqBovzp3n1dqYO7+JzM7GLga6E8yr+B0kj58TzfgEnXj7dsAlxU55hmS1U1ERERahKwVOM7vf3Kwvndz5i1g6z0K7+uwYbsgMdQXx8MTJnL0ToXGm1ZGLEkxlJ4Azsn593YkI2vr4424T3Ki+wsky8LVd1yPAtuuJkkepQRh59/T3HsiUhsGnXUMEK4fYDF3jX2U0/fuEuRedz8wnr7Hnllw3/Bhg4IlollxTJ3+CkfvFG5C6qxkNLRSEzNrxD0ac46IiEiLcf3tj/HuO2/RtvV6HLXPdmyy2aZMfvEt/jk76Qt30G492HXHbXhy+kzemjmXz7/4gh26b8qBu2/Lq7MX8ebMuSz+eDkd27flkN23of1GG/Hc9LeZPXchAP323pbtenbj6ekzM1fgmPHmTAiUAGb549MvsH+3dasdRnBZyWhopSaAreo/RERERHJtt+123HTBmoMzjt5nz7WOO3D3tefp61fkmiccsPda2w7evTc/vv/5RsUY0sTJU9i/BpeCi0lJg0Dc/YvGvCoVvIiISHMQcrBByNU+sjSHOGLqkxda2ZaCExERkcKyVqMot6zVPm69dlgUcYSUFcecwNPRxJIUQz0JoJkNNrNzQwUjIiLSEoWcAHjIlSOK7psy7eUo4rjkgnD94LLiuPuB8cHigHiSYqi/BvBWYHihHWZ2j5k9Wv6QREREpBLG/e7P1Q6hpmUlo6E1ZBBIsVG8xwCblTGWmqbpV0REpFbccsf9wdYklsLUB1BERKTCQg42CLnaR5bmEEdMffJCUwIoIiJSYSEHG5zf/+Si+84746Qo4ggpK47QffJiSYpBCaCIiEjFhRxscNfY4t3zu3XZPIo4+h2yXxRxhO6TF0tSDI1cok1ERCR2L806KOj9dg96t+JmvDmz6L6rbhodrO9dVhxHH9o32FJwWXGEdtfYR7n0mnDJbxYlgCIiTfVSwHv1CngvkQr58YhRDD0xlpQ5nJiS0YYkgBub2dOFtgMU2ZfL3f2wkiMTERFpIZLBBp9WO4xoLFm6vNohAHH1yQutIQlga+DgjP1Z+0BzjoiISI3br0/vYE2eWat97LvnrkFiqC+OkLLiOL//ycH+u8SmvgTwviBRiIiItGBDrhwRrO/dlGkvc8x2hfuZnX58v2AJT1YcXQMORsmK466xj3L63l2CxRJLUgz1JIDufk6oQERERKTpxv3uzxzznQsL7rt59H18//Dtqx7H0IFnBUtEs+KY8eZMCJgAZiWjoWkaGBERkRrxfsD5CLM8PGFitUOoipiW4lMCKCIiUmG1PNigkKnTX6l2CDVP08CIiEhZhZx/r7lMJBJysEHWah8dNmwXJIb64ggpK45brx1Ws4NAVAMoIiJSYVmrUZRb1mofw4cNiiKOkLLimDLt5YCRxJMUgxJAERGRigs5AfBVN40uuu+PT78QRRzXXDowijhC98mLJSkGJYAiIiI1Y+LkKdUOAYA5kQxGCS0rGQ1NCaCIiIgEdfcD46sdQs1TAigiIlJhIScADrnaR5bmEEdMffJCUwIoIiJSYSEHG5x+fL+i+y654Mwo4ggpK47QffJiSYpBCaCIiEjFhRxscPPoOFZxzYrjtOOOjCKO0H3yYkmKQfMAikhz9VLg+/UKfD+RRspa7eOWO+4PtiZxVhz79ekdbP69WFY/gSQZve4WLQUnIiIiNWjIlSOqHUJVxJSMKgEUERGpsJCDDUKu9pGlOcQRU5+80JQAioiIVFjIwQZZq330OyRc82PIVUeyZMURuk9eLEkxKAEUERGpuJCDDbJW+zj60L5RxLHzDj2jiCP0gJlYkmJQAigiItKiZK328eMRo6KI4/z+J0cRR+g+eSGX4quPEkAREZEasWTp8mqHAMBdYx+tdghVEctSfKBpYEREWoyXZh0U7F67B7tTy1DLgw0KmfHmTNi7S7XDiKpPXmiqARQREamwkIMNslb76BpwMErIVUeyZMURU5+80JQAioiIVFgsq3MMHXhWtUOISug+ebEkxaAEUEREpOJCDja45Y77i+57eMLEKOK49dphUcQRU5+80JQAioiI1Iip01+pdggATJn2crVDqIqsZDQ0JYAiIiIVVsuDDQoZ97s/VzuEmqdRwCJSmpcC3qtXwHuJVNDwYYNY8vbUIPcKudpHluYQxyUXnAmfvBswmnioBlBERKTCQg42yFrt45pLB0YRR0ixxAHxJMWgBFBERKTiQg42yFrtY07AwShZcZx3xklRxBG6T15MyagSQBERkRYka7WPux8YH0Uc3QLORxjL6icQdim++qgPoIhIE2kFDpHSXHXTaIafeUC1wwgupmRUNYAiIiIVFnIC4JCrfWRpDnHE1CcvNCWAIiIiLUjWah+nHXdkFHGElBVH6D55sSTFoARQRESk4kIONsha7WO/Pr2jiGPfPXeNIo7QffJiSYpBfQBFmg/NvyciDTB1+isMKLJvyJUjgvW9y4rj9OP7BZsXMSuO0H3yHp4wkQFD42h2Vg2giIiIBHXz6PuqHUJVxLIUH6gGUESaqZAjb0Gjb6VpanmwQSHvz1sAbF/tMKLqkxeaagBFREQqLORgg6zVPnbeoWcUcYSUFUdMffJCUwIoIiJSYSEHG2St9nF+/5OjiKPDhu2iiCNrgEglxJIUgxJAERGRigs52CBrtY+7xj4aRRzDhw2KIo7QffJCLsVXH/UBFKmPRt+KSAsx482ZsHeXaofBH59+gf27rVvtMIK7+4Hx9D023KTgWVQDKCIiUmG1PNigkImTp1Q7hJqnGkARKYnWvRUp3dCBZwWb9y7kah9ZmkMc11w6EBa8FjCaeKgGUEREpMJCDjbIWu3j1muHRRFHSFlxhO6TF0tSDEoARUREKi7kYIMhV44oum/KtJejiOOSC8L1g8uKI2uASCXEkhSDmoAlViEHXoAGX4hITRj3uz+zS6Cl4GRtQ64cwb0PPVbtMICIE0Az6wtcBexFUlM5HbjW3Z8u4Ro7A9cDBwJtgNeAm939kfJHLFJZ6nsnIi3FLXfcH2xNYiksyiZgM+sHPAP0AX4N3ENSRzPJzI5r4DV6A38B+gETgP8BNgXGmdlFFQhbRESkoJATAIdc7SNLc4gjpj55oUVXA2hmrYExwCpgf3efkW6/EXgZuMPMJrn7p/VcajTQDjjS3Z9MrzEc+Cswwswedff5lfoczZbmvBMRKbs58xbQPdC0d1mrfZx3xknAwqrHEVJWHPv16R1sdDbEkxRDhAkgcDiwNXB3XfIH4O7zzex24FrgGKDodOZmthOwD/BkXfKXXmOpmd0A/Ar4DvCzynwEaUnU9CoiTXX3A+ODNXneNfZRLr1mv4L7unXZHBaESQCz4uh3SOHtoeMYcuWIoE3RsSTFEGcCeGD6PqnAvkkkCeBBZCSADbgG6TXiSQAjqXmLJdkJGQco8RKRlmPGmzOL7rvqptHBEp6sOI4+tG+wmresOELLSkZDizEB3DZ9f6fAvnfyjin5Gu6+wMyWNeAaQcWSeImIiFTaj0eMYuiJtffbKKZk1Ny92jGswcz+DBwBbOfu7+Tta0XSN3CKu++fcY07gfOBI3KbgHP2zwVw962KnP994PvpjzsAbzbio4SwKfCvagcRGZXJ2lQma1J5rE1lsiaVx9pUJmuKuTy2dvfO9R0UYw1g1bn7ncCd1Y6jPmY23d33rHYcMVGZrE1lsiaVx9pUJmtSeaxNZbKmllAeMU4DsyR971BgX922j5twjbrt9V1DREREpEWKMQHM6ueX1T+wQdcws82B9g24hoiIiEiLFGMC+Fz6fkSBfUfkHVPJazQH0TdTV4HKZG0qkzWpPNamMlmTymNtKpM1NfvyiHEQSGvgbaAz0CdnIugtSSaC/gLoWTcRtJn1BFoBM939s5zrTAX2Zs2JoDckmQi6B7Ctu88L9blEREREYhFdAghgZkcBjwPLgAeBlcDpwGbASe4+IefYWSQTR2/j7rNytvcGXgDWBR4iGa1zItATuNjdR4b4LCIiIiKxiTIBBDCzvsDVJLV4BkwHhrv703nHzaJAApju2wW4jmTS5zbAa8BN7v5IhcMXERERiVa0CaCIiIiIVEaMg0BaHDPramb/YWZPmtkcM1tlZnPN7NdpLWWhc/qa2SQz+9jMlprZZDM7NOMeO5vZY2a2yMyWm9lfzezUeuLaPz3nQzNbYWazzOwhM+vW1M9cz32jKw8z65def156/Btm9t9m1qUcn7k+lS4TMzvWzEaa2V/M7FMzczM7u56YupnZr9Lvx6dm9nczu8DMrAwfOVNM5WFm7c3su2b2GzN7J/1/ZVF6r2+V8WNniqlMipw/JD3Hi8VTTrGWh1XpuZreO7oysSo+WytZHma2iZkNMLPHzexdM1uZ/jefYGZZC1WU/Lu6Ytxdrwq/gJ8CDrxFMnLopyR9HL8EVgCH5B3fD/gc+AgYDdwKzCcZAHNcgev3BpYCnwK/BG4CZqb3vKhITIPS+88B7gB+AtwHvAf0raXyAC5J932YlsUI4Kl02wKgSwv4jjyTXn8R8G7677Mz4ukGzEuv9zBwI8kgLAdurqXyAI7K+X48mP6/cj+wPN3+n5Uuj9jKpMC5PdPyWJaet0stlgdVfK7GWCZU+dlayfIALkivPQe4N/1vPQ74LL3+GQXiKfl3dUXLJ/QNa/EFnAQcUGD7qel/+H/kbGsNzAI+AXbO2b5l+j/MPGD9vOtMTb9wh+ds2xB4Pb3OlnnH75d+oX8DtCkQ13q1Uh4kI8iXAAuBzfKuc20az9Ut4DvSl2TkO8BF1P/gfjA95nt5ZfV0Wra71Up5ALsC3wFa5W3fDlhM8sDfqta+IznnGUliMB34FeESwKjKgyo/V2MrEyJ4tlayPIBDgW8C6xT4HqxKnw1t8vaV9Lu64t+XkDfTq8B/gGSdYQc2TX8+Jv35rgLH/le67+ScbTul2yYVOL5/uu+HedufIlkJpUO1P3+1ywPYIt32pwLH75vuG9mcy6TAMfU9uDumD7C3Cuzrm557e62URz2xjEnPPaWWviN5xw4iSYJ7k9SEBEkAYyuPmJ+r1SiT2J+t5S6PvOMnpsfvmbOt5N/VlX6pD2D1rUrfP0/fD0zfJxU4tm7bQTnbSjrezDYGDkn3LTezb5rZj8zsQjPrVWrwFRC0PEj+svs3sIeZ5S+efUz6/kxGvCE0tUxKtS/JX+9PFtg3laSprynXb6rQ5VFKLNVSlTIxs61JmtVudveXm3q9MgpaHs3guQrhvyOxP1srWR6FngvVfE4VtF7Im8mazGwPYBdgurt/lG7OWu6u0BJ3RY939wVmtizv+N1JmmwWAVOAvXJPMbPbgP/w9M+SkKpRHu7uZnYxSZ+uGWY2nuSv+D1Iart+4u6/aeRHarIylUmpssrwCzN7t4nXb7QqlUexWNoDJ5P0JXq+3NcvIY5qlsndJH2krinDtcqiSuUR7XMVqlMmMT9bK1keZrYVcBjwAfBqzq5SwkI0WwAACYxJREFUf1dXnBLAKkl/edxHUu17Wc6uDun7kgKn1W3r2MDj67bnHr9p+v49ki/igcDfgK8DdwE/IFmJZVS9H6KMqlgeuPuDZvYR8AAwIGfXUyT9eaqijGVSqoaU4fpm1spzVt+ptCqWRzEjSfoHXePu/67A9etVzTIxs/NJftEd4u4rmnKtcqlieUT5XIXqfkdifLZWsjzMbL302usDF7r7Fw28ft32SjynilITcBVYstzdI8DOJJ1gn67nlHJaJ+f92+7+vLsvc/epwGkkHVQvCRhPtcsDMxsATCDpz7U10J7kAb4J8ELWkP4KxlTVMolNbOVhZlcCZ5E03VxXpRiqViZm1hW4Gbjb3Z8Ndd8seq6urdr/38T2bK1keZiZkYx0Pgz4pbvfW65rV4oSwMDSvxAeJpla4mfuPjzvkLq/DjqwtrptHzfw+LrtucfX/XtOfp8dd3+dZEj618ysU9EPUUbVLg8z25Hkr/IJ7n65u8929+Xu/jxwPElfuJ829POUQwXKpFQNKcNPQ9X+RVAe+fEMBYaTNPue4O7B+/9FUCYjSfqCXtqEa5RNBOUR1XMVql8msT1bA5THbcC5JFPBnF9gf6m/qytOCWBA6RfwQeAEklGUQwscltXXoFAfgqLHm9nmJH9x5R7/Vvpe7ItWt339IvvLJpLyOJxkvei1ajHcfTbwT2C34p+ivCpUJqXKKsN1gW2aeP0Gi6Q8cuMZQjJ311TgGHf/pBzXLTGGGMqkN0nz90f21eTPTlIrCvBquq13E+7RIJGURzTPVYimTKJ5tla6PMzs5ySjon9LMv/fFwUOK/V3U8UpAQwk/cX5K+AU4A53H1zk0OfS9yMK7Dsi75jGHP8OMJfkr9E2eTG2IpnQ9VPgX0XiK4uIyqOuDDalsE2AlUX2lVUFy6RUU0mm9Ti8wL59gXZNvH6DRFQedfEMAn4OTAOOcvdlTb1mI2KIpUweAu4p8Ho73T8+/bmifSMjKo8onqvp/WIpkyierZUuDzO7CRhCMsH06RktAkGeUyUJOedMrb5IEu26CVLvJl2DucixrUlmjS/nxMdd8o6/igKTcAKXp9sfqpXyIJm000ke3pvnXWdwum98c/+O5J3fHCaCjq08BqSf+/+ATpX+PjSHMily3r2Emwg6qvKgys/V2MqECJ6tlS4P4Ib02n+kwOTfBe5R0u/qSr8sDUAqyMyuAX5MsrzM7SRfgHy3ejoc3cyOIvlrYhnJL+KVwOnAZsBJ7j4h7/q9gRdIqtsfIvkr80SSvzovdveRecdvQPKXxh4ko7FeJhmtdiTJlA57u/ucJn/wIiIsj0dI/jr8iKQK/98k0zocStJ0s58n/XgqJkCZnEDS/AHQC9gb+F++anJ4zN0fyzm+G/Bier3fkCz7dBTJqhg/88JNKGUTU3lYsg5o3ZyII0mm+sj3mFd4HryYyiQjxntJmoG/7u6vlfgRSxJbeVT7uZrGEFuZVPXZWsnyMLNzgF+kx9xKMh1UvnvdfVbOOSX9bqq4kNlmrb746q/irFePvHP6kvzSWUryZXwGODTjHrsAj5EsP/MJyS/vUzOO35CkL9N7JJNWzif5CynEklZRlQfJ/4yDSZr2lpE0f9at77htS/iOAFfXc+2rC5zTHRhLspTTCpI5rQaS8Vd0SywP4OwGxHJ2LZVJA2IMUQMYXXlQxedqjGVClZ+tlSyPBpSFAwcXOK+k39WVfKkGUERERKTGaBCIiIiISI1RAigiIiJSY5QAioiIiNQYJYAiIiIiNUYJoIiIiEiNUQIoIiIiUmOUAIqIiIjUGCWAIiIiIjVGCaCISA4zm2RmbmbT0oXks47dw8w+T48/I1SMIiJNpQRQRGRN55MsAbUn8MNiB5lZK+AekuWufu/uD4QJT0Sk6ZQAiojk8GTx9svTH68xs+2LHHoZsCvJovYXBAhNRKRstBawiEgeMzPgWeAA4AXgQM95WJrZjsDfgDbAee5+T1UCFRFpJNUAiojkSZO9c4FPgb7ARXX7zGwdkqbfNsCkQsmfma1rZt8zs6fN7F9mtsrM3jezB8xst0L3NLP1zOw4M7vbzP5mZh+a2Uozm2tmj5hZ32Lxmtn0tB/iKWa2qZndYmZvm9mnZvZ+E4tDRFog1QCKiBRhZkOBm4DlwC7uPsvMfgDcStJPcBd3fy/vnI2A35EkjgAOLAU6pD9/Dgxw91/knbcPMDXnnCVAK2CDnG1D3P22AnFOB/YAhgBDga7AivReH7t710YVgIi0WKoBFBEp7ufAi0A74E4z2wa4Pt33owLJnwEPkyR/fwEOBdZ3945AZ+BakufuGDPbPe9eK4A7gcOADu7eyd3bAV2A69JjbjGzr2fEex2wMr3GBu6+IXBwyZ9aRFo81QCKiGQws51I+vu1BuYCWwHPAQd73gPUzE4Afgu8Auzn7p8UuN51wBXAw+7+7RLiuBEYBox094vz9tXVAK4gqZWc2fBPKCK1SDWAIiIZ3P11YHj641Yk/QLPzU/+Umel76MLJX+puulijigxlN+n7/tnHDNeyZ+INIRqAEVE6mFm6wHzSJpxf+7ulxQ5bgGwGbAI+KzY5dJjANrlJopm1h4YCBwH9AI6Aevlnb/A3bfIu29dDeDF7j6yhI8mIjUq/8EiIiJ53P1zM6tL1JYUOiZdNaRz+uPGDbz0BsAn6flbA88APXL2L0v3O8nzehOS/ojFLGzgfUWkxqkJWESkPNYhqd0DOMLdrQGvf+Wc/z8kyd8bwPFAJ3ff0N03T2v8DkuPM4r7osyfSURaKNUAioiUgbt/ZmaLSGr/updyrpltCPRLfzzV3V8rcNjmTQxRRGQ11QCKiJRP3Tx+R5d43pYkawp/XiT5Azi80VGJiORRAigiUj73pu8nmtmBWQemE0bX+Th9X8/MehU4tgcwoAzxiYgASgBFRMrpUeBPJLV5T5jZD8xs9YCQdJm2U8zsT3w1tQzuvgB4Nf3xV2a2c3r8umZ2NDCZ4qOKRURKpgRQRKRM0rkBTydJAtuRLBn3LzNbZGZLSUbpPsJX/f1yDQZWAXsCr6XHLwOeIBktrBpAESkbJYAiImXk7kuAY4CTgAnAB0B7kuft28BDwHeBy/LOe4ZkCbnHSZqEWwHzgZFAb+DNIB9ARGqCJoIWERERqTGqARQRERGpMUoARURERGqMEkARERGRGqMEUERERKTGKAEUERERqTFKAEVERERqjBJAERERkRqjBFBERESkxigBFBEREakxSgBFREREasz/B4qnnD1AkMJiAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 648x468 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(9, 6.5))\n",
    "hatch = None\n",
    "ls = '--'\n",
    "edgecolor = 'black'\n",
    "alpha = 0.6\n",
    "plt.bar(year_list[:-4], x1_list[:-4], width=0.8, color='silver', bottom=x2_list[:-4]+x3_list[:-4]+x4_list[:-4], \n",
    "        label='pre-diffusion')\n",
    "plt.bar(year_list[:-4], x2_list[:-4], width=0.8, color='gold', bottom=x3_list[:-4]+x4_list[:-4], \n",
    "        label='ramp-up')\n",
    "plt.bar(year_list[:-4], x3_list[:-4], width=0.8, color='orange', bottom=x4_list[:-4], label='ramp-down')\n",
    "plt.bar(year_list[:-4], x4_list[:-4], width=0.8, color='#CD853F', label='saturated')\n",
    "\n",
    "plt.bar(year_list[-4:], x2_list[-4:], width=0.8, color='gold', bottom=x3_list[-4:]+x4_list[-4:], \n",
    "        linestyle=ls, hatch=hatch, edgecolor=edgecolor, alpha=alpha)\n",
    "plt.bar(year_list[-4:], x3_list[-4:], width=0.8, color='orange', bottom=x4_list[-4:], \n",
    "        linestyle=ls, hatch=hatch, edgecolor=edgecolor, alpha=alpha)\n",
    "plt.bar(year_list[-4:], x4_list[-4:], width=0.8, color='#CD853F', \n",
    "        linestyle=ls, hatch=hatch, edgecolor=edgecolor, alpha=alpha)\n",
    "plt.xlabel('Year', fontsize=24)\n",
    "plt.ylabel('Fraction of block groups', fontsize=24)\n",
    "plt.xticks(fontsize=19)\n",
    "plt.yticks(fontsize=19)\n",
    "plt.legend(fontsize=17)\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "low_income_group 0.027929753493913155\n",
      "midlow_income_group 0.037230874780580146\n",
      "midhigh_income_group 0.050006817147371124\n",
      "high_income_group 0.05822157359478841\n"
     ]
    }
   ],
   "source": [
    "segments_by_income_level = {}\n",
    "saturated_adoption_level_dist_list = {}\n",
    "for group in ['low_income_group', 'midlow_income_group', 'midhigh_income_group', 'high_income_group']:\n",
    "    df_sub = merged3[merged3[group] == 1]\n",
    "    merged_sub = df_sub[df_sub['d'].isnull() == False]\n",
    "    year_list = list(range(2006, 2021))\n",
    "    x1_list = []\n",
    "    x2_list = []\n",
    "    x3_list = []\n",
    "    x4_list = []\n",
    "    saturated_adoption_level_by_year_list = []\n",
    "    for year in year_list:\n",
    "        year_idx = year - 2006\n",
    "        x1 = df_sub['d'].isnull().sum()\n",
    "        x1 += np.sum(year_idx < merged_sub['d'])\n",
    "        x2 = np.sum((year_idx >= merged_sub['d']) & (year_idx < merged_sub['peak_time']))\n",
    "        x3 = np.sum((year_idx >= merged_sub['d']) & (year_idx >= merged_sub['peak_time']) &\\\n",
    "                    (year_idx < merged_sub['saturation_time_0.95']))\n",
    "        x4 = np.sum(year_idx >= merged_sub['saturation_time_0.95'])\n",
    "        saturated_adoption_level = merged_sub[year_idx >= merged_sub['saturation_time_0.95']][\n",
    "                                                            'saturated_adoption_rate_building_lt600'].median()\n",
    "    #     print(year, (x1, x2, x3, x4), x1+x2+x3+x4)\n",
    "        x1_list.append(x1)\n",
    "        x2_list.append(x2)\n",
    "        x3_list.append(x3)\n",
    "        x4_list.append(x4)\n",
    "        saturated_adoption_level_by_year_list.append(saturated_adoption_level)\n",
    "    x1_list = np.array(x1_list) * 1. / df_sub.shape[0]\n",
    "    x2_list = np.array(x2_list) * 1. / df_sub.shape[0]\n",
    "    x3_list = np.array(x3_list) * 1. / df_sub.shape[0]\n",
    "    x4_list = np.array(x4_list) * 1. / df_sub.shape[0]\n",
    "    \n",
    "    print(group, merged_sub[merged_sub['d'].isnull() == False]['saturated_adoption_rate_building_lt600'].median())\n",
    "    saturated_adoption_level_dist_list[group] =\\\n",
    "                    merged_sub[merged_sub['d'].isnull() == False]['saturated_adoption_rate_building_lt600'].tolist()\n",
    "    segments_by_income_level[group] = [x1_list, x2_list, x3_list, x4_list, saturated_adoption_level_by_year_list]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.027929753493913155\n",
      "0.037230874780580146\n",
      "0.050006817147371124\n",
      "0.05822157359478841\n"
     ]
    }
   ],
   "source": [
    "for group in saturated_adoption_level_dist_list:\n",
    "    print(np.median(saturated_adoption_level_dist_list[group]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x792 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hatch = None\n",
    "ls = '--'\n",
    "edgecolor = 'black'\n",
    "alpha = 0.6\n",
    "title_list = ['Low income', 'Mid-low income', 'Mid-high income', 'High income']\n",
    "fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(15, 11))\n",
    "for i, group in enumerate(['low_income_group', 'midlow_income_group', 'midhigh_income_group', 'high_income_group']):\n",
    "    x1_list, x2_list, x3_list, x4_list, _ = segments_by_income_level[group]\n",
    "    axes[i // 2, i % 2].bar(year_list[:-4], x1_list[:-4], width=0.8, color='silver', \n",
    "                            bottom=x2_list[:-4]+x3_list[:-4]+x4_list[:-4], label='pre-diffusion')\n",
    "    axes[i // 2, i % 2].bar(year_list[:-4], x2_list[:-4], width=0.8, color='gold', \n",
    "                            bottom=x3_list[:-4]+x4_list[:-4], label='ramp-up')\n",
    "    axes[i // 2, i % 2].bar(year_list[:-4], x3_list[:-4], width=0.8, color='orange', \n",
    "                            bottom=x4_list[:-4], label='ramp-down')\n",
    "    axes[i // 2, i % 2].bar(year_list[:-4], x4_list[:-4], width=0.8, color='#CD853F', label='saturated')\n",
    "\n",
    "    axes[i // 2, i % 2].bar(year_list[-4:], x2_list[-4:], width=0.8, color='gold', \n",
    "                            bottom=x3_list[-4:]+x4_list[-4:], \n",
    "                            linestyle=ls, hatch=hatch, edgecolor=edgecolor, alpha=alpha)\n",
    "    axes[i // 2, i % 2].bar(year_list[-4:], x3_list[-4:], width=0.8, color='orange', bottom=x4_list[-4:], \n",
    "                            linestyle=ls, hatch=hatch, edgecolor=edgecolor, alpha=alpha)\n",
    "    axes[i // 2, i % 2].bar(year_list[-4:], x4_list[-4:], width=0.8, color='#CD853F', \n",
    "                            linestyle=ls, hatch=hatch, edgecolor=edgecolor, alpha=alpha)\n",
    "    if i == 0 or i == 2:\n",
    "        axes[i // 2, i % 2].set_ylabel('Fraction of block groups', fontsize=22)\n",
    "    if i == 2 or i == 3:\n",
    "        axes[i // 2, i % 2].set_xlabel('Year', fontsize=22)\n",
    "    axes[i // 2, i % 2].tick_params(axis='both', which='major', labelsize=17.5)\n",
    "    axes[i // 2, i % 2].set_title(title_list[i], fontsize=22)\n",
    "    axes[i // 2, i % 2].legend(fontsize=16)\n",
    "    axes[i // 2, i % 2].set_xlim(2005.3, 2021.5)\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exclude pre-diffusion phase\n",
    "segments_by_income_level = {}\n",
    "for group in ['low_income_group', 'midlow_income_group', 'midhigh_income_group', 'high_income_group']:\n",
    "    df_sub = merged3[merged3[group] == 1]\n",
    "    merged_sub = df_sub[df_sub['d'].isnull() == False]\n",
    "    year_list = list(range(2006, 2021))\n",
    "    x1_list = []\n",
    "    x2_list = []\n",
    "    x3_list = []\n",
    "    x4_list = []\n",
    "    for year in year_list:\n",
    "        year_idx = year - 2006\n",
    "        x1 = df_sub['d'].isnull().sum()\n",
    "        x1 += np.sum(year_idx < merged_sub['d'])\n",
    "        x2 = np.sum((year_idx >= merged_sub['d']) & (year_idx < merged_sub['peak_time']))\n",
    "        x3 = np.sum((year_idx >= merged_sub['d']) & (year_idx >= merged_sub['peak_time']) &\\\n",
    "                    (year_idx < merged_sub['saturation_time_0.95']))\n",
    "        x4 = np.sum(year_idx >= merged_sub['saturation_time_0.95'])\n",
    "    #     print(year, (x1, x2, x3, x4), x1+x2+x3+x4)\n",
    "#         x1_list.append(x1)\n",
    "        x2_list.append(x2)\n",
    "        x3_list.append(x3)\n",
    "        x4_list.append(x4)\n",
    "#     x1_list = np.array(x1_list) * 1. / df_sub.shape[0]\n",
    "    denominator = np.array(x2_list) + np.array(x3_list) + np.array(x4_list)\n",
    "    x2_list = np.array(x2_list) * 1. / denominator\n",
    "    x3_list = np.array(x3_list) * 1. / denominator\n",
    "    x4_list = np.array(x4_list) * 1. / denominator\n",
    "    segments_by_income_level[group] = [x2_list, x3_list, x4_list]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "low_income_group 0.6873689727463312\n",
      "midlow_income_group 0.5763903245813521\n",
      "midhigh_income_group 0.5367647058823529\n",
      "high_income_group 0.506029477445288\n"
     ]
    }
   ],
   "source": [
    "for group in segments_by_income_level:\n",
    "    print(group, segments_by_income_level[group][2][-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hatch = None\n",
    "ls = '--'\n",
    "edgecolor = 'black'\n",
    "alpha = 0.6\n",
    "title_list = ['Low income', 'Mid-low income', 'Mid-high income', 'High income']\n",
    "fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(15, 10))\n",
    "for i, group in enumerate(['low_income_group', 'midlow_income_group', 'midhigh_income_group', 'high_income_group']):\n",
    "    x2_list, x3_list, x4_list = segments_by_income_level[group]\n",
    "\n",
    "    axes[i // 2, i % 2].bar(year_list[:-4], x2_list[:-4], width=0.8, color='gold', \n",
    "                            bottom=x3_list[:-4]+x4_list[:-4], label='ramp-up')\n",
    "    axes[i // 2, i % 2].bar(year_list[:-4], x3_list[:-4], width=0.8, color='orange', \n",
    "                            bottom=x4_list[:-4], label='ramp-down')\n",
    "    axes[i // 2, i % 2].bar(year_list[:-4], x4_list[:-4], width=0.8, color='#CD853F', label='saturated')\n",
    "\n",
    "    axes[i // 2, i % 2].bar(year_list[-4:], x2_list[-4:], width=0.8, color='gold', \n",
    "                            bottom=x3_list[-4:]+x4_list[-4:], \n",
    "                            linestyle=ls, hatch=hatch, edgecolor=edgecolor, alpha=alpha)\n",
    "    axes[i // 2, i % 2].bar(year_list[-4:], x3_list[-4:], width=0.8, color='orange', bottom=x4_list[-4:], \n",
    "                            linestyle=ls, hatch=hatch, edgecolor=edgecolor, alpha=alpha)\n",
    "    axes[i // 2, i % 2].bar(year_list[-4:], x4_list[-4:], width=0.8, color='#CD853F', \n",
    "                            linestyle=ls, hatch=hatch, edgecolor=edgecolor, alpha=alpha)\n",
    "    if i == 0 or i == 2:\n",
    "        axes[i // 2, i % 2].set_ylabel('Fraction of block groups\\n(excluding pre-diffusion)', fontsize=17)\n",
    "    if i == 2 or i == 3:\n",
    "        axes[i // 2, i % 2].set_xlabel('Year', fontsize=17)\n",
    "    axes[i // 2, i % 2].tick_params(axis='both', which='major', labelsize=13)\n",
    "    axes[i // 2, i % 2].set_title(title_list[i], fontsize=17)\n",
    "    axes[i // 2, i % 2].legend(fontsize=14, loc=2)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Environment (conda_tensorflow_p36)",
   "language": "python",
   "name": "conda_tensorflow_p36"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}