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

pvlib/tests/spectrum/test_irradiance.py

@@ -0,0 +1,138 @@
+import pytest
+from numpy.testing import assert_allclose, assert_approx_equal, assert_equal
+import pandas as pd
+import numpy as np
+from pvlib import spectrum
+from pvlib._deprecation import pvlibDeprecationWarning
+
+from ..conftest import assert_series_equal, fail_on_pvlib_version
+
+
+@fail_on_pvlib_version('0.12')
+def test_get_am15g():
+    # test that the reference spectrum is read and interpolated correctly
+    with pytest.warns(pvlibDeprecationWarning,
+                      match="get_reference_spectra instead"):
+        e = spectrum.get_am15g()
+    assert_equal(len(e), 2002)
+    assert_equal(np.sum(e.index), 2761442)
+    assert_approx_equal(np.sum(e), 1002.88, significant=6)
+
+    wavelength = [270, 850, 950, 1200, 1201.25, 4001]
+    expected = [0.0, 0.893720, 0.147260, 0.448250, 0.4371025, 0.0]
+
+    with pytest.warns(pvlibDeprecationWarning,
+                      match="get_reference_spectra instead"):
+        e = spectrum.get_am15g(wavelength)
+    assert_equal(len(e), len(wavelength))
+    assert_allclose(e, expected, rtol=1e-6)
+
+
+@pytest.mark.parametrize(
+    "reference_identifier,expected_sums",
+    [
+        (
+            "ASTM G173-03",  # reference_identifier
+            {  # expected_sums
+                "extraterrestrial": 1356.15,
+                "global": 1002.88,
+                "direct": 887.65,
+            },
+        ),
+    ],
+)
+def test_get_reference_spectra(reference_identifier, expected_sums):
+    # test reading of a standard spectrum
+    standard = spectrum.get_reference_spectra(standard=reference_identifier)
+    assert set(standard.columns) == expected_sums.keys()
+    assert standard.index.name == "wavelength"
+    assert standard.index.is_monotonic_increasing is True
+    expected_sums = pd.Series(expected_sums)  # convert prior to comparison
+    assert_series_equal(np.sum(standard, axis=0), expected_sums, atol=1e-2)
+
+
+def test_get_reference_spectra_custom_wavelengths():
+    # test that the spectrum is interpolated correctly when custom wavelengths
+    # are specified
+    # only checked for ASTM G173-03 reference spectrum
+    wavelength = [270, 850, 951.634, 1200, 4001]
+    expected_sums = pd.Series(
+        {"extraterrestrial": 2.23266, "global": 1.68952, "direct": 1.58480}
+    )  # for given ``wavelength``
+    standard = spectrum.get_reference_spectra(
+        wavelength, standard="ASTM G173-03"
+    )
+    assert_equal(len(standard), len(wavelength))
+    # check no NaN values were returned
+    assert not standard.isna().any().any()  # double any to return one value
+    assert_series_equal(np.sum(standard, axis=0), expected_sums, atol=1e-4)
+
+
+def test_get_reference_spectra_invalid_reference():
+    # test that an invalid reference identifier raises a ValueError
+    with pytest.raises(ValueError, match="Invalid standard identifier"):
+        spectrum.get_reference_spectra(standard="invalid")
+
+
+def test_average_photon_energy_series():
+    # test that the APE is calculated correctly with single spectrum
+    # series input
+
+    spectra = spectrum.get_reference_spectra()
+    spectra = spectra['global']
+    ape = spectrum.average_photon_energy(spectra)
+    expected = 1.45017
+    assert_allclose(ape, expected, rtol=1e-4)
+
+
+def test_average_photon_energy_dataframe():
+    # test that the APE is calculated correctly with multiple spectra
+    # dataframe input and that the output is a series
+
+    spectra = spectrum.get_reference_spectra().T
+    ape = spectrum.average_photon_energy(spectra)
+    expected = pd.Series([1.36848, 1.45017, 1.40885])
+    expected.index = spectra.index
+    assert_series_equal(ape, expected, rtol=1e-4)
+
+
+def test_average_photon_energy_invalid_type():
+    # test that spectrum argument is either a pandas Series or dataframe
+    spectra = 5
+    with pytest.raises(TypeError, match='must be either a pandas Series or'
+                       ' DataFrame'):
+        spectrum.average_photon_energy(spectra)
+
+
+def test_average_photon_energy_neg_irr_series():
+    # test for handling of negative spectral irradiance values with a
+    # pandas Series input
+
+    spectra = spectrum.get_reference_spectra()['global']*-1
+    with pytest.raises(ValueError, match='must be positive'):
+        spectrum.average_photon_energy(spectra)
+
+
+def test_average_photon_energy_neg_irr_dataframe():
+    # test for handling of negative spectral irradiance values with a
+    # pandas DataFrame input
+
+    spectra = spectrum.get_reference_spectra().T*-1
+
+    with pytest.raises(ValueError, match='must be positive'):
+        spectrum.average_photon_energy(spectra)
+
+
+def test_average_photon_energy_zero_irr():
+    # test for handling of zero spectral irradiance values with
+    # pandas DataFrame and pandas Series input
+
+    spectra_df_zero = spectrum.get_reference_spectra().T
+    spectra_df_zero.iloc[1] = 0
+    spectra_series_zero = spectrum.get_reference_spectra()['global']*0
+    out_1 = spectrum.average_photon_energy(spectra_df_zero)
+    out_2 = spectrum.average_photon_energy(spectra_series_zero)
+    expected_1 = np.array([1.36848, np.nan, 1.40885])
+    expected_2 = np.nan
+    assert_allclose(out_1, expected_1, atol=1e-3)
+    assert_allclose(out_2, expected_2, atol=1e-3)

