pvlib 0.11.2__py3-none-any.whl → 0.12.0__py3-none-any.whl

pvlib/tests/ivtools/test_sdm.py

@@ -1,429 +0,0 @@
-import numpy as np
-import pandas as pd
-from scipy import optimize
-
-import pytest
-from numpy.testing import assert_allclose
-
-from pvlib.ivtools import sdm
-from pvlib import pvsystem
-
-from pvlib.tests.conftest import requires_pysam, requires_statsmodels
-
-from ..conftest import DATA_DIR
-
-
-@pytest.fixture
-def get_test_iv_params():
-    return {'IL': 8.0, 'I0': 5e-10, 'Rsh': 1000, 'Rs': 0.2, 'nNsVth': 1.61864}
-
-
-@pytest.fixture
-def cec_params_cansol_cs5p_220p():
-    return {'ivcurve': {'V_mp_ref': 46.6, 'I_mp_ref': 4.73, 'V_oc_ref': 58.3,
-                        'I_sc_ref': 5.05},
-            'specs': {'alpha_sc': 0.0025, 'beta_voc': -0.19659,
-                      'gamma_pmp': -0.43, 'cells_in_series': 96},
-            'params': {'I_L_ref': 5.056, 'I_o_ref': 1.01e-10,
-                       'R_sh_ref': 837.51, 'R_s': 1.004, 'a_ref': 2.3674,
-                       'Adjust': 2.3}}
-
-
-@requires_pysam
-def test_fit_cec_sam(cec_params_cansol_cs5p_220p):
-    input_data = cec_params_cansol_cs5p_220p['ivcurve']
-    specs = cec_params_cansol_cs5p_220p['specs']
-    I_L_ref, I_o_ref, R_s, R_sh_ref, a_ref, Adjust = \
-        sdm.fit_cec_sam(
-            celltype='polySi', v_mp=input_data['V_mp_ref'],
-            i_mp=input_data['I_mp_ref'], v_oc=input_data['V_oc_ref'],
-            i_sc=input_data['I_sc_ref'], alpha_sc=specs['alpha_sc'],
-            beta_voc=specs['beta_voc'],
-            gamma_pmp=specs['gamma_pmp'],
-            cells_in_series=specs['cells_in_series'])
-    expected = pd.Series(cec_params_cansol_cs5p_220p['params'])
-    modeled = pd.Series(index=expected.index, data=np.nan)
-    modeled['a_ref'] = a_ref
-    modeled['I_L_ref'] = I_L_ref
-    modeled['I_o_ref'] = I_o_ref
-    modeled['R_s'] = R_s
-    modeled['R_sh_ref'] = R_sh_ref
-    modeled['Adjust'] = Adjust
-    assert np.allclose(modeled.values, expected.values, rtol=5e-2)
-
-
-@requires_pysam
-def test_fit_cec_sam_estimation_failure(cec_params_cansol_cs5p_220p):
-    # Failing to estimate the parameters for the CEC SDM model should raise an
-    # exception.
-    with pytest.raises(RuntimeError):
-        sdm.fit_cec_sam(celltype='polySi', v_mp=0.45, i_mp=5.25, v_oc=0.55,
-                        i_sc=5.5, alpha_sc=0.00275, beta_voc=0.00275,
-                        gamma_pmp=0.0055, cells_in_series=1, temp_ref=25)
-
-
-def test_fit_desoto():
-    result, _ = sdm.fit_desoto(v_mp=31.0, i_mp=8.71, v_oc=38.3, i_sc=9.43,
-                               alpha_sc=0.005658, beta_voc=-0.13788,
-                               cells_in_series=60)
-    result_expected = {'I_L_ref': 9.45232,
-                       'I_o_ref': 3.22460e-10,
-                       'R_s': 0.297814,
-                       'R_sh_ref': 125.798,
-                       'a_ref': 1.59128,
-                       'alpha_sc': 0.005658,
-                       'EgRef': 1.121,
-                       'dEgdT': -0.0002677,
-                       'irrad_ref': 1000,
-                       'temp_ref': 25}
-    assert np.allclose(pd.Series(result), pd.Series(result_expected),
-                       rtol=1e-4)
-
-
-def test_fit_desoto_init_guess(mocker):
-    init_guess_array = np.array([9.4, 3.0e-10, 0.3, 125., 1.6])
-    init_guess = {k: v for k, v in zip(
-        ['IL_0', 'Io_0', 'Rs_0', 'Rsh_0', 'a_0'], init_guess_array)}
-    spy = mocker.spy(optimize, 'root')
-    result, _ = sdm.fit_desoto(v_mp=31.0, i_mp=8.71, v_oc=38.3, i_sc=9.43,
-                               alpha_sc=0.005658, beta_voc=-0.13788,
-                               cells_in_series=60, init_guess=init_guess)
-    np.testing.assert_array_equal(init_guess_array, spy.call_args[1]['x0'])
-
-
-def test_fit_desoto_init_bad_key():
-    init_guess = {'IL_0': 6., 'bad_key': 0}
-    with pytest.raises(ValueError, match='is not a valid name;'):
-        result, _ = sdm.fit_desoto(v_mp=31.0, i_mp=8.71, v_oc=38.3, i_sc=9.43,
-                                   alpha_sc=0.005658, beta_voc=-0.13788,
-                                   cells_in_series=60, init_guess=init_guess)
-
-
-def test_fit_desoto_failure():
-    with pytest.raises(RuntimeError) as exc:
-        sdm.fit_desoto(v_mp=31.0, i_mp=8.71, v_oc=38.3, i_sc=9.43,
-                       alpha_sc=0.005658, beta_voc=-0.13788,
-                       cells_in_series=10)
-    assert ('Parameter estimation failed') in str(exc.value)
-
-
-@requires_statsmodels
-def test_fit_desoto_sandia(cec_params_cansol_cs5p_220p):
-    # this test computes a set of IV curves for the input fixture, fits
-    # the De Soto model to the calculated IV curves, and compares the fitted
-    # parameters to the starting values
-    params = cec_params_cansol_cs5p_220p['params']
-    params.pop('Adjust')
-    specs = cec_params_cansol_cs5p_220p['specs']
-    effective_irradiance = np.array([400., 500., 600., 700., 800., 900.,
-                                     1000.])
-    temp_cell = np.array([15., 25., 35., 45.])
-    ee = np.tile(effective_irradiance, len(temp_cell))
-    tc = np.repeat(temp_cell, len(effective_irradiance))
-    IL, I0, Rs, Rsh, nNsVth = pvsystem.calcparams_desoto(
-        ee, tc, alpha_sc=specs['alpha_sc'], **params)
-    ivcurve_params = dict(photocurrent=IL, saturation_current=I0,
-                          resistance_series=Rs, resistance_shunt=Rsh,
-                          nNsVth=nNsVth)
-    sim_ivcurves = pvsystem.singlediode(**ivcurve_params).to_dict('series')
-    v = np.linspace(0., sim_ivcurves['v_oc'], 300)
-    i = pvsystem.i_from_v(voltage=v, **ivcurve_params)
-    sim_ivcurves.update(v=v.T, i=i.T, ee=ee, tc=tc)
-
-    result = sdm.fit_desoto_sandia(sim_ivcurves, specs)
-    modeled = pd.Series(index=params.keys(), data=np.nan)
-    modeled['a_ref'] = result['a_ref']
-    modeled['I_L_ref'] = result['I_L_ref']
-    modeled['I_o_ref'] = result['I_o_ref']
-    modeled['R_s'] = result['R_s']
-    modeled['R_sh_ref'] = result['R_sh_ref']
-    expected = pd.Series(params)
-    assert np.allclose(modeled[params.keys()].values,
-                       expected[params.keys()].values, rtol=5e-2)
-    assert_allclose(result['dEgdT'], -0.0002677)
-    assert_allclose(result['EgRef'], 1.3112547292120638)
-    assert_allclose(result['cells_in_series'], specs['cells_in_series'])
-
-
-def _read_iv_curves_for_test(datafile, npts):
-    """ read constants and npts IV curves from datafile """
-    iv_specs = dict.fromkeys(['cells_in_series', 'alpha_sc', 'beta_voc',
-                              'descr'])
-    ivcurves = dict.fromkeys(['i_sc', 'i_mp', 'v_mp', 'v_oc', 'poa', 'tc',
-                              'ee'])
-
-    infilen = DATA_DIR / datafile
-    with infilen.open(mode='r') as f:
-
-        Ns, aIsc, bVoc, descr = f.readline().split(',')
-
-        iv_specs.update(
-            cells_in_series=int(Ns), alpha_sc=float(aIsc),
-            beta_voc=float(bVoc), descr=descr)
-
-        strN, strM = f.readline().split(',')
-        N = int(strN)
-        M = int(strM)
-
-        isc = np.empty(N)
-        imp = np.empty(N)
-        vmp = np.empty(N)
-        voc = np.empty(N)
-        ee = np.empty(N)
-        poa = np.empty(N)
-        tc = np.empty(N)
-        v = np.empty((N, M))
-        i = np.empty((N, M))
-        v[:] = np.nan  # fill with nan
-        i[:] = np.nan
-
-        for k in range(N):
-            tmp = (float(x) for x in f.readline().split(','))
-            isc[k], imp[k], vmp[k], voc[k], poa[k], tc[k], ee[k] = tmp
-            # read voltage and current
-            tmp = [float(x) for x in f.readline().split(',')]
-            while len(tmp) < M:
-                tmp.append(np.nan)
-            v[k, :] = tmp
-            tmp = [float(x) for x in f.readline().split(',')]
-            while len(tmp) < M:
-                tmp.append(np.nan)
-            i[k, :] = tmp
-
-    ivcurves['i_sc'] = isc[:npts]
-    ivcurves['i_mp'] = imp[:npts]
-    ivcurves['v_oc'] = voc[:npts]
-    ivcurves['v_mp'] = vmp[:npts]
-    ivcurves['ee'] = ee[:npts]
-    ivcurves['tc'] = tc[:npts]
-    ivcurves['v'] = v[:npts]
-    ivcurves['i'] = i[:npts]
-    ivcurves['p_mp'] = ivcurves['v_mp'] * ivcurves['i_mp']  # power
-
-    return iv_specs, ivcurves
-
-
-def _read_pvsyst_expected(datafile):
-    """ Read Pvsyst model parameters and diode equation values for each
-    IV curve
-    """
-    pvsyst_specs = dict.fromkeys(['cells_in_series', 'alpha_sc', 'beta_voc',
-                                  'descr'])
-    # order required to match file being read
-    paramlist = [
-        'I_L_ref', 'I_o_ref', 'EgRef', 'R_sh_ref', 'R_sh_0', 'R_sh_exp', 'R_s',
-        'gamma_ref', 'mu_gamma']
-    varlist = ['iph', 'io', 'rs', 'rsh', 'u']
-    pvsyst = dict.fromkeys(paramlist + varlist)
-
-    infilen = DATA_DIR / datafile
-    with infilen.open(mode='r') as f:
-
-        Ns, aIsc, bVoc, descr = f.readline().split(',')
-
-        pvsyst_specs.update(
-            cells_in_series=int(Ns), alpha_sc=float(aIsc),
-            beta_voc=float(bVoc), descr=descr)
-
-        tmp = [float(x) for x in f.readline().split(',')]
-        # I_L_ref, I_o_ref, EgRef, R_s, R_sh_ref, R_sh_0, R_sh_exp, gamma_ref,
-        # mu_gamma
-        pvsyst.update(zip(paramlist, tmp))
-
-        strN = f.readline()
-        N = int(strN)
-
-        Iph = np.empty(N)
-        Io = np.empty(N)
-        Rsh = np.empty(N)
-        Rs = np.empty(N)
-        u = np.empty(N)
-
-        for k in range(N):
-            tmp = [float(x) for x in f.readline().split(',')]
-            Iph[k], Io[k], Rsh[k], Rs[k], u[k] = tmp
-
-    pvsyst.update(zip(varlist, [Iph, Io, Rs, Rsh, u]))
-
-    return pvsyst_specs, pvsyst
-
-
-@requires_statsmodels
-def test_fit_pvsyst_sandia(npts=3000):
-
-    # get IV curve data
-    iv_specs, ivcurves = _read_iv_curves_for_test('PVsyst_demo.csv', npts)
-
-    # get known Pvsyst model parameters and five parameters from each fitted
-    # IV curve
-    pvsyst_specs, pvsyst = _read_pvsyst_expected('PVsyst_demo_model.csv')
-
-    modeled = sdm.fit_pvsyst_sandia(ivcurves, iv_specs)
-
-    # calculate IV curves using the fitted model, for comparison with input
-    # IV curves
-    param_res = pvsystem.calcparams_pvsyst(
-        effective_irradiance=ivcurves['ee'], temp_cell=ivcurves['tc'],
-        alpha_sc=iv_specs['alpha_sc'], gamma_ref=modeled['gamma_ref'],
-        mu_gamma=modeled['mu_gamma'], I_L_ref=modeled['I_L_ref'],
-        I_o_ref=modeled['I_o_ref'], R_sh_ref=modeled['R_sh_ref'],
-        R_sh_0=modeled['R_sh_0'], R_s=modeled['R_s'],
-        cells_in_series=iv_specs['cells_in_series'], EgRef=modeled['EgRef'])
-    iv_res = pvsystem.singlediode(*param_res)
-
-    # assertions
-    assert np.allclose(
-        ivcurves['p_mp'], iv_res['p_mp'], equal_nan=True, rtol=0.038)
-    assert np.allclose(
-        ivcurves['v_mp'], iv_res['v_mp'], equal_nan=True, rtol=0.029)
-    assert np.allclose(
-        ivcurves['i_mp'], iv_res['i_mp'], equal_nan=True, rtol=0.021)
-    assert np.allclose(
-        ivcurves['i_sc'], iv_res['i_sc'], equal_nan=True, rtol=0.003)
-    assert np.allclose(
-        ivcurves['v_oc'], iv_res['v_oc'], equal_nan=True, rtol=0.019)
-    # cells_in_series, alpha_sc, beta_voc, descr
-    assert all((iv_specs[k] == pvsyst_specs[k]) for k in iv_specs.keys())
-    # I_L_ref, I_o_ref, EgRef, R_sh_ref, R_sh_0, R_sh_exp, R_s, gamma_ref,
-    # mu_gamma
-    assert np.isclose(modeled['I_L_ref'], pvsyst['I_L_ref'], rtol=6.5e-5)
-    assert np.isclose(modeled['I_o_ref'], pvsyst['I_o_ref'], rtol=0.15)
-    assert np.isclose(modeled['R_s'], pvsyst['R_s'], rtol=0.0035)
-    assert np.isclose(modeled['R_sh_ref'], pvsyst['R_sh_ref'], rtol=0.091)
-    assert np.isclose(modeled['R_sh_0'], pvsyst['R_sh_0'], rtol=0.013)
-    assert np.isclose(modeled['EgRef'], pvsyst['EgRef'], rtol=0.037)
-    assert np.isclose(modeled['gamma_ref'], pvsyst['gamma_ref'], rtol=0.0045)
-    assert np.isclose(modeled['mu_gamma'], pvsyst['mu_gamma'], rtol=0.064)
-
-    # Iph, Io, Rsh, Rs, u
-    mask = np.ones(modeled['u'].shape, dtype=bool)
-    # exclude one curve with different convergence
-    umask = mask.copy()
-    umask[2540] = False
-    assert all(modeled['u'][umask] == pvsyst['u'][:npts][umask])
-    assert np.allclose(
-        modeled['iph'][modeled['u']], pvsyst['iph'][:npts][modeled['u']],
-        equal_nan=True, rtol=0.0009)
-    assert np.allclose(
-        modeled['io'][modeled['u']], pvsyst['io'][:npts][modeled['u']],
-        equal_nan=True, rtol=0.096)
-    assert np.allclose(
-        modeled['rs'][modeled['u']], pvsyst['rs'][:npts][modeled['u']],
-        equal_nan=True, rtol=0.035)
-    # exclude one curve with Rsh outside 63% tolerance
-    rshmask = modeled['u'].copy()
-    rshmask[2545] = False
-    assert np.allclose(
-        modeled['rsh'][rshmask], pvsyst['rsh'][:npts][rshmask],
-        equal_nan=True, rtol=0.63)
-
-
-@pytest.mark.parametrize('vmp, imp, iph, io, rs, rsh, nnsvth, expected', [
-    (2., 2., 2., 2., 2., 2., 2., np.nan),
-    (2., 2., 0., 2., 2., 2., 2., np.nan),
-    (2., 2., 2., 0., 2., 2., 2., np.nan),
-    (2., 2., 2., 2., 0., 2., 2., np.nan),
-    (2., 2., 2., 2., 2., 0., 2., np.nan),
-    (2., 2., 2., 2., 2., 2., 0., np.nan)])
-def test__update_rsh_fixed_pt_nans(vmp, imp, iph, io, rs, rsh, nnsvth,
-                                   expected):
-    outrsh = sdm._update_rsh_fixed_pt(vmp, imp, iph, io, rs, rsh, nnsvth)
-    assert np.all(np.isnan(outrsh))
-
-
-def test__update_rsh_fixed_pt_vmp0():
-    outrsh = sdm._update_rsh_fixed_pt(vmp=0., imp=2., iph=2., io=2., rs=2.,
-                                      rsh=2., nnsvth=2.)
-    assert_allclose(outrsh, np.array([502.]), atol=.0001)
-
-
-def test__update_rsh_fixed_pt_vector():
-    outrsh = sdm._update_rsh_fixed_pt(rsh=np.array([-1., 3, .5, 2.]),
-                                      rs=np.array([1., -.5, 2., 2.]),
-                                      io=np.array([.2, .3, -.4, 2.]),
-                                      iph=np.array([-.1, 1, 3., 2.]),
-                                      nnsvth=np.array([4., -.2, .1, 2.]),
-                                      imp=np.array([.2, .2, -1., 2.]),
-                                      vmp=np.array([0., -1, 0., 0.]))
-    assert np.all(np.isnan(outrsh[0:3]))
-    assert_allclose(outrsh[3], np.array([502.]), atol=.0001)
-
-
-@pytest.mark.parametrize('voc, iph, io, rs, rsh, nnsvth, expected', [
-    (2., 2., 2., 2., 2., 2., 0.5911),
-    (2., 2., 2., 0., 2., 2., 0.5911),
-    (2., 2., 0., 2., 2., 2., 0.),
-    (2., 0., 2., 2., 2., 2., 1.0161e-4),
-    (0., 2., 2., 2., 2., 2., 17.9436)])
-def test__update_io(voc, iph, io, rs, rsh, nnsvth, expected):
-    outio = sdm._update_io(voc, iph, io, rs, rsh, nnsvth)
-    assert_allclose(outio, expected, atol=.0001)
-
-
-@pytest.mark.parametrize('voc, iph, io, rs, rsh, nnsvth', [
-    (2., 2., 2., 2., 2., 0.),
-    (-1., -1., -1., -1., -1., -1.)])
-def test__update_io_nan(voc, iph, io, rs, rsh, nnsvth):
-    outio = sdm._update_io(voc, iph, io, rs, rsh, nnsvth)
-    assert np.isnan(outio)
-
-
-@pytest.mark.parametrize('vmp, imp, iph, io, rs, rsh, nnsvth, expected', [
-    (2., 2., 2., 2., 2., 2., 2., (1.8726, 2.)),
-    (2., 0., 2., 2., 2., 2., 2., (1.8726, 3.4537)),
-    (2., 2., 0., 2., 2., 2., 2., (1.2650, 0.8526)),
-    (0., 2., 2., 2., 2., 2., 2., (1.5571, 2.))])
-def test__calc_theta_phi_exact(vmp, imp, iph, io, rs, rsh, nnsvth, expected):
-    theta, phi = sdm._calc_theta_phi_exact(vmp, imp, iph, io, rs, rsh, nnsvth)
-    assert_allclose(theta, expected[0], atol=.0001)
-    assert_allclose(phi, expected[1], atol=.0001)
-
-
-@pytest.mark.parametrize('vmp, imp, iph, io, rs, rsh, nnsvth', [
-    (2., 2., 2., 0., 2., 2., 2.),
-    (2., 2., 2., 2., 2., 2., 0.),
-    (2., 0., 2., 2., 2., 0., 2.)])
-def test__calc_theta_phi_exact_both_nan(vmp, imp, iph, io, rs, rsh, nnsvth):
-    theta, phi = sdm._calc_theta_phi_exact(vmp, imp, iph, io, rs, rsh, nnsvth)
-    assert np.isnan(theta)
-    assert np.isnan(phi)
-
-
-def test__calc_theta_phi_exact_one_nan():
-    theta, phi = sdm._calc_theta_phi_exact(imp=2., iph=2., vmp=2., io=2.,
-                                           nnsvth=2., rs=0., rsh=2.)
-    assert np.isnan(theta)
-    assert_allclose(phi, 2., atol=.0001)
-
-
-def test__calc_theta_phi_exact_vector():
-    theta, phi = sdm._calc_theta_phi_exact(imp=np.array([1., -1.]),
-                                           iph=np.array([-1., 1.]),
-                                           vmp=np.array([1., -1.]),
-                                           io=np.array([-1., 1.]),
-                                           nnsvth=np.array([1., -1.]),
-                                           rs=np.array([-1., 1.]),
-                                           rsh=np.array([1., -1.]))
-    assert np.isnan(theta[0])
-    assert np.isnan(theta[1])
-    assert np.isnan(phi[0])
-    assert_allclose(phi[1], 2.2079, atol=.0001)
-
-
-def test_pvsyst_temperature_coeff():
-    # test for consistency with dP/dT estimated with secant rule
-    params = {'alpha_sc': 0., 'gamma_ref': 1.1, 'mu_gamma': 0.,
-              'I_L_ref': 6., 'I_o_ref': 5.e-9, 'R_sh_ref': 200.,
-              'R_sh_0': 2000., 'R_s': 0.5, 'cells_in_series': 60}
-    expected = -0.004886706494879083
-    # params defines a Pvsyst model for a notional module.
-    # expected value is created by calculating power at 1000 W/m2, and cell
-    # temperature of 24 and 26C, using pvsystem.calcparams_pvsyst and
-    # pvsystem.singlediode. The derivative (value for expected) is estimated
-    # as the slope (p_mp at 26C - p_mp at 24C) / 2
-    # using the secant rule for derivatives.
-    gamma_pdc = sdm.pvsyst_temperature_coeff(
-        params['alpha_sc'], params['gamma_ref'], params['mu_gamma'],
-        params['I_L_ref'], params['I_o_ref'], params['R_sh_ref'],
-        params['R_sh_0'], params['R_s'], params['cells_in_series'])
-    assert_allclose(gamma_pdc, expected, rtol=0.0005)

