singlediode is slow

[mikofski]

The single diode is taking milliseconds on my mac os x i5, and the i_mp, v_mp, and p_mp are very slightly off from the correct values.

There is another method from "Computer simulation of the effects of electrical mismatches in photovoltaic cell interconnection circuits" JW Bishop, Solar Cell (1988)

When I implement this method, the results are more accurate and about 15x to 30x faster!. Also, the pmp is higher, and cross-checking using pvs_imp = i_from_v(vmp) and vmp = v_from_i(imp) shows that the faster method is actually more accurate and still consistent with the old method.

Here are results from test_way_faster.py that compares values using assertions and also measures speed in just one loop:

In [1]: %run pvlib/test/test_way_faster.py
DEBUG:__main__:single diode elapsed time = 0.108363[s]
DEBUG:__main__:way faster elapsed time = 0.000411[s]
DEBUG:__main__:spr_e20_327 speedup = 263.657             <-- first one is much slower :(
DEBUG:__main__:single diode elapsed time = 0.007208[s]
DEBUG:__main__:way faster elapsed time = 0.000314[s]
DEBUG:__main__:fs_495 speedup = 22.9554

In [2]: %run pvlib/test/test_way_faster.py
DEBUG:__main__:single diode elapsed time = 0.00827[s]
DEBUG:__main__:way faster elapsed time = 0.000384[s]
DEBUG:__main__:spr_e20_327 speedup = 21.5365
DEBUG:__main__:single diode elapsed time = 0.008368[s]
DEBUG:__main__:way faster elapsed time = 0.000252[s]
DEBUG:__main__:fs_495 speedup = 33.2063

In [3]: %run pvlib/test/test_way_faster.py
DEBUG:__main__:single diode elapsed time = 0.006553[s]
DEBUG:__main__:way faster elapsed time = 0.000386[s]
DEBUG:__main__:spr_e20_327 speedup = 16.9767
DEBUG:__main__:single diode elapsed time = 0.00638[s]
DEBUG:__main__:way faster elapsed time = 0.000386[s]
DEBUG:__main__:fs_495 speedup = 16.5285

In [4]: %run pvlib/test/test_way_faster.py
DEBUG:__main__:single diode elapsed time = 0.006512[s]
DEBUG:__main__:way faster elapsed time = 0.000348[s]
DEBUG:__main__:spr_e20_327 speedup = 18.7126
DEBUG:__main__:single diode elapsed time = 0.010524[s]
DEBUG:__main__:way faster elapsed time = 0.000345[s]
DEBUG:__main__:fs_495 speedup = 30.5043

In [5]: %run pvlib/test/test_way_faster.py
DEBUG:__main__:single diode elapsed time = 0.00794[s]
DEBUG:__main__:way faster elapsed time = 0.0003[s]
DEBUG:__main__:spr_e20_327 speedup = 26.4667
DEBUG:__main__:single diode elapsed time = 0.007225[s]
DEBUG:__main__:way faster elapsed time = 0.000256[s]
DEBUG:__main__:fs_495 speedup = 28.2227

[wholmgren]

@mikofski this post documents the speed ups but not the accuracy issues. Can you document the accuracy issues here for posterity? No one is going to be able to follow the discussion in #409 in the future. Thanks.

[mikofski]

CORRECTION The values for imp, vmp, and pmp are not slightly off. The method that is being tested is using a higher convergence criteria, and so it is finding a different MPP that is very, very slightly greater, and most likely below the uncertainty. Back checking the slightly different MPP values into the existing method by calling i_from_v and v_from_i demonstrate that the existing method and the new method being tested agree.

spr-e20-327

# run the test
>>> %run pvlib/test/test_way_faster.py

>>> r_spr_e20_327  # test results with way faster 1st and lambert-w 2nd
(5.8575945831511333,
 57.779106188588912,
 5.3759693335701924,
 47.463952341550574,
 255.164752238213,
 OrderedDict([('i_sc', 5.857594583158265),
              ('v_oc', 57.779106188588685),
              ('i_mp', 5.374898118822274),
              ('v_mp', 47.473396494199655),
              ('p_mp', 255.16466951077766),
              ('i_x', 5.770970666689348),
              ('i_xx', 4.048918484984828)]))

# calculate relative difference in percent
>>> (np.array(r_spr_e20_327[:5]) - np.array(list(r_spr_e20_327[5].values())[:5])) / np.array(r_spr_e20_327[:5]) * 100
# the relative differences:
array([ -1.21757705e-10,  <-- Isc
   3.93522314e-13,  <-- Voc
   1.99259832e-02,  <-- Imp
  -1.98975268e-02,  <-- Vmp
   3.24211846e-05])  <-- Pmp

So there is a 0.02% difference for both Imp and Vmp which results in a 0.00003% difference in power. How do we know that the Bishop method is correct? If we then take the calculated Imp and Vmp and run it back through the existing i_from_v(vmp_bishop) and v_from_i(imp_bishop), then we get agreement. Although this difference is very, very small, it will not pass the test criteria, typ. 1E-5, so I have to use np.isclose(i_from_v(vmp), imp and np.isclose(v_from_i(imp), vmp to compare them to bishop88. But this difference does not indicate an error in the existing method, it is an artifact of the different convergence criteria.

fs_495

>>> r_fs_495  # contains test results
(1.4020527838184862,
 75.417048551820244,
 1.2599303890145119,
 57.709609195857304,
 72.710090364011947,
...,  # big array of i-v curve points
 OrderedDict([('i_sc', 1.4020527838304147),
              ('v_oc', 75.41704855182024),
              ('i_mp', 1.2599626119945482),
              ('v_mp', 57.708133027723818),
              ('p_mp', 72.710090022939752),
              ('i_x', 1.3606253515830833),
              ('i_xx', 0.8340096657730403),
...,  # big array of i-v curve points
)

# calculate relative differences
>>> (np.array(r_fs_495[:5]) - np.array(list(r_fs_495[8].values())[:5])) / np.array(r_fs_495[:5]) * 100
Out[27]:
array([ -8.50785246e-10,
   0.00000000e+00,
  -2.55752066e-03,
   2.55792433e-03,
   4.69085092e-07])

So again super small deltas, only 0.003% for both Imp and Vmp, and 0.0000005% for power, but these differences are still bigger than the tolerance to pass the test, so I have to use the existing i_from_v and v_from_i methods to compare them, which is good, because getting agreement there proves that the points are on both curves, and that the curves from both methods agree.

Therefore the existing method is not wrong, because it does get points from the I-V curve, it's just that the ones it finds are not as close to the max power point because the convergence tolerance is lower, and actually more reasonable given the uncertainty.

[mikofski]

FYI: I believe SciPy PR 8357 has satisfied all of the reviewers comments, and is hopefully about to be merged. If you are still interested, now might be a good time to show your support for a vectorized Newton method.