pvlib/tests/{test_spectrum.py → spectrum/test_mismatch.py}

@@ -1,194 +1,10 @@
 import pytest
-from numpy.testing import assert_allclose, assert_approx_equal, assert_equal
+from numpy.testing import assert_allclose, assert_approx_equal
 import pandas as pd
 import numpy as np
 from pvlib import spectrum
-from pvlib._deprecation import pvlibDeprecationWarning
-
-from .conftest import DATA_DIR, assert_series_equal, fail_on_pvlib_version
-
-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
-
-
-def test_spectrl2(spectrl2_data):
-    # compare against output from solar_utils wrapper around NREL spectrl2_2.c
-    kwargs, expected = spectrl2_data
-    actual = spectrum.spectrl2(**kwargs)
-    assert_allclose(expected['wavelength'].values, actual['wavelength'])
-    assert_allclose(expected['specdif'].values, actual['dhi'].ravel(),
-                    atol=7e-5)
-    assert_allclose(expected['specdir'].values, actual['dni'].ravel(),
-                    atol=1.5e-4)
-    assert_allclose(expected['specetr'], actual['dni_extra'].ravel(),
-                    atol=2e-4)
-    assert_allclose(expected['specglo'], actual['poa_global'].ravel(),
-                    atol=1e-4)
-
-
-def test_spectrl2_array(spectrl2_data):
-    # test that supplying arrays instead of scalars works
-    kwargs, expected = spectrl2_data
-    kwargs = {k: np.array([v, v, v]) for k, v in kwargs.items()}
-    actual = spectrum.spectrl2(**kwargs)
-
-    assert actual['wavelength'].shape == (122,)
-
-    keys = ['dni_extra', 'dhi', 'dni', 'poa_sky_diffuse', 'poa_ground_diffuse',
-            'poa_direct', 'poa_global']
-    for key in keys:
-        assert actual[key].shape == (122, 3)
-
-
-def test_spectrl2_series(spectrl2_data):
-    # test that supplying Series instead of scalars works
-    kwargs, expected = spectrl2_data
-    kwargs.pop('dayofyear')
-    index = pd.to_datetime(['2020-03-15 10:45:59']*3)
-    kwargs = {k: pd.Series([v, v, v], index=index) for k, v in kwargs.items()}
-    actual = spectrum.spectrl2(**kwargs)
-
-    assert actual['wavelength'].shape == (122,)
-
-    keys = ['dni_extra', 'dhi', 'dni', 'poa_sky_diffuse', 'poa_ground_diffuse',
-            'poa_direct', 'poa_global']
-    for key in keys:
-        assert actual[key].shape == (122, 3)
-
-
-def test_dayofyear_missing(spectrl2_data):
-    # test that not specifying dayofyear with non-pandas inputs raises error
-    kwargs, expected = spectrl2_data
-    kwargs.pop('dayofyear')
-    with pytest.raises(ValueError, match='dayofyear must be specified'):
-        _ = spectrum.spectrl2(**kwargs)
-
-
-def test_aoi_gt_90(spectrl2_data):
-    # test that returned irradiance values are non-negative when aoi > 90
-    # see GH #1348
-    kwargs, _ = spectrl2_data
-    kwargs['apparent_zenith'] = 70
-    kwargs['aoi'] = 130
-    kwargs['surface_tilt'] = 60
-
-    spectra = spectrum.spectrl2(**kwargs)
-    for key in ['poa_direct', 'poa_global']:
-        message = f'{key} contains negative values for aoi>90'
-        assert np.all(spectra[key] >= 0), message
-
-
-def test_get_example_spectral_response():
-    # test that the sample sr is read and interpolated correctly
-    sr = spectrum.get_example_spectral_response()
-    assert_equal(len(sr), 185)
-    assert_equal(np.sum(sr.index), 136900)
-    assert_approx_equal(np.sum(sr), 107.6116)
-
-    wavelength = [270, 850, 950, 1200, 4001]
-    expected = [0.0, 0.92778, 1.0, 0.0, 0.0]
-
-    sr = spectrum.get_example_spectral_response(wavelength)
-    assert_equal(len(sr), len(wavelength))
-    assert_allclose(sr, expected, rtol=1e-5)
-
-
-@fail_on_pvlib_version('0.12')
-def test_get_am15g():
-    # test that the reference spectrum is read and interpolated correctly
-    with pytest.warns(pvlibDeprecationWarning,
-                      match="get_reference_spectra instead"):
-        e = spectrum.get_am15g()
-    assert_equal(len(e), 2002)
-    assert_equal(np.sum(e.index), 2761442)
-    assert_approx_equal(np.sum(e), 1002.88, significant=6)
-
-    wavelength = [270, 850, 950, 1200, 1201.25, 4001]
-    expected = [0.0, 0.893720, 0.147260, 0.448250, 0.4371025, 0.0]
-
-    with pytest.warns(pvlibDeprecationWarning,
-                      match="get_reference_spectra instead"):
-        e = spectrum.get_am15g(wavelength)
-    assert_equal(len(e), len(wavelength))
-    assert_allclose(e, expected, rtol=1e-6)
-
-
-@pytest.mark.parametrize(
-    "reference_identifier,expected_sums",
-    [
-        (
-            "ASTM G173-03",  # reference_identifier
-            {  # expected_sums
-                "extraterrestrial": 1356.15,
-                "global": 1002.88,
-                "direct": 887.65,
-            },
-        ),
-    ],
-)
-def test_get_reference_spectra(reference_identifier, expected_sums):
-    # test reading of a standard spectrum
-    standard = spectrum.get_reference_spectra(standard=reference_identifier)
-    assert set(standard.columns) == expected_sums.keys()
-    assert standard.index.name == "wavelength"
-    assert standard.index.is_monotonic_increasing is True
-    expected_sums = pd.Series(expected_sums)  # convert prior to comparison
-    assert_series_equal(np.sum(standard, axis=0), expected_sums, atol=1e-2)
-
-
-def test_get_reference_spectra_custom_wavelengths():
-    # test that the spectrum is interpolated correctly when custom wavelengths
-    # are specified
-    # only checked for ASTM G173-03 reference spectrum
-    wavelength = [270, 850, 951.634, 1200, 4001]
-    expected_sums = pd.Series(
-        {"extraterrestrial": 2.23266, "global": 1.68952, "direct": 1.58480}
-    )  # for given ``wavelength``
-    standard = spectrum.get_reference_spectra(
-        wavelength, standard="ASTM G173-03"
-    )
-    assert_equal(len(standard), len(wavelength))
-    # check no NaN values were returned
-    assert not standard.isna().any().any()  # double any to return one value
-    assert_series_equal(np.sum(standard, axis=0), expected_sums, atol=1e-4)
-
-
-def test_get_reference_spectra_invalid_reference():
-    # test that an invalid reference identifier raises a ValueError
-    with pytest.raises(ValueError, match="Invalid standard identifier"):
-        spectrum.get_reference_spectra(standard="invalid")
+
+from ..conftest import assert_series_equal
 
 
 def test_calc_spectral_mismatch_field(spectrl2_data):
