From a7d0070a06a955c718b8551d73cb0a4f54e136a8 Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Thu, 10 Nov 2022 18:32:17 +0100
Subject: [PATCH 01/35] First prototype

---
 pvlib/spectrum/__init__.py   |   3 +-
 pvlib/spectrum/mismatch.py   | 151 +++++++++++++++++++++++++++++++++++
 pvlib/tests/test_spectrum.py | 139 +++++++++++++++++++++++++++++++-
 3 files changed, 290 insertions(+), 3 deletions(-)

diff --git a/pvlib/spectrum/__init__.py b/pvlib/spectrum/__init__.py
index b3d838acfe..efdab55c1c 100644
--- a/pvlib/spectrum/__init__.py
+++ b/pvlib/spectrum/__init__.py
@@ -1,3 +1,4 @@
 from pvlib.spectrum.spectrl2 import spectrl2  # noqa: F401
 from pvlib.spectrum.mismatch import (get_example_spectral_response, get_am15g,
-                                     calc_spectral_mismatch_field)
+                                     calc_spectral_mismatch_field,
+                                     martin_ruiz_spectral_modifier)
diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index 5db4649ddd..a069ac7251 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -7,6 +7,7 @@
 import pandas as pd
 from scipy.interpolate import interp1d
 import os
+from warnings import warn
 
 
 def get_example_spectral_response(wavelength=None):
@@ -235,3 +236,153 @@ def integrate(e):
         smm = pd.Series(smm, index=e_sun.index)
 
     return smm
+
+
+def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
+                                  cell_type=None, model_parameters=None):
+    r"""
+    Calculate mismatch modifiers for POA direct, sky diffuse and ground diffuse
+    irradiances due to material's spectral response to spectrum characterised
+    by the clearness index and the absolute airmass, with respect to the
+    standard spectrum.
+
+    .. warning::
+        Included model parameters for ``monosi``, ``polysi`` and ``asi`` were
+        estimated using the airmass model ``kasten1966`` [1]_. It is heavily
+        recommended to use the same model in order to not introduce errors.
+        See :py:func:`~pvlib.atmosphere.get_relative_airmass`.
+
+    Parameters
+    ----------
+    clearness_index : numeric
+        Clearness index of the sky.
+        Should be obtained through :py:func:`~pvlib.irradiance.clearness_index`
+
+    airmass_absolute : numeric
+        Absolute airmass. Give attention to algorithm used (``kasten1966`` is
+        recommended for default parameters of ``monosi``, ``polysi`` and
+        ``asi``, as used in [1]_).
+
+    cell_type : string or None, default None
+        Specifies material of the cell in order to infer model parameters.
+        Allowed types are ``monosi``, ``polysi`` and ``asi``, either lower or
+        upper case. If None, the parameters must be provided.
+
+    model_parameters : dict-like or None, default None
+        In case you want to specify your model parameters use a dict or a
+        ``pd.DataFrame`` as follows:
+
+        .. code-block:: python
+
+            # Using a dict
+            model_parameters = {
+                'direct': {'c': c1, 'a': a1, 'b': b1},
+                'sky_diffuse': {'c': c2, 'a': a2, 'b': b2},
+                'ground_diffuse': {'c': c3, 'a': a3, 'b': b3}
+            }
+            # Using a pd.DataFrame
+            model_parameters = pd.DataFrame({
+                'direct': [a1, b1, c1],
+                'sky diffuse':  [a2, b2, c2],
+                'ground diffuse':  [a3, b3, c3]},
+                index=('a', 'b', 'c'))
+
+        ``a``, ``b`` and ``c`` must be scalar.
+
+    Returns
+    -------
+    Mismatch modifiers : pd.Series of numeric
+        Modifiers for direct, sky diffuse and ground diffuse irradiances, with
+        indexes ``direct``, ``sky_diffuse``, ``ground_diffuse``.
+        Each mismatch modifier should be multiplied by its corresponding
+        POA component.
+
+    Raises
+    ------
+    ValueError
+        If ``model_parameters`` is not suitable. See example given above.
+    TypeError
+        If neither ``cell_type`` nor ``model_parameters`` are given.
+    NotImplementedError
+        If ``cell_type`` is not found in internal table of parameters.
+
+    Notes
+    -----
+    The mismatch modifier is defined as
+
+    .. math:: M = c \cdot \exp( a \cdot (K_t - 0.74) + b \cdot (AM - 1.5) )
+    
+    where ``a``, ``b`` and ``c`` are the model parameters, different for each
+    irradiance component.
+
+    References
+    ----------
+    .. [1] Martín, N. and Ruiz, J.M. (1999), A new method for the spectral
+       characterisation of PV modules. Prog. Photovolt: Res. Appl., 7: 299-310.
+       :doi:10.1002/(SICI)1099-159X(199907/08)7:4<299::AID-PIP260>3.0.CO;2-0
+
+    See Also
+    --------
+    pvlib.irradiance.clearness_index
+    pvlib.atmosphere.get_relative_airmass
+    pvlib.atmosphere.get_absolute_airmass
+    pvlib.atmosphere.first_solar_spectral_correction
+    """
+
+    IRRAD_COMPONENTS = ('direct', 'sky_diffuse', 'ground_diffuse')
+    # Fitting parameters directly from [1]_
+    MARTIN_RUIZ_PARAMS = pd.DataFrame(
+        index=('monosi', 'polysi', 'asi'),
+        columns=pd.MultiIndex.from_product([IRRAD_COMPONENTS,
+                                           ('c', 'a', 'b')]),
+        data=[  # Direct(c,a,b)  | Sky diffuse(c,a,b) | Ground diffuse(c,a,b)
+            [1.029, -.313, 524e-5, .764, -.882, -.0204, .970, -.244, .0129],
+            [1.029, -.311, 626e-5, .764, -.929, -.0192, .970, -.270, .0158],
+            [1.024, -.222, 920e-5, .840, -.728, -.0183, .989, -.219, .0179],
+        ])
+
+    # Argument validation and choose components and model parameters
+    if cell_type is not None and model_parameters is None:
+        # Infer parameters from cell material
+        cell_type_lower = cell_type.lower()
+        if cell_type_lower in MARTIN_RUIZ_PARAMS.index:
+            _params = MARTIN_RUIZ_PARAMS.loc[cell_type_lower]
+        else:
+            raise NotImplementedError('Cell type parameters not defined in '
+                                      'algorithm! Allowed types are '
+                                      f'{tuple(MARTIN_RUIZ_PARAMS.index)}')
+    elif cell_type is None and model_parameters is None:
+        raise TypeError('You must pass at least "cell_type" '
+                        'or "model_parameters" as arguments!')
+    elif model_parameters is not None:
+        # Use user-defined model parameters
+        # Validate 'model_parameters' dict keys and sub-dicts keys
+        if (set(IRRAD_COMPONENTS) != model_parameters.keys()):
+            raise ValueError('You must specify model parameters for exact '
+                             f'irradiance components {IRRAD_COMPONENTS}')
+        if any([{'a', 'b', 'c'} != model_parameters[irrad_type].keys()
+                for irrad_type in IRRAD_COMPONENTS]):
+            raise ValueError("You must specify model parameters with keys "
+                             "'a','b','c' for each irradiation component.")
+
+        _params = model_parameters
+        if cell_type is not None:
+            warn('Both "cell_type" and "model_parameters" given! '
+                 'Using provided "model_parameters".')
+
+    # Compute difference to avoid recalculating inside loop
+    kt_delta = clearness_index - 0.74
+    am_delta = airmass_absolute - 1.5
+
+    modifiers = pd.Series()
+
+    # Order of irradiations shouldn't be changed
+    # Values are tested in return order in test_martin_ruiz_spectral_modifier
+    for irrad_type in IRRAD_COMPONENTS:
+        _coeffs = _params[irrad_type]
+
+        modifier = _coeffs['c'] * np.exp(_coeffs['a'] * kt_delta
+                                         + _coeffs['b'] * am_delta)
+        modifiers[irrad_type] = modifier
+
+    return modifiers
diff --git a/pvlib/tests/test_spectrum.py b/pvlib/tests/test_spectrum.py
index 80b53d2af3..41fcfb29c4 100644
--- a/pvlib/tests/test_spectrum.py
+++ b/pvlib/tests/test_spectrum.py
@@ -4,10 +4,11 @@
 import numpy as np
 from pvlib import spectrum
 
-from .conftest import DATA_DIR
+from .conftest import DATA_DIR, assert_series_equal
 
 SPECTRL2_TEST_DATA = DATA_DIR / 'spectrl2_example_spectra.csv'
 
+
 @pytest.fixture
 def spectrl2_data():
     # reference spectra generated with solar_utils==0.3
@@ -140,7 +141,7 @@ def test_get_am15g():
 
 def test_calc_spectral_mismatch_field(spectrl2_data):
     # test that the mismatch is calculated correctly with
-    # - default and custom reference sepctrum
+    # - default and custom reference spectrum
     # - single or multiple sun spectra
 
     # sample data
@@ -171,3 +172,137 @@ def test_calc_spectral_mismatch_field(spectrl2_data):
     mm = spectrum.calc_spectral_mismatch_field(sr, e_sun=e_sun)
     assert mm.index is e_sun.index
     assert_allclose(mm, expected, rtol=1e-6)
+
+
+def test_martin_ruiz_spectral_modifier():
+    # tests with only cell_type given
+    # test with scalar values
+    clearness_index = 0.82
+    airmass_absolute = 1.2
+    # Expected values: Direct | Sky diffuse | Ground diffuse
+    # Do not change order in any 'expected' values list
+    expected = (1.00197741, 0.71632057, 0.94757498)
+
+    result = \
+        spectrum.martin_ruiz_spectral_modifier(clearness_index,
+                                               airmass_absolute,
+                                               cell_type='monosi')
+    assert_approx_equal(result['direct'], expected[0])
+    assert_approx_equal(result['sky_diffuse'], expected[1])
+    assert_approx_equal(result['ground_diffuse'], expected[2])
+
+    # test NaN in, NaN out
+    clearness_index = 0.82
+    airmass_absolute = np.nan
+    result = spectrum.martin_ruiz_spectral_modifier(clearness_index,
+                                                    airmass_absolute,
+                                                    cell_type='monosi')
+    assert result.isna().all()
+
+    # test with Series input
+    clearness_index = pd.Series([0.56, 0.67, 0.80])
+    airmass_absolute = pd.Series([1.6, 1.4, 1.2])
+    expected = (
+        pd.Series([1.088928, 1.050989, 1.008082]),  # Direct
+        pd.Series([0.901327, 0.816901, 0.726754]),  # Sky diffuse
+        pd.Series([1.019917, 0.986947, 0.949899]))  # Ground diffuse
+
+    result = \
+        spectrum.martin_ruiz_spectral_modifier(clearness_index,
+                                               airmass_absolute,
+                                               cell_type='polysi')
+    assert_series_equal(result['direct'], expected[0], atol=1e-5)
+    assert_series_equal(result['sky_diffuse'], expected[1], atol=1e-5)
+    assert_series_equal(result['ground_diffuse'], expected[2], atol=1e-5)
+
+    # test results when giving 'model_parameters' as DataFrame
+    clearness_index = np.array([0.56, 0.612, 0.664, 0.716, 0.768, 0.82])
+    airmass_absolute = np.array([2, 1.8, 1.6, 1.4, 1.2, 1])
+    model_parameters = pd.DataFrame({  # monosi values
+        'direct': [1.029, -0.313, 0.00524],
+        'sky diffuse':  [0.764, -0.882, -0.0204],
+        'ground diffuse':  [0.97, -0.244, 0.0129]},
+        index=('c', 'a', 'b'))
+    expected = (  # Direct / Sky diffuse / Ground diffuse
+        np.array([1.09149, 1.07274, 1.05432, 1.03621, 1.01841, 1.00092]),
+        np.array([0.88636, 0.85009, 0.81530, 0.78193, 0.74993, 0.71924]),
+        np.array([1.02011, 1.00465, 0.98943, 0.97443, 0.95967, 0.94513]))
+
+    result = spectrum.martin_ruiz_spectral_modifier(
+        clearness_index,
+        airmass_absolute,
+        cell_type='asi',
+        model_parameters=model_parameters)
+    assert_allclose(result['direct'], expected[0], atol=1e-5)
+    assert_allclose(result['sky_diffuse'], expected[1], atol=1e-5)
+    assert_allclose(result['ground_diffuse'], expected[2], atol=1e-5)
+
+    # test warning is raised with both 'cell_type' and 'model_parameters'
+    # test results when giving 'model_parameters' as dict
+    clearness_index = np.array([0.56, 0.612, 0.664, 0.716, 0.768, 0.82])
+    airmass_absolute = np.array([2, 1.8, 1.6, 1.4, 1.2, 1])
+    model_parameters = {  # Using 'monosi' values
+        'direct': {'c': 1.029, 'a': -3.13e-1, 'b': 5.24e-3},
+        'sky_diffuse': {'c': 0.764, 'a': -8.82e-1, 'b': -2.04e-2},
+        'ground_diffuse': {'c': 0.970, 'a': -2.44e-1, 'b': 1.29e-2}}
+    expected = (  # Direct / Sky diffuse / Ground diffuse
+        np.array([1.09149, 1.07274, 1.05432, 1.03621, 1.01841, 1.00092]),
+        np.array([0.88636, 0.85009, 0.81530, 0.78193, 0.74993, 0.71924]),
+        np.array([1.02011, 1.00465, 0.98943, 0.97443, 0.95967, 0.94513]))
+
+    with pytest.warns(UserWarning,
+                      match='Both "cell_type" and "model_parameters" given! '
+                            'Using provided "model_parameters".'):
+        result = spectrum.martin_ruiz_spectral_modifier(
+            clearness_index,
+            airmass_absolute,
+            cell_type='asi',
+            model_parameters=model_parameters)
+        assert_allclose(result['direct'], expected[0], atol=1e-5)
+        assert_allclose(result['sky_diffuse'], expected[1], atol=1e-5)
+        assert_allclose(result['ground_diffuse'], expected[2], atol=1e-5)
+
+
+def test_martin_ruiz_spectral_modifier_errors():
+    # mock values to run errors
+    clearness_index = 0.75
+    airmass_absolute = 1.6
+    # test exception raised when cell_type does not exist in algorithm
+    with pytest.raises(NotImplementedError,
+                       match='Cell type parameters not defined in algorithm!'):
+        _ = spectrum.martin_ruiz_spectral_modifier(clearness_index,
+                                                   airmass_absolute,
+                                                   cell_type='')
+    # test exception raised when missing cell_type and model_parameters
+    with pytest.raises(TypeError,
+                       match='You must pass at least "cell_type" '
+                             'or "model_parameters" as arguments!'):
+        _ = spectrum.martin_ruiz_spectral_modifier(clearness_index,
+                                                   airmass_absolute)
+    # tests for inadequate "model_parameters"
+    clearness_index = 0.74
+    airmass_absolute = 1.5
+    # test for error on irradiances keys
+    model_parameters = {
+        'direct': {'c': 1.029, 'a': -3.13e-1, 'b': 5.24e-3},
+        'sky_diffuse': {'c': 0.764, 'a': -8.82e-1, 'b': -2.04e-2},
+        ':(': {'c': 0.970, 'a': -2.44e-1, 'b': 1.29e-2}}
+    with pytest.raises(ValueError,
+                       match='You must specify model parameters for exact '
+                             'irradiance components '):
+        _ = spectrum.martin_ruiz_spectral_modifier(
+            clearness_index,
+            airmass_absolute,
+            model_parameters=model_parameters)
+    # test for error on params keys
+    model_parameters = {
+        'direct': {'c': 1.029, 'a': -3.13e-1, 'b': 5.24e-3},
+        'sky_diffuse': {'c': 0.764, 'a': -8.82e-1, 'b': -2.04e-2},
+        'ground_diffuse': {'z': 0.970, 'x': -2.44e-1, 'y': 1.29e-2}}
+    with pytest.raises(ValueError,
+                       match="You must specify model parameters with keys "
+                             "'a','b','c' for each irradiation component."):
+        _ = spectrum.martin_ruiz_spectral_modifier(
+            clearness_index,
+            airmass_absolute,
+            model_parameters=model_parameters)

From 60a63fd163e9457290c39540824faaa40975357a Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Sun, 13 Nov 2022 18:43:38 +0100
Subject: [PATCH 02/35] Allow for custom irradiations in 'model_parameters'

---
 pvlib/spectrum/mismatch.py   | 35 ++++++++++++++++-------------------
 pvlib/tests/test_spectrum.py | 26 +++++---------------------
 2 files changed, 21 insertions(+), 40 deletions(-)

diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index a069ac7251..d4a66cb9c9 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -261,7 +261,7 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
     airmass_absolute : numeric
         Absolute airmass. Give attention to algorithm used (``kasten1966`` is
         recommended for default parameters of ``monosi``, ``polysi`` and
-        ``asi``, as used in [1]_).
+        ``asi``, see reference [1]_).
 
     cell_type : string or None, default None
         Specifies material of the cell in order to infer model parameters.
@@ -269,8 +269,8 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
         upper case. If None, the parameters must be provided.
 
     model_parameters : dict-like or None, default None
-        In case you want to specify your model parameters use a dict or a
-        ``pd.DataFrame`` as follows:
+        In case you want to specify your model parameters and components
+        use a dict or a ``pd.DataFrame`` as follows:
 
         .. code-block:: python
 
@@ -283,8 +283,7 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
             # Using a pd.DataFrame
             model_parameters = pd.DataFrame({
                 'direct': [a1, b1, c1],
-                'sky diffuse':  [a2, b2, c2],
-                'ground diffuse':  [a3, b3, c3]},
+                'diffuse':  [a2, b2, c2]},
                 index=('a', 'b', 'c'))
 
         ``a``, ``b`` and ``c`` must be scalar.
@@ -300,7 +299,7 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
     Raises
     ------
     ValueError
-        If ``model_parameters`` is not suitable. See example given above.
+        If ``model_parameters`` is not suitable. See examples given above.
     TypeError
         If neither ``cell_type`` nor ``model_parameters`` are given.
     NotImplementedError
@@ -311,7 +310,7 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
     The mismatch modifier is defined as
 
     .. math:: M = c \cdot \exp( a \cdot (K_t - 0.74) + b \cdot (AM - 1.5) )
-    
+
     where ``a``, ``b`` and ``c`` are the model parameters, different for each
     irradiance component.
 
@@ -329,11 +328,11 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
     pvlib.atmosphere.first_solar_spectral_correction
     """
 
-    IRRAD_COMPONENTS = ('direct', 'sky_diffuse', 'ground_diffuse')
+    irrad_components = ('direct', 'sky_diffuse', 'ground_diffuse')
     # Fitting parameters directly from [1]_
     MARTIN_RUIZ_PARAMS = pd.DataFrame(
         index=('monosi', 'polysi', 'asi'),
-        columns=pd.MultiIndex.from_product([IRRAD_COMPONENTS,
+        columns=pd.MultiIndex.from_product([irrad_components,
                                            ('c', 'a', 'b')]),
         data=[  # Direct(c,a,b)  | Sky diffuse(c,a,b) | Ground diffuse(c,a,b)
             [1.029, -.313, 524e-5, .764, -.882, -.0204, .970, -.244, .0129],
@@ -354,14 +353,13 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
     elif cell_type is None and model_parameters is None:
         raise TypeError('You must pass at least "cell_type" '
                         'or "model_parameters" as arguments!')
-    elif model_parameters is not None:
-        # Use user-defined model parameters
-        # Validate 'model_parameters' dict keys and sub-dicts keys
-        if (set(IRRAD_COMPONENTS) != model_parameters.keys()):
-            raise ValueError('You must specify model parameters for exact '
-                             f'irradiance components {IRRAD_COMPONENTS}')
-        if any([{'a', 'b', 'c'} != model_parameters[irrad_type].keys()
-                for irrad_type in IRRAD_COMPONENTS]):
+    elif model_parameters is not None:  # Use user-defined model parameters
+        # Overwrite components, to later iterate over them,
+        # in case user wants to specify their components
+        irrad_components = model_parameters.keys()
+        # Validate 'model_parameters' sub-dicts keys
+        if any([{'a', 'b', 'c'} != set(model_parameters[component].keys())
+                for component in irrad_components]):
             raise ValueError("You must specify model parameters with keys "
                              "'a','b','c' for each irradiation component.")
 
@@ -376,9 +374,8 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
 
     modifiers = pd.Series()
 
-    # Order of irradiations shouldn't be changed
     # Values are tested in return order in test_martin_ruiz_spectral_modifier
-    for irrad_type in IRRAD_COMPONENTS:
+    for irrad_type in irrad_components:
         _coeffs = _params[irrad_type]
 
         modifier = _coeffs['c'] * np.exp(_coeffs['a'] * kt_delta
diff --git a/pvlib/tests/test_spectrum.py b/pvlib/tests/test_spectrum.py
index 41fcfb29c4..6fb0f5a25e 100644
--- a/pvlib/tests/test_spectrum.py
+++ b/pvlib/tests/test_spectrum.py
@@ -216,26 +216,23 @@ def test_martin_ruiz_spectral_modifier():
     assert_series_equal(result['ground_diffuse'], expected[2], atol=1e-5)
 
     # test results when giving 'model_parameters' as DataFrame
+    # test custom quantity of components and its names can be given
     clearness_index = np.array([0.56, 0.612, 0.664, 0.716, 0.768, 0.82])
     airmass_absolute = np.array([2, 1.8, 1.6, 1.4, 1.2, 1])
     model_parameters = pd.DataFrame({  # monosi values
         'direct': [1.029, -0.313, 0.00524],
-        'sky diffuse':  [0.764, -0.882, -0.0204],
-        'ground diffuse':  [0.97, -0.244, 0.0129]},
+        'diffuse_sky':  [0.764, -0.882, -0.0204]},
         index=('c', 'a', 'b'))
     expected = (  # Direct / Sky diffuse / Ground diffuse
         np.array([1.09149, 1.07274, 1.05432, 1.03621, 1.01841, 1.00092]),
-        np.array([0.88636, 0.85009, 0.81530, 0.78193, 0.74993, 0.71924]),
-        np.array([1.02011, 1.00465, 0.98943, 0.97443, 0.95967, 0.94513]))
+        np.array([0.88636, 0.85009, 0.81530, 0.78193, 0.74993, 0.71924]))
 
     result = spectrum.martin_ruiz_spectral_modifier(
         clearness_index,
         airmass_absolute,
-        cell_type='asi',
         model_parameters=model_parameters)
     assert_allclose(result['direct'], expected[0], atol=1e-5)
-    assert_allclose(result['sky_diffuse'], expected[1], atol=1e-5)
-    assert_allclose(result['ground_diffuse'], expected[2], atol=1e-5)
+    assert_allclose(result['diffuse_sky'], expected[1], atol=1e-5)
 
     # test warning is raised with both 'cell_type' and 'model_parameters'
     # test results when giving 'model_parameters' as dict
@@ -279,22 +276,9 @@ def test_martin_ruiz_spectral_modifier_errors():
                              'or "model_parameters" as arguments!'):
         _ = spectrum.martin_ruiz_spectral_modifier(clearness_index,
                                                    airmass_absolute)
-    # tests for inadequate "model_parameters"
+    # test for error in params keys
     clearness_index = 0.74
     airmass_absolute = 1.5
-    # test for error on irradiances keys
-    model_parameters = {
-        'direct': {'c': 1.029, 'a': -3.13e-1, 'b': 5.24e-3},
-        'sky_diffuse': {'c': 0.764, 'a': -8.82e-1, 'b': -2.04e-2},
-        ':(': {'c': 0.970, 'a': -2.44e-1, 'b': 1.29e-2}}
-    with pytest.raises(ValueError,
-                       match='You must specify model parameters for exact '
-                             'irradiance components '):
-        _ = spectrum.martin_ruiz_spectral_modifier(
-            clearness_index,
-            airmass_absolute,
-            model_parameters=model_parameters)
-    # test for error on params keys
     model_parameters = {
         'direct': {'c': 1.029, 'a': -3.13e-1, 'b': 5.24e-3},
         'sky_diffuse': {'c': 0.764, 'a': -8.82e-1, 'b': -2.04e-2},

From 93f1038aae7daaa14625a4b1c9c2c7ee9c76578f Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Thu, 24 Nov 2022 17:26:21 +0100
Subject: [PATCH 03/35] Atomize tests with a fixture

* Upgrade docstring
---
 pvlib/spectrum/mismatch.py   |   2 +-
 pvlib/tests/test_spectrum.py | 208 ++++++++++++++++++++++-------------
 2 files changed, 134 insertions(+), 76 deletions(-)

diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index d4a66cb9c9..3c10e05f0a 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -256,7 +256,6 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
     ----------
     clearness_index : numeric
         Clearness index of the sky.
-        Should be obtained through :py:func:`~pvlib.irradiance.clearness_index`
 
     airmass_absolute : numeric
         Absolute airmass. Give attention to algorithm used (``kasten1966`` is
@@ -327,6 +326,7 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
     pvlib.atmosphere.get_absolute_airmass
     pvlib.atmosphere.first_solar_spectral_correction
     """
+    # Note tests for this function are prefixed with test_martin_ruiz_mm_*
 
     irrad_components = ('direct', 'sky_diffuse', 'ground_diffuse')
     # Fitting parameters directly from [1]_
diff --git a/pvlib/tests/test_spectrum.py b/pvlib/tests/test_spectrum.py
index 6fb0f5a25e..d051d1e322 100644
--- a/pvlib/tests/test_spectrum.py
+++ b/pvlib/tests/test_spectrum.py
@@ -174,115 +174,173 @@ def test_calc_spectral_mismatch_field(spectrl2_data):
     assert_allclose(mm, expected, rtol=1e-6)
 
 
-def test_martin_ruiz_spectral_modifier():
-    # tests with only cell_type given
-    # test with scalar values
-    clearness_index = 0.82
-    airmass_absolute = 1.2
-    # Expected values: Direct | Sky diffuse | Ground diffuse
-    # Do not change order in any 'expected' values list
-    expected = (1.00197741, 0.71632057, 0.94757498)
-
-    result = \
-        spectrum.martin_ruiz_spectral_modifier(clearness_index,
-                                               airmass_absolute,
-                                               cell_type='monosi')
-    assert_approx_equal(result['direct'], expected[0])
-    assert_approx_equal(result['sky_diffuse'], expected[1])
-    assert_approx_equal(result['ground_diffuse'], expected[2])
-
-    # test NaN in, NaN out
-    clearness_index = 0.82
-    airmass_absolute = np.nan
+@pytest.fixture
+def martin_ruiz_mismatch_data():
+    # Data to run tests of martin_ruiz_spectral_modifier
+    kwargs = {
+        'clearness_index': [0.56, 0.612, 0.664, 0.716, 0.768, 0.82],
+        'airmass_absolute': [2, 1.8, 1.6, 1.4, 1.2, 1],
+        'monosi_expected': {
+            'dir': [1.09149, 1.07275, 1.05432, 1.03622, 1.01842, 1.00093],
+            'sky': [0.88636, 0.85009, 0.81530, 0.78194, 0.74994, 0.71925],
+            'gnd': [1.02011, 1.00465, 0.98943, 0.97444, 0.95967, 0.94513]},
+        'polysi_expected': {
+            'dir': [1.09166, 1.07280, 1.05427, 1.03606, 1.01816, 1.00058],
+            'sky': [0.89443, 0.85553, 0.81832, 0.78273, 0.74868, 0.71612],
+            'gnd': [1.02638, 1.00888, 0.99168, 0.97476, 0.95814, 0.94180]},
+        'asi_expected': {
+            'dir': [1.07066, 1.05643, 1.04238, 1.02852, 1.01485, 1.00136],
+            'sky': [0.94889, 0.91699, 0.88616, 0.85637, 0.82758, 0.79976],
+            'gnd': [1.03801, 1.02259, 1.00740, 0.99243, 0.97769, 0.96316]},
+        'monosi_model_params_dict': {
+            'direct': {'c': 1.029, 'a': -3.13e-1, 'b': 5.24e-3},
+            'sky_diffuse': {'c': 0.764, 'a': -8.82e-1, 'b': -2.04e-2},
+            'ground_diffuse': {'c': 0.970, 'a': -2.44e-1, 'b': 1.29e-2}},
+        'monosi_custom_params_df': pd.DataFrame({
+            'direct': [1.029, -0.313, 0.00524],
+            'diffuse_sky': [0.764, -0.882, -0.0204]},
+            index=('c', 'a', 'b'))
+    }
+    return kwargs
+
+
+def test_martin_ruiz_mm_scalar(martin_ruiz_mismatch_data):
+    # test scalar input ; only cell_type given
+    clearness_index = martin_ruiz_mismatch_data['clearness_index'][0]
+    airmass_absolute = martin_ruiz_mismatch_data['airmass_absolute'][0]
+    result = spectrum.martin_ruiz_spectral_modifier(clearness_index,
+                                                    airmass_absolute,
+                                                    cell_type='asi')
+
+    assert_approx_equal(result['direct'],
+                        martin_ruiz_mismatch_data['asi_expected']['dir'][0],
+                        significant=5)
+    assert_approx_equal(result['sky_diffuse'],
+                        martin_ruiz_mismatch_data['asi_expected']['sky'][0],
+                        significant=5)
+    assert_approx_equal(result['ground_diffuse'],
+                        martin_ruiz_mismatch_data['asi_expected']['gnd'][0],
+                        significant=5)
+
+
+def test_martin_ruiz_mm_series(martin_ruiz_mismatch_data):
+    # test with Series input ; only cell_type given
+    clearness_index = pd.Series(martin_ruiz_mismatch_data['clearness_index'])
+    airmass_absolute = pd.Series(martin_ruiz_mismatch_data['airmass_absolute'])
+    expected = {
+        'dir': pd.Series(martin_ruiz_mismatch_data['polysi_expected']['dir']),
+        'sky': pd.Series(martin_ruiz_mismatch_data['polysi_expected']['sky']),
+        'gnd': pd.Series(martin_ruiz_mismatch_data['polysi_expected']['gnd'])}
+
+    result = spectrum.martin_ruiz_spectral_modifier(clearness_index,
+                                                    airmass_absolute,
+                                                    cell_type='polysi')
+    assert_series_equal(result['direct'], expected['dir'], atol=1e-5)
+    assert_series_equal(result['sky_diffuse'], expected['sky'], atol=1e-5)
+    assert_series_equal(result['ground_diffuse'], expected['gnd'], atol=1e-5)
+
+
+def test_martin_ruiz_mm_nans(martin_ruiz_mismatch_data):
+    # test NaN in, NaN out ; only cell_type given
+    clearness_index = pd.Series(martin_ruiz_mismatch_data['clearness_index'])
+    airmass_absolute = pd.Series(martin_ruiz_mismatch_data['airmass_absolute'])
+    airmass_absolute[:5] = np.nan
+
     result = spectrum.martin_ruiz_spectral_modifier(clearness_index,
                                                     airmass_absolute,
                                                     cell_type='monosi')
-    assert result.isna().all()
-
-    # test with Series input
-    clearness_index = pd.Series([0.56, 0.67, 0.80])
-    airmass_absolute = pd.Series([1.6, 1.4, 1.2])
-    expected = (
-        pd.Series([1.088928, 1.050989, 1.008082]),  # Direct
-        pd.Series([0.901327, 0.816901, 0.726754]),  # Sky diffuse
-        pd.Series([1.019917, 0.986947, 0.949899]))  # Ground diffuse
-
-    result = \
-        spectrum.martin_ruiz_spectral_modifier(clearness_index,
-                                               airmass_absolute,
-                                               cell_type='polysi')
-    assert_series_equal(result['direct'], expected[0], atol=1e-5)
-    assert_series_equal(result['sky_diffuse'], expected[1], atol=1e-5)
-    assert_series_equal(result['ground_diffuse'], expected[2], atol=1e-5)
+    assert np.isnan(result['direct'][:5]).all()
+    assert not np.isnan(result['direct'][5:]).any()
+    assert np.isnan(result['sky_diffuse'][:5]).all()
+    assert not np.isnan(result['sky_diffuse'][5:]).any()
+    assert np.isnan(result['ground_diffuse'][:5]).all()
+    assert not np.isnan(result['ground_diffuse'][5:]).any()
+
+
+def test_martin_ruiz_mm_model_dict(martin_ruiz_mismatch_data):
+    # test results when giving 'model_parameters' as dict
+    # test custom quantity of components and its names can be given
+    clearness_index = pd.Series(martin_ruiz_mismatch_data['clearness_index'])
+    airmass_absolute = pd.Series(martin_ruiz_mismatch_data['airmass_absolute'])
+    expected = {
+        'dir': pd.Series(martin_ruiz_mismatch_data['monosi_expected']['dir']),
+        'sky': pd.Series(martin_ruiz_mismatch_data['monosi_expected']['sky']),
+        'gnd': pd.Series(martin_ruiz_mismatch_data['monosi_expected']['gnd'])}
+    model_parameters = martin_ruiz_mismatch_data['monosi_model_params_dict']
+
+    result = spectrum.martin_ruiz_spectral_modifier(
+        clearness_index,
+        airmass_absolute,
+        model_parameters=model_parameters)
+    assert_allclose(result['direct'], expected['dir'], atol=1e-5)
+    assert_allclose(result['sky_diffuse'], expected['sky'], atol=1e-5)
+    assert_allclose(result['ground_diffuse'], expected['gnd'], atol=1e-5)
 
+
+def test_martin_ruiz_mm_model_df(martin_ruiz_mismatch_data):
     # test results when giving 'model_parameters' as DataFrame
     # test custom quantity of components and its names can be given
-    clearness_index = np.array([0.56, 0.612, 0.664, 0.716, 0.768, 0.82])
-    airmass_absolute = np.array([2, 1.8, 1.6, 1.4, 1.2, 1])
-    model_parameters = pd.DataFrame({  # monosi values
-        'direct': [1.029, -0.313, 0.00524],
-        'diffuse_sky':  [0.764, -0.882, -0.0204]},
-        index=('c', 'a', 'b'))
-    expected = (  # Direct / Sky diffuse / Ground diffuse
-        np.array([1.09149, 1.07274, 1.05432, 1.03621, 1.01841, 1.00092]),
-        np.array([0.88636, 0.85009, 0.81530, 0.78193, 0.74993, 0.71924]))
+    clearness_index = np.array(martin_ruiz_mismatch_data['clearness_index'])
+    airmass_absolute = np.array(martin_ruiz_mismatch_data['airmass_absolute'])
+    model_parameters = martin_ruiz_mismatch_data['monosi_custom_params_df']
+    expected = {
+        'dir': np.array(martin_ruiz_mismatch_data['monosi_expected']['dir']),
+        'sky': np.array(martin_ruiz_mismatch_data['monosi_expected']['sky'])}
 
     result = spectrum.martin_ruiz_spectral_modifier(
         clearness_index,
         airmass_absolute,
         model_parameters=model_parameters)
-    assert_allclose(result['direct'], expected[0], atol=1e-5)
-    assert_allclose(result['diffuse_sky'], expected[1], atol=1e-5)
+    assert_allclose(result['direct'], expected['dir'], atol=1e-5)
+    assert_allclose(result['diffuse_sky'], expected['sky'], atol=1e-5)
+
 
+def test_martin_ruiz_mm_userwarning(martin_ruiz_mismatch_data):
     # test warning is raised with both 'cell_type' and 'model_parameters'
-    # test results when giving 'model_parameters' as dict
-    clearness_index = np.array([0.56, 0.612, 0.664, 0.716, 0.768, 0.82])
-    airmass_absolute = np.array([2, 1.8, 1.6, 1.4, 1.2, 1])
-    model_parameters = {  # Using 'monosi' values
-        'direct': {'c': 1.029, 'a': -3.13e-1, 'b': 5.24e-3},
-        'sky_diffuse': {'c': 0.764, 'a': -8.82e-1, 'b': -2.04e-2},
-        'ground_diffuse': {'c': 0.970, 'a': -2.44e-1, 'b': 1.29e-2}}
-    expected = (  # Direct / Sky diffuse / Ground diffuse
-        np.array([1.09149, 1.07274, 1.05432, 1.03621, 1.01841, 1.00092]),
-        np.array([0.88636, 0.85009, 0.81530, 0.78193, 0.74993, 0.71924]),
-        np.array([1.02011, 1.00465, 0.98943, 0.97443, 0.95967, 0.94513]))
+    clearness_index = pd.Series(martin_ruiz_mismatch_data['clearness_index'])
+    airmass_absolute = pd.Series(martin_ruiz_mismatch_data['airmass_absolute'])
+    model_parameters = martin_ruiz_mismatch_data['monosi_model_params_dict']
 
     with pytest.warns(UserWarning,
                       match='Both "cell_type" and "model_parameters" given! '
                             'Using provided "model_parameters".'):
-        result = spectrum.martin_ruiz_spectral_modifier(
+        _ = spectrum.martin_ruiz_spectral_modifier(
             clearness_index,
             airmass_absolute,
             cell_type='asi',
             model_parameters=model_parameters)
-        assert_allclose(result['direct'], expected[0], atol=1e-5)
-        assert_allclose(result['sky_diffuse'], expected[1], atol=1e-5)
-        assert_allclose(result['ground_diffuse'], expected[2], atol=1e-5)
 
 
-def test_martin_ruiz_spectral_modifier_errors():
-    # mock values to run errors
-    clearness_index = 0.75
-    airmass_absolute = 1.6
-    # test exception raised when cell_type does not exist in algorithm
+def test_martin_ruiz_mm_error_notimplemented(martin_ruiz_mismatch_data):
+    # test exception is raised when cell_type does not exist in algorithm
+    clearness_index = np.array(martin_ruiz_mismatch_data['clearness_index'])
+    airmass_absolute = np.array(martin_ruiz_mismatch_data['airmass_absolute'])
+
     with pytest.raises(NotImplementedError,
                        match='Cell type parameters not defined in algorithm!'):
         _ = spectrum.martin_ruiz_spectral_modifier(clearness_index,
                                                    airmass_absolute,
                                                    cell_type='')
-    # test exception raised when missing cell_type and model_parameters
+
+
+def test_martin_ruiz_mm_error_missing_params(martin_ruiz_mismatch_data):
+    # test exception is raised when missing cell_type and model_parameters
+    clearness_index = np.array(martin_ruiz_mismatch_data['clearness_index'])
+    airmass_absolute = np.array(martin_ruiz_mismatch_data['airmass_absolute'])
+
     with pytest.raises(TypeError,
                        match='You must pass at least "cell_type" '
                              'or "model_parameters" as arguments!'):
         _ = spectrum.martin_ruiz_spectral_modifier(clearness_index,
                                                    airmass_absolute)
-    # test for error in params keys
-    clearness_index = 0.74
-    airmass_absolute = 1.5
+
+
+def test_martin_ruiz_mm_error_model_keys(martin_ruiz_mismatch_data):
+    # test exception is raised when  in params keys
+    clearness_index = np.array(martin_ruiz_mismatch_data['clearness_index'])
+    airmass_absolute = np.array(martin_ruiz_mismatch_data['airmass_absolute'])
     model_parameters = {
-        'direct': {'c': 1.029, 'a': -3.13e-1, 'b': 5.24e-3},
-        'sky_diffuse': {'c': 0.764, 'a': -8.82e-1, 'b': -2.04e-2},
-        'ground_diffuse': {'z': 0.970, 'x': -2.44e-1, 'y': 1.29e-2}}
+        'component_example': {'z': 0.970, 'x': -2.44e-1, 'y': 1.29e-2}}
     with pytest.raises(ValueError,
                        match="You must specify model parameters with keys "
                              "'a','b','c' for each irradiation component."):

From f606cd8018009c1e4246631a3dec853c147dc35d Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Fri, 25 Nov 2022 01:53:35 +0100
Subject: [PATCH 04/35] Comply with 'optional' instead of 'default None'

Following #1574
---
 pvlib/spectrum/mismatch.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index 3c10e05f0a..302855b837 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -262,14 +262,14 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
         recommended for default parameters of ``monosi``, ``polysi`` and
         ``asi``, see reference [1]_).
 
-    cell_type : string or None, default None
+    cell_type : string, optional
         Specifies material of the cell in order to infer model parameters.
         Allowed types are ``monosi``, ``polysi`` and ``asi``, either lower or
         upper case. If None, the parameters must be provided.
 
-    model_parameters : dict-like or None, default None
         In case you want to specify your model parameters and components
         use a dict or a ``pd.DataFrame`` as follows:
+    model_parameters : dict-like, optional
 
         .. code-block:: python
 

From f79628af00ebb2cb26332ebe94ba0e8e0bc94ac5 Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Sat, 26 Nov 2022 01:05:51 +0100
Subject: [PATCH 05/35] Update docstring

---
 pvlib/spectrum/mismatch.py | 23 ++++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index 302855b837..44de01d79c 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -265,27 +265,32 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
     cell_type : string, optional
         Specifies material of the cell in order to infer model parameters.
         Allowed types are ``monosi``, ``polysi`` and ``asi``, either lower or
-        upper case. If None, the parameters must be provided.
+        upper case. If not specified, ``model_parameters`` must be provided.
 
-        In case you want to specify your model parameters and components
-        use a dict or a ``pd.DataFrame`` as follows:
     model_parameters : dict-like, optional
+        In case you computed the model parameters for any specified components.
+        Result keys will be the same as the input keys with each component in
+        ``model_parameters``, so it can easily be used when some parameters
+        are unknown.
+        Provide either a dict or a ``pd.DataFrame`` as follows:
 
         .. code-block:: python
 
             # Using a dict
+            # Return keys are the same as specifying 'cell_type'
             model_parameters = {
                 'direct': {'c': c1, 'a': a1, 'b': b1},
                 'sky_diffuse': {'c': c2, 'a': a2, 'b': b2},
                 'ground_diffuse': {'c': c3, 'a': a3, 'b': b3}
             }
-            # Using a pd.DataFrame
+            # Using a pd.DataFrame and grouping sky and ground diffuse
+            # Yields result with 'direct' & 'diffuse' keys only
             model_parameters = pd.DataFrame({
-                'direct': [a1, b1, c1],
-                'diffuse':  [a2, b2, c2]},
-                index=('a', 'b', 'c'))
+                'direct': [c1, a1, b1],
+                'diffuse':  [c2, a2, b2]},
+                index=('c', 'a', 'b'))
 
-        ``a``, ``b`` and ``c`` must be scalar.
+        ``c``, ``a`` and ``b`` must be scalar.
 
     Returns
     -------
@@ -310,7 +315,7 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
 
     .. math:: M = c \cdot \exp( a \cdot (K_t - 0.74) + b \cdot (AM - 1.5) )
 
-    where ``a``, ``b`` and ``c`` are the model parameters, different for each
+    where ``c``, ``a`` and ``b`` are the model parameters, different for each
     irradiance component.
 
     References

From a7b47b43231b20056897f69699e6bf10fd3b1bc8 Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Sat, 26 Nov 2022 01:46:48 +0100
Subject: [PATCH 06/35] Update docstring (2)

---
 pvlib/spectrum/mismatch.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index 44de01d79c..e4b184cb41 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -268,11 +268,11 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
         upper case. If not specified, ``model_parameters`` must be provided.
 
     model_parameters : dict-like, optional
-        In case you computed the model parameters for any specified components.
-        Result keys will be the same as the input keys with each component in
-        ``model_parameters``, so it can easily be used when some parameters
-        are unknown.
-        Provide either a dict or a ``pd.DataFrame`` as follows:
+        In case you computed the model parameters for any specified
+        components. Result keys will be the same as the input keys with each
+        component in ``model_parameters``, so it can easily be used when some
+        parameters are unknown. Provide either a dict or a ``pd.DataFrame`` as
+        follows:
 
         .. code-block:: python
 

From b9ec506a0043d6fae192aa370890a8cd7e28b9e5 Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Mon, 28 Nov 2022 22:28:14 +0100
Subject: [PATCH 07/35] Update comments

---
 pvlib/spectrum/mismatch.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index e4b184cb41..234a927bef 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -359,8 +359,7 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
         raise TypeError('You must pass at least "cell_type" '
                         'or "model_parameters" as arguments!')
     elif model_parameters is not None:  # Use user-defined model parameters
-        # Overwrite components, to later iterate over them,
-        # in case user wants to specify their components
+        # Overwrite components with user-specified ones
         irrad_components = model_parameters.keys()
         # Validate 'model_parameters' sub-dicts keys
         if any([{'a', 'b', 'c'} != set(model_parameters[component].keys())
@@ -379,7 +378,7 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
 
     modifiers = pd.Series()
 
-    # Values are tested in return order in test_martin_ruiz_spectral_modifier
+    # Calculate mismatch modifier for each irradiation
     for irrad_type in irrad_components:
         _coeffs = _params[irrad_type]
 

From 3a8630e65cda4ab65d03a0133f89c7870189f6ed Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Fri, 2 Dec 2022 12:12:57 +0100
Subject: [PATCH 08/35] Change return & model_parameters behaviour

Now, even if not given parameters for a irradiation, a result is yield with value None.
---
 pvlib/spectrum/mismatch.py   | 35 ++++++++++++++++++-----------------
 pvlib/tests/test_spectrum.py |  5 +++--
 2 files changed, 21 insertions(+), 19 deletions(-)

diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index 234a927bef..dedd2ea15d 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -268,11 +268,9 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
         upper case. If not specified, ``model_parameters`` must be provided.
 
     model_parameters : dict-like, optional
-        In case you computed the model parameters for any specified
-        components. Result keys will be the same as the input keys with each
-        component in ``model_parameters``, so it can easily be used when some
-        parameters are unknown. Provide either a dict or a ``pd.DataFrame`` as
-        follows:
+        In case you computed the model parameters. In case any component is not
+        specified, result will have a ``None`` value in its corresponding key.
+        Provide either a dict or a ``pd.DataFrame`` as follows:
 
         .. code-block:: python
 
@@ -283,22 +281,24 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
                 'sky_diffuse': {'c': c2, 'a': a2, 'b': b2},
                 'ground_diffuse': {'c': c3, 'a': a3, 'b': b3}
             }
-            # Using a pd.DataFrame and grouping sky and ground diffuse
-            # Yields result with 'direct' & 'diffuse' keys only
+            # Using a pd.DataFrame
             model_parameters = pd.DataFrame({
                 'direct': [c1, a1, b1],
-                'diffuse':  [c2, a2, b2]},
+                'sky_diffuse':  [c2, a2, b2],
+                'ground_diffuse': [c3, a3, b3]},
                 index=('c', 'a', 'b'))
 
         ``c``, ``a`` and ``b`` must be scalar.
 
     Returns
     -------
-    Mismatch modifiers : pd.Series of numeric
+    Mismatch modifiers : pd.Series of numeric or None
         Modifiers for direct, sky diffuse and ground diffuse irradiances, with
         indexes ``direct``, ``sky_diffuse``, ``ground_diffuse``.
         Each mismatch modifier should be multiplied by its corresponding
         POA component.
