NREL non-uniform irradiance mismatch loss for bifacial modules

docs/examples/bifacial/plot_irradiance_nonuniformity_loss.py

@@ -0,0 +1,125 @@
+"""
+Plot Irradiance Non-uniformity Loss
+===================================
+
+Calculate the DC power lost to non-uniformity in a bifacial PV array
+"""
+
+# %%
+# The incident irradiance on the backside of a bifacial PV module is
+# not uniform due to neighboring rows, the ground albedo and site conditions.
+# When each cell works at different irradiance levels, the power produced by
+# the module is less than the sum of the power produced by each cell since the
+# maximum power point (MPP) of each cell is different, but cells connected in
+# series will operate at the same current.
+# This is known as irradiance non-uniformity loss.
+#
+# Calculating the IV curve of each cell and then matching the working point of
+# the whole module is computationally expensive, so a simple model to account
+# for this loss is of interest. Deline et al. [1]_ proposed a model based on
+# the Relative Mean Absolute Difference (RMAD) of the irradiance of each cell.
+# They did also use the standard deviation of the cells' irradiances, but they
+# found that the RMAD was a better predictor of the mismatch loss.
+#
+# This example demonstrates how to model the irradiance non-uniformity loss
+# from the irradiance levels of each cell in a PV module.
+#
+# The function
+# :py:func:`pvlib.bifacial.power_mismatch_deline ` is
+# used to transform the Relative Mean Absolute Difference (RMAD) of the
+# irradiance into a power loss percentage. Down below you will find a
+# numpy-based implementation of the RMAD function.
+#
+# References
+# ----------
+# .. [1] C. Deline, S. Ayala Pelaez, S. MacAlpine, and C. Olalla, 'Estimating
+#    and parameterizing mismatch power loss in bifacial photovoltaic
+#    systems', Progress in Photovoltaics: Research and Applications, vol. 28,
+#    no. 7, pp. 691-703, 2020, :doi:`10.1002/pip.3259`.
+#
+# .. sectionauthor:: Echedey Luis <echelual (at) gmail.com>
+
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.cm import ScalarMappable
+from matplotlib.colors import Normalize
+
+from pvlib.bifacial import power_mismatch_deline
+
+# %%
+# Problem description
+# -------------------
+# Let's set a fixed irradiance to each cell row of the PV array with the values
+# described in Figure 1 (A), [1]_. We will cover this case for educational
+# purposes, although it can be achieved with the packages
+# :ref:`solarfactors <https://github.com/pvlib/solarfactors/>` and
+# :ref:`bifacial_radiance <https://github.com/NREL/bifacial_radiance>`.
+#
+# Here we set and plot the global irradiance level of each cell.
+
+x = np.arange(12, 0, -1)
+y = np.arange(6, 0, -1)
+cells_irrad = np.repeat([1059, 976, 967, 986, 1034, 1128], len(x)).reshape(
+    len(y), len(x)
+)
+
+color_map = "gray"
+color_norm = Normalize(930, 1150)
+
+fig, ax = plt.subplots()
+fig.suptitle("Global Irradiance Levels of Each Cell")
+fig.colorbar(
+    ScalarMappable(cmap=color_map, norm=color_norm),
+    ax=ax,
+    orientation="vertical",
+    label="$[W/m^2]$",
+)
+ax.set_aspect("equal")
+ax.pcolormesh(
+    x,
+    y,
+    cells_irrad,
+    shading="nearest",
+    edgecolors="black",
+    cmap=color_map,
+    norm=color_norm,
+)
+
+# %%
+# Relative Mean Absolute Difference
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+# Calculate the Relative Mean Absolute Difference (RMAD) of the cells'
+# irradiances with the following function, Eq. (4) of [1]_:
+#
+# .. math::
+#
+#    \Delta \left[ \% \right] = \frac{1}{n^2 \bar{G}_{total}}
+#    \sum_{i=1}^{n} \sum_{j=1}^{n} \lvert G_{total,i} - G_{total,j} \rvert
+#
+
+
+def rmad(data, axis=None):
+    """
+    Relative Mean Absolute Difference.
+    https://stackoverflow.com/a/19472336/19371110
+    """
+    mad = np.mean(np.absolute(data - np.mean(data, axis)), axis)
+    return mad / np.mean(data, axis)
+
+
+rmad_cells = rmad(cells_irrad)
+
+# this is the same as a column's RMAD!
+print(rmad_cells == rmad(cells_irrad[:, 0]))
+
+# %%
+# Mismatch Loss
+# ^^^^^^^^^^^^^
+# Calculate the power loss percentage due to the irradiance non-uniformity
+# with the function
+# :py:func:`pvlib.bifacial.power_mismatch_deline `.
+
+mismatch_loss = power_mismatch_deline(rmad_cells)
+
+print(f"RMAD of the cells' irradiance: {rmad_cells:.3} [unitless]")
+print(f"Power loss due to the irradiance non-uniformity: {mismatch_loss:.3%}")

