diff --git a/freight_economic_competitiveness/ReadMe.md b/freight_economic_competitiveness/ReadMe.md new file mode 100644 index 000000000..5c3575d20 --- /dev/null +++ b/freight_economic_competitiveness/ReadMe.md @@ -0,0 +1 @@ +Freight Economic Competitiveness Analysis conducted for Kelly McClendon to contribute to the SB125 conversation diff --git a/freight_economic_competitiveness/freight_ec_data.csv b/freight_economic_competitiveness/freight_ec_data.csv new file mode 100644 index 000000000..a4edec8aa --- /dev/null +++ b/freight_economic_competitiveness/freight_ec_data.csv @@ -0,0 +1,32 @@ +sln,freight_ec +03, +04,17860.5 +05,3370.16 +07,19599.28 +10,3323.42 +11,3119.47 +12,1467.86 +15,3473.47 +18,4199.73 +19,4555.1 +22,3479.98 +23,16643.05 +25, +27,771.96 +29,72.21 +30,10533.22 +32,1085.17 +37,7913.15 +39,12896.31 +40,11352.45 +42,4181.13 +43, +44,2524.16 +45,3950.36 +47,2863.96 +50,9210.17 +53,618.38 +54,12667.98 +61,443.47 +62,9753.58 +63,7552.66 diff --git a/freight_economic_competitiveness/freight_ec_data.parquet b/freight_economic_competitiveness/freight_ec_data.parquet new file mode 100644 index 000000000..7e6be911f Binary files /dev/null and b/freight_economic_competitiveness/freight_ec_data.parquet differ diff --git a/freight_economic_competitiveness/freight_truck_ec.ipynb b/freight_economic_competitiveness/freight_truck_ec.ipynb new file mode 100644 index 000000000..9f9684f55 --- /dev/null +++ b/freight_economic_competitiveness/freight_truck_ec.ipynb @@ -0,0 +1,1133 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "08ac9974-c868-4ba3-8b63-f265950ab2d2", + "metadata": {}, + "source": [ + "# SB 125\n", + "## Cycle 4, Spring FY2024\n", + "### Freight Truck Economic Competitiveness\n", + "Created March 2024 \n", + "Analysis and write-up completed by Noah Sanchez for Kelly McClendon for a request he received from CTC, Angel, and Hannah \n", + "Geodatabase provided by Affi N'Guessan contained data from the FAF5 https://www.bts.gov/faf " + ] + }, + { + "cell_type": "markdown", + "id": "1f582986-fe0c-42e8-b59d-642a330bd15f", + "metadata": {}, + "source": [ + "#### TCEP/SCCP Cycle 4\n", + "Project's included in the TCEP/SCCP Cycle 4 (https://experience.arcgis.com/experience/1173a09d9f7a452ca7be858c39546678/) were analyzed for freight movement to identify Freight Truck Economic Competitiveness. " + ] + }, + { + "cell_type": "markdown", + "id": "22f01fe4-6bf6-4c37-ad1d-982268929218", + "metadata": {}, + "source": [ + "#### Methodology\n", + "ArcGIS was used to identify the segments in the FAF5 datasets that corresponded with Caltrans' Projects that were included in the TCEP/SCCP Cycle 4. Not all projects were included, only non-rail projects that had project lines that were within the limits of the various projects. Attribute tables that included the segments of the various projects were exported from ArcGIS Pro and imported into JupyterLab for this analysis. Each Project had the values in the column ['TOT_Tons_All_22'] averaged. " + ] + }, + { + "cell_type": "markdown", + "id": "8ac14f1d-4898-44d1-afea-13b51f039a96", + "metadata": {}, + "source": [ + "#### Deliverable\n", + "This analysis is not a comprehensive economic analysis, but is being used to add to the conversation. The final deliverable is a CSV or Excel doc containing the Economic Competitive Analysis results and other general project information. The final deliverable was sent to Kelly McClendon and Affi N'Guessan via email on 3/21/2024. " + ] + }, + { + "cell_type": "markdown", + "id": "05dee661-6eba-4926-9cb8-514ceeefb9f3", + "metadata": {}, + "source": [ + "#### Additional Research\n", + "We discussed potential future analysis could be performed, including a more detailed breakdown of the freight being transported per segment in an effort to identify the average value of the freight in a given area." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "780fed8b-b6f2-49f6-ba32-878834b95c4f", + "metadata": {}, + "outputs": [], + "source": [ + "# import modules\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import pyarrow as pa\n", + "import pyarrow.parquet as pq\n", + "import os\n", + "import nbformat\n", + "from nbconvert import PDFExporter\n", + "from nbformat import read" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0805fa7d-834c-41bf-9ffd-e1f06a4bd32d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/conda/lib/python3.9/site-packages/google/auth/_default.py:78: UserWarning: Your application has authenticated using end user credentials from Google Cloud SDK without a quota project. You might receive a \"quota exceeded\" or \"API not enabled\" error. See the following page for troubleshooting: https://cloud.google.com/docs/authentication/adc-troubleshooting/user-creds. \n", + " warnings.warn(_CLOUD_SDK_CREDENTIALS_WARNING)\n" + ] + } + ], + "source": [ + "\n", + "\n", + "test_df = pd.read_csv(\"gs://calitp-analytics-data/data-analyses/freight_ec_2024/03_links_flow_trucks_SR132_West_3A.csv\")\n", + "\n", + "# do a for loop to read in the data\n", + "# f strings can be used to create an easier way to read-in all the data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a05d78c1-aef6-4992-8dc1-9ca62afed631", + "metadata": {}, + "outputs": [], + "source": [ + "# Create an easy to use GCS path\n", + "GCS_PATH = \"gs://calitp-analytics-data/data-analyses/freight_ec_2024/\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fd83db53-11ed-47b4-82ec-9a8c51171cb7", + "metadata": {}, + "outputs": [], + "source": [ + "#test_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e45ef50d-279a-469d-9b5f-e3c21916f1ac", + "metadata": {}, + "outputs": [], + "source": [ + "# Assign the DataFrame names\n", + "\n", + "# assign names to the datafile that were exported from the FAF5 geodatabase\n", + "# the exported data includes FAF5 segments (similar to OSM segments) that contain Truck Freight Flow data\n", + "# sln == \"submission log number\"\n", + "sln03_data = '03_links_flow_trucks_SR132_West_3A.csv'\n", + "sln04_data = '04_links_flow_trucks_Sac5_managed_lanes.csv'\n", + "sln05_data = '05_links_flow_trucks_Konocti.csv'\n", + "sln07_data = '07_links_flow_trucks_sr132_west_phase2.csv'\n", + "sln10_data = '10_links_flow_trucks_SR46East_UnionRoad.csv'\n", + "sln11_data = '11_links_flow_trucks_SR46_AntelopeGrade.csv'\n", + "sln12_data = '12_links_flow_trucks_805_15_Transit_Only_Connector.csv'\n", + "sln15_data = '15_links_flow_trucks_SantaBarbaraUS101.csv'\n", + "sln18_data = '18_links_flow_trucks_sr84_us101_Interchange.csv'\n", + "sln19_data = '19_links_flow_trucks_I680_SR4_Interchange.csv'\n", + "sln22_data = '22_links_flow_trucks_SR37_SearsPoint_US101.csv'\n", + "sln23_data = '23_links_flow_trucks_TulareSixLane.csv'\n", + "sln25_data = '25_links_flow_trucks_centennial_corridor.csv'\n", + "sln27_data = '27_links_flow_trucks_HarborDrive_2_0.csv'\n", + "sln29_data = '29_links_flow_trucks_ScenicRoute_68.csv'\n", + "sln30_data = '30_links_flow_trucks_I680_NB_ExpressLane_phase1.csv'\n", + "sln32_data = '32_links_flow_trucks_I10_RiversideAvenue.csv'\n", + "sln37_data = '37_links_flow_trucks_AmericanCanyonSR29.csv'\n", + "sln39_data = '39_links_flow_trucks_SR60_WorldLogistics.csv'\n", + "sln40_data = '40_links_flow_trucks_SR60_RedlandsBlvd.csv'\n", + "sln42_data = '42_links_flow_trucks_i15_ExpressLanes_Southern.csv'\n", + "sln43_data = '43_links_flow_trucks_McCall_Boulevard.csv'\n", + "sln44_data = '44_links_flow_trucks_i15_sr74_ii.csv'\n", + "sln45_data = '45_links_flow_trucks_Watsonville1_SantaCruz.csv'\n", + "sln47_data = '47_links_flow_trucks_SR91_Central_Ave.csv'\n", + "sln50_data = '50_links_flow_trucks_harbor_scenic.csv'\n", + "sln53_data = '53_links_flow_trucks_HuenemeRoad.csv'\n", + "sln54_data = '54_links_flow_trucks_i5_managed_lanes.csv'\n", + "sln61_data = '61_links_flow_trucks_castrovilleBoulevard.csv'\n", + "sln62_data = '62_links_flow_trucks_multimodal_skyway.csv'\n", + "sln63_data = '63_links_flow_trucks_SC_SR71_GapClosure.csv'" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ab8ea0e0-cbcb-40c6-b7b6-5475190f19f5", + "metadata": {}, + "outputs": [], + "source": [ + "# create a function to import the data from a csv file\n", + "def getData(path):\n", + " # reads in the data from a .csv file\n", + " # add in an f string to designate the data path\n", + " df = pd.read_csv(f\"{GCS_PATH}{path}\")\n", + " return df\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e934ca92-cf41-47e8-9087-eea0589dd8c3", + "metadata": {}, + "outputs": [], + "source": [ + "# Pull in data\n", + "\n", + "sln03_data = getData(sln03_data)\n", + "sln04_data = getData(sln04_data)\n", + "sln05_data = getData(sln05_data)\n", + "sln07_data = getData(sln07_data)\n", + "sln10_data = getData(sln10_data)\n", + "sln11_data = getData(sln11_data)\n", + "sln12_data = getData(sln12_data)\n", + "sln15_data = getData(sln15_data)\n", + "sln18_data = getData(sln18_data)\n", + "sln19_data = getData(sln19_data)\n", + "sln22_data = getData(sln22_data)\n", + "sln23_data = getData(sln23_data)\n", + "sln25_data = getData(sln25_data)\n", + "sln27_data = getData(sln27_data)\n", + "sln29_data = getData(sln29_data)\n", + "sln30_data = getData(sln30_data)\n", + "sln32_data = getData(sln32_data)\n", + "sln37_data = getData(sln37_data)\n", + "sln39_data = getData(sln39_data)\n", + "sln40_data = getData(sln40_data)\n", + "sln42_data = getData(sln42_data)\n", + "sln43_data = getData(sln43_data)\n", + "sln44_data = getData(sln44_data)\n", + "sln45_data = getData(sln45_data)\n", + "sln47_data = getData(sln47_data)\n", + "sln50_data = getData(sln50_data)\n", + "sln53_data = getData(sln53_data)\n", + "sln54_data = getData(sln54_data)\n", + "sln61_data = getData(sln61_data)\n", + "sln62_data = getData(sln62_data)\n", + "sln63_data = getData(sln63_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4c307bf0-0788-4951-ae24-6333444a622a", + "metadata": {}, + "outputs": [], + "source": [ + "# Create subsets\n", + "\n", + "# Create subsets using only the [ID] and [TOT_Tons_22_All] columns\n", + "data_03 = sln03_data[['TOT_Tons_22_All']]\n", + "data_04 = sln04_data[['TOT_Tons_22_All']]\n", + "data_05 = sln05_data[['TOT_Tons_22_All']]\n", + "data_07 = sln07_data[['TOT_Tons_22_All']]\n", + "data_10 = sln10_data[['TOT_Tons_22_All']]\n", + "data_11 = sln11_data[['TOT_Tons_22_All']]\n", + "data_12 = sln12_data[['TOT_Tons_22_All']]\n", + "data_15 = sln15_data[['TOT_Tons_22_All']]\n", + "data_18 = sln18_data[['TOT_Tons_22_All']]\n", + "data_19 = sln19_data[['TOT_Tons_22_All']]\n", + "data_22 = sln22_data[['TOT_Tons_22_All']]\n", + "data_23 = sln23_data[['TOT_Tons_22_All']]\n", + "data_25 = sln25_data[['TOT_Tons_22_All']]\n", + "data_27 = sln27_data[['TOT_Tons_22_All']]\n", + "data_29 = sln29_data[['TOT_Tons_22_All']]\n", + "data_30 = sln30_data[['TOT_Tons_22_All']]\n", + "data_32 = sln32_data[['TOT_Tons_22_All']]\n", + "data_37 = sln37_data[['TOT_Tons_22_All']]\n", + "data_39 = sln39_data[['TOT_Tons_22_All']]\n", + "data_40 = sln40_data[['TOT_Tons_22_All']]\n", + "data_42 = sln42_data[['TOT_Tons_22_All']]\n", + "data_43 = sln43_data[['TOT_Tons_22_All']]\n", + "data_44 = sln44_data[['TOT_Tons_22_All']]\n", + "data_45 = sln45_data[['TOT_Tons_22_All']]\n", + "data_47 = sln47_data[['TOT_Tons_22_All']]\n", + "data_50 = sln50_data[['TOT_Tons_22_All']]\n", + "data_53 = sln53_data[['TOT_Tons_22_All']]\n", + "data_54 = sln54_data[['TOT_Tons_22_All']]\n", + "data_61 = sln61_data[['TOT_Tons_22_All']]\n", + "data_62 = sln62_data[['TOT_Tons_22_All']]\n", + "data_63 = sln63_data[['TOT_Tons_22_All']]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "83d96202-50e4-4a24-8931-4d2821057b08", + "metadata": {}, + "outputs": [], + "source": [ + "# Create a function to average the Totals Column\n", + "def calculate_average_combined_freight(path):\n", + " try:\n", + " # Identify the dataset\n", + " data = path\n", + " \n", + " # Filter out NaN values from the specified column\n", + " filtered_data = data.dropna(subset=['TOT_Tons_22_All'])\n", + " \n", + " # Calculate the total of the specified column\n", + " total = filtered_data['TOT_Tons_22_All'].sum()\n", + " \n", + " # Calculate teh number of records with data in the column\n", + " count = filtered_data['TOT_Tons_22_All'].count()\n", + " \n", + " # Ensure count is not zero to avoid division by zero\n", + " if count != 0:\n", + " # Calculate the average\n", + " average = (total)/count\n", + " # Format the average to have two digits past the decimal point\n", + " formatted_average =\"{:.2f}\".format(average)\n", + " #Convert the formatted average back to a float\n", + " average_float = float(formatted_average)\n", + " # Convert the float to a DataFrame\n", + " # I had trouble with this one, still working on it\n", + " #formatted_average = pd.DataFrame(formatted_average)\n", + " \n", + " return average_float\n", + " else:\n", + " #print(\"No records with data in the column.\") # This step has been changed to a comment to clean up the final PDF version\n", + " return None\n", + " except Exception as e:\n", + " print(\"An error occurred:\", e)\n", + " return None\n", + "\n", + "# Create a function to rename the first column\n", + "def rename_col(df):\n", + " # rename the columns\n", + " mapping = {\n", + " df.columns[0]: 'freight_ec',\n", + " df.columns[1]: 'sln'\n", + " }\n", + " df = df.rename(columns=mapping)\n", + " return df\n", + "\n", + "\n", + "# Create a function to reorder the columns so the [sln] column appears first\n", + "def reorder_columns(df):\n", + " \"\"\"\n", + " Reorder columns from 'freight_ec' and 'sln' to 'sln' and 'freight_ec'\n", + " \n", + " Paramters:\n", + " df (pandas.DataFrame): Input DataFrame.\n", + " \n", + " Returns:\n", + " pandas.DataFrame: DataFrame with reordered columns\n", + " \"\"\"\n", + " # Ensure that the columns exist in the DataFrame\n", + " if 'freight_ec' in df.columns and 'sln' in df.columns:\n", + " # Reorder columns\n", + " new_df = df[['sln', 'freight_ec']]\n", + " return new_df\n", + " else:\n", + " print(\"Error: 'freight_ec_ and/or 'sln' columns not found in the DataFrame.\")\n", + " return df \n", + "\n", + "# Create a function to export the data to a parquet\n", + "def export_to_parquet(df, output_file):\n", + " \"\"\"\n", + " Export a Pandas DataFrame to a Parquet file.\n", + " \n", + " Parameters:\n", + " df (pandas.DataFrame): The DataFrame to Export\n", + " output_file (str): The path to the output Parquet file.\n", + " \n", + " Returns:\n", + " None\n", + " \"\"\"\n", + " # Convert the DataFrame to a PyArrow table\n", + " table = pa.Table.from_pandas(df)\n", + " \n", + " # write the PyArrow table to a Parquet file\n", + " pq.write_table(table, output_file)\n", + " \n", + " print(f\"DataFrame exported to Parquet successfully at {output_file}.\")\n", + "\n", + "# Create a function to export a notebook to a PDF\n", + "def notebook_to_pdf_with_code(input_notebook, output_pdf):\n", + " \"\"\"\n", + " Convert a Jupyter Notebook to PDF.\n", + " \n", + " Paramters: \n", + " input_notebook (str): Path to the input Jupyter Notebook.\n", + " output_pdf (str): Path to save the output PDF file. \n", + " \"\"\"\n", + " if not input_notebook_c.endswith('.ipynb'):\n", + " raise ValueError(\"Input file should be a Jupyter Notebook (.ipynb)\")\n", + " \n", + " if not output_pdf_c.endswith('.pdf'):\n", + " raise ValueError(\"Output file should be a PDF (.pdf)\")\n", + " \n", + " if not os.path.isfile(input_notebook_c):\n", + " raise FileNotFoundError(\"Input notebook not found.\")\n", + " \n", + " pdf_exporter = PDFExporter()\n", + " with open(input_notebook_c, 'rb') as f:\n", + " notebook_content = read(f, as_version=4)\n", + " body, _ = pdf_exporter.from_notebook_node(notebook_content)\n", + " \n", + " with open(output_pdf_c, 'wb') as f:\n", + " f.write(body)\n", + " \n", + " print(f\"Notebook successfully converted to PDF: {output_pdf_c}\") \n", + " \n", + "def notebook_to_pdf_without_code(notebook_path, output_path):\n", + " # Read the notebook\n", + " with open(input_notebook, 'r', encoding='utf-8') as f:\n", + " notebook = nbformat.read(f, as_version=4)\n", + " \n", + " # Iterate through each cell\n", + " for cell in notebook.cells:\n", + " # Hide code cells\n", + " if cell.cell_type == 'code':\n", + " cell['execution_count'] = None\n", + " cell['source'] = ''\n", + " \n", + " # Export to PDF\n", + " pdf_exporter = PDFExporter()\n", + " pdf_exporter.exclude_input = True\n", + " pdf_exporter.exclude_output_prompt = False # This can be changed if you want to hide teh output cells as well\n", + " (body, resources) = pdf_exporter.from_notebook_node(notebook)\n", + " \n", + " # Write PDF to file\n", + " with open(output_pdf, 'wb') as f:\n", + " f.write(body)\n", + " \n", + " print(f\"Notebook successfully converted to PDF: {output_pdf}\") " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4e9de515-610a-4b6c-abf8-348d3b09e79d", + "metadata": {}, + "outputs": [], + "source": [ + "# Use the calculate_average_combined_freight(path) function to identify the average\n", + "# freight tonnage for the segments in each of the project's limits\n", + "average_03 = calculate_average_combined_freight(data_03)\n", + "average_04 = calculate_average_combined_freight(data_04)\n", + "average_05 = calculate_average_combined_freight(data_05)\n", + "average_07 = calculate_average_combined_freight(data_07)\n", + "average_10 = calculate_average_combined_freight(data_10)\n", + "average_11 = calculate_average_combined_freight(data_11)\n", + "average_12 = calculate_average_combined_freight(data_12)\n", + "average_15 = calculate_average_combined_freight(data_15)\n", + "average_18 = calculate_average_combined_freight(data_18)\n", + "average_19 = calculate_average_combined_freight(data_19)\n", + "average_22 = calculate_average_combined_freight(data_22)\n", + "average_23 = calculate_average_combined_freight(data_23)\n", + "average_25 = calculate_average_combined_freight(data_25)\n", + "average_27 = calculate_average_combined_freight(data_27)\n", + "average_29 = calculate_average_combined_freight(data_29)\n", + "average_30 = calculate_average_combined_freight(data_30)\n", + "average_32 = calculate_average_combined_freight(data_32)\n", + "average_37 = calculate_average_combined_freight(data_37)\n", + "average_39 = calculate_average_combined_freight(data_39)\n", + "average_40 = calculate_average_combined_freight(data_40)\n", + "average_42 = calculate_average_combined_freight(data_42)\n", + "average_43 = calculate_average_combined_freight(data_43)\n", + "average_44 = calculate_average_combined_freight(data_44)\n", + "average_45 = calculate_average_combined_freight(data_45)\n", + "average_47 = calculate_average_combined_freight(data_47)\n", + "average_50 = calculate_average_combined_freight(data_50)\n", + "average_53 = calculate_average_combined_freight(data_53)\n", + "average_54 = calculate_average_combined_freight(data_54)\n", + "average_61 = calculate_average_combined_freight(data_61)\n", + "average_62 = calculate_average_combined_freight(data_62)\n", + "average_63 = calculate_average_combined_freight(data_63)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a5816f34-8da2-40a7-9d34-2ea4d41f4102", + "metadata": {}, + "outputs": [], + "source": [ + "# Create a DataFrame for each average value\n", + "df_03 = pd.DataFrame([average_03])\n", + "df_04 = pd.DataFrame([average_04])\n", + "df_05 = pd.DataFrame([average_05])\n", + "df_07 = pd.DataFrame([average_07])\n", + "df_10 = pd.DataFrame([average_10])\n", + "df_11 = pd.DataFrame([average_11])\n", + "df_12 = pd.DataFrame([average_12])\n", + "df_15 = pd.DataFrame([average_15])\n", + "df_18 = pd.DataFrame([average_18])\n", + "df_19 = pd.DataFrame([average_19])\n", + "df_22 = pd.DataFrame([average_22])\n", + "df_23 = pd.DataFrame([average_23])\n", + "df_25 = pd.DataFrame([average_25])\n", + "df_27 = pd.DataFrame([average_27])\n", + "df_29 = pd.DataFrame([average_29])\n", + "df_30 = pd.DataFrame([average_30])\n", + "df_32 = pd.DataFrame([average_32])\n", + "df_37 = pd.DataFrame([average_37])\n", + "df_39 = pd.DataFrame([average_39])\n", + "df_40 = pd.DataFrame([average_40])\n", + "df_42 = pd.DataFrame([average_42])\n", + "df_43 = pd.DataFrame([average_43])\n", + "df_44 = pd.DataFrame([average_44])\n", + "df_45 = pd.DataFrame([average_45])\n", + "df_47 = pd.DataFrame([average_47])\n", + "df_50 = pd.DataFrame([average_50])\n", + "df_53 = pd.DataFrame([average_53])\n", + "df_54 = pd.DataFrame([average_54])\n", + "df_61 = pd.DataFrame([average_61])\n", + "df_62 = pd.DataFrame([average_62])\n", + "df_63 = pd.DataFrame([average_63])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a3195816-0c8a-4999-87bb-75f564fb387c", + "metadata": {}, + "outputs": [], + "source": [ + "# adding a column to the datasets called 'sln' which stands for 'submission log number'\n", + "# the value of the 'sln' column will correspond with that record's submission log number that is found on the TCEP_SCCP_Cycle_4... Excel doc\n", + "df_03['sln'] = '03'\n", + "df_04['sln'] = '04'\n", + "df_05['sln'] = '05'\n", + "df_07['sln'] = '07'\n", + "df_10['sln'] = '10'\n", + "df_11['sln'] = '11'\n", + "df_12['sln'] = '12'\n", + "df_15['sln'] = '15'\n", + "df_18['sln'] = '18'\n", + "df_19['sln'] = '19'\n", + "df_22['sln'] = '22'\n", + "df_23['sln'] = '23'\n", + "df_25['sln'] = '25'\n", + "df_27['sln'] = '27'\n", + "df_29['sln'] = '29'\n", + "df_30['sln'] = '30'\n", + "df_32['sln'] = '32'\n", + "df_37['sln'] = '37'\n", + "df_39['sln'] = '39'\n", + "df_40['sln'] = '40'\n", + "df_42['sln'] = '42'\n", + "df_43['sln'] = '43'\n", + "df_44['sln'] = '44'\n", + "df_45['sln'] = '45'\n", + "df_47['sln'] = '47'\n", + "df_50['sln'] = '50'\n", + "df_53['sln'] = '53'\n", + "df_54['sln'] = '54'\n", + "df_61['sln'] = '61'\n", + "df_62['sln'] = '62'\n", + "df_63['sln'] = '63'" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b25a8fae-95b5-4bad-a389-296787043cc8", + "metadata": {}, + "outputs": [], + "source": [ + "# Rename the columns using the rename column function\n", + "df_03 = rename_col(df_03)\n", + "df_04 = rename_col(df_04)\n", + "df_05 = rename_col(df_05)\n", + "df_07 = rename_col(df_07)\n", + "df_10 = rename_col(df_10)\n", + "df_11 = rename_col(df_11)\n", + "df_12 = rename_col(df_12)\n", + "df_15 = rename_col(df_15)\n", + "df_18 = rename_col(df_18)\n", + "df_19 = rename_col(df_19)\n", + "df_22 = rename_col(df_22)\n", + "df_23 = rename_col(df_23)\n", + "df_25 = rename_col(df_25)\n", + "df_27 = rename_col(df_27)\n", + "df_29 = rename_col(df_29)\n", + "df_30 = rename_col(df_30)\n", + "df_32 = rename_col(df_32)\n", + "df_37 = rename_col(df_37)\n", + "df_39 = rename_col(df_39)\n", + "df_40 = rename_col(df_40)\n", + "df_42 = rename_col(df_42)\n", + "df_43 = rename_col(df_43)\n", + "df_44 = rename_col(df_44)\n", + "df_45 = rename_col(df_45)\n", + "df_47 = rename_col(df_47)\n", + "df_50 = rename_col(df_50)\n", + "df_53 = rename_col(df_53)\n", + "df_54 = rename_col(df_54)\n", + "df_61 = rename_col(df_61)\n", + "df_62 = rename_col(df_62)\n", + "df_63 = rename_col(df_63)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "639bddbf-2091-451a-a580-f739a9dcffd3", + "metadata": {}, + "outputs": [], + "source": [ + "# Reorder the columns using the Reorder column function\n", + "df_03 = reorder_columns(df_03)\n", + "df_04 = reorder_columns(df_04)\n", + "df_05 = reorder_columns(df_05)\n", + "df_07 = reorder_columns(df_07)\n", + "df_10 = reorder_columns(df_10)\n", + "df_11 = reorder_columns(df_11)\n", + "df_12 = reorder_columns(df_12)\n", + "df_15 = reorder_columns(df_15)\n", + "df_18 = reorder_columns(df_18)\n", + "df_19 = reorder_columns(df_19)\n", + "df_22 = reorder_columns(df_22)\n", + "df_23 = reorder_columns(df_23)\n", + "df_25 = reorder_columns(df_25)\n", + "df_27 = reorder_columns(df_27)\n", + "df_29 = reorder_columns(df_29)\n", + "df_30 = reorder_columns(df_30)\n", + "df_32 = reorder_columns(df_32)\n", + "df_37 = reorder_columns(df_37)\n", + "df_39 = reorder_columns(df_39)\n", + "df_40 = reorder_columns(df_40)\n", + "df_42 = reorder_columns(df_42)\n", + "df_43 = reorder_columns(df_43)\n", + "df_44 = reorder_columns(df_44)\n", + "df_45 = reorder_columns(df_45)\n", + "df_47 = reorder_columns(df_47)\n", + "df_50 = reorder_columns(df_50)\n", + "df_53 = reorder_columns(df_53)\n", + "df_54 = reorder_columns(df_54)\n", + "df_61 = reorder_columns(df_61)\n", + "df_62 = reorder_columns(df_62)\n", + "df_63 = reorder_columns(df_63)" + ] + }, + { + "cell_type": "markdown", + "id": "6902a4b4-bed8-4e38-b596-4dac17961795", + "metadata": {}, + "source": [ + "#### Freight Economic Competitiveness Analysis Results" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "da39f086-15de-4792-81a4-bd090c413c04", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
slnfreight_ec
003NaN
10417860.50
2053370.16
30719599.28
4103323.42
5113119.47
6121467.86
7153473.47
8184199.73
9194555.10
10223479.98
112316643.05
1225NaN
1327771.96
142972.21
153010533.22
16321085.17
17377913.15
183912896.31
194011352.45
20424181.13
2143NaN
22442524.16
23453950.36
24472863.96
25509210.17
2653618.38
275412667.98
2861443.47
29629753.58
30637552.66
\n", + "
" + ], + "text/plain": [ + " sln freight_ec\n", + "0 03 NaN\n", + "1 04 17860.50\n", + "2 05 3370.16\n", + "3 07 19599.28\n", + "4 10 3323.42\n", + "5 11 3119.47\n", + "6 12 1467.86\n", + "7 15 3473.47\n", + "8 18 4199.73\n", + "9 19 4555.10\n", + "10 22 3479.98\n", + "11 23 16643.05\n", + "12 25 NaN\n", + "13 27 771.96\n", + "14 29 72.21\n", + "15 30 10533.22\n", + "16 32 1085.17\n", + "17 37 7913.15\n", + "18 39 12896.31\n", + "19 40 11352.45\n", + "20 42 4181.13\n", + "21 43 NaN\n", + "22 44 2524.16\n", + "23 45 3950.36\n", + "24 47 2863.96\n", + "25 50 9210.17\n", + "26 53 618.38\n", + "27 54 12667.98\n", + "28 61 443.47\n", + "29 62 9753.58\n", + "30 63 7552.66" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create a DataFrame for each average value and then concatenate them together\n", + "freight_ec_data = pd.concat([df_03, df_04, df_05, df_07, df_10, df_11, df_12, df_15, df_18, df_19, df_22, df_23, df_25, df_27, df_29, df_30, df_32, df_37, df_39, df_40, df_42, df_43, df_44, df_45, df_47, df_50, df_53, df_54, df_61, df_62, df_63], ignore_index=True)\n", + "freight_ec_data" + ] + }, + { + "cell_type": "markdown", + "id": "fc2a93f7-9eab-4e98-87ea-13f0eafa8604", + "metadata": {}, + "source": [ + "### Data Visualizations" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "45798efb-7ef6-4f5c-a67e-dfe4557fc402", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# identifying the tonnage weight column ['freight_ec']\n", + "freight_ec_column = freight_ec_data['freight_ec']\n", + "\n", + "# Setting the style of seaborn\n", + "sns.set_style(\"whitegrid\")\n", + "\n", + "# Plotting the tonnage weight values\n", + "plt.figure(figsize=(10, 6))\n", + "sns.histplot(freight_ec_column, bins=20, color='skyblue', edgecolor='black')\n", + "plt.title('Freight Economic Competitiveness Analysis')\n", + "plt.xlabel('Tonnage Weight')\n", + "plt.ylabel('Frequency')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "86fe2757-34d2-4add-9cab-2a6eaf62c3af", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# identifying the tonnage weight column ['freight_ec']\n", + "freight_ec_column = freight_ec_data['freight_ec']\n", + "\n", + "# Setting the style of seaborn\n", + "sns.set_style(\"whitegrid\")\n", + "\n", + "# Plotting the tonnage weight values using a violin plot\n", + "plt.figure(figsize=(10,6))\n", + "sns.violinplot(y=freight_ec_column, color='skyblue')\n", + "plt.title('Freight Economic Compeititve Analysis Violin Plot')\n", + "plt.ylabel('Tonnage Weight')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "164efc26-83e4-4f0f-9c1c-4fb2d93ece84", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# identifying the tonnage weight column ['freight_ec']\n", + "freight_ec_column = freight_ec_data['freight_ec']\n", + "\n", + "# Generating x values (assuming sln numbers as the x values)\n", + "#x_values = freight_ec_data['sln']\n", + "x_values = freight_ec_data.index\n", + "\n", + "# Plotting the tonnage weight values using a scatterplot\n", + "plt.figure(figsize=(10,6))\n", + "plt.scatter(x_values, freight_ec_column, color='skyblue', alpha=0.6)\n", + "plt.title('Freight Economic Competitive Analysis Scatter Plot')\n", + "plt.ylabel('sln')\n", + "plt.xlabel('Tonnage Weight')\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c2d49962-c6ec-452d-93f8-1dc99ea4b8d4", + "metadata": {}, + "source": [ + "#### Exports" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "c2eec2bf-4d50-4b76-8ae6-f2da6772a6d0", + "metadata": {}, + "outputs": [], + "source": [ + "# Export Notebooks\n", + "\n", + "# PDF" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "b9ba289a-b0ae-4f73-805d-b80f81c026b5", + "metadata": {}, + "outputs": [], + "source": [ + "# Hide the code cells and write to a PDF paramters without code\n", + "input_notebook = 'freight_truck_ec.ipynb'\n", + "output_pdf = 'freight_truck_ec_analysis_hidden_code.pdf'" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "abeed225-b9a9-4549-a20a-f9c093897059", + "metadata": {}, + "outputs": [], + "source": [ + "# Hide the code cells and write to a PDF paramters with code\n", + "input_notebook_c = 'freight_truck_ec.ipynb'\n", + "output_pdf_c = 'freight_truck_ec_analysis.pdf'" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "6b3dc865-2103-4553-87ce-13891173438e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Notebook successfully converted to PDF: freight_truck_ec_analysis_hidden_code.pdf\n" + ] + } + ], + "source": [ + "# Create a PDF that hides the code cells\n", + "notebook_to_pdf_without_code(input_notebook, output_pdf)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "0f038ef5-eb1b-4dc7-8385-4e5cdf275392", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Notebook successfully converted to PDF: freight_truck_ec_analysis.pdf\n" + ] + } + ], + "source": [ + "# Create a PDF that include the code cells\n", + "notebook_to_pdf_with_code(input_notebook_c, output_pdf_c)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "063eb2d0-3d10-4bd7-9610-e20913eea951", + "metadata": {}, + "outputs": [], + "source": [ + "# CSV" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "e06736a5-6b5e-460c-b954-1dafbc855b3d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataFrame exported to CSV successfully at freight_ec_data.csv\n" + ] + } + ], + "source": [ + "# Create a CSV from the data\n", + "freight_ec_data.to_csv('freight_ec_data.csv', index=False)\n", + "\n", + "# the following script is pending approval\n", + "#freight_ec_data.to_csv(f\"{GCS_PATH}/outputs/freight_ec_data.csv\", index=False)\n", + "\n", + "\n", + "# Print the success statement after the CSV has been exported\n", + "print(f\"DataFrame exported to CSV successfully at freight_ec_data.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "342a4e65-b594-487c-97ca-8e6dfe2dc5ba", + "metadata": {}, + "outputs": [], + "source": [ + "# Parquet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0bb36f8d-10fc-4641-bcf4-7fcee9f782fa", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the output file path for the Parquet file\n", + "parquet_output_file = 'freight_ec_data.parquet'\n", + "\n", + "# Export the DataFrame to Parquet using the export_to_parquet function\n", + "export_to_parquet(freight_ec_data, parquet_output_file)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/freight_economic_competitiveness/freight_truck_ec_analysis.pdf b/freight_economic_competitiveness/freight_truck_ec_analysis.pdf new file mode 100644 index 000000000..432209cb8 Binary files /dev/null and b/freight_economic_competitiveness/freight_truck_ec_analysis.pdf differ diff --git a/freight_economic_competitiveness/freight_truck_ec_analysis_hidden_code.pdf b/freight_economic_competitiveness/freight_truck_ec_analysis_hidden_code.pdf new file mode 100644 index 000000000..2fc540ff8 Binary files /dev/null and b/freight_economic_competitiveness/freight_truck_ec_analysis_hidden_code.pdf differ