+        Returns None for a component if provided ``model_parameters`` does not
+        include its coefficients.
 
     Raises
     ------
@@ -333,11 +333,11 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
     """
     # Note tests for this function are prefixed with test_martin_ruiz_mm_*
 
-    irrad_components = ('direct', 'sky_diffuse', 'ground_diffuse')
+    IRRAD_COMPONENTS = ('direct', 'sky_diffuse', 'ground_diffuse')
     # Fitting parameters directly from [1]_
     MARTIN_RUIZ_PARAMS = pd.DataFrame(
         index=('monosi', 'polysi', 'asi'),
-        columns=pd.MultiIndex.from_product([irrad_components,
+        columns=pd.MultiIndex.from_product([IRRAD_COMPONENTS,
                                            ('c', 'a', 'b')]),
         data=[  # Direct(c,a,b)  | Sky diffuse(c,a,b) | Ground diffuse(c,a,b)
             [1.029, -.313, 524e-5, .764, -.882, -.0204, .970, -.244, .0129],
@@ -359,11 +359,9 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
         raise TypeError('You must pass at least "cell_type" '
                         'or "model_parameters" as arguments!')
     elif model_parameters is not None:  # Use user-defined model parameters
-        # Overwrite components with user-specified ones
-        irrad_components = model_parameters.keys()
         # Validate 'model_parameters' sub-dicts keys
         if any([{'a', 'b', 'c'} != set(model_parameters[component].keys())
-                for component in irrad_components]):
+                for component in model_parameters.keys()]):
             raise ValueError("You must specify model parameters with keys "
                              "'a','b','c' for each irradiation component.")
 
@@ -376,12 +374,15 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
     kt_delta = clearness_index - 0.74
     am_delta = airmass_absolute - 1.5
 
-    modifiers = pd.Series()
+    modifiers = pd.Series(index=IRRAD_COMPONENTS, data=[None, None, None])
 
     # Calculate mismatch modifier for each irradiation
-    for irrad_type in irrad_components:
+    for irrad_type in IRRAD_COMPONENTS:
+        # Skip irradiations not specified in 'model_params'
+        if irrad_type not in _params.keys():
+            continue
+        # Else, calculate the mismatch modifier
         _coeffs = _params[irrad_type]
-
         modifier = _coeffs['c'] * np.exp(_coeffs['a'] * kt_delta
                                          + _coeffs['b'] * am_delta)
         modifiers[irrad_type] = modifier
diff --git a/pvlib/tests/test_spectrum.py b/pvlib/tests/test_spectrum.py
index d051d1e322..342be09436 100644
--- a/pvlib/tests/test_spectrum.py
+++ b/pvlib/tests/test_spectrum.py
@@ -198,7 +198,7 @@ def martin_ruiz_mismatch_data():
             'ground_diffuse': {'c': 0.970, 'a': -2.44e-1, 'b': 1.29e-2}},
         'monosi_custom_params_df': pd.DataFrame({
             'direct': [1.029, -0.313, 0.00524],
-            'diffuse_sky': [0.764, -0.882, -0.0204]},
+            'sky_diffuse': [0.764, -0.882, -0.0204]},
             index=('c', 'a', 'b'))
     }
     return kwargs
@@ -292,7 +292,8 @@ def test_martin_ruiz_mm_model_df(martin_ruiz_mismatch_data):
         airmass_absolute,
         model_parameters=model_parameters)
     assert_allclose(result['direct'], expected['dir'], atol=1e-5)
-    assert_allclose(result['diffuse_sky'], expected['sky'], atol=1e-5)
+    assert_allclose(result['sky_diffuse'], expected['sky'], atol=1e-5)
+    assert_equal(result['ground_diffuse'], None)
 
 
 def test_martin_ruiz_mm_userwarning(martin_ruiz_mismatch_data):

From 025c76e069ac9d5b0f0e4a1a0a601f6cd46e5836 Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Fri, 3 Feb 2023 19:12:03 +0100
Subject: [PATCH 09/35] Minor typos in docstrings

---
 pvlib/atmosphere.py  | 2 +-
 pvlib/ivtools/sdm.py | 2 +-
 pvlib/pvsystem.py    | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/pvlib/atmosphere.py b/pvlib/atmosphere.py
index ff1ce8d4d5..4233c68590 100644
--- a/pvlib/atmosphere.py
+++ b/pvlib/atmosphere.py
@@ -148,7 +148,7 @@ def get_relative_airmass(zenith, model='kastenyoung1989'):
         Available models include the following:
 
         * 'simple' - secant(apparent zenith angle) -
-          Note that this gives -Inf at zenith=90
+          Note that this gives +Inf at zenith=90
         * 'kasten1966' - See reference [1] -
           requires apparent sun zenith
         * 'youngirvine1967' - See reference [2] -
diff --git a/pvlib/ivtools/sdm.py b/pvlib/ivtools/sdm.py
index 70c3be389f..6d10d87e9e 100644
--- a/pvlib/ivtools/sdm.py
+++ b/pvlib/ivtools/sdm.py
@@ -81,7 +81,7 @@ def fit_cec_sam(celltype, v_mp, i_mp, v_oc, i_sc, alpha_sc, beta_voc,
 
     Notes
     -----
-    The CEC model and estimation method  are described in [1]_.
+    The CEC model and estimation method are described in [1]_.
     Inputs ``v_mp``, ``i_mp``, ``v_oc`` and ``i_sc`` are assumed to be from a
     single IV curve at constant irradiance and cell temperature. Irradiance is
     not explicitly used by the fitting procedure. The irradiance level at which
diff --git a/pvlib/pvsystem.py b/pvlib/pvsystem.py
index 48371ca961..7cda12b790 100644
--- a/pvlib/pvsystem.py
+++ b/pvlib/pvsystem.py
@@ -2497,8 +2497,8 @@ def sapm(effective_irradiance, temp_cell, module):
                        Imp, Vmp, Ix, and Ixx to effective irradiance
     Isco               Short circuit current at reference condition (amps)
     Impo               Maximum power current at reference condition (amps)
-    Voco               Open circuit voltage at reference condition (amps)
-    Vmpo               Maximum power voltage at reference condition (amps)
+    Voco               Open circuit voltage at reference condition (volts)
+    Vmpo               Maximum power voltage at reference condition (volts)
     Aisc               Short circuit current temperature coefficient at
                        reference condition (1/C)
     Aimp               Maximum power current temperature coefficient at

From f0ea4984f55ba115c507b57496a0d00f4cd79b38 Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Fri, 3 Feb 2023 23:48:51 +0100
Subject: [PATCH 10/35] Squashed commit of the following:

commit 8f3b965be7f1e9f8442924dde407a3dca9d41c26
Author: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date:   Fri Feb 3 19:25:42 2023 +0100

    Update mismatch_modifiers.ipynb

commit 34860690486983e41dfa089d0df94a263eebf303
Author: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date:   Thu Feb 2 23:28:31 2023 +0100

    Create mismatch_modifiers.ipynb

commit 0747a430267af5f9a93c8f7edaef0741b115b7fb
Author: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date:   Fri Jan 27 13:05:49 2023 +0100

    I did fck it with the tmy_data.shift, never again

commit 0e600b2382bb1f247839e3a2935a760aaefc2d32
Author: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date:   Tue Dec 6 17:12:04 2022 +0100

    Example draft
---
 ..._martin_ruiz_spectral_modifier_figs4to6.py | 104 ++++++
 docs/tutorials/mismatch_modifiers.ipynb       | 334 ++++++++++++++++++
 2 files changed, 438 insertions(+)
 create mode 100644 docs/examples/spectrum/plot_martin_ruiz_spectral_modifier_figs4to6.py
 create mode 100644 docs/tutorials/mismatch_modifiers.ipynb

diff --git a/docs/examples/spectrum/plot_martin_ruiz_spectral_modifier_figs4to6.py b/docs/examples/spectrum/plot_martin_ruiz_spectral_modifier_figs4to6.py
new file mode 100644
index 0000000000..6646f638d2
--- /dev/null
+++ b/docs/examples/spectrum/plot_martin_ruiz_spectral_modifier_figs4to6.py
@@ -0,0 +1,104 @@
+"""
+Modeling N. Martin and J. Ruiz Spectral Modifiers
+=================================================
+
+Mimic Figures 4, 5 & 6 from paper [1]_.
+Note raw data is unavailable, so we are only plotting the line given from the
+model.
+
+References
+----------
+.. [1] Martín, N. and Ruiz, J.M. (1999), A new method for the spectral
+   characterisation of PV modules. Prog. Photovolt: Res. Appl., 7: 299-310.
+   :doi:10.1002/(SICI)1099-159X(199907/08)7:4<299::AID-PIP260>3.0.CO;2-0
+"""
+
+# from pvlib.spectrum.mismatch import martin_ruiz_spectral_modifier
+from pvlib.location import Location
+from pvlib.iotools import get_pvgis_tmy
+from pvlib.irradiance import get_extra_radiation, clearness_index
+from pvlib.tools import cosd
+from datetime import datetime, timedelta
+import numpy as np
+# import pandas as pd
+import matplotlib.pyplot as plt
+# import matplotlib as mpl
+min_cos_zen = 0.065*1 #5 # OJO, esto es para más adelante: '1' -> '5'
+# clearness = np.linspace(0.56, 0.82, 10)
+
+site = Location(40.4534, -3.7270, altitude=664, name='IES-UPM, Madrid',
+                tz='CET')
+
+# time = pd.date_range(start=datetime(2020, 1, 1), end=datetime(2020, 12, 31),
+#                      freq=timedelta(hours=1))
+
+tmy_data, _, _, _ = get_pvgis_tmy(site.latitude, site.longitude,
+                                  map_variables=True)
+tmy_data.index = [ts.replace(year=2022) for ts in tmy_data.index]
+
+solar_pos = site.get_solarposition(tmy_data.index)
+
+extra_rad = get_extra_radiation(tmy_data.index)
+
+clearness = clearness_index(ghi=tmy_data['ghi'],
+                            solar_zenith=solar_pos['zenith'],
+                            extra_radiation=extra_rad,
+                            min_cos_zenith=min_cos_zen)
+pass
+
+tmy_data['ghi'].plot()
+extra_rad.plot()
+
+# Ec. en clearness_index; mínimo del coseno que se permite es 0.065
+(np.maximum(cosd(solar_pos['zenith']), min_cos_zen)*1000).plot()
+
+(clearness*1000).plot()
+
+plt.legend(['ghi', 'extra_rad', 'cosd [x1000]', 'kt [x1000]'])
+plt.show()
+
+
+exit()
+pass
+plt.cla()
+plt.clf()
+
+print('clearness')
+print(clearness)
+np.max(clearness)
+clearness.plot()
+
+plt.show()
+
+
+pass
+
+print('airmass')
+airmass = site.get_airmass(solar_position=solar_pos, model='kasten1966')
+print(airmass)
+
+monosi_mm = martin_ruiz_spectral_modifier(clearness,
+                                          1.5,
+                                          cell_type='monosi')
+polysi_mm = martin_ruiz_spectral_modifier(clearness,
+                                          1.5,
+                                          cell_type='polysi')
+asi_mm = martin_ruiz_spectral_modifier(clearness,
+                                       1.5,
+                                       cell_type='asi')
+
+# fig, (ax1, ax2, ax3) = plt.subplots(1, 3, sharex=True, sharey=True)
+
+# ax1.plot(clearness, monosi_mm['direct'], marker='s')
+# ax1.plot(clearness, polysi_mm['direct'], marker='^')
+# ax1.plot(clearness, asi_mm['direct'], marker='D')
+
+# ax2.plot(clearness, monosi_mm['sky_diffuse'], marker='s')
+# ax2.plot(clearness, polysi_mm['sky_diffuse'], marker='^')
+# ax2.plot(clearness, asi_mm['sky_diffuse'], marker='D')
+
+# ax3.plot(clearness, monosi_mm['ground_diffuse'], marker='s')
+# ax3.plot(clearness, polysi_mm['ground_diffuse'], marker='^')
+# ax3.plot(clearness, asi_mm['ground_diffuse'], marker='D')
+
+# plt.show()
diff --git a/docs/tutorials/mismatch_modifiers.ipynb b/docs/tutorials/mismatch_modifiers.ipynb
new file mode 100644
index 0000000000..3c2bbaa49c
--- /dev/null
+++ b/docs/tutorials/mismatch_modifiers.ipynb
@@ -0,0 +1,334 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Mismatch Modifiers\n",
+    "Learn to use mismatch modifiers with this notebook!\n",
+    "Feel free to add other models, be sure to update the index and give you credit ;)\n",
+    "\n",
+    "Table of contents:\n",
+    "1. [Setup](#setup)\n",
+    "1. [N. Martin & J. M. Ruiz Experimental Mismatch Modifier](#n-martin--j-m-ruiz-experimental-mismatch-modifier)\n",
+    "\n",
+    "Authors:\n",
+    "* Echedey Luis (@echedey-ls), 2023 Feb"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup\n",
+    "Let's prepare the environment:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Show matplotlib's figures in the notebook\n",
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n",
+    "# And pvlib\n",
+    "import pvlib"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### N. Martin & J. M. Ruiz Mismatch Modifier\n",
+    "This modifier takes into account the responsivities to different spectrums,\n",
+    "characterized by the airmass and the clearness index, as two independent\n",
+    "variables. In fact, it is 3 different modifiers, each one for each component\n",
+    "(``poa_direct``, ``poa_sky_diffuse``, ``poa_ground_diffuse``)\n",
+    "\n",
+    "The formula for each component has three coefficients; we are lucky the authors\n",
+    "of this model computed fitting values for m-Si, p-Si and a-Si!\n",
+    "However, if you would like to compute and/or use your own values, keep reading.\n",
+    "[TODO: LO HAGO O NO LO HAGO?? ###]"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "First step is get to the effective irradiance. For simplicity, we will copy the procedure explained in the tutorial ``tmy_to_power.ipynb``. Please refer to it to get a more in depth explanation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "site = pvlib.location.Location(40.4534, -3.7270, altitude=664,\n",
+    "                               name='IES-UPM, Madrid', tz='CET')\n",
+    "\n",
+    "surface_tilt = 40\n",
+    "surface_azimuth = 180  # Pointing South\n",
+    "\n",
+    "tmy_data, _, _, _ = pvlib.iotools.get_pvgis_tmy(site.latitude, site.longitude, map_variables=True,\n",
+    "                                                startyear=2005, endyear=2015)\n",
+    "tmy_data.index = [ts.replace(year=2022) for ts in tmy_data.index]\n",
+    "\n",
+    "solar_pos = site.get_solarposition(tmy_data.index)\n",
+    "\n",
+    "extra_rad = pvlib.irradiance.get_extra_radiation(tmy_data.index)\n",
+    "\n",
+    "poa_sky_diffuse = pvlib.irradiance.haydavies(surface_tilt, surface_azimuth, tmy_data['dhi'],\n",
+    "                            tmy_data['dni'], extra_rad,\n",
+    "                            solar_pos['apparent_zenith'], solar_pos['azimuth'])\n",
+    "\n",
+    "poa_ground_diffuse = pvlib.irradiance.get_ground_diffuse(surface_tilt, tmy_data['ghi'])\n",
+    "\n",
+    "aoi = pvlib.irradiance.aoi(surface_tilt, surface_azimuth, solar_pos['apparent_zenith'], solar_pos['azimuth'])\n",
+    "\n",
+    "# Let's consider this the irradiances without modifiers\n",
+    "poa_irrad = pvlib.irradiance.poa_components(aoi, tmy_data['dni'], poa_sky_diffuse, poa_ground_diffuse)\n",
+    "\n",
+    "# Following part will be needed later\n",
+    "thermal_params = pvlib.temperature.TEMPERATURE_MODEL_PARAMETERS['sapm']['open_rack_glass_polymer']\n",
+    "pvtemps = pvlib.temperature.sapm_cell(poa_irrad['poa_global'], tmy_data['temp_air'], tmy_data['wind_speed'], **thermal_params)\n",
+    "\n",
+    "# Note that we use the CEC Module provided for the singledionde subsection\n",
+    "cec_modules = pvlib.pvsystem.retrieve_sam(name='CECMod')\n",
+    "cec_module = cec_modules['Canadian_Solar_Inc__CS5P_220M']"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here comes the modifier. Let's calculate it and examine the introduced\n",
+    "difference.\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "That was a lot, yeah. But don't worry, now we can find the effective irradiance, the mismatch modifier (with the airmass and clearness index)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# First, let's find the airmass and the clearness index\n",
+    "# Little caution: default values for this model were fitted obtaining the airmass through the kasten1966 method, not used by default\n",
+    "airmass = site.get_airmass(solar_position=solar_pos, model='kasten1966')\n",
+    "clearness = pvlib.irradiance.clearness_index(ghi=tmy_data['ghi'],\n",
+    "                                             solar_zenith=solar_pos['zenith'],\n",
+    "                                             extra_radiation=extra_rad)\n",
+    "# Check module is m-Si (monocrystalline silicon)\n",
+    "print('Module type is: ' + cec_module['Technology'])\n",
+    "\n",
+    "# Get the mismatch modifiers\n",
+    "modifiers = pvlib.spectrum.martin_ruiz_spectral_modifier(clearness,\n",
+    "                                                         airmass['airmass_absolute'],\n",
+    "                                                         cell_type='monosi')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And then we can find the modified irradiances by means of a simple multiplication."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TODO: find a pythonic way\n",
+    "poa_irrad_modified = pd.Series(dtype=pd.Float64Dtype)  # Suppress FutureWarning about dtype default\n",
+    "poa_irrad_modified['poa_direct'] = poa_irrad['poa_direct'] * modifiers['direct']\n",
+    "poa_irrad_modified['poa_sky_diffuse'] = poa_irrad['poa_sky_diffuse'] * modifiers['sky_diffuse']\n",
+    "poa_irrad_modified['poa_ground_diffuse'] = poa_irrad['poa_ground_diffuse'] * modifiers['ground_diffuse']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # TODO: find a pythonic way\n",
+    "# poa_irrad_modified2 = pd.Series(dtype=pd.Float64Dtype)  # Suppress FutureWarning about dtype default\n",
+    "# modifiers2 = modifiers.rename(index={\n",
+    "#     'direct': 'poa_direct',\n",
+    "#     'sky_diffuse': 'poa_sky_diffuse',\n",
+    "#     'ground_diffuse': 'poa_ground_diffuse'\n",
+    "# })\n",
+    "# poa_irrad_modified2 = poa_irrad.multiply(modifiers2)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, we compute the global modified irradiance, to be used in the output power calculation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "poa_irrad_modified = pvlib.irradiance.poa_components(aoi,\n",
+    "                                                     poa_irrad_modified['poa_direct'],\n",
+    "                                                     poa_irrad_modified['poa_sky_diffuse'],\n",
+    "                                                     poa_irrad_modified['poa_ground_diffuse'])"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's plot the raw vs modified global irradiances, and the difference."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "poa_irrad_global_diff = poa_irrad['poa_global'] - poa_irrad_modified['poa_global']\n",
+    "poa_irrad['poa_global'].plot()\n",
+    "poa_irrad_modified['poa_global'].plot()\n",
+    "poa_irrad_global_diff.plot()\n",
+    "plt.legend(['Original', 'Modified', 'Difference'])\n",
+    "plt.ylabel('Irradiance [W/m²]')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, we can get the power result. Instead of using\n",
+    "``pvlib.pvsystem.sapm_effective_irradiance``, which already applies another\n",
+    "experimental model for the response of the solar module, we have to use the\n",
+    "diode model.\n",
+    "\n",
+    "Have a look to subsection ``DC power using single diode`` in notebook\n",
+    "``tmy_to_power.ipynb``. This is just the same two times."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "module_params = {k: cec_module[k] for k in ['a_ref', 'I_L_ref', 'I_o_ref', 'R_sh_ref', 'R_s', 'alpha_sc']}"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Again, we compute one considering the modifier and another one without it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# With modifier\n",
+    "photocurrent, saturation_current, resistance_series, resistance_shunt, nNsVth = \\\n",
+    "    pvlib.pvsystem.calcparams_desoto(poa_irrad_modified['poa_global'],\n",
+    "                                     pvtemps,\n",
+    "                                     EgRef=1.121,\n",
+    "                                     dEgdT=-0.0002677,\n",
+    "                                     **module_params)\n",
+    "single_diode_out_modified = pvlib.pvsystem.singlediode(photocurrent, saturation_current,\n",
+    "                                                       resistance_series, resistance_shunt,\n",
+    "                                                       nNsVth)\n",
+    "# Without modifier\n",
+    "photocurrent, saturation_current, resistance_series, resistance_shunt, nNsVth = \\\n",
+    "    pvlib.pvsystem.calcparams_desoto(poa_irrad['poa_global'],\n",
+    "                                     pvtemps,\n",
+    "                                     EgRef=1.121,\n",
+    "                                     dEgdT=-0.0002677,\n",
+    "                                     **module_params)\n",
+    "single_diode_out = pvlib.pvsystem.singlediode(photocurrent, saturation_current,\n",
+    "                                              resistance_series, resistance_shunt,\n",
+    "                                              nNsVth)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Calculate difference of max power output\n",
+    "single_diode_out_max_pwr_diff = (single_diode_out['p_mp']\n",
+    "                                 - single_diode_out_modified['p_mp'])\n",
+    "# Plot results\n",
+    "single_diode_out['p_mp'].plot()\n",
+    "single_diode_out_modified['p_mp'].plot()\n",
+    "single_diode_out_max_pwr_diff.plot()\n",
+    "plt.legend(['Original', 'Modified', 'Difference'])\n",
+    "plt.ylabel('DC Power (W)')\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "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.10.4"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "e7b76f25baca03aa641c501db0912de76daa352e2d97ceb6fcf3025f206f2928"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 8d4442eddcdb3ed0efad5688e91cb4ce2218d60e Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Sat, 4 Feb 2023 00:38:50 +0100
Subject: [PATCH 11/35] Typo

---
 docs/tutorials/mismatch_modifiers.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/tutorials/mismatch_modifiers.ipynb b/docs/tutorials/mismatch_modifiers.ipynb
index 3c2bbaa49c..b1786b2128 100644
--- a/docs/tutorials/mismatch_modifiers.ipynb
+++ b/docs/tutorials/mismatch_modifiers.ipynb
@@ -103,7 +103,7 @@
     "thermal_params = pvlib.temperature.TEMPERATURE_MODEL_PARAMETERS['sapm']['open_rack_glass_polymer']\n",
     "pvtemps = pvlib.temperature.sapm_cell(poa_irrad['poa_global'], tmy_data['temp_air'], tmy_data['wind_speed'], **thermal_params)\n",
     "\n",
-    "# Note that we use the CEC Module provided for the singledionde subsection\n",
+    "# Note that we use the CEC Module provided for the singlediode subsection\n",
     "cec_modules = pvlib.pvsystem.retrieve_sam(name='CECMod')\n",
     "cec_module = cec_modules['Canadian_Solar_Inc__CS5P_220M']"
    ]

From 399312b5aca2e809869f2e468115237eb9dfdd1e Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Sat, 4 Feb 2023 00:41:35 +0100
Subject: [PATCH 12/35] Allow easier multiplication of modifiers and
 irradiances

Result new keys are ('poa_direct', 'poa_sky_diffuse', 'poa_ground_diffuse')
For irradiances obtained thru pvlib.irradiance.poa_components
---
 docs/tutorials/mismatch_modifiers.ipynb | 145 ++++++++++++++----------
 pvlib/spectrum/mismatch.py              |  31 ++---
 pvlib/tests/test_spectrum.py            |  60 +++++-----
 3 files changed, 132 insertions(+), 104 deletions(-)

diff --git a/docs/tutorials/mismatch_modifiers.ipynb b/docs/tutorials/mismatch_modifiers.ipynb
index b1786b2128..a6bc3d47d0 100644
--- a/docs/tutorials/mismatch_modifiers.ipynb
+++ b/docs/tutorials/mismatch_modifiers.ipynb
@@ -28,7 +28,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -70,7 +70,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -88,20 +88,30 @@
     "\n",
     "extra_rad = pvlib.irradiance.get_extra_radiation(tmy_data.index)\n",
     "\n",
-    "poa_sky_diffuse = pvlib.irradiance.haydavies(surface_tilt, surface_azimuth, tmy_data['dhi'],\n",
-    "                            tmy_data['dni'], extra_rad,\n",
-    "                            solar_pos['apparent_zenith'], solar_pos['azimuth'])\n",
+    "poa_sky_diffuse = \\\n",
+    "    pvlib.irradiance.haydavies(surface_tilt, surface_azimuth, tmy_data['dhi'],\n",
+    "                               tmy_data['dni'], extra_rad,\n",
+    "                               solar_pos['apparent_zenith'], solar_pos['azimuth'])\n",
     "\n",
     "poa_ground_diffuse = pvlib.irradiance.get_ground_diffuse(surface_tilt, tmy_data['ghi'])\n",
     "\n",
-    "aoi = pvlib.irradiance.aoi(surface_tilt, surface_azimuth, solar_pos['apparent_zenith'], solar_pos['azimuth'])\n",
+    "aoi = pvlib.irradiance.aoi(surface_tilt, surface_azimuth,\n",
+    "                           solar_pos['apparent_zenith'], solar_pos['azimuth'])\n",
     "\n",
     "# Let's consider this the irradiances without modifiers\n",
+    "# We can calculate the mismatch before and then create a \"poa_irrad\" var for\n",
+    "# modified irradiances, but we are also doing this to compare later.\n",
+    "# 'spectrum.martin_ruiz_spectral_modifier' result is designed to make it\n",
+    "# easy to multiply each modifier and the irradiance component with a single\n",
+    "# line of code.\n",
     "poa_irrad = pvlib.irradiance.poa_components(aoi, tmy_data['dni'], poa_sky_diffuse, poa_ground_diffuse)\n",
     "\n",
     "# Following part will be needed later\n",
     "thermal_params = pvlib.temperature.TEMPERATURE_MODEL_PARAMETERS['sapm']['open_rack_glass_polymer']\n",
-    "pvtemps = pvlib.temperature.sapm_cell(poa_irrad['poa_global'], tmy_data['temp_air'], tmy_data['wind_speed'], **thermal_params)\n",
+    "pvtemps = pvlib.temperature.sapm_cell(poa_irrad['poa_global'],\n",
+    "                                      tmy_data['temp_air'],\n",
+    "                                      tmy_data['wind_speed'],\n",
+    "                                      **thermal_params)\n",
     "\n",
     "# Note that we use the CEC Module provided for the singlediode subsection\n",
     "cec_modules = pvlib.pvsystem.retrieve_sam(name='CECMod')\n",
@@ -127,9 +137,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Module type is: Mono-c-Si\n"
+     ]
+    }
+   ],
    "source": [
     "# First, let's find the airmass and the clearness index\n",
     "# Little caution: default values for this model were fitted obtaining the airmass through the kasten1966 method, not used by default\n",
@@ -151,56 +169,26 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "And then we can find the modified irradiances by means of a simple multiplication."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# TODO: find a pythonic way\n",
-    "poa_irrad_modified = pd.Series(dtype=pd.Float64Dtype)  # Suppress FutureWarning about dtype default\n",
-    "poa_irrad_modified['poa_direct'] = poa_irrad['poa_direct'] * modifiers['direct']\n",
-    "poa_irrad_modified['poa_sky_diffuse'] = poa_irrad['poa_sky_diffuse'] * modifiers['sky_diffuse']\n",
-    "poa_irrad_modified['poa_ground_diffuse'] = poa_irrad['poa_ground_diffuse'] * modifiers['ground_diffuse']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# # TODO: find a pythonic way\n",
-    "# poa_irrad_modified2 = pd.Series(dtype=pd.Float64Dtype)  # Suppress FutureWarning about dtype default\n",
-    "# modifiers2 = modifiers.rename(index={\n",
-    "#     'direct': 'poa_direct',\n",
-    "#     'sky_diffuse': 'poa_sky_diffuse',\n",
-    "#     'ground_diffuse': 'poa_ground_diffuse'\n",
-    "# })\n",
-    "# poa_irrad_modified2 = poa_irrad.multiply(modifiers2)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now, we compute the global modified irradiance, to be used in the output power calculation."
+    "And then we can find the 3 components modified irradiances by means of a simple\n",
+    "multiplication.\n",
+    "\n",
+    "Note, however, that neither this does modify ``poa_global`` nor\n",
+    "``poa_diffuse``, so we should update."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
-    "poa_irrad_modified = pvlib.irradiance.poa_components(aoi,\n",
-    "                                                     poa_irrad_modified['poa_direct'],\n",
-    "                                                     poa_irrad_modified['poa_sky_diffuse'],\n",
-    "                                                     poa_irrad_modified['poa_ground_diffuse'])"
+    "poa_irrad_modified = poa_irrad * modifiers\n",
+    "# We need global modified irradiance for the output power calculation\n",
+    "poa_irrad_modified = \\\n",
+    "    pvlib.irradiance.poa_components(aoi,\n",
+    "                                    poa_irrad_modified['poa_direct'],\n",
+    "                                    poa_irrad_modified['poa_sky_diffuse'],\n",
+    "                                    poa_irrad_modified['poa_ground_diffuse'])"
    ]
   },
   {
@@ -213,11 +201,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "poa_irrad_global_diff = poa_irrad['poa_global'] - poa_irrad_modified['poa_global']\n",
+    "poa_irrad_global_diff = (poa_irrad['poa_global']\n",
+    "                         - poa_irrad_modified['poa_global'])\n",
     "poa_irrad['poa_global'].plot()\n",
     "poa_irrad_modified['poa_global'].plot()\n",
     "poa_irrad_global_diff.plot()\n",
@@ -242,11 +242,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
-    "module_params = {k: cec_module[k] for k in ['a_ref', 'I_L_ref', 'I_o_ref', 'R_sh_ref', 'R_s', 'alpha_sc']}"
+    "module_params = {k: cec_module[k]\n",
+    "                 for k in ['a_ref', 'I_L_ref', 'I_o_ref', 'R_sh_ref', 'R_s', 'alpha_sc']}"
    ]
   },
   {
@@ -259,9 +260,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\Yo\\Documents\\01_UPM\\IES\\ISI-IES-GROUP-codes\\pvlib-python\\pvlib\\tools.py:359: RuntimeWarning: divide by zero encountered in divide\n",
+      "  np.trunc(np.log(atol / (df['VH'] - df['VL'])) / np.log(phim1)))\n",
+      "C:\\Users\\Yo\\Documents\\01_UPM\\IES\\ISI-IES-GROUP-codes\\pvlib-python\\pvlib\\tools.py:359: RuntimeWarning: divide by zero encountered in divide\n",
+      "  np.trunc(np.log(atol / (df['VH'] - df['VL'])) / np.log(phim1)))\n"
+     ]
+    }
+   ],
    "source": [
     "# With modifier\n",
     "photocurrent, saturation_current, resistance_series, resistance_shunt, nNsVth = \\\n",
@@ -287,9 +299,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Calculate difference of max power output\n",
     "single_diode_out_max_pwr_diff = (single_diode_out['p_mp']\n",
diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index dedd2ea15d..e6e4286ae8 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -269,7 +269,8 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
 
     model_parameters : dict-like, optional
         In case you computed the model parameters. In case any component is not
-        specified, result will have a ``None`` value in its corresponding key.
+        specified, result will have a ``np.nan`` value in its
+        corresponding value.
         Provide either a dict or a ``pd.DataFrame`` as follows:
 
         .. code-block:: python
@@ -277,24 +278,25 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
             # Using a dict
             # Return keys are the same as specifying 'cell_type'
             model_parameters = {
-                'direct': {'c': c1, 'a': a1, 'b': b1},
-                'sky_diffuse': {'c': c2, 'a': a2, 'b': b2},
-                'ground_diffuse': {'c': c3, 'a': a3, 'b': b3}
+                'poa_direct': {'c': c1, 'a': a1, 'b': b1},
+                'poa_sky_diffuse': {'c': c2, 'a': a2, 'b': b2},
+                'poa_ground_diffuse': {'c': c3, 'a': a3, 'b': b3}
             }
             # Using a pd.DataFrame
             model_parameters = pd.DataFrame({
-                'direct': [c1, a1, b1],
-                'sky_diffuse':  [c2, a2, b2],
-                'ground_diffuse': [c3, a3, b3]},
+                'poa_direct': [c1, a1, b1],
+                'poa_sky_diffuse':  [c2, a2, b2],
+                'poa_ground_diffuse': [c3, a3, b3]},
                 index=('c', 'a', 'b'))
 
         ``c``, ``a`` and ``b`` must be scalar.
 
     Returns
     -------
-    Mismatch modifiers : pd.Series of numeric or None
-        Modifiers for direct, sky diffuse and ground diffuse irradiances, with
-        indexes ``direct``, ``sky_diffuse``, ``ground_diffuse``.
+    Modifiers : pd.DataFrame (iterable input) or dict (scalar input) of numeric
+        Mismatch modifiers for direct, sky diffuse and ground diffuse
+        irradiances, with indexes ``poa_direct``, ``poa_sky_diffuse``,
+        ``poa_ground_diffuse``.
         Each mismatch modifier should be multiplied by its corresponding
         POA component.
         Returns None for a component if provided ``model_parameters`` does not
@@ -333,7 +335,7 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
     """
     # Note tests for this function are prefixed with test_martin_ruiz_mm_*
 