pvlib/tests/ivtools/test_utils.py

@@ -1,173 +0,0 @@
-import numpy as np
-import pandas as pd
-import pytest
-from pvlib.ivtools.utils import _numdiff, rectify_iv_curve, astm_e1036
-from pvlib.ivtools.utils import _schumaker_qspline
-
-from ..conftest import DATA_DIR
-
-
-@pytest.fixture
-def ivcurve():
-    voltage = np.array([0., 1., 5., 10., 25., 25.00001, 30., 28., 45., 47.,
-                        49., 51., np.nan])
-    current = np.array([7., 6., 6., 5., 4., 3., 2.7, 2.5, np.nan, 0.5, -1., 0.,
-                        np.nan])
-    return voltage, current
-
-
-def test__numdiff():
-    iv = pd.read_csv(DATA_DIR / 'ivtools_numdiff.csv',
-                     names=['I', 'V', 'dIdV', 'd2IdV2'], dtype=float)
-    df, d2f = _numdiff(iv.V, iv.I)
-    assert np.allclose(iv.dIdV, df, equal_nan=True)
-    assert np.allclose(iv.d2IdV2, d2f, equal_nan=True)
-
-
-def test_rectify_iv_curve(ivcurve):
-    voltage, current = ivcurve
-
-    vexp_no_dec = np.array([0., 1.,  5., 10., 25., 25.00001, 28., 30., 47.,
-                            51.])
-    iexp_no_dec = np.array([7., 6., 6., 5., 4., 3., 2.5, 2.7, 0.5, 0.])
-    v, i = rectify_iv_curve(voltage, current)
-    np.testing.assert_allclose(v, vexp_no_dec, atol=.0001)
-    np.testing.assert_allclose(i, iexp_no_dec, atol=.0001)
-
-    vexp = np.array([0., 1., 5., 10., 25., 28., 30., 47., 51.])
-    iexp = np.array([7., 6., 6., 5., 3.5, 2.5, 2.7, 0.5, 0.])
-    v, i = rectify_iv_curve(voltage, current, decimals=4)
-    np.testing.assert_allclose(v, vexp, atol=.0001)
-    np.testing.assert_allclose(i, iexp, atol=.0001)
-
-
-@pytest.mark.parametrize('x,y,expected', [
-    (np.array([0., 1., 2., 3., 4., 1., 2., 3., 4., 5.]),
-     np.array([2., 1., 0., 1., 2., 3., 2., 1., 2., 3.]),
-     (np.array([[0., -1., 2.], [-0.5, -1., 1.], [-0.75, -0.5, 3.],
-                [0.75, -1.5, 0.375], [0.125, -1.25, 2.5625], [1.5, 0., 0.],
-                [-0.5, -1., 2.], [-0.25, 1.5, 0.375], [0.75, -1.5, 1.375],
-                [0.5, 1., 1.], [1.5, 0., 1.], [0.0278, -0.3333, 2.1667],
-                [-0.75, 1.5, 1.625], [-0.25, 1.5, 1.375], [0.1667, 0., 2.],
-                [0., 1., 2.]]),
-      np.array([0., 1., 1., 1.5, 1.5, 2., 2., 2.5, 2.5, 3., 3., 3., 3.5, 3.5,
-                4., 4., 5.]),
-      np.array([2., 1., 3., 0.375, 2.5625, 0., 2., 0.375, 1.375, 1., 1.,
-                2.1667, 1.625, 1.375, 2., 2., 3.]),
-      np.array([0., 0., 0., 1., 1., 0., 0., 1., 1., 0., 0., 1., 1., 1., 0., 0.,
-                0.]))),
-    (np.array([1., 2., 3., 4., 5.]),
-     np.array([-2., -1., 0., 1., 2.]),
-     (np.array([[0., 1., -2.], [0., 1., -1.], [0., 1., 0.], [0., 1., 1.]]),
-      np.array([1., 2., 3., 4., 5.]),
-      np.array([-2., -1., 0., 1., 2.]),
-      np.array([0., 0., 0., 0., 0.]))),
-    (np.array([-.5, -.1, 0., .2, .3]),
-     np.array([-5., -1., .2, .5, 2.]),
-     (np.array([[2.2727, 9.0909, -5.], [63.0303, 10.9091, -1.],
-                [-72.7273, 17.2121, -.297], [-11.8182, 2.6667, .2],
-                [6.0606, .303, .3485], [122.7273, 2.7273, .5]]),
-      np.array([-.5, -.1, -.05, 0., .1, .2, .3]),
-      np.array([-5., -1., -.297, .2, .3485, .5, 2.]),
-      np.array([0., 0., 1., 0., 1., 0., 0.])))])
-def test__schmumaker_qspline(x, y, expected):
-    [t, c, yhat, kflag] = _schumaker_qspline(x, y)
-    np.testing.assert_allclose(c, expected[0], atol=0.0001)
-    np.testing.assert_allclose(t, expected[1], atol=0.0001)
-    np.testing.assert_allclose(yhat, expected[2], atol=0.0001)
-    np.testing.assert_allclose(kflag, expected[3], atol=0.0001)
-
-
-@pytest.fixture
-def i_array():
-    i = np.array([8.09403993, 8.09382549, 8.09361103, 8.09339656, 8.09318205,
-                  8.09296748, 8.09275275, 8.09253771, 8.09232204, 8.09210506,
-                  8.09188538, 8.09166014, 8.09142342, 8.09116305, 8.09085392,
-                  8.09044425, 8.08982734, 8.08878333, 8.08685945, 8.08312463,
-                  8.07566926, 8.06059856, 8.03005836, 7.96856869, 7.8469714,
-                  7.61489584, 7.19789314, 6.51138396, 5.49373476, 4.13267172,
-                  2.46021487, 0.52838624, -1.61055289])
-    return i
-
-
-@pytest.fixture
-def v_array():
-    v = np.array([-0.005, 0.015, 0.035, 0.055, 0.075, 0.095, 0.115, 0.135,
-                  0.155, 0.175, 0.195, 0.215, 0.235, 0.255, 0.275, 0.295,
-                  0.315, 0.335, 0.355, 0.375, 0.395, 0.415, 0.435, 0.455,
-                  0.475, 0.495, 0.515, 0.535, 0.555, 0.575, 0.595, 0.615,
-                  0.635])
-    return v
-
-
-# astm_e1036 tests
-def test_astm_e1036(v_array, i_array):
-    result = astm_e1036(v_array, i_array)
-    expected = {'voc': 0.6195097477985162,
-                'isc': 8.093986320386227,
-                'vmp': 0.494283417170082,
-                'imp': 7.626088301548568,
-                'pmp': 3.7694489853302127,
-                'ff': 0.7517393078504361}
-    fit = result.pop('mp_fit')
-    expected_fit = np.array(
-        [3.6260726, 0.49124176, -0.24644747, -0.26442383, -0.1223237])
-    assert fit.coef == pytest.approx(expected_fit)
-    assert result == pytest.approx(expected)
-
-
-def test_astm_e1036_fit_order(v_array, i_array):
-    result = astm_e1036(v_array, i_array, mp_fit_order=3)
-    fit = result.pop('mp_fit')
-    expected_fit = np.array(
-        [3.64081697, 0.49124176, -0.3720477, -0.26442383])
-    assert fit.coef == pytest.approx(expected_fit)
-
-
-def test_astm_e1036_est_isc_voc(v_array, i_array):
-    '''
-    Test the case in which Isc and Voc estimates are
-    valid without a linear fit
-    '''
-    v = v_array
-    i = i_array
-    v = np.append(v, [0.001, 0.6201])
-    i = np.append(i, [8.09397560e+00, 7.10653445e-04])
-    result = astm_e1036(v, i)
-    expected = {'voc': 0.6201,
-                'isc': 8.093975598317805,
-                'vmp': 0.494283417170082,
-                'imp': 7.626088301548568,
-                'pmp': 3.7694489853302127,
-                'ff': 0.751024747526615}
-    result.pop('mp_fit')
-    assert result == pytest.approx(expected)
-
-
-def test_astm_e1036_mpfit_limits(v_array, i_array):
-    result = astm_e1036(v_array,
-                        i_array,
-                        imax_limits=(0.85, 1.1),
-                        vmax_limits=(0.85, 1.1))
-    expected = {'voc': 0.6195097477985162,
-                'isc': 8.093986320386227,
-                'vmp': 0.49464214190725303,
-                'imp': 7.620032530519718,
-                'pmp': 3.769189212299219,
-                'ff': 0.7516875014460312}
-    result.pop('mp_fit')
-    assert result == pytest.approx(expected)
-
-
-def test_astm_e1036_fit_points(v_array, i_array):
-    i = i_array
-    i[3] = 8.1  # ensure an interesting change happens
-    result = astm_e1036(v_array, i, voc_points=4, isc_points=4)
-    expected = {'voc': 0.619337073271274,
-                'isc': 8.093160893325297,
-                'vmp': 0.494283417170082,
-                'imp': 7.626088301548568,
-                'pmp': 3.7694489853302127,
-                'ff': 0.7520255886236707}
-    result.pop('mp_fit')
-    assert result == pytest.approx(expected)

pvlib/tests/spectrum/conftest.py

@@ -1,40 +0,0 @@
-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