docs/sphinx/source/reference/bifacial.rst

@@ -12,6 +12,13 @@ Functions for calculating front and back surface irradiance
    bifacial.infinite_sheds.get_irradiance
    bifacial.infinite_sheds.get_irradiance_poa
 
+Loss models that are specific to bifacial PV systems
+
+.. autosummary::
+   :toctree: generated/
+
+   bifacial.power_mismatch_deline
+
 Utility functions for bifacial modeling
 
 .. autosummary::

docs/sphinx/source/whatsnew/v0.11.0.rst

@@ -32,6 +32,9 @@ Enhancements
   efficiency ([unitless]) and vice versa. The conversion functions are
   :py:func:`pvlib.spectrum.sr_to_qe` and :py:func:`pvlib.spectrum.qe_to_sr`
   respectively. (:issue:`2040`, :pull:`2041`)
+* Add new losses function that accounts for non-uniform irradiance of bifacial
+  modules, :py:func:`pvlib.bifacial.power_mismatch_deline `.
+  (:issue:`2045`, :pr:`2046`)
 
 
 Bug fixes

pvlib/bifacial/__init__.py

@@ -1,10 +1,10 @@
 """
-The ``bifacial`` module contains functions to model irradiance for bifacial
-modules.
-
+The ``bifacial`` submodule contains functions to model bifacial modules.
 """
+
 from pvlib._deprecation import deprecated