-    IRRAD_COMPONENTS = ('direct', 'sky_diffuse', 'ground_diffuse')
+    IRRAD_COMPONENTS = ('poa_direct', 'poa_sky_diffuse', 'poa_ground_diffuse')
     # Fitting parameters directly from [1]_
     MARTIN_RUIZ_PARAMS = pd.DataFrame(
         index=('monosi', 'polysi', 'asi'),
@@ -370,11 +372,14 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
             warn('Both "cell_type" and "model_parameters" given! '
                  'Using provided "model_parameters".')
 
-    # Compute difference to avoid recalculating inside loop
+    # Compute difference here to avoid recalculating inside loop
     kt_delta = clearness_index - 0.74
     am_delta = airmass_absolute - 1.5
 
-    modifiers = pd.Series(index=IRRAD_COMPONENTS, data=[None, None, None])
+    if hasattr(kt_delta, '__iter__') or hasattr(am_delta, '__iter__'):
+        modifiers = pd.DataFrame(columns=IRRAD_COMPONENTS)
+    else:
+        modifiers = dict(zip(IRRAD_COMPONENTS, (np.nan,)*3))
 
     # Calculate mismatch modifier for each irradiation
     for irrad_type in IRRAD_COMPONENTS:
diff --git a/pvlib/tests/test_spectrum.py b/pvlib/tests/test_spectrum.py
index 342be09436..e0298f40d1 100644
--- a/pvlib/tests/test_spectrum.py
+++ b/pvlib/tests/test_spectrum.py
@@ -4,7 +4,7 @@
 import numpy as np
 from pvlib import spectrum
 
-from .conftest import DATA_DIR, assert_series_equal
+from .conftest import DATA_DIR
 
 SPECTRL2_TEST_DATA = DATA_DIR / 'spectrl2_example_spectra.csv'
 
@@ -193,12 +193,12 @@ def martin_ruiz_mismatch_data():
             'sky': [0.94889, 0.91699, 0.88616, 0.85637, 0.82758, 0.79976],
             'gnd': [1.03801, 1.02259, 1.00740, 0.99243, 0.97769, 0.96316]},
         'monosi_model_params_dict': {
-            'direct': {'c': 1.029, 'a': -3.13e-1, 'b': 5.24e-3},
-            'sky_diffuse': {'c': 0.764, 'a': -8.82e-1, 'b': -2.04e-2},
-            'ground_diffuse': {'c': 0.970, 'a': -2.44e-1, 'b': 1.29e-2}},
+            'poa_direct': {'c': 1.029, 'a': -3.13e-1, 'b': 5.24e-3},
+            'poa_sky_diffuse': {'c': 0.764, 'a': -8.82e-1, 'b': -2.04e-2},
+            'poa_ground_diffuse': {'c': 0.970, 'a': -2.44e-1, 'b': 1.29e-2}},
         'monosi_custom_params_df': pd.DataFrame({
-            'direct': [1.029, -0.313, 0.00524],
-            'sky_diffuse': [0.764, -0.882, -0.0204]},
+            'poa_direct': [1.029, -0.313, 0.00524],
+            'poa_sky_diffuse': [0.764, -0.882, -0.0204]},
             index=('c', 'a', 'b'))
     }
     return kwargs
@@ -212,13 +212,13 @@ def test_martin_ruiz_mm_scalar(martin_ruiz_mismatch_data):
                                                     airmass_absolute,
                                                     cell_type='asi')
 
-    assert_approx_equal(result['direct'],
+    assert_approx_equal(result['poa_direct'],
                         martin_ruiz_mismatch_data['asi_expected']['dir'][0],
                         significant=5)
-    assert_approx_equal(result['sky_diffuse'],
+    assert_approx_equal(result['poa_sky_diffuse'],
                         martin_ruiz_mismatch_data['asi_expected']['sky'][0],
                         significant=5)
-    assert_approx_equal(result['ground_diffuse'],
+    assert_approx_equal(result['poa_ground_diffuse'],
                         martin_ruiz_mismatch_data['asi_expected']['gnd'][0],
                         significant=5)
 
@@ -227,17 +227,17 @@ def test_martin_ruiz_mm_series(martin_ruiz_mismatch_data):
     # test with Series input ; only cell_type given
     clearness_index = pd.Series(martin_ruiz_mismatch_data['clearness_index'])
     airmass_absolute = pd.Series(martin_ruiz_mismatch_data['airmass_absolute'])
-    expected = {
+    expected = pd.DataFrame(data={
         'dir': pd.Series(martin_ruiz_mismatch_data['polysi_expected']['dir']),
         'sky': pd.Series(martin_ruiz_mismatch_data['polysi_expected']['sky']),
-        'gnd': pd.Series(martin_ruiz_mismatch_data['polysi_expected']['gnd'])}
+        'gnd': pd.Series(martin_ruiz_mismatch_data['polysi_expected']['gnd'])})
 
     result = spectrum.martin_ruiz_spectral_modifier(clearness_index,
                                                     airmass_absolute,
                                                     cell_type='polysi')
-    assert_series_equal(result['direct'], expected['dir'], atol=1e-5)
-    assert_series_equal(result['sky_diffuse'], expected['sky'], atol=1e-5)
-    assert_series_equal(result['ground_diffuse'], expected['gnd'], atol=1e-5)
+    assert_allclose(result['poa_direct'], expected['dir'], atol=1e-5)
+    assert_allclose(result['poa_sky_diffuse'], expected['sky'], atol=1e-5)
+    assert_allclose(result['poa_ground_diffuse'], expected['gnd'], atol=1e-5)
 
 
 def test_martin_ruiz_mm_nans(martin_ruiz_mismatch_data):
@@ -249,12 +249,12 @@ def test_martin_ruiz_mm_nans(martin_ruiz_mismatch_data):
     result = spectrum.martin_ruiz_spectral_modifier(clearness_index,
                                                     airmass_absolute,
                                                     cell_type='monosi')
-    assert np.isnan(result['direct'][:5]).all()
-    assert not np.isnan(result['direct'][5:]).any()
-    assert np.isnan(result['sky_diffuse'][:5]).all()
-    assert not np.isnan(result['sky_diffuse'][5:]).any()
-    assert np.isnan(result['ground_diffuse'][:5]).all()
-    assert not np.isnan(result['ground_diffuse'][5:]).any()
+    assert np.isnan(result['poa_direct'][:5]).all()
+    assert not np.isnan(result['poa_direct'][5:]).any()
+    assert np.isnan(result['poa_sky_diffuse'][:5]).all()
+    assert not np.isnan(result['poa_sky_diffuse'][5:]).any()
+    assert np.isnan(result['poa_ground_diffuse'][:5]).all()
+    assert not np.isnan(result['poa_ground_diffuse'][5:]).any()
 
 
 def test_martin_ruiz_mm_model_dict(martin_ruiz_mismatch_data):
@@ -262,19 +262,19 @@ def test_martin_ruiz_mm_model_dict(martin_ruiz_mismatch_data):
     # test custom quantity of components and its names can be given
     clearness_index = pd.Series(martin_ruiz_mismatch_data['clearness_index'])
     airmass_absolute = pd.Series(martin_ruiz_mismatch_data['airmass_absolute'])
-    expected = {
+    expected = pd.DataFrame(data={
         'dir': pd.Series(martin_ruiz_mismatch_data['monosi_expected']['dir']),
         'sky': pd.Series(martin_ruiz_mismatch_data['monosi_expected']['sky']),
-        'gnd': pd.Series(martin_ruiz_mismatch_data['monosi_expected']['gnd'])}
+        'gnd': pd.Series(martin_ruiz_mismatch_data['monosi_expected']['gnd'])})
     model_parameters = martin_ruiz_mismatch_data['monosi_model_params_dict']
 
     result = spectrum.martin_ruiz_spectral_modifier(
         clearness_index,
         airmass_absolute,
         model_parameters=model_parameters)
-    assert_allclose(result['direct'], expected['dir'], atol=1e-5)
-    assert_allclose(result['sky_diffuse'], expected['sky'], atol=1e-5)
-    assert_allclose(result['ground_diffuse'], expected['gnd'], atol=1e-5)
+    assert_allclose(result['poa_direct'], expected['dir'], atol=1e-5)
+    assert_allclose(result['poa_sky_diffuse'], expected['sky'], atol=1e-5)
+    assert_allclose(result['poa_ground_diffuse'], expected['gnd'], atol=1e-5)
 
 
 def test_martin_ruiz_mm_model_df(martin_ruiz_mismatch_data):
@@ -283,17 +283,17 @@ def test_martin_ruiz_mm_model_df(martin_ruiz_mismatch_data):
     clearness_index = np.array(martin_ruiz_mismatch_data['clearness_index'])
     airmass_absolute = np.array(martin_ruiz_mismatch_data['airmass_absolute'])
     model_parameters = martin_ruiz_mismatch_data['monosi_custom_params_df']
-    expected = {
+    expected = pd.DataFrame(data={
         'dir': np.array(martin_ruiz_mismatch_data['monosi_expected']['dir']),
-        'sky': np.array(martin_ruiz_mismatch_data['monosi_expected']['sky'])}
+        'sky': np.array(martin_ruiz_mismatch_data['monosi_expected']['sky'])})
 
     result = spectrum.martin_ruiz_spectral_modifier(
         clearness_index,
         airmass_absolute,
         model_parameters=model_parameters)
-    assert_allclose(result['direct'], expected['dir'], atol=1e-5)
-    assert_allclose(result['sky_diffuse'], expected['sky'], atol=1e-5)
-    assert_equal(result['ground_diffuse'], None)
+    assert_allclose(result['poa_direct'], expected['dir'], atol=1e-5)
+    assert_allclose(result['poa_sky_diffuse'], expected['sky'], atol=1e-5)
+    assert result['poa_ground_diffuse'].isna().all()
 
 
 def test_martin_ruiz_mm_userwarning(martin_ruiz_mismatch_data):

From f24aa928b6fc3b37201dc6549f7c349795c80ce6 Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Mon, 6 Feb 2023 19:14:54 +0100
Subject: [PATCH 13/35] Show few days on example

---
 docs/tutorials/mismatch_modifiers.ipynb | 104 +++++++++---------------
 1 file changed, 37 insertions(+), 67 deletions(-)

diff --git a/docs/tutorials/mismatch_modifiers.ipynb b/docs/tutorials/mismatch_modifiers.ipynb
index a6bc3d47d0..d551d37fd3 100644
--- a/docs/tutorials/mismatch_modifiers.ipynb
+++ b/docs/tutorials/mismatch_modifiers.ipynb
@@ -28,7 +28,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -70,30 +70,41 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "site = pvlib.location.Location(40.4534, -3.7270, altitude=664,\n",
-    "                               name='IES-UPM, Madrid', tz='CET')\n",
+    "                               name='IES-UPM, Madrid')\n",
     "\n",
     "surface_tilt = 40\n",
     "surface_azimuth = 180  # Pointing South\n",
     "\n",
-    "tmy_data, _, _, _ = pvlib.iotools.get_pvgis_tmy(site.latitude, site.longitude, map_variables=True,\n",
-    "                                                startyear=2005, endyear=2015)\n",
-    "tmy_data.index = [ts.replace(year=2022) for ts in tmy_data.index]\n",
+    "pvgis_data, _, _, _ = \\\n",
+    "    pvlib.iotools.get_pvgis_tmy(site.latitude, site.longitude,\n",
+    "                                map_variables=True,\n",
+    "                                startyear=2005, endyear=2015)\n",
+    "pvgis_data.index = [ts.replace(year=2022) for ts in pvgis_data.index]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "weather_data = pvgis_data['2022-09-03':'2022-09-06']\n",
     "\n",
-    "solar_pos = site.get_solarposition(tmy_data.index)\n",
+    "solar_pos = site.get_solarposition(weather_data.index)\n",
     "\n",
-    "extra_rad = pvlib.irradiance.get_extra_radiation(tmy_data.index)\n",
+    "extra_rad = pvlib.irradiance.get_extra_radiation(weather_data.index)\n",
     "\n",
     "poa_sky_diffuse = \\\n",
-    "    pvlib.irradiance.haydavies(surface_tilt, surface_azimuth, tmy_data['dhi'],\n",
-    "                               tmy_data['dni'], extra_rad,\n",
+    "    pvlib.irradiance.haydavies(surface_tilt, surface_azimuth, weather_data['dhi'],\n",
+    "                               weather_data['dni'], extra_rad,\n",
     "                               solar_pos['apparent_zenith'], solar_pos['azimuth'])\n",
     "\n",
-    "poa_ground_diffuse = pvlib.irradiance.get_ground_diffuse(surface_tilt, tmy_data['ghi'])\n",
+    "poa_ground_diffuse = pvlib.irradiance.get_ground_diffuse(surface_tilt, weather_data['ghi'])\n",
     "\n",
     "aoi = pvlib.irradiance.aoi(surface_tilt, surface_azimuth,\n",
     "                           solar_pos['apparent_zenith'], solar_pos['azimuth'])\n",
@@ -103,14 +114,14 @@
     "# modified irradiances, but we are also doing this to compare later.\n",
     "# 'spectrum.martin_ruiz_spectral_modifier' result is designed to make it\n",
     "# easy to multiply each modifier and the irradiance component with a single\n",
-    "# line of code.\n",
-    "poa_irrad = pvlib.irradiance.poa_components(aoi, tmy_data['dni'], poa_sky_diffuse, poa_ground_diffuse)\n",
+    "# line of code, if you get this dataframe before.\n",
+    "poa_irrad = pvlib.irradiance.poa_components(aoi, weather_data['dni'], poa_sky_diffuse, poa_ground_diffuse)\n",
     "\n",
     "# Following part will be needed later\n",
     "thermal_params = pvlib.temperature.TEMPERATURE_MODEL_PARAMETERS['sapm']['open_rack_glass_polymer']\n",
     "pvtemps = pvlib.temperature.sapm_cell(poa_irrad['poa_global'],\n",
-    "                                      tmy_data['temp_air'],\n",
-    "                                      tmy_data['wind_speed'],\n",
+    "                                      weather_data['temp_air'],\n",
+    "                                      weather_data['wind_speed'],\n",
     "                                      **thermal_params)\n",
     "\n",
     "# Note that we use the CEC Module provided for the singlediode subsection\n",
@@ -137,22 +148,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Module type is: Mono-c-Si\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# First, let's find the airmass and the clearness index\n",
     "# Little caution: default values for this model were fitted obtaining the airmass through the kasten1966 method, not used by default\n",
     "airmass = site.get_airmass(solar_position=solar_pos, model='kasten1966')\n",
-    "clearness = pvlib.irradiance.clearness_index(ghi=tmy_data['ghi'],\n",
+    "clearness = pvlib.irradiance.clearness_index(ghi=weather_data['ghi'],\n",
     "                                             solar_zenith=solar_pos['zenith'],\n",
     "                                             extra_radiation=extra_rad)\n",
     "# Check module is m-Si (monocrystalline silicon)\n",
@@ -178,7 +181,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -201,20 +204,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "poa_irrad_global_diff = (poa_irrad['poa_global']\n",
     "                         - poa_irrad_modified['poa_global'])\n",
@@ -242,7 +234,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -260,20 +252,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "C:\\Users\\Yo\\Documents\\01_UPM\\IES\\ISI-IES-GROUP-codes\\pvlib-python\\pvlib\\tools.py:359: RuntimeWarning: divide by zero encountered in divide\n",
-      "  np.trunc(np.log(atol / (df['VH'] - df['VL'])) / np.log(phim1)))\n",
-      "C:\\Users\\Yo\\Documents\\01_UPM\\IES\\ISI-IES-GROUP-codes\\pvlib-python\\pvlib\\tools.py:359: RuntimeWarning: divide by zero encountered in divide\n",
-      "  np.trunc(np.log(atol / (df['VH'] - df['VL'])) / np.log(phim1)))\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# With modifier\n",
     "photocurrent, saturation_current, resistance_series, resistance_shunt, nNsVth = \\\n",
@@ -299,20 +280,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Calculate difference of max power output\n",
     "single_diode_out_max_pwr_diff = (single_diode_out['p_mp']\n",

From c26b865f81addeb704a023201360ceef77790d61 Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Mon, 6 Feb 2023 22:08:00 +0100
Subject: [PATCH 14/35] Cant live without line length limit

---
 docs/tutorials/mismatch_modifiers.ipynb | 34 +++++++++++++++----------
 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/docs/tutorials/mismatch_modifiers.ipynb b/docs/tutorials/mismatch_modifiers.ipynb
index d551d37fd3..9622938742 100644
--- a/docs/tutorials/mismatch_modifiers.ipynb
+++ b/docs/tutorials/mismatch_modifiers.ipynb
@@ -100,11 +100,13 @@
     "extra_rad = pvlib.irradiance.get_extra_radiation(weather_data.index)\n",
     "\n",
     "poa_sky_diffuse = \\\n",
-    "    pvlib.irradiance.haydavies(surface_tilt, surface_azimuth, weather_data['dhi'],\n",
-    "                               weather_data['dni'], extra_rad,\n",
-    "                               solar_pos['apparent_zenith'], solar_pos['azimuth'])\n",
+    "    pvlib.irradiance.haydavies(surface_tilt, surface_azimuth,\n",
+    "                               weather_data['dhi'],  weather_data['dni'],\n",
+    "                               extra_rad, solar_pos['apparent_zenith'],\n",
+    "                               solar_pos['azimuth'])\n",
     "\n",
-    "poa_ground_diffuse = pvlib.irradiance.get_ground_diffuse(surface_tilt, weather_data['ghi'])\n",
+    "poa_ground_diffuse = pvlib.irradiance.get_ground_diffuse(surface_tilt,\n",
+    "                                                         weather_data['ghi'])\n",
     "\n",
     "aoi = pvlib.irradiance.aoi(surface_tilt, surface_azimuth,\n",
     "                           solar_pos['apparent_zenith'], solar_pos['azimuth'])\n",
@@ -115,7 +117,10 @@
     "# 'spectrum.martin_ruiz_spectral_modifier' result is designed to make it\n",
     "# easy to multiply each modifier and the irradiance component with a single\n",
     "# line of code, if you get this dataframe before.\n",
-    "poa_irrad = pvlib.irradiance.poa_components(aoi, weather_data['dni'], poa_sky_diffuse, poa_ground_diffuse)\n",
+    "poa_irrad = pvlib.irradiance.poa_components(aoi,\n",
+    "                                            weather_data['dni'],\n",
+    "                                            poa_sky_diffuse,\n",
+    "                                            poa_ground_diffuse)\n",
     "\n",
     "# Following part will be needed later\n",
     "thermal_params = pvlib.temperature.TEMPERATURE_MODEL_PARAMETERS['sapm']['open_rack_glass_polymer']\n",
@@ -162,9 +167,10 @@
     "print('Module type is: ' + cec_module['Technology'])\n",
     "\n",
     "# Get the mismatch modifiers\n",
-    "modifiers = pvlib.spectrum.martin_ruiz_spectral_modifier(clearness,\n",
-    "                                                         airmass['airmass_absolute'],\n",
-    "                                                         cell_type='monosi')"
+    "modifiers = \\\n",
+    "    pvlib.spectrum.martin_ruiz_spectral_modifier(clearness,\n",
+    "                                                airmass['airmass_absolute'],\n",
+    "                                                cell_type='monosi')"
    ]
   },
   {
@@ -263,9 +269,9 @@
     "                                     EgRef=1.121,\n",
     "                                     dEgdT=-0.0002677,\n",
     "                                     **module_params)\n",
-    "single_diode_out_modified = pvlib.pvsystem.singlediode(photocurrent, saturation_current,\n",
-    "                                                       resistance_series, resistance_shunt,\n",
-    "                                                       nNsVth)\n",
+    "single_diode_out_modified = \\\n",
+    "    pvlib.pvsystem.singlediode(photocurrent, saturation_current,\n",
+    "                               resistance_series, resistance_shunt, nNsVth)\n",
     "# Without modifier\n",
     "photocurrent, saturation_current, resistance_series, resistance_shunt, nNsVth = \\\n",
     "    pvlib.pvsystem.calcparams_desoto(poa_irrad['poa_global'],\n",
@@ -273,9 +279,9 @@
     "                                     EgRef=1.121,\n",
     "                                     dEgdT=-0.0002677,\n",
     "                                     **module_params)\n",
-    "single_diode_out = pvlib.pvsystem.singlediode(photocurrent, saturation_current,\n",
-    "                                              resistance_series, resistance_shunt,\n",
-    "                                              nNsVth)"
+    "single_diode_out = \\\n",
+    "    pvlib.pvsystem.singlediode(photocurrent, saturation_current,\n",
+    "                               resistance_series, resistance_shunt, nNsVth)"
    ]
   },
   {

From 900ed98bc7e134700c3b3191c0834ccbbb8b2f5b Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Tue, 7 Feb 2023 14:37:48 +0100
Subject: [PATCH 15/35] Rename notebook and specify spectral mismatch modifiers

---
 ...pynb => spectral_mismatch_modifiers.ipynb} | 97 ++-----------------
 1 file changed, 9 insertions(+), 88 deletions(-)
 rename docs/tutorials/{mismatch_modifiers.ipynb => spectral_mismatch_modifiers.ipynb} (70%)

