pvlib 0.10.5__tar.gz → 0.11.0__tar.gz

{pvlib-0.10.5/pvlib.egg-info → pvlib-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pvlib
-Version: 0.10.5
+Version: 0.11.0
 Summary: A set of functions and classes for simulating the performance of photovoltaic energy systems.
 Home-page: https://github.com/pvlib/pvlib-python
 Author-email: pvlib python Developers <pvlib-admin@googlegroups.com>

pvlib-0.11.0/docs/examples/agrivoltaics/README.rst

@@ -0,0 +1,2 @@
+Agrivoltaic Systems Modelling
+-----------------------------

pvlib-0.11.0/docs/examples/agrivoltaics/plot_diffuse_PAR_Spitters_relationship.py

@@ -0,0 +1,161 @@
+"""
+Calculating daily diffuse PAR using Spitter's relationship
+==========================================================
+
+This example demonstrates how to calculate the diffuse photosynthetically
+active radiation (PAR) from diffuse fraction of broadband insolation.
+"""
+
+# %%
+# The photosynthetically active radiation (PAR) is a key metric in quantifying
+# the photosynthesis process of plants. As with broadband irradiance, PAR can
+# be divided into direct and diffuse components. The diffuse fraction of PAR
+# with respect to the total PAR is important in agrivoltaic systems, where
+# crops are grown under solar panels. The diffuse fraction of PAR can be
+# calculated using the Spitter's relationship [1]_ implemented in
+# :py:func:`~pvlib.irradiance.diffuse_par_spitters`.
+# This model requires the average daily solar zenith angle and the
+# daily fraction of the broadband insolation that is diffuse as inputs.
+#
+# .. note::
+#    Understanding the distinction between the broadband insolation and the PAR
+#    is a key concept. Broadband insolation is the total amount of solar
+#    energy that gets to a surface, often used in PV applications, while PAR
+#    is a measurement of a narrower spectrum of wavelengths that are involved
+#    in photosynthesis. See section on *Photosynthetically Active insolation*
+#    in pp. 222-223 of [1]_.
+#
+# References
+# ----------
+# .. [1] C. J. T. Spitters, H. A. J. M. Toussaint, and J. Goudriaan,
+#    'Separating the diffuse and direct component of global radiation and its
+#    implications for modeling canopy photosynthesis Part I. Components of
+#    incoming radiation', Agricultural and Forest Meteorology, vol. 38,
+#    no. 1, pp. 217-229, Oct. 1986, :doi:`10.1016/0168-1923(86)90060-2`.
+#
+# Read some example data
+# ^^^^^^^^^^^^^^^^^^^^^^
+# Let's read some weather data from a TMY3 file and calculate the solar
+# position.
+
+import pvlib
+import pandas as pd
+import matplotlib.pyplot as plt
+from matplotlib.dates import AutoDateLocator, ConciseDateFormatter
+from pathlib import Path
+
+# Datafile found in the pvlib distribution
+DATA_FILE = Path(pvlib.__path__[0]).joinpath("data", "723170TYA.CSV")
+
+tmy, metadata = pvlib.iotools.read_tmy3(
+    DATA_FILE, coerce_year=2002, map_variables=True
+)
+tmy = tmy.filter(
+    ["ghi", "dhi", "dni", "pressure", "temp_air"]
+)  # remaining columns are not needed
+tmy = tmy["2002-09-06":"2002-09-21"]  # select some days
+
+solar_position = pvlib.solarposition.get_solarposition(
+    # TMY timestamp is at end of hour, so shift to center of interval
+    tmy.index.shift(freq="-30T"),
+    latitude=metadata["latitude"],
+    longitude=metadata["longitude"],
+    altitude=metadata["altitude"],
+    pressure=tmy["pressure"] * 100,  # convert from millibar to Pa
+    temperature=tmy["temp_air"],
+)
+solar_position.index = tmy.index  # reset index to end of the hour
+
+# %%
+# Calculate daily values
+# ^^^^^^^^^^^^^^^^^^^^^^
+# The daily average solar zenith angle and the daily diffuse fraction of
+# broadband insolation are calculated as follows:
+
+daily_solar_zenith = solar_position["zenith"].resample("D").mean()
+# integration over the day with a time step of 1 hour
+daily_tmy = tmy[["ghi", "dhi"]].resample("D").sum() * 1
+daily_tmy["diffuse_fraction"] = daily_tmy["dhi"] / daily_tmy["ghi"]
+
+# %%
+# Calculate Photosynthetically Active Radiation
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+# The total PAR can be approximated as 0.50 times the broadband horizontal
+# insolation (integral of GHI) for an average solar elevation higher that 10°.
+# See section on *Photosynthetically Active Radiation* in pp. 222-223 of [1]_.
+
+par = pd.DataFrame({"total": 0.50 * daily_tmy["ghi"]}, index=daily_tmy.index)
+if daily_solar_zenith.min() < 10:
+    raise ValueError(
+        "The total PAR can't be assumed to be half the broadband insolation "
+        + "for average zenith angles lower than 10°."
+    )
+
+# Calculate broadband insolation diffuse fraction, input of the Spitter's model
+daily_tmy["diffuse_fraction"] = daily_tmy["dhi"] / daily_tmy["ghi"]
+
+# Calculate diffuse PAR fraction using Spitter's relationship
+par["diffuse_fraction"] = pvlib.irradiance.diffuse_par_spitters(
+    solar_position["zenith"], daily_tmy["diffuse_fraction"]
+)
+
+# Finally, calculate the diffuse PAR
+par["diffuse"] = par["total"] * par["diffuse_fraction"]
+
+# %%
+# Plot the results
+# ^^^^^^^^^^^^^^^^
+# Insolation on left axis, diffuse fraction on right axis
+
+fig, ax_l = plt.subplots(figsize=(12, 6))
+ax_l.set(
+    xlabel="Time",
+    ylabel="Daily insolation $[Wh/m^2/day]$",
+    title="Diffuse PAR using Spitter's relationship",
+)
+ax_l.xaxis.set_major_formatter(
+    ConciseDateFormatter(AutoDateLocator(), tz=daily_tmy.index.tz)
+)
+ax_l.plot(
+    daily_tmy.index,
+    daily_tmy["ghi"],
+    label="Broadband: total",
+    color="deepskyblue",
+)
+ax_l.plot(
+    daily_tmy.index,
+    daily_tmy["dhi"],
+    label="Broadband: diffuse",
+    color="skyblue",
+    linestyle="-.",
+)
+ax_l.plot(daily_tmy.index, par["total"], label="PAR: total", color="orangered")
+ax_l.plot(
+    daily_tmy.index,
+    par["diffuse"],
+    label="PAR: diffuse",
+    color="coral",
+    linestyle="-.",
+)
+ax_l.grid()
+ax_l.legend(loc="upper left")
+
+ax_r = ax_l.twinx()
+ax_r.set(ylabel="Diffuse fraction")
+ax_r.plot(
+    daily_tmy.index,
+    daily_tmy["diffuse_fraction"],
+    label="Broadband diffuse fraction",
+    color="plum",
+    linestyle=":",
+)
+ax_r.plot(
+    daily_tmy.index,
+    par["diffuse_fraction"],
+    label="PAR diffuse fraction",
+    color="chocolate",
+    linestyle=":",
+)
+ax_r.legend(loc="upper right")
+
+plt.show()

pvlib-0.11.0/docs/examples/shading/plot_martinez_shade_loss.py

@@ -0,0 +1,272 @@
+"""
+Modelling shading losses in modules with bypass diodes
+======================================================
+"""
+
+# %%
+# This example illustrates how to use the loss model proposed by Martinez et
+# al. [1]_. The model proposes a power output losses factor by adjusting
+# the incident direct and circumsolar beam irradiance fraction of a PV module
+# based on the number of shaded *blocks*. A *block* is defined as a group of
+# cells protected by a bypass diode. More information on *blocks* can be found
+# in the original paper [1]_ and in the
+# :py:func:`pvlib.shading.direct_martinez` documentation.
+#
+# The following key functions are used in this example:
+#
+# 1. :py:func:`pvlib.shading.direct_martinez` to calculate the power output
+#    losses fraction due to shading.
+# 2. :py:func:`pvlib.shading.shaded_fraction1d` to calculate the fraction of
+#    shaded surface and consequently the number of shaded *blocks* due to
+#    row-to-row shading.
+# 3. :py:func:`pvlib.tracking.singleaxis` to calculate the rotation angle of
+#    the trackers.
+#
+# .. sectionauthor:: Echedey Luis <echelual (at) gmail.com>
+#
+# Problem description
+# -------------------
+# Let's consider a PV system with the following characteristics:
+#
+# - Two north-south single-axis trackers, each one having 6 modules.
+# - The rows have the same true-tracking tilt angles. True tracking
+#   is chosen in this example, so shading is significant.
+# - Terrain slope is 7 degrees downward to the east.
+# - Row axes are horizontal.
+# - The modules are comprised of multiple cells. We will compare these cases:
+#    - modules with one bypass diode
+#    - modules with three bypass diodes
+#    - half-cut cell modules with three bypass diodes in portrait and landscape
+#
+# Setting up the system
+# ----------------------
+# Let's start by defining the system characteristics, location and the time
+# range for the analysis.
+
+import pvlib
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.dates import ConciseDateFormatter
+
+pitch = 4  # meters
+width = 1.5  # meters
+gcr = width / pitch  # ground coverage ratio
+N_modules_per_row = 6
+axis_azimuth = 180  # N-S axis
+axis_tilt = 0  # flat because the axis is perpendicular to the slope
+cross_axis_tilt = -7  # 7 degrees downward to the east
+
+latitude, longitude = 40.2712, -3.7277
+locus = pvlib.location.Location(
+    latitude,
+    longitude,
+    tz="Europe/Madrid",
+    altitude=pvlib.location.lookup_altitude(latitude, longitude),
+)
+
+times = pd.date_range("2001-04-11T04", "2001-04-11T20", freq="10min")
+
+# %%
+# True-tracking algorithm and shaded fraction
+# -------------------------------------------
+# Since this model is about row-to-row shading, we will use the true-tracking
+# algorithm to calculate the trackers rotation. Back-tracking eliminates
+# shading between rows, and since this example is about shading, we will not
+# use it.
+#
+# Then, the next step is to calculate the fraction of shaded surface. This is
+# done using :py:func:`pvlib.shading.shaded_fraction1d`. Using this function is
+# straightforward with the variables we already have defined.
+# Then, we can calculate the number of shaded blocks by rounding up the shaded
+# fraction by the number of blocks along the shaded length.
+
+# Calculate solar position to get single-axis tracker rotation and irradiance
+solar_pos = locus.get_solarposition(times)
+solar_apparent_zenith, solar_azimuth = (
+    solar_pos["apparent_zenith"],
+    solar_pos["azimuth"],
+)  # unpack for better readability
+
+tracking_result = pvlib.tracking.singleaxis(
+    apparent_zenith=solar_apparent_zenith,
+    apparent_azimuth=solar_azimuth,
+    axis_tilt=axis_tilt,
+    axis_azimuth=axis_azimuth,
+    max_angle=(-90 + cross_axis_tilt, 90 + cross_axis_tilt),  # (min, max)
+    backtrack=False,
+    gcr=gcr,
+    cross_axis_tilt=cross_axis_tilt,
+)
+
+tracker_theta, aoi, surface_tilt, surface_azimuth = (
+    tracking_result["tracker_theta"],
+    tracking_result["aoi"],
+    tracking_result["surface_tilt"],
+    tracking_result["surface_azimuth"],
+)  # unpack for better readability
+
+# Calculate the shade fraction
+shaded_fraction = pvlib.shading.shaded_fraction1d(
+    solar_apparent_zenith,
+    solar_azimuth,
+    axis_azimuth,
+    axis_tilt=axis_tilt,
+    shaded_row_rotation=tracker_theta,
+    shading_row_rotation=tracker_theta,
+    collector_width=width,
+    pitch=pitch,
+    cross_axis_slope=cross_axis_tilt,
+)
+
+# %%
+# Number of shaded blocks
+# -----------------------
+# The number of shaded blocks depends on the module configuration and number
+# of bypass diodes. For example,
+# modules with one bypass diode will behave like one block.
+# On the other hand, modules with three bypass diodes will have three blocks,
+# except for the half-cut cell modules, which will have six blocks; 2x3 blocks
+# where the two rows are along the longest side of the module.
+# We can argue that the dimensions of the system change when you switch from
+# portrait to landscape, but for this example, we will consider it the same.
+#
+# The number of shaded blocks is calculated by rounding up the shaded fraction
+# by the number of blocks along the shaded length. So let's define the number
+# of blocks for each module configuration:
+#
+# - 1 bypass diode: 1 block
+# - 3 bypass diodes: 3 blocks in landscape; 1 in portrait
+# - 3 bypass diodes half-cut cells:
+#   - 2 blocks in portrait
+#   - 3 blocks in landscape
+#
+# .. figure:: ../../_images/PV_module_layout_cesardd.jpg
+#    :align: center
+#    :width: 75%
+#    :alt: Normal and half-cut cells module layouts
+#
+#    Left: common module layout. Right: half-cut cells module layout.
+#    Each module has three bypass diodes. On the left, they connect cell
+#    columns 1-2, 2-3 & 3-4. On the right, they connect cell columns 1-2, 3-4 &
+#    5-6.
+#    *Source: César Domínguez. CC BY-SA 4.0, Wikimedia Commons*
+#
+# In the image above, each orange U-shaped string section is a block.
+# By symmetry, the yellow inverted-U's of the subcircuit are also blocks.
+# For this reason, the half-cut cell modules have 6 blocks in total: two along
+# the longest side and three along the shortest side.
+
+blocks_per_module = {
+    "1 bypass diode": 1,
+    "3 bypass diodes": 3,
+    "3 bypass diodes half-cut, portrait": 2,
+    "3 bypass diodes half-cut, landscape": 3,
+}
+
+# Calculate the number of shaded blocks during the day
+shaded_blocks_per_module = {
+    k: np.ceil(blocks_N * shaded_fraction)
+    for k, blocks_N in blocks_per_module.items()
+}
+
+# %%
+# Plane of array irradiance example data
+# --------------------------------------
+# To calculate the power output losses due to shading, we need the plane of
+# array irradiance. For this example, we will use synthetic data:
+
+clearsky = locus.get_clearsky(
+    times, solar_position=solar_pos, model="ineichen"
+)
+dni_extra = pvlib.irradiance.get_extra_radiation(times)
+airmass = pvlib.atmosphere.get_relative_airmass(solar_apparent_zenith)
+sky_diffuse = pvlib.irradiance.perez_driesse(
+    surface_tilt, surface_azimuth, clearsky["dhi"], clearsky["dni"],
+    solar_apparent_zenith, solar_azimuth, dni_extra, airmass,
+)  # fmt: skip
+poa_components = pvlib.irradiance.poa_components(
+    aoi, clearsky["dni"], sky_diffuse, poa_ground_diffuse=0
+)  # ignore ground diffuse for brevity
+poa_global, poa_direct = (
+    poa_components["poa_global"],
+    poa_components["poa_direct"],
+)
+
+# %%
+# Results
+# -------
+# Now that we have the number of shaded blocks for each module configuration,
+# we can apply the model and estimate the power loss due to shading.
+#
+# Note that this model is not linear with the shaded blocks ratio, so there is
+# a difference between applying it to just a module or a whole row.
+
+shade_losses_per_module = {
+    k: pvlib.shading.direct_martinez(
+        poa_global=poa_global,
+        poa_direct=poa_direct,
+        shaded_fraction=shaded_fraction,
+        shaded_blocks=module_shaded_blocks,
+        total_blocks=blocks_per_module[k],
+    )
+    for k, module_shaded_blocks in shaded_blocks_per_module.items()
+}
+
+shade_losses_per_row = {
+    k: pvlib.shading.direct_martinez(
+        poa_global=poa_global,
+        poa_direct=poa_direct,
+        shaded_fraction=shaded_fraction,
+        shaded_blocks=module_shaded_blocks * N_modules_per_row,
+        total_blocks=blocks_per_module[k] * N_modules_per_row,
+    )
+    for k, module_shaded_blocks in shaded_blocks_per_module.items()
+}
+
+# %%
+# Plotting the results
+# ^^^^^^^^^^^^^^^^^^^^
+
+fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)
+fig.suptitle("Martinez power losses due to shading")
+for k, shade_losses in shade_losses_per_module.items():
+    linestyle = "--" if k == "3 bypass diodes half-cut, landscape" else "-"
+    ax1.plot(times, shade_losses, label=k, linestyle=linestyle)
+ax1.legend(loc="upper center")
+ax1.grid()
+ax1.set_xlabel("Time")
+ax1.xaxis.set_major_formatter(
+    ConciseDateFormatter("%H:%M", tz="Europe/Madrid")
+)
+ax1.set_ylabel(r"$P_{out}$ losses")
+ax1.set_title("Per module")
+
+for k, shade_losses in shade_losses_per_row.items():
+    linestyle = "--" if k == "3 bypass diodes half-cut, landscape" else "-"
+    ax2.plot(times, shade_losses, label=k, linestyle=linestyle)
+ax2.legend(loc="upper center")
+ax2.grid()
+ax2.set_xlabel("Time")
+ax2.xaxis.set_major_formatter(
+    ConciseDateFormatter("%H:%M", tz="Europe/Madrid")
+)
+ax2.set_ylabel(r"$P_{out}$ losses")
+ax2.set_title("Per row")
+fig.tight_layout()
+fig.show()
+
+# %%
+# Note how the half-cut cell module in portrait performs better than the
+# normal module with three bypass diodes. This is because the number of shaded
+# blocks is less along the shaded length is higher in the half-cut module.
+# This is the reason why half-cut cell modules are preferred in portrait
+# orientation.
+
+# %%
+# References
+# ----------
+# .. [1] F. Martínez-Moreno, J. Muñoz, and E. Lorenzo, 'Experimental model
+#    to estimate shading losses on PV arrays', Solar Energy Materials and
+#    Solar Cells, vol. 94, no. 12, pp. 2298-2303, Dec. 2010,
+#    :doi:`10.1016/j.solmat.2010.07.029`.