@@ -264,6 +80,22 @@ def test_spectral_factor_firstsolar_supplied():
     assert_allclose(out, expected, atol=1e-3)
 
 
+def test_spectral_factor_firstsolar_large_airmass_supplied_max():
+    # test airmass > user-defined maximum is treated same as airmass=maximum
+    m_eq11 = spectrum.spectral_factor_firstsolar(1, 11, 'monosi',
+                                                 max_airmass_absolute=11)
+    m_gt11 = spectrum.spectral_factor_firstsolar(1, 15, 'monosi',
+                                                 max_airmass_absolute=11)
+    assert_allclose(m_eq11, m_gt11)
+
+
+def test_spectral_factor_firstsolar_large_airmass():
+    # test that airmass > 10 is treated same as airmass=10
+    m_eq10 = spectrum.spectral_factor_firstsolar(1, 10, 'monosi')
+    m_gt10 = spectrum.spectral_factor_firstsolar(1, 15, 'monosi')
+    assert_allclose(m_eq10, m_gt10)
+
+
 def test_spectral_factor_firstsolar_ambiguous():
     with pytest.raises(TypeError):
         spectrum.spectral_factor_firstsolar(1, 1)
@@ -276,36 +108,34 @@ def test_spectral_factor_firstsolar_ambiguous_both():
         spectrum.spectral_factor_firstsolar(1, 1, 'cdte', coefficients=coeffs)
 
 
-def test_spectral_factor_firstsolar_large_airmass():
-    # test that airmass > 10 is treated same as airmass==10
-    m_eq10 = spectrum.spectral_factor_firstsolar(1, 10, 'monosi')
-    m_gt10 = spectrum.spectral_factor_firstsolar(1, 15, 'monosi')
-    assert_allclose(m_eq10, m_gt10)
-
-
 def test_spectral_factor_firstsolar_low_airmass():
-    with pytest.warns(UserWarning, match='Exceptionally low air mass'):
+    m_eq58 = spectrum.spectral_factor_firstsolar(1, 0.58, 'monosi')
+    m_lt58 = spectrum.spectral_factor_firstsolar(1, 0.1, 'monosi')
+    assert_allclose(m_eq58, m_lt58)
+    with pytest.warns(UserWarning, match='Low airmass values replaced'):
         _ = spectrum.spectral_factor_firstsolar(1, 0.1, 'monosi')
 
 
 def test_spectral_factor_firstsolar_range():
-    with pytest.warns(UserWarning, match='Exceptionally high pw values'):
-        out = spectrum.spectral_factor_firstsolar(np.array([.1, 3, 10]),
-                                                  np.array([1, 3, 5]),
-                                                  module_type='monosi')
+    out = spectrum.spectral_factor_firstsolar(np.array([.1, 3, 10]),
+                                              np.array([1, 3, 5]),
+                                              module_type='monosi')
     expected = np.array([0.96080878, 1.03055092, np.nan])
     assert_allclose(out, expected, atol=1e-3)