diff --git a/docs/tutorials/mismatch_modifiers.ipynb b/docs/tutorials/spectral_mismatch_modifiers.ipynb
similarity index 70%
rename from docs/tutorials/mismatch_modifiers.ipynb
rename to docs/tutorials/spectral_mismatch_modifiers.ipynb
index 9622938742..871fbd48da 100644
--- a/docs/tutorials/mismatch_modifiers.ipynb
+++ b/docs/tutorials/spectral_mismatch_modifiers.ipynb
@@ -5,8 +5,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Mismatch Modifiers\n",
-    "Learn to use mismatch modifiers with this notebook!\n",
+    "# Spectral mismatch Modifiers\n",
+    "Learn to use spectral mismatch modifiers with this notebook!\n",
     "Feel free to add other models, be sure to update the index and give you credit ;)\n",
     "\n",
     "Table of contents:\n",
@@ -49,15 +49,14 @@
    "metadata": {},
    "source": [
     "### N. Martin & J. M. Ruiz Mismatch Modifier\n",
-    "This modifier takes into account the responsivities to different spectrums,\n",
-    "characterized by the airmass and the clearness index, as two independent\n",
-    "variables. In fact, it is 3 different modifiers, each one for each component\n",
-    "(``poa_direct``, ``poa_sky_diffuse``, ``poa_ground_diffuse``)\n",
+    "This modifier takes into account the spectral responses of several solar cell\n",
+    "material, characterized by the airmass and the clearness index, as two\n",
+    "independent variables. In fact, there are three different modifiers, each one\n",
+    "for each component (``poa_direct``, ``poa_sky_diffuse``,\n",
+    "``poa_ground_diffuse``)\n",
     "\n",
     "The formula for each component has three coefficients; we are lucky the authors\n",
-    "of this model computed fitting values for m-Si, p-Si and a-Si!\n",
-    "However, if you would like to compute and/or use your own values, keep reading.\n",
-    "[TODO: LO HAGO O NO LO HAGO?? ###]"
+    "of this model computed fitting values for m-Si, p-Si and a-Si!"
    ]
   },
   {
@@ -205,7 +204,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Let's plot the raw vs modified global irradiances, and the difference."
+    "Finally, let's plot the raw vs modified global irradiances, and the difference."
    ]
   },
   {
@@ -223,84 +222,6 @@
     "plt.ylabel('Irradiance [W/m²]')\n",
     "plt.show()"
    ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Finally, we can get the power result. Instead of using\n",
-    "``pvlib.pvsystem.sapm_effective_irradiance``, which already applies another\n",
-    "experimental model for the response of the solar module, we have to use the\n",
-    "diode model.\n",
-    "\n",
-    "Have a look to subsection ``DC power using single diode`` in notebook\n",
-    "``tmy_to_power.ipynb``. This is just the same two times."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "module_params = {k: cec_module[k]\n",
-    "                 for k in ['a_ref', 'I_L_ref', 'I_o_ref', 'R_sh_ref', 'R_s', 'alpha_sc']}"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Again, we compute one considering the modifier and another one without it."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# With modifier\n",
-    "photocurrent, saturation_current, resistance_series, resistance_shunt, nNsVth = \\\n",
-    "    pvlib.pvsystem.calcparams_desoto(poa_irrad_modified['poa_global'],\n",
-    "                                     pvtemps,\n",
-    "                                     EgRef=1.121,\n",
-    "                                     dEgdT=-0.0002677,\n",
-    "                                     **module_params)\n",
-    "single_diode_out_modified = \\\n",
-    "    pvlib.pvsystem.singlediode(photocurrent, saturation_current,\n",
-    "                               resistance_series, resistance_shunt, nNsVth)\n",
-    "# Without modifier\n",
-    "photocurrent, saturation_current, resistance_series, resistance_shunt, nNsVth = \\\n",
-    "    pvlib.pvsystem.calcparams_desoto(poa_irrad['poa_global'],\n",
-    "                                     pvtemps,\n",
-    "                                     EgRef=1.121,\n",
-    "                                     dEgdT=-0.0002677,\n",
-    "                                     **module_params)\n",
-    "single_diode_out = \\\n",
-    "    pvlib.pvsystem.singlediode(photocurrent, saturation_current,\n",
-    "                               resistance_series, resistance_shunt, nNsVth)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Calculate difference of max power output\n",
-    "single_diode_out_max_pwr_diff = (single_diode_out['p_mp']\n",
-    "                                 - single_diode_out_modified['p_mp'])\n",
-    "# Plot results\n",
-    "single_diode_out['p_mp'].plot()\n",
-    "single_diode_out_modified['p_mp'].plot()\n",
-    "single_diode_out_max_pwr_diff.plot()\n",
-    "plt.legend(['Original', 'Modified', 'Difference'])\n",
-    "plt.ylabel('DC Power (W)')\n",
-    "plt.show()"
-   ]
   }
  ],
  "metadata": {

From eb1b24532fd3a64bffe34cab5559fc9cd4106164 Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Tue, 7 Feb 2023 15:19:47 +0100
Subject: [PATCH 16/35] Delete plot_martin_ruiz_spectral_modifier_figs4to6.py

---
 ..._martin_ruiz_spectral_modifier_figs4to6.py | 104 ------------------
 1 file changed, 104 deletions(-)
 delete mode 100644 docs/examples/spectrum/plot_martin_ruiz_spectral_modifier_figs4to6.py

diff --git a/docs/examples/spectrum/plot_martin_ruiz_spectral_modifier_figs4to6.py b/docs/examples/spectrum/plot_martin_ruiz_spectral_modifier_figs4to6.py
deleted file mode 100644
index 6646f638d2..0000000000
--- a/docs/examples/spectrum/plot_martin_ruiz_spectral_modifier_figs4to6.py
+++ /dev/null
@@ -1,104 +0,0 @@
-"""
-Modeling N. Martin and J. Ruiz Spectral Modifiers
-=================================================
-
-Mimic Figures 4, 5 & 6 from paper [1]_.
-Note raw data is unavailable, so we are only plotting the line given from the
-model.
-
-References
-----------
-.. [1] Martín, N. and Ruiz, J.M. (1999), A new method for the spectral
-   characterisation of PV modules. Prog. Photovolt: Res. Appl., 7: 299-310.
-   :doi:10.1002/(SICI)1099-159X(199907/08)7:4<299::AID-PIP260>3.0.CO;2-0
-"""
-
-# from pvlib.spectrum.mismatch import martin_ruiz_spectral_modifier
-from pvlib.location import Location
-from pvlib.iotools import get_pvgis_tmy
-from pvlib.irradiance import get_extra_radiation, clearness_index
-from pvlib.tools import cosd
-from datetime import datetime, timedelta
-import numpy as np
-# import pandas as pd
-import matplotlib.pyplot as plt
-# import matplotlib as mpl
-min_cos_zen = 0.065*1 #5 # OJO, esto es para más adelante: '1' -> '5'
-# clearness = np.linspace(0.56, 0.82, 10)
-
-site = Location(40.4534, -3.7270, altitude=664, name='IES-UPM, Madrid',
-                tz='CET')
-
-# time = pd.date_range(start=datetime(2020, 1, 1), end=datetime(2020, 12, 31),
-#                      freq=timedelta(hours=1))
-
-tmy_data, _, _, _ = get_pvgis_tmy(site.latitude, site.longitude,
-                                  map_variables=True)
-tmy_data.index = [ts.replace(year=2022) for ts in tmy_data.index]
-
-solar_pos = site.get_solarposition(tmy_data.index)
-
-extra_rad = get_extra_radiation(tmy_data.index)
-
-clearness = clearness_index(ghi=tmy_data['ghi'],
-                            solar_zenith=solar_pos['zenith'],
-                            extra_radiation=extra_rad,
-                            min_cos_zenith=min_cos_zen)
-pass
-
-tmy_data['ghi'].plot()
-extra_rad.plot()
-
-# Ec. en clearness_index; mínimo del coseno que se permite es 0.065
-(np.maximum(cosd(solar_pos['zenith']), min_cos_zen)*1000).plot()
-
-(clearness*1000).plot()
-
-plt.legend(['ghi', 'extra_rad', 'cosd [x1000]', 'kt [x1000]'])
-plt.show()
-
-
-exit()
-pass
-plt.cla()
-plt.clf()
-
-print('clearness')
-print(clearness)
-np.max(clearness)
-clearness.plot()
-
-plt.show()
-
-
-pass
-
-print('airmass')
-airmass = site.get_airmass(solar_position=solar_pos, model='kasten1966')
-print(airmass)
-
-monosi_mm = martin_ruiz_spectral_modifier(clearness,
-                                          1.5,
-                                          cell_type='monosi')
-polysi_mm = martin_ruiz_spectral_modifier(clearness,
-                                          1.5,
-                                          cell_type='polysi')
-asi_mm = martin_ruiz_spectral_modifier(clearness,
-                                       1.5,
-                                       cell_type='asi')
-
-# fig, (ax1, ax2, ax3) = plt.subplots(1, 3, sharex=True, sharey=True)
-
-# ax1.plot(clearness, monosi_mm['direct'], marker='s')
-# ax1.plot(clearness, polysi_mm['direct'], marker='^')
-# ax1.plot(clearness, asi_mm['direct'], marker='D')
-
-# ax2.plot(clearness, monosi_mm['sky_diffuse'], marker='s')
-# ax2.plot(clearness, polysi_mm['sky_diffuse'], marker='^')
-# ax2.plot(clearness, asi_mm['sky_diffuse'], marker='D')
-
-# ax3.plot(clearness, monosi_mm['ground_diffuse'], marker='s')
-# ax3.plot(clearness, polysi_mm['ground_diffuse'], marker='^')
-# ax3.plot(clearness, asi_mm['ground_diffuse'], marker='D')
-
-# plt.show()

From 149c557915f63d2be2dcbdfb5816e0d2837b197e Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Tue, 7 Feb 2023 15:20:18 +0100
Subject: [PATCH 17/35] Little changes to docs and var names

---
 docs/tutorials/spectral_mismatch_modifiers.ipynb | 16 ++++++++--------
 pvlib/spectrum/mismatch.py                       |  7 +++----
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/docs/tutorials/spectral_mismatch_modifiers.ipynb b/docs/tutorials/spectral_mismatch_modifiers.ipynb
index 871fbd48da..a3e6df07e1 100644
--- a/docs/tutorials/spectral_mismatch_modifiers.ipynb
+++ b/docs/tutorials/spectral_mismatch_modifiers.ipynb
@@ -110,7 +110,7 @@
     "aoi = pvlib.irradiance.aoi(surface_tilt, surface_azimuth,\n",
     "                           solar_pos['apparent_zenith'], solar_pos['azimuth'])\n",
     "\n",
-    "# Let's consider this the irradiances without modifiers\n",
+    "# Let's consider this the irradiances without spectral modifiers\n",
     "# We can calculate the mismatch before and then create a \"poa_irrad\" var for\n",
     "# modified irradiances, but we are also doing this to compare later.\n",
     "# 'spectrum.martin_ruiz_spectral_modifier' result is designed to make it\n",
@@ -159,17 +159,17 @@
     "# First, let's find the airmass and the clearness index\n",
     "# Little caution: default values for this model were fitted obtaining the airmass through the kasten1966 method, not used by default\n",
     "airmass = site.get_airmass(solar_position=solar_pos, model='kasten1966')\n",
-    "clearness = pvlib.irradiance.clearness_index(ghi=weather_data['ghi'],\n",
+    "clearness_index = pvlib.irradiance.clearness_index(ghi=weather_data['ghi'],\n",
     "                                             solar_zenith=solar_pos['zenith'],\n",
     "                                             extra_radiation=extra_rad)\n",
     "# Check module is m-Si (monocrystalline silicon)\n",
     "print('Module type is: ' + cec_module['Technology'])\n",
     "\n",
-    "# Get the mismatch modifiers\n",
-    "modifiers = \\\n",
-    "    pvlib.spectrum.martin_ruiz_spectral_modifier(clearness,\n",
-    "                                                airmass['airmass_absolute'],\n",
-    "                                                cell_type='monosi')"
+    "# Get the spectral mismatch modifiers\n",
+    "spectral_modifiers = \\\n",
+    "    pvlib.spectrum.martin_ruiz_spectral_modifier(clearness_index,\n",
+    "                                                 airmass['airmass_absolute'],\n",
+    "                                                 cell_type='monosi')"
    ]
   },
   {
@@ -190,7 +190,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "poa_irrad_modified = poa_irrad * modifiers\n",
+    "poa_irrad_modified = poa_irrad * spectral_modifiers\n",
     "# We need global modified irradiance for the output power calculation\n",
     "poa_irrad_modified = \\\n",
     "    pvlib.irradiance.poa_components(aoi,\n",
diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index e6e4286ae8..26551e5500 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -241,10 +241,9 @@ def integrate(e):
 def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
                                   cell_type=None, model_parameters=None):
     r"""
-    Calculate mismatch modifiers for POA direct, sky diffuse and ground diffuse
-    irradiances due to material's spectral response to spectrum characterised
-    by the clearness index and the absolute airmass, with respect to the
-    standard spectrum.
+    Calculate spectral mismatch modifiers for POA direct, sky diffuse and
+    ground diffuse irradiances using the clearness index and the absolute
+    airmass.
 
     .. warning::
         Included model parameters for ``monosi``, ``polysi`` and ``asi`` were

From 2bf9d5b45ff9922eca42b7872d595440443256db Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Wed, 8 Feb 2023 23:10:08 +0100
Subject: [PATCH 18/35] Clean up & minor upgrades to notebook

---
 .../spectral_mismatch_modifiers.ipynb         | 53 +++++++------------
 1 file changed, 19 insertions(+), 34 deletions(-)

diff --git a/docs/tutorials/spectral_mismatch_modifiers.ipynb b/docs/tutorials/spectral_mismatch_modifiers.ipynb
index a3e6df07e1..7d712831ff 100644
--- a/docs/tutorials/spectral_mismatch_modifiers.ipynb
+++ b/docs/tutorials/spectral_mismatch_modifiers.ipynb
@@ -5,7 +5,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Spectral mismatch Modifiers\n",
+    "# Spectral Mismatch Modifiers\n",
     "Learn to use spectral mismatch modifiers with this notebook!\n",
     "Feel free to add other models, be sure to update the index and give you credit ;)\n",
     "\n",
@@ -64,7 +64,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "First step is get to the effective irradiance. For simplicity, we will copy the procedure explained in the tutorial ``tmy_to_power.ipynb``. Please refer to it to get a more in depth explanation."
+    "First step is get to the effective irradiance. For simplicity, we will copy the\n",
+    "procedure explained in the tutorial ``tmy_to_power.ipynb`` to obtain it.\n",
+    "Please refer to it to get a more in depth explanation."
    ]
   },
   {
@@ -119,27 +121,7 @@
     "poa_irrad = pvlib.irradiance.poa_components(aoi,\n",
     "                                            weather_data['dni'],\n",
     "                                            poa_sky_diffuse,\n",
-    "                                            poa_ground_diffuse)\n",
-    "\n",
-    "# Following part will be needed later\n",
-    "thermal_params = pvlib.temperature.TEMPERATURE_MODEL_PARAMETERS['sapm']['open_rack_glass_polymer']\n",
-    "pvtemps = pvlib.temperature.sapm_cell(poa_irrad['poa_global'],\n",
-    "                                      weather_data['temp_air'],\n",
-    "                                      weather_data['wind_speed'],\n",
-    "                                      **thermal_params)\n",
-    "\n",
-    "# Note that we use the CEC Module provided for the singlediode subsection\n",
-    "cec_modules = pvlib.pvsystem.retrieve_sam(name='CECMod')\n",
-    "cec_module = cec_modules['Canadian_Solar_Inc__CS5P_220M']"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Here comes the modifier. Let's calculate it and examine the introduced\n",
-    "difference.\n"
+    "                                            poa_ground_diffuse)"
    ]
   },
   {
@@ -147,7 +129,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "That was a lot, yeah. But don't worry, now we can find the effective irradiance, the mismatch modifier (with the airmass and clearness index)"
+    "Here comes the modifier. Let's calculate it with the airmass and clearness\n",
+    "index."
    ]
   },
   {
@@ -157,13 +140,13 @@
    "outputs": [],
    "source": [
     "# First, let's find the airmass and the clearness index\n",
-    "# Little caution: default values for this model were fitted obtaining the airmass through the kasten1966 method, not used by default\n",
+    "# Little caution: default values for this model were fitted obtaining the\n",
+    "# airmass through the kasten1966 method, not used by default\n",
     "airmass = site.get_airmass(solar_position=solar_pos, model='kasten1966')\n",
-    "clearness_index = pvlib.irradiance.clearness_index(ghi=weather_data['ghi'],\n",
-    "                                             solar_zenith=solar_pos['zenith'],\n",
-    "                                             extra_radiation=extra_rad)\n",
-    "# Check module is m-Si (monocrystalline silicon)\n",
-    "print('Module type is: ' + cec_module['Technology'])\n",
+    "clearness_index = \\\n",
+    "    pvlib.irradiance.clearness_index(ghi=weather_data['ghi'],\n",
+    "                                     solar_zenith=solar_pos['zenith'],\n",
+    "                                     extra_radiation=extra_rad)\n",
     "\n",
     "# Get the spectral mismatch modifiers\n",
     "spectral_modifiers = \\\n",
@@ -181,7 +164,8 @@
     "multiplication.\n",
     "\n",
     "Note, however, that neither this does modify ``poa_global`` nor\n",
-    "``poa_diffuse``, so we should update."
+    "``poa_diffuse``, so we should update the dataframe afterwards, again with\n",
+    "``irradiance.poa_components``."
    ]
   },
   {
@@ -204,7 +188,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Finally, let's plot the raw vs modified global irradiances, and the difference."
+    "Finally, let's plot the incident vs modified global irradiances, and their\n",
+    "difference."
    ]
   },
   {
@@ -218,8 +203,8 @@
     "poa_irrad['poa_global'].plot()\n",
     "poa_irrad_modified['poa_global'].plot()\n",
     "poa_irrad_global_diff.plot()\n",
-    "plt.legend(['Original', 'Modified', 'Difference'])\n",
-    "plt.ylabel('Irradiance [W/m²]')\n",
+    "plt.legend(['Incident', 'Modified', 'Difference'])\n",
+    "plt.ylabel('POA Global irradiance [W/m²]')\n",
     "plt.show()"
    ]
   }

From be9554fb515c0a92b8598a6a255812e2b19bd164 Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Wed, 8 Feb 2023 23:10:34 +0100
Subject: [PATCH 19/35] Add output of notebook

---
 .../spectral_mismatch_modifiers.ipynb         | 38 ++++++++++++++-----
 1 file changed, 28 insertions(+), 10 deletions(-)

diff --git a/docs/tutorials/spectral_mismatch_modifiers.ipynb b/docs/tutorials/spectral_mismatch_modifiers.ipynb
index 7d712831ff..8517f3c33a 100644
--- a/docs/tutorials/spectral_mismatch_modifiers.ipynb
+++ b/docs/tutorials/spectral_mismatch_modifiers.ipynb
@@ -10,7 +10,7 @@
     "Feel free to add other models, be sure to update the index and give you credit ;)\n",
     "\n",
     "Table of contents:\n",
-    "1. [Setup](#setup)\n",
+    "1. [Setup](#setup-the-environment)\n",
     "1. [N. Martin & J. M. Ruiz Experimental Mismatch Modifier](#n-martin--j-m-ruiz-experimental-mismatch-modifier)\n",
     "\n",
     "Authors:\n",
@@ -22,13 +22,20 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Setup\n",
-    "Let's prepare the environment:"
+    "## Setup the environment"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Run this before anything else."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -71,7 +78,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -90,7 +97,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -135,7 +142,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -170,7 +177,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -194,9 +201,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 22,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "poa_irrad_global_diff = (poa_irrad['poa_global']\n",
     "                         - poa_irrad_modified['poa_global'])\n",

From 10ff9c22d3326619d2c4e773ad253c0a28b756da Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Thu, 9 Feb 2023 00:14:59 +0100
Subject: [PATCH 20/35] Small error in docsting

---
 pvlib/spectrum/mismatch.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index 26551e5500..62418c76b9 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -298,8 +298,8 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
         ``poa_ground_diffuse``.
         Each mismatch modifier should be multiplied by its corresponding
         POA component.
-        Returns None for a component if provided ``model_parameters`` does not
-        include its coefficients.
+        Returns np.nan for a component if provided ``model_parameters`` does
+        not include its coefficients.
 
     Raises
     ------

From 6a2dbf0666968e2523edd0a71eff2c45f8f27eda Mon Sep 17 00:00:00 2001
From: Echedey Luis <80125792+echedey-ls@users.noreply.github.com>
Date: Thu, 9 Feb 2023 19:11:31 +0100
Subject: [PATCH 21/35] docstring: Apply suggestions from code review

Co-authored-by: Cliff Hansen <cwhanse@sandia.gov>
---
 pvlib/spectrum/mismatch.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index 62418c76b9..c1fa8b8852 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -259,7 +259,7 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
     airmass_absolute : numeric
         Absolute airmass. Give attention to algorithm used (``kasten1966`` is
         recommended for default parameters of ``monosi``, ``polysi`` and
-        ``asi``, see reference [1]_).
+        ``asi``, see [1]_).
 
     cell_type : string, optional
         Specifies material of the cell in order to infer model parameters.
@@ -267,9 +267,6 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
         upper case. If not specified, ``model_parameters`` must be provided.
 
     model_parameters : dict-like, optional
-        In case you computed the model parameters. In case any component is not
-        specified, result will have a ``np.nan`` value in its
-        corresponding value.
         Provide either a dict or a ``pd.DataFrame`` as follows:
 
         .. code-block:: python
@@ -289,13 +286,16 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
                 index=('c', 'a', 'b'))
 
         ``c``, ``a`` and ``b`` must be scalar.
-
+```suggestion
+        If parameters for an irradiance component (`'poa_direct'`,
+        `'poa_sky_diffuse'`, or `'poa_ground_diffuse'`) are not
+        specified, ``np.nan`` will be returned in the corresponding value.
     Returns
     -------
     Modifiers : pd.DataFrame (iterable input) or dict (scalar input) of numeric
         Mismatch modifiers for direct, sky diffuse and ground diffuse
-        irradiances, with indexes ``poa_direct``, ``poa_sky_diffuse``,
-        ``poa_ground_diffuse``.
+        irradiances, with indexes `'poa_direct'`, `'poa_sky_diffuse'`,
+        `'poa_ground_diffuse'`.
         Each mismatch modifier should be multiplied by its corresponding
         POA component.
         Returns np.nan for a component if provided ``model_parameters`` does

From 3d5ccebdf410653f0ae99ee47aaca3ca1f701739 Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Thu, 9 Feb 2023 19:14:27 +0100
Subject: [PATCH 22/35] Exceptions: Delete exclamation marks as per code review

---
 pvlib/spectrum/mismatch.py   | 6 +++---
 pvlib/tests/test_spectrum.py | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index c1fa8b8852..1a40d05991 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -354,11 +354,11 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
             _params = MARTIN_RUIZ_PARAMS.loc[cell_type_lower]
         else:
             raise NotImplementedError('Cell type parameters not defined in '
-                                      'algorithm! Allowed types are '
+                                      'algorithm. Allowed types are '
                                       f'{tuple(MARTIN_RUIZ_PARAMS.index)}')
     elif cell_type is None and model_parameters is None:
         raise TypeError('You must pass at least "cell_type" '
-                        'or "model_parameters" as arguments!')
+                        'or "model_parameters" as arguments.')
     elif model_parameters is not None:  # Use user-defined model parameters
         # Validate 'model_parameters' sub-dicts keys
         if any([{'a', 'b', 'c'} != set(model_parameters[component].keys())
@@ -368,7 +368,7 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
 
         _params = model_parameters
         if cell_type is not None:
-            warn('Both "cell_type" and "model_parameters" given! '
+            warn('Both "cell_type" and "model_parameters" given. '
                  'Using provided "model_parameters".')
 
     # Compute difference here to avoid recalculating inside loop
diff --git a/pvlib/tests/test_spectrum.py b/pvlib/tests/test_spectrum.py
index e0298f40d1..341c7b2925 100644
--- a/pvlib/tests/test_spectrum.py
+++ b/pvlib/tests/test_spectrum.py
@@ -303,7 +303,7 @@ def test_martin_ruiz_mm_userwarning(martin_ruiz_mismatch_data):
     model_parameters = martin_ruiz_mismatch_data['monosi_model_params_dict']
 
     with pytest.warns(UserWarning,
-                      match='Both "cell_type" and "model_parameters" given! '
+                      match='Both "cell_type" and "model_parameters" given. '
                             'Using provided "model_parameters".'):
         _ = spectrum.martin_ruiz_spectral_modifier(
             clearness_index,
@@ -318,7 +318,7 @@ def test_martin_ruiz_mm_error_notimplemented(martin_ruiz_mismatch_data):
     airmass_absolute = np.array(martin_ruiz_mismatch_data['airmass_absolute'])
 
     with pytest.raises(NotImplementedError,
-                       match='Cell type parameters not defined in algorithm!'):
+                       match='Cell type parameters not defined in algorithm.'):
         _ = spectrum.martin_ruiz_spectral_modifier(clearness_index,
                                                    airmass_absolute,
                                                    cell_type='')
@@ -331,7 +331,7 @@ def test_martin_ruiz_mm_error_missing_params(martin_ruiz_mismatch_data):
 
     with pytest.raises(TypeError,
                        match='You must pass at least "cell_type" '
-                             'or "model_parameters" as arguments!'):
+                             'or "model_parameters" as arguments.'):
         _ = spectrum.martin_ruiz_spectral_modifier(clearness_index,
                                                    airmass_absolute)
 

From b16eaa6d635d508a4679db3c3d29f3f90d27aaba Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Thu, 9 Feb 2023 19:59:42 +0100
Subject: [PATCH 23/35] docstring: update per code review (II)

---
 pvlib/spectrum/mismatch.py | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index 1a40d05991..60cbc4a48a 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -286,10 +286,11 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
                 index=('c', 'a', 'b'))
 
         ``c``, ``a`` and ``b`` must be scalar.
-```suggestion
-        If parameters for an irradiance component (`'poa_direct'`,
-        `'poa_sky_diffuse'`, or `'poa_ground_diffuse'`) are not
-        specified, ``np.nan`` will be returned in the corresponding value.
+
+        Unspecified parameters for an irradiance component (`'poa_direct'`,
+        `'poa_sky_diffuse'`, or `'poa_ground_diffuse'`) will cause ``np.nan``
+        to be returned in the corresponding result.
+
     Returns
     -------
     Modifiers : pd.DataFrame (iterable input) or dict (scalar input) of numeric
@@ -298,8 +299,6 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
         `'poa_ground_diffuse'`.
         Each mismatch modifier should be multiplied by its corresponding
         POA component.
-        Returns np.nan for a component if provided ``model_parameters`` does
-        not include its coefficients.
 
     Raises
     ------

From f5352acce6f3cfe087e024a07b101fbb4cd13db0 Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Wed, 15 Feb 2023 19:11:27 +0100
Subject: [PATCH 24/35] code review

* doi backticks
* cell_type --> module_type
* spectrum.martin_ruiz_spectral_modifer --> spectrum.martin_ruiz
* change hastattr __iter__ to np.isscalar
* behaviour: providing module_type and model_parameters raises an error instead of a warning
---
 pvlib/spectrum/__init__.py   |  2 +-
 pvlib/spectrum/mismatch.py   | 49 +++++++++----------
 pvlib/tests/test_spectrum.py | 94 +++++++++++++++++-------------------
 3 files changed, 68 insertions(+), 77 deletions(-)

diff --git a/pvlib/spectrum/__init__.py b/pvlib/spectrum/__init__.py
index efdab55c1c..a73ca1e0cf 100644
--- a/pvlib/spectrum/__init__.py
+++ b/pvlib/spectrum/__init__.py
@@ -1,4 +1,4 @@
 from pvlib.spectrum.spectrl2 import spectrl2  # noqa: F401
 from pvlib.spectrum.mismatch import (get_example_spectral_response, get_am15g,
                                      calc_spectral_mismatch_field,
-                                     martin_ruiz_spectral_modifier)
+                                     martin_ruiz)
diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index 60cbc4a48a..991b29ce48 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -7,7 +7,6 @@
 import pandas as pd
 from scipy.interpolate import interp1d
 import os
-from warnings import warn
 
 
 def get_example_spectral_response(wavelength=None):
@@ -238,8 +237,8 @@ def integrate(e):
     return smm
 
 
-def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
-                                  cell_type=None, model_parameters=None):
+def martin_ruiz(clearness_index, airmass_absolute, module_type=None,
+                model_parameters=None):
     r"""
     Calculate spectral mismatch modifiers for POA direct, sky diffuse and
     ground diffuse irradiances using the clearness index and the absolute
@@ -261,7 +260,7 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
         recommended for default parameters of ``monosi``, ``polysi`` and
         ``asi``, see [1]_).
 
-    cell_type : string, optional
+    module_type : string, optional
         Specifies material of the cell in order to infer model parameters.
         Allowed types are ``monosi``, ``polysi`` and ``asi``, either lower or
         upper case. If not specified, ``model_parameters`` must be provided.
@@ -272,7 +271,7 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
         .. code-block:: python
 
             # Using a dict
-            # Return keys are the same as specifying 'cell_type'
+            # Return keys are the same as specifying 'module_type'
             model_parameters = {
                 'poa_direct': {'c': c1, 'a': a1, 'b': b1},
                 'poa_sky_diffuse': {'c': c2, 'a': a2, 'b': b2},
@@ -305,9 +304,9 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
     ValueError
         If ``model_parameters`` is not suitable. See examples given above.
     TypeError
-        If neither ``cell_type`` nor ``model_parameters`` are given.
+        If neither ``module_type`` nor ``model_parameters`` are given.
     NotImplementedError
-        If ``cell_type`` is not found in internal table of parameters.
+        If ``module_type`` is not found in internal table of parameters.
 
     Notes
     -----
@@ -322,7 +321,7 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
     ----------
     .. [1] Martín, N. and Ruiz, J.M. (1999), A new method for the spectral
        characterisation of PV modules. Prog. Photovolt: Res. Appl., 7: 299-310.
-       :doi:10.1002/(SICI)1099-159X(199907/08)7:4<299::AID-PIP260>3.0.CO;2-0
+       :doi:`10.1002/(SICI)1099-159X(199907/08)7:4<299::AID-PIP260>3.0.CO;2-0`
 
     See Also
     --------
@@ -346,39 +345,39 @@ def martin_ruiz_spectral_modifier(clearness_index, airmass_absolute,
         ])
 
     # Argument validation and choose components and model parameters
-    if cell_type is not None and model_parameters is None:
+    if module_type is not None and model_parameters is None:
         # Infer parameters from cell material
-        cell_type_lower = cell_type.lower()
-        if cell_type_lower in MARTIN_RUIZ_PARAMS.index:
-            _params = MARTIN_RUIZ_PARAMS.loc[cell_type_lower]
+        module_type_lower = module_type.lower()
+        if module_type_lower in MARTIN_RUIZ_PARAMS.index:
+            _params = MARTIN_RUIZ_PARAMS.loc[module_type_lower]
         else:
             raise NotImplementedError('Cell type parameters not defined in '
                                       'algorithm. Allowed types are '
                                       f'{tuple(MARTIN_RUIZ_PARAMS.index)}')
-    elif cell_type is None and model_parameters is None:
-        raise TypeError('You must pass at least "cell_type" '
-                        'or "model_parameters" as arguments.')
-    elif model_parameters is not None:  # Use user-defined model parameters
+    elif model_parameters is not None and module_type is None:
+        # Use user-defined model parameters
         # Validate 'model_parameters' sub-dicts keys
         if any([{'a', 'b', 'c'} != set(model_parameters[component].keys())
                 for component in model_parameters.keys()]):
             raise ValueError("You must specify model parameters with keys "
                              "'a','b','c' for each irradiation component.")
-
         _params = model_parameters
-        if cell_type is not None:
-            warn('Both "cell_type" and "model_parameters" given. '
-                 'Using provided "model_parameters".')
+    elif module_type is None and model_parameters is None:
+        raise TypeError('You must pass at least "module_type" '
+                        'or "model_parameters" as arguments.')
+    elif model_parameters is not None and module_type is not None:
+        raise TypeError('Cannot resolve input: must supply only one of '
+                        '"module_type" or "model_parameters"')
+
+    if np.isscalar(clearness_index) and np.isscalar(airmass_absolute):
+        modifiers = dict(zip(IRRAD_COMPONENTS, (np.nan,)*3))
+    else:
+        modifiers = pd.DataFrame(columns=IRRAD_COMPONENTS)
 
     # Compute difference here to avoid recalculating inside loop
     kt_delta = clearness_index - 0.74
     am_delta = airmass_absolute - 1.5
 
-    if hasattr(kt_delta, '__iter__') or hasattr(am_delta, '__iter__'):
-        modifiers = pd.DataFrame(columns=IRRAD_COMPONENTS)
-    else:
-        modifiers = dict(zip(IRRAD_COMPONENTS, (np.nan,)*3))
-
     # Calculate mismatch modifier for each irradiation
     for irrad_type in IRRAD_COMPONENTS:
         # Skip irradiations not specified in 'model_params'
diff --git a/pvlib/tests/test_spectrum.py b/pvlib/tests/test_spectrum.py
index 341c7b2925..83b5892a64 100644
--- a/pvlib/tests/test_spectrum.py
+++ b/pvlib/tests/test_spectrum.py
@@ -176,7 +176,7 @@ def test_calc_spectral_mismatch_field(spectrl2_data):
 
 @pytest.fixture
 def martin_ruiz_mismatch_data():
-    # Data to run tests of martin_ruiz_spectral_modifier
+    # Data to run tests of spectrum.martin_ruiz
     kwargs = {
         'clearness_index': [0.56, 0.612, 0.664, 0.716, 0.768, 0.82],
         'airmass_absolute': [2, 1.8, 1.6, 1.4, 1.2, 1],
@@ -205,12 +205,12 @@ def martin_ruiz_mismatch_data():
 
 
 def test_martin_ruiz_mm_scalar(martin_ruiz_mismatch_data):
-    # test scalar input ; only cell_type given
+    # test scalar input ; only module_type given
     clearness_index = martin_ruiz_mismatch_data['clearness_index'][0]
     airmass_absolute = martin_ruiz_mismatch_data['airmass_absolute'][0]
-    result = spectrum.martin_ruiz_spectral_modifier(clearness_index,
-                                                    airmass_absolute,
-                                                    cell_type='asi')
+    result = spectrum.martin_ruiz(clearness_index,
+                                  airmass_absolute,
+                                  module_type='asi')
 
     assert_approx_equal(result['poa_direct'],
                         martin_ruiz_mismatch_data['asi_expected']['dir'][0],
@@ -224,7 +224,7 @@ def test_martin_ruiz_mm_scalar(martin_ruiz_mismatch_data):
 
 
 def test_martin_ruiz_mm_series(martin_ruiz_mismatch_data):
-    # test with Series input ; only cell_type given
+    # test with Series input ; only module_type given
     clearness_index = pd.Series(martin_ruiz_mismatch_data['clearness_index'])
     airmass_absolute = pd.Series(martin_ruiz_mismatch_data['airmass_absolute'])
     expected = pd.DataFrame(data={
@@ -232,23 +232,21 @@ def test_martin_ruiz_mm_series(martin_ruiz_mismatch_data):
         'sky': pd.Series(martin_ruiz_mismatch_data['polysi_expected']['sky']),
         'gnd': pd.Series(martin_ruiz_mismatch_data['polysi_expected']['gnd'])})
 
-    result = spectrum.martin_ruiz_spectral_modifier(clearness_index,
-                                                    airmass_absolute,
-                                                    cell_type='polysi')
+    result = spectrum.martin_ruiz(clearness_index, airmass_absolute,
+                                  module_type='polysi')
     assert_allclose(result['poa_direct'], expected['dir'], atol=1e-5)
     assert_allclose(result['poa_sky_diffuse'], expected['sky'], atol=1e-5)
     assert_allclose(result['poa_ground_diffuse'], expected['gnd'], atol=1e-5)
 
 
 def test_martin_ruiz_mm_nans(martin_ruiz_mismatch_data):
-    # test NaN in, NaN out ; only cell_type given
+    # test NaN in, NaN out ; only module_type given
     clearness_index = pd.Series(martin_ruiz_mismatch_data['clearness_index'])
     airmass_absolute = pd.Series(martin_ruiz_mismatch_data['airmass_absolute'])
     airmass_absolute[:5] = np.nan
 
-    result = spectrum.martin_ruiz_spectral_modifier(clearness_index,
-                                                    airmass_absolute,
-                                                    cell_type='monosi')
+    result = spectrum.martin_ruiz(clearness_index, airmass_absolute,
+                                  module_type='monosi')
     assert np.isnan(result['poa_direct'][:5]).all()
     assert not np.isnan(result['poa_direct'][5:]).any()
     assert np.isnan(result['poa_sky_diffuse'][:5]).all()
@@ -268,7 +266,7 @@ def test_martin_ruiz_mm_model_dict(martin_ruiz_mismatch_data):
         'gnd': pd.Series(martin_ruiz_mismatch_data['monosi_expected']['gnd'])})
     model_parameters = martin_ruiz_mismatch_data['monosi_model_params_dict']
 
-    result = spectrum.martin_ruiz_spectral_modifier(
+    result = spectrum.martin_ruiz(
         clearness_index,
         airmass_absolute,
         model_parameters=model_parameters)
@@ -287,7 +285,7 @@ def test_martin_ruiz_mm_model_df(martin_ruiz_mismatch_data):
         'dir': np.array(martin_ruiz_mismatch_data['monosi_expected']['dir']),
         'sky': np.array(martin_ruiz_mismatch_data['monosi_expected']['sky'])})
 