pvlib-0.11.0/docs/examples/shading/plot_shaded_fraction1d_ns_hsat_example.py

@@ -0,0 +1,181 @@
+"""
+Shaded fraction of a horizontal single-axis tracker
+====================================================
+
+This example illustrates how to calculate the 1D shaded fraction of three rows
+in a North-South horizontal single axis tracker (HSAT) configuration.
+"""
+
+# %%
+# :py:func:`pvlib.shading.shaded_fraction1d` exposes a useful method for the
+# calculation of the shaded fraction of the width of a solar collector. Here,
+# the width is defined as the dimension perpendicular to the axis of rotation.
+# This method for calculating the shaded fraction only requires minor
+# modifications to be applicable for fixed-tilt systems.
+#
+# It is highly recommended to read :py:func:`pvlib.shading.shaded_fraction1d`
+# documentation to understand the input parameters and the method's
+# capabilities. For more in-depth information, please see the journal paper
+# `10.1063/5.0202220 <https://doi.org/10.1063/5.0202220>`_ describing
+# the methodology.
+#
+# Let's start by obtaining the true-tracking angles for each of the rows and
+# limiting the angles to the range of -50 to 50 degrees. This decision is
+# done to create an example scenario with significant shading.
+#
+# Key functions used in this example are:
+#
+# 1. :py:func:`pvlib.tracking.singleaxis` to calculate the tracking angles.
+# 2. :py:func:`pvlib.shading.projected_solar_zenith_angle` to calculate the
+#    projected solar zenith angle.
+# 3. :py:func:`pvlib.shading.shaded_fraction1d` to calculate the shaded
+#    fractions.
+#
+# .. sectionauthor:: Echedey Luis <echelual (at) gmail.com>
+
+import pvlib
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from matplotlib.dates import DateFormatter
+
+# Define the solar system parameters
+latitude, longitude = 28.51, -13.89
+altitude = pvlib.location.lookup_altitude(latitude, longitude)
+
+axis_tilt = 3  # degrees, positive is upwards in the axis_azimuth direction
+axis_azimuth = 180  # degrees, N-S tracking axis
+collector_width = 3.2  # m
+pitch = 4.15  # m
+gcr = collector_width / pitch
+cross_axis_slope = -5  # degrees
+surface_to_axis_offset = 0.07  # m
+
+# Generate a time range for the simulation
+times = pd.date_range(
+    start="2024-01-01T05",
+    end="2024-01-01T21",
+    freq="5min",
+    tz="Atlantic/Canary",
+)
+
+# Calculate the solar position
+solar_position = pvlib.solarposition.get_solarposition(
+    times, latitude, longitude, altitude
+)
+solar_azimuth = solar_position["azimuth"]
+solar_zenith = solar_position["apparent_zenith"]
+
+# Calculate the tracking angles
+rotation_angle = pvlib.tracking.singleaxis(
+    solar_zenith,
+    solar_azimuth,
+    axis_tilt,
+    axis_azimuth,
+    max_angle=(-50, 50),  # (min, max) degrees
+    backtrack=False,
+    gcr=gcr,
+    cross_axis_tilt=cross_axis_slope,
+)["tracker_theta"]
+
+# %%
+# Once the tracker angles have been obtained, the next step is to calculate
+# the shaded fraction. Special care must be taken
+# to ensure that the shaded or shading tracker roles are correctly assigned
+# depending on the solar position.
+# This means we will have a result for each row, ``eastmost_shaded_fraction``,
+# ``middle_shaded_fraction``, and ``westmost_shaded_fraction``.
+# Switching the parameters will be based on the
+# sign of :py:func:`pvlib.shading.projected_solar_zenith_angle`.
+#
+# The following code is verbose to make it easier to understand the process,
+# but with some effort you may be able to simplify it. This verbosity also
+# allows to change the premises easily per case, e.g., in case of a tracker
+# failure or with a different system configuration.
+
+psza = pvlib.shading.projected_solar_zenith_angle(
+    solar_zenith, solar_azimuth, axis_tilt, axis_azimuth
+)
+
+# Calculate the shaded fraction for the eastmost row
+eastmost_shaded_fraction = np.where(
+    psza < 0,
+    0,  # no shaded fraction in the morning
+    # shaded fraction in the evening
+    pvlib.shading.shaded_fraction1d(
+        solar_zenith,
+        solar_azimuth,
+        axis_azimuth,
+        shaded_row_rotation=rotation_angle,
+        axis_tilt=axis_tilt,
+        collector_width=collector_width,
+        pitch=pitch,
+        surface_to_axis_offset=surface_to_axis_offset,
+        cross_axis_slope=cross_axis_slope,
+        shading_row_rotation=rotation_angle,
+    ),
+)
+
+# Calculate the shaded fraction for the middle row
+middle_shaded_fraction = np.where(
+    psza < 0,
+    # shaded fraction in the morning
+    pvlib.shading.shaded_fraction1d(
+        solar_zenith,
+        solar_azimuth,
+        axis_azimuth,
+        shaded_row_rotation=rotation_angle,
+        axis_tilt=axis_tilt,
+        collector_width=collector_width,
+        pitch=pitch,
+        surface_to_axis_offset=surface_to_axis_offset,
+        cross_axis_slope=cross_axis_slope,
+        shading_row_rotation=rotation_angle,
+    ),
+    # shaded fraction in the evening
+    pvlib.shading.shaded_fraction1d(
+        solar_zenith,
+        solar_azimuth,
+        axis_azimuth,
+        shaded_row_rotation=rotation_angle,
+        axis_tilt=axis_tilt,
+        collector_width=collector_width,
+        pitch=pitch,
+        surface_to_axis_offset=surface_to_axis_offset,
+        cross_axis_slope=cross_axis_slope,
+        shading_row_rotation=rotation_angle,
+    ),
+)
+
+# Calculate the shaded fraction for the westmost row
+westmost_shaded_fraction = np.where(
+    psza < 0,
+    # shaded fraction in the morning
+    pvlib.shading.shaded_fraction1d(
+        solar_zenith,
+        solar_azimuth,
+        axis_azimuth,
+        shaded_row_rotation=rotation_angle,
+        axis_tilt=axis_tilt,
+        collector_width=collector_width,
+        pitch=pitch,
+        surface_to_axis_offset=surface_to_axis_offset,
+        cross_axis_slope=cross_axis_slope,
+        shading_row_rotation=rotation_angle,
+    ),
+    0,  # no shaded fraction in the evening
+)
+
+# %%
+# Plot the shaded fraction result for each row:
+plt.plot(times, eastmost_shaded_fraction, label="East-most", color="blue")
+plt.plot(times, middle_shaded_fraction, label="Middle", color="green",
+         linewidth=3, linestyle="--")  # fmt: skip
+plt.plot(times, westmost_shaded_fraction, label="West-most", color="red")
+plt.title(r"$shaded\_fraction1d$ of each row vs time")
+plt.xlabel("Time")
+plt.gca().xaxis.set_major_formatter(DateFormatter("%H:%M"))
+plt.ylabel("Shaded Fraction")
+plt.legend()
+plt.show()