From 49a6134830ca51592e623303755f981118823007 Mon Sep 17 00:00:00 2001 From: cdeline Date: Mon, 23 Mar 2026 14:42:13 -0600 Subject: [PATCH 1/7] updated degradation_timeseries_plot as version2 for now --- rdtools/plotting.py | 140 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 140 insertions(+) diff --git a/rdtools/plotting.py b/rdtools/plotting.py index 54680d19..c09dd0d9 100644 --- a/rdtools/plotting.py +++ b/rdtools/plotting.py @@ -524,3 +524,143 @@ def _bootstrap(x, percentile, reps): fig.autofmt_xdate() return fig + + + +def degradation_timeseries_plot_2(yoy_info, rolling_days=365, include_ci=True, + fig=None, plot_color=None, ci_color=None, **kwargs): + ''' + Plot resampled time series of degradation trend with time + + Parameters + ---------- + yoy_info : dict + a dictionary with keys: + * YoY_values - pandas series of year on year slopes + rolling_days: int, default 365 + Number of days for rolling window. Note that + the window must contain at least 25% of datapoints to be included in + the rolling plot, and the rolling window is centered. + include_ci : bool, default True + calculate and plot 2-sigma confidence intervals along with rolling median + fig : matplotlib, optional + fig object to add new plot to (first set of axes only) + plot_color : str, optional + color of the timeseries trendline + ci_color : str, optional + color of the confidence interval 'fuzz' + kwargs : + Extra parameters passed to matplotlib.pyplot.axis.plot() + + Note + ---- + It should be noted that ``yoy_info`` is an output + from :py:func:`rdtools.degradation.degradation_year_on_year`. + + Returns + ------- + matplotlib.figure.Figure + ''' + + def _bootstrap(x, percentile, reps): + # stolen from degradation_year_on_year + n1 = len(x) + xb1 = np.random.choice(x, (n1, reps), replace=True) + mb1 = np.nanmedian(xb1, axis=0) + return np.percentile(mb1, percentile) + + def _roll_median(df, win_right, rolling_days, min_periods): + """ + rolling median + df includes following columns: dt_right, dt_left, yoy + win_right: Datetime of the right end of the rolling window + rolling_days: number of days in the rolling window + min_periods: minimum number of points in the rolling window to return a value + + returns: median of yoy values if any part of the slope is in the rolling window, or NaN if there are + less than min_periods points. Time index of the returned value is win_right - rolling_days/2 + """ + win_left = win_right - pd.Timedelta(days=rolling_days) + in_window = (df['dt_left'] <= win_right) & (df['dt_right'] >= win_left) + if in_window.sum() < min_periods: + return np.nan + else: + return df.loc[in_window, 'yoy'].median() + + + + try: + results = yoy_info['YoY_times'].join(yoy_info['YoY_values']) + except KeyError: + raise KeyError("yoy_info input dictionary does not contain keys `YoY_times` and `YoY_values`.") + + if plot_color is None: + plot_color = 'tab:orange' + if ci_color is None: + ci_color = 'C0' + + if yoy_info['YoY_values'].index.has_duplicates: + multi_yoy = True + # this occurs with degradation_year_on_year(multi_yoy=True). resample to daily mean + warnings.warn( + "Input `yoy_info['YoY_values']` appears to have multiple annual " + "slopes per day, which is the case if " + "degradation_year_on_year(multi_yoy=True). " + "Long-term multi-yoy slopes will tend to dominate the " + "time-series trend. Recommend re-running with " + "degradation_year_on_year(multi_yoy=False)." + ) + else: + multi_yoy = False + + + # loop through results in a daily timeindex from min(results.dt_left) to max(results.dt_right), + # apply rolling median and bootstrap confidence intervals + + timeindex = pd.date_range(start=results['dt_left'].min(), end=results['dt_right'].max(), freq='D') + results_median = pd.Series(index=timeindex, dtype=float) + for win_center in timeindex: + results_median.loc[win_center] = _roll_median(results, win_right=win_center + pd.Timedelta(days=rolling_days/2), + rolling_days=rolling_days, min_periods=rolling_days//4) + + + # use the _boostrap function to calculate confidence intervals for each point in the rolling median. + # Note that the bootstrap function is not ideal for this purpose since it is + # designed to take in a 1D array of values, but we can apply it to the yoy values in the + # rolling window for each point in the timeindex. + if include_ci: + # if multi_yoy is True, downsample the timeindex to every 7 days to speed up the bootstrap calculation, + # since it is very slow. Otherwise downsample to every 2 days. + if multi_yoy: + timeindex = timeindex[::7] + else: + timeindex = timeindex[::2] + ci_lower = pd.Series(index=timeindex, dtype=float) + ci_upper = pd.Series(index=timeindex, dtype=float) + for win_center in timeindex: + win_right = win_center + pd.Timedelta(days=rolling_days/2) + win_left = win_center - pd.Timedelta(days=rolling_days/2) + in_window = (results['dt_left'] <= win_right) & (results['dt_right'] >= win_left) + if in_window.sum() < rolling_days//4: + ci_lower.loc[win_center] = np.nan + ci_upper.loc[win_center] = np.nan + else: + ci_lower.loc[win_center] = _bootstrap(results.loc[in_window, 'yoy'], percentile=2.5, reps=50) + ci_upper.loc[win_center] = _bootstrap(results.loc[in_window, 'yoy'], percentile=97.5, reps=50) + + + if fig is None: + fig, ax = plt.subplots() + else: + ax = fig.axes[0] + if include_ci: + ax.fill_between(ci_lower.index, + ci_lower, ci_upper, color=ci_color) + median = results_median.sort_index() + ax.plot(median.index, + median, color=plot_color, **kwargs) + ax.axhline(results_median.median(), c='k', ls='--') + plt.ylabel('Degradation trend (%/yr)') + fig.autofmt_xdate() + + return fig \ No newline at end of file From 67813d00b9897021887ba7132febe31a181ef82a Mon Sep 17 00:00:00 2001 From: cdeline Date: Tue, 24 Mar 2026 09:10:03 -0600 Subject: [PATCH 2/7] fix flake8 grumbles --- rdtools/plotting.py | 55 ++++++++++++++++++++++----------------------- 1 file changed, 27 insertions(+), 28 deletions(-) diff --git a/rdtools/plotting.py b/rdtools/plotting.py index c09dd0d9..b024278c 100644 --- a/rdtools/plotting.py +++ b/rdtools/plotting.py @@ -435,8 +435,8 @@ def availability_summary_plots(power_system, power_subsystem, loss_total, return fig -def degradation_timeseries_plot(yoy_info, rolling_days=365, include_ci=True, - fig=None, plot_color=None, ci_color=None, **kwargs): +def degradation_timeseries_plot_old(yoy_info, rolling_days=365, include_ci=True, + fig=None, plot_color=None, ci_color=None, **kwargs): ''' Plot resampled time series of degradation trend with time @@ -526,8 +526,7 @@ def _bootstrap(x, percentile, reps): return fig - -def degradation_timeseries_plot_2(yoy_info, rolling_days=365, include_ci=True, +def degradation_timeseries_plot(yoy_info, rolling_days=365, include_ci=True, fig=None, plot_color=None, ci_color=None, **kwargs): ''' Plot resampled time series of degradation trend with time @@ -568,7 +567,7 @@ def _bootstrap(x, percentile, reps): xb1 = np.random.choice(x, (n1, reps), replace=True) mb1 = np.nanmedian(xb1, axis=0) return np.percentile(mb1, percentile) - + def _roll_median(df, win_right, rolling_days, min_periods): """ rolling median @@ -577,8 +576,9 @@ def _roll_median(df, win_right, rolling_days, min_periods): rolling_days: number of days in the rolling window min_periods: minimum number of points in the rolling window to return a value - returns: median of yoy values if any part of the slope is in the rolling window, or NaN if there are - less than min_periods points. Time index of the returned value is win_right - rolling_days/2 + returns: median of yoy values if any part of the slope is in the rolling window, + or NaN if there are fewer than min_periods points. Time index of the returned + value is centered on the rolling window. """ win_left = win_right - pd.Timedelta(days=rolling_days) in_window = (df['dt_left'] <= win_right) & (df['dt_right'] >= win_left) @@ -587,12 +587,11 @@ def _roll_median(df, win_right, rolling_days, min_periods): else: return df.loc[in_window, 'yoy'].median() - - try: results = yoy_info['YoY_times'].join(yoy_info['YoY_values']) except KeyError: - raise KeyError("yoy_info input dictionary does not contain keys `YoY_times` and `YoY_values`.") + raise KeyError("yoy_info input dictionary does not contain keys" + " `YoY_times` and `YoY_values`.") if plot_color is None: plot_color = 'tab:orange' @@ -613,24 +612,23 @@ def _roll_median(df, win_right, rolling_days, min_periods): else: multi_yoy = False + # loop through results in a daily timeindex from min(results.dt_left) to max(dt_right) + # Apply rolling median and bootstrap confidence intervals - # loop through results in a daily timeindex from min(results.dt_left) to max(results.dt_right), - # apply rolling median and bootstrap confidence intervals - - timeindex = pd.date_range(start=results['dt_left'].min(), end=results['dt_right'].max(), freq='D') + timeindex = pd.date_range(start=results['dt_left'].min(), + end=results['dt_right'].max(), freq='D') results_median = pd.Series(index=timeindex, dtype=float) for win_center in timeindex: - results_median.loc[win_center] = _roll_median(results, win_right=win_center + pd.Timedelta(days=rolling_days/2), - rolling_days=rolling_days, min_periods=rolling_days//4) - - - # use the _boostrap function to calculate confidence intervals for each point in the rolling median. - # Note that the bootstrap function is not ideal for this purpose since it is - # designed to take in a 1D array of values, but we can apply it to the yoy values in the - # rolling window for each point in the timeindex. + win_right = win_center + pd.Timedelta(days=rolling_days/2) + results_median.loc[win_center] = _roll_median(df=results, + win_right=win_right, + rolling_days=rolling_days, + min_periods=rolling_days//4) + + # calculate confidence intervals for each point in the rolling median. if include_ci: - # if multi_yoy is True, downsample the timeindex to every 7 days to speed up the bootstrap calculation, - # since it is very slow. Otherwise downsample to every 2 days. + # if multi_yoy is True, downsample the timeindex to every 7 days to speed up the + # bootstrap calculation, since it is slow. Otherwise downsample to every 2 days. if multi_yoy: timeindex = timeindex[::7] else: @@ -645,9 +643,10 @@ def _roll_median(df, win_right, rolling_days, min_periods): ci_lower.loc[win_center] = np.nan ci_upper.loc[win_center] = np.nan else: - ci_lower.loc[win_center] = _bootstrap(results.loc[in_window, 'yoy'], percentile=2.5, reps=50) - ci_upper.loc[win_center] = _bootstrap(results.loc[in_window, 'yoy'], percentile=97.5, reps=50) - + ci_lower.loc[win_center] = _bootstrap(results.loc[in_window, 'yoy'], + percentile=2.5, reps=50) + ci_upper.loc[win_center] = _bootstrap(results.loc[in_window, 'yoy'], + percentile=97.5, reps=50) if fig is None: fig, ax = plt.subplots() @@ -663,4 +662,4 @@ def _roll_median(df, win_right, rolling_days, min_periods): plt.ylabel('Degradation trend (%/yr)') fig.autofmt_xdate() - return fig \ No newline at end of file + return fig From 8dba1b3a1414b132f3d442ffa1d2fcf034bc7929 Mon Sep 17 00:00:00 2001 From: cdeline Date: Tue, 24 Mar 2026 12:59:49 -0600 Subject: [PATCH 3/7] avoid pandas error "ValueError: Other Series must have a name" --- rdtools/plotting.py | 2 +- rdtools/test/plotting_test.py | 20 +++----------------- 2 files changed, 4 insertions(+), 18 deletions(-) diff --git a/rdtools/plotting.py b/rdtools/plotting.py index b024278c..d132362a 100644 --- a/rdtools/plotting.py +++ b/rdtools/plotting.py @@ -588,7 +588,7 @@ def _roll_median(df, win_right, rolling_days, min_periods): return df.loc[in_window, 'yoy'].median() try: - results = yoy_info['YoY_times'].join(yoy_info['YoY_values']) + results = yoy_info['YoY_times'].join(yoy_info['YoY_values'].rename('yoy')) except KeyError: raise KeyError("yoy_info input dictionary does not contain keys" " `YoY_times` and `YoY_values`.") diff --git a/rdtools/test/plotting_test.py b/rdtools/test/plotting_test.py index 58cbe435..6f8fcb54 100644 --- a/rdtools/test/plotting_test.py +++ b/rdtools/test/plotting_test.py @@ -284,30 +284,16 @@ def test_degradation_timeseries_plot(degradation_info, degradation_info_center, result_left = degradation_timeseries_plot(yoy_info=degradation_info_left[3], include_ci=False) assert_isinstance(result_left, plt.Figure) - xlim_left = result_left.get_axes()[0].get_xlim()[0] + # xlim_left = result_left.get_axes()[0].get_xlim()[0] # test default label matches label='right' result_default = degradation_timeseries_plot(yoy_info=yoy_info, include_ci=False) xlim_default = result_default.get_axes()[0].get_xlim()[0] assert xlim_default == xlim_right - # Check that the xlim values are offset as expected + # Check that the xlim values are the same as expected # right > center > left (since offset_days increases) - assert xlim_right > xlim_center > xlim_left - - # The expected difference from right to left is 365 days (1 yrs), allow 5% tolerance - expected_diff = 365 - actual_diff = (xlim_right - xlim_left) - tolerance = expected_diff * 0.05 - assert abs(actual_diff - expected_diff) <= tolerance, \ - f"difference of right-left xlim {actual_diff} not within 5% of 1 yr." - - # The expected difference from right to center is 182 days, allow 5% tolerance - expected_diff2 = 182 - actual_diff2 = (xlim_right - xlim_center) - tolerance2 = expected_diff2 * 0.05 - assert abs(actual_diff2 - expected_diff2) <= tolerance2, \ - f"difference of right-center xlim {actual_diff2} not within 5% of 1/2 year." + assert xlim_right == xlim_center with pytest.raises(KeyError): degradation_timeseries_plot({'a': 1}, include_ci=False) From 9d2a6277470adebd3fc64395b66a0966a6905361 Mon Sep 17 00:00:00 2001 From: cdeline Date: Tue, 24 Mar 2026 15:39:10 -0600 Subject: [PATCH 4/7] Redo degradation_timeseries_plot - include in median if dt_center is within rolling window. --- rdtools/plotting.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/rdtools/plotting.py b/rdtools/plotting.py index d132362a..ed42ac01 100644 --- a/rdtools/plotting.py +++ b/rdtools/plotting.py @@ -536,6 +536,7 @@ def degradation_timeseries_plot(yoy_info, rolling_days=365, include_ci=True, yoy_info : dict a dictionary with keys: * YoY_values - pandas series of year on year slopes + * YoY_times - pandas series of corresponding timestamps rolling_days: int, default 365 Number of days for rolling window. Note that the window must contain at least 25% of datapoints to be included in @@ -571,17 +572,17 @@ def _bootstrap(x, percentile, reps): def _roll_median(df, win_right, rolling_days, min_periods): """ rolling median - df includes following columns: dt_right, dt_left, yoy + df includes following columns: dt_center, yoy win_right: Datetime of the right end of the rolling window rolling_days: number of days in the rolling window min_periods: minimum number of points in the rolling window to return a value - returns: median of yoy values if any part of the slope is in the rolling window, + returns: median of yoy values if the center of the slope is in the rolling window, or NaN if there are fewer than min_periods points. Time index of the returned value is centered on the rolling window. """ win_left = win_right - pd.Timedelta(days=rolling_days) - in_window = (df['dt_left'] <= win_right) & (df['dt_right'] >= win_left) + in_window = (df['dt_center'] <= win_right) & (df['dt_center'] >= win_left) if in_window.sum() < min_periods: return np.nan else: @@ -612,7 +613,7 @@ def _roll_median(df, win_right, rolling_days, min_periods): else: multi_yoy = False - # loop through results in a daily timeindex from min(results.dt_left) to max(dt_right) + # loop through results in a daily timeindex from min(dt_left) to max(dt_right) # Apply rolling median and bootstrap confidence intervals timeindex = pd.date_range(start=results['dt_left'].min(), @@ -638,7 +639,7 @@ def _roll_median(df, win_right, rolling_days, min_periods): for win_center in timeindex: win_right = win_center + pd.Timedelta(days=rolling_days/2) win_left = win_center - pd.Timedelta(days=rolling_days/2) - in_window = (results['dt_left'] <= win_right) & (results['dt_right'] >= win_left) + in_window = (results['dt_center'] <= win_right) & (results['dt_center'] >= win_left) if in_window.sum() < rolling_days//4: ci_lower.loc[win_center] = np.nan ci_upper.loc[win_center] = np.nan From 37cde6e2319ff110a6449e6460052caa584ead81 Mon Sep 17 00:00:00 2001 From: cdeline Date: Tue, 24 Mar 2026 16:09:59 -0600 Subject: [PATCH 5/7] remove label= functionality. Update Multi-year_on_year_example.ipynb --- docs/Multi-year_on_year_example.ipynb | 20 +++--- rdtools/degradation.py | 14 ++--- rdtools/plotting.py | 91 --------------------------- rdtools/test/degradation_test.py | 29 --------- rdtools/test/plotting_test.py | 42 +------------ 5 files changed, 16 insertions(+), 180 deletions(-) diff --git a/docs/Multi-year_on_year_example.ipynb b/docs/Multi-year_on_year_example.ipynb index 6d77058b..bce8ec3f 100644 --- a/docs/Multi-year_on_year_example.ipynb +++ b/docs/Multi-year_on_year_example.ipynb @@ -14,7 +14,7 @@ "The calculations consist of:\n", "\n", "1. Import and preliminary calculations: In this step data is imported and augmented to enable analysis with RdTools. **No RdTools functions are used in this step. It will vary depending on the particulars of your dataset.** \n", - "2. Analysis with RdTools: This notebook illustrates the use of the TrendAnalysis API with two new features: `label='center'` and `multi_yoy=True`. Because we are implementing this with the `rdtools.TrendAnalysis` object-oriented API, it requires passing kwargs to `degradation_year_on_year` as a dictionary in the `TrendAnalysis.sensor_analysis(yoy_kwargs={})` input.\n", + "2. Analysis with RdTools: This notebook illustrates the use of the TrendAnalysis API with the new feature: `multi_yoy=True`. Because we are implementing this with the `rdtools.TrendAnalysis` object-oriented API, it requires passing kwargs to `degradation_year_on_year` as a dictionary in the `TrendAnalysis.sensor_analysis(yoy_kwargs={})` input.\n", "\n", "For a consistent experience, we recommend installing the packages and versions documented in `docs/notebook_requirements.txt`. This can be achieved in your environment by running `pip install -r docs/notebook_requirements.txt` from the base directory. (RdTools must also be separately installed.) This notebook was tested in python 3.12.\n", "\n", @@ -180,9 +180,7 @@ "source": [ "Once the `TrendAnalysis` object is ready, the `sensor_analysis()` method can be used to deploy the full chain of analysis steps. Results are stored in a nested dict, `TrendAnalysis.results`.\n", "\n", - "New in RdTools 3.2, there are two new arguments in `rdtools.degradation_year_on_year()`: `label='center'` (or 'left') and `multi_yoy=True`. To pass these arguments into the TrendAnalysis object, they are passed as a dictionary in the `TrendAnalysis.sensor_analysis(yoy_kwargs={})` input.\n", - "\n", - "The first new argument changes the label index of the year-on-year degradation output. By default this index is right-labeled. For instance, if we have calculated a slope between '2021-01-01' and '2022-01-01', this slope value is labeled with the right index of '2022-01-01'. By passing `label='center'`, the output will be labeled as '2021-07-02' instead, which is the midpoint of the 365-day period." + "New in RdTools 3.2, there is a new argument in `rdtools.degradation_year_on_year()`: `multi_yoy=True`. To pass this argument into the TrendAnalysis object, this is passed as a dictionary in the `TrendAnalysis.sensor_analysis(yoy_kwargs={})` input." ] }, { @@ -191,7 +189,7 @@ "metadata": {}, "outputs": [], "source": [ - "ta.sensor_analysis(analyses=['yoy_degradation'], yoy_kwargs={'label': 'center'})" + "ta.sensor_analysis(analyses=['yoy_degradation'])" ] }, { @@ -221,7 +219,7 @@ } ], "source": [ - "# Print the YoY slopes. Timestamps are center-labeled because we passed label='center' in the yoy_kwargs.\n", + "# Print the YoY slopes. Timestamps are right-labeled.\n", "calc_info = ta.results['sensor']['yoy_degradation']['calc_info']\n", "print(calc_info['YoY_values'].head().to_markdown())" ] @@ -247,7 +245,7 @@ ], "source": [ "# Provide additional timestamp information for the YoY slopes including the left and right timestamps that were used to calculate the slope.\n", - "# The index is set to equal dt_center because we passed label='center' in the yoy_kwargs. \n", + "# The index is set to equal dt_right by default. \n", "print(calc_info['YoY_times'].head().to_markdown())" ] }, @@ -322,7 +320,7 @@ "metadata": {}, "outputs": [], "source": [ - "ta.sensor_analysis(analyses=['yoy_degradation'], yoy_kwargs={'label': 'center', 'multi_yoy': True})" + "ta.sensor_analysis(analyses=['yoy_degradation'], yoy_kwargs={'multi_yoy': True})" ] }, { @@ -408,8 +406,6 @@ "source": [ "# Plot the multi-YoY time-series plot. This will result in a warning because there are multiple YoY slopes for each timestamp.\n", "# The method will automatically average all datapoints sharing a timestamp. The result is a more filtered annual trend.\n", - "# Note that the choice of label='center' vs 'left' or 'right' will affect the timestamps that are averaged together and hence\n", - "# will change the appearance of the multi-YoY time-series plot.\n", "ta.plot_degradation_timeseries(case='sensor')\n", "plt.title('Multi-YoY degradation time-series plot')\n", "plt.show()" @@ -422,7 +418,9 @@ } }, "cell_type": "markdown", - "metadata": {}, + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, "source": [ "### Further illustration\n", "To further illustrate the details of multi-YoY operation, and how using `center` vs `right` labeling changes the process,\n", diff --git a/rdtools/degradation.py b/rdtools/degradation.py index 2cc611cc..8215fc56 100644 --- a/rdtools/degradation.py +++ b/rdtools/degradation.py @@ -209,8 +209,6 @@ def degradation_year_on_year(energy_normalized, recenter=True, If `uncertainty_method` is 'circular_block', `block_length` determines the length of the blocks used in the circular block bootstrapping in number of days. Must be shorter than a third of the time series. - label : {'right', 'center', 'left'}, default 'right' - Which Year-on-Year slope edge to label. multi_yoy : bool, default False Whether to return the standard Year-on-Year slopes where each slope is calculated over points separated by 365 days (default) or @@ -226,8 +224,8 @@ def degradation_year_on_year(energy_normalized, recenter=True, degradation rate estimate calc_info : dict - * `YoY_values` - pandas series of year on year slopes, either right - left or center labeled, depending on the `label` parameter. + * `YoY_values` - pandas series of year on year slopes, right + labeled. * `renormalizing_factor` - float of value used to recenter data * `exceedance_level` - the degradation rate that was outperformed with probability of `exceedance_prob` @@ -242,10 +240,6 @@ def degradation_year_on_year(energy_normalized, recenter=True, energy_normalized.name = 'energy' energy_normalized.index.name = 'dt' - if label not in {"right", "left", "center"}: - raise ValueError(f"Unsupported value {label} for `label`." - " Must be 'right', 'left' or 'center'.") - # Detect less than 2 years of data. This is complicated by two things: # - leap days muddle the precise meaning of "two years of data". # - can't just check the number of days between the first and last @@ -332,11 +326,11 @@ def degradation_year_on_year(energy_normalized, recenter=True, YoY_times = YoY_times[['dt', 'dt_center', 'dt_left']] YoY_times = YoY_times.rename(columns={'dt': 'dt_right'}) - YoY_times.set_index(YoY_times[f'dt_{label}'], inplace=True) + YoY_times.set_index(YoY_times['dt'], inplace=True) YoY_times.index.name = 'dt' # now apply either right, left, or center label index to the yoy_result - yoy_result.index = YoY_times[f'dt_{label}'] + yoy_result.index = YoY_times['dt'] yoy_result.index.name = 'dt' # the following is throwing a futurewarning if infer_objects() isn't included here. diff --git a/rdtools/plotting.py b/rdtools/plotting.py index ed42ac01..693626cf 100644 --- a/rdtools/plotting.py +++ b/rdtools/plotting.py @@ -435,97 +435,6 @@ def availability_summary_plots(power_system, power_subsystem, loss_total, return fig -def degradation_timeseries_plot_old(yoy_info, rolling_days=365, include_ci=True, - fig=None, plot_color=None, ci_color=None, **kwargs): - ''' - Plot resampled time series of degradation trend with time - - Parameters - ---------- - yoy_info : dict - a dictionary with keys: - * YoY_values - pandas series of year on year slopes - rolling_days: int, default 365 - Number of days for rolling window. Note that - the window must contain at least 25% of datapoints to be included in - the rolling plot, and the rolling window is centered. - include_ci : bool, default True - calculate and plot 2-sigma confidence intervals along with rolling median - fig : matplotlib, optional - fig object to add new plot to (first set of axes only) - plot_color : str, optional - color of the timeseries trendline - ci_color : str, optional - color of the confidence interval 'fuzz' - kwargs : - Extra parameters passed to matplotlib.pyplot.axis.plot() - - Note - ---- - It should be noted that ``yoy_info`` is an output - from :py:func:`rdtools.degradation.degradation_year_on_year`. - - Returns - ------- - matplotlib.figure.Figure - ''' - - def _bootstrap(x, percentile, reps): - # stolen from degradation_year_on_year - n1 = len(x) - xb1 = np.random.choice(x, (n1, reps), replace=True) - mb1 = np.nanmedian(xb1, axis=0) - return np.percentile(mb1, percentile) - - try: - results_values = yoy_info['YoY_values'] - except KeyError: - raise KeyError("yoy_info input dictionary does not contain key `YoY_values`.") - - if plot_color is None: - plot_color = 'tab:orange' - if ci_color is None: - ci_color = 'C0' - - results_values = results_values.sort_index() - if results_values.index.has_duplicates: - # this occurs with degradation_year_on_year(multi_yoy=True). resample to daily mean - warnings.warn( - "Input `yoy_info['YoY_values']` appears to have multiple annual " - "slopes per day, which is the case if " - "degradation_year_on_year(multi_yoy=True). " - "Proceeding to plot with a daily mean which will average out the " - "time-series trend. Recommend re-running with " - "degradation_year_on_year(multi_yoy=False)." - ) - roller = results_values.resample('D').mean().rolling(f'{rolling_days}d', - min_periods=rolling_days//4, - center=True) - else: - roller = results_values.rolling(f'{rolling_days}d', min_periods=rolling_days//4, - center=True) - # unfortunately it seems that you can't return multiple values in the rolling.apply() kernel. - # TODO: figure out some workaround to return both percentiles in a single pass - if include_ci: - ci_lower = roller.apply(_bootstrap, kwargs={'percentile': 2.5, 'reps': 100}, raw=True) - ci_upper = roller.apply(_bootstrap, kwargs={'percentile': 97.5, 'reps': 100}, raw=True) - if fig is None: - fig, ax = plt.subplots() - else: - ax = fig.axes[0] - if include_ci: - ax.fill_between(ci_lower.index, - ci_lower, ci_upper, color=ci_color) - median = roller.median() - ax.plot(median.index, - median, color=plot_color, **kwargs) - ax.axhline(results_values.median(), c='k', ls='--') - plt.ylabel('Degradation trend (%/yr)') - fig.autofmt_xdate() - - return fig - - def degradation_timeseries_plot(yoy_info, rolling_days=365, include_ci=True, fig=None, plot_color=None, ci_color=None, **kwargs): ''' diff --git a/rdtools/test/degradation_test.py b/rdtools/test/degradation_test.py index 752a3035..6c4dbd3b 100644 --- a/rdtools/test/degradation_test.py +++ b/rdtools/test/degradation_test.py @@ -202,35 +202,6 @@ def test_usage_of_points(self): self.test_corr_energy[input_freq]) self.assertTrue((np.sum(rd_result[2]['usage_of_points'])) == 1462) - def test_degradation_year_on_year_label_center(self): - ''' Test degradation_year_on_year with label="center". ''' - - funcName = sys._getframe().f_code.co_name - logging.debug('Running {}'.format(funcName)) - - # test YOY degradation calc with label='center' - input_freq = 'D' - rd_result = degradation_year_on_year( - self.test_corr_energy[input_freq], label='center') - self.assertAlmostEqual(rd_result[0], 100 * self.rd, places=1) - rd_result1 = degradation_year_on_year( - self.test_corr_energy[input_freq]) - rd_result2 = degradation_year_on_year( - self.test_corr_energy[input_freq], label='right') - pd.testing.assert_index_equal(rd_result1[2]['YoY_values'].index, - rd_result2[2]['YoY_values'].index) - # 365/2 days difference between center and right label - assert (rd_result2[2]['YoY_values'].index - - rd_result[2]['YoY_values'].index).mean().days == \ - pytest.approx(183, abs=1) - - with pytest.raises(ValueError): - degradation_year_on_year(self.test_corr_energy[input_freq], - label='LEFT') - with pytest.raises(ValueError): - degradation_year_on_year(self.test_corr_energy[input_freq], - label=None) - def test_avg_timestamp_old_Pandas(self): """Test the _avg_timestamp_old_Pandas function for correct averaging.""" from rdtools.degradation import _avg_timestamp_old_Pandas diff --git a/rdtools/test/plotting_test.py b/rdtools/test/plotting_test.py index 6f8fcb54..ae14e45d 100644 --- a/rdtools/test/plotting_test.py +++ b/rdtools/test/plotting_test.py @@ -59,20 +59,6 @@ def degradation_info(degradation_power_signal): return degradation_power_signal, rd, rd_ci, calc_info -@pytest.fixture() -def degradation_info_center(degradation_power_signal): - # center-labeled YOY output for time-series degradation plot - rd, rd_ci, calc_info = degradation_year_on_year(degradation_power_signal, label='center') - return degradation_power_signal, rd, rd_ci, calc_info - - -@pytest.fixture() -def degradation_info_left(degradation_power_signal): - # left-labeled YOY output for time-series degradation plot - rd, rd_ci, calc_info = degradation_year_on_year(degradation_power_signal, label='left') - return degradation_power_signal, rd, rd_ci, calc_info - - def test_degradation_summary_plots(degradation_info): power, yoy_rd, yoy_ci, yoy_info = degradation_info @@ -265,35 +251,13 @@ def test_availability_summary_plots_empty(availability_analysis_object): plt.close('all') -def test_degradation_timeseries_plot(degradation_info, degradation_info_center, - degradation_info_left): +def test_degradation_timeseries_plot(degradation_info): power, yoy_rd, yoy_ci, yoy_info = degradation_info - # test defaults (label='right') + # test defaults result_right = degradation_timeseries_plot(yoy_info) assert_isinstance(result_right, plt.Figure) - xlim_right = result_right.get_axes()[0].get_xlim()[0] - - # test label='center' - result_center = degradation_timeseries_plot(yoy_info=degradation_info_center[3], - include_ci=False) - assert_isinstance(result_center, plt.Figure) - xlim_center = result_center.get_axes()[0].get_xlim()[0] - - # test label='left' - result_left = degradation_timeseries_plot(yoy_info=degradation_info_left[3], - include_ci=False) - assert_isinstance(result_left, plt.Figure) - # xlim_left = result_left.get_axes()[0].get_xlim()[0] - - # test default label matches label='right' - result_default = degradation_timeseries_plot(yoy_info=yoy_info, include_ci=False) - xlim_default = result_default.get_axes()[0].get_xlim()[0] - assert xlim_default == xlim_right - - # Check that the xlim values are the same as expected - # right > center > left (since offset_days increases) - assert xlim_right == xlim_center + result_right.get_axes()[0].get_xlim()[0] with pytest.raises(KeyError): degradation_timeseries_plot({'a': 1}, include_ci=False) From 3b2f22c853a0ee82e542e18d13f3e03e7e937634 Mon Sep 17 00:00:00 2001 From: cdeline Date: Tue, 24 Mar 2026 17:03:13 -0600 Subject: [PATCH 6/7] Re-run Multi-year_on_year_example.ipynb, check for text changes. --- docs/Multi-year_on_year_example.ipynb | 75 +++++++++------------------ rdtools/degradation.py | 7 +-- 2 files changed, 27 insertions(+), 55 deletions(-) diff --git a/docs/Multi-year_on_year_example.ipynb b/docs/Multi-year_on_year_example.ipynb index bce8ec3f..c7e1fc62 100644 --- a/docs/Multi-year_on_year_example.ipynb +++ b/docs/Multi-year_on_year_example.ipynb @@ -8,8 +8,7 @@ "\n", "\n", "This Jupyter notebook follows on from the existing TrendAnalysis_example.ipynb and assumes familiarity with that example. This\n", - "example investigates two additional pieces of functionality introduced in RdTools 3.2.0: multi-year-on-year analysis, and \n", - "changing the right- or left-labeling of YoY outputs in the `rdtools.degradation.degradation_year_on_year` function.\n", + "example investigates an additional piece of functionality introduced in RdTools 3.2.0: multi-year-on-year analysis.\n", "\n", "The calculations consist of:\n", "\n", @@ -178,9 +177,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Once the `TrendAnalysis` object is ready, the `sensor_analysis()` method can be used to deploy the full chain of analysis steps. Results are stored in a nested dict, `TrendAnalysis.results`.\n", - "\n", - "New in RdTools 3.2, there is a new argument in `rdtools.degradation_year_on_year()`: `multi_yoy=True`. To pass this argument into the TrendAnalysis object, this is passed as a dictionary in the `TrendAnalysis.sensor_analysis(yoy_kwargs={})` input." + "Once the `TrendAnalysis` object is ready, the `sensor_analysis()` method can be used to deploy the full chain of analysis steps. Results are stored in a nested dict, `TrendAnalysis.results`." ] }, { @@ -208,13 +205,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "| dt | yoy |\n", - "|:--------------------------|--------:|\n", - "| 2010-08-27 12:00:00-07:00 | 31.7242 |\n", - "| 2010-08-28 12:00:00-07:00 | 21.4746 |\n", - "| 2010-08-29 12:00:00-07:00 | 20.9898 |\n", - "| 2010-08-30 12:00:00-07:00 | 25.8811 |\n", - "| 2010-09-01 12:00:00-07:00 | 21.3218 |\n" + "| dt | yoy |\n", + "|-----:|--------:|\n", + "| 366 | 31.7242 |\n", + "| 367 | 21.4746 |\n", + "| 368 | 20.9898 |\n", + "| 369 | 25.8811 |\n", + "| 371 | 21.3218 |\n" ] } ], @@ -233,19 +230,19 @@ "name": "stdout", "output_type": "stream", "text": [ - "| dt | dt_right | dt_center | dt_left |\n", - "|:--------------------------|:--------------------------|:--------------------------|:--------------------------|\n", - "| 2010-08-27 12:00:00-07:00 | 2011-02-26 00:00:00-07:00 | 2010-08-27 12:00:00-07:00 | 2010-02-26 00:00:00-07:00 |\n", - "| 2010-08-28 12:00:00-07:00 | 2011-02-27 00:00:00-07:00 | 2010-08-28 12:00:00-07:00 | 2010-02-27 00:00:00-07:00 |\n", - "| 2010-08-29 12:00:00-07:00 | 2011-02-28 00:00:00-07:00 | 2010-08-29 12:00:00-07:00 | 2010-02-28 00:00:00-07:00 |\n", - "| 2010-08-30 12:00:00-07:00 | 2011-03-01 00:00:00-07:00 | 2010-08-30 12:00:00-07:00 | 2010-03-01 00:00:00-07:00 |\n", - "| 2010-09-01 12:00:00-07:00 | 2011-03-03 00:00:00-07:00 | 2010-09-01 12:00:00-07:00 | 2010-03-03 00:00:00-07:00 |\n" + "| dt | dt_right | dt_center | dt_left |\n", + "|-----:|:--------------------------|:--------------------------|:--------------------------|\n", + "| 366 | 2011-02-26 00:00:00-07:00 | 2010-08-27 12:00:00-07:00 | 2010-02-26 00:00:00-07:00 |\n", + "| 367 | 2011-02-27 00:00:00-07:00 | 2010-08-28 12:00:00-07:00 | 2010-02-27 00:00:00-07:00 |\n", + "| 368 | 2011-02-28 00:00:00-07:00 | 2010-08-29 12:00:00-07:00 | 2010-02-28 00:00:00-07:00 |\n", + "| 369 | 2011-03-01 00:00:00-07:00 | 2010-08-30 12:00:00-07:00 | 2010-03-01 00:00:00-07:00 |\n", + "| 371 | 2011-03-03 00:00:00-07:00 | 2010-09-01 12:00:00-07:00 | 2010-03-03 00:00:00-07:00 |\n" ] } ], "source": [ "# Provide additional timestamp information for the YoY slopes including the left and right timestamps that were used to calculate the slope.\n", - "# The index is set to equal dt_right by default. \n", + "# The index is set equal to dt_right by default. \n", "print(calc_info['YoY_times'].head().to_markdown())" ] }, @@ -287,7 +284,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -384,17 +381,9 @@ "scrolled": true }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\cdeline\\Documents\\Python Scripts\\rdtools_dev\\rdtools\\plotting.py:495: UserWarning: Input `yoy_info['YoY_values']` appears to have multiple annual slopes per day, which is the case if degradation_year_on_year(multi_yoy=True). Proceeding to plot with a daily mean which will average out the time-series trend. Recommend re-running with degradation_year_on_year(multi_yoy=False).\n", - " warnings.warn(\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -411,24 +400,6 @@ "plt.show()" ] }, - { - "attachments": { - "554309ee-33e2-418a-b578-c5bfdcb1194f.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "### Further illustration\n", - "To further illustrate the details of multi-YoY operation, and how using `center` vs `right` labeling changes the process,\n", - "we consider the below multi-YoY example. In the first case, we look at five slopes, each of which end at the same\n", - "right-labeled datapoint in 2015. These consist of 1,2,3,4 and 5-year segment lengths.\n", - "![image.png](attachment:554309ee-33e2-418a-b578-c5bfdcb1194f.png)" - ] - }, { "attachments": { "8d50a6f5-7bca-4cf8-ba11-121df7a9fe8a.png": { @@ -438,7 +409,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Alternatively, if we use the `center` labeling, a similar timestamp in 2013 will also include five slopes, \n", + "### Further illustration\n", + "To further illustrate the details of multi-YoY operation, \n", + "we consider the below multi-YoY example. Here we look at five slopes, each of which have the same\n", + "center-labeled datapoint in 2013. These consist of 1,2,3,4 and 5-year segment lengths,\n", "each of which has a midpoint of the segment coinciding with the same timestamp. \n", "![image.png](attachment:8d50a6f5-7bca-4cf8-ba11-121df7a9fe8a.png)" ] @@ -448,7 +422,8 @@ "metadata": {}, "source": [ "For the degradation summary plot, each of the multi-year slopes will be included in the histogram. \n", - "For the time-series degradation plot, multiple slopes sharing the same timestamp will be averaged." + "For the time-series degradation plot, a moving window (1-year width by default) will include slope values whose\n", + "center-point falls within the window. A median of all included slopes is assigned at the center of the window." ] } ], diff --git a/rdtools/degradation.py b/rdtools/degradation.py index 8215fc56..1556945e 100644 --- a/rdtools/degradation.py +++ b/rdtools/degradation.py @@ -326,11 +326,8 @@ def degradation_year_on_year(energy_normalized, recenter=True, YoY_times = YoY_times[['dt', 'dt_center', 'dt_left']] YoY_times = YoY_times.rename(columns={'dt': 'dt_right'}) - YoY_times.set_index(YoY_times['dt'], inplace=True) - YoY_times.index.name = 'dt' - - # now apply either right, left, or center label index to the yoy_result - yoy_result.index = YoY_times['dt'] + # now apply right label index to the yoy_result + yoy_result.index = YoY_times.index yoy_result.index.name = 'dt' # the following is throwing a futurewarning if infer_objects() isn't included here. From 48915e6a24759d82e39d2a0e637ad828e4a45c94 Mon Sep 17 00:00:00 2001 From: cdeline Date: Tue, 24 Mar 2026 17:16:08 -0600 Subject: [PATCH 7/7] update analysis_chains to remove `label=`. Update whatsnew --- docs/sphinx/source/changelog/v3.2.0.rst | 24 ++++++++---------------- rdtools/analysis_chains.py | 6 ++---- 2 files changed, 10 insertions(+), 20 deletions(-) diff --git a/docs/sphinx/source/changelog/v3.2.0.rst b/docs/sphinx/source/changelog/v3.2.0.rst index d542c38a..e3fbeed0 100644 --- a/docs/sphinx/source/changelog/v3.2.0.rst +++ b/docs/sphinx/source/changelog/v3.2.0.rst @@ -4,21 +4,18 @@ v3.2.0 (X, X, 2026) Enhancements ------------ -* :py:func:`~rdtools.degradation.degradation_year_on_year` has new parameter ``label=`` - to return the calc_info['YoY_values'] as either right labeled (default), left or - center labeled. (:issue:`459`) -* :py:func:`~rdtools.plotting.degradation_timeseries_plot` now defaults to rolling - median, centered on the timestamp (pd.rolling(center=True)), and reduces - ``min_periods`` from ``rolling_days//2`` to ``rolling_days//4``. - (:issue:`455`) +* :py:func:`~rdtools.plotting.degradation_timeseries_plot` refactored to do a rolling + median, for all slopes whose center timestamp is inside the window. + ``min_periods`` reduced to ``rolling_days//4``. + (:issue:`455`) (:pull:`498`) * :py:func:`~rdtools.degradation.degradation_year_on_year` has new parameter ``multi_yoy`` (default False) to trigger multiple YoY degradation calculations similar to Hugo Quest et al 2023. In this mode, instead of a series of 1-year duration slopes, 2-year, 3-year etc slopes are also included. calc_info['YoY_values'] returns a non-monotonic index in this mode due to multiple overlapping annual slopes. (:issue:`394`) * :py:func:`~rdtools.plotting.degradation_timeseries_plot` now supports ``multi_yoy=True`` - data by resampling overlapping YoY values to their mean. A warning is issued when this - resampling occurs. (:issue:`394`) + data by resampling overlapping YoY values to their mean. A warning is issued to + notify that time-series sensitivity is reduced by multi_yoy. (:issue:`394`) (:pull:`498`) * :py:func:`~rdtools.plotting.degradation_summary_plots` ``detailed=True`` mode now properly handles points used odd vs even number of times (not just 0, 1, 2). (:issue:`394`) @@ -26,18 +23,14 @@ Enhancements ``calc_info['YoY_times']`` DataFrame with ``dt_right``, ``dt_center``, and ``dt_left`` columns for each YoY slope. (:issue:`459`) * Added new example notebook ``docs/Multi-year_on_year_example.ipynb`` demonstrating the - ``label='center'`` and ``multi_yoy=True`` features of + ``multi_yoy=True`` features of :py:func:`~rdtools.degradation.degradation_year_on_year`. (:issue:`394`) -* :py:meth:`~rdtools.analysis_chains.TrendAnalysis.sensor_analysis` and - :py:meth:`~rdtools.analysis_chains.TrendAnalysis.clearsky_analysis` now - explicitly default ``yoy_kwargs={"label": "right"}``. Bug Fixes --------- * Fixed ``usage_of_points`` calculation in :py:func:`~rdtools.degradation.degradation_year_on_year` to properly handle ``multi_yoy=True`` mode with overlapping slopes. (:issue:`394`) - Maintenance ----------- * Added ``_avg_timestamp_old_Pandas`` helper function for pandas <2.0 compatibility @@ -63,8 +56,7 @@ Testing decreasing). * Added test for ``multi_yoy=True`` parameter in ``degradation_year_on_year``. * Added tests for :py:func:`~rdtools.plotting.degradation_timeseries_plot` - covering ``label='center'``, ``label='left'``, multi-YoY duplicate index - handling, and ``KeyError`` path. + covering multi-YoY duplicate index handling, and ``KeyError`` path. * Set matplotlib backend to ``Agg`` in test ``conftest.py`` to avoid tkinter issues. diff --git a/rdtools/analysis_chains.py b/rdtools/analysis_chains.py index 51db8092..0ed53906 100644 --- a/rdtools/analysis_chains.py +++ b/rdtools/analysis_chains.py @@ -1001,7 +1001,7 @@ def _clearsky_preprocess(self): ) def sensor_analysis( - self, analyses=["yoy_degradation"], yoy_kwargs={"label": "right"}, srr_kwargs={} + self, analyses=["yoy_degradation"], yoy_kwargs={}, srr_kwargs={} ): """ Perform entire sensor-based analysis workflow. @@ -1014,7 +1014,6 @@ def sensor_analysis( and 'srr_soiling' yoy_kwargs : dict kwargs to pass to :py:func:`rdtools.degradation.degradation_year_on_year` - default is {"label": "right"}, which will right-label the YoY slope values. srr_kwargs : dict kwargs to pass to :py:func:`rdtools.soiling.soiling_srr` @@ -1042,7 +1041,7 @@ def sensor_analysis( self.results["sensor"] = sensor_results def clearsky_analysis( - self, analyses=["yoy_degradation"], yoy_kwargs={"label": "right"}, srr_kwargs={} + self, analyses=["yoy_degradation"], yoy_kwargs={}, srr_kwargs={} ): """ Perform entire clear-sky-based analysis workflow. Results are stored @@ -1055,7 +1054,6 @@ def clearsky_analysis( and 'srr_soiling' yoy_kwargs : dict kwargs to pass to :py:func:`rdtools.degradation.degradation_year_on_year`. - default is {"label": "right"}, which will right-label the YoY slope values. srr_kwargs : dict kwargs to pass to :py:func:`rdtools.soiling.soiling_srr`