-from pvlib.bifacial import pvfactors, infinite_sheds, utils   # noqa: F401
+from pvlib.bifacial import pvfactors, infinite_sheds, utils  # noqa: F401
+from .loss_models import power_mismatch_deline  # noqa: F401
 
 pvfactors_timeseries = deprecated(
     since='0.9.1',

pvlib/bifacial/loss_models.py

@@ -0,0 +1,171 @@
+import numpy as np
+
+from typing import Literal
+
+
+def power_mismatch_deline(
+    rmad,
+    model: Literal[
+        "fixed-tilt", "single-axis-tracking"
+    ] = "single-axis-tracking",
+    fillfactor: float = None,
+):
+    r"""
+    Estimate DC power loss due to irradiance non-uniformity.
+
+    This model is described for bifacial modules in [1]_, where the backside
+    irradiance is less uniform due to mounting and site conditions.
+
+    Depending on the mounting type, the power loss is estimated with either
+    equation (11) or (12) of [1]_. Passing a custom polynomial is also valid.
+
+    Use ``fillfactor`` to account for different fill factors between the
+    trained model and the module of interest.
+    For example, if the fill factor of the module of interest is
+    0.65, then set ``fillfactor=0.65``.
+
+    .. versionadded:: 0.11.0
+
+    Parameters
+    ----------
+    rmad : numeric
+        The Relative Mean Absolute Difference of the cell-by-cell total
+        irradiance. [Unitless]
+        Check out the *Notes* section for the equation to calculate it from the
+        bifaciality and the front and back irradiances.
+
+    model : str, numpy.polynomial.polynomial.Polynomial or list, default ``"single-axis-tracking"``
+        The model coefficients to use.
+        If a string, it must be one of the following:
+
+        * ``"fixed-tilt"``: Eq. (11) of [1]_.
+        * ``"single-axis-tracking"``: Eq. (12) of [1]_.
+
+        If a :external:class:`numpy.polynomial.polynomial.Polynomial`,
+        it is evaluated as is.
+
+        If neither a string nor a ``Polynomial``, it must be the coefficients
+        of a polynomial in ``rmad``, where the first element is the constant
+        term and the last element is the highest order term. A
+        :external:class:`~numpy.polynomial.polynomial.Polynomial`
+        will be created internally.
+
+    fillfactor : float, optional
+        Fill factor at standard test condition (STC) of the module.
+        Accounts for different fill factors between the trained model and the
+        module under non-uniform irradiance.
+        Models from [1]_ were calculated for a ``fillfactor`` of 0.79.
+        This parameter will only be used if ``model`` is a string.
+        Raises a ``ValueError`` if the model is a custom polynomial.
+        Internally, this argument applies :ref:`Equation (7) <fillfactor_eq>`.
+
+    Returns
+    -------
+    loss : numeric
+        The power loss.
+
+    Raises
+    ------
+    ValueError
+        If the model is not a string and ``fillfactor`` is not ``None``.
+
+    Notes
+    -----
+    The models implemented are equations (11) and (12) of [1]_:
+
+    .. math::
+
+       \text{model="fixed-tilt"} & \Rightarrow M[\%] =
+       0.142 \Delta[\%] + 0.032 \Delta[\%]^2 \qquad & \text{(11)}
+
+       \text{model="single-axis-tracking"} & \Rightarrow M[\%] =
+       0.054 \Delta[\%] + 0.068 \Delta[\%]^2 \qquad & \text{(12)}
+
+    where :math:`\Delta[\%]` is the Relative Mean Absolute Difference of the
+    global irradiance, Eq. (4) of [1]_ and [2]_.
+
+    The losses definition is Eq. (1) of [1]_, and it's defined as a loss of the
+    output power:
+
+    .. math::
+
+       M[\%] = 1 - \frac{P_{Array}}{\sum P_{Cells}} \qquad \text{(1)}
+
+    To account for a module with a fill factor distinct from the one used to
+    train the model (0.79), the output of the model can be modified by Eq. (7):
+
+    .. _fillfactor_eq:
+
+    .. math::
+
+       M[\%]_{FF_1} = M[\%]_{FF_0} \frac{FF_1}{FF_0} \qquad \text{(7)}
+
+    In the section *See Also*, you will find two packages that can be used to
+    calculate the irradiance at different points of the module.
+
+    .. note::
+       The global irradiance RMAD is different from the backside irradiance
+       RMAD.
+
+    In case the RMAD of the backside irradiance is known, the global RMAD can
+    be calculated as follows, assuming the front irradiance RMAD is
+    negligible [2]_:
+
+    .. math::
+
+       RMAD(k \cdot X + c) = RMAD(X) \cdot k \frac{k \bar{X}}{k \bar{X} + c}
+       = RMAD(X) \cdot k \frac{1}{1 + \frac{c}{k \bar{X}}}
+
+    by similarity with equation (2) of [1]_:
+
+    .. math::
+
+       G_{total\,i} = G_{front\,i} + \phi_{Bifi} G_{rear\,i} \qquad \text{(2)}
+
+    See Also
+    --------
+    `solarfactors <https://github.com/pvlib/solarfactors/>`_
+        Calculate the irradiance at different points of the module.
+    `bifacial_radiance <https://github.com/NREL/bifacial_radiance>`_
+        Calculate the irradiance at different points of the module.
+
+    References
+    ----------
+    .. [1] C. Deline, S. Ayala Pelaez, S. MacAlpine, and C. Olalla, 'Estimating
+       and parameterizing mismatch power loss in bifacial photovoltaic
+       systems', Progress in Photovoltaics: Research and Applications, vol. 28,
+       no. 7, pp. 691-703, 2020, :doi:`10.1002/pip.3259`.
+    .. [2] “Mean absolute difference,” Wikipedia, Sep. 05, 2023.
+       https://en.wikipedia.org/wiki/Mean_absolute_difference#Relative_mean_absolute_difference
+       (accessed 2024-04-14).
+    """  # noqa: E501
+    if isinstance(model, str):
+        _MODEL_POLYNOMS = {
+            "fixed-tilt": [0, 0.142, 0.032],  # Eq. (11), [1]
+            "single-axis-tracking": [0, 0.054, 0.068],  # Eq. (12), [1]
+        }
+        try:
+            model_polynom = np.polynomial.Polynomial(_MODEL_POLYNOMS[model])
+        except KeyError:
+            raise ValueError(
+                f"Invalid model '{model}'. Available models are "
+                f"{list(_MODEL_POLYNOMS.keys())}."
+            )
+        else:
+            if fillfactor:
+                # Use fillfactor to modify output of a known trained model
+                # Eq. (7), [1]
+                model_polynom = model_polynom * fillfactor / 0.79
+    else:
+        if fillfactor:
+            raise ValueError(
+                "Fill factor can only be used with predefined models. "
+                "Modify polynomial or multiply output by "
+                "'module_fillfactor / training_fillfactor'."
+            )
+        if isinstance(model, np.polynomial.Polynomial):
+            model_polynom = model
+        else:  # expect an iterable
+            model_polynom = np.polynomial.Polynomial(coef=model)
+
+    return model_polynom(rmad)