-    with pytest.warns(UserWarning, match='Exceptionally high pw values'):
+    with pytest.warns(UserWarning, match='High precipitable water values '
+                      'replaced'):
         out = spectrum.spectral_factor_firstsolar(6, 1.5,
                                                   max_precipitable_water=5,
                                                   module_type='monosi')
-    with pytest.warns(UserWarning, match='Exceptionally low pw values'):
+    with pytest.warns(UserWarning, match='Low precipitable water values '
+                      'replaced'):
         out = spectrum.spectral_factor_firstsolar(np.array([0, 3, 8]),
                                                   np.array([1, 3, 5]),
                                                   module_type='monosi')
     expected = np.array([0.96080878, 1.03055092, 1.04932727])
     assert_allclose(out, expected, atol=1e-3)
-    with pytest.warns(UserWarning, match='Exceptionally low pw values'):
+    with pytest.warns(UserWarning, match='Low precipitable water values '
+                      'replaced'):
         out = spectrum.spectral_factor_firstsolar(0.2, 1.5,
                                                   min_precipitable_water=1,
                                                   module_type='monosi')
@@ -472,107 +302,3 @@ def test_spectral_factor_jrc_supplied_ambiguous():
     with pytest.raises(ValueError, match='No valid input provided'):
         spectrum.spectral_factor_jrc(1.0, 0.8, module_type=None,
                                      coefficients=None)
