pvlib 0.11.2__py3-none-any.whl → 0.12.1a1__py3-none-any.whl

pvlib/tests/bifacial/test_utils.py

@@ -1,192 +0,0 @@
-"""
-test bifical.utils
-"""
-import numpy as np
-import pytest
-from pvlib.bifacial import utils
-from pvlib.shading import masking_angle, ground_angle
-from pvlib.tools import cosd
-from scipy.integrate import trapezoid
-
-
-@pytest.fixture
-def test_system_fixed_tilt():
-    syst = {'height': 1.0,
-            'pitch': 2.,
-            'surface_tilt': 30.,
-            'surface_azimuth': 180.,
-            'axis_azimuth': None,
-            'rotation': -30.}
-    syst['gcr'] = 1.0 / syst['pitch']
-    # view factors from 3 points on the ground between rows to the sky
-    pts = np.linspace(0, 1, num=3)
-    sqr3 = np.sqrt(3) / 4
-    # c_i,j = cos(angle from point i to edge of row j), j=0 is row = -1
-    # c_i,j = cos(angle from point i to edge of row j), j=0 is row = -1
-    c00 = (-2 - sqr3) / np.sqrt(1.25**2 + (2 + sqr3)**2)  # right edge row -1
-    c01 = -sqr3 / np.sqrt(1.25**2 + sqr3**2)  # right edge row 0
-    c02 = sqr3 / np.sqrt(0.75**2 + sqr3**2)  # left edge of row 0
-    c03 = (2 - sqr3) / np.sqrt(1.25**2 + (2 - sqr3)**2)  # right edge of row 1
-    vf_0 = 0.5 * (c03 - c02 + c01 - c00)  # vf at point 0
-    c10 = (-3 - sqr3) / np.sqrt(1.25**2 + (3 + sqr3)**2)  # right edge row -1
-    c11 = (-1 - sqr3) / np.sqrt(1.25**2 + (1 + sqr3)**2)  # right edge row 0
-    c12 = (-1 + sqr3) / np.sqrt(0.75**2 + (-1 + sqr3)**2)  # left edge row 0
-    c13 = (1 - sqr3) / np.sqrt(1.25**2 + (1 - sqr3)**2)  # right edge row
-    vf_1 = 0.5 * (c13 - c12 + c11 - c10)  # vf at point 1
-    c20 = -(4 + sqr3) / np.sqrt(1.25**2 + (4 + sqr3)**2)  # right edge row -1
-    c21 = (-2 + sqr3) / np.sqrt(0.75**2 + (-2 + sqr3)**2)  # left edge row 0
-    c22 = (-2 - sqr3) / np.sqrt(1.25**2 + (2 + sqr3)**2)  # right edge row 0
-    c23 = (0 - sqr3) / np.sqrt(1.25**2 + (0 - sqr3)**2)  # right edge row 1
-    vf_2 = 0.5 * (c23 - c22 + c21 - c20)  # vf at point 1
-    vfs_ground_sky = np.array([[vf_0], [vf_1], [vf_2]])
-    return syst, pts, vfs_ground_sky
-
-
-def test__solar_projection_tangent():
-    tan_phi_f = utils._solar_projection_tangent(
-        30, 150, 180)
-    tan_phi_b = utils._solar_projection_tangent(
-        30, 150, 0)
-    assert np.allclose(tan_phi_f, 0.5)
-    assert np.allclose(tan_phi_b, -0.5)
-    assert np.allclose(tan_phi_f, -tan_phi_b)
-
-
-@pytest.mark.parametrize(
-    "gcr,surface_tilt,surface_azimuth,solar_zenith,solar_azimuth,expected",
-    [(0.5, 0., 180., 0., 180., 0.5),
-     (1.0, 0., 180., 0., 180., 0.0),
-     (1.0, 90., 180., 0., 180., 1.0),
-     (0.5, 45., 180., 45., 270., 1.0 - np.sqrt(2) / 4),
-     (0.5, 45., 180., 90., 180., 0.),
-     (np.sqrt(2) / 2, 45, 180, 0, 180, 0.5),
-     (np.sqrt(2) / 2, 45, 180, 45, 180, 0.0),
-     (np.sqrt(2) / 2, 45, 180, 45, 90, 0.5),
-     (np.sqrt(2) / 2, 45, 180, 45, 0, 1.0),
-     (np.sqrt(2) / 2, 45, 180, 45, 135, 0.5 * (1 - np.sqrt(2) / 2)),
-     ])
-def test__unshaded_ground_fraction(
-        surface_tilt, surface_azimuth, solar_zenith, solar_azimuth, gcr,
-        expected):
-    # frontside, same for both sides
-    f_sky_beam_f = utils._unshaded_ground_fraction(
-        surface_tilt, surface_azimuth, solar_zenith, solar_azimuth, gcr)
-    assert np.allclose(f_sky_beam_f, expected)
-    # backside, should be the same as frontside
-    f_sky_beam_b = utils._unshaded_ground_fraction(
-        180. - surface_tilt, surface_azimuth - 180., solar_zenith,
-        solar_azimuth, gcr)
-    assert np.allclose(f_sky_beam_b, expected)
-
-
-def test__vf_ground_sky_2d(test_system_fixed_tilt):
-    # vector input
-    ts, pts, vfs_gnd_sky = test_system_fixed_tilt
-    vfs = utils.vf_ground_sky_2d(ts['rotation'], ts['gcr'], pts,
-                                 ts['pitch'], ts['height'], max_rows=1)
-    assert np.allclose(vfs, vfs_gnd_sky, rtol=0.1)  # middle point vf is off
-    # test with singleton x
-    vf = utils.vf_ground_sky_2d(ts['rotation'], ts['gcr'], pts[0],
-                                ts['pitch'], ts['height'], max_rows=1)
-    assert np.isclose(vf, vfs_gnd_sky[0])
-
-
-@pytest.mark.parametrize("vectorize", [True, False])
-def test_vf_ground_sky_2d_integ(test_system_fixed_tilt, vectorize):
-    ts, pts, vfs_gnd_sky = test_system_fixed_tilt
-    # pass rotation here since max_rows=1 for the hand-solved case in
-    # the fixture test_system, which means the ground-to-sky view factor
-    # isn't summed over enough rows for symmetry to hold.
-    vf_integ = utils.vf_ground_sky_2d_integ(
-        ts['rotation'], ts['gcr'], ts['height'], ts['pitch'],
-        max_rows=1, npoints=3, vectorize=vectorize)
-    expected_vf_integ = trapezoid(vfs_gnd_sky, pts, axis=0)
-    assert np.isclose(vf_integ, expected_vf_integ, rtol=0.1)
-
-
-def test_vf_row_sky_2d(test_system_fixed_tilt):
-    ts, _, _ = test_system_fixed_tilt
-    # with float input, fx at top of row
-    vf = utils.vf_row_sky_2d(ts['surface_tilt'], ts['gcr'], 1.)
-    expected = 0.5 * (1 + cosd(ts['surface_tilt']))
-    assert np.isclose(vf, expected)
-    # with array input
-    fx = np.array([0., 0.5, 1.])
-    vf = utils.vf_row_sky_2d(ts['surface_tilt'], ts['gcr'], fx)
-    phi = masking_angle(ts['surface_tilt'], ts['gcr'], fx)
-    expected = 0.5 * (1 + cosd(ts['surface_tilt'] + phi))
-    assert np.allclose(vf, expected)
-
-
-def test_vf_row_sky_2d_integ(test_system_fixed_tilt):
-    ts, _, _ = test_system_fixed_tilt
-    # with float input, check end position
-    with np.errstate(invalid='ignore'):
-        vf = utils.vf_row_sky_2d_integ(ts['surface_tilt'], ts['gcr'], 1., 1.)
-    expected = utils.vf_row_sky_2d(ts['surface_tilt'], ts['gcr'], 1.)
-    assert np.isclose(vf, expected)
-    # with array input
-    fx0 = np.array([0., 0.5])
-    fx1 = np.array([0., 0.8])
-    with np.errstate(invalid='ignore'):
-        vf = utils.vf_row_sky_2d_integ(ts['surface_tilt'], ts['gcr'], fx0, fx1)
-    phi = masking_angle(ts['surface_tilt'], ts['gcr'], fx0[0])
-    y0 = 0.5 * (1 + cosd(ts['surface_tilt'] + phi))
-    x = np.arange(fx0[1], fx1[1], 1e-4)
-    phi_y = masking_angle(ts['surface_tilt'], ts['gcr'], x)
-    y = 0.5 * (1 + cosd(ts['surface_tilt'] + phi_y))
-    y1 = trapezoid(y, x) / (fx1[1] - fx0[1])
-    expected = np.array([y0, y1])
-    assert np.allclose(vf, expected, rtol=1e-3)
-    # with defaults (0, 1)
-    vf = utils.vf_row_sky_2d_integ(ts['surface_tilt'], ts['gcr'])
-    x = np.arange(0, 1, 1e-4)
-    phi_y = masking_angle(ts['surface_tilt'], ts['gcr'], x)
-    y = 0.5 * (1 + cosd(ts['surface_tilt'] + phi_y))
-    y1 = trapezoid(y, x) / (1 - 0)
-    assert np.allclose(vf, y1, rtol=1e-3)
-
-
-def test_vf_row_ground_2d(test_system_fixed_tilt):
-    ts, _, _ = test_system_fixed_tilt
-    # with float input, fx at bottom of row
-    vf = utils.vf_row_ground_2d(ts['surface_tilt'], ts['gcr'], 0.)
-    expected = 0.5 * (1. - cosd(ts['surface_tilt']))
-    assert np.isclose(vf, expected)
-    # with array input
-    fx = np.array([0., 0.5, 1.0])
-    vf = utils.vf_row_ground_2d(ts['surface_tilt'], ts['gcr'], fx)
-    phi = ground_angle(ts['surface_tilt'], ts['gcr'], fx)
-    expected = 0.5 * (1 - cosd(phi - ts['surface_tilt']))
-    assert np.allclose(vf, expected)
-
-
-def test_vf_ground_2d_integ(test_system_fixed_tilt):
-    ts, _, _ = test_system_fixed_tilt
-    # with float input, check end position
-    with np.errstate(invalid='ignore'):
-        vf = utils.vf_row_ground_2d_integ(ts['surface_tilt'], ts['gcr'],
-                                          0., 0.)
-    expected = utils.vf_row_ground_2d(ts['surface_tilt'], ts['gcr'], 0.)
-    assert np.isclose(vf, expected)
-    # with array input
-    fx0 = np.array([0., 0.5])
-    fx1 = np.array([0., 0.8])
-    with np.errstate(invalid='ignore'):
-        vf = utils.vf_row_ground_2d_integ(ts['surface_tilt'], ts['gcr'],
-                                          fx0, fx1)
-    phi = ground_angle(ts['surface_tilt'], ts['gcr'], fx0[0])
-    y0 = 0.5 * (1 - cosd(phi - ts['surface_tilt']))
-    x = np.arange(fx0[1], fx1[1], 1e-4)
-    phi_y = ground_angle(ts['surface_tilt'], ts['gcr'], x)
-    y = 0.5 * (1 - cosd(phi_y - ts['surface_tilt']))
-    y1 = trapezoid(y, x) / (fx1[1] - fx0[1])
-    expected = np.array([y0, y1])
-    assert np.allclose(vf, expected, rtol=1e-2)
-    # with defaults (0, 1)
-    vf = utils.vf_row_ground_2d_integ(ts['surface_tilt'], ts['gcr'], 0, 1)
-    x = np.arange(0, 1, 1e-4)
-    phi_y = ground_angle(ts['surface_tilt'], ts['gcr'], x)
-    y = 0.5 * (1 - cosd(phi_y - ts['surface_tilt']))
-    y1 = trapezoid(y, x) / (1 - 0)
-    assert np.allclose(vf, y1, rtol=1e-2)

