pvlib 0.11.0a1__py3-none-any.whl → 0.11.1__py3-none-any.whl

pvlib/spectrum/response.py

@@ -0,0 +1,280 @@
+"""
+The ``response`` module in the ``spectrum`` package provides functions for
+spectral response and quantum efficiency calculations.
+"""
+from pvlib.tools import normalize_max2one
+import numpy as np
+import pandas as pd
+import scipy.constants
+from scipy.interpolate import interp1d
+
+
+_PLANCK_BY_LIGHT_SPEED_OVER_ELEMENTAL_CHARGE_BY_BILLION = (
+    scipy.constants.speed_of_light
+    * scipy.constants.Planck
+    / scipy.constants.elementary_charge
+    * 1e9
+)
+
+
+def get_example_spectral_response(wavelength=None):
+    '''
+    Generate a generic smooth spectral response (SR) for tests and experiments.
+
+    Parameters
+    ----------
+    wavelength: 1-D sequence of numeric, optional
+        Wavelengths at which spectral response values are generated.
+        By default ``wavelength`` is from 280 to 1200 in 5 nm intervals. [nm]
+
+    Returns
+    -------
+    spectral_response : pandas.Series
+        The relative spectral response indexed by ``wavelength`` in nm. [-]
+
+    Notes
+    -----
+    This spectral response is based on measurements taken on a c-Si cell.
+    A small number of points near the measured curve are used to define
+    a cubic spline having no undue oscillations, as shown in [1]_.  The spline
+    can be interpolated at arbitrary wavelengths to produce a continuous,
+    smooth curve , which makes it suitable for experimenting with spectral
+    data of different resolutions.
+
+    References
+    ----------
+    .. [1] Driesse, Anton, and Stein, Joshua. "Global Normal Spectral
+       Irradiance in Albuquerque: a One-Year Open Dataset for PV Research".
+       United States 2020. :doi:`10.2172/1814068`.
+    '''
+    # Contributed by Anton Driesse (@adriesse), PV Performance Labs. Aug. 2022
+
+    SR_DATA = np.array([[290, 0.00],
+                        [350, 0.27],
+                        [400, 0.37],
+                        [500, 0.52],
+                        [650, 0.71],
+                        [800, 0.88],
+                        [900, 0.97],
+                        [950, 1.00],
+                        [1000, 0.93],
+                        [1050, 0.58],
+                        [1100, 0.21],
+                        [1150, 0.05],
+                        [1190, 0.00]]).transpose()
+
+    if wavelength is None:
+        resolution = 5.0
+        wavelength = np.arange(280, 1200 + resolution, resolution)
+
+    interpolator = interp1d(SR_DATA[0], SR_DATA[1],
+                            kind='cubic',
+                            bounds_error=False,
+                            fill_value=0.0,
+                            copy=False,
+                            assume_sorted=True)
+
+    sr = pd.Series(data=interpolator(wavelength), index=wavelength)
+
+    sr.index.name = 'wavelength'
+    sr.name = 'spectral_response'
+
+    return sr
+
+
+def sr_to_qe(sr, wavelength=None, normalize=False):
+    """
+    Convert spectral responsivities to quantum efficiencies.
+    If ``wavelength`` is not provided, the spectral responsivity ``sr`` must be
+    a :py:class:`pandas.Series` or :py:class:`pandas.DataFrame`, with the
+    wavelengths in the index.
+
+    Provide wavelengths in nanometers, [nm].
+
+    Conversion is described in [1]_.
+
+    .. versionadded:: 0.11.0
+
+    Parameters
+    ----------
+    sr : numeric, pandas.Series or pandas.DataFrame
+        Spectral response, [A/W].
+        Index must be the wavelength in nanometers, [nm].
+
+    wavelength : numeric, optional
+        Points where spectral response is measured, in nanometers, [nm].
+
+    normalize : bool, default False
+        If True, the quantum efficiency is normalized so that the maximum value
+        is 1.
+        For ``pandas.DataFrame``, normalization is done for each column.
+        For 2D arrays, normalization is done for each sub-array.
+
+    Returns
+    -------
+    quantum_efficiency : numeric, same type as ``sr``
+        Quantum efficiency, in the interval [0, 1].
+
+    Notes
+    -----
+    - If ``sr`` is of type ``pandas.Series`` or ``pandas.DataFrame``,
+      column names will remain unchanged in the returned object.
+    - If ``wavelength`` is provided it will be used independently of the
+      datatype of ``sr``.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import pandas as pd
+    >>> from pvlib import spectrum
+    >>> wavelengths = np.array([350, 550, 750])
+    >>> spectral_response = np.array([0.25, 0.40, 0.57])
+    >>> quantum_efficiency = spectrum.sr_to_qe(spectral_response, wavelengths)
+    >>> print(quantum_efficiency)
+    array([0.88560142, 0.90170326, 0.94227991])
+
+    >>> spectral_response_series = pd.Series(spectral_response, index=wavelengths, name="dataset")
+    >>> qe = spectrum.sr_to_qe(spectral_response_series)
+    >>> print(qe)
+    350    0.885601
+    550    0.901703
+    750    0.942280
+    Name: dataset, dtype: float64
+
+    >>> qe = spectrum.sr_to_qe(spectral_response_series, normalize=True)
+    >>> print(qe)
+    350    0.939850
+    550    0.956938
+    750    1.000000
+    Name: dataset, dtype: float64
+
+    References
+    ----------
+    .. [1] “Spectral Response,” PV Performance Modeling Collaborative (PVPMC).
+        https://pvpmc.sandia.gov/modeling-guide/2-dc-module-iv/effective-irradiance/spectral-response/
+    .. [2] “Spectral Response | PVEducation,” www.pveducation.org.
+        https://www.pveducation.org/pvcdrom/solar-cell-operation/spectral-response
+
+    See Also
+    --------
+    pvlib.spectrum.qe_to_sr
+    """  # noqa: E501
+    if wavelength is None:
+        if hasattr(sr, "index"):  # true for pandas objects
+            # use reference to index values instead of index alone so
+            # sr / wavelength returns a series with the same name
+            wavelength = sr.index.array
+        else:
+            raise TypeError(
+                "'sr' must have an '.index' attribute"
+                + " or 'wavelength' must be provided"
+            )
+    quantum_efficiency = (
+        sr
+        / wavelength
+        * _PLANCK_BY_LIGHT_SPEED_OVER_ELEMENTAL_CHARGE_BY_BILLION
+    )
+
+    if normalize:
+        quantum_efficiency = normalize_max2one(quantum_efficiency)
+
+    return quantum_efficiency
+
+
+def qe_to_sr(qe, wavelength=None, normalize=False):
+    """
+    Convert quantum efficiencies to spectral responsivities.
+    If ``wavelength`` is not provided, the quantum efficiency ``qe`` must be
+    a :py:class:`pandas.Series` or :py:class:`pandas.DataFrame`, with the
+    wavelengths in the index.
+
+    Provide wavelengths in nanometers, [nm].
+
+    Conversion is described in [1]_.
+
+    .. versionadded:: 0.11.0
+
+    Parameters
+    ----------
+    qe : numeric, pandas.Series or pandas.DataFrame
+        Quantum efficiency.
+        If pandas subtype, index must be the wavelength in nanometers, [nm].
+
+    wavelength : numeric, optional
+        Points where quantum efficiency is measured, in nanometers, [nm].
+
+    normalize : bool, default False
+        If True, the spectral response is normalized so that the maximum value
+        is 1.
+        For ``pandas.DataFrame``, normalization is done for each column.
+        For 2D arrays, normalization is done for each sub-array.
+
+    Returns
+    -------
+    spectral_response : numeric, same type as ``qe``
+        Spectral response, [A/W].
+
+    Notes
+    -----
+    - If ``qe`` is of type ``pandas.Series`` or ``pandas.DataFrame``,
+      column names will remain unchanged in the returned object.
+    - If ``wavelength`` is provided it will be used independently of the
+      datatype of ``qe``.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import pandas as pd
+    >>> from pvlib import spectrum
+    >>> wavelengths = np.array([350, 550, 750])
+    >>> quantum_efficiency = np.array([0.86, 0.90, 0.94])
+    >>> spectral_response = spectrum.qe_to_sr(quantum_efficiency, wavelengths)
+    >>> print(spectral_response)
+    array([0.24277287, 0.39924442, 0.56862085])
+
+    >>> quantum_efficiency_series = pd.Series(quantum_efficiency, index=wavelengths, name="dataset")
+    >>> sr = spectrum.qe_to_sr(quantum_efficiency_series)
+    >>> print(sr)
+    350    0.242773
+    550    0.399244
+    750    0.568621
+    Name: dataset, dtype: float64
+
+    >>> sr = spectrum.qe_to_sr(quantum_efficiency_series, normalize=True)
+    >>> print(sr)
+    350    0.426950
+    550    0.702128
+    750    1.000000
+    Name: dataset, dtype: float64
+
+    References
+    ----------
+    .. [1] “Spectral Response,” PV Performance Modeling Collaborative (PVPMC).
+        https://pvpmc.sandia.gov/modeling-guide/2-dc-module-iv/effective-irradiance/spectral-response/
+    .. [2] “Spectral Response | PVEducation,” www.pveducation.org.
+        https://www.pveducation.org/pvcdrom/solar-cell-operation/spectral-response
+
+    See Also
+    --------
+    pvlib.spectrum.sr_to_qe
+    """  # noqa: E501
+    if wavelength is None:
+        if hasattr(qe, "index"):  # true for pandas objects
+            # use reference to index values instead of index alone so
+            # sr / wavelength returns a series with the same name
+            wavelength = qe.index.array
+        else:
+            raise TypeError(
+                "'qe' must have an '.index' attribute"
+                + " or 'wavelength' must be provided"
+            )
+    spectral_responsivity = (
+        qe
+        * wavelength
+        / _PLANCK_BY_LIGHT_SPEED_OVER_ELEMENTAL_CHARGE_BY_BILLION
+    )
+
+    if normalize:
+        spectral_responsivity = normalize_max2one(spectral_responsivity)
+
+    return spectral_responsivity

