GvdDool/final_demo_code_v1.ipynb

## final_demo_code_v1.ipynb
{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "91b7d1d2-fb85-431a-a24e-ddee5cf0eac2",
   "metadata": {},
   "source": [
    "## Libaries and settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d0598a9f-f1a0-415a-a8ed-c6f0652a6b54",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, netCDF4, time\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import geopandas as gpd\n",
    "\n",
    "#import numpy_indexed as npi\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import Normalize\n",
    "\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "#if file not in the root\n",
    "#berkeley_file('/Users/hausfath/Desktop/Climate Science/GHCN Monthly/')\n",
    "\n",
    "berkeley_file = r\"E:\\Projects\\GitHub\\CodeExperiment_Repo\\20250825_ShowYourStripes_Working\\Complete_TAVG_LatLong1.nc\"\n",
    "file_path1 = r\"E:\\Projects\\GitHub\\CodeExperiment_Repo\\20250825_ShowYourStripes_Working\\labrijn_ea\\labrijn_ea.dat\"\n",
    "file_path2 = r\"E:\\Projects\\GitHub\\CodeExperiment_Repo\\20250825_ShowYourStripes_Working\\CentralEnglandTemperature.txt\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "644a44ad-6d32-4153-80a0-7f5592da79bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Year  Jan  Feb  Mar  Apr  May  Jun  Jul  Aug  Sep    Oct   Nov   Dec  \\\n",
      "0  1706    5   32   55   87  146  170  174  173  140  110.0  44.0  23.0   \n",
      "1  1707    7   49   47   83  120  168  181  159  149   90.0  65.0  19.0   \n",
      "2  1708   39   31   59   95  122  146  154  185  159   92.0  54.0   4.0   \n",
      "3  1709  -51   -3   11   92  116  153  161  162  145  109.0  78.0  25.0   \n",
      "4  1710    4   18   56   70  133  150  152  161  147  108.0  70.0  55.0   \n",
      "\n",
      "   Year_avg   Win    Spr    Sum    Aut  \n",
      "0      97.0  96.0  172.0   98.0    NaN  \n",
      "1      95.0  26.0   83.0  169.0  101.0  \n",
      "2      95.0  30.0   92.0  162.0  102.0  \n",
      "3      83.0 -17.0   73.0  159.0  111.0  \n",
      "4      94.0  16.0   86.0  154.0  108.0  \n"
     ]
    }
   ],
   "source": [
    "# Read the data, skipping metadata lines\n",
    "# You might need to adjust skiprows depending on how many lines are metadata\n",
    "df = pd.read_csv(\n",
    "    file_path1,\n",
    "    sep=r'\\s+',          # use regex for whitespace separation\n",
    "    skiprows=22,         # adjust based on your metadata\n",
    "    names=[\"Year\",\"Jan\",\"Feb\",\"Mar\",\"Apr\",\"May\",\"Jun\",\"Jul\",\"Aug\",\"Sep\",\"Oct\",\"Nov\",\"Dec\",\"Year_avg\",\"Win\",\"Spr\",\"Sum\",\"Aut\"]\n",
    ")\n",
    "\n",
    "\n",
    "# Check the first few rows\n",
    "print(df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3065506f-7296-4ff5-b15b-d2cc5f3f642a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Year  Jan  Feb  Mar  Apr   May   Jun   Jul   Aug   Sep   Oct  Nov  Dec  \\\n",
      "0  1706  0.5  3.2  5.5  8.7  14.6  17.0  17.4  17.3  14.0  11.0  4.4  2.3   \n",
      "1  1707  0.7  4.9  4.7  8.3  12.0  16.8  18.1  15.9  14.9   9.0  6.5  1.9   \n",
      "2  1708  3.9  3.1  5.9  9.5  12.2  14.6  15.4  18.5  15.9   9.2  5.4  0.4   \n",
      "3  1709 -5.1 -0.3  1.1  9.2  11.6  15.3  16.1  16.2  14.5  10.9  7.8  2.5   \n",
      "4  1710  0.4  1.8  5.6  7.0  13.3  15.0  15.2  16.1  14.7  10.8  7.0  5.5   \n",
      "\n",
      "   Year_avg   Win    Spr    Sum    Aut  Annual_mean  \n",
      "0       9.7  96.0  172.0   98.0    NaN     9.658333  \n",
      "1       9.5  26.0   83.0  169.0  101.0     9.475000  \n",
      "2       9.5  30.0   92.0  162.0  102.0     9.500000  \n",
      "3       8.3 -17.0   73.0  159.0  111.0     8.316667  \n",
      "4       9.4  16.0   86.0  154.0  108.0     9.366667  \n"
     ]
    }
   ],
   "source": [
    "# Convert tenths of degrees to degrees Celsius\n",
    "months = [\"Jan\",\"Feb\",\"Mar\",\"Apr\",\"May\",\"Jun\",\"Jul\",\"Aug\",\"Sep\",\"Oct\",\"Nov\",\"Dec\",\"Year_avg\"]\n",
    "df[months] = df[months] / 10\n",
    "\n",
    "# Compute annual mean from monthly data (if needed)\n",
    "df[\"Annual_mean\"] = df[[\"Jan\",\"Feb\",\"Mar\",\"Apr\",\"May\",\"Jun\",\"Jul\",\"Aug\",\"Sep\",\"Oct\",\"Nov\",\"Dec\"]].mean(axis=1)\n",
    "\n",
    "print(df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "551fd1dd-0b17-48d4-a36e-431e5ae242b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "temps = df['Annual_mean'].values  # your annual mean temperatures\n",
    "years = df['Year'].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8063b6af-4311-4145-b5e4-5da3b4b078bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1961–1990 baseline mean: 9.37 °C\n"
     ]
    }
   ],
   "source": [
    "baseline_mask = (years >= 1961) & (years <= 1990)\n",
    "baseline_mean = temps[baseline_mask].mean()\n",
    "print(f\"1961–1990 baseline mean: {baseline_mean:.2f} °C\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "164061bd-d5d1-499e-b74d-b2d194703dff",
   "metadata": {},
   "outputs": [],
   "source": [
    "year_loc = np.where((years >= 1709) & (years <= 2024))[0]  # example range\n",
    "temps = temps[year_loc]\n",
    "temps_anomaly = temps - baseline_mean\n",
    "\n",
    "years = years[year_loc]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "62fec1e8-4fb1-4908-8399-62eee323ed61",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.50055556, 1.33388889, 1.56722222, 1.95055556, 1.78388889,\n",
       "       2.31722222, 1.08388889, 2.18388889, 2.40055556, 2.42555556])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temps_anomaly[-10:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "017d030f-d86d-4cbb-9722-a94380c8d6c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "temps_normed_NL = ((temps_anomaly - temps_anomaly.min()) / np.ptp(temps_anomaly)) * (len(temps_anomaly) - 1)\n",
    "elements_NL = len(temps_anomaly)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a582d753-6a7c-44e4-ad69-05e9f603a089",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([260.19592476, 250.32131661, 264.14576803, 286.85736677,\n",
       "       276.98275862, 308.5815047 , 235.50940439, 300.68181818,\n",
       "       313.51880878, 315.        ])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temps_normed_NL[-10:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "826ac135-ef01-4250-8d33-3a86fe91c180",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_lbls = np.arange(elements_NL)\n",
    "y_vals2 = np.ones(elements_NL)  # stripes cover full height\n",
    "\n",
    "my_cmap = plt.cm.RdBu_r  # choose colormap\n",
    "norm = Normalize(vmin=0, vmax=elements_NL - 1)\n",
    "\n",
    "def colorval(num):\n",
    "    return my_cmap(norm(num))\n",
    "\n",
    "fig = plt.figure(figsize=(10, 2))  # wide and short figure\n",
    "plt.axis('off')\n",
    "\n",
    "plt.bar(x_lbls, y_vals2, color=list(map(colorval, temps_normed_NL)), width=1.0, edgecolor='none')\n",
    "plt.ylim(0, 1)\n",
    "fig.subplots_adjust(left=0, right=1, top=1, bottom=0)\n",
    "#fig.savefig('Labrijn_stripes.png', dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56366d83-33ed-49fd-be81-5647a8d67533",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0471fc94-077b-4e1c-bfc5-21073b2e3a63",
   "metadata": {},
   "source": [
    "### Function set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "24508807-4e36-458f-ad1b-c238a4fcb798",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'netCDF4.Variable'>\n",
      "float32 temperature(time, latitude, longitude)\n",
      "    units: degree C\n",
      "    standard_name: surface_temperature_anomaly\n",
      "    long_name: Air Surface Temperature Anomaly\n",
      "    missing_value: nan\n",
      "    valid_min: -16.295777024848707\n",
      "    valid_max: 17.883551529596865\n",
      "unlimited dimensions: time\n",
      "current shape = (3300, 180, 360)\n",
      "filling on, default _FillValue of 9.969209968386869e+36 used\n",
      "(3300, 180, 360)\n"
     ]
    }
   ],
   "source": [
    "def import_berkeley(filename, verbose = False):\n",
    "    nc = netCDF4.Dataset(filename, 'r')\n",
    "\n",
    "    print(nc.variables['temperature'])\n",
    "\n",
    "    nc.set_auto_mask(False)    # disable masked array conversion\n",
    "    nc.set_auto_scale(False)   # disable auto scaling + valid_min/valid_max checks\n",
    "    \n",
    "    lats = nc.variables['latitude'][:]\n",
    "    lons = nc.variables['longitude'][:]\n",
    "    temps = nc.variables['temperature'][:,:,:]\n",
    "    times = nc.variables['time'][:]\n",
    "    years = times.astype(int)\n",
    "    return {\n",
    "        'lats' : lats,\n",
    "        'lons' : lons,\n",
    "        'temps' : temps,\n",
    "        'times' : times,\n",
    "        'years' : years\n",
    "    }\n",
    "\n",
    "\n",
    "def local_timeseries(data, local_lat, local_lon):\n",
    "    near_lat = find_nearest(data['lats'], local_lat)\n",
    "    near_lon = find_nearest(data['lons'], local_lon)\n",
    "    near_lat_pos = np.where(data['lats'] == near_lat)[0][0]\n",
    "    near_lon_pos = np.where(data['lons'] == near_lon)[0][0]\n",
    "    try:\n",
    "        anoms = np.swapaxes(data['anoms'],0,2)\n",
    "        anoms = np.swapaxes(anoms,0,1)\n",
    "    except:\n",
    "        anoms = np.swapaxes(data['temps'],0,2)\n",
    "        anoms = np.swapaxes(anoms,0,1)\n",
    "    return anoms[near_lat_pos][near_lon_pos]\n",
    "\n",
    "\n",
    "def find_nearest(array, value):\n",
    "    idx = (np.abs(array - value)).argmin()\n",
    "    return array[idx]\n",
    "\n",
    "# Original\n",
    "# def berkeley_local_annual(filename, local_lat, local_lon, data):\n",
    "#     local_data = local_timeseries(data, local_lat, local_lon)\n",
    "#     unique, mean = npi.group_by(data['years']).mean(local_data)\n",
    "#     df = pd.DataFrame({'years' : unique,\n",
    "#                        'temps' : mean})\n",
    "#     return df\n",
    "\n",
    "def berkeley_local_annual(filename, local_lat, local_lon, data):\n",
    "    local_data = local_timeseries(data, local_lat, local_lon)\n",
    "    \n",
    "    df = pd.DataFrame({\n",
    "        \"years\": data[\"years\"],\n",
    "        \"temps\": local_data\n",
    "    })\n",
    "    \n",
    "    df = df.groupby(\"years\", as_index=False).mean()  # mean per year\n",
    "    \n",
    "    return df\n",
    "\n",
    "data_berkeley = import_berkeley(berkeley_file)\n",
    "print(data_berkeley['temps'].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "574a7256-7f9c-4a42-abf3-a055fde841d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4114c64-c0e3-4857-81c9-3146ed29984b",
   "metadata": {},
   "source": [
    "### Using the three localtions NLD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "081a1a79-abc0-4d98-a0c4-22b72911641c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of setup for West Netherlands stations\n",
    "coords = {\n",
    "    \"Zwanenburg\": (52.379, 4.745),\n",
    "    \"Utrecht\": (52.091, 5.122),\n",
    "    \"De Bilt\": (52.110, 5.181),\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "4d65d8c0-248e-42ef-baef-56bcabb52f46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     years  Zwanenburg   Utrecht   De Bilt  WestNL_mean\n",
      "170   2020    2.073054  2.147810  2.147810     2.122891\n",
      "171   2021    1.036274  1.056139  1.056139     1.049517\n",
      "172   2022    2.131661  2.129435  2.129435     2.130177\n",
      "173   2023    2.195541  2.270276  2.270276     2.245364\n",
      "174   2024    2.286909  2.379073  2.379073     2.348352\n"
     ]
    }
   ],
   "source": [
    "# Years of interest\n",
    "start_year, end_year = 1850, 2024\n",
    "\n",
    "# Store results for each city\n",
    "all_results = []\n",
    "\n",
    "for city, (lat, lon) in coords.items():\n",
    "    df = berkeley_local_annual(berkeley_file, lat, lon, data_berkeley)\n",
    "    df = df[(df['years'] >= start_year) & (df['years'] <= end_year)]\n",
    "    df = df.rename(columns={'temps': city})  # rename temps column to city name\n",
    "    all_results.append(df)\n",
    "\n",
    "# Merge all three dataframes on 'years'\n",
    "merged = all_results[0]\n",
    "for df in all_results[1:]:\n",
    "    merged = pd.merge(merged, df, on='years', how='inner')\n",
    "\n",
    "# Now average across stations\n",
    "merged['WestNL_mean'] = merged[['Zwanenburg', 'Utrecht', 'De Bilt']].mean(axis=1)\n",
    "\n",
    "print(merged.tail())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "191377e3-ede4-4dff-be58-a7ab4b5977ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "year_loc = np.where((merged['years'] >= start_year) & (merged['years'] <= end_year))[0]\n",
    "temp = merged.loc[year_loc, 'WestNL_mean']\n",
    "\n",
    "temps_normed = ((temp - temp.min()) / (temp.max() - temp.min())) * (len(temp) - 1)\n",
    "elements = len(temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6a24d4b9-2f1b-45d3-bd37-5ecaf80bc4cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       50.402618\n",
       "1       55.604580\n",
       "2       95.729797\n",
       "3       25.175001\n",
       "4       66.340759\n",
       "          ...    \n",
       "170    164.969513\n",
       "171    121.977104\n",
       "172    165.261322\n",
       "173    169.875000\n",
       "174    174.000000\n",
       "Name: WestNL_mean, Length: 175, dtype: float32"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temps_normed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "90b0b83e-0254-40f7-ba30-f3e672449873",
   "metadata": {},
   "outputs": [],
   "source": [
    "x_lbls = np.arange(elements)\n",
    "y_vals = temps_normed / (elements- 1)\n",
    "y_vals2 = np.full(elements, 1)\n",
    "bar_wd  = 1\n",
    "\n",
    "my_cmap = plt.cm.RdBu_r #choose colormap to use for bars\n",
    "norm = Normalize(vmin=0, vmax=elements - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "3c1416a4-7643-4eff-8043-173f82b27ee5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig=plt.figure(figsize=(6,3))\n",
    "plt.axis('off')\n",
    "plt.axis('tight')\n",
    "\n",
    "#Plot warming stripes. Change y_vals2 to y_vals to plot stripes under the line only.\n",
    "plt.bar(x_lbls, y_vals2, color = list(map(colorval, temps_normed)), width=1.0, edgecolor = \"none\")\n",
    "\n",
    "#Plot temperature timeseries. Comment out to only plot stripes\n",
    "#plt.plot((x_lbls + 0.5), y_vals - 0.002, color='black', linewidth=2)\n",
    "\n",
    "plt.xticks( x_lbls + bar_wd, x_lbls)\n",
    "plt.ylim(0, 1)\n",
    "fig.subplots_adjust(bottom = 0)\n",
    "fig.subplots_adjust(top = 1)\n",
    "fig.subplots_adjust(right = 1)\n",
    "fig.subplots_adjust(left = 0)\n",
    "#fig.savefig(savename+'.png', dpi=300)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "708eca7b-bb68-4087-9e87-279e8452a3c1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e0c98519-5d92-4351-92de-4e6029206c27",
   "metadata": {},
   "source": [
    "### Combining the historical and Model NLD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "b181cbb6-f00d-4eed-94c9-95a5c1135bbf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     year  anomaly_norm source\n",
      "486  2020      0.943073  model\n",
      "487  2021      0.741184  model\n",
      "488  2022      0.944443  model\n",
      "489  2023      0.966108  model\n",
      "490  2024      0.985479  model\n"
     ]
    }
   ],
   "source": [
    "# Your arrays\n",
    "years_hist = np.arange(1709, 2025)  # 1709–2024\n",
    "years_model = np.arange(1850, 2025) # 1850–2024\n",
    "hist_anom = temps_anomaly      # shape (316,)\n",
    "model_anom = temp          # shape (175,)\n",
    "\n",
    "# Combine the values for normalization\n",
    "combined_values = np.concatenate([hist_anom, model_anom])\n",
    "combined_norm = (combined_values - combined_values.min()) / (combined_values.max() - combined_values.min())\n",
    "\n",
    "# Source labels\n",
    "source_labels = ['historical'] * len(hist_anom) + ['model'] * len(model_anom)\n",
    "combined_years = np.concatenate([years_hist, years_model])\n",
    "\n",
    "# Build DataFrame\n",
    "df_combined = pd.DataFrame({\n",
    "    'year': combined_years,\n",
    "    'anomaly_norm': combined_norm,\n",
    "    'source': source_labels\n",
    "})\n",
    "\n",
    "# Now you can filter separately if needed\n",
    "df_hist = df_combined[df_combined['source']=='historical']\n",
    "df_model = df_combined[df_combined['source']=='model']\n",
    "\n",
    "print(df_combined.tail())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "0ae87ec1-4342-41df-b242-ce03cc0c2ca2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(16, 4))\n",
    "\n",
    "# ------------------------\n",
    "# Left: Warming stripes (75% width)\n",
    "# ------------------------\n",
    "ax_stripes = fig.add_axes([0.05, 0.1, 0.68, 0.8])  # [left, bottom, width, height]\n",
    "\n",
    "years = np.arange(1659, 2025)\n",
    "model_vals = df_model.set_index(\"year\").reindex(years)['anomaly_norm'].values\n",
    "hist_vals = df_hist.set_index(\"year\").reindex(years)['anomaly_norm'].values\n",
    "# Prepare data: top row = model, bottom row = historical\n",
    "data = np.vstack([model_vals, hist_vals])  # model first, historical second\n",
    "\n",
    "\n",
    "years = np.arange(1659, 2025)  # or whatever year range your data has\n",
    "x_edges = np.arange(years[0], years[-1] + 2)  # +1 to get 317 edges for 316 columns\n",
    "\n",
    "# pcolormesh with y_edges from 0–2 (0–1 bottom row, 1–2 top row)\n",
    "y_edges = [0, 1, 2]  # bottom row = historical, top row = model\n",
    "\n",
    "# Flip rows so model is on top\n",
    "data_flipped = data[::-1, :]  # model on top, historical below\n",
    "# Swap the rows so model is on top\n",
    "data_flipped = data[::-1, :]  # reverse rows\n",
    "\n",
    "#ax_stripes.pcolormesh(x_edges, y_edges, data_flipped, cmap='RdBu_r', edgecolors='face')\n",
    "ax_stripes.pcolormesh(x_edges, y_edges, data_flipped, cmap='RdBu_r', edgecolors='face')\n",
    "\n",
    "\n",
    "ax_stripes.set_yticks([0.5, 1.5])\n",
    "ax_stripes.set_yticklabels([\"Historical\", \"Model\"])  # labels match flipped rows\n",
    "ax_stripes.set_xlim(1659, 2024)\n",
    "ax_stripes.set_ylim(0,2)\n",
    "ax_stripes.set_xticks(np.linspace(1660, 2020, 7))\n",
    "ax_stripes.set_title(\"Warming Stripes: Netherlands\")\n",
    "\n",
    "# ------------------------\n",
    "# Right: Scatter plot (25% width)\n",
    "# ------------------------\n",
    "ax_scatter = fig.add_axes([0.78, 0.1, 0.2, 0.8])  # [left, bottom, width, height]\n",
    "\n",
    "overlap_years = sorted(set(df_hist['year']).intersection(df_model['year']))\n",
    "hist_overlap = df_hist.set_index(\"year\").loc[overlap_years, \"anomaly_norm\"]\n",
    "model_overlap = df_model.set_index(\"year\").loc[overlap_years, \"anomaly_norm\"]\n",
    "\n",
    "ax_scatter.scatter(hist_overlap, model_overlap, alpha=0.7)\n",
    "ax_scatter.plot([hist_overlap.min(), hist_overlap.max()],\n",
    "                [hist_overlap.min(), hist_overlap.max()],\n",
    "                'r--', label=\"1:1 line\")\n",
    "\n",
    "m, b = np.polyfit(hist_overlap, model_overlap, 1)\n",
    "x_vals = np.linspace(hist_overlap.min(), hist_overlap.max(), 100)\n",
    "ax_scatter.plot(x_vals, m*x_vals + b, 'b-', label=f\"Fit: y={m:.2f}x+{b:.2f}\")\n",
    "\n",
    "rmse = np.sqrt(mean_squared_error(hist_overlap, model_overlap))\n",
    "res_std = np.std(hist_overlap.values - model_overlap.values)\n",
    "ax_scatter.set_title(f\"Obs vs Model [1850-2024]\\nRMSE={rmse:.3f}°C, σ={res_std:.3f}°C\")\n",
    "ax_scatter.set_xlabel(\"Observed (°C)\")\n",
    "ax_scatter.set_ylabel(\"Model (°C)\")\n",
    "ax_scatter.legend()\n",
    "ax_scatter.grid(True)\n",
    "\n",
    "fig.savefig('NLD_stripes.png', dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34017e78-7e40-4a75-8878-6a1ed258ce53",
   "metadata": {},
   "source": [
    "## GB stripes historically"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "7d2f00f9-0456-4f2c-9c00-33bdcc88ce09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Year  Jan  Feb  Mar  Apr   May   Jun   Jul   Aug    Se   Oct  Nov  Dec  \\\n",
      "0  1659  3.0  4.0  6.0  7.0  11.0  13.0  16.0  16.0  13.0  10.0  5.0  2.0   \n",
      "1  1660  0.0  4.0  6.0  9.0  11.0  14.0  15.0  16.0  13.0  10.0  6.0  5.0   \n",
      "2  1661  5.0  5.0  6.0  8.0  11.0  14.0  15.0  15.0  13.0  11.0  8.0  6.0   \n",
      "3  1662  5.0  6.0  6.0  8.0  11.0  15.0  15.0  15.0  13.0  11.0  6.0  3.0   \n",
      "4  1663  1.0  1.0  5.0  7.0  10.0  14.0  15.0  15.0  13.0  10.0  7.0  5.0   \n",
      "\n",
      "   Annual  \n",
      "0    8.87  \n",
      "1    9.10  \n",
      "2    9.78  \n",
      "3    9.52  \n",
      "4    8.63  \n"
     ]
    }
   ],
   "source": [
    "# Path to your data file\n",
    "\n",
    "\n",
    "# Read the data, skipping metadata lines\n",
    "# You might need to adjust skiprows depending on how many lines are metadata\n",
    "df = pd.read_csv(\n",
    "    file_path2,\n",
    "    sep=r'\\s+',          # use regex for whitespace separation\n",
    "    skiprows=1,         # adjust based on your metadata\n",
    "    names=[\"Year\", \"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Se\", \"Oct\", \"Nov\", \"Dec\", \"Annual\"]\n",
    ")\n",
    "\n",
    "# Convert Year column to integer\n",
    "#df['Year'] = df['Year'].astype(int)\n",
    "\n",
    "# Check the first few rows\n",
    "print(df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "7b136ec2-5fe2-44b4-ae0f-cc26219bbeca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1961–1990 baseline mean: 9.46 °C\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "temps = df['Annual'].values  # your annual mean temperatures\n",
    "years = df['Year'].values\n",
    "\n",
    "baseline_mask = (years >= 1961) & (years <= 1990)\n",
    "baseline_mean = temps[baseline_mask].mean()\n",
    "print(f\"1961–1990 baseline mean: {baseline_mean:.2f} °C\")\n",
    "\n",
    "year_loc = np.where((years >= 1659) & (years <= 2024))[0]  # example range\n",
    "temps = temps[year_loc]\n",
    "temps_anomaly = temps - baseline_mean\n",
    "\n",
    "years = years[year_loc]\n",
    "\n",
    "\n",
    "temps_normed_GB = ((temps_anomaly - temps_anomaly.min()) / np.ptp(temps_anomaly)) * (len(temps_anomaly) - 1)\n",
    "elements_GB = len(temps_anomaly)\n",
    "\n",
    "x_lbls = np.arange(elements_GB)\n",
    "y_vals2 = np.ones(elements_GB)  # stripes cover full height\n",
    "\n",
    "my_cmap = plt.cm.RdBu_r  # choose colormap\n",
    "norm = Normalize(vmin=0, vmax=elements_GB - 1)\n",
    "\n",
    "def colorval(num):\n",
    "    return my_cmap(norm(num))\n",
    "\n",
    "fig = plt.figure(figsize=(10, 2))  # wide and short figure\n",
    "plt.axis('off')\n",
    "\n",
    "plt.bar(x_lbls, y_vals2, color=list(map(colorval, temps_normed_GB)), width=1.0, edgecolor='none')\n",
    "plt.ylim(0, 1)\n",
    "fig.subplots_adjust(left=0, right=1, top=1, bottom=0)\n",
    "#fig.savefig('Labrijn_stripes.png', dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d46194a-cfa7-4f32-891a-980d2ae08cf1",
   "metadata": {},
   "source": [
    "### Using three locations GB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "6ebee5cd-4730-44cc-ab82-4069b2f06b01",
   "metadata": {},
   "outputs": [],
   "source": [
    "coords = {\n",
    "    \"Stonyhurst\": (53.892, -2.218),\n",
    "    \"Rothamsted\": (51.802, -0.356),\n",
    "    \"Pershore\": (52.089, -2.062),\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "1a2df162-9aa9-4e4e-9e6f-21f9bee63f7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 366)\n"
     ]
    }
   ],
   "source": [
    "print(data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "6b1aa8f1-d640-4dac-aa73-ac16255a0dd7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     years  Stonyhurst  Rothamsted  Pershore  CET_GBR_mean\n",
      "170   2020    1.384093    1.700817  1.491286      1.525398\n",
      "171   2021    1.117187    0.987947  1.113617      1.072917\n",
      "172   2022    1.861891    2.083327  1.884564      1.943261\n",
      "173   2023    1.848946    1.915227  1.866878      1.877017\n",
      "174   2024    1.676415    1.840639  1.717260      1.744771\n"
     ]
    }
   ],
   "source": [
    "# Years of interest\n",
    "start_year, end_year = 1850, 2024\n",
    "\n",
    "# Store results for each city\n",
    "all_results = []\n",
    "\n",
    "for city, (lat, lon) in coords.items():\n",
    "    df = berkeley_local_annual(berkeley_file, lat, lon, data_berkeley)\n",
    "    df = df[(df['years'] >= start_year) & (df['years'] <= end_year)]\n",
    "    df = df.rename(columns={'temps': city})  # rename temps column to city name\n",
    "    all_results.append(df)\n",
    "\n",
    "# Merge all three dataframes on 'years'\n",
    "merged = all_results[0]\n",
    "for df in all_results[1:]:\n",
    "    merged = pd.merge(merged, df, on='years', how='inner')\n",
    "\n",
    "# Now average across stations\n",
    "merged['CET_GBR_mean'] = merged[['Stonyhurst', 'Rothamsted', 'Pershore']].mean(axis=1)\n",
    "\n",
    "print(merged.tail())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "7e6031cb-1bd2-48fe-9283-5173cbf1f44b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "year_loc = np.where((merged['years'] >= start_year) & (merged['years'] <= end_year))[0]\n",
    "temp = merged.loc[year_loc, 'CET_GBR_mean']\n",
    "\n",
    "temps_normed = ((temp - temp.min()) / (temp.max() - temp.min())) * (len(temp) - 1)\n",
    "elements = len(temp)\n",
    "\n",
    "x_lbls = np.arange(elements)\n",
    "y_vals = temps_normed / (elements- 1)\n",
    "y_vals2 = np.full(elements, 1)\n",
    "bar_wd  = 1\n",
    "\n",
    "my_cmap = plt.cm.RdBu_r #choose colormap to use for bars\n",
    "norm = Normalize(vmin=0, vmax=elements - 1)\n",
    "\n",
    "fig=plt.figure(figsize=(6,3))\n",
    "plt.axis('off')\n",
    "plt.axis('tight')\n",
    "\n",
    "#Plot warming stripes. Change y_vals2 to y_vals to plot stripes under the line only.\n",
    "plt.bar(x_lbls, y_vals2, color = list(map(colorval, temps_normed)), width=1.0, edgecolor = \"none\")\n",
    "\n",
    "#Plot temperature timeseries. Comment out to only plot stripes\n",
    "#plt.plot((x_lbls + 0.5), y_vals - 0.002, color='black', linewidth=2)\n",
    "\n",
    "plt.xticks( x_lbls + bar_wd, x_lbls)\n",
    "plt.ylim(0, 1)\n",
    "fig.subplots_adjust(bottom = 0)\n",
    "fig.subplots_adjust(top = 1)\n",
    "fig.subplots_adjust(right = 1)\n",
    "fig.subplots_adjust(left = 0)\n",
    "#fig.savefig(savename+'.png', dpi=300)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9af63058-1814-4ec6-aa5d-27bb81c147be",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c99ddba6-56b9-45e0-af75-0422fcec99ec",
   "metadata": {},
   "source": [
    "### Combining the datasets GBR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "be202a1a-8116-4f39-abc2-d57b6e7192da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     year  anomaly_norm source\n",
      "536  2020      0.908114  model\n",
      "537  2021      0.808614  model\n",
      "538  2022      1.000000  model\n",
      "539  2023      0.985433  model\n",
      "540  2024      0.956353  model\n"
     ]
    }
   ],
   "source": [
    "# Your arrays\n",
    "years_hist = np.arange(1659, 2025)  # 1709–2024\n",
    "years_model = np.arange(1850, 2025) # 1850–2024\n",
    "hist_anom = temps_anomaly      # shape (316,)\n",
    "model_anom = temp          # shape (175,)\n",
    "\n",
    "# Combine the values for normalization\n",
    "combined_values = np.concatenate([hist_anom, model_anom])\n",
    "combined_norm = (combined_values - combined_values.min()) / (combined_values.max() - combined_values.min())\n",
    "\n",
    "# Source labels\n",
    "source_labels = ['historical'] * len(hist_anom) + ['model'] * len(model_anom)\n",
    "combined_years = np.concatenate([years_hist, years_model])\n",
    "\n",
    "# Build DataFrame\n",
    "df_combined = pd.DataFrame({\n",
    "    'year': combined_years,\n",
    "    'anomaly_norm': combined_norm,\n",
    "    'source': source_labels\n",
    "})\n",
    "\n",
    "# Now you can filter separately if needed\n",
    "df_hist = df_combined[df_combined['source']=='historical']\n",
    "df_model = df_combined[df_combined['source']=='model']\n",
    "\n",
    "print(df_combined.tail())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "82df3298-0969-46e7-8eec-159cf67b3287",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(16, 4))\n",
    "\n",
    "# ------------------------\n",
    "# Left: Warming stripes (75% width)\n",
    "# ------------------------\n",
    "ax_stripes = fig.add_axes([0.05, 0.1, 0.68, 0.8])  # [left, bottom, width, height]\n",
    "\n",
    "years = np.arange(1659, 2025)\n",
    "model_vals = df_model.set_index(\"year\").reindex(years)['anomaly_norm'].values\n",
    "hist_vals = df_hist.set_index(\"year\").reindex(years)['anomaly_norm'].values\n",
    "# Prepare data: top row = model, bottom row = historical\n",
    "data = np.vstack([model_vals, hist_vals])  # model first, historical second\n",
    "\n",
    "\n",
    "years = np.arange(1659, 2025)  # or whatever year range your data has\n",
    "x_edges = np.arange(years[0], years[-1] + 2)  # +1 to get 317 edges for 316 columns\n",
    "\n",
    "# pcolormesh with y_edges from 0–2 (0–1 bottom row, 1–2 top row)\n",
    "y_edges = [0, 1, 2]  # bottom row = historical, top row = model\n",
    "\n",
    "# Flip rows so model is on top\n",
    "data_flipped = data[::-1, :]  # model on top, historical below\n",
    "# Swap the rows so model is on top\n",
    "data_flipped = data[::-1, :]  # reverse rows\n",
    "\n",
    "#ax_stripes.pcolormesh(x_edges, y_edges, data_flipped, cmap='RdBu_r', edgecolors='face')\n",
    "ax_stripes.pcolormesh(x_edges, y_edges, data_flipped, cmap='RdBu_r', edgecolors='face')\n",
    "\n",
    "\n",
    "ax_stripes.set_yticks([0.5, 1.5])\n",
    "ax_stripes.set_yticklabels([\"Historical\", \"Model\"])  # labels match flipped rows\n",
    "ax_stripes.set_xlim(1659, 2024)\n",
    "ax_stripes.set_ylim(0,2)\n",
    "ax_stripes.set_xticks(np.linspace(1660, 2020, 7))\n",
    "ax_stripes.set_title(\"Warming Stripes: Central England\")\n",
    "\n",
    "# ------------------------\n",
    "# Right: Scatter plot (25% width)\n",
    "# ------------------------\n",
    "ax_scatter = fig.add_axes([0.78, 0.1, 0.2, 0.8])  # [left, bottom, width, height]\n",
    "\n",
    "overlap_years = sorted(set(df_hist['year']).intersection(df_model['year']))\n",
    "hist_overlap = df_hist.set_index(\"year\").loc[overlap_years, \"anomaly_norm\"]\n",
    "model_overlap = df_model.set_index(\"year\").loc[overlap_years, \"anomaly_norm\"]\n",
    "\n",
    "ax_scatter.scatter(hist_overlap, model_overlap, alpha=0.7)\n",
    "ax_scatter.plot([hist_overlap.min(), hist_overlap.max()],\n",
    "                [hist_overlap.min(), hist_overlap.max()],\n",
    "                'r--', label=\"1:1 line\")\n",
    "\n",
    "m, b = np.polyfit(hist_overlap, model_overlap, 1)\n",
    "x_vals = np.linspace(hist_overlap.min(), hist_overlap.max(), 100)\n",
    "ax_scatter.plot(x_vals, m*x_vals + b, 'b-', label=f\"Fit: y={m:.2f}x+{b:.2f}\")\n",
    "\n",
    "rmse = np.sqrt(mean_squared_error(hist_overlap, model_overlap))\n",
    "res_std = np.std(hist_overlap.values - model_overlap.values)\n",
    "ax_scatter.set_title(f\"Obs vs Model [1850-2024]\\nRMSE={rmse:.3f}°C, σ={res_std:.3f}°C\")\n",
    "ax_scatter.set_xlabel(\"Observed (°C)\")\n",
    "ax_scatter.set_ylabel(\"Model (°C)\")\n",
    "ax_scatter.legend()\n",
    "ax_scatter.grid(True)\n",
    "\n",
    "fig.savefig('CET_Stripes.png', dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "721e31c4-b842-4e6b-9a9f-4165c358dbbf",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (geo_env_20250322)",
   "language": "python",
   "name": "geo_env_20250322"
  },
  "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.10.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
No results found