pvlib/tests/conftest.py

@@ -1,476 +0,0 @@
-from pathlib import Path
-import platform
-import warnings
-
-import pandas as pd
-import os
-from packaging.version import Version
-import pytest
-from functools import wraps
-
-import pvlib
-from pvlib.location import Location
-
-
-pvlib_base_version = Version(Version(pvlib.__version__).base_version)
-
-
-# decorator takes one argument: the base version for which it should fail
-# for example @fail_on_pvlib_version('0.7') will cause a test to fail
-# on pvlib versions 0.7a, 0.7b, 0.7rc1, etc.
-def fail_on_pvlib_version(version):
-    # second level of decorator takes the function under consideration
-    def wrapper(func):
-        # third level defers computation until the test is called
-        # this allows the specific test to fail at test runtime,
-        # rather than at decoration time (when the module is imported)
-        @wraps(func)
-        def inner(*args, **kwargs):
-            # fail if the version is too high
-            if pvlib_base_version >= Version(version):
-                pytest.fail('the tested function is scheduled to be '
-                            'removed in %s' % version)
-            # otherwise return the function to be executed
-            else:
-                return func(*args, **kwargs)
-        return inner
-    return wrapper
-
-
-def _check_pandas_assert_kwargs(kwargs):
-    # handles the change in API related to default
-    # tolerances in pandas 1.1.0.  See pvlib GH #1018
-    if Version(pd.__version__) >= Version('1.1.0'):
-        if kwargs.pop('check_less_precise', False):
-            kwargs['atol'] = 1e-3
-            kwargs['rtol'] = 1e-3
-        else:
-            kwargs['atol'] = 1e-5
-            kwargs['rtol'] = 1e-5
-    else:
-        kwargs.pop('rtol', None)
-        kwargs.pop('atol', None)
-    return kwargs
-
-
-def assert_index_equal(left, right, **kwargs):
-    kwargs = _check_pandas_assert_kwargs(kwargs)
-    pd.testing.assert_index_equal(left, right, **kwargs)
-
-
-def assert_series_equal(left, right, **kwargs):
-    kwargs = _check_pandas_assert_kwargs(kwargs)
-    pd.testing.assert_series_equal(left, right, **kwargs)
-
-
-def assert_frame_equal(left, right, **kwargs):
-    kwargs = _check_pandas_assert_kwargs(kwargs)
-    pd.testing.assert_frame_equal(left, right, **kwargs)
-
-
-# commonly used directories in the tests
-TEST_DIR = Path(__file__).parent
-DATA_DIR = TEST_DIR.parent / 'data'
-
-
-# pytest-rerunfailures variables
-RERUNS = 5
-RERUNS_DELAY = 2
-
-
-platform_is_windows = platform.system() == 'Windows'
-skip_windows = pytest.mark.skipif(platform_is_windows,
-                                  reason='does not run on windows')
-
-
-try:
-    # Attempt to load BSRN credentials used for testing pvlib.iotools.get_bsrn
-    bsrn_username = os.environ["BSRN_FTP_USERNAME"]
-    bsrn_password = os.environ["BSRN_FTP_PASSWORD"]
-    has_bsrn_credentials = True
-except KeyError:
-    has_bsrn_credentials = False
-
-requires_bsrn_credentials = pytest.mark.skipif(
-    not has_bsrn_credentials, reason='requires bsrn credentials')
-
-
-try:
-    # Attempt to load SolarAnywhere API key used for testing
-    # pvlib.iotools.get_solaranywhere
-    solaranywhere_api_key = os.environ["SOLARANYWHERE_API_KEY"]
-    has_solaranywhere_credentials = True
-except KeyError:
-    has_solaranywhere_credentials = False
-
-requires_solaranywhere_credentials = pytest.mark.skipif(
-    not has_solaranywhere_credentials,
-    reason='requires solaranywhere credentials')
-
-
-try:
-    import statsmodels  # noqa: F401
-    has_statsmodels = True
-except ImportError:
-    has_statsmodels = False
-
-requires_statsmodels = pytest.mark.skipif(
-    not has_statsmodels, reason='requires statsmodels')
-
-
-try:
-    import ephem  # noqa: F401
-    has_ephem = True
-except ImportError:
-    has_ephem = False
-
-requires_ephem = pytest.mark.skipif(not has_ephem, reason='requires ephem')
-
-
-def has_spa_c():
-    try:
-        from pvlib.spa_c_files.spa_py import spa_calc  # noqa: F401
-    except ImportError:
-        return False
-    else:
-        return True
-
-
-requires_spa_c = pytest.mark.skipif(not has_spa_c(), reason="requires spa_c")
-
-
-try:
-    import numba   # noqa: F401
-    has_numba = True
-except ImportError:
-    has_numba = False
-
-
-requires_numba = pytest.mark.skipif(not has_numba, reason="requires numba")
-
-
-try:
-    import pvfactors  # noqa: F401
-    has_pvfactors = True
-except ImportError:
-    has_pvfactors = False
-
-requires_pvfactors = pytest.mark.skipif(not has_pvfactors,
-                                        reason='requires pvfactors')
-
-
-try:
-    import PySAM  # noqa: F401
-    has_pysam = True
-except ImportError:
-    has_pysam = False
-
-requires_pysam = pytest.mark.skipif(not has_pysam, reason="requires PySAM")
-
-
-has_pandas_2_0 = Version(pd.__version__) >= Version("2.0.0")
-requires_pandas_2_0 = pytest.mark.skipif(not has_pandas_2_0,
-                                         reason="requires pandas>=2.0.0")
-
-
-@pytest.fixture()
-def golden():
-    return Location(39.742476, -105.1786, 'America/Denver', 1830.14)
-
-
-@pytest.fixture()
-def golden_mst():
-    return Location(39.742476, -105.1786, 'MST', 1830.14)
-
-
-@pytest.fixture()
-def expected_solpos():
-    return pd.DataFrame({'elevation': 39.872046,
-                         'apparent_zenith': 50.111622,
-                         'azimuth': 194.340241,
-                         'apparent_elevation': 39.888378},
-                        index=['2003-10-17T12:30:30Z'])
-
-
-@pytest.fixture(scope="session")
-def sam_data():
-    data = {}
-    with warnings.catch_warnings():
-        # ignore messages about duplicate entries in the databases.
-        warnings.simplefilter("ignore", UserWarning)
-        data['sandiamod'] = pvlib.pvsystem.retrieve_sam('sandiamod')
-        data['adrinverter'] = pvlib.pvsystem.retrieve_sam('adrinverter')
-    return data
-
-
-@pytest.fixture(scope="function")
-def pvsyst_module_params():
-    """
-    Define some PVSyst module parameters for testing.
-
-    The scope of the fixture is set to ``'function'`` to allow tests to modify
-    parameters if required without affecting other tests.
-    """
-    parameters = {
-        'gamma_ref': 1.05,
-        'mu_gamma': 0.001,
-        'I_L_ref': 6.0,
-        'I_o_ref': 5e-9,
-        'EgRef': 1.121,
-        'R_sh_ref': 300,
-        'R_sh_0': 1000,
-        'R_s': 0.5,
-        'R_sh_exp': 5.5,
-        'cells_in_series': 60,
-        'alpha_sc': 0.001,
-    }
-    return parameters
-
-
-@pytest.fixture(scope='function')
-def adr_inverter_parameters():
-    """
-    Define some ADR inverter parameters for testing.
-
-    The scope of the fixture is set to ``'function'`` to allow tests to modify
-    parameters if required without affecting other tests.
-    """
-    parameters = {
-        'Name': 'Ablerex Electronics Co., Ltd.: ES 2200-US-240 (240Vac)'
-                '[CEC 2011]',
-        'Vac': 240.,
-        'Pacmax': 2110.,
-        'Pnom': 2200.,
-        'Vnom': 396.,
-        'Vmin': 155.,
-        'Vmax': 413.,
-        'Vdcmax': 500.,
-        'MPPTHi': 450.,
-        'MPPTLow': 150.,
-        'Pnt': 0.25,
-        'ADRCoefficients': [0.01385, 0.0152, 0.00794, 0.00286, -0.01872,
-                            -0.01305, 0.0, 0.0, 0.0]
-    }
-    return parameters
-
-
-@pytest.fixture(scope='function')
-def cec_inverter_parameters():
-    """
-    Define some CEC inverter parameters for testing.
-
-    The scope of the fixture is set to ``'function'`` to allow tests to modify
-    parameters if required without affecting other tests.
-    """
-    parameters = {
-        'Name': 'ABB: MICRO-0.25-I-OUTD-US-208 208V [CEC 2014]',
-        'Vac': 208.0,
-        'Paco': 250.0,
-        'Pdco': 259.5220505,
-        'Vdco': 40.24260317,
-        'Pso': 1.771614224,
-        'C0': -2.48e-5,
-        'C1': -9.01e-5,
-        'C2': 6.69e-4,
-        'C3': -0.0189,
-        'Pnt': 0.02,
-        'Vdcmax': 65.0,
-        'Idcmax': 10.0,
-        'Mppt_low': 20.0,
-        'Mppt_high': 50.0,
-    }
-    return parameters
-
-
-@pytest.fixture(scope='function')
-def cec_module_params():
-    """
-    Define some CEC module parameters for testing.
-
-    The scope of the fixture is set to ``'function'`` to allow tests to modify
-    parameters if required without affecting other tests.
-    """
-    parameters = {
-        'Name': 'Example Module',
-        'BIPV': 'Y',
-        'Date': '4/28/2008',
-        'T_NOCT': 65,
-        'A_c': 0.67,
-        'N_s': 18,
-        'I_sc_ref': 7.5,
-        'V_oc_ref': 10.4,
-        'I_mp_ref': 6.6,
-        'V_mp_ref': 8.4,
-        'alpha_sc': 0.003,
-        'beta_oc': -0.04,
-        'a_ref': 0.473,
-        'I_L_ref': 7.545,
-        'I_o_ref': 1.94e-09,
-        'R_s': 0.094,
-        'R_sh_ref': 15.72,
-        'Adjust': 10.6,
-        'gamma_r': -0.5,
-        'Version': 'MM105',
-        'PTC': 48.9,
-        'Technology': 'Multi-c-Si',
-    }
-    return parameters
-
-
-@pytest.fixture(scope='function')
-def cec_module_cs5p_220m():
-    """
-    Define Canadian Solar CS5P-220M module parameters for testing.
-
-    The scope of the fixture is set to ``'function'`` to allow tests to modify
-    parameters if required without affecting other tests.
-    """
-    parameters = {
-        'Name': 'Canadian Solar CS5P-220M',
-        'BIPV': 'N',
-        'Date': '10/5/2009',
-        'T_NOCT': 42.4,
-        'A_c': 1.7,
-        'N_s': 96,
-        'I_sc_ref': 5.1,
-        'V_oc_ref': 59.4,
-        'I_mp_ref': 4.69,
-        'V_mp_ref': 46.9,
-        'alpha_sc': 0.004539,
-        'beta_oc': -0.22216,
-        'a_ref': 2.6373,
-        'I_L_ref': 5.114,
-        'I_o_ref': 8.196e-10,
-        'R_s': 1.065,
-        'R_sh_ref': 381.68,
-        'Adjust': 8.7,
-        'gamma_r': -0.476,
-        'Version': 'MM106',
-        'PTC': 200.1,
-        'Technology': 'Mono-c-Si',
-    }
-    return parameters
-
-
-@pytest.fixture(scope='function')
-def cec_module_spr_e20_327():
-    """
-    Define SunPower SPR-E20-327 module parameters for testing.
-
-    The scope of the fixture is set to ``'function'`` to allow tests to modify
-    parameters if required without affecting other tests.
-    """
-    parameters = {
-        'Name': 'SunPower SPR-E20-327',
-        'BIPV': 'N',
-        'Date': '1/14/2013',
-        'T_NOCT': 46,
-        'A_c': 1.631,
-        'N_s': 96,
-        'I_sc_ref': 6.46,
-        'V_oc_ref': 65.1,
-        'I_mp_ref': 5.98,
-        'V_mp_ref': 54.7,
-        'alpha_sc': 0.004522,
-        'beta_oc': -0.23176,
-        'a_ref': 2.6868,
-        'I_L_ref': 6.468,
-        'I_o_ref': 1.88e-10,
-        'R_s': 0.37,
-        'R_sh_ref': 298.13,
-        'Adjust': -0.1862,
-        'gamma_r': -0.386,
-        'Version': 'NRELv1',
-        'PTC': 301.4,
-        'Technology': 'Mono-c-Si',
-    }
-    return parameters
-
-
-@pytest.fixture(scope='function')
-def cec_module_fs_495():
-    """
-    Define First Solar FS-495 module parameters for testing.
-
-    The scope of the fixture is set to ``'function'`` to allow tests to modify
-    parameters if required without affecting other tests.
-    """
-    parameters = {
-        'Name': 'First Solar FS-495',
-        'BIPV': 'N',
-        'Date': '9/18/2014',
-        'T_NOCT': 44.6,
-        'A_c': 0.72,
-        'N_s': 216,
-        'I_sc_ref': 1.55,
-        'V_oc_ref': 86.5,
-        'I_mp_ref': 1.4,
-        'V_mp_ref': 67.9,
-        'alpha_sc': 0.000924,
-        'beta_oc': -0.22741,
-        'a_ref': 2.9482,
-        'I_L_ref': 1.563,
-        'I_o_ref': 2.64e-13,
-        'R_s': 6.804,
-        'R_sh_ref': 806.27,
-        'Adjust': -10.65,
-        'gamma_r': -0.264,
-        'Version': 'NRELv1',
-        'PTC': 89.7,
-        'Technology': 'CdTe',
-    }
-    return parameters
-
-
-@pytest.fixture(scope='function')
-def sapm_temperature_cs5p_220m():
-    # SAPM temperature model parameters for Canadian_Solar_CS5P_220M
-    # (glass/polymer) in open rack
-    return {'a': -3.40641, 'b': -0.0842075, 'deltaT': 3}
-
-
-@pytest.fixture(scope='function')
-def sapm_module_params():
-    """
-    Define SAPM model parameters for Canadian Solar CS5P 220M module.
-
-    The scope of the fixture is set to ``'function'`` to allow tests to modify
-    parameters if required without affecting other tests.
-    """
-    parameters = {'Material': 'c-Si',
-                  'Cells_in_Series': 96,
-                  'Parallel_Strings': 1,
-                  'A0': 0.928385,
-                  'A1': 0.068093,
-                  'A2': -0.0157738,
-                  'A3': 0.0016606,
-                  'A4': -6.93E-05,
-                  'B0': 1,
-                  'B1': -0.002438,
-                  'B2': 0.0003103,
-                  'B3': -0.00001246,
-                  'B4': 2.11E-07,
-                  'B5': -1.36E-09,
-                  'C0': 1.01284,
-                  'C1': -0.0128398,
-                  'C2': 0.279317,
-                  'C3': -7.24463,
-                  'C4': 0.996446,
-                  'C5': 0.003554,
-                  'C6': 1.15535,
-                  'C7': -0.155353,
-                  'Isco': 5.09115,
-                  'Impo': 4.54629,
-                  'Voco': 59.2608,
-                  'Vmpo': 48.3156,
-                  'Aisc': 0.000397,
-                  'Aimp': 0.000181,
-                  'Bvoco': -0.21696,
-                  'Mbvoc': 0.0,
-                  'Bvmpo': -0.235488,
-                  'Mbvmp': 0.0,
-                  'N': 1.4032,
-                  'IXO': 4.97599,
-                  'IXXO': 3.18803,
-                  'FD': 1}
-    return parameters