-
-
-@pytest.fixture
-def sr_and_eqe_fixture():
-    # Just some arbitrary data for testing the conversion functions
-    df = pd.DataFrame(
-        columns=("wavelength", "quantum_efficiency", "spectral_response"),
-        data=[
-            # nm, [0,1], A/W
-            [300, 0.85, 0.205671370402405],
-            [350, 0.86, 0.242772872514211],
-            [400, 0.87, 0.280680929019753],
-            [450, 0.88, 0.319395539919029],
-            [500, 0.89, 0.358916705212040],
-            [550, 0.90, 0.399244424898786],
-            [600, 0.91, 0.440378698979267],
-            [650, 0.92, 0.482319527453483],
-            [700, 0.93, 0.525066910321434],
-            [750, 0.94, 0.568620847583119],
-            [800, 0.95, 0.612981339238540],
-            [850, 0.90, 0.617014111207215],
-            [900, 0.80, 0.580719163489143],
-            [950, 0.70, 0.536358671833723],
-            [1000, 0.6, 0.483932636240953],
-            [1050, 0.4, 0.338752845368667],
-        ],
-    )
-    df.set_index("wavelength", inplace=True)
-    return df
-
-
-def test_sr_to_qe(sr_and_eqe_fixture):
-    # vector type
-    qe = spectrum.sr_to_qe(
-        sr_and_eqe_fixture["spectral_response"].values,
-        sr_and_eqe_fixture.index.values,  # wavelength, nm
-    )
-    assert_allclose(qe, sr_and_eqe_fixture["quantum_efficiency"])
-    # pandas series type
-    # note: output Series' name should match the input
-    qe = spectrum.sr_to_qe(
-        sr_and_eqe_fixture["spectral_response"]
-    )
-    pd.testing.assert_series_equal(
-        qe, sr_and_eqe_fixture["quantum_efficiency"],
-        check_names=False
-    )
-    assert qe.name == "spectral_response"
-    # series normalization
-    qe = spectrum.sr_to_qe(
-        sr_and_eqe_fixture["spectral_response"] * 10, normalize=True
-    )
-    pd.testing.assert_series_equal(
-        qe,
-        sr_and_eqe_fixture["quantum_efficiency"]
-        / max(sr_and_eqe_fixture["quantum_efficiency"]),
-        check_names=False,
-    )
-    # error on lack of wavelength parameter if no pandas object is provided
-    with pytest.raises(TypeError, match="must have an '.index' attribute"):
-        _ = spectrum.sr_to_qe(sr_and_eqe_fixture["spectral_response"].values)
-
-
-def test_qe_to_sr(sr_and_eqe_fixture):
-    # vector type
-    sr = spectrum.qe_to_sr(
-        sr_and_eqe_fixture["quantum_efficiency"].values,
-        sr_and_eqe_fixture.index.values,  # wavelength, nm
-    )
-    assert_allclose(sr, sr_and_eqe_fixture["spectral_response"])
-    # pandas series type
-    # note: output Series' name should match the input
-    sr = spectrum.qe_to_sr(
-        sr_and_eqe_fixture["quantum_efficiency"]
-    )
-    pd.testing.assert_series_equal(
-        sr, sr_and_eqe_fixture["spectral_response"],
-        check_names=False
-    )
-    assert sr.name == "quantum_efficiency"
-    # series normalization
-    sr = spectrum.qe_to_sr(
-        sr_and_eqe_fixture["quantum_efficiency"] * 10, normalize=True
-    )
-    pd.testing.assert_series_equal(
-        sr,
-        sr_and_eqe_fixture["spectral_response"]
-        / max(sr_and_eqe_fixture["spectral_response"]),
-        check_names=False,
-    )
-    # error on lack of wavelength parameter if no pandas object is provided
-    with pytest.raises(TypeError, match="must have an '.index' attribute"):
-        _ = spectrum.qe_to_sr(
-            sr_and_eqe_fixture["quantum_efficiency"].values
-        )
-
-
-def test_qe_and_sr_reciprocal_conversion(sr_and_eqe_fixture):
-    # test that the conversion functions are reciprocal
-    qe = spectrum.sr_to_qe(sr_and_eqe_fixture["spectral_response"])
-    sr = spectrum.qe_to_sr(qe)
-    assert_allclose(sr, sr_and_eqe_fixture["spectral_response"])
-    qe = spectrum.sr_to_qe(sr)
-    assert_allclose(qe, sr_and_eqe_fixture["quantum_efficiency"])

pvlib/tests/spectrum/test_response.py

