bass_model_parameter_regression.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 runs multi-variate regressions with various Bass model parameters as dependent variables and socioconomic characteristics as independent variables. R code blocks are inserted for running regressions. \n",
    "\n",
    "Figure 3 and 4 in the paper can be produced using this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext rpy2.ipython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "CPI2010 = 320.4 # compared with 2010\n",
    "CPI_dict = {2000: 252.9, 2001: 260.1, 2002: 264.2, 2003: 270.2, 2004: 277.5,\n",
    "            2005: 286.9, 2006: 296.2, 2007:  304.6, 2008: 316.3, 2009: 315.2, 2010: 320.4, 2011: 330.5, \n",
    "           2012: 337.5, 2013: 342.5, 2014: 348.3, 2015: 348.9, 2016: 353.4, 2017: 361.0, 2018: 369.8, 2019: 376.5}\n",
    "inflation_adj_rate = {x: CPI2010 / CPI_dict[x] for x in CPI_dict}\n",
    "inflation_adj_rate_df = pd.DataFrame(inflation_adj_rate.items())\n",
    "inflation_adj_rate_df.columns = ['year', 'inflation_adj_rate']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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": "markdown",
   "metadata": {},
   "source": [
    "# 1. Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = bg.sort_values(['year', 'blockgroup_FIPS'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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": 9,
   "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": 10,
   "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": 11,
   "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": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sub = df[(df['year'] <= 2016) & (df['year'] >= 2006)]\n",
    "df_sub = pd.merge(df_sub, prev_year_cum, how='left', on=['blockgroup_FIPS', 'year'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 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)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 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": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "del bg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Derive profit margin and rebate by year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_LCOE(price_per_kw, OM_cost_per_year, radiation, n_years=30, discount_rate=0.03, performance_ratio=1.):\n",
    "    \"\"\"\n",
    "    price_per_kw: $/kW\n",
    "    OM_cost_per_year: $/kW/year\n",
    "    radiation: W/m^2\n",
    "    performance_ratio: between 0 and 1\n",
    "    \"\"\"\n",
    "    cum_discount_rate = np.sum((1. / (1 + discount_rate)) ** np.arange(1, n_years+1))\n",
    "    total_cost = price_per_kw / (1 + discount_rate) + cum_discount_rate * OM_cost_per_year\n",
    "    total_generated_energy = 365 * 24 * (radiation / 1000) * cum_discount_rate * performance_ratio\n",
    "    return total_cost / total_generated_energy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_LCOE_2(price_per_kw, OM_cost_per_year, radiation, n_years=30, discount_rate=0.03, performance_ratio=1.):\n",
    "    \"\"\"\n",
    "    price_per_kw: $/kW\n",
    "    OM_cost_per_year: $/kW/year\n",
    "    radiation: W/m^2\n",
    "    performance_ratio: between 0 and 1\n",
    "    \"\"\"\n",
    "    CF = radiation / 1000.\n",
    "    nominator = price_per_kw * ((1 + discount_rate) ** (n_years) * discount_rate) /\\\n",
    "                ((1 + discount_rate) ** n_years - 1) + OM_cost_per_year\n",
    "    denominator = 8760 * CF\n",
    "    return nominator / denominator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_levelized_electricity_rate(electricity_rate, n_years=30, discount_rate=0.03, cost_escalation_rate=0.07):\n",
    "    \"\"\"\n",
    "    electricity rate: $/kWh\n",
    "    \"\"\"\n",
    "    if cost_escalation_rate == discount_rate:\n",
    "        nominator = n_years * electricity_rate\n",
    "    else:\n",
    "        nominator = electricity_rate * (1 - ((1+cost_escalation_rate) / (1+discount_rate)) ** n_years) /\\\n",
    "                        (1 - ((1+cost_escalation_rate) / (1+discount_rate))) * ((1+cost_escalation_rate) / (1+discount_rate))\n",
    "    denominator = (1 - 1 / ((1+discount_rate) ** n_years)) / (1 - 1 / (1 + discount_rate)) * (1 / (1+discount_rate))\n",
    "    return nominator / denominator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PV price per kW, rebate per kW, and PV module efficiency, from Tracking the Sun dataset\n",
    "price_by_county = pd.read_csv(\n",
    "    'data/socioeconomics/price_and_efficiency_TTS/pv_price_by_county.csv')\n",
    "rebate_by_county = pd.read_csv(\n",
    "    'data/socioeconomics/price_and_efficiency_TTS/rebate_or_grant_by_county.csv')\n",
    "efficiency_by_state = pd.read_csv(\n",
    "    'data/socioeconomics/price_and_efficiency_TTS/pv_efficiency_by_state.csv')\n",
    "efficiency_overall = pd.read_csv(\n",
    "    'data/socioeconomics/price_and_efficiency_TTS/pv_efficiency_us_overall.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create searching dict\n",
    "efficiency_overall_dict = {}\n",
    "for i in efficiency_overall.index:\n",
    "    year = efficiency_overall.loc[i, 'year']\n",
    "    efficiency_overall_dict[year] = efficiency_overall.loc[i, 'efficiency_median']\n",
    "    \n",
    "efficiency_by_state_dict = {}\n",
    "for i in efficiency_by_state.index:\n",
    "    year = efficiency_by_state.loc[i, 'year']\n",
    "    state_abbr = efficiency_by_state.loc[i, 'state_abbr']\n",
    "    efficiency_by_state_dict[(state_abbr, year)] = efficiency_by_state.loc[i, 'efficiency_median']\n",
    "    \n",
    "price_by_county_dict = {}\n",
    "for i in price_by_county.index:\n",
    "    year = price_by_county.loc[i, 'year']\n",
    "    cfips = price_by_county.loc[i, 'county_FIPS']\n",
    "    price_by_county_dict[(cfips, year)] = price_by_county.loc[i, 'price_per_kw_median_inflation_adj']\n",
    "    \n",
    "rebate_by_county_dict = {}\n",
    "for i in rebate_by_county.index:\n",
    "    year = rebate_by_county.loc[i, 'year']\n",
    "    cfips = rebate_by_county.loc[i, 'county_FIPS']\n",
    "    rebate_by_county_dict[(cfips, year)] = rebate_by_county.loc[i, 'rebate_or_grant_per_kw_median_inflation_adj']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imputed price and rebate\n",
    "imputed_prices = pd.read_csv('data/socioeconomics/price_and_efficiency_TTS/pv_median_price_by_county_imputed.csv')\n",
    "imputed_prices.index = imputed_prices['county_FIPS']\n",
    "\n",
    "# imputed rebate\n",
    "imputed_rebates = pd.read_csv('data/socioeconomics/price_and_efficiency_TTS/rebate_by_county_imputed.csv')\n",
    "imputed_rebates.index = imputed_rebates['county_FIPS']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# electricity rate\n",
    "rate_tract = pd.read_csv('data/socioeconomics/electricity_rate_nrel/electricity_rate_by_tract_year.csv')\n",
    "rate_tract_2 = pd.read_csv(\n",
    "    'data/socioeconomics/electricity_rate_nrel/electricity_rate_by_tract_year_363counties.csv')\n",
    "rate_tract_3 = pd.read_csv(\n",
    "    'data/socioeconomics/electricity_rate_nrel/electricity_rate_by_tract_year_2718counties.csv')\n",
    "rate_tract = pd.concat([rate_tract, rate_tract_2, rate_tract_3], ignore_index=True)\n",
    "rate_tract.rename(columns={'fips': 'tract_FIPS'}, inplace=True)\n",
    "\n",
    "# adjust by inflation for electricity rates\n",
    "for x in ['residential_rate', 'commercial_rate', 'industrial_rate']:\n",
    "    rate_tract[x + '_inflation_adj'] = 0.\n",
    "    for year in range(2005, 2018):\n",
    "         rate_tract[x + '_inflation_adj'] += (rate_tract['year'] == year) * rate_tract[x] * inflation_adj_rate[year]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# map (tract FIPS, year) to its corresponding electricity rate\n",
    "rate_tract_dict = {}\n",
    "for i in rate_tract.index:\n",
    "    year = rate_tract.loc[i, 'year']\n",
    "    tfips = rate_tract.loc[i, 'tract_FIPS']\n",
    "    rate_tract_dict[(tfips, year)] = rate_tract.loc[i, 'residential_rate_inflation_adj']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Operation & maintanance cost per year\n",
    "# https://www.nrel.gov/docs/fy21osti/77324.pdf, page 28\n",
    "OM_cost_per_year_dict = {2010: 56, 2011: 49, 2012: 42, 2013: 36, 2014: 31, 2015: 26, 2016: 25, 2017: 25, 2018: 25}\n",
    "for x in OM_cost_per_year_dict:\n",
    "    OM_cost_per_year_dict[x] = OM_cost_per_year_dict[x] * inflation_adj_rate[2019]\n",
    "# As OM cost data is not available before 2010, we use 0.007 * median price_per_kw_median_inflation_adj as a proxy\n",
    "for x in [2005, 2006, 2007, 2008, 2009]:\n",
    "    OM_cost_per_year_dict[x] = 0.007 * price_by_county.groupby('year').agg(\n",
    "                                                                'mean').loc[x, 'price_per_kw_median_inflation_adj']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged2 = pd.read_csv('results/bass_model/merged_bg_bass.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The year when 1st PV was installed in a blockgroup, predicted by fitted Bass model\n",
    "merged2['predicted_1st_adoption_time'] = \\\n",
    "        get_t_by_cum_adoption_amount(merged2['p'], merged2['q'], merged2['m'], merged2['d'], 1)\n",
    "merged2['state_FIPS'] = merged2['state_FIPS'].astype(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The year when 1st PV was installed in a blockgroup, observed in the data\n",
    "l = []\n",
    "for i in merged2.index:\n",
    "    bfips = merged2.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",
    "merged2['actual_1st_adoption_time'] = l\n",
    "merged2['actual_1st_adoption_time'] -= 2006"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7414369110995214"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ss = merged2[['d', 'actual_1st_adoption_time', 'predicted_1st_adoption_time']]\n",
    "ss = ss.dropna()\n",
    "ss['predicted_1st_adoption_time'] = np.maximum(-1, ss['predicted_1st_adoption_time'])\n",
    "ss['d'] = np.maximum(-1, ss['d'])\n",
    "r2_score(ss['actual_1st_adoption_time'], ss['predicted_1st_adoption_time'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged2['d_rounded'] = np.round(merged2['d'], 0) + 2006\n",
    "merged2['predicted_1st_adoption_time_rounded'] = np.round(merged2['predicted_1st_adoption_time'], 0) + 2006\n",
    "merged2['actual_1st_adoption_time_rounded'] = np.round(merged2['actual_1st_adoption_time'], 0) + 2006"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 Cost and benefit at the onset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "anchor_year_col = 'd_rounded'\n",
    "l = []\n",
    "for i in merged2[merged2[anchor_year_col].isnull() == False].index:\n",
    "    bfips = merged2.loc[i, 'blockgroup_FIPS']\n",
    "    tfips = bfips // 10\n",
    "    cfips = bfips // 10000000\n",
    "    GHI = merged2.loc[i, 'avg_GHI']\n",
    "    anchor_year = int(merged2.loc[i, anchor_year_col])\n",
    "#     anchor_year = 2010\n",
    "    if anchor_year > 2017 or anchor_year < 2005:\n",
    "        continue\n",
    "    if (cfips, anchor_year) not in price_by_county_dict:\n",
    "        continue\n",
    "    efficiency = efficiency_overall_dict[anchor_year]\n",
    "    OM_cost_per_year = OM_cost_per_year_dict[anchor_year]\n",
    "    price_per_kw = price_by_county_dict[(cfips, anchor_year)]\n",
    "    res_rate = rate_tract_dict[(tfips, anchor_year)]\n",
    "    lcoe = price_per_kw / (GHI * 1.0)\n",
    "    calculated_lcoe = calculate_LCOE_2(price_per_kw, OM_cost_per_year, GHI, \n",
    "                                     n_years=30, discount_rate=0.04, performance_ratio=1.)\n",
    "    levelized_res_rate = calculate_levelized_electricity_rate(res_rate, \n",
    "                                     n_years=30, discount_rate=0.04, cost_escalation_rate=0.01)\n",
    "    if (cfips, anchor_year) not in rebate_by_county_dict:\n",
    "        rebate_per_kw = None\n",
    "        calculated_lcoe_subsidized = None\n",
    "        price_per_kw_subsidized = None\n",
    "    else:\n",
    "        rebate_per_kw = rebate_by_county_dict[(cfips, anchor_year)]\n",
    "        calculated_lcoe_subsidized = calculate_LCOE_2(price_per_kw - rebate_per_kw, OM_cost_per_year, GHI, \n",
    "                                     n_years=30, discount_rate=0.04, performance_ratio=1.)\n",
    "        price_per_kw_subsidized = price_per_kw - rebate_per_kw\n",
    "        \n",
    "    l.append([bfips, price_per_kw, price_per_kw_subsidized, rebate_per_kw,\n",
    "              res_rate, levelized_res_rate, lcoe, calculated_lcoe, calculated_lcoe_subsidized])\n",
    "cost_benefit_onset_df = pd.DataFrame(l)\n",
    "cost_benefit_onset_df.columns = [\n",
    "    'blockgroup_FIPS',\n",
    "    'price_per_kw_onset',\n",
    "    'price_per_kw_subsidized_onset',\n",
    "    'rebate_or_grant_per_kw_onset',\n",
    "    'residential_rate_onset', \n",
    "    'residential_rate_levelized_onset',\n",
    "    'LCOE_uncalibrated_onset',\n",
    "    'LCOE_calculated_onset',\n",
    "    'LCOE_calculated_subsidized_onset',\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                               OLS Regression Results                              \n",
      "===================================================================================\n",
      "Dep. Variable:     LCOE_uncalibrated_onset   R-squared:                       0.035\n",
      "Model:                                 OLS   Adj. R-squared:                  0.035\n",
      "Method:                      Least Squares   F-statistic:                     304.6\n",
      "Date:                     Wed, 07 Sep 2022   Prob (F-statistic):           2.36e-67\n",
      "Time:                             11:58:52   Log-Likelihood:                -45144.\n",
      "No. Observations:                    11715   AIC:                         9.029e+04\n",
      "Df Residuals:                        11713   BIC:                         9.031e+04\n",
      "Df Model:                                1                                         \n",
      "Covariance Type:                       HC1                                         \n",
      "==========================================================================================\n",
      "                             coef    std err          z      P>|z|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------------------\n",
      "Intercept                 23.5204      0.544     43.206      0.000      22.453      24.587\n",
      "residential_rate_onset    62.6312      3.589     17.452      0.000      55.597      69.665\n",
      "==============================================================================\n",
      "Omnibus:                     2006.928   Durbin-Watson:                   1.197\n",
      "Prob(Omnibus):                  0.000   Jarque-Bera (JB):             3955.292\n",
      "Skew:                           1.046   Prob(JB):                         0.00\n",
      "Kurtosis:                       4.931   Cond. No.                         29.3\n",
      "==============================================================================\n",
      "\n",
      "Warnings:\n",
      "[1] Standard Errors are heteroscedasticity robust (HC1)\n"
     ]
    }
   ],
   "source": [
    "# Calibration\n",
    "dependent = 'LCOE_uncalibrated_onset'\n",
    "features = [\n",
    "    'residential_rate_onset',\n",
    "]\n",
    "results_calibration = smf.ols(make_str(dependent, features), data=cost_benefit_onset_df).fit(cov_type='HC1')\n",
    "print(results_calibration.summary())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "62.631243406307966 23.520413150524803\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'p / r at the onset')"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(7, 5))\n",
    "print(results_calibration.params['residential_rate_onset'],results_calibration.params['Intercept'])\n",
    "plt.scatter(\n",
    "    cost_benefit_onset_df['residential_rate_onset'], \n",
    "    cost_benefit_onset_df['LCOE_uncalibrated_onset'], \n",
    "    s=1)\n",
    "x1 = cost_benefit_onset_df['residential_rate_onset'].min()\n",
    "x2 = cost_benefit_onset_df['residential_rate_onset'].max()\n",
    "y1 = results_calibration.params['residential_rate_onset'] * x1 + results_calibration.params['Intercept']\n",
    "y2 = results_calibration.params['residential_rate_onset'] * x2 + results_calibration.params['Intercept']\n",
    "plt.plot([x1, x2], [y1, y2], color='red')\n",
    "plt.xlabel('Residential rate at the onset', fontsize=15)\n",
    "plt.ylabel('p / r at the onset', fontsize=15)\n",
    "# plt.ylim(0, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "cost_benefit_onset_df['rate_LCOE_diff_calibrated_onset'] =\\\n",
    "    results_calibration.params['residential_rate_onset'] * cost_benefit_onset_df['residential_rate_onset'] -\\\n",
    "    cost_benefit_onset_df['LCOE_uncalibrated_onset']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# derived variables\n",
    "cost_benefit_onset_df['rate_LCOE_diff_calculated_onset'] =\\\n",
    "    cost_benefit_onset_df['residential_rate_onset'] - cost_benefit_onset_df['LCOE_calculated_onset']\n",
    "cost_benefit_onset_df['rate_LCOE_diff_subsidized_calculated_onset'] =\\\n",
    "    cost_benefit_onset_df['residential_rate_onset'] - cost_benefit_onset_df['LCOE_calculated_subsidized_onset']\n",
    "cost_benefit_onset_df['levelized_rate_LCOE_diff_calculated_onset'] =\\\n",
    "    cost_benefit_onset_df['residential_rate_levelized_onset'] - cost_benefit_onset_df['LCOE_calculated_onset']\n",
    "cost_benefit_onset_df['levelized_rate_LCOE_diff_subsidized_calculated_onset'] =\\\n",
    "cost_benefit_onset_df['residential_rate_levelized_onset'] - cost_benefit_onset_df['LCOE_calculated_subsidized_onset']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Cost and benefit by year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 54493/54493 [00:13<00:00, 4083.96it/s] \n"
     ]
    }
   ],
   "source": [
    "# Use imputed price and rebate\n",
    "l = []\n",
    "for i in tqdm(merged2.index):\n",
    "    bfips = merged2.loc[i, 'blockgroup_FIPS']\n",
    "    tfips = bfips // 10\n",
    "    cfips = bfips // 10000000\n",
    "    GHI = merged2.loc[i, 'avg_GHI']\n",
    "    for anchor_year in range(2005, 2018):\n",
    "        OM_cost_per_year = OM_cost_per_year_dict[anchor_year]\n",
    "        if cfips not in imputed_prices.index:\n",
    "            continue\n",
    "        price_per_kw = imputed_prices.loc[cfips, str(anchor_year)]\n",
    "        price_per_kw = max(price_per_kw, 0) # bounded to be >= 0 !!!\n",
    "        \n",
    "        res_rate = rate_tract_dict[(tfips, anchor_year)]\n",
    "        lcoe = price_per_kw / (GHI * 1.0)\n",
    "        calculated_lcoe = calculate_LCOE_2(price_per_kw, OM_cost_per_year, GHI, \n",
    "                                         n_years=30, discount_rate=0.04, performance_ratio=1.)\n",
    "        levelized_res_rate = calculate_levelized_electricity_rate(res_rate, \n",
    "                                     n_years=30, discount_rate=0.04, cost_escalation_rate=0.01)\n",
    "        \n",
    "        if cfips not in imputed_rebates.index:\n",
    "            rebate_per_kw = None\n",
    "            calculated_lcoe_subsidized = None\n",
    "            price_per_kw_subsidized = None\n",
    "        \n",
    "        else:\n",
    "            rebate_per_kw = imputed_rebates.loc[cfips, str(anchor_year)]\n",
    "            rebate_per_kw = max(rebate_per_kw, 0) # bounded to be >= 0 !!!\n",
    "            calculated_lcoe_subsidized = calculate_LCOE_2(price_per_kw - rebate_per_kw, OM_cost_per_year, GHI, \n",
    "                                     n_years=30, discount_rate=0.04, performance_ratio=1.)\n",
    "            price_per_kw_subsidized = price_per_kw - rebate_per_kw\n",
    "        \n",
    "        l.append([bfips, anchor_year, price_per_kw, price_per_kw_subsidized, rebate_per_kw,\n",
    "              res_rate, levelized_res_rate, lcoe, calculated_lcoe, calculated_lcoe_subsidized])\n",
    "\n",
    "cost_benefit_df = pd.DataFrame(l)\n",
    "cost_benefit_df.columns = [\n",
    "    'blockgroup_FIPS', \n",
    "    'year',\n",
    "    'price_per_kw',\n",
    "    'price_per_kw_subsidized',\n",
    "    'rebate_or_grant_per_kw',\n",
    "    'residential_rate', \n",
    "    'residential_rate_levelized',\n",
    "    'LCOE_uncalibrated',\n",
    "    'LCOE_calculated',\n",
    "    'LCOE_calculated_subsidized',\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "cost_benefit_df['rate_LCOE_diff_calculated'] = cost_benefit_df['residential_rate'] - cost_benefit_df['LCOE_calculated']\n",
    "cost_benefit_df['rate_LCOE_diff_subsidized_calculated'] = cost_benefit_df['residential_rate'] -\\\n",
    "                                               cost_benefit_df['LCOE_calculated_subsidized']\n",
    "cost_benefit_df['levelized_rate_LCOE_diff_calculated'] = cost_benefit_df['residential_rate_levelized'] -\\\n",
    "                                                         cost_benefit_df['LCOE_calculated']\n",
    "cost_benefit_df['levelized_rate_LCOE_diff_subsidized_calculated'] = cost_benefit_df['residential_rate_levelized'] -\\\n",
    "                                                          cost_benefit_df['LCOE_calculated_subsidized']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# average cost/benefit over 2005-2016\n",
    "cost_benefit_avg = cost_benefit_df[\n",
    "    (cost_benefit_df['year'] >= 2005) & (cost_benefit_df['year'] <= 2016)].groupby('blockgroup_FIPS').agg('mean')\n",
    "del cost_benefit_avg['year']\n",
    "cost_benefit_avg.columns = [x + '_avg' for x in cost_benefit_avg.columns]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/pandas/core/frame.py:4025: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  return super(DataFrame, self).rename(**kwargs)\n"
     ]
    }
   ],
   "source": [
    "cost_benefit_2016 = cost_benefit_df[cost_benefit_df['year'] == 2016]\n",
    "del cost_benefit_2016['year']\n",
    "cost_benefit_2016.rename(\n",
    "    columns={x: x + '_2016' for x in cost_benefit_2016.columns if x != 'blockgroup_FIPS'},\n",
    "    inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def statsmodel_results_to_df_2(results):\n",
    "    \"\"\"Convert the statsmodel results into a dataframe\"\"\"\n",
    "    res = results.params.to_frame(name='coef')\n",
    "#     res['std err'] = results.HC1_se\n",
    "    res['std err'] = results.bse\n",
    "    res['z'] = results.tvalues\n",
    "    res['P>|z|'] = results.pvalues\n",
    "    res = res.loc[[x for x in res.index if 'state' not in x or ':' in x], :]\n",
    "    l = []\n",
    "    for x in res.index:\n",
    "        pval = res.loc[x, 'P>|z|']\n",
    "        if pval < 0.001:\n",
    "            star = '***'\n",
    "        elif pval < 0.01:\n",
    "            star = '**'\n",
    "        elif pval < 0.05:\n",
    "            star = '*'\n",
    "        else:\n",
    "            star = ''\n",
    "        l.append(star)\n",
    "    res['significance'] = l\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def order_variables_by_coefs(coef_list, CI_list, varname_list):\n",
    "    \"\"\"\n",
    "    Sort the coefficients by coefficient value (high to low), sort \n",
    "    the coefficient names and CI accordingly.\n",
    "    \"\"\"\n",
    "    combo_list = list(zip(coef_list, CI_list, varname_list))\n",
    "    combo_list.sort(key=lambda x: x[0], reverse=True)\n",
    "    coef_list1 = []\n",
    "    CI_list1 = []\n",
    "    varname_list1 = []\n",
    "    for coef, ci, varname in combo_list:\n",
    "        coef_list1.append(coef)\n",
    "        CI_list1.append(ci)\n",
    "        varname_list1.append(varname)\n",
    "    return coef_list1, CI_list1, varname_list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def order_variables_by_varnames(coef_list, CI_list, varname_list, signifance_list=None, varname_order=None):\n",
    "    \"\"\"\n",
    "    Sort the coefficients by given varname order, sort \n",
    "    the coefficient names and CI accordingly.\n",
    "    \"\"\"\n",
    "    varname_order_dict = {}\n",
    "    if varname_order:\n",
    "        for i, varname in enumerate(varname_order):\n",
    "            varname_order_dict[varname] = i\n",
    "    return_sigificance = True\n",
    "    if not signifance_list:\n",
    "        signifance_list = ['' for i in range(len(coef_list))]\n",
    "        return_sigificance = False\n",
    "    for varname in varname_list:\n",
    "        if varname not in varname_order_dict:\n",
    "            if 'LCOE' in varname:\n",
    "                for x in varname_order_dict:\n",
    "                    if 'LCOE' in x:\n",
    "                        break\n",
    "                varname_order_dict[varname] = varname_order_dict[x]\n",
    "            else:\n",
    "                varname_order_dict[varname] = 9999\n",
    "    combo_list = list(zip(coef_list, CI_list, varname_list, signifance_list))\n",
    "    combo_list.sort(key=lambda x: varname_order_dict[x[2]])\n",
    "    coef_list1 = []\n",
    "    CI_list1 = []\n",
    "    varname_list1 = []\n",
    "    signifance_list1 = []\n",
    "    for coef, ci, varname, significance in combo_list:\n",
    "        coef_list1.append(coef)\n",
    "        CI_list1.append(ci)\n",
    "        varname_list1.append(varname)\n",
    "        signifance_list1.append(significance)\n",
    "    if return_sigificance:\n",
    "        return coef_list1, CI_list1, varname_list1, signifance_list1\n",
    "    else:\n",
    "        return coef_list1, CI_list1, varname_list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged3 = pd.merge(merged2, cost_benefit_onset_df, how='left', on='blockgroup_FIPS')\n",
    "merged3 = pd.merge(merged3, cost_benefit_avg, how='left', on='blockgroup_FIPS')\n",
    "merged3 = pd.merge(merged3, cost_benefit_2016, how='left', on='blockgroup_FIPS')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged3['county_FIPS'] = merged3['blockgroup_FIPS'] // 10000000\n",
    "merged3['county_FIPS'] = merged3['county_FIPS'].astype(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged3['installation_indicator_2016'] = merged3['blockgroup_FIPS'].isin(\n",
    "    cum_adoption_matrix_bg[cum_adoption_matrix_bg['2016'] > 0].index).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.4888968244948154\n",
      "0.21474396540173235\n",
      "0.4875631190405393\n"
     ]
    }
   ],
   "source": [
    "for response in ['ACS_edu_score_2016', \n",
    "                 'ACS_occupancy_occupied_renter_rate_2016', 'ACS_housing_unit_median_value_2016']:\n",
    "    df_reg_sub = merged3[['blockgroup_FIPS', response, 'ACS_median_household_income_2016']]\n",
    "    df_reg_sub = df_reg_sub.dropna()\n",
    "    X = df_reg_sub['ACS_median_household_income_2016'].to_numpy().reshape([-1, 1])\n",
    "    y = df_reg_sub[response].to_numpy()\n",
    "    lm = LinearRegression()\n",
    "    lm.fit(X, y)\n",
    "    y_pred = lm.predict(X)\n",
    "    print(r2_score(y, y_pred))\n",
    "    df_reg_sub[response + '_pred'] = y_pred\n",
    "    df_reg_sub[response + '_residual'] = df_reg_sub[response] - df_reg_sub[response + '_pred']\n",
    "    merged3 = pd.merge(merged3, df_reg_sub[['blockgroup_FIPS', response + '_residual']], how='left', \n",
    "                       on='blockgroup_FIPS')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "income_normalized_benefit_mapping = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert the unit relative benefit of PV from $ to cent\n",
    "merged3['rate_LCOE_diff_calculated_avg'] *= 100\n",
    "merged3['levelized_rate_LCOE_diff_calculated_avg'] *= 100\n",
    "merged3['rate_LCOE_diff_subsidized_calculated_avg'] *= 100\n",
    "merged3['levelized_rate_LCOE_diff_subsidized_calculated_avg'] *= 100\n",
    "merged3['rebate_or_grant_per_kw_avg'] *= 100\n",
    "merged3['price_per_kw_avg'] *= 100\n",
    "merged3['price_per_kw_subsidized_avg'] *= 100\n",
    "\n",
    "merged3['rate_LCOE_diff_calculated_2016'] *= 100\n",
    "merged3['levelized_rate_LCOE_diff_calculated_2016'] *= 100\n",
    "merged3['rate_LCOE_diff_subsidized_calculated_2016'] *= 100\n",
    "merged3['levelized_rate_LCOE_diff_subsidized_calculated_2016'] *= 100\n",
    "merged3['rebate_or_grant_per_kw_2016'] *= 100\n",
    "merged3['price_per_kw_2016'] *= 100\n",
    "merged3['price_per_kw_subsidized_2016'] *= 100\n",
    "\n",
    "merged3['rate_LCOE_diff_calculated_onset'] *= 100\n",
    "merged3['levelized_rate_LCOE_diff_calculated_onset'] *= 100\n",
    "merged3['rate_LCOE_diff_subsidized_calculated_onset'] *= 100\n",
    "merged3['levelized_rate_LCOE_diff_subsidized_calculated_onset'] *= 100\n",
    "merged3['rebate_or_grant_per_kw_onset'] *= 100\n",
    "merged3['price_per_kw_onset'] *= 100\n",
    "merged3['price_per_kw_subsidized_onset'] *= 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "name_dict = {\n",
    "    'ACS_median_household_income_2016': 'Median household\\nincome',\n",
    "    'ACS_housing_unit_density_2016': 'Housing unit\\ndensity',\n",
    "    'ACS_diversity_NH_2016': 'Racial diversity',\n",
    "    'ACS_diversity_NH_2016_simpson': 'Racial diversity\\n(Simpson\\'s index)',\n",
    "    'ACS_age_median_2016': 'Median age of\\npopulation',\n",
    "    'ACS_occupancy_occupied_rate_2016': 'Housing unit \\noccupancy rate',\n",
    "    'ACS_occupancy_occupied_renter_rate_2016': '% renter-occupied\\nhousing units',\n",
    "    \n",
    "    'ACS_edu_score_2016': 'Years of education',\n",
    "    \n",
    "    'ACS_edu_score_2016_residual': 'Years of education\\n(residual)',\n",
    "    'ACS_occupancy_occupied_renter_rate_2016_residual': '% renter-occupied\\nhousing units (residual)',\n",
    "    'ACS_housing_unit_median_value_2016_residual': 'Median housing unit\\nvalue (residual)',\n",
    "    # \n",
    "    'rate_LCOE_diff_calculated_avg': 'Avg. PV benefit',\n",
    "    'levelized_rate_LCOE_diff_calculated_avg': 'Avg. PV benefit',\n",
    "    'rate_LCOE_diff_subsidized_calculated_avg': 'Avg. PV benefit\\nwith rebate/grant',\n",
    "    'levelized_rate_LCOE_diff_subsidized_calculated_avg': 'Avg. PV benefit\\nwith rebate/grant',\n",
    "    'rebate_or_grant_per_kw_avg': 'Avg. rebate/grant\\nper kW',\n",
    "    'price_per_kw_avg': 'Avg. PV cost\\nper kW',\n",
    "    'price_per_kw_subsidized_avg': 'Avg. PV cost\\nper kW (subsidized)',\n",
    "    'relative_benefit_avg': 'Avg. relative savings\\nof PV (as a share of income)',\n",
    "    'relative_subsidized_benefit_avg': 'Avg. relative savings\\nof PV (with rebate/grant,\\nas a share of income)',\n",
    "    'relative_levelized_benefit_avg': 'Avg. relative savings\\nof PV (as a share of income)',\n",
    "    'relative_levelized_subsidized_benefit_avg': 'Avg. relative savings\\nof PV (with rebate/grant,\\nas a share of income)',\n",
    "    # \n",
    "    'rate_LCOE_diff_calculated_2016': 'PV benefit in 2016',\n",
    "    'levelized_rate_LCOE_diff_calculated_2016': 'PV benefit in 2016',\n",
    "    'rate_LCOE_diff_subsidized_calculated_2016': 'PV benefit with\\nrebate/grant in 2016',\n",
    "    'levelized_rate_LCOE_diff_subsidized_calculated_2016': 'PV benefit with\\nrebate/grant in 2016',\n",
    "    'rebate_or_grant_per_kw_2016': 'Rebate/grant per kW\\nin 2016',\n",
    "    'price_per_kw_2016': 'PV cost per kW\\nin 2016',\n",
    "    'price_per_kw_subsidized_2016': 'PV cost per kW\\nin 2016 (subsidized)',\n",
    "    \n",
    "    'relative_benefit_2016': 'Relative savings of PV\\nin 2016 (as a share of income)',\n",
    "    'relative_subsidized_benefit_2016': 'Relative savings of PV\\nin 2016 (with rebate/grant,\\nas a share of income)',\n",
    "    'relative_levelized_benefit_2016': 'Relative savings of PV\\nin 2016 (as a share of income)',\n",
    "    'relative_levelized_subsidized_benefit_2016': 'Relative savings of PV\\nin 2016 (with rebate/grant,\\nas a share of income)',\n",
    "    #\n",
    "    'rate_LCOE_diff_calculated_onset': 'PV benefit at onset',\n",
    "    'levelized_rate_LCOE_diff_calculated_onset': 'PV benefit at onset',\n",
    "    'rate_LCOE_diff_subsidized_calculated_onset': 'PV benefit(with\\nrebate/grant) at onset',\n",
    "    'levelized_rate_LCOE_diff_subsidized_calculated_onset': 'PV benefit(with\\nrebate/grant) at onset',\n",
    "    'rebate_or_grant_per_kw_onset': 'Rebate/grant per kW\\nat onset',\n",
    "    'price_per_kw_onset': 'PV cost per kW\\nat onset',\n",
    "    'price_per_kw_subsidized_onset': 'PV cost per kW\\nat onset (subsidized)',\n",
    "    \n",
    "    'relative_benefit_onset': 'Relative savings of PV\\nat onset (as a share of income)',\n",
    "    'relative_subsidized_benefit_onset': 'Relative savings of PV\\nat onset (with rebate/grant,\\nas a share of income)',\n",
    "    'relative_levelized_benefit_onset': 'Relative savings of PV\\nat onset (as a share of income)',\n",
    "    'relative_levelized_subsidized_benefit_onset': 'Relative savings of PV\\nat onset (with rebate/grant,\\nas a share of income)',\n",
    "    #\n",
    "    'ACS_median_household_income_2016:rate_LCOE_diff_subsidized_calculated_avg': 'Income x\\n avg. profit margin',\n",
    "    'ACS_median_household_income_2016:rate_LCOE_diff_subsidized_calculated_onset': 'Income x\\n profit margin at onset',\n",
    "    'ACS_median_household_income_2016:rate_LCOE_diff_subsidized_calculated_2016': 'Income x\\n profit margin in 2016',\n",
    "    \n",
    "    'incentive_grant_program': 'Grant',\n",
    "    'incentive_leasing_program': 'Leasing',\n",
    "    'incentive_loan_program': 'Loan',\n",
    "    'incentive_pace_financing': 'PACE',\n",
    "    'incentive_performance_based_incentive': 'PBI',\n",
    "    'incentive_property_tax_incentive': 'Property tax\\nincentive',\n",
    "    'incentive_rebate_program': 'Rebate',\n",
    "    'incentive_utility_rate_discount': 'Utility rate\\ndiscount',\n",
    "    'incentive_property_tax_incentive': 'PTI',\n",
    "    'incentive_green_building_incentive': 'GBI',\n",
    "    'incentive_sales_tax_incentive': 'Sales tax\\nincentive',\n",
    "    'incentive_personal_tax_credit': 'Personal tax\\ncredit',\n",
    "    'incentive_feed_in_tariff': 'FiT',\n",
    "    'incentive_net_metering': 'NEM',\n",
    "    \n",
    "    'avg_GHI': 'Avg. GHI',\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "incentive_type_indicator_bg = pd.read_csv(\n",
    "    'data/incentives/spatiotemporal_res_incentive_type_indicator_bg_420counties.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/pandas/core/frame.py:4025: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  return super(DataFrame, self).rename(**kwargs)\n"
     ]
    }
   ],
   "source": [
    "incentive_type_indicator_2016 = incentive_type_indicator_bg[incentive_type_indicator_bg['year'] == 2016]\n",
    "del incentive_type_indicator_2016['year']\n",
    "incentive_type_indicator_2016.rename(columns={x: x + '_2016' for x in incentive_type_indicator_2016.columns\n",
    "                                             if 'incentive' in x},\n",
    "                                    inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "incentive_type_indicator_avg = incentive_type_indicator_bg[\n",
    "    (incentive_type_indicator_bg['year'] >= 2005) & (incentive_type_indicator_bg['year'] <= 2016)].groupby('blockgroup_FIPS').agg('mean')\n",
    "del incentive_type_indicator_avg['year']\n",
    "incentive_type_indicator_avg.rename(columns={x: x + '_avg' for x in incentive_type_indicator_avg.columns\n",
    "                                             if 'incentive' in x},\n",
    "                                    inplace=True)\n",
    "incentive_type_indicator_avg.reset_index(inplace=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged3 = pd.merge(merged3, incentive_type_indicator_2016, how='left', on='blockgroup_FIPS')\n",
    "merged3 = pd.merge(merged3, incentive_type_indicator_avg, how='left', on='blockgroup_FIPS')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# divided indicator by GHI\n",
    "for col in incentive_type_indicator_2016.columns:\n",
    "    if 'incentive' in col:\n",
    "        merged3[col + '_normalized'] = merged3[col] / merged3['avg_GHI']\n",
    "for col in incentive_type_indicator_avg.columns:\n",
    "    if 'incentive' in col:\n",
    "        merged3[col + '_normalized'] = merged3[col] / merged3['avg_GHI']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# all involved incentives\n",
    "all_incentive_types = []\n",
    "for x in merged3.columns:\n",
    "    if 'incentive' in x and 'rollout' not in x and 'before_saturation' not in x and 'onset' not in x and 'normalized' not in x and 'avg' not in x and '2016' not in x:\n",
    "        all_incentive_types.append(x)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_OLS_regression(t, configs, std_type='HC1', fixed_effect=None, cluster='state_FIPS',\n",
    "                      income_normalized_benefit=False, only_adoption=True, return_raw_results=False):\n",
    "    reg_results = {}\n",
    "    for config_name in configs:\n",
    "        config = configs[config_name]\n",
    "        dependent = config['dependent']\n",
    "        features = config['features'].copy()\n",
    "        if income_normalized_benefit:\n",
    "            if dependent in income_normalized_benefit_mapping:\n",
    "                dependent = income_normalized_benefit_mapping[dependent]\n",
    "            features_new = []\n",
    "            for x in features:\n",
    "                if x in income_normalized_benefit_mapping:\n",
    "                    features_new.append(income_normalized_benefit_mapping[x])\n",
    "                else:\n",
    "                    features_new.append(x)\n",
    "            features = features_new.copy()\n",
    "        if fixed_effect and fixed_effect not in features and config['incentive_indicators'] is None:\n",
    "            features.append(fixed_effect)\n",
    "        incentive_indicators = config['incentive_indicators']\n",
    "        normalize_features = config['normalize_features']        \n",
    "        if incentive_indicators:\n",
    "            features.extend(incentive_indicators)\n",
    "        other_vars = []\n",
    "        if std_type == 'cluster' and cluster not in features:\n",
    "            other_vars.append(cluster)\n",
    "        if only_adoption:\n",
    "            df_reg = t[t['d'].isnull() == False][features + [dependent] + other_vars]\n",
    "        else:\n",
    "            df_reg = t[features + [dependent] + other_vars]\n",
    "        if normalize_features:\n",
    "            for feature in features:\n",
    "                if 'FIPS' not in feature:\n",
    "                    df_reg[feature] = (df_reg[feature] - df_reg[feature].mean()) / df_reg[feature].std()\n",
    "        fmla = make_str(dependent, features)  \n",
    "        if std_type == 'cluster':\n",
    "            df_reg = df_reg.dropna()\n",
    "            %R -i fmla\n",
    "            %R -i df_reg\n",
    "            %R -i cluster\n",
    "            %R -i std_type\n",
    "            %R library(lmtest)\n",
    "            %R library(sandwich)\n",
    "\n",
    "            %R model <- lm(fmla, data = df_reg) \n",
    "            %R coeftest_results <- coeftest(model, vcov. = vcovCL(model, cluster = df_reg[[cluster]], type = \"HC0\"))\n",
    "            %R coeftest_results_df <- as.data.frame.matrix(coeftest_results)\n",
    "            %R write.csv(coeftest_results_df, 'results/tmp_regression_results.csv')\n",
    "        else:\n",
    "            %R -i fmla\n",
    "            %R -i df_reg\n",
    "            %R -i cluster\n",
    "            %R -i std_type\n",
    "            %R library(lmtest)\n",
    "            %R library(sandwich)\n",
    "\n",
    "            %R model <- lm(fmla, data = df_reg) \n",
    "            %R coeftest_results <- coeftest(model, vcov = vcovHC, type = std_type)\n",
    "            %R coeftest_results_df <- as.data.frame.matrix(coeftest_results)\n",
    "            %R write.csv(coeftest_results_df, 'results/tmp_regression_results.csv')\n",
    "        classification_results = pd.read_csv('results/tmp_regression_results.csv')\n",
    "        classification_results.index = classification_results['Unnamed: 0']\n",
    "        del classification_results['Unnamed: 0']\n",
    "        classification_results.columns = ['coef', 'std err', 'z', 'P>|z|']\n",
    "        classification_results = classification_results.loc[[x for x in classification_results.index if 'state' not in x], :]\n",
    "        l = []\n",
    "        for x in classification_results.index:\n",
    "            pval = classification_results.loc[x, 'P>|z|']\n",
    "            if pval < 0.001:\n",
    "                star = '***'\n",
    "            elif pval < 0.01:\n",
    "                star = '**'\n",
    "            elif pval < 0.05:\n",
    "                star = '*'\n",
    "            else:\n",
    "                star = ''\n",
    "            l.append(star)\n",
    "        classification_results['significance'] = l\n",
    "        reg_results[config_name] = classification_results\n",
    "    return reg_results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 Saturated adotpion rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "configs_saturation_level = {\n",
    "    'unsubsidized_delta_normalized': {\n",
    "        'dependent': 'saturated_adoption_rate_building_lt600',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rate_LCOE_diff_calculated_avg',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'unsubsidized_delta_rebate_normalized': {\n",
    "        'dependent': 'saturated_adoption_rate_building_lt600',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rate_LCOE_diff_calculated_avg',\n",
    "            'rebate_or_grant_per_kw_avg',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'subsidized_delta_normalized': {\n",
    "        'dependent': 'saturated_adoption_rate_building_lt600',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rate_LCOE_diff_subsidized_calculated_avg',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'unsubsidized_delta_indicator': {\n",
    "        'dependent': 'saturated_adoption_rate_building_lt600',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rate_LCOE_diff_calculated_avg',\n",
    "        ],\n",
    "        'incentive_indicators': all_incentive_types,\n",
    "        'normalize_features': False,\n",
    "    },\n",
    "    'subsidized_delta_normalized_indicator': {\n",
    "        'dependent': 'saturated_adoption_rate_building_lt600',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rate_LCOE_diff_subsidized_calculated_avg',\n",
    "            'state_FIPS',\n",
    "#             'avg_GHI',\n",
    "        ],\n",
    "        'incentive_indicators': [\n",
    "            'incentive_performance_based_incentive_avg',\n",
    "        ],\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'unsubsidized_delta_normalized_indicator': {\n",
    "        'dependent': 'saturated_adoption_rate_building_lt600',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rate_LCOE_diff_calculated_avg',\n",
    "            'state_FIPS',\n",
    "        ],\n",
    "        'incentive_indicators': [\n",
    "            'incentive_performance_based_incentive_avg',\n",
    "            'incentive_rebate_program_avg',\n",
    "            'incentive_grant_program_avg',\n",
    "        ],\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "configs_d = {\n",
    "    'unsubsidized_delta_normalized': {\n",
    "        'dependent': 'd',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rate_LCOE_diff_calculated_avg',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'unsubsidized_delta_rebate_normalized': {\n",
    "        'dependent': 'd',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rate_LCOE_diff_calculated_avg',\n",
    "            'rebate_or_grant_per_kw_avg',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'subsidized_delta_normalized': {\n",
    "        'dependent': 'd',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rate_LCOE_diff_subsidized_calculated_avg',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'subsidized_delta_normalized_indicator': {\n",
    "        'dependent': 'd',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rate_LCOE_diff_subsidized_calculated_avg',\n",
    "            'state_FIPS',\n",
    "        ],\n",
    "        'incentive_indicators': [\n",
    "            'incentive_performance_based_incentive_avg',\n",
    "        ],\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'unsubsidized_delta_normalized_indicator': {\n",
    "        'dependent': 'd',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rate_LCOE_diff_calculated_avg',\n",
    "            'state_FIPS',\n",
    "        ],\n",
    "        'incentive_indicators': [\n",
    "            'incentive_performance_based_incentive_avg',\n",
    "            'incentive_rebate_program_avg',\n",
    "            'incentive_grant_program_avg',\n",
    "        ],\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3 Delta at the onset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "configs_delta_onset = {\n",
    "    'unsubsidized_delta_normalized': {\n",
    "        'dependent': 'rate_LCOE_diff_calculated_onset',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'unsubsidized_delta_rebate_normalized': {\n",
    "        'dependent': 'rate_LCOE_diff_calculated_onset',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rebate_or_grant_per_kw_onset',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'subsidized_delta_normalized': {\n",
    "        'dependent': 'rate_LCOE_diff_subsidized_calculated_onset',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4 Delta in 2016"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "configs_delta_2016 = {\n",
    "    'unsubsidized_delta_normalized': {\n",
    "        'dependent': 'rate_LCOE_diff_calculated_2016',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'unsubsidized_delta_rebate_normalized': {\n",
    "        'dependent': 'rate_LCOE_diff_calculated_2016',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rebate_or_grant_per_kw_2016',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'rebate_normalized': {\n",
    "        'dependent': 'rebate_or_grant_per_kw_2016',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'subsidized_delta_normalized': {\n",
    "        'dependent': 'rate_LCOE_diff_subsidized_calculated_2016',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.5 Adoption indicator in 2016"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "configs_adoption_indicator = {\n",
    "    'unsubsidized_delta_normalized': {\n",
    "        'dependent': 'installation_indicator_2016',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rate_LCOE_diff_calculated_2016',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'unsubsidized_delta_rebate_normalized': {\n",
    "        'dependent': 'installation_indicator_2016',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rate_LCOE_diff_calculated_2016',\n",
    "            'rebate_or_grant_per_kw_2016',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'subsidized_delta_normalized': {\n",
    "        'dependent': 'installation_indicator_2016',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rate_LCOE_diff_subsidized_calculated_2016',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'subsidized_delta_normalized_indicator': {\n",
    "        'dependent': 'installation_indicator_2016',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rate_LCOE_diff_subsidized_calculated_2016',\n",
    "            'state_FIPS',\n",
    "        ],\n",
    "        'incentive_indicators': [\n",
    "            'incentive_performance_based_incentive_2016',\n",
    "        ],\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'unsubsidized_delta_normalized_indicator': {\n",
    "        'dependent': 'installation_indicator_2016',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "            'rate_LCOE_diff_calculated_2016',\n",
    "            'state_FIPS',\n",
    "        ],\n",
    "        'incentive_indicators': [\n",
    "            'incentive_performance_based_incentive_2016',\n",
    "            'incentive_rebate_program_2016',\n",
    "            'incentive_grant_program_2016',\n",
    "        ],\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'PBI_normalized': {\n",
    "        'dependent': 'incentive_performance_based_incentive_2016',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "    'rebate_normalized': {\n",
    "        'dependent': 'incentive_rebate_program_2016',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "        ],\n",
    "        'incentive_indicators': None,\n",
    "        'normalize_features': True,\n",
    "    },\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "std_type = 'HC1'\n",
    "se_cluster = 'county_FIPS'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reg_results_saturation_level = run_OLS_regression(merged3, configs_saturation_level, std_type=std_type, \n",
    "                                                  fixed_effect='state_FIPS', cluster=se_cluster,\n",
    "                                                  income_normalized_benefit=False, only_adoption=True,\n",
    "                                                 return_raw_results=False)\n",
    "\n",
    "reg_results_d = run_OLS_regression(merged3, configs_d, std_type=std_type,\n",
    "                                   fixed_effect='state_FIPS', cluster=se_cluster,\n",
    "                                   income_normalized_benefit=False, only_adoption=True,\n",
    "                                  return_raw_results=False)\n",
    "\n",
    "reg_results_delta_onset = run_OLS_regression(merged3, configs_delta_onset, std_type=std_type,\n",
    "                                             fixed_effect='state_FIPS', cluster=se_cluster,\n",
    "                                             income_normalized_benefit=False, only_adoption=True,\n",
    "                                            return_raw_results=False)\n",
    "\n",
    "reg_results_delta_2016 = run_OLS_regression(merged3, configs_delta_2016, std_type=std_type, \n",
    "                                            fixed_effect='state_FIPS', cluster=se_cluster,\n",
    "                                            income_normalized_benefit=False, only_adoption=False,\n",
    "                                           return_raw_results=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fixed_effect = 'state_FIPS'\n",
    "cluster = se_cluster\n",
    "income_normalized_benefit=False\n",
    "only_adoption=False\n",
    "\n",
    "reg_results_adoption_indicator = {}\n",
    "for config_name in configs_adoption_indicator:\n",
    "    config = configs_adoption_indicator[config_name]\n",
    "    dependent = config['dependent']\n",
    "    features = config['features'].copy()\n",
    "    if income_normalized_benefit:\n",
    "        if dependent in income_normalized_benefit_mapping:\n",
    "            dependent = income_normalized_benefit_mapping[dependent]\n",
    "        features_new = []\n",
    "        for x in features:\n",
    "            if x in income_normalized_benefit_mapping:\n",
    "                features_new.append(income_normalized_benefit_mapping[x])\n",
    "            else:\n",
    "                features_new.append(x)\n",
    "        features = features_new.copy()\n",
    "    if fixed_effect and fixed_effect not in features:\n",
    "        features.append(fixed_effect)\n",
    "    incentive_indicators = config['incentive_indicators']\n",
    "    normalize_features = config['normalize_features']\n",
    "    if incentive_indicators:\n",
    "        features.extend(incentive_indicators)\n",
    "    other_vars = []\n",
    "    if std_type == 'cluster' and cluster not in features:\n",
    "        other_vars.append(cluster)\n",
    "    if only_adoption:\n",
    "        df_reg = merged3[merged3['d'].isnull() == False][features + [dependent] + other_vars]\n",
    "    else:\n",
    "        df_reg = merged3[features + [dependent] + other_vars]\n",
    "    if normalize_features:\n",
    "        for feature in features:\n",
    "            if feature != 'state_FIPS':\n",
    "                df_reg[feature] = (df_reg[feature] - df_reg[feature].mean()) / df_reg[feature].std()\n",
    "    if 'interaction_features' in config:\n",
    "        features.extend(config['interaction_features'])\n",
    "    fmla = make_str(dependent, features)\n",
    "    if std_type == 'cluster':\n",
    "        df_reg = df_reg.dropna()\n",
    "        %R -i fmla\n",
    "        %R -i df_reg\n",
    "        %R -i cluster\n",
    "        %R -i std_type\n",
    "        %R library(lmtest)\n",
    "        %R library(sandwich)\n",
    "\n",
    "        %R model <- glm(fmla, family = binomial(link = \"logit\"), data = df_reg) \n",
    "        %R coeftest_results <- coeftest(model, vcov. = vcovCL(model, cluster = df_reg[[cluster]], type = \"HC0\"))\n",
    "        %R coeftest_results_df <- as.data.frame.matrix(coeftest_results)\n",
    "        %R write.csv(coeftest_results_df, 'results/tmp_regression_results.csv')\n",
    "    else:\n",
    "        %R -i fmla\n",
    "        %R -i df_reg\n",
    "        %R -i cluster\n",
    "        %R -i std_type\n",
    "        %R library(lmtest)\n",
    "        %R library(sandwich)\n",
    "\n",
    "        %R model <- glm(fmla, family = binomial(link = \"logit\"), data = df_reg) \n",
    "        %R coeftest_results <- coeftest(model, vcov = vcovHC, type = std_type)\n",
    "        %R coeftest_results_df <- as.data.frame.matrix(coeftest_results)\n",
    "        %R write.csv(coeftest_results_df, 'results/tmp_regression_results.csv')\n",
    "    \n",
    "    classification_results = pd.read_csv('results/tmp_regression_results.csv')\n",
    "    classification_results.index = classification_results['Unnamed: 0']\n",
    "    del classification_results['Unnamed: 0']\n",
    "    classification_results.columns = ['coef', 'std err', 'z', 'P>|z|']\n",
    "    classification_results = classification_results.loc[[x for x in classification_results.index if 'state' not in x], :]\n",
    "    l = []\n",
    "    for x in classification_results.index:\n",
    "        pval = classification_results.loc[x, 'P>|z|']\n",
    "        if pval < 0.001:\n",
    "            star = '***'\n",
    "        elif pval < 0.01:\n",
    "            star = '**'\n",
    "        elif pval < 0.05:\n",
    "            star = '*'\n",
    "        else:\n",
    "            star = ''\n",
    "        l.append(star)\n",
    "    classification_results['significance'] = l\n",
    "    reg_results_adoption_indicator[config_name] = classification_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x324 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "res = reg_results_delta_onset['subsidized_delta_normalized']\n",
    "order_by_coefs = True\n",
    "coef_list1 = []\n",
    "CI_list1 = []\n",
    "varname_list1 = []\n",
    "for varname in res.index:\n",
    "    if 'Intercept' in varname:\n",
    "        continue\n",
    "    coef = res.loc[varname, 'coef']\n",
    "    std = res.loc[varname, 'std err']\n",
    "    varname_list1.append(varname)\n",
    "    coef_list1.append(coef)\n",
    "    CI_list1.append(std * 1.96) # 1.96 for 95% CI, 2.58 for 99% CI\n",
    "\n",
    "if order_by_coefs:\n",
    "    coef_list1, CI_list1, varname_list1 = order_variables_by_coefs(coef_list1, CI_list1, varname_list1)\n",
    "\n",
    "max_val1 = max([x+y for x, y in zip(coef_list1, CI_list1)])\n",
    "min_val1 = min([x-y for x, y in zip(coef_list1, CI_list1)])\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(8, 4.5))\n",
    "max_abs_val = max(abs(max_val1), abs(min_val1))\n",
    "ax.errorbar(np.arange(len(coef_list1)), coef_list1, yerr=CI_list1, \n",
    "                                 linestyle='None', color='red', marker='.', markersize=13,\n",
    "                                 elinewidth=3, ecolor='blue', capsize=6, capthick=3)\n",
    "\n",
    "ax.set_ylim(-1.1*max_abs_val, 1.1*max_abs_val)\n",
    "ax.set_xlim(-0.2, len(coef_list1) - 1 + 0.2)\n",
    "ax.plot([-0.2, len(coef_list1) - 1 + 0.2], [0, 0], linestyle='--', color='black')\n",
    "ax.set_xticks(range(len(coef_list1)))\n",
    "ax.set_xticklabels([name_dict[x] for x in varname_list1], rotation=75)\n",
    "ax.tick_params(axis='both', which='major', labelsize=17)\n",
    "ax.set_ylabel('Standardized coefficient', fontsize=20)\n",
    "# ax.legend(fontsize=12, loc=0)\n",
    "ax.grid(axis='y', linestyle='--', alpha=0.7)\n",
    "# ax.set_title('Dependent: relative savings with rebate/grant\\nof PV in 2016', fontsize=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "varname_order = [\n",
    "#     'rate_LCOE_diff_calculated_avg',\n",
    "#     'rate_LCOE_diff_calculated_2016',\n",
    "    'rate_LCOE_diff_subsidized_calculated_avg',\n",
    "    'rate_LCOE_diff_subsidized_calculated_2016',\n",
    "    \n",
    "    \n",
    "    'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "    'ACS_edu_score_2016_residual',\n",
    "    'ACS_housing_unit_density_2016',\n",
    "    'ACS_age_median_2016',\n",
    "    'ACS_diversity_NH_2016',\n",
    "    'ACS_occupancy_occupied_rate_2016',\n",
    "    'ACS_median_household_income_2016',\n",
    "]\n",
    "\n",
    "varname2position = {varname_order[i]: i for i in range(len(varname_order))}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x576 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(1, 4, figsize=(15, 8))\n",
    "# config_name = 'unsubsidized_delta_normalized'\n",
    "results_to_plot = [\n",
    "    reg_results_adoption_indicator['subsidized_delta_normalized_indicator'],\n",
    "    reg_results_d['subsidized_delta_normalized_indicator'],\n",
    "    reg_results_delta_2016['subsidized_delta_normalized'],\n",
    "    reg_results_saturation_level['subsidized_delta_normalized_indicator'],\n",
    "]\n",
    "title_list = [\n",
    "    r\"$\\bf{A.}$\" + 'PV adoption by\\n2016 ' + r\"($\\bf{I}$\" + r\"$[S(2016) > 0])$\",\n",
    "    r\"$\\bf{B.}$\" + 'Time of PV adoption\\nonset (d)',\n",
    "#     r\"$\\bf{C.}$\" + 'PV benefit with\\nrebate/grant in 2016',\n",
    "    r\"$\\bf{C.}$\" + 'PV benefit\\nin 2016',\n",
    "    r\"$\\bf{D.}$\" + 'Saturated adoption\\nlevel (m/M)'\n",
    "]\n",
    "emphasized_vars = ['ACS_edu_score_2016_residual', \n",
    "                   'rate_LCOE_diff_subsidized_calculated_2016', 'rate_LCOE_diff_subsidized_calculated_avg',\n",
    "                   'ACS_median_household_income_2016', 'rate_LCOE_diff_calculated_avg', \n",
    "                  'rate_LCOE_diff_calculated_2016']\n",
    "for i, res in enumerate(results_to_plot):\n",
    "    coef_list1 = []\n",
    "    CI_list1 = []\n",
    "    varname_list1 = []\n",
    "    signifance_list1 = []\n",
    "    for varname in res.index:\n",
    "        if 'Intercept' in varname:\n",
    "            continue\n",
    "        if varname not in varname2position:\n",
    "            continue\n",
    "        coef = res.loc[varname, 'coef']\n",
    "        std = res.loc[varname, 'std err']\n",
    "        significance = res.loc[varname, 'significance']\n",
    "        varname_list1.append(varname)\n",
    "        coef_list1.append(coef)\n",
    "        CI_list1.append(std * 1.96) # 1.96 for 95% CI, 2.58 for 99% CI\n",
    "        signifance_list1.append(significance)\n",
    "    coef_list1, CI_list1, varname_list1, signifance_list1 = order_variables_by_varnames(\n",
    "        coef_list1, CI_list1, varname_list1, signifance_list1, varname_order=varname_order)\n",
    "    \n",
    "    \n",
    "    max_val1 = max([x+y for x, y in zip(coef_list1, CI_list1)])\n",
    "    min_val1 = min([x-y for x, y in zip(coef_list1, CI_list1)])\n",
    "    max_abs_val = max(abs(max_val1), abs(min_val1))\n",
    "    \n",
    "    # plot positive coefs and negative coefs in different colors\n",
    "    varname_list_pos, coef_list_pos, CI_list_pos, positions_pos = [], [], [], []\n",
    "    varname_list_neg, coef_list_neg, CI_list_neg, positions_neg = [], [], [], []\n",
    "    for x, y, z in zip(varname_list1, coef_list1, CI_list1):\n",
    "        if y > 0:\n",
    "            varname_list_pos.append(x)\n",
    "            coef_list_pos.append(y)\n",
    "            CI_list_pos.append(z) \n",
    "            positions_pos.append(varname2position[x])\n",
    "        else:\n",
    "            varname_list_neg.append(x)\n",
    "            coef_list_neg.append(y)\n",
    "            CI_list_neg.append(z)\n",
    "            positions_neg.append(varname2position[x])\n",
    "    \n",
    "    if varname_list_pos:\n",
    "        axes[i].errorbar(y=positions_pos, x=coef_list_pos, xerr=CI_list_pos, \n",
    "                                         linestyle='None', color='#0571b0', marker='.', markersize=11,\n",
    "                                         elinewidth=3, ecolor='#0571b0')\n",
    "    if varname_list_neg:\n",
    "        axes[i].errorbar(y=positions_neg, x=coef_list_neg, xerr=CI_list_neg, \n",
    "                                         linestyle='None', color='#ca0020', marker='.', markersize=11,\n",
    "                                         elinewidth=3, ecolor='#ca0020')\n",
    "\n",
    "    axes[i].set_xlim(-1.55*max_abs_val, 1.55*max_abs_val)\n",
    "    axes[i].set_ylim(-0.2, len(varname_order) - 1 + 0.5)\n",
    "    axes[i].plot([0, 0], [-0.2, len(varname_order) - 1 + 0.5], linestyle='--', color='black', alpha=0.5)\n",
    "    axes[i].tick_params(axis='x', which='major', labelsize=15, rotation=0)\n",
    "    axes[i].set_yticks([])\n",
    "    axes[i].set_title(title_list[i], fontsize=17)\n",
    "#     axes[i].grid(axis='both', linestyle='--', alpha=0.7)\n",
    "\n",
    "    # annotate text (coef + significance mark)\n",
    "    for varname, c, mark in zip(varname_list1, coef_list1, signifance_list1):\n",
    "        pos = varname2position[varname]\n",
    "        color = '#0571b0' if c > 0 else '#ca0020'\n",
    "        txt = str(round(c, 3))\n",
    "        if len(txt.replace('-', '')) == 4:\n",
    "            txt = txt + '0' # this is to append \"0\" at the end in case python round it up\n",
    "        txt += ' ' + mark\n",
    "        axes[i].text(c, pos+0.1, txt, fontsize=14, color=color, horizontalalignment='center')\n",
    "\n",
    "axes[0].set_yticks(np.arange(len(varname_order)))\n",
    "axes[0].set_yticklabels([name_dict[x] for x in varname_order])\n",
    "\n",
    "axes[0].tick_params(axis='y', which='major', labelsize=15)\n",
    "\n",
    "for j, x in enumerate(varname_order):\n",
    "    if x not in emphasized_vars:\n",
    "#         axes[0].get_yticklabels()[j].set_fontweight(\"bold\")\n",
    "        axes[0].get_yticklabels()[j].set_color(\"grey\")\n",
    "fig.text(0.55, 0.01, 'Standardized coefficient', ha='center', fontsize=17)\n",
    "plt.tight_layout(pad=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. By income level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "color_dict = {\n",
    "    'low_income_group': '#e66101',\n",
    "    'midlow_income_group': '#fdb863',\n",
    "    'midhigh_income_group': '#b2abd2',\n",
    "    'high_income_group': '#5e3c99'\n",
    "}\n",
    "legend_dict = {\n",
    "    'low_income_group': 'Low income',\n",
    "    'midlow_income_group': 'Mid-low income',\n",
    "    'midhigh_income_group': 'Mid-high income',\n",
    "    'high_income_group': 'High income'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "std_type = 'HC1'\n",
    "se_cluster = 'county_FIPS'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reg_results_saturation_level_by_income = {}\n",
    "for group in ['low_income_group', 'midlow_income_group', 'midhigh_income_group', 'high_income_group']:\n",
    "    reg_results = run_OLS_regression(merged3[merged3[group] == 1], configs_saturation_level, \n",
    "                                           std_type=std_type, fixed_effect='state_FIPS', cluster=se_cluster, \n",
    "                                           income_normalized_benefit=False, only_adoption=True)\n",
    "    reg_results_saturation_level_by_income[group] = reg_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reg_results_d_by_income = {}\n",
    "for group in ['low_income_group', 'midlow_income_group', 'midhigh_income_group', 'high_income_group']:\n",
    "    reg_results = run_OLS_regression(merged3[merged3[group] == 1], configs_d, \n",
    "                                           std_type=std_type, fixed_effect='state_FIPS', cluster=se_cluster, \n",
    "                                           income_normalized_benefit=False, only_adoption=True)\n",
    "    reg_results_d_by_income[group] = reg_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reg_results_delta_onset_by_income = {}\n",
    "for group in ['low_income_group', 'midlow_income_group', 'midhigh_income_group', 'high_income_group']:\n",
    "    reg_results = run_OLS_regression(merged3[merged3[group] == 1], configs_delta_onset, \n",
    "                                           std_type=std_type, fixed_effect='state_FIPS', cluster=se_cluster, \n",
    "                                           income_normalized_benefit=False, only_adoption=True)\n",
    "    reg_results_delta_onset_by_income[group] = reg_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reg_results_delta_2016_by_income = {}\n",
    "for group in ['low_income_group', 'midlow_income_group', 'midhigh_income_group', 'high_income_group']:\n",
    "    reg_results = run_OLS_regression(merged3[merged3[group] == 1], configs_delta_2016, \n",
    "                                           std_type=std_type, fixed_effect='state_FIPS', cluster=se_cluster, \n",
    "                                           income_normalized_benefit=False, only_adoption=True)\n",
    "    reg_results_delta_2016_by_income[group] = reg_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fixed_effect = 'state_FIPS'\n",
    "cluster = se_cluster\n",
    "income_normalized_benefit=False\n",
    "only_adoption=False\n",
    "\n",
    "reg_results_adoption_indicator_by_income = {}\n",
    "for group in ['low_income_group', 'midlow_income_group', 'midhigh_income_group', 'high_income_group']:\n",
    "    print(group)\n",
    "    reg_results = {}\n",
    "    df_income_group = merged3[merged3[group] == 1]\n",
    "    for config_name in configs_adoption_indicator:\n",
    "        config = configs_adoption_indicator[config_name]\n",
    "        dependent = config['dependent']\n",
    "        features = config['features'].copy()\n",
    "        if income_normalized_benefit:\n",
    "            if dependent in income_normalized_benefit_mapping:\n",
    "                dependent = income_normalized_benefit_mapping[dependent]\n",
    "            features_new = []\n",
    "            for x in features:\n",
    "                if x in income_normalized_benefit_mapping:\n",
    "                    features_new.append(income_normalized_benefit_mapping[x])\n",
    "                else:\n",
    "                    features_new.append(x)\n",
    "            features = features_new.copy()\n",
    "        if fixed_effect and fixed_effect not in features:\n",
    "            features.append(fixed_effect)\n",
    "        incentive_indicators = config['incentive_indicators']\n",
    "        normalize_features = config['normalize_features']\n",
    "        if incentive_indicators:\n",
    "            features.extend(incentive_indicators)\n",
    "        other_vars = []\n",
    "        if std_type == 'cluster' and cluster not in features:\n",
    "            other_vars.append(cluster)\n",
    "        if only_adoption:\n",
    "            df_reg = df_income_group[df_income_group['d'].isnull() == False][features + [dependent] + other_vars]\n",
    "        else:\n",
    "            df_reg = df_income_group[features + [dependent] + other_vars]\n",
    "        if normalize_features:\n",
    "            for feature in features:\n",
    "                if feature != 'state_FIPS':\n",
    "                    df_reg[feature] = (df_reg[feature] - df_reg[feature].mean()) / df_reg[feature].std()\n",
    "        if 'interaction_features' in config:\n",
    "            features.extend(config['interaction_features'])\n",
    "        fmla = make_str(dependent, features)\n",
    "        if std_type == 'cluster':\n",
    "            df_reg = df_reg.dropna()\n",
    "            %R -i fmla\n",
    "            %R -i df_reg\n",
    "            %R -i cluster\n",
    "            %R -i std_type\n",
    "            %R library(lmtest)\n",
    "            %R library(sandwich)\n",
    "\n",
    "            %R model <- glm(fmla, family = binomial(link = \"logit\"), data = df_reg) \n",
    "            %R coeftest_results <- coeftest(model, vcov. = vcovCL(model, cluster = df_reg[[cluster]], type = \"HC0\"))\n",
    "            %R coeftest_results_df <- as.data.frame.matrix(coeftest_results)\n",
    "            %R write.csv(coeftest_results_df, 'results/tmp_regression_results.csv')\n",
    "        else:\n",
    "            %R -i fmla\n",
    "            %R -i df_reg\n",
    "            %R -i cluster\n",
    "            %R -i std_type\n",
    "            %R library(lmtest)\n",
    "            %R library(sandwich)\n",
    "\n",
    "            %R model <- glm(fmla, family = binomial(link = \"logit\"), data = df_reg) \n",
    "            %R coeftest_results <- coeftest(model, vcov = vcovHC, type = std_type)\n",
    "            %R coeftest_results_df <- as.data.frame.matrix(coeftest_results)\n",
    "            %R write.csv(coeftest_results_df, 'results/tmp_regression_results.csv')\n",
    "\n",
    "        classification_results = pd.read_csv('results/tmp_regression_results.csv')\n",
    "        classification_results.index = classification_results['Unnamed: 0']\n",
    "        del classification_results['Unnamed: 0']\n",
    "        classification_results.columns = ['coef', 'std err', 'z', 'P>|z|']\n",
    "        classification_results = classification_results.loc[[x for x in classification_results.index if 'state' not in x], :]\n",
    "        l = []\n",
    "        for x in classification_results.index:\n",
    "            pval = classification_results.loc[x, 'P>|z|']\n",
    "            if pval < 0.001:\n",
    "                star = '***'\n",
    "            elif pval < 0.01:\n",
    "                star = '**'\n",
    "            elif pval < 0.05:\n",
    "                star = '*'\n",
    "            else:\n",
    "                star = ''\n",
    "            l.append(star)\n",
    "        classification_results['significance'] = l\n",
    "        reg_results[config_name] = classification_results\n",
    "    reg_results_adoption_indicator_by_income[group] = reg_results\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "config_name = 'subsidized_delta_normalized_indicator'\n",
    "res_results_to_plot = reg_results_d_by_income.copy()\n",
    "max_abs_val = 0\n",
    "fig, ax = plt.subplots(figsize=(8, 5))\n",
    "avg_coef_dict = {}\n",
    "for i, group in enumerate(['low_income_group', 'midlow_income_group', 'midhigh_income_group', 'high_income_group']):\n",
    "    res = res_results_to_plot[group][config_name]\n",
    "    for varname in res.index:\n",
    "        if 'Intercept' in varname or 'incentive' in varname:\n",
    "            continue\n",
    "        coef = res.loc[varname, 'coef']\n",
    "        std = res.loc[varname, 'std err']\n",
    "        if not varname in avg_coef_dict:\n",
    "            avg_coef_dict[varname] = [coef, std * 1.96, 1]\n",
    "        else:\n",
    "            avg_coef_dict[varname][0] += coef\n",
    "            avg_coef_dict[varname][1] += std * 1.96\n",
    "            avg_coef_dict[varname][2] += 1\n",
    "\n",
    "for varname in avg_coef_dict:\n",
    "    avg_coef_dict[varname][0] = avg_coef_dict[varname][0] / avg_coef_dict[varname][2]\n",
    "    avg_coef_dict[varname][1] = avg_coef_dict[varname][1] / avg_coef_dict[varname][2]\n",
    "varname_order_list = sorted(list(avg_coef_dict), key=lambda x: avg_coef_dict[x][0], reverse=True)\n",
    "\n",
    "for i, group in enumerate(['low_income_group', 'midlow_income_group', 'midhigh_income_group', 'high_income_group']):\n",
    "    res = res_results_to_plot[group][config_name]\n",
    "    coef_list1 = []\n",
    "    CI_list1 = []\n",
    "    varname_list1 = []\n",
    "    for varname in res.index:\n",
    "        if 'Intercept' in varname or 'incentive' in varname:\n",
    "            continue\n",
    "        coef = res.loc[varname, 'coef']\n",
    "        std = res.loc[varname, 'std err']\n",
    "        varname_list1.append(varname)\n",
    "        coef_list1.append(coef)\n",
    "        CI_list1.append(std * 1.96) # 1.96 for 95% CI, 2.58 for 99% CI\n",
    "    coef_list1, CI_list1, varname_list1 = order_variables_by_varnames(coef_list1, CI_list1, varname_list1, \n",
    "                                                                      varname_order=varname_order_list)\n",
    "    max_val1 = max([x+y for x, y in zip(coef_list1, CI_list1)])\n",
    "    min_val1 = min([x-y for x, y in zip(coef_list1, CI_list1)])\n",
    "    max_abs_val = max(max_abs_val, abs(max_val1), abs(min_val1))\n",
    "    ax.errorbar(np.arange(len(coef_list1)) + i * 0.1 - 0.15, coef_list1, yerr=CI_list1, \n",
    "                                     linestyle='None', color='red', marker='.', markersize=9,\n",
    "                                     elinewidth=2, ecolor=color_dict[group], capsize=2, capthick=2,\n",
    "                                     label=legend_dict[group])\n",
    "\n",
    "ax.set_ylim(-1.1*max_abs_val, 1.1*max_abs_val)\n",
    "ax.set_xlim(-0.2, len(coef_list1) - 1 + 0.2)\n",
    "ax.plot([-0.2, len(coef_list1) - 1 + 0.2], [0, 0], linestyle='--', color='black')\n",
    "ax.set_xticks(range(len(coef_list1)))\n",
    "ax.set_xticklabels([name_dict[x] for x in varname_list1], rotation=65)\n",
    "ax.tick_params(axis='both', which='major', labelsize=14)\n",
    "ax.set_ylabel('Standardized coefficient', fontsize=18)\n",
    "ax.legend(fontsize=13, loc=0)\n",
    "ax.grid(axis='y', linestyle='--', alpha=0.7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "selected_incentive_types = [\n",
    "    'incentive_pace_financing',\n",
    "    'incentive_performance_based_incentive',\n",
    "    'incentive_rebate_program',\n",
    "    'incentive_grant_program',\n",
    "    'incentive_loan_program',\n",
    "    'incentive_property_tax_incentive',\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "config_name = 'unsubsidized_delta_indicator'\n",
    "res_results_to_plot = reg_results_saturation_level_by_income.copy()\n",
    "max_abs_val = 0\n",
    "fig, ax = plt.subplots(figsize=(4, 8))\n",
    "avg_coef_dict = {}\n",
    "for i, group in enumerate(['low_income_group', 'midlow_income_group', 'midhigh_income_group', 'high_income_group']):\n",
    "    res = res_results_to_plot[group][config_name]\n",
    "    for varname in res.index:\n",
    "        if 'incentive' not in varname or varname not in selected_incentive_types:\n",
    "            continue\n",
    "        coef = res.loc[varname, 'coef']\n",
    "        std = res.loc[varname, 'std err']\n",
    "        if not varname in avg_coef_dict:\n",
    "            avg_coef_dict[varname] = [coef, std * 1.96, 1]\n",
    "        else:\n",
    "            avg_coef_dict[varname][0] += coef\n",
    "            avg_coef_dict[varname][1] += std * 1.96\n",
    "            avg_coef_dict[varname][2] += 1\n",
    "\n",
    "for varname in avg_coef_dict:\n",
    "    avg_coef_dict[varname][0] = avg_coef_dict[varname][0] / avg_coef_dict[varname][2]\n",
    "    avg_coef_dict[varname][1] = avg_coef_dict[varname][1] / avg_coef_dict[varname][2]\n",
    "varname_order_list = sorted(list(avg_coef_dict), key=lambda x: avg_coef_dict[x][0], reverse=False)\n",
    "\n",
    "for i, group in enumerate(['low_income_group', 'midlow_income_group', 'midhigh_income_group', 'high_income_group']):\n",
    "    res = res_results_to_plot[group][config_name]\n",
    "    coef_list1 = []\n",
    "    CI_list1 = []\n",
    "    varname_list1 = []\n",
    "    signifance_list1 = []\n",
    "    for varname in configs_saturation_level[config_name]['incentive_indicators']:\n",
    "        if 'incentive' not in varname or varname not in selected_incentive_types:\n",
    "            continue\n",
    "        if varname in res.index:\n",
    "            coef = res.loc[varname, 'coef']\n",
    "            std = res.loc[varname, 'std err']\n",
    "            significance = res.loc[varname, 'significance']\n",
    "        else:\n",
    "            coef = np.nan\n",
    "            std = np.nan\n",
    "        varname_list1.append(varname)\n",
    "        coef_list1.append(coef)\n",
    "        CI_list1.append(std * 1.96) # 1.96 for 95% CI, 2.58 for 99% CI\n",
    "        signifance_list1.append(significance)\n",
    "        coef_list1, CI_list1, varname_list1 = order_variables_by_varnames(coef_list1, CI_list1, varname_list1, \n",
    "                                                                      varname_order=varname_order_list)\n",
    "\n",
    "    max_val1 = max([x+y for x, y in zip(coef_list1, CI_list1) if np.isnan(x) == False])\n",
    "    min_val1 = min([x-y for x, y in zip(coef_list1, CI_list1) if np.isnan(x) == False])\n",
    "    max_abs_val = max(max_abs_val, abs(max_val1), abs(min_val1))\n",
    "    ax.errorbar(y=np.arange(len(coef_list1)) - i * 0.1 + 0.15, x=coef_list1, xerr=CI_list1, \n",
    "                                     linestyle='None', color=color_dict[group], marker='.', markersize=9,\n",
    "                                     elinewidth=2, ecolor=color_dict[group], capsize=2, capthick=2, \n",
    "                                     label=legend_dict[group])\n",
    "    \n",
    "ax.yaxis.tick_right()\n",
    "ax.set_xlim(-1.1*max_abs_val, 1.1*max_abs_val)\n",
    "ax.set_ylim(-1.6, len(coef_list1) - 1 + 0.3)\n",
    "ax.plot([0, 0], [-0.3, len(coef_list1) - 1 + 0.3], linestyle='--', color='black', alpha=0.5)\n",
    "ax.set_yticks(range(len(coef_list1)))\n",
    "ax.set_yticklabels([name_dict[x] for x in varname_list1], rotation=0)\n",
    "ax.tick_params(axis='both', which='major', labelsize=15)\n",
    "ax.set_xlabel('Coefficient', fontsize=18)\n",
    "ax.legend(fontsize=13, loc=3)\n",
    "plt.tight_layout()\n",
    "# ax.grid(axis='x', linestyle='--', alpha=0.7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Run adoption indicator vs incentive indicators for each year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "configs_adoption_indicator_by_year = {\n",
    "    'unsubsidized_delta_indicator': {\n",
    "        'dependent': 'installation_indicator_year',\n",
    "        'features': [\n",
    "            'ACS_median_household_income_2016',\n",
    "            'ACS_housing_unit_density_2016',\n",
    "            'ACS_diversity_NH_2016',\n",
    "            'ACS_age_median_2016',\n",
    "            'ACS_occupancy_occupied_rate_2016',\n",
    "            'ACS_edu_score_2016_residual',\n",
    "            'ACS_occupancy_occupied_renter_rate_2016_residual',\n",
    "        ],\n",
    "        'economic_features': [\n",
    "            'rate_LCOE_diff_calculated',\n",
    "        ],\n",
    "        'incentive_indicators': all_incentive_types,\n",
    "        'normalize_features': False,\n",
    "    },\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "std_type = 'HC1'\n",
    "cluster = 'county_FIPS'\n",
    "col_as_anchor_year = 'predicted_1st_adoption_time_rounded'\n",
    "config_name = 'unsubsidized_delta_indicator'\n",
    "reg_results_adoption_indicator_by_year = {}\n",
    "adoption_indicator_stats_dict = {}\n",
    "df_reg_dict = {}\n",
    "config = configs_adoption_indicator_by_year[config_name]\n",
    "dependent = config['dependent']\n",
    "features = config['features'].copy()\n",
    "incentive_indicators = config['incentive_indicators']\n",
    "normalize_features = config['normalize_features']\n",
    "economic_features = config['economic_features']\n",
    "features_all = features + incentive_indicators + economic_features\n",
    "\n",
    "for year in range(2006, 2017):\n",
    "    # exclude all block groups that started adoption before \"year\"\n",
    "    merged_sub = merged3[(merged3[col_as_anchor_year] >= year) | merged3[col_as_anchor_year].isnull()]\n",
    "    merged_sub['installation_indicator_year'] = merged_sub[col_as_anchor_year] == year\n",
    "    adoption_indicator_stats_dict[year] = [len(merged_sub), np.sum(merged_sub['installation_indicator_year'] == 1)]\n",
    "    \n",
    "    if 'state_FIPS' not in features:\n",
    "        df_reg = merged_sub[features + [dependent] + ['blockgroup_FIPS', 'state_FIPS']]\n",
    "    else:\n",
    "        df_reg = merged_sub[features + [dependent] + ['blockgroup_FIPS']]\n",
    "    df_reg['county_FIPS'] = df_reg['blockgroup_FIPS'] // 10000000\n",
    "    df_reg['county_FIPS'] = df_reg['county_FIPS'].astype(str)\n",
    "    \n",
    "    # incorporate year-specific incentive type indicators\n",
    "    incentive_type_indicator_bg_sub = incentive_type_indicator_bg[incentive_type_indicator_bg['year'] == year]\n",
    "    df_reg = pd.merge(df_reg, incentive_type_indicator_bg_sub, on='blockgroup_FIPS', how='left')\n",
    "    df_reg = pd.merge(df_reg, \n",
    "            cost_benefit_df[cost_benefit_df['year'] == year][['blockgroup_FIPS'] + economic_features],\n",
    "            on='blockgroup_FIPS', how='left')\n",
    "    if 'state_FIPS' not in features_all:\n",
    "        df_reg = df_reg[features_all + [dependent, 'blockgroup_FIPS', 'county_FIPS', 'state_FIPS']]\n",
    "    else:\n",
    "        df_reg = df_reg[features_all + [dependent, 'blockgroup_FIPS', 'county_FIPS']]\n",
    "    df_reg['blockgroup_FIPS'] = df_reg['blockgroup_FIPS'].astype(str)\n",
    "    df_reg_dict[year] = df_reg ##\n",
    "    if normalize_features:\n",
    "        for feature in features_all:\n",
    "            if feature != 'state_FIPS':\n",
    "                df_reg[feature] = (df_reg[feature] - df_reg[feature].mean()) / df_reg[feature].std()\n",
    "    if 'interaction_features' in config:\n",
    "        features_all.extend(config['interaction_features'])\n",
    "    fmla = make_str(dependent, features_all)\n",
    "    if std_type == 'cluster':\n",
    "        df_reg = df_reg.dropna()\n",
    "        %R -i fmla\n",
    "        %R -i df_reg\n",
    "        %R -i cluster\n",
    "        %R library(lmtest)\n",
    "        %R library(sandwich)\n",
    "        %R model <- glm(fmla, family = binomial(link = \"logit\"), data = df_reg) \n",
    "        %R coeftest_results <- coeftest(model, vcov. = vcovCL(model, cluster = df_reg[[cluster]], type = \"HC0\"))\n",
    "        %R coeftest_results_df <- as.data.frame.matrix(coeftest_results)\n",
    "        %R write.csv(coeftest_results_df, 'results/tmp_regression_results.csv')\n",
    "    else:\n",
    "        %R -i fmla\n",
    "        %R -i df_reg\n",
    "        %R -i cluster\n",
    "        %R -i std_type\n",
    "        %R library(lmtest)\n",
    "        %R library(sandwich)\n",
    "        %R model <- glm(fmla, family = binomial(link = \"logit\"), data = df_reg) \n",
    "        %R coeftest_results <- coeftest(model, vcov = vcovHC, type = std_type)\n",
    "        %R coeftest_results_df <- as.data.frame.matrix(coeftest_results)\n",
    "        %R write.csv(coeftest_results_df, 'results/tmp_regression_results.csv')\n",
    "    classification_results = pd.read_csv('results/tmp_regression_results.csv')\n",
    "    classification_results.index = classification_results['Unnamed: 0']\n",
    "    del classification_results['Unnamed: 0']\n",
    "    classification_results.columns = ['coef', 'std err', 'z', 'P>|z|']\n",
    "    l = []\n",
    "    for x in classification_results.index:\n",
    "        pval = classification_results.loc[x, 'P>|z|']\n",
    "        if pval < 0.001:\n",
    "            star = '***'\n",
    "        elif pval < 0.01:\n",
    "            star = '**'\n",
    "        elif pval < 0.05:\n",
    "            star = '*'\n",
    "        else:\n",
    "            star = ''\n",
    "        l.append(star)\n",
    "    classification_results['significance'] = l\n",
    "    reg_results_adoption_indicator_by_year[year] = classification_results\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# no state FE, robust SE\n",
    "fig, axes = plt.subplots(2, 1, figsize=(8, 8), gridspec_kw={'height_ratios': [2, 1]})\n",
    "incentive_types = [\n",
    "    'incentive_pace_financing',\n",
    "    'incentive_performance_based_incentive',\n",
    "    'incentive_rebate_program',\n",
    "    'incentive_grant_program',\n",
    "    'incentive_loan_program',\n",
    "    'incentive_property_tax_incentive',\n",
    "]\n",
    "color_list = ['red', 'mediumblue', 'limegreen', 'deeppink', 'gray', 'gold', 'purple', 'black', 'cyan', \n",
    "              'magenta']\n",
    "marker_list = ['.', 'v', 'o', 's', 'x', 'D', '.', 'v', 'o', 's']\n",
    "for i, x in enumerate(incentive_types):\n",
    "    year_list = []\n",
    "    coef_list1 = []\n",
    "    upper_list = []\n",
    "    bottom_list = []\n",
    "    color = color_list[i]\n",
    "    for year in range(2009, 2017):\n",
    "        res = reg_results_adoption_indicator_by_year[year]\n",
    "        if x not in res.index:\n",
    "            continue\n",
    "        coef = res.loc[x, 'coef']\n",
    "        std = res.loc[x, 'std err']\n",
    "        year_list.append(year)\n",
    "        coef_list1.append(coef)\n",
    "        upper_list.append(coef + std * 1.96) # 1.96 for 95% CI, 2.58 for 99% CI\n",
    "        bottom_list.append(coef - std * 1.96) # 1.96 for 95% CI, 2.58 for 99% CI\n",
    "    axes[0].plot(year_list, coef_list1, color=color, label=name_dict[x], marker=marker_list[i], markersize=5)\n",
    "    axes[0].fill_between(year_list, upper_list, bottom_list, color=color, alpha=0.1)\n",
    "axes[0].plot([2008.5, 2016.5], [0, 0], color='black', ls='--', alpha=0.4)\n",
    "axes[0].set_xlim(2008.5, 2016.5)\n",
    "axes[0].set_ylim(-5, 8)\n",
    "# axes[0].set_ylim(-3, 3)\n",
    "\n",
    "axes[1].set_xlabel('Year', fontsize=17)\n",
    "axes[0].set_xticks(year_list)\n",
    "# axes[0].set_xticklabels([''] * 6)\n",
    "axes[0].set_ylabel('Coefficient', fontsize=17)\n",
    "axes[0].tick_params(axis='both', which='major', labelsize=15)\n",
    "\n",
    "frac1_list, frac2_list, frac3_list = [], [], []\n",
    "for year in year_list:\n",
    "    base, npos = adoption_indicator_stats_dict[year]\n",
    "    frac1 = (len(merged3) - base) / len(merged3) # # fraction of BGs that started adoption before year t\n",
    "    frac2 = npos / len(merged3) # fraction of BGs that started adoption in year t\n",
    "    frac3 = (base - npos) / len(merged3) # fraction of BGs that started adoption after year t\n",
    "    frac1_list.append(frac1)\n",
    "    frac2_list.append(frac2)\n",
    "    frac3_list.append(frac3)\n",
    "axes[1].bar(year_list, frac1_list, width=0.9, color='white', linestyle='--', hatch=None, edgecolor='black')\n",
    "axes[1].bar(year_list, frac2_list, bottom=np.array(frac1_list), width=0.9, color='darkgrey', \n",
    "            linestyle='-', hatch=None, edgecolor='black')\n",
    "axes[1].bar(year_list, frac3_list, bottom=np.array(frac1_list)+np.array(frac2_list), width=0.9, color='lightgrey',\n",
    "           linestyle='-', hatch=None, edgecolor='black')\n",
    "axes[1].set_ylim(-0.01, 1)\n",
    "axes[1].set_xticks([])\n",
    "\n",
    "axes[1].set_xlim(2008.5, 2016.5)\n",
    "axes[1].set_axis_off()\n",
    "axes[1].set_yticks([0, 1])\n",
    "axes[1].set_yticklabels([0, 1])\n",
    "fig.text(0.13, 0.08, '0', fontsize=15, ha='center')\n",
    "fig.text(0.13, 0.34, '1', fontsize=15, ha='center')\n",
    "fig.text(0.1, 0.25, 'Fraction of\\nblock groups', fontsize=17, ha='center', rotation='vertical')\n",
    "fig.text(0.55, 0.02, 'Year', fontsize=17, ha='center')\n",
    "for i, year in enumerate(year_list):\n",
    "    fig.text(0.155 + 0.8 * i / len(year_list), 0.06, str(year), fontsize=15)\n",
    "\n",
    "axes[0].legend(fontsize=13, ncol=3, loc=4)\n",
    "plt.tight_layout(pad=3.0)\n",
    "# # plt.ylim()"
   ]
  },
  {
   "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
}