From ea892199d1c24d8ca41773c5c838d357592a8182 Mon Sep 17 00:00:00 2001
From: tobin-ford <tford@nrel.gov>
Date: Fri, 7 Feb 2025 11:16:30 -0700
Subject: [PATCH] verification

---
 pvdeg/chamber.py                          |  28 +-
 testing-setpoints/mike-verification.ipynb | 597 ++++++++++++++++++++++
 testing-setpoints/standards_testing.ipynb | 118 +++--
 3 files changed, 694 insertions(+), 49 deletions(-)
 create mode 100644 testing-setpoints/mike-verification.ipynb

diff --git a/pvdeg/chamber.py b/pvdeg/chamber.py
index b3ca40d..c6d467a 100644
--- a/pvdeg/chamber.py
+++ b/pvdeg/chamber.py
@@ -336,7 +336,7 @@ def _temp_calc_no_irradiance(
 
     for i in range(0, temps.shape[0] - 1):
         delta_t = times[i + 1] - times[i]
-        delta_t = delta_t.astype("timedelta64[m]").astype(int)
+        delta_t = delta_t.astype("timedelta64[m]").astype(float) # this was init previously, probably fine because we were using constant 1 min timesteps for this case but should be float
 
         res[i + 1] = fdm_temperature(
             t_current=res[i],
@@ -385,18 +385,34 @@ def _temp_calc_irradiance(
 
 
 # calculate the air temperature in a chamber using finite difference method
+# REDO THESE TO USE REDUCE DUPLICATE CODE
 def air_temperature(
-    setpoints_df: pd.DataFrame, tau_c: float, air_temp_0: float
+    setpoints_df: pd.DataFrame, tau_c_air: float, air_temp_0: float
 ) -> np.ndarray:
     air_temp = _temp_calc_no_irradiance(
         temps=setpoints_df["setpoint_temperature"].to_numpy(),
-        times=setpoints_df.index.to_numpy(),
-        tau=tau_c,
+        times=setpoints_df.index.to_numpy(dtype="timedelta64[ns]"),
+        tau=tau_c_air,
         temp_0=air_temp_0,
     )
 
     return pd.Series(air_temp, index=setpoints_df.index, name="Air Temperature")
 
+# COMBINE WITH ABOVE
+def chamber_rh(
+    setpoints_df: pd.DataFrame, tau_c_rh: float, rh_0: float
+) -> np.ndarray:
+    air_temp = _temp_calc_no_irradiance(
+        temps=setpoints_df["setpoint_relative_humidity"].to_numpy(),
+        times=setpoints_df.index.to_numpy(dtype="timedelta64[ns]"),
+        tau=tau_c_rh,
+        temp_0=rh_0,
+    )
+
+    return pd.Series(air_temp, index=setpoints_df.index, name="Relative Humidity")
+
+
+
 
 def sample_temperature(
     setpoints_df: pd.DataFrame,
@@ -663,7 +679,7 @@ def calc_temperatures(
             pandas series of sample temperatures inside of test chamber [C]
         """
         self.air_temperature = air_temperature(
-            self.setpoints, tau_c=tau_c, air_temp_0=air_temp_0
+            self.setpoints, tau_c_air=tau_c, air_temp_0=air_temp_0
         )
 
         if (
@@ -804,7 +820,7 @@ def chamber_conditions(self, tau_c: float, air_temp_0: float) -> pd.DataFrame:
         """
 
         self.air_temperature = air_temperature(
-            self.setpoints, tau_c=tau_c, air_temp_0=air_temp_0
+            self.setpoints, tau_c_air=tau_c, air_temp_0=air_temp_0
         )
         self.calc_water_vapor_pressure()
         self.calc_dew_point()
diff --git a/testing-setpoints/mike-verification.ipynb b/testing-setpoints/mike-verification.ipynb
new file mode 100644
index 0000000..7f47ddc
--- /dev/null
+++ b/testing-setpoints/mike-verification.ipynb
@@ -0,0 +1,597 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "from numba import njit\n",
+    "import numpy as np\n",
+    "\n",
+    "import pvdeg"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "new temperature with irradiance function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def fdm_temperature_irradiance_heat_rate(\n",
+    "    t_current: float, \n",
+    "    t_set: float, \n",
+    "    irrad_full_set: float,\n",
+    "    delta_time: float, \n",
+    "    tau_s_temp: float, \n",
+    "    heat_per_1000w: float\n",
+    ") -> float:\n",
+    "\n",
+    "    t_next = t_current + ( t_set + heat_per_1000w / 1000 * irrad_full_set - t_current) * (1 - np.exp( -delta_time / tau_s_temp) )\n",
+    "\n",
+    "    return t_next\n",
+    "\n",
+    "def sample_temp_with_irradiance(\n",
+    "    temps_sets: np.ndarray,\n",
+    "    irradiances_sets: np.ndarray,\n",
+    "    times: np.ndarray,\n",
+    "    tau_s_temp: float,\n",
+    "    sample_temp_0: float,\n",
+    "    heat_per_1000w: float,\n",
+    ") -> np.ndarray:\n",
+    "    res = np.empty_like(temps_sets)\n",
+    "    res[0] = (\n",
+    "        sample_temp_0     # initial irradiance has no effect on intial temperature because it is at an instant so the accumulated irradiance (integral of G = 0)\n",
+    "    )\n",
+    "\n",
+    "    for i in range(0, temps_sets.shape[0] - 1):\n",
+    "        delta_t = times[i + 1] - times[i]\n",
+    "        delta_t = delta_t.astype(\"timedelta64[m]\").astype(float)\n",
+    "\n",
+    "        res[i + 1] = fdm_temperature_irradiance_heat_rate(\n",
+    "            t_current=res[i],\n",
+    "            t_set=temps_sets[i + 1],\n",
+    "            irrad_full_set=irradiances_sets[i + 1],\n",
+    "            delta_time=delta_t,\n",
+    "            tau_s_temp=tau_s_temp, \n",
+    "            heat_per_1000w=heat_per_1000w\n",
+    "        )\n",
+    "\n",
+    "    return res\n",
+    "\n",
+    "def sample_relative_humidity(chamber_temp, chamber_humidity, sample_temp):\n",
+    "\n",
+    "    # we proabbly want to rewrite the psat with numba\n",
+    "    psat_chamber = pvdeg.humidity.psat(chamber_temp, average=False)\n",
+    "    psat_sample = pvdeg.humidity.psat(sample_temp, average=False)\n",
+    "\n",
+    "    rh_ratio = (psat_chamber * chamber_humidity / 100) / psat_sample\n",
+    "\n",
+    "    # may be better to mask and replace\n",
+    "    return np.minimum(rh_ratio * 100, 100)\n",
+    "\n",
+    "# # @njit\n",
+    "# def calc_degradation_excel(\n",
+    "#     deg_prev,\n",
+    "#     time_delta,\n",
+    "#     sample_rh_curr,\n",
+    "#     sample_temp_curr,\n",
+    "#     irradiance_curr,\n",
+    "#     n,\n",
+    "#     p,\n",
+    "#     ea,\n",
+    "# ) -> float:\n",
+    "#     \"\"\"latex equation shown later in notebook\"\"\"\n",
+    "\n",
+    "#     # backwards difference\n",
+    "#     # formula above uses forwards difference\n",
+    "#     # mikes formula uses hours so i tried that but the rate still blows up\n",
+    "#     deg = deg_prev - time_delta / 60 * (sample_rh_curr ** n) * np.exp( -ea / (0.008314426 * sample_temp_curr + 273.15)) * ((irradiance_curr / 1000) ** p)\n",
+    "#     return deg\n",
+    "\n",
+    "# def degradation_excel(\n",
+    "#     sample_temps: np.ndarray,\n",
+    "#     sample_rhs: np.ndarray,\n",
+    "#     irradiances_sets: np.ndarray,\n",
+    "#     times: np.ndarray,\n",
+    "# ) -> np.ndarray:\n",
+    "#     res = np.zeros((len(sample_temps),))\n",
+    "\n",
+    "#     for i in range(1, sample_temps.shape[0] - 1):\n",
+    "#         delta_t = times[i] - times[i - 1]\n",
+    "#         delta_t = delta_t.astype(\"timedelta64[m]\").astype(float) # why does this need to be in hours instead of minutes\n",
+    "\n",
+    "#         res[i] = calc_degradation_excel(\n",
+    "#             deg_prev=res[i - 1],\n",
+    "#             time_delta=delta_t,\n",
+    "#             sample_temp_curr=sample_temps[i],\n",
+    "#             sample_rh_curr=sample_rhs[i],\n",
+    "#             irradiance_curr=irradiances_sets[i],\n",
+    "#             n=0,        # humidity dependence\n",
+    "#             p=0.5,      # irradiance dependence\n",
+    "#             ea=38.7,    # kJ/mol\n",
+    "#         )\n",
+    "\n",
+    "#     return pd.Series(data=res, index=times)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mike_data = pd.read_csv(r\"C:\\Users\\tford\\Documents\\mike-chamber.csv\", index_col=0)\n",
+    "mike_data.index = pd.TimedeltaIndex(mike_data.index) + pd.Timestamp(0) # this should be added to the class\n",
+    "\n",
+    "mike_setpoints = mike_data[[\"setpoint_temperature\",\t\"setpoint_relative_humidity\",\"setpoint_irradiance_full\"]]\n",
+    "mike_setpoints = mike_setpoints.astype(float) # set to floats, we dont want people to have to do this\n",
+    "\n",
+    "# mike_data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Testing if chamber temperatures and humidity make sense. These are the same as I belive they should be. Errors can likely be accounted for by floating point error and or internal representation differences."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "count    7.242000e+04\n",
+       "mean     7.595481e-11\n",
+       "std      1.995538e-09\n",
+       "min     -5.225491e-09\n",
+       "25%     -2.285958e-10\n",
+       "50%     -7.105427e-14\n",
+       "75%      3.369536e-10\n",
+       "max      5.472494e-09\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tobin_air_temp = pvdeg.chamber.air_temperature(\n",
+    "    setpoints_df=mike_setpoints,\n",
+    "    tau_c_air=10,\n",
+    "    air_temp_0=25,\n",
+    ")\n",
+    "\n",
+    "(tobin_air_temp - mike_data[\"Chamber Temperature (°C)\"]).describe()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "count    7.242000e+04\n",
+       "mean     6.905479e-13\n",
+       "std      1.288723e-09\n",
+       "min     -4.996252e-09\n",
+       "25%     -1.421085e-13\n",
+       "50%      3.552714e-14\n",
+       "75%      3.552714e-14\n",
+       "max      4.996480e-09\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# we are going to brutalize the air_temperature function by using it to calculate chamber relative humidity \n",
+    "# this is a new function that i wrote for this, adapted 1d-fdm from temperature_fdm \n",
+    "tobin_chamber_rh = pvdeg.chamber.chamber_rh(\n",
+    "    setpoints_df=mike_setpoints,\n",
+    "    tau_c_rh=20,\n",
+    "    rh_0=50\n",
+    ")\n",
+    "    \n",
+    "(tobin_chamber_rh - mike_data[\"Chamber Humidity (%)\"]).describe()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "sample tempeature issues?  \n",
+    "- prev, calculating with surface area and absorptance. Does not need to be this complicated. Can use temp increase per 1000W for a single point as a good approximation.\n",
+    "\n",
+    "old function with the issues:  \n",
+    "``pvdeg.chamber._temp_calc_irradiance()``\n",
+    "\n",
+    "New function expresses the logic from the excel and is much simpler. It is implemented at the top of this notebook.  Once again, numerical errors are negligable and can likely be attributed to floating point error or internal representation differences. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "count    7.242000e+04\n",
+       "mean    -2.666197e-10\n",
+       "std      1.250634e-08\n",
+       "min     -4.992886e-08\n",
+       "25%     -8.691714e-10\n",
+       "50%     -7.105427e-14\n",
+       "75%      3.637746e-10\n",
+       "max      4.991381e-08\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sample_temp = sample_temp_with_irradiance(\n",
+    "    temps_sets=mike_setpoints['setpoint_temperature'].values,\n",
+    "    irradiances_sets=mike_setpoints['setpoint_irradiance_full'].values,\n",
+    "    times=mike_setpoints.index.values,\n",
+    "    tau_s_temp=10, # I think the excel sheet is using the wrong value for this, so i used the same value here but it shoiuld be the sample temperature equilibriation time\n",
+    "    heat_per_1000w=25, # C/1000W\n",
+    "    sample_temp_0=25 # C\n",
+    ")\n",
+    "\n",
+    "tobin_sample_temp = pd.Series(data=sample_temp, index = mike_setpoints.index)\n",
+    "\n",
+    "(tobin_sample_temp - mike_data[\"Sample Temperature (°C)\"]).describe()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "count    7.242000e+04\n",
+       "mean     6.801728e-10\n",
+       "std      1.929224e-09\n",
+       "min     -4.995961e-09\n",
+       "25%     -2.370228e-10\n",
+       "50%      5.202674e-10\n",
+       "75%      2.049838e-09\n",
+       "max      4.998608e-09\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tobin_sample_rh = sample_relative_humidity(\n",
+    "    chamber_temp=tobin_air_temp,\n",
+    "    chamber_humidity=tobin_chamber_rh,\n",
+    "    sample_temp=tobin_sample_temp\n",
+    ")\n",
+    "\n",
+    "(tobin_sample_rh - mike_data[\"Sample surface humidity (%)\"]).describe()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$D_t = D_{t-1} - \\left( \\frac{T_{t+1} - T_{t-1}}{2} \\right) \\cdot RH_t^n \\cdot \\exp\\left(\\frac{-E_a}{R(T_t + 273.15)}\\right) \\cdot \\left(\\frac{I_t}{1000}\\right)^p$\n",
+    "\n",
+    "degradation from spreadsheet. this takes into account irradiance but is not a spectral degradation formula.  \n",
+    "notably uses central difference approximation instead of forward or backward difference. should all of the finite difference method implementations use central difference or some other differencing scheme."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# gets us hours since start\n",
+    "# i really dont like the way this is working\n",
+    "# this function isnt working so we will use the ones below\n",
+    "hour_times = (mike_setpoints.index.values.astype(\"timedelta64[ns]\") / (1e9)).astype(float)  / 3600\n",
+    "\n",
+    "# tobin_deg = degradation_excel(\n",
+    "#     sample_temps=tobin_sample_temp.values,\n",
+    "#     sample_rhs=tobin_sample_rh.values,\n",
+    "#     irradiances_sets=mike_setpoints['setpoint_irradiance_full'].values,\n",
+    "#     times=hour_times # times in hours since start\n",
+    "# )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "center differencing scheme. last timestep will be skipped. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\tford\\AppData\\Local\\Temp\\1\\ipykernel_7808\\1155960470.py:15: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
+      "  deg[i] = deg[i-1] - ((hour_times[i + 1] - hour_times[i - 1]) / 2) * (tobin_sample_rh[i] ** n) * np.exp(-ea / (0.008314426 * (273.15 + sample_temp[i]))) * ((irradance_sets[i] / 1000) ** p)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# this is a terrible way to do it\n",
+    "# why does it need to be in units of hours?\n",
+    "hour_times = (mike_setpoints.index.values.astype(\"timedelta64[ns]\") / (1e9)).astype(float)  / 3600\n",
+    "\n",
+    "n = 0\n",
+    "p = 0.5\n",
+    "ea = 38.7\n",
+    "\n",
+    "irradance_sets = mike_setpoints[\"setpoint_irradiance_full\"].values\n",
+    "\n",
+    "deg = np.zeros((len(hour_times),))\n",
+    "\n",
+    "for i in range(1, len(hour_times) - 1):\n",
+    "\n",
+    "    deg[i] = deg[i-1] - ((hour_times[i + 1] - hour_times[i - 1]) / 2) * (tobin_sample_rh[i] ** n) * np.exp(-ea / (0.008314426 * (273.15 + sample_temp[i]))) * ((irradance_sets[i] / 1000) ** p)\n",
+    "\n",
+    "deg = pd.Series(data=deg, index=mike_setpoints.index)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1970-01-01 00:00:00    0.000000e+00\n",
+       "1970-01-01 00:01:00   -5.670743e-09\n",
+       "1970-01-01 00:02:00   -1.423158e-08\n",
+       "1970-01-01 00:03:00   -2.642647e-08\n",
+       "1970-01-01 00:04:00   -4.298361e-08\n",
+       "                           ...     \n",
+       "1970-02-20 06:55:00   -8.130101e-03\n",
+       "1970-02-20 06:56:00   -8.130102e-03\n",
+       "1970-02-20 06:57:00   -8.130102e-03\n",
+       "1970-02-20 06:58:00   -8.130102e-03\n",
+       "1970-02-20 06:59:00    0.000000e+00\n",
+       "Length: 72420, dtype: float64"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# we can see that the last value is skipped, can use different differencing\n",
+    "deg"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "backward differencing, this shouldn't change the result because all timesteps are the same"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\tford\\AppData\\Local\\Temp\\1\\ipykernel_7808\\2884395853.py:11: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
+      "  deg[i] = deg[i-1] - (hour_times[i] - hour_times[i - 1]) * (tobin_sample_rh[i] ** n) * np.exp(-ea / (0.008314426 * (273.15 + sample_temp[i]))) * ((irradance_sets[i] / 1000) ** p)\n"
+     ]
+    }
+   ],
+   "source": [
+    "n = 0\n",
+    "p = 0.5\n",
+    "ea = 38.7\n",
+    "\n",
+    "irradance_sets = mike_setpoints[\"setpoint_irradiance_full\"].values\n",
+    "\n",
+    "deg = np.zeros((len(hour_times),))\n",
+    "\n",
+    "for i in range(1, len(hour_times)):\n",
+    "\n",
+    "    deg[i] = deg[i-1] - (hour_times[i] - hour_times[i - 1]) * (tobin_sample_rh[i] ** n) * np.exp(-ea / (0.008314426 * (273.15 + sample_temp[i]))) * ((irradance_sets[i] / 1000) ** p)\n",
+    "\n",
+    "deg = pd.Series(data=deg, index=mike_setpoints.index)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1970-01-01 00:00:00    0.000000e+00\n",
+       "1970-01-01 00:01:00   -5.670743e-09\n",
+       "1970-01-01 00:02:00   -1.423158e-08\n",
+       "1970-01-01 00:03:00   -2.642647e-08\n",
+       "1970-01-01 00:04:00   -4.298361e-08\n",
+       "                           ...     \n",
+       "1970-02-20 06:55:00   -8.130101e-03\n",
+       "1970-02-20 06:56:00   -8.130102e-03\n",
+       "1970-02-20 06:57:00   -8.130102e-03\n",
+       "1970-02-20 06:58:00   -8.130102e-03\n",
+       "1970-02-20 06:59:00   -8.130103e-03\n",
+       "Length: 72420, dtype: float64"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "deg"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: >"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# they are very similar result wise\n",
+    "mike_data[\"D (%)\"].plot()\n",
+    "deg.plot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\tford\\AppData\\Local\\Temp\\1\\ipykernel_7808\\3320530468.py:12: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
+      "  deg[i] = deg[i-1] - ((ns_times[i] - ns_times[i - 1]).astype(\"float\") / 1e9 / 3600) * (tobin_sample_rh[i] ** n) * np.exp(-ea / (0.008314426 * (273.15 + sample_temp[i]))) * ((irradance_sets[i] / 1000) ** p)\n"
+     ]
+    }
+   ],
+   "source": [
+    "n = 0\n",
+    "p = 0.5\n",
+    "ea = 38.7\n",
+    "\n",
+    "irradance_sets = mike_setpoints[\"setpoint_irradiance_full\"].values\n",
+    "ns_times = mike_setpoints.index.values\n",
+    "\n",
+    "deg = np.zeros((len(hour_times),))\n",
+    "\n",
+    "for i in range(1, len(hour_times)):\n",
+    "\n",
+    "    # alternatively we convert to hours inside the function, why does time unit need to be in hours?\n",
+    "    deg[i] = deg[i-1] - ((ns_times[i] - ns_times[i - 1]).astype(\"float\") / 1e9 / 3600) * (tobin_sample_rh[i] ** n) * np.exp(-ea / (0.008314426 * (273.15 + sample_temp[i]))) * ((irradance_sets[i] / 1000) ** p)\n",
+    "\n",
+    "deg = pd.Series(data=deg, index=mike_setpoints.index)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\tford\\AppData\\Local\\Temp\\1\\ipykernel_7808\\2881138796.py:1: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
+      "  deg[-1] / ((ns_times[-1] - ns_times[0]).astype(\"float\") / 1e9 / 3600)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "-6.735886974928249e-06"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# degradation rate percent per hour\n",
+    "deg[-1] / ((ns_times[-1] - ns_times[0]).astype(\"float\") / 1e9 / 3600)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "deg",
+   "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.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/testing-setpoints/standards_testing.ipynb b/testing-setpoints/standards_testing.ipynb
index 87255f8..02c77a4 100644
--- a/testing-setpoints/standards_testing.ipynb
+++ b/testing-setpoints/standards_testing.ipynb
@@ -2,15 +2,22 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "import matplotlib.pyplot as plt\n",
-    "import pvdeg\n",
-    "from pvlib import spectrum, solarposition, irradiance, atmosphere\n",
     "import pandas as pd\n",
-    "import os"
+    "import os\n",
+    "\n",
+    "from pvlib import (\n",
+    "    spectrum, \n",
+    "    solarposition, \n",
+    "    irradiance, \n",
+    "    atmosphere\n",
+    ")\n",
+    "\n",
+    "import pvdeg"
    ]
   },
   {
@@ -39,7 +46,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -50,7 +57,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -192,7 +199,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -221,7 +228,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -236,7 +243,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -281,7 +288,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -296,7 +303,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -343,7 +350,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -358,7 +365,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -409,7 +416,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
@@ -452,7 +459,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -470,7 +477,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
@@ -612,16 +619,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x167e4027b20>"
+       "<matplotlib.legend.Legend at 0x2af6ff4d940>"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -669,7 +676,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -687,7 +694,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
@@ -716,7 +723,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
@@ -847,7 +854,7 @@
        "[72420 rows x 3 columns]"
       ]
      },