-    result = spectrum.martin_ruiz_spectral_modifier(
+    result = spectrum.martin_ruiz(
         clearness_index,
         airmass_absolute,
         model_parameters=model_parameters)
@@ -296,44 +294,15 @@ def test_martin_ruiz_mm_model_df(martin_ruiz_mismatch_data):
     assert result['poa_ground_diffuse'].isna().all()
 
 
-def test_martin_ruiz_mm_userwarning(martin_ruiz_mismatch_data):
-    # test warning is raised with both 'cell_type' and 'model_parameters'
-    clearness_index = pd.Series(martin_ruiz_mismatch_data['clearness_index'])
-    airmass_absolute = pd.Series(martin_ruiz_mismatch_data['airmass_absolute'])
-    model_parameters = martin_ruiz_mismatch_data['monosi_model_params_dict']
-
-    with pytest.warns(UserWarning,
-                      match='Both "cell_type" and "model_parameters" given. '
-                            'Using provided "model_parameters".'):
-        _ = spectrum.martin_ruiz_spectral_modifier(
-            clearness_index,
-            airmass_absolute,
-            cell_type='asi',
-            model_parameters=model_parameters)
-
-
 def test_martin_ruiz_mm_error_notimplemented(martin_ruiz_mismatch_data):
-    # test exception is raised when cell_type does not exist in algorithm
+    # test exception is raised when module_type does not exist in algorithm
     clearness_index = np.array(martin_ruiz_mismatch_data['clearness_index'])
     airmass_absolute = np.array(martin_ruiz_mismatch_data['airmass_absolute'])
 
     with pytest.raises(NotImplementedError,
                        match='Cell type parameters not defined in algorithm.'):
-        _ = spectrum.martin_ruiz_spectral_modifier(clearness_index,
-                                                   airmass_absolute,
-                                                   cell_type='')
-
-
-def test_martin_ruiz_mm_error_missing_params(martin_ruiz_mismatch_data):
-    # test exception is raised when missing cell_type and model_parameters
-    clearness_index = np.array(martin_ruiz_mismatch_data['clearness_index'])
-    airmass_absolute = np.array(martin_ruiz_mismatch_data['airmass_absolute'])
-
-    with pytest.raises(TypeError,
-                       match='You must pass at least "cell_type" '
-                             'or "model_parameters" as arguments.'):
-        _ = spectrum.martin_ruiz_spectral_modifier(clearness_index,
-                                                   airmass_absolute)
+        _ = spectrum.martin_ruiz(clearness_index, airmass_absolute,
+                                 module_type='')
 
 
 def test_martin_ruiz_mm_error_model_keys(martin_ruiz_mismatch_data):
@@ -345,7 +314,30 @@ def test_martin_ruiz_mm_error_model_keys(martin_ruiz_mismatch_data):
     with pytest.raises(ValueError,
                        match="You must specify model parameters with keys "
                              "'a','b','c' for each irradiation component."):
-        _ = spectrum.martin_ruiz_spectral_modifier(
-            clearness_index,
-            airmass_absolute,
-            model_parameters=model_parameters)
+        _ = spectrum.martin_ruiz(clearness_index, airmass_absolute,
+                                 model_parameters=model_parameters)
+
+
+def test_martin_ruiz_mm_error_missing_params(martin_ruiz_mismatch_data):
+    # test exception is raised when missing module_type and model_parameters
+    clearness_index = np.array(martin_ruiz_mismatch_data['clearness_index'])
+    airmass_absolute = np.array(martin_ruiz_mismatch_data['airmass_absolute'])
+
+    with pytest.raises(TypeError,
+                       match='You must pass at least "module_type" '
+                             'or "model_parameters" as arguments.'):
+        _ = spectrum.martin_ruiz(clearness_index, airmass_absolute)
+
+
+def test_martin_ruiz_mm_error_too_many_arguments(martin_ruiz_mismatch_data):
+    # test warning is raised with both 'module_type' and 'model_parameters'
+    clearness_index = pd.Series(martin_ruiz_mismatch_data['clearness_index'])
+    airmass_absolute = pd.Series(martin_ruiz_mismatch_data['airmass_absolute'])
+    model_parameters = martin_ruiz_mismatch_data['monosi_model_params_dict']
+
+    with pytest.raises(TypeError,
+                       match='Cannot resolve input: must supply only one of '
+                             '"module_type" or "model_parameters"'):
+        _ = spectrum.martin_ruiz(clearness_index, airmass_absolute,
+                                 module_type='asi',
+                                 model_parameters=model_parameters)

From d66f16e2b38225850deb5cf76a308960aa6246b9 Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Wed, 15 Feb 2023 19:13:05 +0100
Subject: [PATCH 25/35] code review

* update tutorial
---
 .../spectral_mismatch_modifiers.ipynb         | 31 +++++++++----------
 1 file changed, 14 insertions(+), 17 deletions(-)

diff --git a/docs/tutorials/spectral_mismatch_modifiers.ipynb b/docs/tutorials/spectral_mismatch_modifiers.ipynb
index 8517f3c33a..e63fbb5172 100644
--- a/docs/tutorials/spectral_mismatch_modifiers.ipynb
+++ b/docs/tutorials/spectral_mismatch_modifiers.ipynb
@@ -35,7 +35,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -78,7 +78,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -97,7 +97,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -122,7 +122,7 @@
     "# Let's consider this the irradiances without spectral modifiers\n",
     "# We can calculate the mismatch before and then create a \"poa_irrad\" var for\n",
     "# modified irradiances, but we are also doing this to compare later.\n",
-    "# 'spectrum.martin_ruiz_spectral_modifier' result is designed to make it\n",
+    "# 'spectrum.martin_ruiz' result is designed to make it\n",
     "# easy to multiply each modifier and the irradiance component with a single\n",
     "# line of code, if you get this dataframe before.\n",
     "poa_irrad = pvlib.irradiance.poa_components(aoi,\n",
@@ -142,7 +142,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -157,9 +157,8 @@
     "\n",
     "# Get the spectral mismatch modifiers\n",
     "spectral_modifiers = \\\n",
-    "    pvlib.spectrum.martin_ruiz_spectral_modifier(clearness_index,\n",
-    "                                                 airmass['airmass_absolute'],\n",
-    "                                                 cell_type='monosi')"
+    "    pvlib.spectrum.martin_ruiz(clearness_index, airmass['airmass_absolute'],\n",
+    "                               module_type='monosi')"
    ]
   },
   {
@@ -177,17 +176,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
     "poa_irrad_modified = poa_irrad * spectral_modifiers\n",
-    "# We need global modified irradiance for the output power calculation\n",
-    "poa_irrad_modified = \\\n",
-    "    pvlib.irradiance.poa_components(aoi,\n",
-    "                                    poa_irrad_modified['poa_direct'],\n",
-    "                                    poa_irrad_modified['poa_sky_diffuse'],\n",
-    "                                    poa_irrad_modified['poa_ground_diffuse'])"
+    "# We want global modified irradiance - so let's add them\n",
+    "poa_irrad_modified['poa_global'] = (poa_irrad_modified['poa_direct']\n",
+    "                                    + poa_irrad_modified['poa_sky_diffuse']\n",
+    "                                    + poa_irrad_modified['poa_ground_diffuse'])"
    ]
   },
   {
@@ -201,12 +198,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]

From db48a7655fb15aaff0eb047d67e3b2ed050a5235 Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Wed, 15 Feb 2023 21:21:36 +0100
Subject: [PATCH 26/35] Add to reference and add whatsnew entry

---
 .../source/reference/effects_on_pv_system_output/spectrum.rst | 1 +
 docs/sphinx/source/whatsnew/v0.9.5.rst                        | 4 ++++
 2 files changed, 5 insertions(+)

diff --git a/docs/sphinx/source/reference/effects_on_pv_system_output/spectrum.rst b/docs/sphinx/source/reference/effects_on_pv_system_output/spectrum.rst
index b6fe7f4684..8be15f1a30 100644
--- a/docs/sphinx/source/reference/effects_on_pv_system_output/spectrum.rst
+++ b/docs/sphinx/source/reference/effects_on_pv_system_output/spectrum.rst
@@ -10,3 +10,4 @@ Spectrum
    spectrum.get_example_spectral_response
    spectrum.get_am15g
    spectrum.calc_spectral_mismatch_field
+   spectrum.martin_ruiz
diff --git a/docs/sphinx/source/whatsnew/v0.9.5.rst b/docs/sphinx/source/whatsnew/v0.9.5.rst
index c11d72f0de..0da9ce6ab8 100644
--- a/docs/sphinx/source/whatsnew/v0.9.5.rst
+++ b/docs/sphinx/source/whatsnew/v0.9.5.rst
@@ -20,6 +20,9 @@ Enhancements
   :py:func:`pvlib.snow.loss_townsend` (:issue:`1636`, :pull:`1653`)
 * Added optional ``n_ar`` parameter to :py:func:`pvlib.iam.physical` to
   support an anti-reflective coating. (:issue:`1501`, :pull:`1616`)
+* Added :py:func:`pvlib.spectrum.martin_ruiz`, a spectral
+  mismatch correction factor for POA components, dependant in module type,
+  airmass and clearness index (:pull:`1658`)
 
 Bug fixes
 ~~~~~~~~~
@@ -64,3 +67,4 @@ Contributors
 * Mark Mikofski (:ghuser:`mikofski`)
 * Anton Driesse (:ghuser:`adriesse`)
 * Michael Deceglie (:ghuser:`mdeceglie`)
+* Echedey Luis (:ghuser:`echedey-ls`)

From e7011efa0342dcd546833023eaed57415321a3db Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Thu, 16 Feb 2023 18:27:45 +0100
Subject: [PATCH 27/35] docstring: forgot to update raises

---
 pvlib/spectrum/mismatch.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index 991b29ce48..8422788185 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -305,6 +305,8 @@ def martin_ruiz(clearness_index, airmass_absolute, module_type=None,
         If ``model_parameters`` is not suitable. See examples given above.
     TypeError
         If neither ``module_type`` nor ``model_parameters`` are given.
+    TypeError
+        If both ``module_type`` and ``model_parameters`` are provided.
     NotImplementedError
         If ``module_type`` is not found in internal table of parameters.
 

From 30c66b973e9379635f8e83bc253c819e8217c78b Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Sun, 19 Feb 2023 23:58:51 +0100
Subject: [PATCH 28/35] Add sphinx example and delete notebook

---
 .../spectrum/plot_martin_ruiz_mismatch.py     | 124 +++++++++
 .../spectral_mismatch_modifiers.ipynb         | 254 ------------------
 2 files changed, 124 insertions(+), 254 deletions(-)
 create mode 100644 docs/examples/spectrum/plot_martin_ruiz_mismatch.py
 delete mode 100644 docs/tutorials/spectral_mismatch_modifiers.ipynb

diff --git a/docs/examples/spectrum/plot_martin_ruiz_mismatch.py b/docs/examples/spectrum/plot_martin_ruiz_mismatch.py
new file mode 100644
index 0000000000..ba7dd244e9
--- /dev/null
+++ b/docs/examples/spectrum/plot_martin_ruiz_mismatch.py
@@ -0,0 +1,124 @@
+"""
+N. Martin & J. M. Ruiz Spectral Mismatch Modifier
+=================================================
+
+How to use this correction factor to adjust the POA global irradiance.
+"""
+
+# %%
+# Effectiveness of a material to convert incident sunlight to current depends
+# on the incident light wavelength. During the day, the spectral distribution
+# of the incident irradiance varies from the standard testing spectra,
+# introducing a small difference between the expected and the real output.
+# In [1]_, N. Martín and J. M. Ruiz propose 3 mismatch factors, one for each
+# irradiance component. These mismatch modifiers are calculated with the help
+# of the airmass, the clearness index and three experimental fitting
+# parameters. In the same paper, these parameters have been obtained for m-Si,
+# p-Si and a-Si modules.
+# With :py:func:`pvlib.spectrum.martin_ruiz` we are able to make use of these
+# already computed values or provide ours.
+#
+# References
+# ----------
+#  .. [1] Martín, N. and Ruiz, J.M. (1999), A new method for the spectral
+#     characterisation of PV modules. Prog. Photovolt: Res. Appl., 7: 299-310.
+#     :doi:`10.1002/(SICI)1099-159X(199907/08)7:4<299::AID-PIP260>3.0.CO;2-0`
+#
+# Calculating the incident and modified global irradiance
+# -------------------------------------------------------
+#
+# This mismatch modifier is applied to the irradiance components, so first
+# step is to get them. We define an hypothetical POA surface and use a TMY to
+# compute them from a TMY.
+
+import matplotlib.pyplot as plt
+from pvlib import spectrum, irradiance, iotools, location
+
+surface_tilt = 40
+surface_azimuth = 180  # Pointing South
+# We will need some location to start with & the TMY
+site = location.Location(40.4534, -3.7270, altitude=664,
+                         name='IES-UPM, Madrid')
+
+pvgis_data, _, _, _ = iotools.get_pvgis_tmy(site.latitude, site.longitude,
+                                            map_variables=True,
+                                            startyear=2005, endyear=2015)
+# Coerce a year: above function returns typical months of different years
+pvgis_data.index = [ts.replace(year=2022) for ts in pvgis_data.index]
+# Select days to show
+weather_data = pvgis_data['2022-10-03':'2022-10-07']
+
+# Then calculate all we need to get the irradiance components
+solar_pos = site.get_solarposition(weather_data.index)
+
+extra_rad = irradiance.get_extra_radiation(weather_data.index)
+
+poa_sky_diffuse = irradiance.haydavies(surface_tilt, surface_azimuth,
+                                       weather_data['dhi'],
+                                       weather_data['dni'],
+                                       extra_rad,
+                                       solar_pos['apparent_zenith'],
+                                       solar_pos['azimuth'])
+
+poa_ground_diffuse = irradiance.get_ground_diffuse(surface_tilt,
+                                                   weather_data['ghi'])
+
+aoi = irradiance.aoi(surface_tilt, surface_azimuth,
+                     solar_pos['apparent_zenith'], solar_pos['azimuth'])
+
+# %%
+# Let's consider this the irradiance components without spectral modifiers.
+# We can calculate the mismatch before and then create a "poa_irrad" var for
+# modified components directly, but we want to show the output difference.
+# Also, note that :py:func:`pvlib.spectrum.martin_ruiz` result is designed to
+# make it easy to multiply each modifier and the irradiance component with a
+# single line of code, if you get this dataframe before.
+
+poa_irrad = irradiance.poa_components(aoi, weather_data['dni'],
+                                      poa_sky_diffuse, poa_ground_diffuse)
+
+# %%
+# Here comes the modifier. Let's calculate it with the airmass and clearness
+# index.
+# First, let's find the airmass and the clearness index.
+# Little caution: default values for this model were fitted obtaining the
+# airmass through the `'kasten1966'` method, which is not used by default.
+
+airmass = site.get_airmass(solar_position=solar_pos, model='kasten1966')
+clearness_index = irradiance.clearness_index(weather_data['ghi'],
+                                             solar_pos['zenith'], extra_rad)
+
+# Get the spectral mismatch modifiers
+spectral_modifiers = spectrum.martin_ruiz(clearness_index,
+                                          airmass['airmass_absolute'],
+                                          module_type='monosi')
+
+# %%
+# And then we can find the 3 modified components of the POA irradiance
+# by means of a simple multiplication.
+# Note, however, that neither this does modify ``poa_global`` nor
+# ``poa_diffuse``, so we should update the dataframe afterwards.
+
+poa_irrad_modified = poa_irrad * spectral_modifiers
+
+# We want global modified irradiance
+poa_irrad_modified['poa_global'] = (poa_irrad_modified['poa_direct']
+                                    + poa_irrad_modified['poa_sky_diffuse']
+                                    + poa_irrad_modified['poa_ground_diffuse'])
+# Don't forget to update `'poa_diffuse'` if you want to use it
+# poa_irrad_modified['poa_diffuse'] = \
+#     (poa_irrad_modified['poa_sky_diffuse']
+#      + poa_irrad_modified['poa_ground_diffuse'])
+
+# %%
+# Finally, let's plot the incident vs modified global irradiance, and their
+# difference.
+
+poa_irrad_global_diff = (poa_irrad['poa_global']
+                         - poa_irrad_modified['poa_global'])
+poa_irrad['poa_global'].plot()
+poa_irrad_modified['poa_global'].plot()
+poa_irrad_global_diff.plot()
+plt.legend(['Incident', 'Modified', 'Difference'])
+plt.ylabel('POA Global irradiance [W/m²]')
+plt.show()
diff --git a/docs/tutorials/spectral_mismatch_modifiers.ipynb b/docs/tutorials/spectral_mismatch_modifiers.ipynb
deleted file mode 100644
index e63fbb5172..0000000000
--- a/docs/tutorials/spectral_mismatch_modifiers.ipynb
+++ /dev/null
@@ -1,254 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Spectral Mismatch Modifiers\n",
-    "Learn to use spectral mismatch modifiers with this notebook!\n",
-    "Feel free to add other models, be sure to update the index and give you credit ;)\n",
-    "\n",
-    "Table of contents:\n",
-    "1. [Setup](#setup-the-environment)\n",
-    "1. [N. Martin & J. M. Ruiz Experimental Mismatch Modifier](#n-martin--j-m-ruiz-experimental-mismatch-modifier)\n",
-    "\n",
-    "Authors:\n",
-    "* Echedey Luis (@echedey-ls), 2023 Feb"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Setup the environment"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Run this before anything else."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Show matplotlib's figures in the notebook\n",
-    "%matplotlib inline\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "\n",
-    "# And pvlib\n",
-    "import pvlib"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### N. Martin & J. M. Ruiz Mismatch Modifier\n",
-    "This modifier takes into account the spectral responses of several solar cell\n",
-    "material, characterized by the airmass and the clearness index, as two\n",
-    "independent variables. In fact, there are three different modifiers, each one\n",
-    "for each component (``poa_direct``, ``poa_sky_diffuse``,\n",
-    "``poa_ground_diffuse``)\n",
-    "\n",
-    "The formula for each component has three coefficients; we are lucky the authors\n",
-    "of this model computed fitting values for m-Si, p-Si and a-Si!"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "First step is get to the effective irradiance. For simplicity, we will copy the\n",
-    "procedure explained in the tutorial ``tmy_to_power.ipynb`` to obtain it.\n",
-    "Please refer to it to get a more in depth explanation."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "site = pvlib.location.Location(40.4534, -3.7270, altitude=664,\n",
-    "                               name='IES-UPM, Madrid')\n",
-    "\n",
-    "surface_tilt = 40\n",
-    "surface_azimuth = 180  # Pointing South\n",
-    "\n",
-    "pvgis_data, _, _, _ = \\\n",
-    "    pvlib.iotools.get_pvgis_tmy(site.latitude, site.longitude,\n",
-    "                                map_variables=True,\n",
-    "                                startyear=2005, endyear=2015)\n",
-    "pvgis_data.index = [ts.replace(year=2022) for ts in pvgis_data.index]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "weather_data = pvgis_data['2022-09-03':'2022-09-06']\n",
-    "\n",
-    "solar_pos = site.get_solarposition(weather_data.index)\n",
-    "\n",
-    "extra_rad = pvlib.irradiance.get_extra_radiation(weather_data.index)\n",
-    "\n",
-    "poa_sky_diffuse = \\\n",
-    "    pvlib.irradiance.haydavies(surface_tilt, surface_azimuth,\n",
-    "                               weather_data['dhi'],  weather_data['dni'],\n",
-    "                               extra_rad, solar_pos['apparent_zenith'],\n",
-    "                               solar_pos['azimuth'])\n",
-    "\n",
-    "poa_ground_diffuse = pvlib.irradiance.get_ground_diffuse(surface_tilt,\n",
-    "                                                         weather_data['ghi'])\n",
-    "\n",
-    "aoi = pvlib.irradiance.aoi(surface_tilt, surface_azimuth,\n",
-    "                           solar_pos['apparent_zenith'], solar_pos['azimuth'])\n",
-    "\n",
-    "# Let's consider this the irradiances without spectral modifiers\n",
-    "# We can calculate the mismatch before and then create a \"poa_irrad\" var for\n",
-    "# modified irradiances, but we are also doing this to compare later.\n",
-    "# 'spectrum.martin_ruiz' result is designed to make it\n",
-    "# easy to multiply each modifier and the irradiance component with a single\n",
-    "# line of code, if you get this dataframe before.\n",
-    "poa_irrad = pvlib.irradiance.poa_components(aoi,\n",
-    "                                            weather_data['dni'],\n",
-    "                                            poa_sky_diffuse,\n",
-    "                                            poa_ground_diffuse)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Here comes the modifier. Let's calculate it with the airmass and clearness\n",
-    "index."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First, let's find the airmass and the clearness index\n",
-    "# Little caution: default values for this model were fitted obtaining the\n",
-    "# airmass through the kasten1966 method, not used by default\n",
-    "airmass = site.get_airmass(solar_position=solar_pos, model='kasten1966')\n",
-    "clearness_index = \\\n",
-    "    pvlib.irradiance.clearness_index(ghi=weather_data['ghi'],\n",
-    "                                     solar_zenith=solar_pos['zenith'],\n",
-    "                                     extra_radiation=extra_rad)\n",
-    "\n",
-    "# Get the spectral mismatch modifiers\n",
-    "spectral_modifiers = \\\n",
-    "    pvlib.spectrum.martin_ruiz(clearness_index, airmass['airmass_absolute'],\n",
-    "                               module_type='monosi')"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "And then we can find the 3 components modified irradiances by means of a simple\n",
-    "multiplication.\n",
-    "\n",
-    "Note, however, that neither this does modify ``poa_global`` nor\n",
-    "``poa_diffuse``, so we should update the dataframe afterwards, again with\n",
-    "``irradiance.poa_components``."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "poa_irrad_modified = poa_irrad * spectral_modifiers\n",
-    "# We want global modified irradiance - so let's add them\n",
-    "poa_irrad_modified['poa_global'] = (poa_irrad_modified['poa_direct']\n",
-    "                                    + poa_irrad_modified['poa_sky_diffuse']\n",
-    "                                    + poa_irrad_modified['poa_ground_diffuse'])"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Finally, let's plot the incident vs modified global irradiances, and their\n",
-    "difference."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "poa_irrad_global_diff = (poa_irrad['poa_global']\n",
-    "                         - poa_irrad_modified['poa_global'])\n",
-    "poa_irrad['poa_global'].plot()\n",
-    "poa_irrad_modified['poa_global'].plot()\n",
-    "poa_irrad_global_diff.plot()\n",
-    "plt.legend(['Incident', 'Modified', 'Difference'])\n",
-    "plt.ylabel('POA Global irradiance [W/m²]')\n",
-    "plt.show()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "venv",
-   "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.10.4"
-  },
-  "orig_nbformat": 4,
-  "vscode": {
-   "interpreter": {
-    "hash": "e7b76f25baca03aa641c501db0912de76daa352e2d97ceb6fcf3025f206f2928"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

From c04b70d6770bcaa03d6815659e4f9f455f184be4 Mon Sep 17 00:00:00 2001
From: Echedey Luis <80125792+echedey-ls@users.noreply.github.com>
Date: Mon, 20 Feb 2023 23:26:19 +0100
Subject: [PATCH 29/35] example: code review

Co-authored-by: Cliff Hansen <cwhanse@sandia.gov>
---
 docs/examples/spectrum/plot_martin_ruiz_mismatch.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/examples/spectrum/plot_martin_ruiz_mismatch.py b/docs/examples/spectrum/plot_martin_ruiz_mismatch.py
index ba7dd244e9..2148fadae1 100644
--- a/docs/examples/spectrum/plot_martin_ruiz_mismatch.py
+++ b/docs/examples/spectrum/plot_martin_ruiz_mismatch.py
@@ -27,9 +27,9 @@
 # Calculating the incident and modified global irradiance
 # -------------------------------------------------------
 #
-# This mismatch modifier is applied to the irradiance components, so first
-# step is to get them. We define an hypothetical POA surface and use a TMY to
-# compute them from a TMY.
+# Mismatch modifiers are applied to the irradiance components, so first
+# step is to get them. We define an hypothetical POA surface and use TMY to
+# compute sky diffuse, ground reflected and direct irradiance.
 
 import matplotlib.pyplot as plt
 from pvlib import spectrum, irradiance, iotools, location
@@ -78,7 +78,7 @@
                                       poa_sky_diffuse, poa_ground_diffuse)
 
 # %%
-# Here comes the modifier. Let's calculate it with the airmass and clearness
+# Here come the modifiers. Let's calculate them with the airmass and clearness
 # index.
 # First, let's find the airmass and the clearness index.
 # Little caution: default values for this model were fitted obtaining the
@@ -96,7 +96,7 @@
 # %%
 # And then we can find the 3 modified components of the POA irradiance
 # by means of a simple multiplication.
-# Note, however, that neither this does modify ``poa_global`` nor
+# Note, however, that this does not modify ``poa_global`` nor
 # ``poa_diffuse``, so we should update the dataframe afterwards.
 
 poa_irrad_modified = poa_irrad * spectral_modifiers

From 183320f33619d183cb087e4de006427c5eae6e59 Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Mon, 20 Feb 2023 23:39:17 +0100
Subject: [PATCH 30/35] example: code review (II)

Co-Authored-By: Cliff Hansen <5393711+cwhanse@users.noreply.github.com>
---
 docs/examples/spectrum/plot_martin_ruiz_mismatch.py | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/docs/examples/spectrum/plot_martin_ruiz_mismatch.py b/docs/examples/spectrum/plot_martin_ruiz_mismatch.py
index 2148fadae1..0012d3ab40 100644
--- a/docs/examples/spectrum/plot_martin_ruiz_mismatch.py
+++ b/docs/examples/spectrum/plot_martin_ruiz_mismatch.py
@@ -66,14 +66,7 @@
 aoi = irradiance.aoi(surface_tilt, surface_azimuth,
                      solar_pos['apparent_zenith'], solar_pos['azimuth'])
 
-# %%
-# Let's consider this the irradiance components without spectral modifiers.
-# We can calculate the mismatch before and then create a "poa_irrad" var for
-# modified components directly, but we want to show the output difference.
-# Also, note that :py:func:`pvlib.spectrum.martin_ruiz` result is designed to
-# make it easy to multiply each modifier and the irradiance component with a
-# single line of code, if you get this dataframe before.
-
+# Get dataframe with all components and global (includes 'poa_direct')
 poa_irrad = irradiance.poa_components(aoi, weather_data['dni'],
                                       poa_sky_diffuse, poa_ground_diffuse)
 

From 8730fcdfaaddd59707d9ce83252e1ef65fb1dc6b Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Mon, 20 Feb 2023 23:42:05 +0100
Subject: [PATCH 31/35] docstring: update per PR #1628

---
 pvlib/spectrum/mismatch.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index 8422788185..edd21ac5a4 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -330,7 +330,7 @@ def martin_ruiz(clearness_index, airmass_absolute, module_type=None,
     pvlib.irradiance.clearness_index
     pvlib.atmosphere.get_relative_airmass
     pvlib.atmosphere.get_absolute_airmass
-    pvlib.atmosphere.first_solar_spectral_correction
+    pvlib.atmosphere.first_solar
     """
     # Note tests for this function are prefixed with test_martin_ruiz_mm_*
 

From 7ced74bc92c1cdd5d2c96213268952938e63e866 Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Wed, 22 Feb 2023 20:10:33 +0100
Subject: [PATCH 32/35] sapm_effective_irradiance: docstring rst typo

---
 pvlib/pvsystem.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/pvlib/pvsystem.py b/pvlib/pvsystem.py
index 7cda12b790..fdb9c1d3bc 100644
--- a/pvlib/pvsystem.py
+++ b/pvlib/pvsystem.py
@@ -2674,10 +2674,7 @@ def sapm_effective_irradiance(poa_direct, poa_diffuse, airmass_absolute, aoi,
     and diffuse irradiance on the plane of array to the irradiance absorbed by
     a module's cells.
 
-    The model is
-    .. math::
-
-        `Ee = f_1(AM_a) (E_b f_2(AOI) + f_d E_d)`
+    The model is :math:`Ee = f_1(AM_a) (E_b f_2(AOI) + f_d E_d)`
 
     where :math:`Ee` is effective irradiance (W/m2), :math:`f_1` is a fourth
     degree polynomial in air mass :math:`AM_a`, :math:`E_b` is beam (direct)

From 6385897b909224b1c126b12622549aef33308e2e Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Wed, 22 Feb 2023 20:10:52 +0100
Subject: [PATCH 33/35] docstring: add math directives to parameters

---
 pvlib/spectrum/mismatch.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index edd21ac5a4..f603717b59 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -316,8 +316,8 @@ def martin_ruiz(clearness_index, airmass_absolute, module_type=None,
 
     .. math:: M = c \cdot \exp( a \cdot (K_t - 0.74) + b \cdot (AM - 1.5) )
 
-    where ``c``, ``a`` and ``b`` are the model parameters, different for each
-    irradiance component.
+    where :math:`c`, :math:`a` and :math:`b` are the model parameters,
+    different for each irradiance component.
 
     References
     ----------

From 108def0ca1a2f7988c29771ab958f025e12526f2 Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Fri, 24 Feb 2023 23:30:25 +0100
Subject: [PATCH 34/35] example: add comparison with other models

0. We've found that MR model does not match other spectral mismatch models as expected - this commit shows that, in case some insight can be given
1. Uses atmosphere.first_solar_spectral_correction--> to be changed before merging
2. Compares with:
 * pvsystem.sapm_spectral_loss
 * atmosphere.first_solar_spectral_correction
3. Docs are already up-to-date with the first_solar renaming
---
 .../spectrum/plot_martin_ruiz_mismatch.py     | 97 ++++++++++++++++++-
 1 file changed, 93 insertions(+), 4 deletions(-)

diff --git a/docs/examples/spectrum/plot_martin_ruiz_mismatch.py b/docs/examples/spectrum/plot_martin_ruiz_mismatch.py
index 0012d3ab40..18f7fec11d 100644
--- a/docs/examples/spectrum/plot_martin_ruiz_mismatch.py
+++ b/docs/examples/spectrum/plot_martin_ruiz_mismatch.py
@@ -32,7 +32,9 @@
 # compute sky diffuse, ground reflected and direct irradiance.
 
 import matplotlib.pyplot as plt
-from pvlib import spectrum, irradiance, iotools, location
+from pvlib import spectrum, irradiance, iotools, location, pvsystem, atmosphere
+import pandas as pd
+from scipy import stats
 
 surface_tilt = 40
 surface_azimuth = 180  # Pointing South
@@ -109,9 +111,96 @@
 
 poa_irrad_global_diff = (poa_irrad['poa_global']
                          - poa_irrad_modified['poa_global'])
-poa_irrad['poa_global'].plot()
-poa_irrad_modified['poa_global'].plot()
-poa_irrad_global_diff.plot()
+plt.figure()
+datetimes = poa_irrad.index  # common to poa_irrad_*
+plt.plot(datetimes, poa_irrad['poa_global'].to_numpy())
+plt.plot(datetimes, poa_irrad_modified['poa_global'].to_numpy())
+plt.plot(datetimes, poa_irrad_global_diff.to_numpy())
 plt.legend(['Incident', 'Modified', 'Difference'])
 plt.ylabel('POA Global irradiance [W/m²]')
+plt.grid()
+plt.show()
+
+# %%
+# Comparison with other models
+# ----------------------------
+# During the addition of this model, a question arose about its trustworthiness
+# so, in order to check the integrity of the implementation, we will
+# compare it against :py:func:`pvlib.pvsystem.sapm_spectral_loss` and
+# :py:func:`pvlib.atmosphere.first_solar`.
+# Former model needs the parameters that characterise a module, but which one?
+# We will take the mean of Sandia parameters `'A0', 'A1', 'A2', 'A3', 'A4'` for
+# the same material type.
+# On the other hand, :py:func:`~pvlib.atmosphere.first_solar` needs the
+# precipitable water. We assume the standard spectrum, `1.42 cm`.
+
+# Retrieve modules and select the subset we want to work with the SAPM model
+module_type = 'mc-Si'  # Equivalent to monosi
+sandia_modules = pvsystem.retrieve_sam(name='SandiaMod')
+modules_subset = \
+    sandia_modules.loc[:, sandia_modules.loc['Material'] == module_type]
+
+# Define typical module and get the means of the A0 to A4 parameters
+modules_aggregated = pd.DataFrame(index=('mean', 'std'))
+for param in ('A0', 'A1', 'A2', 'A3', 'A4'):
+    result, _, _ = stats.mvsdist(modules_subset.loc[param])
+    modules_aggregated[param] = result.mean(), result.std()
+
+# Check if 'mean' is a representative value with help of 'std' just in case
+print(modules_aggregated)
+
+# Then apply the SAPM model and calculate introduced difference
+modifier_sapm_f1 = pvsystem.sapm_spectral_loss(airmass['airmass_absolute'],
+                                               modules_aggregated.loc['mean'])
+poa_irrad_sapm_modified = poa_irrad['poa_global'] * modifier_sapm_f1
+poa_irrad_sapm_difference = (poa_irrad['poa_global']
+                             - poa_irrad_sapm_modified)
+
+# atmosphere.first_solar model
+first_solar_pw = 1.42  # Default for AM1.5 spectrum
+modifier_first_solar = \
+    atmosphere.first_solar_spectral_correction(first_solar_pw,
+                                               airmass['airmass_absolute'],
+                                               module_type='monosi')
+poa_irrad_first_solar_mod = poa_irrad['poa_global'] * modifier_first_solar
+poa_irrad_first_solar_diff = (poa_irrad['poa_global']
+                              - poa_irrad_first_solar_mod)
+
+# %%
+# Plot global irradiance difference over time
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+datetimes = poa_irrad_global_diff.index  # common to poa_irrad_*_diff*
+plt.figure()
+plt.plot(datetimes, poa_irrad_global_diff.to_numpy(),
+         label='spectrum.martin_ruiz')
+plt.plot(datetimes, poa_irrad_sapm_difference.to_numpy(),
+         label='atmosphere.first_solar')
+plt.plot(datetimes, poa_irrad_first_solar_diff.to_numpy(),
+         label='pvsystem.sapm_spectral_loss')
+plt.legend()
+plt.title('Introduced difference comparison of different models')
+plt.ylabel('POA Global Irradiance Difference [W/m²]')
+plt.grid()
+plt.show()
+
+# %%
+# Plot modifier vs absolute airmass
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ama = airmass['airmass_absolute'].to_numpy()
+# spectrum.martin_ruiz has 3 modifiers, so we only calculate one as
+# M = S_eff / S_incident that takes into account the global effect
+martin_ruiz_agg_modifier = (poa_irrad_modified['poa_global']
+                            / poa_irrad['poa_global'])
+plt.figure()
+plt.scatter(ama, martin_ruiz_agg_modifier.to_numpy(),
+            label='spectrum.martin_ruiz')
+plt.scatter(ama, modifier_sapm_f1.to_numpy(),
+            label='pvsystem.sapm_spectral_loss')
+plt.scatter(ama, modifier_first_solar.to_numpy(),
+            label='atmosphere.first_solar')
+plt.legend()
+plt.title('Introduced difference comparison of different models')
+plt.xlabel('Absolute airmass')
+plt.ylabel(r'Modifier $M = \frac{S_{effective}}{S_{incident}}$')
+plt.grid()
 plt.show()

From d75eea03c0004cc2b605836ebc747bf4483b1e8c Mon Sep 17 00:00:00 2001
From: echedey-ls <80125792+echedey-ls@users.noreply.github.com>
Date: Sat, 25 Feb 2023 00:39:58 +0100
Subject: [PATCH 35/35] code review: func model, tests & example

Addressed in this commit:
* docstring: use "must"
* TypeError --> ValueError (func & tests updated)
* Make use of a local TMY data file
* Show per component maths behind modifier application

Co-Authored-By: Anton Driesse <9001027+adriesse@users.noreply.github.com>
---
 .../spectrum/plot_martin_ruiz_mismatch.py     | 81 +++++++++++--------
 pvlib/spectrum/mismatch.py                    | 25 +++---
 pvlib/tests/test_spectrum.py                  |  4 +-
 3 files changed, 62 insertions(+), 48 deletions(-)

diff --git a/docs/examples/spectrum/plot_martin_ruiz_mismatch.py b/docs/examples/spectrum/plot_martin_ruiz_mismatch.py
index 18f7fec11d..6da7a4bf7d 100644
--- a/docs/examples/spectrum/plot_martin_ruiz_mismatch.py
+++ b/docs/examples/spectrum/plot_martin_ruiz_mismatch.py
@@ -31,46 +31,51 @@
 # step is to get them. We define an hypothetical POA surface and use TMY to
 # compute sky diffuse, ground reflected and direct irradiance.
 
+import os
+
 import matplotlib.pyplot as plt
-from pvlib import spectrum, irradiance, iotools, location, pvsystem, atmosphere
-import pandas as pd
+import pvlib
 from scipy import stats
+import pandas as pd
 
 surface_tilt = 40
 surface_azimuth = 180  # Pointing South
-# We will need some location to start with & the TMY
-site = location.Location(40.4534, -3.7270, altitude=664,
-                         name='IES-UPM, Madrid')
 
-pvgis_data, _, _, _ = iotools.get_pvgis_tmy(site.latitude, site.longitude,
-                                            map_variables=True,
-                                            startyear=2005, endyear=2015)
+# Get TMY data & create location
+datapath = os.path.join(pvlib.__path__[0], 'data',
+                        'tmy_45.000_8.000_2005_2016.csv')
+pvgis_data, _, metadata, _ = pvlib.iotools.read_pvgis_tmy(datapath,
+                                                          map_variables=True)
+site = pvlib.location.Location(metadata['latitude'], metadata['longitude'],
+                               altitude=metadata['elevation'])
+
 # Coerce a year: above function returns typical months of different years
 pvgis_data.index = [ts.replace(year=2022) for ts in pvgis_data.index]
 # Select days to show
-weather_data = pvgis_data['2022-10-03':'2022-10-07']
+weather_data = pvgis_data['2022-09-03':'2022-09-06']
 
 # Then calculate all we need to get the irradiance components
 solar_pos = site.get_solarposition(weather_data.index)
 
-extra_rad = irradiance.get_extra_radiation(weather_data.index)
+extra_rad = pvlib.irradiance.get_extra_radiation(weather_data.index)
 
-poa_sky_diffuse = irradiance.haydavies(surface_tilt, surface_azimuth,
-                                       weather_data['dhi'],
-                                       weather_data['dni'],
-                                       extra_rad,
-                                       solar_pos['apparent_zenith'],
-                                       solar_pos['azimuth'])
+poa_sky_diffuse = pvlib.irradiance.haydavies(surface_tilt, surface_azimuth,
+                                             weather_data['dhi'],
+                                             weather_data['dni'],
+                                             extra_rad,
+                                             solar_pos['apparent_zenith'],
+                                             solar_pos['azimuth'])
 
-poa_ground_diffuse = irradiance.get_ground_diffuse(surface_tilt,
-                                                   weather_data['ghi'])
+poa_ground_diffuse = pvlib.irradiance.get_ground_diffuse(surface_tilt,
+                                                         weather_data['ghi'])
 
-aoi = irradiance.aoi(surface_tilt, surface_azimuth,
-                     solar_pos['apparent_zenith'], solar_pos['azimuth'])
+aoi = pvlib.irradiance.aoi(surface_tilt, surface_azimuth,
+                           solar_pos['apparent_zenith'], solar_pos['azimuth'])
 
 # Get dataframe with all components and global (includes 'poa_direct')
-poa_irrad = irradiance.poa_components(aoi, weather_data['dni'],
-                                      poa_sky_diffuse, poa_ground_diffuse)
+poa_irrad = pvlib.irradiance.poa_components(aoi, weather_data['dni'],
+                                            poa_sky_diffuse,
+                                            poa_ground_diffuse)
 
 # %%
 # Here come the modifiers. Let's calculate them with the airmass and clearness
@@ -80,13 +85,15 @@
 # airmass through the `'kasten1966'` method, which is not used by default.
 
 airmass = site.get_airmass(solar_position=solar_pos, model='kasten1966')
-clearness_index = irradiance.clearness_index(weather_data['ghi'],
-                                             solar_pos['zenith'], extra_rad)
+airmass_absolute = airmass['airmass_absolute']  # We only use absolute airmass
+clearness_index = pvlib.irradiance.clearness_index(weather_data['ghi'],
+                                                   solar_pos['zenith'],
+                                                   extra_rad)
 
 # Get the spectral mismatch modifiers
-spectral_modifiers = spectrum.martin_ruiz(clearness_index,
-                                          airmass['airmass_absolute'],
-                                          module_type='monosi')
+spectral_modifiers = pvlib.spectrum.martin_ruiz(clearness_index,
+                                                airmass_absolute,
+                                                module_type='monosi')
 
 # %%
 # And then we can find the 3 modified components of the POA irradiance
@@ -95,6 +102,11 @@
 # ``poa_diffuse``, so we should update the dataframe afterwards.
 
 poa_irrad_modified = poa_irrad * spectral_modifiers
+# Above line is equivalent to:
+# poa_irrad_modified = pd.DataFrame()
+# for component in ('poa_direct', 'poa_sky_diffuse', 'poa_ground_diffuse'):
+#     poa_irrad_modified[component] = (poa_irrad[component]
+#                                      * spectral_modifiers[component])
 
 # We want global modified irradiance
 poa_irrad_modified['poa_global'] = (poa_irrad_modified['poa_direct']
@@ -136,7 +148,7 @@
 
 # Retrieve modules and select the subset we want to work with the SAPM model
 module_type = 'mc-Si'  # Equivalent to monosi
-sandia_modules = pvsystem.retrieve_sam(name='SandiaMod')
+sandia_modules = pvlib.pvsystem.retrieve_sam(name='SandiaMod')
 modules_subset = \
     sandia_modules.loc[:, sandia_modules.loc['Material'] == module_type]
 
@@ -150,8 +162,9 @@
 print(modules_aggregated)
 
 # Then apply the SAPM model and calculate introduced difference
-modifier_sapm_f1 = pvsystem.sapm_spectral_loss(airmass['airmass_absolute'],
-                                               modules_aggregated.loc['mean'])
+modifier_sapm_f1 = \
+    pvlib.pvsystem.sapm_spectral_loss(airmass_absolute,
+                                      modules_aggregated.loc['mean'])
 poa_irrad_sapm_modified = poa_irrad['poa_global'] * modifier_sapm_f1
 poa_irrad_sapm_difference = (poa_irrad['poa_global']
                              - poa_irrad_sapm_modified)
@@ -159,9 +172,9 @@
 # atmosphere.first_solar model
 first_solar_pw = 1.42  # Default for AM1.5 spectrum
 modifier_first_solar = \
-    atmosphere.first_solar_spectral_correction(first_solar_pw,
-                                               airmass['airmass_absolute'],
-                                               module_type='monosi')
+    pvlib.atmosphere.first_solar_spectral_correction(first_solar_pw,
+                                                     airmass_absolute,
+                                                     module_type='monosi')
 poa_irrad_first_solar_mod = poa_irrad['poa_global'] * modifier_first_solar
 poa_irrad_first_solar_diff = (poa_irrad['poa_global']
                               - poa_irrad_first_solar_mod)
@@ -186,7 +199,7 @@
 # %%
 # Plot modifier vs absolute airmass
 # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-ama = airmass['airmass_absolute'].to_numpy()
+ama = airmass_absolute.to_numpy()
 # spectrum.martin_ruiz has 3 modifiers, so we only calculate one as
 # M = S_eff / S_incident that takes into account the global effect
 martin_ruiz_agg_modifier = (poa_irrad_modified['poa_global']
diff --git a/pvlib/spectrum/mismatch.py b/pvlib/spectrum/mismatch.py
index f603717b59..e1d127c129 100644
--- a/pvlib/spectrum/mismatch.py
+++ b/pvlib/spectrum/mismatch.py
@@ -246,8 +246,9 @@ def martin_ruiz(clearness_index, airmass_absolute, module_type=None,
 
     .. warning::
         Included model parameters for ``monosi``, ``polysi`` and ``asi`` were
-        estimated using the airmass model ``kasten1966`` [1]_. It is heavily
-        recommended to use the same model in order to not introduce errors.
+        estimated using the airmass model ``kasten1966`` [1]_.
+        The same airmass model *must* be used to calculate the airmass input
+        values to this function in order to not introduce errors.
         See :py:func:`~pvlib.atmosphere.get_relative_airmass`.
 
     Parameters
@@ -256,14 +257,14 @@ def martin_ruiz(clearness_index, airmass_absolute, module_type=None,
         Clearness index of the sky.
 
     airmass_absolute : numeric
-        Absolute airmass. Give attention to algorithm used (``kasten1966`` is
-        recommended for default parameters of ``monosi``, ``polysi`` and
-        ``asi``, see [1]_).
+        Absolute airmass. ``kasten1966`` airmass algorithm must be used
+        for default parameters of ``monosi``, ``polysi`` and ``asi``,
+        see [1]_.
 
     module_type : string, optional
         Specifies material of the cell in order to infer model parameters.
         Allowed types are ``monosi``, ``polysi`` and ``asi``, either lower or
-        upper case. If not specified, ``model_parameters`` must be provided.
+        upper case. If not specified, ``model_parameters`` has to be provided.
 
     model_parameters : dict-like, optional
         Provide either a dict or a ``pd.DataFrame`` as follows:
@@ -303,9 +304,9 @@ def martin_ruiz(clearness_index, airmass_absolute, module_type=None,
     ------
     ValueError
         If ``model_parameters`` is not suitable. See examples given above.
-    TypeError
+    ValueError
         If neither ``module_type`` nor ``model_parameters`` are given.
-    TypeError
+    ValueError
         If both ``module_type`` and ``model_parameters`` are provided.
     NotImplementedError
         If ``module_type`` is not found in internal table of parameters.
@@ -365,11 +366,11 @@ def martin_ruiz(clearness_index, airmass_absolute, module_type=None,
                              "'a','b','c' for each irradiation component.")
         _params = model_parameters
     elif module_type is None and model_parameters is None:
-        raise TypeError('You must pass at least "module_type" '
-                        'or "model_parameters" as arguments.')
+        raise ValueError('You must pass at least "module_type" '
+                         'or "model_parameters" as arguments.')
     elif model_parameters is not None and module_type is not None:
-        raise TypeError('Cannot resolve input: must supply only one of '
-                        '"module_type" or "model_parameters"')
+        raise ValueError('Cannot resolve input: must supply only one of '
+                         '"module_type" or "model_parameters"')
 
     if np.isscalar(clearness_index) and np.isscalar(airmass_absolute):
         modifiers = dict(zip(IRRAD_COMPONENTS, (np.nan,)*3))
diff --git a/pvlib/tests/test_spectrum.py b/pvlib/tests/test_spectrum.py
index 83b5892a64..ad298e6c48 100644
--- a/pvlib/tests/test_spectrum.py
+++ b/pvlib/tests/test_spectrum.py
@@ -323,7 +323,7 @@ def test_martin_ruiz_mm_error_missing_params(martin_ruiz_mismatch_data):
     clearness_index = np.array(martin_ruiz_mismatch_data['clearness_index'])
     airmass_absolute = np.array(martin_ruiz_mismatch_data['airmass_absolute'])
 
-    with pytest.raises(TypeError,
+    with pytest.raises(ValueError,
                        match='You must pass at least "module_type" '
                              'or "model_parameters" as arguments.'):
         _ = spectrum.martin_ruiz(clearness_index, airmass_absolute)
@@ -335,7 +335,7 @@ def test_martin_ruiz_mm_error_too_many_arguments(martin_ruiz_mismatch_data):
     airmass_absolute = pd.Series(martin_ruiz_mismatch_data['airmass_absolute'])
     model_parameters = martin_ruiz_mismatch_data['monosi_model_params_dict']
 
-    with pytest.raises(TypeError,
+    with pytest.raises(ValueError,
                        match='Cannot resolve input: must supply only one of '
                              '"module_type" or "model_parameters"'):
         _ = spectrum.martin_ruiz(clearness_index, airmass_absolute,