pvlib/spectrum/spectrl2.py

@@ -181,7 +181,7 @@ def spectrl2(apparent_zenith, aoi, surface_tilt, ground_albedo,
     (SPECTRL2).
 
     The Bird Simple Spectral Model [1]_ produces terrestrial spectra between
-    300 and 4000 nm with a resolution of approximately 10 nm. Direct and
+    300 nm and 4000 nm with a resolution of approximately 10 nm. Direct and
     diffuse spectral irradiance are modeled for horizontal and tilted surfaces
     under cloudless skies. SPECTRL2 models radiative transmission, absorption,
     and scattering due to atmospheric aerosol, water vapor, and ozone content.
@@ -189,31 +189,31 @@ def spectrl2(apparent_zenith, aoi, surface_tilt, ground_albedo,
     Parameters
     ----------
     apparent_zenith : numeric
-        Solar zenith angle [degrees]
+        Solar zenith angle. [degrees]
     aoi : numeric
-        Angle of incidence of the solar vector on the panel [degrees]
+        Angle of incidence of the solar vector on the panel. [degrees]
     surface_tilt : numeric
-        Panel tilt from horizontal [degrees]
+        Panel tilt from horizontal. [degrees]
     ground_albedo : numeric
         Albedo [0-1] of the ground surface. Can be provided as a scalar value
         if albedo is not spectrally-dependent, or as a 122xN matrix where
         the first dimension spans the wavelength range and the second spans
         the number of simulations. [unitless]
     surface_pressure : numeric
-        Surface pressure [Pa]
+        Surface pressure. [Pa]
     relative_airmass : numeric
         Relative airmass. The airmass model used in [1]_ is the `'kasten1966'`
         model, while a later implementation by NREL uses the
         `'kastenyoung1989'` model. [unitless]
     precipitable_water : numeric
-        Atmospheric water vapor content [cm]
+        Atmospheric water vapor content. [cm]
     ozone : numeric
-        Atmospheric ozone content [atm-cm]
+        Atmospheric ozone content. [atm-cm]
     aerosol_turbidity_500nm : numeric
-        Aerosol turbidity at 500 nm [unitless]
+        Aerosol turbidity at 500 nm. [unitless]
     dayofyear : numeric, optional
-        The day of year [1-365].  Must be provided if ``apparent_zenith`` is
-        not a pandas Series.
+        The day of year [1-365]. Must be provided if ``apparent_zenith`` is
+        not a ``pandas.Series``.
     scattering_albedo_400nm : numeric, default 0.945
         Aerosol single scattering albedo at 400nm. The default value of 0.945
         is suggested in [1]_ for a rural aerosol model. [unitless]
@@ -223,15 +223,15 @@ def spectrl2(apparent_zenith, aoi, surface_tilt, ground_albedo,
     wavelength_variation_factor : numeric, default 0.095
         Wavelength variation factor [unitless]
     aerosol_asymmetry_factor : numeric, default 0.65
-        Aerosol asymmetry factor (mean cosine of scattering angle) [unitless]
+        Aerosol asymmetry factor (mean cosine of scattering angle). [unitless]
 
     Returns
     -------
-    spectra : dict
+    spectra_components : dict
         A dict of arrays.  With the exception of `wavelength`, which has length
         122, each array has shape (122, N) where N is the length of the
         input ``apparent_zenith``.  All values are spectral irradiance
-        with units W/m^2/nm except for `wavelength`, which is in nanometers.
+        with units Wm⁻²nm⁻¹, except for `wavelength`, which is in nanometers.
 
         * wavelength
         * dni_extra
@@ -267,7 +267,7 @@ def spectrl2(apparent_zenith, aoi, surface_tilt, ground_albedo,
 
     References
     ----------
-    .. [1] Bird, R, and Riordan, C., 1984, "Simple solar spectral model for
+    .. [1] Bird, R., and Riordan, C., 1984, "Simple solar spectral model for
        direct and diffuse irradiance on horizontal and tilted planes at the
        earth's surface for cloudless atmospheres", NREL Technical Report
        TR-215-2436 :doi:`10.2172/5986936`.
@@ -288,7 +288,7 @@ def spectrl2(apparent_zenith, aoi, surface_tilt, ground_albedo,
                 aerosol_turbidity_500nm, scattering_albedo_400nm, alpha,
                 wavelength_variation_factor, aerosol_asymmetry_factor]))
 
-        dayofyear = original_index.dayofyear.values
+        dayofyear = pvlib.tools._pandas_to_doy(original_index).values
 
     if not is_pandas and dayofyear is None:
         raise ValueError('dayofyear must be specified if not using pandas '
@@ -363,7 +363,7 @@ def spectrl2(apparent_zenith, aoi, surface_tilt, ground_albedo,
 
     # calculate spectral irradiance on a tilted surface, Eq 3-18
     # Note: clipping cosd(aoi) to >=0 is not in the reference, but is necessary
-    # to prevent nonsense values when the sun is behind the plane of array.
+    # to prevent negative values when the sun is behind the plane of array.
     # The same constraint is applied in irradiance.haydavies when not
     # supplying `projection_ratio`.
     aoi_projection_nn = np.maximum(cosd(aoi), 0)  # GH 1348

pvlib/tests/bifacial/test_losses_models.py

@@ -0,0 +1,54 @@
+from pvlib import bifacial
+
+import pandas as pd
+import numpy as np
+from numpy.testing import assert_allclose
+
+
+def test_power_mismatch_deline():
+    """tests bifacial.power_mismatch_deline"""
+    premise_rmads = np.array([0.0, 0.05, 0.1, 0.15, 0.2, 0.25])
+    # test default model is for fixed tilt
+    expected_ft_mms = np.array([0.0, 0.0151, 0.0462, 0.0933, 0.1564, 0.2355])
+    result_def_mms = bifacial.power_mismatch_deline(premise_rmads)
+    assert_allclose(result_def_mms, expected_ft_mms, atol=1e-5)
+    assert np.all(np.diff(result_def_mms) > 0)  # higher RMADs => higher losses
+
+    # test custom coefficients, set model to 1+1*RMAD
+    # as Polynomial class
+    polynomial = np.polynomial.Polynomial([1, 1, 0])
+    result_custom_mms = bifacial.power_mismatch_deline(
+        premise_rmads, coefficients=polynomial
+    )
+    assert_allclose(result_custom_mms, 1 + premise_rmads)
+    # as list
+    result_custom_mms = bifacial.power_mismatch_deline(
+        premise_rmads, coefficients=[1, 1, 0]
+    )
+    assert_allclose(result_custom_mms, 1 + premise_rmads)
+
+    # test datatypes IO with Series
+    result_mms = bifacial.power_mismatch_deline(pd.Series(premise_rmads))
+    assert isinstance(result_mms, pd.Series)
+
+    # test fill_factor, fill_factor_reference
+    # default model + default fill_factor_reference
+    ff_ref_default = 0.79
+    ff_of_interest = 0.65
+    result_mms = bifacial.power_mismatch_deline(
+        premise_rmads, fill_factor=ff_of_interest
+    )
+    assert_allclose(
+        result_mms,
+        expected_ft_mms * ff_of_interest / ff_ref_default,
+        atol=1e-5,
+    )
+    # default model + custom fill_factor_reference
+    ff_of_interest = 0.65
+    ff_ref = 0.75
+    result_mms = bifacial.power_mismatch_deline(
+        premise_rmads, fill_factor=ff_of_interest, fill_factor_reference=ff_ref
+    )
+    assert_allclose(
+        result_mms, expected_ft_mms * ff_of_interest / ff_ref, atol=1e-5
+    )

pvlib/tests/iotools/test_pvgis.py

@@ -11,8 +11,7 @@ from pvlib.iotools import get_pvgis_tmy, read_pvgis_tmy
 from pvlib.iotools import get_pvgis_hourly, read_pvgis_hourly
 from pvlib.iotools import get_pvgis_horizon
 from ..conftest import (DATA_DIR, RERUNS, RERUNS_DELAY, assert_frame_equal,
-                        fail_on_pvlib_version, assert_series_equal)
-from pvlib._deprecation import pvlibDeprecationWarning
+                        assert_series_equal)
 
 
 # PVGIS Hourly tests
@@ -316,7 +315,7 @@ def userhorizon_expected():
 @pytest.fixture
 def month_year_expected():
     return [
-        2009, 2012, 2014, 2010, 2011, 2013, 2011, 2011, 2013, 2013, 2013, 2011]
+        2014, 2011, 2008, 2011, 2009, 2011, 2020, 2006, 2006, 2013, 2007, 2018]
 
 
 @pytest.fixture
@@ -324,10 +323,10 @@ def inputs_expected():
     return {
         'location': {'latitude': 45.0, 'longitude': 8.0, 'elevation': 250.0},
         'meteo_data': {
-            'radiation_db': 'PVGIS-SARAH',
-            'meteo_db': 'ERA-Interim',
+            'radiation_db': 'PVGIS-SARAH2',
+            'meteo_db': 'ERA5',
             'year_min': 2005,
-            'year_max': 2016,
+            'year_max': 2020,
             'use_horizon': True,
             'horizon_db': 'DEM-calculated'}}
 
@@ -435,6 +434,53 @@ def _compare_pvgis_tmy_basic(expected, meta_expected, pvgis_data):
         assert np.allclose(data[outvar], expected[outvar])
 
 
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+def test_get_pvgis_tmy_coerce_year():
+    """test utc_offset and coerce_year work as expected"""
+    base_case, _, _, _ = get_pvgis_tmy(45, 8)  # Turin
+    assert str(base_case.index.tz) == 'UTC'
+    assert base_case.index.name == 'time(UTC)'
+    noon_test_data = [
+        base_case[base_case.index.month == m].iloc[12]
+        for m in range(1, 13)]
+    cet_tz = 1  # Turin time is CET
+    cet_name = 'Etc/GMT-1'
+    # check indices of rolled data after converting timezone
+    pvgis_data, _, _, _ = get_pvgis_tmy(45, 8, roll_utc_offset=cet_tz)
+    jan1_midnight = pd.Timestamp('1990-01-01 00:00:00', tz=cet_name)
+    dec31_midnight = pd.Timestamp('1990-12-31 23:00:00', tz=cet_name)
+    assert pvgis_data.index[0] == jan1_midnight
+    assert pvgis_data.index[-1] == dec31_midnight
+    assert pvgis_data.index.name == f'time({cet_name})'
+    # spot check rolled data matches original
+    for m, test_case in enumerate(noon_test_data):
+        expected = pvgis_data[pvgis_data.index.month == m+1].iloc[12+cet_tz]
+        assert all(test_case == expected)
+    # repeat tests with year coerced
+    test_yr = 2021
+    pvgis_data, _, _, _ = get_pvgis_tmy(
+        45, 8, roll_utc_offset=cet_tz, coerce_year=test_yr)
+    jan1_midnight = pd.Timestamp(f'{test_yr}-01-01 00:00:00', tz=cet_name)
+    dec31_midnight = pd.Timestamp(f'{test_yr}-12-31 23:00:00', tz=cet_name)
+    assert pvgis_data.index[0] == jan1_midnight
+    assert pvgis_data.index[-1] == dec31_midnight
+    assert pvgis_data.index.name == f'time({cet_name})'
+    for m, test_case in enumerate(noon_test_data):
+        expected = pvgis_data[pvgis_data.index.month == m+1].iloc[12+cet_tz]
+        assert all(test_case == expected)
+    # repeat tests with year coerced but utc offset none or zero
+    pvgis_data, _, _, _ = get_pvgis_tmy(45, 8, coerce_year=test_yr)
+    jan1_midnight = pd.Timestamp(f'{test_yr}-01-01 00:00:00', tz='UTC')
+    dec31_midnight = pd.Timestamp(f'{test_yr}-12-31 23:00:00', tz='UTC')
+    assert pvgis_data.index[0] == jan1_midnight
+    assert pvgis_data.index[-1] == dec31_midnight
+    assert pvgis_data.index.name == 'time(UTC)'
+    for m, test_case in enumerate(noon_test_data):
+        expected = pvgis_data[pvgis_data.index.month == m+1].iloc[12]
+        assert all(test_case == expected)
+
+
 @pytest.mark.remote_data
 @pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
 def test_get_pvgis_tmy_csv(expected, month_year_expected, inputs_expected,
@@ -518,14 +564,14 @@ def test_read_pvgis_horizon_invalid_coords():
 
 
 def test_read_pvgis_tmy_map_variables(pvgis_tmy_mapped_columns):
-    fn = DATA_DIR / 'tmy_45.000_8.000_2005_2016.json'
+    fn = DATA_DIR / 'tmy_45.000_8.000_2005_2020.json'
     actual, _, _, _ = read_pvgis_tmy(fn, map_variables=True)
     assert all(c in pvgis_tmy_mapped_columns for c in actual.columns)
 
 
 def test_read_pvgis_tmy_json(expected, month_year_expected, inputs_expected,
                              meta_expected):
-    fn = DATA_DIR / 'tmy_45.000_8.000_2005_2016.json'
+    fn = DATA_DIR / 'tmy_45.000_8.000_2005_2020.json'
     # infer outputformat from file extensions
     pvgis_data = read_pvgis_tmy(fn, map_variables=False)
     _compare_pvgis_tmy_json(expected, month_year_expected, inputs_expected,
@@ -542,7 +588,7 @@ def test_read_pvgis_tmy_json(expected, month_year_expected, inputs_expected,
 
 
 def test_read_pvgis_tmy_epw(expected, epw_meta):
-    fn = DATA_DIR / 'tmy_45.000_8.000_2005_2016.epw'
+    fn = DATA_DIR / 'tmy_45.000_8.000_2005_2020.epw'
     # infer outputformat from file extensions
     pvgis_data = read_pvgis_tmy(fn, map_variables=False)
     _compare_pvgis_tmy_epw(expected, epw_meta, pvgis_data)
@@ -557,7 +603,7 @@ def test_read_pvgis_tmy_epw(expected, epw_meta):
 
 def test_read_pvgis_tmy_csv(expected, month_year_expected, inputs_expected,
                             meta_expected, csv_meta):
-    fn = DATA_DIR / 'tmy_45.000_8.000_2005_2016.csv'
+    fn = DATA_DIR / 'tmy_45.000_8.000_2005_2020.csv'
     # infer outputformat from file extensions
     pvgis_data = read_pvgis_tmy(fn, map_variables=False)
     _compare_pvgis_tmy_csv(expected, month_year_expected, inputs_expected,
@@ -574,7 +620,7 @@ def test_read_pvgis_tmy_csv(expected, month_year_expected, inputs_expected,
 
 
 def test_read_pvgis_tmy_basic(expected, meta_expected):
-    fn = DATA_DIR / 'tmy_45.000_8.000_2005_2016.txt'
+    fn = DATA_DIR / 'tmy_45.000_8.000_2005_2020.txt'
     # XXX: can't infer outputformat from file extensions for basic
     with pytest.raises(ValueError, match="pvgis format 'txt' was unknown"):
         read_pvgis_tmy(fn, map_variables=False)

pvlib/tests/spectrum/conftest.py

@@ -0,0 +1,40 @@
+import numpy as np
+import pytest
+import pandas as pd
+
+from ..conftest import DATA_DIR
+
+SPECTRL2_TEST_DATA = DATA_DIR / 'spectrl2_example_spectra.csv'
+
+
+@pytest.fixture
+def spectrl2_data():
+    # reference spectra generated with solar_utils==0.3
+    """
+    expected = solar_utils.spectrl2(
+        units=1,
+        location=[40, -80, -5],
+        datetime=[2020, 3, 15, 10, 45, 59],
+        weather=[1013, 15],
+        orientation=[0, 180],
+        atmospheric_conditions=[1.14, 0.65, 0.344, 0.1, 1.42],
+        albedo=[0.3, 0.7, 0.8, 1.3, 2.5, 4.0] + [0.2]*6,
+    )
+    """
+    kwargs = {
+        'surface_tilt': 0,
+        'relative_airmass': 1.4899535986910446,
+        'apparent_zenith': 47.912086486816406,
+        'aoi': 47.91208648681641,
+        'ground_albedo': 0.2,
+        'surface_pressure': 101300,
+        'ozone': 0.344,
+        'precipitable_water': 1.42,
+        'aerosol_turbidity_500nm': 0.1,
+        'dayofyear': 75
+    }
+    df = pd.read_csv(SPECTRL2_TEST_DATA, index_col=0)
+    # convert um to nm
+    df['wavelength'] = np.round(df['wavelength'] * 1000, 1)
+    df[['specdif', 'specdir', 'specetr', 'specglo']] /= 1000
+    return kwargs, df