@@ -0,0 +1,124 @@
+import pytest
+import pandas as pd
+from numpy.testing import assert_allclose, assert_approx_equal, assert_equal
+import numpy as np
+from pvlib import spectrum
+
+
+def test_get_example_spectral_response():
+    # test that the sample sr is read and interpolated correctly
+    sr = spectrum.get_example_spectral_response()
+    assert_equal(len(sr), 185)
+    assert_equal(np.sum(sr.index), 136900)
+    assert_approx_equal(np.sum(sr), 107.6116)
+
+    wavelength = [270, 850, 950, 1200, 4001]
+    expected = [0.0, 0.92778, 1.0, 0.0, 0.0]
+
+    sr = spectrum.get_example_spectral_response(wavelength)
+    assert_equal(len(sr), len(wavelength))
+    assert_allclose(sr, expected, rtol=1e-5)
+
+
+@pytest.fixture
+def sr_and_eqe_fixture():
+    # Just some arbitrary data for testing the conversion functions
+    df = pd.DataFrame(
+        columns=("wavelength", "quantum_efficiency", "spectral_response"),
+        data=[
+            # nm, [0,1], A/W
+            [300, 0.85, 0.205671370402405],
+            [350, 0.86, 0.242772872514211],
+            [400, 0.87, 0.280680929019753],
+            [450, 0.88, 0.319395539919029],
+            [500, 0.89, 0.358916705212040],
+            [550, 0.90, 0.399244424898786],
+            [600, 0.91, 0.440378698979267],
+            [650, 0.92, 0.482319527453483],
+            [700, 0.93, 0.525066910321434],
+            [750, 0.94, 0.568620847583119],
+            [800, 0.95, 0.612981339238540],
+            [850, 0.90, 0.617014111207215],
+            [900, 0.80, 0.580719163489143],
+            [950, 0.70, 0.536358671833723],
+            [1000, 0.6, 0.483932636240953],
+            [1050, 0.4, 0.338752845368667],
+        ],
+    )
+    df.set_index("wavelength", inplace=True)
+    return df
+
+
+def test_sr_to_qe(sr_and_eqe_fixture):
+    # vector type
+    qe = spectrum.sr_to_qe(
+        sr_and_eqe_fixture["spectral_response"].values,
+        sr_and_eqe_fixture.index.values,  # wavelength, nm
+    )
+    assert_allclose(qe, sr_and_eqe_fixture["quantum_efficiency"])
+    # pandas series type
+    # note: output Series' name should match the input
+    qe = spectrum.sr_to_qe(
+        sr_and_eqe_fixture["spectral_response"]
+    )
+    pd.testing.assert_series_equal(
+        qe, sr_and_eqe_fixture["quantum_efficiency"],
+        check_names=False
+    )
+    assert qe.name == "spectral_response"
+    # series normalization
+    qe = spectrum.sr_to_qe(
+        sr_and_eqe_fixture["spectral_response"] * 10, normalize=True
+    )
+    pd.testing.assert_series_equal(
+        qe,
+        sr_and_eqe_fixture["quantum_efficiency"]
+        / max(sr_and_eqe_fixture["quantum_efficiency"]),
+        check_names=False,
+    )
+    # error on lack of wavelength parameter if no pandas object is provided
+    with pytest.raises(TypeError, match="must have an '.index' attribute"):
+        _ = spectrum.sr_to_qe(sr_and_eqe_fixture["spectral_response"].values)
+
+
+def test_qe_to_sr(sr_and_eqe_fixture):
+    # vector type
+    sr = spectrum.qe_to_sr(
+        sr_and_eqe_fixture["quantum_efficiency"].values,
+        sr_and_eqe_fixture.index.values,  # wavelength, nm
+    )
+    assert_allclose(sr, sr_and_eqe_fixture["spectral_response"])
+    # pandas series type
+    # note: output Series' name should match the input
+    sr = spectrum.qe_to_sr(
+        sr_and_eqe_fixture["quantum_efficiency"]
+    )
+    pd.testing.assert_series_equal(
+        sr, sr_and_eqe_fixture["spectral_response"],
+        check_names=False
+    )
+    assert sr.name == "quantum_efficiency"
+    # series normalization
+    sr = spectrum.qe_to_sr(
+        sr_and_eqe_fixture["quantum_efficiency"] * 10, normalize=True
+    )
+    pd.testing.assert_series_equal(
+        sr,
+        sr_and_eqe_fixture["spectral_response"]
+        / max(sr_and_eqe_fixture["spectral_response"]),
+        check_names=False,
+    )
+    # error on lack of wavelength parameter if no pandas object is provided
+    with pytest.raises(TypeError, match="must have an '.index' attribute"):
+        _ = spectrum.qe_to_sr(
+            sr_and_eqe_fixture["quantum_efficiency"].values
+        )
+
+
+def test_qe_and_sr_reciprocal_conversion(sr_and_eqe_fixture):
+    # test that the conversion functions are reciprocal
+    qe = spectrum.sr_to_qe(sr_and_eqe_fixture["spectral_response"])
+    sr = spectrum.qe_to_sr(qe)
+    assert_allclose(sr, sr_and_eqe_fixture["spectral_response"])
+    qe = spectrum.sr_to_qe(sr)
+    assert_allclose(qe, sr_and_eqe_fixture["quantum_efficiency"])