-     "execution_count": 17,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -880,7 +887,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
@@ -889,7 +896,7 @@
        "<Axes: title={'center': 'rh setpoints : contain nans'}>"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -911,7 +918,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
@@ -920,7 +927,7 @@
        "<Axes: title={'center': 'rh setpoints : nans fixed'}>"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -946,7 +953,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -964,7 +971,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
@@ -984,26 +991,35 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [],
    "source": [
     "chamber_63556.calc_temperatures(\n",
     "    air_temp_0=chamber_63556.setpoints[\"setpoint_temperature\"].iloc[0],\n",
     "    sample_temp_0=chamber_63556.setpoints[\"setpoint_temperature\"].iloc[0],\n",
-    "    tau_c=15,\n",
-    "    tau_s=10\n",
+    "    tau_c=10, # chamber temperature equilibriation time\n",
+    "    tau_s=15, # sample temperature equilibriation time\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chamber_63556.air_temperature.to_csv(\"standards-testing-air-temps.csv\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -1018,7 +1034,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tobin_chamber = chamber_63556.chamber_conditions(\n",
+    "    tau_c=15, \n",
+    "    air_temp_0=chamber_63556.setpoints[\"setpoint_temperature\"].iloc[0]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
    "metadata": {},
    "outputs": [
     {
@@ -1198,21 +1226,18 @@
        "[72420 rows x 6 columns]"
       ]
      },
-     "execution_count": 24,
+     "execution_count": 27,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "chamber_63556.chamber_conditions(\n",
-    "    tau_c=15, \n",
-    "    air_temp_0=chamber_63556.setpoints[\"setpoint_temperature\"].iloc[0]\n",
-    ")"
+    "tobin_chamber"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1224,7 +1249,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [
     {
@@ -1392,7 +1417,7 @@
        "[72420 rows x 5 columns]"
       ]
      },
-     "execution_count": 26,
+     "execution_count": 31,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2426,6 +2451,13 @@
     "\n",
     "af"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {