tests for the two additional functions

Author: kandersolar

pvlib/ivtools/sdm/__init__.py

@@ -4,17 +4,14 @@
  fitting method.
 """
 
-from pvlib.ivtools.sdm.batzelis import (  # noqa: F401
-    fit_desoto_batzelis,
-)
-
 from pvlib.ivtools.sdm.cec import (  # noqa: F401
     fit_cec_sam,
 )
 
 from pvlib.ivtools.sdm.desoto import (  # noqa: F401
     fit_desoto,
-    fit_desoto_sandia
+    fit_desoto_batzelis,
+    fit_desoto_sandia,
 )
 
 from pvlib.ivtools.sdm.pvsyst import (  # noqa: F401

pvlib/ivtools/sdm/batzelis.py

@@ -2,6 +2,7 @@
 
 from scipy import constants
 from scipy import optimize
+from scipy.special import lambertw
 
 from pvlib.ivtools.utils import rectify_iv_curve
 from pvlib.ivtools.sde import _fit_sandia_cocontent
@@ -399,3 +400,64 @@ def _fit_desoto_sandia_diode(ee, voc, vth, tc, specs, const):
     new_x = sm.add_constant(x)
     res = sm.RLM(y, new_x).fit()
     return np.array(res.params)[1]
+
+
+def fit_desoto_batzelis(isc0, voc0, imp0, vmp0, alpha_sc, beta_voc):
+    """
+    Determine De Soto single-diode model parameters from datasheet values
+    using Batzelis's method.
+
+    This method is described in Section II.C of [1]_.
+
+    Parameters
+    ----------
+    isc0 : float
+        Short-circuit current at STC. [A]
+    voc0 : float
+        Open-circuit voltage at STC. [V]
+    imp0 : float
+        Maximum power point current at STC. [A]
+    vmp0 : float
+        Maximum power point voltage at STC. [V]
+    alpha_sc : float
+        Short-circuit current temperature coefficient at STC. [1/K]
+    beta_voc : float
+        Open-circuit voltage temperature coefficient at STC. [1/K]    
+
+    Returns
+    -------
+    dict
+        The returned dict contains the keys:
+
+        * ``alpha_sc`` [A/K]
+        * ``a_ref`` [V]
+        * ``I_L_ref`` [A]
+        * ``I_o_ref`` [A]
+        * ``R_sh_ref`` [Ohm]
+        * ``R_s`` [Ohm]
+
+    References
+    ----------
+    .. [1] E. I. Batzelis, "Simple PV Performance Equations Theoretically Well
+       Founded on the Single-Diode Model," Journal of Photovoltaics vol. 7,
+       no. 5, pp. 1400-1409, Sep 2017, :doi:`10.1109/JPHOTOV.2017.2711431`
+    """
+    t0 = 298.15  # K
+    del0 = (1 - beta_voc * t0) / (50.1 - alpha_sc * t0)  # Eq 9
+    w0 = np.real(lambertw(np.exp(1/del0 + 1)))
+
+    # Eqs 11-15
+    a0 = del0 * voc0
+    Rs0 = (a0 * (w0 - 1) - vmp0) / imp0
+    Rsh0 = a0 * (w0 - 1) / (isc0 * (1 - 1/w0) - imp0)
+    Iph0 = (1 + Rs0 / Rsh0) * isc0
+    Isat0 = Iph0 * np.exp(-1/del0)
+
+    return {
+        'alpha_sc': alpha_sc * isc0,  # convert 1/K to A/K
+        'a_ref': a0,
+        'I_L_ref': Iph0,
+        'I_o_ref': Isat0,
+        'R_sh_ref': Rsh0,
+        'R_s': Rs0,
+    }

pvlib/ivtools/sdm/desoto.py

@@ -9,6 +9,7 @@
 """
 
 import numpy as np
+import pandas as pd
 from scipy.optimize import curve_fit
 from scipy.special import exp10, lambertw
 
@@ -482,7 +483,7 @@ def batzelis(effective_irradiance, temp_cell,
 
     # Eq 9-10
     del0 = (1 - beta_voc * t0) / (50.1 - alpha_sc * t0)
-    w0 = lambertw(np.exp(1/del0 + 1)).real
+    w0 = np.real(lambertw(np.exp(1/del0 + 1)))
 
     # Eqs 27-28
     alpha_imp = alpha_sc + (beta_voc - 1/t0) / (w0 - 1)
@@ -505,11 +506,20 @@ def batzelis(effective_irradiance, temp_cell,
     vmp = np.clip(vmp, a_min=0, a_max=None)
     voc = np.clip(voc, a_min=0, a_max=None)
 
-    # TODO return dataframe for is_pandas
-    return {
+    out = {
         'p_mp': vmp * imp,
         'i_mp': imp,
         'v_mp': vmp,
         'i_sc': isc,
         'v_oc': voc,
     }
+
+    # if pandas in, ensure pandas out
+    pandas_inputs = [
+        x for x in [effective_irradiance, temp_cell]
+        if isinstance(x, pd.Series)
+    ]
+    if pandas_inputs:
+        out = pd.DataFrame(out, index=pandas_inputs[0].index)
+
+    return out

pvlib/pvarray.py

@@ -3,6 +3,7 @@
 """
 
 import numpy as np
+import pandas as pd
 from pvlib.tools import _golden_sect_DataFrame
 
 from scipy.optimize import brentq, newton
@@ -866,8 +867,8 @@ def _pwr_optfcn(df, loc):
 def batzelis_keypoints(photocurrent, saturation_current, resistance_series,
                        resistance_shunt, nNsVth):
     """
-    Estimate maximum power, open-circuit, and short-circuit values
-    using Batzelis's method.
+    Estimate maximum power, open-circuit, and short-circuit points from
+    single-diode equation parameters using Batzelis's method.
 
     This method is described in Section II.B of [1]_.
 
@@ -916,18 +917,34 @@ def batzelis_keypoints(photocurrent, saturation_current, resistance_series,
 
     # Eqs 3-4
     isc = Iph * Rsh / (Rs + Rsh)
-    voc = a * np.log(Iph / Is)
+    with np.errstate(divide='ignore'):  # zero Iph
+        voc = a * np.log(Iph / Is)
 
     # Eqs 5-8
-    w = lambertw(np.e * Iph / Is).real
+    w = np.real(lambertw(np.e * Iph / Is))
     #vmp = (1 + Rs/Rsh) * a * (w - 1) - Rs * Iph * (1 - 1/w)  # not needed
-    imp = Iph * (1 - 1/w) - a * (w - 1) / Rsh
+    with np.errstate(divide='ignore', invalid='ignore'):  # zero Iph -> zero w
+        imp = Iph * (1 - 1/w) - a * (w - 1) / Rsh
+
     vmp = a * (w - 1) - Rs * imp
 
-    return {
+    vmp = np.where(Iph > 0, vmp, 0)
+    voc = np.where(Iph > 0, voc, 0)
+    imp = np.where(Iph > 0, imp, 0)
+    isc = np.where(Iph > 0, isc, 0)
+
+    out = {
         'p_mp': imp * vmp,
         'i_mp': imp,
         'v_mp': vmp,
         'i_sc': isc,
         'v_oc': voc,
     }
+
+    # if pandas in, ensure pandas out
+    pandas_inputs = [
+        x for x in [Iph, Is, Rsh, Rs, a] if isinstance(x, pd.Series)]
+    if pandas_inputs:
+        out = pd.DataFrame(out, index=pandas_inputs[0].index)
+
+    return out

pvlib/singlediode.py

@@ -92,3 +92,28 @@ def test_fit_desoto_sandia(cec_params_cansol_cs5p_220p):
     assert_allclose(result['dEgdT'], -0.0002677)
     assert_allclose(result['EgRef'], 1.3112547292120638)
     assert_allclose(result['cells_in_series'], specs['cells_in_series'])
+
+
+def test_fit_desoto_batzelis():
+    params = {'isc0': 15.98, 'voc0': 50.26, 'imp0': 15.27, 'vmp0': 42.57,
+              'alpha_sc': 0.00046, 'beta_voc': -0.0024}
+    expected = {  # calculated with the function itself
+        'alpha_sc': 0.0073508,
+        'a_ref': 1.7257631194825132,
+        'I_L_ref': 15.985408869737098,
+        'I_o_ref': 3.594300567343102e-12,
+        'R_sh_ref': 389.4378389153357,
+        'R_s': 0.1318159287478395
+    }
+    out = sdm.fit_desoto_batzelis(**params)
+    for k in expected:
+        assert out[k] == pytest.approx(expected[k])
+
+    # ensure the STC values are reproduced
+    iv = pvsystem.singlediode(out['I_L_ref'], out['I_o_ref'], out['R_s'],
+                              out['R_sh_ref'], out['a_ref'])
+    assert iv['i_sc'] == pytest.approx(params['isc0'])
+    assert iv['i_mp'] == pytest.approx(params['imp0'], rel=3e-3)
+    assert iv['v_oc'] == pytest.approx(params['voc0'], rel=3e-4)
+    assert iv['v_mp'] == pytest.approx(params['vmp0'], rel=4e-3)
+    

tests/ivtools/sdm/test_desoto.py

@@ -137,8 +137,9 @@ def test_batzelis():
 
     # pandas series
     actual = pvarray.batzelis(pd.Series(g), pd.Series(t), **params)
+    assert isinstance(actual, pd.DataFrame)
     for key, exp in expected.items():
-        pd.testing.assert_series_equal(actual[key], pd.Series(exp), atol=1e-3)
+        np.testing.assert_allclose(actual[key], pd.Series(exp), atol=1e-3)
 
     # scalar
     actual = pvarray.batzelis(g[1], t[1], **params)

tests/test_pvarray.py

@@ -7,7 +7,8 @@
 import scipy
 from pvlib import pvsystem
 from pvlib.singlediode import (bishop88_mpp, estimate_voc, VOLTAGE_BUILTIN,
-                               bishop88, bishop88_i_from_v, bishop88_v_from_i)
+                               bishop88, bishop88_i_from_v, bishop88_v_from_i,
+                               batzelis_keypoints)
 import pytest
 from numpy.testing import assert_array_equal
 from .conftest import TESTS_DATA_DIR
@@ -600,9 +601,52 @@ def test_bishop88_init_cond(method):
                                      NsVbi=NsVbi))
     bad_results = np.isnan(vmp2) | (vmp2 < 0) | (err > 0.00001)
     assert not bad_results.any()
-    # test v_from_i
+    # test i_from_v
     imp2 = bishop88_i_from_v(vmp, *sde_params, d2mutau=d2mutau, NsVbi=NsVbi)
     err = np.abs(_sde_check_solution(imp2, vmp, *sde_params, d2mutau=d2mutau,
                                      NsVbi=NsVbi))
     bad_results = np.isnan(imp2) | (imp2 < 0) | (err > 0.00001)
     assert not bad_results.any()
+
+
+def test_batzelis_keypoints():
+    params = {'photocurrent': 10, 'saturation_current': 1e-10,
+              'resistance_series': 0.2, 'resistance_shunt': 3000,
+              'nNsVth': 1.7}
+    
+    exact_values = {  # calculated using pvlib.pvsystem.singlediode
+        'i_sc': 9.999333377550565,
+        'v_oc': 43.05589965219406,
+        'i_mp': 9.513255314772051,
+        'v_mp': 35.97259289596944,
+        'p_mp': 342.21646055371264,
+    }
+    rtol = 5e-3  # accurate to within half a percent in this case
+
+    output = batzelis_keypoints(**params)
+    for key in exact_values:
+        assert output[key] == pytest.approx(exact_values[key], rel=rtol)
+
+    # numpy arrays
+    params2 = {k: np.array([v] * 2) for k, v in params.items()}
+    output2 = batzelis_keypoints(**params2)
+    for key in exact_values:
+        exp = np.array([exact_values[key]] * 2)
+        np.testing.assert_allclose(output2[key], exp, rtol=rtol)
+
+    # pandas
+    params3 = {k: pd.Series(v) for k, v in params2.items()}
+    output3 = batzelis_keypoints(**params3)
+    assert isinstance(output3, pd.DataFrame)
+    for key in exact_values:
+        exp = pd.Series([exact_values[key]] * 2)
+        np.testing.assert_allclose(output3[key], exp, rtol=rtol)
+
+
+def test_batzelis_keypoints_night():
+    # SDMs produce photocurrent=0 and resistance_shunt=inf at night
+    out = batzelis_keypoints(photocurrent=0, saturation_current=1e-10,
+                             resistance_series=0.2, resistance_shunt=np.inf,
+                             nNsVth=1.7)
+    for k, v in out.items():
+        assert v == 0, k  # ensure all outputs are zero (not nan, etc)