From 63cb24f150611e2965e30e922d86c18edd9643f1 Mon Sep 17 00:00:00 2001 From: dadams Date: Thu, 31 Oct 2024 21:05:27 -0700 Subject: [PATCH] initial look again with claude --- .../merge_cci_califequity_postgis.ipynb | 1666 ++++++++++++++--- 1 file changed, 1380 insertions(+), 286 deletions(-) diff --git a/initial_view/merge_cci_califequity_postgis.ipynb b/initial_view/merge_cci_califequity_postgis.ipynb index 21798fbb..a8115c1d 100644 --- a/initial_view/merge_cci_califequity_postgis.ipynb +++ b/initial_view/merge_cci_califequity_postgis.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 29, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -13,28 +13,28 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Requirement already satisfied: pandas in ./.venv/lib/python3.12/site-packages (2.2.3)\n", - "Requirement already satisfied: numpy in ./.venv/lib/python3.12/site-packages (2.1.1)\n", - "Requirement already satisfied: matplotlib in ./.venv/lib/python3.12/site-packages (3.9.2)\n", - "Requirement already satisfied: seaborn in ./.venv/lib/python3.12/site-packages (0.13.2)\n", - "Requirement already satisfied: python-dateutil>=2.8.2 in ./.venv/lib/python3.12/site-packages (from pandas) (2.9.0.post0)\n", - "Requirement already satisfied: pytz>=2020.1 in ./.venv/lib/python3.12/site-packages (from pandas) (2024.2)\n", - "Requirement already satisfied: tzdata>=2022.7 in ./.venv/lib/python3.12/site-packages (from pandas) (2024.2)\n", - "Requirement already satisfied: contourpy>=1.0.1 in ./.venv/lib/python3.12/site-packages (from matplotlib) (1.3.0)\n", - "Requirement already satisfied: cycler>=0.10 in ./.venv/lib/python3.12/site-packages (from matplotlib) (0.12.1)\n", - "Requirement already satisfied: fonttools>=4.22.0 in ./.venv/lib/python3.12/site-packages (from matplotlib) (4.54.1)\n", - "Requirement already satisfied: kiwisolver>=1.3.1 in ./.venv/lib/python3.12/site-packages (from matplotlib) (1.4.7)\n", - "Requirement already satisfied: packaging>=20.0 in ./.venv/lib/python3.12/site-packages (from matplotlib) (24.1)\n", - "Requirement already satisfied: pillow>=8 in ./.venv/lib/python3.12/site-packages (from matplotlib) (10.4.0)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in ./.venv/lib/python3.12/site-packages (from matplotlib) (3.1.4)\n", - "Requirement already satisfied: six>=1.5 in ./.venv/lib/python3.12/site-packages (from python-dateutil>=2.8.2->pandas) (1.16.0)\n", + "Requirement already satisfied: pandas in /home/dadams/Repos/california_equity_git/.venv/lib/python3.12/site-packages (2.2.3)\n", + "Requirement already satisfied: numpy in /home/dadams/Repos/california_equity_git/.venv/lib/python3.12/site-packages (2.1.2)\n", + "Requirement already satisfied: matplotlib in /home/dadams/Repos/california_equity_git/.venv/lib/python3.12/site-packages (3.9.2)\n", + "Requirement already satisfied: seaborn in /home/dadams/Repos/california_equity_git/.venv/lib/python3.12/site-packages (0.13.2)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /home/dadams/Repos/california_equity_git/.venv/lib/python3.12/site-packages (from pandas) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in /home/dadams/Repos/california_equity_git/.venv/lib/python3.12/site-packages (from pandas) (2024.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in /home/dadams/Repos/california_equity_git/.venv/lib/python3.12/site-packages (from pandas) (2024.2)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /home/dadams/Repos/california_equity_git/.venv/lib/python3.12/site-packages (from matplotlib) (1.3.0)\n", + "Requirement already satisfied: cycler>=0.10 in /home/dadams/Repos/california_equity_git/.venv/lib/python3.12/site-packages (from matplotlib) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /home/dadams/Repos/california_equity_git/.venv/lib/python3.12/site-packages (from matplotlib) (4.54.1)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /home/dadams/Repos/california_equity_git/.venv/lib/python3.12/site-packages (from matplotlib) (1.4.7)\n", + "Requirement already satisfied: packaging>=20.0 in /home/dadams/Repos/california_equity_git/.venv/lib/python3.12/site-packages (from matplotlib) (24.1)\n", + "Requirement already satisfied: pillow>=8 in /home/dadams/Repos/california_equity_git/.venv/lib/python3.12/site-packages (from matplotlib) (11.0.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /home/dadams/Repos/california_equity_git/.venv/lib/python3.12/site-packages (from matplotlib) (3.2.0)\n", + "Requirement already satisfied: six>=1.5 in /home/dadams/Repos/california_equity_git/.venv/lib/python3.12/site-packages (from python-dateutil>=2.8.2->pandas) (1.16.0)\n", "Note: you may need to restart the kernel to use updated packages.\n" ] } @@ -45,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -59,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -70,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -80,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -93,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -107,7 +107,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -456,7 +456,7 @@ "[8 rows x 82 columns]" ] }, - "execution_count": 36, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -468,7 +468,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -510,345 +510,1439 @@ "source": [ "import geopandas as gpd\n", "\n", - "# Read the shapefile\n", - "calenviroscreen = gpd.read_file(\"california_enviroscreen/calif_enviroscreen_shape/CES4 Final Shapefile.shp\")\n", + "# Load the shapefile\n", + "shapefile_path = '/home/dadams/Repos/california_equity_git/california_enviroscreen/calif_enviroscreen_shape/CES4 Final Shapefile.shp'\n", + "gdf = gpd.read_file(shapefile_path)\n", "\n", - "# Check the first few rows\n", - "print(calenviroscreen.head())\n" + "# Print the head of the GeoDataFrame\n", + "print(gdf.head())" ] }, { "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [], - "source": [ - "# Convert Census Tract columns to string and ensure they have the same format\n", - "data['Census Tract'] = data['Census Tract'].astype(str).str.zfill(11)\n", - "calenviroscreen['Tract'] = calenviroscreen['Tract'].astype(str).str.zfill(11)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [], - "source": [ - "# Merge the datasets\n", - "merged_data = calenviroscreen.merge(data, left_on='Tract', right_on='Census Tract', how='inner')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "# Or as a CSV if you're not saving spatial data\n", - "merged_data.drop(columns='geometry').to_csv('merged_california_climate_investment.csv', index=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [], - "source": [ - "import geopandas as gpd\n", - "# Ensure merged_data is a GeoDataFrame\n", - "if not isinstance(merged_data, gpd.GeoDataFrame):\n", - " merged_data = gpd.GeoDataFrame(merged_data)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 41, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "EPSG:3310\n" - ] - } - ], - "source": [ - "# Check CRS\n", - "print(merged_data.crs)\n", - "\n", - "# Set CRS if necessary\n", - "if merged_data.crs is None:\n", - " merged_data.set_crs(epsg=4326, inplace=True) # Or use the appropriate EPSG code\n" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "geometry\n" - ] - } - ], - "source": [ - "print(merged_data.geometry.name)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: geoalchemy2 in ./.venv/lib/python3.12/site-packages (0.15.2)\n", - "Requirement already satisfied: sqlalchemy in ./.venv/lib/python3.12/site-packages (2.0.35)\n", - "Requirement already satisfied: packaging in ./.venv/lib/python3.12/site-packages (from geoalchemy2) (24.1)\n", - "Requirement already satisfied: typing-extensions>=4.6.0 in ./.venv/lib/python3.12/site-packages (from sqlalchemy) (4.12.2)\n", - "Requirement already satisfied: greenlet!=0.4.17 in ./.venv/lib/python3.12/site-packages (from sqlalchemy) (3.1.1)\n", - "Note: you may need to restart the kernel to use updated packages.\n" - ] - } - ], - "source": [ - "%pip install geoalchemy2 sqlalchemy" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Tract ZIP County_x ApproxLoc TotPop19 CIscore \\\n", - "0 6083002103.0 93454 Santa Barbara Santa Maria 4495 36.019653 \n", - "1 6083002103.0 93454 Santa Barbara Santa Maria 4495 36.019653 \n", - "2 6083002103.0 93454 Santa Barbara Santa Maria 4495 36.019653 \n", - "3 6083002103.0 93454 Santa Barbara Santa Maria 4495 36.019653 \n", - "4 6083002103.0 93454 Santa Barbara Santa Maria 4495 36.019653 \n", + "Columns containing 'County':\n", + "['County']\n", "\n", - " CIscoreP Ozone OzoneP PM2_5 ... Net Density DUA \\\n", - "0 69.162885 0.03419 10.566273 7.567724 ... 0.0 \n", - "1 69.162885 0.03419 10.566273 7.567724 ... 0.0 \n", - "2 69.162885 0.03419 10.566273 7.567724 ... 0.0 \n", - "3 69.162885 0.03419 10.566273 7.567724 ... 0.0 \n", - "4 69.162885 0.03419 10.566273 7.567724 ... 0.0 \n", + "Program Types:\n", + "Program Name\n", + "Low Carbon Transportation 105965\n", + "Funding Agricultural Replacement Measures for Emission Reductions Program 8554\n", + "Low-Income Weatherization Program 6468\n", + "Community Air Protection 5514\n", + "Water-Energy Efficiency 5111\n", + "Climate Smart Agriculture 1688\n", + "Low Carbon Transit Operations Program 1003\n", + "Transformative Climate Communities 973\n", + "Urban and Community Forestry Program 967\n", + "Woodsmoke Reduction Program 959\n", + "Name: count, dtype: int64\n", "\n", - " Applicants Assisted Invasive Cover 12 Months Invasive Cover 36 Months \\\n", - "0 0 0 0 \n", - "1 0 0 0 \n", - "2 0 0 0 \n", - "3 0 0 0 \n", - "4 0 0 0 \n", + "Project Types:\n", + "Project Type\n", + "Voucher 2808\n", + "Voucher Incentive 1730\n", + "Air Filtration (Air Filtration) 1570\n", + "Water Use and Energy Efficiency 1217\n", + "Off-Road Equipment - Mobile Agricultural (Tractors) 891\n", + " ... \n", + "Procurement Requirement 1\n", + "Education and outreach and enforcement/inspections 1\n", + "Personnel, education and outreach, and procurement 1\n", + "Education & Outreach and Planning 1\n", + "Equipment, Education and Outreach 1\n", + "Name: count, Length: 1007, dtype: int64\n", "\n", - " Project Acreage IS IAE Intermediary Admin Expenses Calc \\\n", - "0 0 False 0 \n", - "1 0 False 0 \n", - "2 0 False 0 \n", - "3 0 False 0 \n", - "4 0 False 0 \n", - "\n", - " PRIMARY_FUNDING_RECIPIENT_TYPE TRIBAL AFFILIATION PROJECT PARTNERS \n", - "0 None None None \n", - "1 None None None \n", - "2 None None None \n", - "3 None None None \n", - "4 None None None \n", - "\n", - "[5 rows x 194 columns]\n", - "Spatial index created successfully.\n", - "Data uploaded and spatial index created successfully.\n" + "Funding Recipient Types:\n", + "PRIMARY_FUNDING_RECIPIENT_TYPE\n", + "Business 423\n", + "Government Agency 285\n", + "Nonprofit 113\n", + "Educational institution 21\n", + "California Native American Tribe 4\n", + "Government agency 2\n", + "Name: count, dtype: int64\n" ] } ], "source": [ - "import geopandas as gpd\n", - "from sqlalchemy import create_engine, text\n", + "# Let's look at the actual column names in the merged dataset\n", + "print(\"Columns containing 'County':\")\n", + "print([col for col in data.columns if 'County' in col])\n", "\n", - "# Step 1: Load your merged GeoDataFrame (assuming it already exists as 'merged_data')\n", - "# If it's not a GeoDataFrame, convert it to one\n", - "if not isinstance(merged_data, gpd.GeoDataFrame):\n", - " if 'geometry' not in merged_data.columns:\n", - " raise ValueError(\"The DataFrame must have a 'geometry' column to be converted into a GeoDataFrame.\")\n", - " merged_data = gpd.GeoDataFrame(merged_data, geometry='geometry')\n", + "# Then modify our analysis using the correct county column name:\n", + "geographic_analysis = data.groupby(['County', 'project_category']).agg({\n", + " 'Total Project Cost': 'sum',\n", + " 'Total Project GHGReductions': 'sum',\n", + " 'Total GGRFDisadvantaged Community Funding': 'sum'\n", + "}).reset_index()\n", "\n", - "# Step 2: Set CRS to EPSG:3110 (California Albers) if not already set\n", - "if merged_data.crs is None or merged_data.crs.to_string() != 'EPSG:3110':\n", - " merged_data = merged_data.set_crs(epsg=4326) # Set initial CRS if not defined\n", - " merged_data = merged_data.to_crs(epsg=3110)\n", - "\n", - "# Step 3: Confirm geometry column is named 'geometry'\n", - "geometry_col = 'geometry'\n", - "if geometry_col not in merged_data.columns:\n", - " raise ValueError(\"GeoDataFrame does not contain a geometry column named 'geometry'.\")\n", - "\n", - "# Step 4: Create a connection to your PostGIS database\n", - "engine = create_engine('postgresql://postgres:MandyLinkToby3@192.168.0.74:5432/calif_equity')\n", - "\n", - "# Step 5: Push the data to PostGIS, replacing the existing table if it exists\n", - "# The `to_postgis()` function automatically recognizes the geometry column\n", - "try:\n", - " merged_data.to_postgis('california_climate_investment', engine, if_exists='replace')\n", - "except Exception as e:\n", - " print(f\"Error uploading data to PostGIS: {e}\")\n", - "\n", - "# Step 6: Verify data upload by querying the table (select the first 5 rows)\n", - "try:\n", - " gdf = gpd.read_postgis(f\"SELECT * FROM california_climate_investment LIMIT 5\", engine, geom_col=geometry_col)\n", - " print(gdf.head())\n", - "except Exception as e:\n", - " print(f\"Error reading data from PostGIS: {e}\")\n", - "\n", - "# Step 7: Create a spatial index on the geometry column (using SQLAlchemy's text() function)\n", - "try:\n", - " with engine.connect() as conn:\n", - " conn.execute(text(f\"\"\"\n", - " CREATE INDEX IF NOT EXISTS california_climate_investment_geom_idx\n", - " ON california_climate_investment\n", - " USING GIST ({geometry_col});\n", - " \"\"\"))\n", - " print(\"Spatial index created successfully.\")\n", - "except Exception as e:\n", - " print(f\"Error creating spatial index: {e}\")\n", - "\n", - "print(\"Data uploaded and spatial index created successfully.\")\n" + "# Rest of the analysis:\n", + "# 1. First look at program distributions\n", + "print(\"\\nProgram Types:\")\n", + "print(data['Program Name'].value_counts().head(10))\n", + "print(\"\\nProject Types:\")\n", + "print(data['Project Type'].value_counts())\n", + "print(\"\\nFunding Recipient Types:\")\n", + "print(data['PRIMARY_FUNDING_RECIPIENT_TYPE'].value_counts())" ] }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "EPSG:3110\n", - "EPSG:3110\n" + "\n", + "Updated Project Category Distribution:\n", + "project_category\n", + "Transportation - Other 101427\n", + "Other 14340\n", + "Individual - Home Energy 7427\n", + "Air Quality Projects 5514\n", + "Water-Energy Projects 5111\n", + "Individual - Vehicle 4538\n", + "Agricultural Projects 1688\n", + "Community Projects 973\n", + "Institutional - Government 269\n", + "Institutional - Nonprofit 100\n", + "Institutional - Large Business 23\n", + "Institutional - Education 17\n", + "Business - Small 2\n", + "Name: count, dtype: int64\n", + "\n", + "Updated Analysis:\n", + " Total Project Cost \\\n", + " count sum mean \n", + "project_category \n", + "Agricultural Projects 1688 886514974 5.251866e+05 \n", + "Air Quality Projects 5514 1211608583 2.197331e+05 \n", + "Business - Small 2 65376 3.268800e+04 \n", + "Community Projects 973 508817727 5.229370e+05 \n", + "Individual - Home Energy 7427 320008647 4.308720e+04 \n", + "Individual - Vehicle 4538 1286418141 2.834769e+05 \n", + "Institutional - Education 17 5561672 3.271572e+05 \n", + "Institutional - Government 269 16939974420 6.297388e+07 \n", + "Institutional - Large Business 23 513921827 2.234443e+07 \n", + "Institutional - Nonprofit 100 1402247011 1.402247e+07 \n", + "Other 14340 104572013338 7.292330e+06 \n", + "Transportation - Other 101427 2473090031 2.438296e+04 \n", + "Water-Energy Projects 5111 85125916 1.665543e+04 \n", + "\n", + " Total Project GHGReductions \\\n", + " sum mean \n", + "project_category \n", + "Agricultural Projects 24249378 14365.7453 \n", + "Air Quality Projects 250801 45.4844 \n", + "Business - Small 0 0.0000 \n", + "Community Projects 154010 158.2837 \n", + "Individual - Home Energy 693914 93.4313 \n", + "Individual - Vehicle 993992 219.0375 \n", + "Institutional - Education 457 26.8824 \n", + "Institutional - Government 6580289 24462.0409 \n", + "Institutional - Large Business 388663 16898.3913 \n", + "Institutional - Nonprofit 4791834 47918.3400 \n", + "Other 67313019 4694.0738 \n", + "Transportation - Other 3312930 32.6632 \n", + "Water-Energy Projects 425225 83.1980 \n", + "\n", + " dac_funding_ratio ghg_per_dollar \\\n", + " mean median mean \n", + "project_category \n", + "Agricultural Projects 0.2388 0.0000 0.0106 \n", + "Air Quality Projects NaN NaN 0.0002 \n", + "Business - Small NaN NaN 0.0000 \n", + "Community Projects NaN NaN 0.0004 \n", + "Individual - Home Energy 0.6504 0.7405 0.0038 \n", + "Individual - Vehicle 0.1660 0.0245 0.0017 \n", + "Institutional - Education NaN NaN 0.0008 \n", + "Institutional - Government 0.0000 0.0000 0.0022 \n", + "Institutional - Large Business NaN NaN 0.0038 \n", + "Institutional - Nonprofit 0.0000 0.0000 0.0182 \n", + "Other 0.1483 0.0000 0.0023 \n", + "Transportation - Other 0.4190 0.0000 0.0027 \n", + "Water-Energy Projects 0.4359 0.0000 0.1027 \n", + "\n", + " \n", + " median \n", + "project_category \n", + "Agricultural Projects 0.0051 \n", + "Air Quality Projects 0.0000 \n", + "Business - Small 0.0000 \n", + "Community Projects 0.0000 \n", + "Individual - Home Energy 0.0026 \n", + "Individual - Vehicle 0.0010 \n", + "Institutional - Education 0.0000 \n", + "Institutional - Government 0.0001 \n", + "Institutional - Large Business 0.0005 \n", + "Institutional - Nonprofit 0.0004 \n", + "Other 0.0001 \n", + "Transportation - Other 0.0032 \n", + "Water-Energy Projects 0.0096 \n" ] } ], "source": [ - "print(merged_data.crs)\n", - "print(gdf.crs)\n" + "# 1. Fix the classification function\n", + "def classify_project_type_v2(row):\n", + " program = str(row['Program Name']).lower()\n", + " project_type = str(row['Project Type']).lower()\n", + " \n", + " # Individual incentive programs\n", + " if program == 'low carbon transportation':\n", + " if 'voucher' in project_type.lower():\n", + " return 'Individual - Vehicle'\n", + " return 'Transportation - Other'\n", + " elif program in ['low-income weatherization program', 'woodsmoke reduction program']:\n", + " return 'Individual - Home Energy'\n", + " elif program == 'water-energy efficiency':\n", + " return 'Water-Energy Projects'\n", + " elif program == 'community air protection':\n", + " return 'Air Quality Projects'\n", + " elif program == 'climate smart agriculture':\n", + " return 'Agricultural Projects'\n", + " elif 'voucher' in project_type.lower():\n", + " return 'Individual - Other'\n", + " elif program == 'transformative climate communities':\n", + " return 'Community Projects'\n", + " \n", + " # Institutional by recipient type\n", + " elif pd.notna(row['PRIMARY_FUNDING_RECIPIENT_TYPE']):\n", + " recipient = str(row['PRIMARY_FUNDING_RECIPIENT_TYPE'])\n", + " if recipient in ['Government Agency', 'Government agency', 'California Native American Tribe']:\n", + " return 'Institutional - Government'\n", + " elif recipient == 'Educational institution':\n", + " return 'Institutional - Education'\n", + " elif recipient == 'Nonprofit':\n", + " return 'Institutional - Nonprofit'\n", + " elif recipient == 'Business':\n", + " if row['Total Project Cost'] > 100000:\n", + " return 'Institutional - Large Business'\n", + " return 'Business - Small'\n", + " \n", + " return 'Other'\n", + "\n", + "# 2. Add safe division function for metrics\n", + "def safe_divide(a, b):\n", + " if b == 0:\n", + " return 0\n", + " return a / b\n", + "\n", + "# 3. Recalculate metrics\n", + "data['project_category'] = data.apply(classify_project_type_v2, axis=1)\n", + "data['dac_funding_ratio'] = data.apply(lambda x: safe_divide(x['Total GGRFDisadvantaged Community Funding'], x['Total Project Cost']), axis=1)\n", + "data['ghg_per_dollar'] = data.apply(lambda x: safe_divide(x['Total Project GHGReductions'], x['Total Project Cost']), axis=1)\n", + "\n", + "# 4. Rerun analysis\n", + "updated_analysis = data.groupby('project_category').agg({\n", + " 'Total Project Cost': ['count', 'sum', 'mean'],\n", + " 'Total Project GHGReductions': ['sum', 'mean'],\n", + " 'dac_funding_ratio': ['mean', 'median'],\n", + " 'ghg_per_dollar': ['mean', 'median']\n", + "}).round(4)\n", + "\n", + "print(\"\\nUpdated Project Category Distribution:\")\n", + "print(data['project_category'].value_counts())\n", + "print(\"\\nUpdated Analysis:\")\n", + "print(updated_analysis)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This refined analysis reveals some fascinating patterns about California's climate investments and their environmental justice implications. Let's break down the key findings:\n", + "\n", + "1. Program Distribution and Scale:\n", + "- Transportation dominates numerically:\n", + " * Transportation-Other: 101,427 projects (71.6% of all projects)\n", + " * Individual Vehicle incentives: 4,538 projects\n", + "- Individual programs have high reach but moderate costs:\n", + " * Home Energy: 7,427 projects (~$43K average)\n", + " * Vehicle incentives: 4,538 projects (~$283K average)\n", + "- Institutional projects are fewer but larger:\n", + " * Government: 269 projects (~$63M average)\n", + " * Nonprofits: 100 projects (~$14M average)\n", + "\n", + "2. Environmental Justice (DAC Funding Ratio):\n", + "- Home Energy programs show strongest DAC focus (65% DAC funding ratio)\n", + "- Water-Energy (44%) and Transportation-Other (42%) also show good DAC targeting\n", + "- Individual Vehicle programs have lower DAC funding (17%)\n", + "- Institutional programs show minimal DAC funding ratios\n", + "\n", + "3. GHG Reduction Efficiency (GHG per dollar):\n", + "- Water-Energy Projects are most efficient (0.1027 tons/$)\n", + "- Nonprofit projects show high efficiency (0.0182 tons/$)\n", + "- Agricultural Projects also perform well (0.0106 tons/$)\n", + "- Individual incentives show lower efficiency:\n", + " * Home Energy: 0.0038 tons/$\n", + " * Vehicle: 0.0017 tons/$\n", + "\n", + "\n", + "Key Environmental Justice Implications:\n", + "\n", + "1. Individual vs Institutional Trade-offs:\n", + "- Individual programs (especially home energy) are better at reaching disadvantaged communities\n", + "- But institutional programs tend to be more cost-effective for GHG reductions\n", + "- This suggests a potential tension between equity and efficiency goals\n", + "\n", + "1. Program-Specific Patterns:\n", + "- Home Energy programs show the best balance of DAC reach and moderate GHG efficiency\n", + "- Vehicle incentives have lower DAC reach and efficiency, supporting your hypothesis about wealth bias\n", + "- Water-Energy projects show promising combination of good DAC reach and high efficiency\n", + "\n", + "1. Policy Implications:\n", + "- Consider expanding successful programs like Water-Energy that combine good DAC reach with high efficiency\n", + "- Look for ways to improve DAC access to vehicle incentives\n", + "- Consider bundling institutional and individual programs to balance efficiency and equity goals\n", + "\n", + "Would you like to explore any of these aspects in more detail? We could:\n", + "1. Drill deeper into geographic distribution\n", + "2. Analyze temporal trends in these patterns\n", + "3. Look at specific program characteristics that drive DAC success" ] }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 16, "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "Row count of merged_data: 119356\n", - "Row count of gdf: 5\n", - "Columns of merged_data: Index(['Tract', 'ZIP', 'County_x', 'ApproxLoc', 'TotPop19', 'CIscore',\n", - " 'CIscoreP', 'Ozone', 'OzoneP', 'PM2_5',\n", - " ...\n", - " 'Net Density DUA', 'Applicants Assisted', 'Invasive Cover 12 Months',\n", - " 'Invasive Cover 36 Months', 'Project Acreage', 'IS IAE',\n", - " 'Intermediary Admin Expenses Calc', 'PRIMARY_FUNDING_RECIPIENT_TYPE',\n", - " 'TRIBAL AFFILIATION', 'PROJECT PARTNERS'],\n", - " dtype='object', length=194)\n", - "Columns of gdf: Index(['Tract', 'ZIP', 'County_x', 'ApproxLoc', 'TotPop19', 'CIscore',\n", - " 'CIscoreP', 'Ozone', 'OzoneP', 'PM2_5',\n", - " ...\n", - " 'Net Density DUA', 'Applicants Assisted', 'Invasive Cover 12 Months',\n", - " 'Invasive Cover 36 Months', 'Project Acreage', 'IS IAE',\n", - " 'Intermediary Admin Expenses Calc', 'PRIMARY_FUNDING_RECIPIENT_TYPE',\n", - " 'TRIBAL AFFILIATION', 'PROJECT PARTNERS'],\n", - " dtype='object', length=194)\n" + "/tmp/ipykernel_738944/3534785368.py:18: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.barplot(data=plot_data,\n", + "/tmp/ipykernel_738944/3534785368.py:28: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.barplot(data=plot_data[mask],\n", + "/tmp/ipykernel_738944/3534785368.py:38: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.barplot(data=plot_data[mask],\n" ] - } - ], - "source": [ - "print(\"Row count of merged_data:\", len(merged_data))\n", - "print(\"Row count of gdf:\", len(gdf))\n", - "print(\"Columns of merged_data:\", merged_data.columns)\n", - "print(\"Columns of gdf:\", gdf.columns)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ + }, { - "ename": "NameError", - "evalue": "name 'merged_data' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[1], line 5\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmatplotlib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpyplot\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mplt\u001b[39;00m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mgeopandas\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mgpd\u001b[39;00m\n\u001b[0;32m----> 5\u001b[0m \u001b[43mmerged_data\u001b[49m\u001b[38;5;241m.\u001b[39mplot(figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m10\u001b[39m, \u001b[38;5;241m10\u001b[39m), edgecolor\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mblack\u001b[39m\u001b[38;5;124m'\u001b[39m, linewidth\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.5\u001b[39m)\n\u001b[1;32m 7\u001b[0m \u001b[38;5;66;03m# Add title and labels\u001b[39;00m\n\u001b[1;32m 8\u001b[0m plt\u001b[38;5;241m.\u001b[39mtitle(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mCensus Tracts\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", - "\u001b[0;31mNameError\u001b[0m: name 'merged_data' is not defined" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", - "import geopandas as gpd\n", + "import seaborn as sns\n", "\n", + "# Prepare data for plotting\n", + "plot_data = data.groupby('project_category').agg({\n", + " 'Total Project Cost': ['count', 'mean'],\n", + " 'dac_funding_ratio': 'mean',\n", + " 'ghg_per_dollar': 'mean'\n", + "}).reset_index()\n", "\n", - "merged_data.plot(figsize=(10, 10), edgecolor='black', linewidth=0.5)\n", + "# Flatten column names\n", + "plot_data.columns = ['project_category', 'count', 'avg_cost', 'dac_ratio', 'ghg_efficiency']\n", "\n", - "# Add title and labels\n", - "plt.title('Census Tracts')\n", - "plt.xlabel('Longitude')\n", - "plt.ylabel('Latitude')\n", + "# Create figure with multiple subplots\n", + "fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(15, 20))\n", "\n", - "# Show the plot\n", - "plt.show()\n" + "# 1. Project Counts\n", + "sns.barplot(data=plot_data, \n", + " x='count', \n", + " y='project_category', \n", + " ax=ax1,\n", + " palette='viridis')\n", + "ax1.set_title('Number of Projects by Category')\n", + "ax1.set_xlabel('Number of Projects')\n", + "\n", + "# 2. DAC Funding Ratio\n", + "mask = plot_data['dac_ratio'].notna() # Filter out NaN values\n", + "sns.barplot(data=plot_data[mask], \n", + " x='dac_ratio', \n", + " y='project_category', \n", + " ax=ax2,\n", + " palette='viridis')\n", + "ax2.set_title('Disadvantaged Community Funding Ratio by Category')\n", + "ax2.set_xlabel('DAC Funding Ratio')\n", + "\n", + "# 3. GHG Efficiency\n", + "mask = plot_data['ghg_efficiency'].notna() # Filter out NaN values\n", + "sns.barplot(data=plot_data[mask], \n", + " x='ghg_efficiency', \n", + " y='project_category', \n", + " ax=ax3,\n", + " palette='viridis')\n", + "ax3.set_title('GHG Reduction Efficiency by Category (tons CO2e per dollar)')\n", + "ax3.set_xlabel('GHG Reduction per Dollar')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Create a scatter plot to show relationship between project size and efficiency\n", + "plt.figure(figsize=(12, 8))\n", + "plt.scatter(plot_data['avg_cost'], \n", + " plot_data['ghg_efficiency'], \n", + " alpha=0.6)\n", + "\n", + "# Add labels for each point\n", + "for i, row in plot_data.iterrows():\n", + " plt.annotate(row['project_category'], \n", + " (row['avg_cost'], row['ghg_efficiency']),\n", + " xytext=(5, 5), \n", + " textcoords='offset points')\n", + "\n", + "plt.xscale('log') # Use log scale for cost due to wide range\n", + "plt.xlabel('Average Project Cost (log scale)')\n", + "plt.ylabel('GHG Reduction Efficiency (tons CO2e per dollar)')\n", + "plt.title('Project Cost vs GHG Reduction Efficiency')\n", + "plt.grid(True)\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Top 10 Counties by Project Count:\n", + "County\n", + "Los Angeles 38032\n", + "Orange 10694\n", + "San Diego 8468\n", + "Fresno 7854\n", + "Santa Clara 7154\n", + "Alameda 6381\n", + "Riverside 6190\n", + "San Bernardino 5159\n", + "Sacramento 4781\n", + "San Joaquin 4202\n", + "Name: count, dtype: int64\n", + "\n", + "Project Categories by County (top 5 counties):\n", + "\n", + "Los Angeles:\n", + "project_category\n", + "Transportation - Other 30411\n", + "Individual - Home Energy 2233\n", + "Individual - Vehicle 2187\n", + "Water-Energy Projects 1945\n", + "Other 794\n", + "Air Quality Projects 352\n", + "Community Projects 79\n", + "Institutional - Government 19\n", + "Institutional - Nonprofit 6\n", + "Agricultural Projects 3\n", + "Institutional - Large Business 3\n", + "Name: count, dtype: int64\n", + "\n", + "Orange:\n", + "project_category\n", + "Transportation - Other 9866\n", + "Individual - Vehicle 290\n", + "Individual - Home Energy 184\n", + "Water-Energy Projects 169\n", + "Other 129\n", + "Air Quality Projects 51\n", + "Institutional - Government 4\n", + "Community Projects 1\n", + "Name: count, dtype: int64\n", + "\n", + "San Diego:\n", + "project_category\n", + "Transportation - Other 7571\n", + "Other 375\n", + "Individual - Vehicle 294\n", + "Air Quality Projects 105\n", + "Individual - Home Energy 83\n", + "Agricultural Projects 30\n", + "Institutional - Government 6\n", + "Institutional - Nonprofit 3\n", + "Community Projects 1\n", + "Name: count, dtype: int64\n", + "\n", + "Fresno:\n", + "project_category\n", + "Transportation - Other 2541\n", + "Other 2144\n", + "Air Quality Projects 1747\n", + "Individual - Home Energy 769\n", + "Water-Energy Projects 338\n", + "Agricultural Projects 142\n", + "Individual - Vehicle 96\n", + "Community Projects 64\n", + "Institutional - Government 7\n", + "Institutional - Education 3\n", + "Institutional - Large Business 2\n", + "Institutional - Nonprofit 1\n", + "Name: count, dtype: int64\n", + "\n", + "Santa Clara:\n", + "project_category\n", + "Transportation - Other 6214\n", + "Water-Energy Projects 530\n", + "Individual - Vehicle 177\n", + "Other 89\n", + "Individual - Home Energy 74\n", + "Air Quality Projects 50\n", + "Agricultural Projects 14\n", + "Institutional - Government 3\n", + "Institutional - Nonprofit 2\n", + "Institutional - Large Business 1\n", + "Name: count, dtype: int64\n", + "\n", + "Percentage of Funding by Category in Top 5 Counties:\n", + "project_category Agricultural Projects Air Quality Projects \\\n", + "County \n", + "Los Angeles 0.00 0.36 \n", + "Orange 0.00 1.44 \n", + "San Diego 0.05 1.61 \n", + "Fresno 6.12 10.44 \n", + "Santa Clara 0.03 0.61 \n", + "\n", + "project_category Business - Small Community Projects \\\n", + "County \n", + "Los Angeles 0.0 0.14 \n", + "Orange 0.0 0.15 \n", + "San Diego 0.0 0.00 \n", + "Fresno 0.0 17.55 \n", + "Santa Clara 0.0 0.00 \n", + "\n", + "project_category Individual - Home Energy Individual - Vehicle \\\n", + "County \n", + "Los Angeles 0.06 0.91 \n", + "Orange 0.09 2.90 \n", + "San Diego 0.10 1.45 \n", + "Fresno 4.74 2.50 \n", + "Santa Clara 0.12 2.07 \n", + "\n", + "project_category Institutional - Education Institutional - Government \\\n", + "County \n", + "Los Angeles 0.00 5.35 \n", + "Orange 0.00 37.65 \n", + "San Diego 0.00 2.90 \n", + "Fresno 0.02 0.73 \n", + "Santa Clara 0.00 15.35 \n", + "\n", + "project_category Institutional - Large Business Institutional - Nonprofit \\\n", + "County \n", + "Los Angeles 0.26 0.71 \n", + "Orange 0.00 0.00 \n", + "San Diego 0.00 2.54 \n", + "Fresno 4.07 0.01 \n", + "Santa Clara 3.88 0.04 \n", + "\n", + "project_category Other Transportation - Other Water-Energy Projects \n", + "County \n", + "Los Angeles 91.48 0.73 0.00 \n", + "Orange 51.20 6.46 0.12 \n", + "San Diego 88.01 3.33 0.00 \n", + "Fresno 47.73 5.73 0.36 \n", + "Santa Clara 73.37 4.43 0.09 \n" + ] + } + ], "source": [ - "# save the dbf file as a csv\n", - "merged_data.drop(columns='geometry').to_csv('data_merged/merged_california_climate_investment.csv', index=False)" + "# First let's see how many counties we have data for and their distribution\n", + "county_analysis = data.groupby(['County', 'project_category']).agg({\n", + " 'Total Project Cost': ['count', 'sum'],\n", + " 'Total Project GHGReductions': 'sum',\n", + " 'dac_funding_ratio': 'mean'\n", + "}).round(2)\n", + "\n", + "# Reset index for easier manipulation\n", + "county_analysis = county_analysis.reset_index()\n", + "\n", + "# Flatten column names\n", + "county_analysis.columns = ['County', 'project_category', 'project_count', 'total_cost', 'total_ghg', 'dac_ratio']\n", + "\n", + "print(\"\\nTop 10 Counties by Project Count:\")\n", + "print(data['County'].value_counts().head(10))\n", + "\n", + "print(\"\\nProject Categories by County (top 5 counties):\")\n", + "top_counties = data['County'].value_counts().head(5).index\n", + "for county in top_counties:\n", + " print(f\"\\n{county}:\")\n", + " county_cats = data[data['County'] == county]['project_category'].value_counts()\n", + " print(county_cats)\n", + "\n", + "# Calculate percentage of projects in each county by category\n", + "county_category_pcts = pd.crosstab(data['County'], \n", + " data['project_category'], \n", + " values=data['Total Project Cost'],\n", + " aggfunc='sum',\n", + " normalize='index') * 100\n", + "\n", + "print(\"\\nPercentage of Funding by Category in Top 5 Counties:\")\n", + "print(county_category_pcts.loc[top_counties].round(2))" ] }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(119356, 194)" + "
" ] }, - "execution_count": 45, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# data shape and columns\n", - "merged_data.shape\n" + "# Create a stacked bar chart for project distribution across top counties\n", + "plt.figure(figsize=(15, 8))\n", + "county_category_pcts.loc[top_counties].plot(kind='bar', stacked=True)\n", + "plt.title('Distribution of Project Funding by Category Across Top Counties')\n", + "plt.xlabel('County')\n", + "plt.ylabel('Percentage of Total Funding')\n", + "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Create a visualization for DAC funding ratio by county\n", + "plt.figure(figsize=(15, 8))\n", + "sns.boxplot(data=data[data['dac_funding_ratio'].notna()], \n", + " x='County', \n", + " y='dac_funding_ratio',\n", + " order=top_counties)\n", + "plt.title('DAC Funding Ratio Distribution by County')\n", + "plt.xticks(rotation=45)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Environmental Justice Analysis by Category:\n", + " Total Project Cost \\\n", + " count sum mean \n", + "ej_category \n", + "Individual - Solar/Energy 7427 320008647 4.308720e+04 \n", + "Individual - Vehicle 4538 1286418141 2.834769e+05 \n", + "Large Projects 10009 127060954384 1.269467e+07 \n", + "Other 119455 1537986491 1.287503e+04 \n", + "\n", + " dac_funding_ratio \\\n", + " mean median \n", + "ej_category \n", + "Individual - Solar/Energy 0.6504 0.7405 \n", + "Individual - Vehicle 0.1660 0.0245 \n", + "Large Projects 0.2761 0.0000 \n", + "Other 0.4129 0.0000 \n", + "\n", + " Is Benefit Disadvantaged Communities \\\n", + " mean \n", + "ej_category \n", + "Individual - Solar/Energy 0.7824 \n", + "Individual - Vehicle 0.3455 \n", + "Large Projects 0.0664 \n", + "Other 0.3275 \n", + "\n", + " Is Low Income Communities \\\n", + " mean \n", + "ej_category \n", + "Individual - Solar/Energy 0.9338 \n", + "Individual - Vehicle 0.4125 \n", + "Large Projects 0.5602 \n", + "Other 0.5708 \n", + "\n", + " Total Project GHGReductions \n", + " sum \n", + "ej_category \n", + "Individual - Solar/Energy 693914 \n", + "Individual - Vehicle 993992 \n", + "Large Projects 103527784 \n", + "Other 3938822 \n", + "\n", + "Percentage of Funding to Disadvantaged and Low-Income Communities:\n", + " DAC_percentage LowIncome_percentage\n", + "ej_category \n", + "Individual - Solar/Energy 41.46 4.97\n", + "Individual - Vehicle 5.13 2.01\n", + "Large Projects 0.91 1.47\n", + "Other 10.11 16.38\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Impact Analysis:\n", + " Total Project GHGReductions Total Project Cost \\\n", + "ej_category \n", + "Individual - Solar/Energy 93.43 43087.20 \n", + "Individual - Vehicle 219.04 283476.89 \n", + "Large Projects 10343.47 12694670.24 \n", + "Other 32.97 12875.03 \n", + "\n", + " GHG_reduction_per_dollar \n", + "ej_category \n", + "Individual - Solar/Energy 0.0022 \n", + "Individual - Vehicle 0.0008 \n", + "Large Projects 0.0008 \n", + "Other 0.0026 \n" + ] + } + ], + "source": [ + "# First, let's create a clearer categorization focused on our question\n", + "def classify_for_ej_analysis(row):\n", + " program = str(row['Program Name']).lower()\n", + " project_type = str(row['Project Type']).lower()\n", + " \n", + " # Individual incentives\n", + " if program == 'low carbon transportation' and 'voucher' in project_type.lower():\n", + " return 'Individual - Vehicle'\n", + " elif program == 'low-income weatherization program':\n", + " return 'Individual - Solar/Energy'\n", + " elif program == 'woodsmoke reduction program':\n", + " return 'Individual - Solar/Energy'\n", + " # Large projects\n", + " elif row['Total Project Cost'] > 100000: # threshold for \"large\" projects\n", + " return 'Large Projects'\n", + " else:\n", + " return 'Other'\n", + "\n", + "data['ej_category'] = data.apply(classify_for_ej_analysis, axis=1)\n", + "\n", + "# Analyze environmental justice metrics by category\n", + "ej_analysis = data.groupby('ej_category').agg({\n", + " 'Total Project Cost': ['count', 'sum', 'mean'],\n", + " 'dac_funding_ratio': ['mean', 'median'],\n", + " 'Is Benefit Disadvantaged Communities': 'mean',\n", + " 'Is Low Income Communities': 'mean',\n", + " 'Total Project GHGReductions': 'sum'\n", + "}).round(4)\n", + "\n", + "print(\"Environmental Justice Analysis by Category:\")\n", + "print(ej_analysis)\n", + "\n", + "# Calculate percentage of funds going to different income communities\n", + "ej_distribution = data.groupby('ej_category').agg({\n", + " 'Total Project Cost': 'sum',\n", + " 'Total GGRFDisadvantaged Community Funding': 'sum',\n", + " 'Low Income Amount': 'sum'\n", + "})\n", + "\n", + "ej_distribution['DAC_percentage'] = (ej_distribution['Total GGRFDisadvantaged Community Funding'] / \n", + " ej_distribution['Total Project Cost'] * 100)\n", + "ej_distribution['LowIncome_percentage'] = (ej_distribution['Low Income Amount'] / \n", + " ej_distribution['Total Project Cost'] * 100)\n", + "\n", + "print(\"\\nPercentage of Funding to Disadvantaged and Low-Income Communities:\")\n", + "print(ej_distribution[['DAC_percentage', 'LowIncome_percentage']].round(2))\n", + "\n", + "# Visualize the distribution\n", + "plt.figure(figsize=(12, 6))\n", + "bar_width = 0.35\n", + "categories = ej_distribution.index\n", + "\n", + "x = np.arange(len(categories))\n", + "plt.bar(x - bar_width/2, ej_distribution['DAC_percentage'], \n", + " bar_width, label='DAC Funding %', alpha=0.8)\n", + "plt.bar(x + bar_width/2, ej_distribution['LowIncome_percentage'], \n", + " bar_width, label='Low Income Funding %', alpha=0.8)\n", + "\n", + "plt.xlabel('Project Category')\n", + "plt.ylabel('Percentage of Total Funding')\n", + "plt.title('Distribution of Funding to Disadvantaged and Low-Income Communities')\n", + "plt.xticks(x, categories, rotation=45)\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Let's also look at the per-project impact\n", + "impact_analysis = data.groupby('ej_category').agg({\n", + " 'Total Project GHGReductions': 'mean',\n", + " 'Total Project Cost': 'mean'\n", + "}).round(2)\n", + "\n", + "impact_analysis['GHG_reduction_per_dollar'] = (impact_analysis['Total Project GHGReductions'] / \n", + " impact_analysis['Total Project Cost']).round(4)\n", + "\n", + "print(\"\\nImpact Analysis:\")\n", + "print(impact_analysis)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Patterns of Equity in California's Climate Investments\n", + "\n", + "1. Individual Solar/Energy Programs Show Strong Equity Focus:\n", + "- Highest DAC funding ratio (0.65 mean, 0.74 median)\n", + "- 78% benefit disadvantaged communities\n", + "- 93% benefit low-income communities\n", + "- 41.46% of funds go to DACs, highest among all categories\n", + "- However, relatively small total investment ($320M)\n", + "\n", + "1. Individual Vehicle Programs Show Wealth Disparity:\n", + "- Much lower DAC funding ratio (0.17 mean, 0.02 median)\n", + "- Only 34.5% benefit disadvantaged communities\n", + "- Only 5.13% of funds go to DACs\n", + "- Larger individual project costs (~$283K vs $43K for solar)\n", + "- This supports your hypothesis about vehicle incentives benefiting wealthier communities\n", + "\n", + "1. Large Projects Show Mixed Results:\n", + "- Low DAC funding ratio (0.28 mean, 0.00 median)\n", + "- Only 6.6% benefit disadvantaged communities\n", + "- But 56% benefit low-income communities\n", + "- Largest total investment ($127B)\n", + "- Highest total GHG reductions (103.5M tons)\n", + "\n", + "Key Findings:\n", + "1. Your hypothesis about vehicle incentives primarily benefiting wealthier communities is strongly supported by the data\n", + "2. However, individual solar/energy programs are actually very successful at reaching disadvantaged communities\n", + "3. Large projects, while achieving the most total GHG reductions, have mixed equity outcomes - good at reaching low-income communities but not DACs\n", + "\n", + "Policy Implications:\n", + "1. The solar/energy program model could potentially be adapted for vehicle incentives to improve equity\n", + "2. There may be structural barriers preventing DACs from accessing vehicle incentives that need to be addressed\n", + "3. Large projects might benefit from stronger DAC targeting requirements, given their current low DAC participation despite good low-income community reach\n", + "\n", + "Would you like to explore any of these aspects in more detail? We could:\n", + "1. Analyze what makes the solar/energy programs more successful at reaching DACs\n", + "2. Look at specific barriers in the vehicle incentive programs\n", + "3. Examine whether certain types of large projects are better at reaching disadvantaged communities" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overall Project Distribution by County:\n", + " Total Project Cost \\\n", + " count \n", + "County \n", + "Los Angeles 38032 \n", + "Alameda 6381 \n", + "Alameda, Contra Costa, Fresno, Kern, Kings, Mad... 9 \n", + "Sacramento 4781 \n", + "San Diego 8468 \n", + "San Francisco 2748 \n", + "Santa Clara 7154 \n", + "San Francisco, Santa Clara 6 \n", + "Orange 10694 \n", + "San Diego, Santa Barbara, Ventura 23 \n", + "\n", + " \\\n", + " sum \n", + "County \n", + "Los Angeles 69936060480 \n", + "Alameda 10379456877 \n", + "Alameda, Contra Costa, Fresno, Kern, Kings, Mad... 7333200000 \n", + "Sacramento 5858784824 \n", + "San Diego 4870580185 \n", + "San Francisco 3813460158 \n", + "Santa Clara 3178166479 \n", + "San Francisco, Santa Clara 2998442533 \n", + "Orange 2383485407 \n", + "San Diego, Santa Barbara, Ventura 2235315130 \n", + "\n", + " Total Project GHGReductions \\\n", + " sum \n", + "County \n", + "Los Angeles 11307708 \n", + "Alameda 10518799 \n", + "Alameda, Contra Costa, Fresno, Kern, Kings, Mad... 546406 \n", + "Sacramento 1975903 \n", + "San Diego 2233426 \n", + "San Francisco 1850982 \n", + "Santa Clara 1793848 \n", + "San Francisco, Santa Clara 1538067 \n", + "Orange 1180528 \n", + "San Diego, Santa Barbara, Ventura 791432 \n", + "\n", + " dac_funding_ratio \\\n", + " mean \n", + "County \n", + "Los Angeles 0.5751 \n", + "Alameda 0.2983 \n", + "Alameda, Contra Costa, Fresno, Kern, Kings, Mad... NaN \n", + "Sacramento 0.4194 \n", + "San Diego 0.1004 \n", + "San Francisco 0.1057 \n", + "Santa Clara 0.2247 \n", + "San Francisco, Santa Clara 0.0101 \n", + "Orange 0.3994 \n", + "San Diego, Santa Barbara, Ventura NaN \n", + "\n", + " Is Benefit Disadvantaged Communities \\\n", + " mean \n", + "County \n", + "Los Angeles 0.5420 \n", + "Alameda 0.2612 \n", + "Alameda, Contra Costa, Fresno, Kern, Kings, Mad... 0.0000 \n", + "Sacramento 0.3403 \n", + "San Diego 0.0993 \n", + "San Francisco 0.1121 \n", + "Santa Clara 0.2200 \n", + "San Francisco, Santa Clara 0.1667 \n", + "Orange 0.3571 \n", + "San Diego, Santa Barbara, Ventura 0.0000 \n", + "\n", + " Is Low Income Communities \n", + " mean \n", + "County \n", + "Los Angeles 0.6534 \n", + "Alameda 0.5557 \n", + "Alameda, Contra Costa, Fresno, Kern, Kings, Mad... 1.0000 \n", + "Sacramento 0.5162 \n", + "San Diego 0.5265 \n", + "San Francisco 0.5761 \n", + "Santa Clara 0.4911 \n", + "San Francisco, Santa Clara 0.8333 \n", + "Orange 0.6461 \n", + "San Diego, Santa Barbara, Ventura 1.0000 \n", + "\n", + "Vulnerable Communities Analysis:\n", + " Total Projects Total Investment GHG Reduction\n", + "All Communities 141429 130205367663 109154512\n", + "Disadvantaged Communities 47167 14111685888 12626682\n", + "Low Income Communities 82595 103691488875 55739585\n", + "\n", + "Project Types in Vulnerable Communities:\n", + " Total Project Cost \\\n", + " count \n", + "project_category Is Benefit Disadvantaged Communities \n", + "Agricultural Projects False 1490 \n", + " True 198 \n", + "Air Quality Projects False 5514 \n", + "Business - Small False 2 \n", + "Community Projects False 973 \n", + "Individual - Home Energy False 1616 \n", + " True 5811 \n", + "Individual - Vehicle False 2970 \n", + " True 1568 \n", + "Institutional - Education False 17 \n", + "Institutional - Government False 269 \n", + "Institutional - Large Business False 23 \n", + "Institutional - Nonprofit False 100 \n", + "Other False 13788 \n", + " True 552 \n", + "Transportation - Other False 64674 \n", + " True 36753 \n", + "Water-Energy Projects False 2826 \n", + " True 2285 \n", + "\n", + " \\\n", + " sum \n", + "project_category Is Benefit Disadvantaged Communities \n", + "Agricultural Projects False 824640269 \n", + " True 61874705 \n", + "Air Quality Projects False 1211608583 \n", + "Business - Small False 65376 \n", + "Community Projects False 508817727 \n", + "Individual - Home Energy False 117426101 \n", + " True 202582546 \n", + "Individual - Vehicle False 839347111 \n", + " True 447071030 \n", + "Institutional - Education False 5561672 \n", + "Institutional - Government False 16939974420 \n", + "Institutional - Large Business False 513921827 \n", + "Institutional - Nonprofit False 1402247011 \n", + "Other False 91784138193 \n", + " True 12787875145 \n", + "Transportation - Other False 1888149934 \n", + " True 584940097 \n", + "Water-Energy Projects False 57783551 \n", + " True 27342365 \n", + "\n", + " Total Project GHGReductions \n", + " sum \n", + "project_category Is Benefit Disadvantaged Communities \n", + "Agricultural Projects False 22903912 \n", + " True 1345466 \n", + "Air Quality Projects False 250801 \n", + "Business - Small False 0 \n", + "Community Projects False 154010 \n", + "Individual - Home Energy False 203507 \n", + " True 490407 \n", + "Individual - Vehicle False 699758 \n", + " True 294234 \n", + "Institutional - Education False 457 \n", + "Institutional - Government False 6580289 \n", + "Institutional - Large Business False 388663 \n", + "Institutional - Nonprofit False 4791834 \n", + "Other False 57935224 \n", + " True 9377795 \n", + "Transportation - Other False 2392628 \n", + " True 920302 \n", + "Water-Energy Projects False 226747 \n", + " True 198478 \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_738944/3838036285.py:63: UserWarning: Tight layout not applied. The bottom and top margins cannot be made large enough to accommodate all Axes decorations.\n", + " plt.tight_layout()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 1. First, let's analyze the overall spatial distribution of investments\n", + "county_analysis = data.groupby('County').agg({\n", + " 'Total Project Cost': ['count', 'sum'],\n", + " 'Total Project GHGReductions': 'sum',\n", + " 'dac_funding_ratio': 'mean',\n", + " 'Is Benefit Disadvantaged Communities': 'mean',\n", + " 'Is Low Income Communities': 'mean'\n", + "}).round(4)\n", + "\n", + "# Add per capita metrics (we would need to merge with county population data)\n", + "# Add GHG reduction per dollar by county\n", + "\n", + "# 2. Let's analyze vulnerable communities specifically\n", + "vulnerability_analysis = pd.DataFrame({\n", + " 'Total Projects': [\n", + " len(data),\n", + " len(data[data['Is Benefit Disadvantaged Communities'] == 1]),\n", + " len(data[data['Is Low Income Communities'] == 1])\n", + " ],\n", + " 'Total Investment': [\n", + " data['Total Project Cost'].sum(),\n", + " data[data['Is Benefit Disadvantaged Communities'] == 1]['Total Project Cost'].sum(),\n", + " data[data['Is Low Income Communities'] == 1]['Total Project Cost'].sum()\n", + " ],\n", + " 'GHG Reduction': [\n", + " data['Total Project GHGReductions'].sum(),\n", + " data[data['Is Benefit Disadvantaged Communities'] == 1]['Total Project GHGReductions'].sum(),\n", + " data[data['Is Low Income Communities'] == 1]['Total Project GHGReductions'].sum()\n", + " ]\n", + "}, index=['All Communities', 'Disadvantaged Communities', 'Low Income Communities'])\n", + "\n", + "# 3. Project type distribution in vulnerable communities\n", + "project_vulnerability = data.groupby(['project_category', 'Is Benefit Disadvantaged Communities']).agg({\n", + " 'Total Project Cost': ['count', 'sum'],\n", + " 'Total Project GHGReductions': 'sum'\n", + "}).round(4)\n", + "\n", + "print(\"Overall Project Distribution by County:\")\n", + "print(county_analysis.sort_values(('Total Project Cost', 'sum'), ascending=False).head(10))\n", + "\n", + "print(\"\\nVulnerable Communities Analysis:\")\n", + "print(vulnerability_analysis)\n", + "\n", + "print(\"\\nProject Types in Vulnerable Communities:\")\n", + "print(project_vulnerability)\n", + "\n", + "# Visualizations\n", + "plt.figure(figsize=(15, 8))\n", + "# Plot investment distribution...\n", + "plt.subplot(1, 2, 1)\n", + "county_analysis[('Total Project Cost', 'sum')].sort_values(ascending=False).head(10).plot(kind='bar')\n", + "plt.title('Top 10 Counties by Total Investment')\n", + "plt.ylabel('Total Investment')\n", + "plt.xlabel('County')\n", + "\n", + "# ...and GHG reductions\n", + "plt.subplot(1, 2, 2)\n", + "county_analysis[('Total Project GHGReductions', 'sum')].sort_values(ascending=False).head(10).plot(kind='bar')\n", + "plt.title('Top 10 Counties by GHG Reductions')\n", + "plt.ylabel('Total GHG Reductions')\n", + "plt.xlabel('County')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Spatial Distribution Statistics:\n", + "\n", + "Top 10 Census Tracts by Total Investment:\n", + " Census Tract Total Project Cost Total Project GHGReductions \\\n", + " count sum sum \n", + "1686 6.037206e+09 369 128838282 71147 \n", + "1701 6.037208e+09 246 79854037 21955 \n", + "1250 6.037113e+09 115 67551314 45625 \n", + "5715 6.073006e+09 38 65309556 1546 \n", + "3340 6.037901e+09 61 37506825 44030 \n", + "2391 6.037408e+09 207 34961176 31158 \n", + "3482 6.037980e+09 67 30672161 23886 \n", + "6642 6.081602e+09 61 26686653 14972 \n", + "7164 6.085512e+09 49 24118370 17130 \n", + "2268 6.037403e+09 81 23674333 11183 \n", + "\n", + " Is Benefit Disadvantaged Communities Is Low Income Communities \n", + " mean mean \n", + "1686 0.5176 0.0108 \n", + "1701 0.7886 0.0447 \n", + "1250 0.0087 0.0435 \n", + "5715 0.0000 0.5789 \n", + "3340 0.0000 0.9672 \n", + "2391 0.8164 0.7923 \n", + "3482 0.0000 0.0149 \n", + "6642 0.0000 0.9508 \n", + "7164 0.0000 0.0204 \n", + "2268 0.3333 0.8148 \n", + "\n", + "Top 10 Census Tracts by Project Count:\n", + " Census Tract Total Project Cost Total Project GHGReductions \\\n", + " count sum sum \n", + "1686 6.037206e+09 369 128838282 71147 \n", + "1701 6.037208e+09 246 79854037 21955 \n", + "2391 6.037408e+09 207 34961176 31158 \n", + "6443 6.077002e+09 132 616605 650 \n", + "6448 6.077002e+09 121 401633 284 \n", + "1250 6.037113e+09 115 67551314 45625 \n", + "6452 6.077003e+09 113 438571 580 \n", + "2670 6.037504e+09 103 13744994 12914 \n", + "6449 6.077002e+09 102 534104 625 \n", + "2276 6.037403e+09 99 5585697 12839 \n", + "\n", + " Is Benefit Disadvantaged Communities Is Low Income Communities \n", + " mean mean \n", + "1686 0.5176 0.0108 \n", + "1701 0.7886 0.0447 \n", + "2391 0.8164 0.7923 \n", + "6443 0.0985 0.9848 \n", + "6448 0.0661 0.9835 \n", + "1250 0.0087 0.0435 \n", + "6452 0.0885 0.9469 \n", + "2670 0.1942 0.0583 \n", + "6449 0.1275 0.9804 \n", + "2276 0.0000 0.1818 \n", + "\n", + "Top 10 Census Tracts by GHG Reductions:\n", + " Census Tract Total Project Cost Total Project GHGReductions \\\n", + " count sum sum \n", + "419 6.009000e+09 13 6718556 735067 \n", + "7330 6.091010e+09 8 1842014 730641 \n", + "7963 6.113011e+09 21 9324110 297675 \n", + "7411 6.095253e+09 17 2631219 163765 \n", + "4432 6.061022e+09 13 1199979 78245 \n", + "1686 6.037206e+09 369 128838282 71147 \n", + "3677 6.053011e+09 26 5634176 53453 \n", + "1250 6.037113e+09 115 67551314 45625 \n", + "3340 6.037901e+09 61 37506825 44030 \n", + "4166 6.059086e+09 84 18951369 32458 \n", + "\n", + " Is Benefit Disadvantaged Communities Is Low Income Communities \n", + " mean mean \n", + "419 0.0000 0.1538 \n", + "7330 0.0000 0.7500 \n", + "7963 0.0000 0.1429 \n", + "7411 0.0000 0.2353 \n", + "4432 0.0000 0.0000 \n", + "1686 0.5176 0.0108 \n", + "3677 0.7692 0.3462 \n", + "1250 0.0087 0.0435 \n", + "3340 0.0000 0.9672 \n", + "4166 0.3214 0.2262 \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import geopandas as gpd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# First, summarize the data at tract level\n", + "tract_summary = data.groupby('Census Tract').agg({\n", + " 'Total Project Cost': ['count', 'sum'],\n", + " 'Total Project GHGReductions': 'sum',\n", + " 'Is Benefit Disadvantaged Communities': 'mean',\n", + " 'Is Low Income Communities': 'mean'\n", + "}).round(4)\n", + "\n", + "# Reset the index to make Census Tract a column\n", + "tract_summary = tract_summary.reset_index()\n", + "\n", + "# Create a few different maps to show different aspects\n", + "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(20, 20))\n", + "\n", + "# Function to create a map with proper legend\n", + "def create_map(data, column, title, ax, cmap):\n", + " im = ax.scatter(data['Census Tract'], \n", + " data[column],\n", + " c=data[column],\n", + " cmap=cmap)\n", + " plt.colorbar(im, ax=ax, label=title)\n", + " ax.set_title(title)\n", + " ax.axis('off')\n", + "\n", + "# 1. Project Count Map\n", + "create_map(tract_summary, \n", + " ('Total Project Cost', 'count'),\n", + " 'Number of CCI Projects by Census Tract',\n", + " ax1,\n", + " 'YlOrRd')\n", + "\n", + "# 2. Total Investment Map\n", + "create_map(tract_summary,\n", + " ('Total Project Cost', 'sum'),\n", + " 'Total CCI Investment by Census Tract',\n", + " ax2,\n", + " 'viridis')\n", + "\n", + "# 3. DAC Benefits Map\n", + "create_map(tract_summary,\n", + " ('Is Benefit Disadvantaged Communities', 'mean'),\n", + " 'Proportion of Projects Benefiting DACs',\n", + " ax3,\n", + " 'RdYlBu')\n", + "\n", + "# 4. GHG Reductions Map\n", + "create_map(tract_summary,\n", + " ('Total Project GHGReductions', 'sum'),\n", + " 'Total GHG Reductions by Census Tract',\n", + " ax4,\n", + " 'YlGn')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Let's also look at the basic statistics\n", + "print(\"\\nSpatial Distribution Statistics:\")\n", + "print(\"\\nTop 10 Census Tracts by Total Investment:\")\n", + "print(tract_summary.nlargest(10, ('Total Project Cost', 'sum')))\n", + "\n", + "print(\"\\nTop 10 Census Tracts by Project Count:\")\n", + "print(tract_summary.nlargest(10, ('Total Project Cost', 'count')))\n", + "\n", + "print(\"\\nTop 10 Census Tracts by GHG Reductions:\")\n", + "print(tract_summary.nlargest(10, ('Total Project GHGReductions', 'sum')))\n", + "\n", + "# Additional visualization of investment intensity\n", + "plt.figure(figsize=(15, 10))\n", + "tract_summary['investment_per_project'] = tract_summary[('Total Project Cost', 'sum')] / tract_summary[('Total Project Cost', 'count')]\n", + "plt.scatter(tract_summary[('Is Benefit Disadvantaged Communities', 'mean')],\n", + " tract_summary['investment_per_project'],\n", + " alpha=0.5)\n", + "plt.xlabel('Proportion of Projects Benefiting DACs')\n", + "plt.ylabel('Investment per Project ($)')\n", + "plt.title('Investment Intensity vs DAC Benefits')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Analysis of Spatial Distribution and Environmental Justice Implications\n", + "## Key Findings:\n", + "\n", + "1. Individual vs. Large Project Analysis\n", + "Key Findings:\n", + "- Individual Program Distribution:\n", + " * Home Energy/Solar Programs:\n", + " - Strong equity performance (78% benefit DACs)\n", + " - High DAC funding ratio (0.65)\n", + " - 93% benefit low-income communities\n", + " - Lower total investment ($320M)\n", + " * Vehicle Programs:\n", + " - Lower equity performance (35% benefit DACs)\n", + " - Low DAC funding ratio (0.17)\n", + " - Only 41% benefit low-income communities\n", + " - Higher individual costs (~$283K vs $43K for solar)\n", + "\n", + "- Large Project Performance:\n", + " * Higher total investment ($127B)\n", + " * Highest total GHG reductions (103.5M tons)\n", + " * Mixed equity outcomes:\n", + " - Low DAC funding ratio (0.28)\n", + " - Only 6.6% benefit DACs\n", + " - But 56% benefit low-income communities\n", + "\n", + "2. Spatial Distribution Analysis\n", + "Key Findings:\n", + "- Geographic Concentration:\n", + " * Urban dominance (LA: 27% of projects, 54% of funds)\n", + " * Top 3 counties (LA, Alameda, San Diego) = 37% of projects\n", + " * Clear urban-rural divide in investment distribution\n", + "\n", + "- Environmental Justice Implications:\n", + " * DACs receive 33% of projects but only 11% of funding\n", + " * Low-income communities show better performance (58% of projects, 80% of funding)\n", + " * Significant variation in DAC benefit rates across regions\n", + "\n", + "Next Steps:\n", + "\n", + "1. Individual vs. Large Project Analysis\n", + "- Detailed program design analysis:\n", + " * What makes home energy programs more successful at reaching DACs?\n", + " * What barriers exist in vehicle programs?\n", + " * How can large project DAC benefits be improved?\n", + "- Cost-effectiveness comparison:\n", + " * Calculate and compare GHG reduction per dollar across programs\n", + " * Analyze trade-offs between equity and efficiency\n", + "- Policy recommendations:\n", + " * Identify best practices from successful programs\n", + " * Suggest modifications for underperforming programs\n", + "\n", + "2. Spatial Distribution Analysis\n", + "- Enhanced geographic analysis:\n", + " * Create detailed maps showing investment patterns\n", + " * Analyze urban-rural disparities\n", + " * Examine relationship between CalEnviroScreen scores and investment patterns\n", + "- Environmental justice metrics:\n", + " * Develop composite indicators of investment equity\n", + " * Analyze temporal changes in distribution\n", + " * Compare to demographic and socioeconomic patterns\n", + "\n", + "3. Integration and Synthesis\n", + "- Combine findings from both approaches to:\n", + " * Identify overlapping patterns\n", + " * Develop comprehensive policy recommendations\n", + " * Create framework for evaluating climate investment equity\n", + "\n", + "4. Specific Data Analysis Tasks:\n", + "```python\n", + "# 1. Create program efficiency metrics\n", + "program_efficiency = data.groupby('project_category').agg({\n", + " 'Total Project GHGReductions': 'sum',\n", + " 'Total Project Cost': 'sum'\n", + "}).assign(\n", + " efficiency = lambda x: x['Total Project GHGReductions'] / x['Total Project Cost']\n", + ")\n", + "\n", + "# 2. Analyze spatial equity\n", + "spatial_equity = merged_data.groupby('CES_quartile').agg({\n", + " 'Total Project Cost': ['sum', 'mean', 'count'],\n", + " 'Total Project GHGReductions': ['sum', 'mean']\n", + "})\n", + "\n", + "# 3. Create temporal analysis\n", + "temporal_patterns = data.groupby(['project_category', 'Date Operational']).agg({\n", + " 'Total Project Cost': 'sum',\n", + " 'Is Benefit Disadvantaged Communities': 'mean'\n", + "})\n", + "```\n", + "\n", + "Would you like me to focus on developing any of these next steps in more detail? We could:\n", + "1. Create specific visualizations for the paper\n", + "2. Develop detailed policy recommendations\n", + "3. Conduct additional statistical analyses\n", + "4. Create a framework for program evaluation" ] } ], "metadata": { "kernelspec": { - "display_name": "spatial_modeling", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -862,7 +1956,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.12.6" } }, "nbformat": 4,