ENH: add methods and tests for a explicit IV curve calculation of single-diode model #409
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -20,6 +20,10 @@ | |
| from pvlib.tools import _build_kwargs | ||
| from pvlib.location import Location | ||
| from pvlib import irradiance, atmosphere | ||
| from pvlib import way_faster | ||
|
There was a problem hiding this comment. Not a fan of this module name. Way faster what exactly? There was a problem hiding this comment. ✔️ changed it to |
||
|
|
||
| bishop88 = way_faster.bishop88 | ||
| est_voc = way_faster.est_voc | ||
|
There was a problem hiding this comment. For this use case, I view this more as an upper bound on Voc, rather than an estimate. |
||
|
|
||
|
|
||
| # not sure if this belongs in the pvsystem module. | ||
|
|
@@ -1571,7 +1575,7 @@ def sapm_effective_irradiance(poa_direct, poa_diffuse, airmass_absolute, aoi, | |
|
|
||
|
|
||
| def singlediode(photocurrent, saturation_current, resistance_series, | ||
| resistance_shunt, nNsVth, ivcurve_pnts=None, method=''): | ||
|
There was a problem hiding this comment. I think the default method should be given a unique name. Something like 'gold' or 'robust' (which then refer to a particular method), or perhaps just the name of the default method. This method could change in the future. There was a problem hiding this comment. ✔️ change it to "gold" but anything that is not "fast" or "lambertw" will be run using the default |
||
| r''' | ||
|
There was a problem hiding this comment. @mikofski can you confirm that the equation still renders properly? If I remember correctly, I added r to some of the doc strings at one point because it was necessary for the equations to render properly. There was a problem hiding this comment. yes, rendered okay for me - I read somewhere that you can avoid using
There was a problem hiding this comment. Thanks for the check. That sounds familiar. Maybe I added "r" in a few places because I thought it was easier to do than escape the backslashes. One could argue that it improves readability too, but let's not fret over it. |
||
| Solve the single-diode model to obtain a photovoltaic IV curve. | ||
|
|
||
|
|
@@ -1627,6 +1631,13 @@ def singlediode(photocurrent, saturation_current, resistance_series, | |
| Number of points in the desired IV curve. If None or 0, no | ||
| IV curves will be produced. | ||
|
|
||
| method : str, default '' | ||
|
There was a problem hiding this comment. In ivcurve_pnts above this line, we should specify that the points are between Isc and Voc, inclusive, and linear-spaced (or log-spaced, see further comments). |
||
| Determines the method used to calculate IV curve and points. If | ||
|
There was a problem hiding this comment. 'calculate points on the IV curve' |
||
| 'lambertw' then ``lambertw`` is used. If 'fast' then ``newton`` is | ||
| used. Otherwise the problem is bounded between zero and open-circuit | ||
| voltage and a bisection method, ``brentq``, is used, that guarantees | ||
| convergence. | ||
|
|
||
| Returns | ||
| ------- | ||
| OrderedDict or DataFrame | ||
|
|
@@ -1655,9 +1666,48 @@ def singlediode(photocurrent, saturation_current, resistance_series, | |
|
|
||
| Notes | ||
| ----- | ||
| The default method employed is an explicit solution using [4] to find an | ||
|
There was a problem hiding this comment. More editing. Move this description of The |
||
| arbitrary point on the IV curve as a function of the diode voltage | ||
| :math:`V_d = V + I*Rs`. Then the voltage is backed out from :math:`V_d`. | ||
| A specific desired point, such as short circuit current or max power, is | ||
| located using the bisection search method, ``brentq``, bounded by a zero | ||
| diode voltage and an estimate of open circuit voltage given by | ||
|
|
||
| .. math:: | ||
|
|
||
| V_{oc, est} = n Ns V_{th} \log \left( \frac{I_L}{I_0} + 1 \right) | ||
|
|
||
| We know that :math:`V_d = 0` corresponds to a voltage less than zero, and | ||
| we can also show that when :math:`V_d = V_{oc, est}`, the resulting | ||
| current is also negative, meaning that the corresponding voltage must be | ||
| in the 4th quadrant and therefore greater than the open circuit voltage | ||
| (see proof below). Therefore the entire forward-bias 1st quadrant IV-curve | ||
| is bounded, and a bisection search within these points will always find | ||
| desired condition. | ||
|
|
||
| .. math:: | ||
|
|
||
| I = I_L - I_0 \left( \exp \left( \frac{V_{oc, est} }{ n Ns V_{th} } \right) - 1 \right) - \frac{V_{oc, est}}{R_{sh}} \\ | ||
| I = I_L - I_0 \left(\exp \left( \frac{ n Ns V_{th} \log \left( \frac{I_L}{I_0} + 1 \right) }{ n Ns V_{th} } \right) - 1 \right) - \frac{n Ns V_{th} \log \left( \frac{I_L}{I_0} + 1\right)}{R_{sh}} \\ | ||
| I = I_L - I_0 \left(\exp \left( \log \left( \frac{I_L}{I_0} + 1 \right) \right) - 1 \right) - \frac{n Ns V_{th} \log \left( \frac{I_L}{I_0} + 1\right)}{R_{sh}} \\ | ||
| I = I_L - I_0 \left(\frac{I_L}{I_0} + 1 - 1 \right) - \frac{n Ns V_{th} \log \left( \frac{I_L}{I_0} + 1\right)}{R_{sh}} \\ | ||
| I = I_L - I_0 \left(\frac{I_L}{I_0} \right) - \frac{n Ns V_{th} \log \left( \frac{I_L}{I_0} + 1\right)}{R_{sh}} \\ | ||
| I = I_L - I_L - \frac{n Ns V_{th} \log \left( \frac{I_L}{I_0} + 1\right)}{R_{sh}} \\ | ||
| I = - \frac{n Ns V_{th} \log \left( \frac{I_L}{I_0} + 1\right)}{R_{sh}} | ||
|
|
||
| If ``method.lower() == 'fast'`` then a gradient descent method, ``newton``, | ||
| is used to solve the implicit diode equation. It should be safe for well | ||
| behaved IV-curves, but the default method is recommended for reliability, | ||
| it is often just as fast. | ||
|
|
||
| If either the "fast" or default methods are indicated, then | ||
| :func:`pvlib.pvsystem.bishop88` is used to calculate the points at diode | ||
| voltages from zero to open-circuit voltage with a log spacing so that | ||
|
There was a problem hiding this comment. Consider making it an option spacing='log' (with default spacing='linear'), or at the very least call it out this change in Equal spacing by arc length would be another cool option to explore later! |
||
| points get closer as they approach the open-circuit voltage. | ||
|
|
||
| If ``method.lower() == 'lambertw'`` then the solution employed to solve the | ||
|
There was a problem hiding this comment.
There was a problem hiding this comment.
|
||
| implicit diode equation utilizes the Lambert W function to obtain an | ||
| explicit function of V=f(i) and I=f(V) as shown in [2]. | ||
|
|
||
| References | ||
| ----------- | ||
|
|
@@ -1671,63 +1721,145 @@ def singlediode(photocurrent, saturation_current, resistance_series, | |
| [3] D. King et al, "Sandia Photovoltaic Array Performance Model", | ||
| SAND2004-3535, Sandia National Laboratories, Albuquerque, NM | ||
|
|
||
| [4] "Computer simulation of the effects of electrical mismatches in | ||
| photovoltaic cell interconnection circuits" JW Bishop, Solar Cell (1988) | ||
| https://doi.org/10.1016/0379-6787(88)90059-2 | ||
|
|
||
| See also | ||
| -------- | ||
| sapm | ||
| calcparams_desoto | ||
| ''' | ||
|
|
||
| if method.lower() == 'lambertw': | ||
|
There was a problem hiding this comment. this is a lot of lines to read within an if/else... There was a problem hiding this comment. we'll handle this in another PR see #497 There was a problem hiding this comment. ✔️ moved to private function in |
||
| # Compute short circuit current | ||
|
There was a problem hiding this comment. Add a comment block here. |
||
| i_sc = i_from_v(resistance_shunt, resistance_series, nNsVth, 0., | ||
| saturation_current, photocurrent) | ||
|
|
||
| # Compute open circuit voltage | ||
| v_oc = v_from_i(resistance_shunt, resistance_series, nNsVth, 0., | ||
| saturation_current, photocurrent) | ||
|
|
||
| params = {'r_sh': resistance_shunt, | ||
| 'r_s': resistance_series, | ||
| 'nNsVth': nNsVth, | ||
| 'i_0': saturation_current, | ||
| 'i_l': photocurrent} | ||
|
|
||
| p_mp, v_mp = _golden_sect_DataFrame(params, 0., v_oc * 1.14, _pwr_optfcn) | ||
|
|
||
| # Invert the Power-Current curve. Find the current where the inverted power | ||
| # is minimized. This is i_mp. Start the optimization at v_oc/2 | ||
| i_mp = i_from_v(resistance_shunt, resistance_series, nNsVth, v_mp, | ||
| saturation_current, photocurrent) | ||
|
|
||
| # Find Ix and Ixx using Lambert W | ||
| i_x = i_from_v(resistance_shunt, resistance_series, nNsVth, 0.5 * v_oc, | ||
| saturation_current, photocurrent) | ||
|
|
||
| i_xx = i_from_v(resistance_shunt, resistance_series, nNsVth, | ||
| 0.5 * (v_oc + v_mp), saturation_current, photocurrent) | ||
|
|
||
| out = OrderedDict() | ||
| out['i_sc'] = i_sc | ||
| out['v_oc'] = v_oc | ||
| out['i_mp'] = i_mp | ||
| out['v_mp'] = v_mp | ||
| out['p_mp'] = p_mp | ||
| out['i_x'] = i_x | ||
| out['i_xx'] = i_xx | ||
|
|
||
| # create ivcurve | ||
| if ivcurve_pnts: | ||
| ivcurve_v = (np.asarray(v_oc)[..., np.newaxis] * | ||
| np.linspace(0, 1, ivcurve_pnts)) | ||
|
|
||
| ivcurve_i = i_from_v(resistance_shunt, resistance_series, nNsVth, | ||
| ivcurve_v.T, saturation_current, photocurrent).T | ||
|
There was a problem hiding this comment. Not a problem from this PR, but I wish this expression and the previous were commented a bit better, esp. w.r.t. array manipulations and resulting dimensions. |
||
|
|
||
| out['v'] = ivcurve_v | ||
| out['i'] = ivcurve_i | ||
|
|
||
| if isinstance(photocurrent, pd.Series) and not ivcurve_pnts: | ||
| out = pd.DataFrame(out, index=photocurrent.index) | ||
|
|
||
| else: | ||
| if method.lower() == 'fast': | ||
| sdm_fun = way_faster.faster_way | ||
|
There was a problem hiding this comment. Perhaps module name and function names should be made more representative of methods employed instead of relative performance to current implementation. |
||
| else: | ||
| sdm_fun = way_faster.slower_way | ||
| try: | ||
| len(photocurrent) | ||
| except TypeError: | ||
| out = sdm_fun( | ||
| photocurrent, saturation_current, resistance_series, | ||
| resistance_shunt, nNsVth, ivcurve_pnts | ||
| ) | ||
| else: | ||
| vecfun = np.vectorize(sdm_fun) | ||
|
There was a problem hiding this comment. Perhaps numba can work wonders here in a followup. |
||
| out = vecfun(photocurrent, saturation_current, resistance_series, | ||
| resistance_shunt, nNsVth, ivcurve_pnts) | ||
| if isinstance(photocurrent, pd.Series) and not ivcurve_pnts: | ||
| out = pd.DataFrame(out.tolist(), index=photocurrent.index) | ||
| else: | ||
| out_array = pd.DataFrame(out.tolist()) | ||
| out = OrderedDict() | ||
| out['i_sc'] = out_array.i_sc.values | ||
| out['v_oc'] = out_array.v_oc.values | ||
| out['i_mp'] = out_array.i_mp.values | ||
| out['v_mp'] = out_array.v_mp.values | ||
| out['p_mp'] = out_array.p_mp.values | ||
| out['i_x'] = out_array.i_x.values | ||
| out['i_xx'] = out_array.i_xx.values | ||
| if ivcurve_pnts: | ||
| out['i'] = np.vstack(out_array.i.values) | ||
| out['v'] = np.vstack(out_array.v.values) | ||
| out['p'] = np.vstack(out_array.p.values) | ||
| return out | ||
|
|
||
|
|
||
| def mppt(photocurrent, saturation_current, resistance_series, resistance_shunt, | ||
| nNsVth, method=''): | ||
| """ | ||
| Max power point tracker. Given the calculated DeSoto parameters calculates | ||
| the maximum power point (MPP). | ||
|
|
||
| :param numeric photocurrent: photo-generated current [A] | ||
| :param numeric saturation_current: diode one reverse saturation current [A] | ||
| :param numeric resistance_series: series resitance [ohms] | ||
| :param numeric resistance_shunt: shunt resitance [ohms] | ||
| :param numeric nNsVth: product of thermal voltage ``Vth`` [V], diode | ||
| :param str method: if "fast" then use Newton, otherwise use bisection | ||
| :returns: ``OrderedDict`` or ``pandas.Datafrane`` with ``i_mp``, ``v_mp``, | ||
| and ``p_mp`` | ||
| """ | ||
| if method.lower() == 'fast': | ||
| mppt_func = way_faster.fast_mppt | ||
| else: | ||
| mppt_func = way_faster.slow_mppt | ||
| try: | ||
| len(photocurrent) | ||
| except TypeError: | ||
| i_mp, v_mp, p_mp = mppt_func( | ||
| photocurrent, saturation_current, resistance_series, | ||
| resistance_shunt, nNsVth | ||
| ) | ||
| out = OrderedDict() | ||
| out['i_mp'] = i_mp | ||
| out['v_mp'] = v_mp | ||
| out['p_mp'] = p_mp | ||
| else: | ||
| vecfun = np.vectorize(mppt_func) | ||
| ivp = vecfun(photocurrent, saturation_current, resistance_series, | ||
| resistance_shunt, nNsVth) | ||
| if isinstance(photocurrent, pd.Series): | ||
| ivp = {k: v for k, v in zip(('i_mp', 'v_mp', 'p_mp'), ivp)} | ||
| out = pd.DataFrame(ivp, index=photocurrent.index) | ||
| else: | ||
| out = OrderedDict() | ||
| out['i_mp'] = ivp[0] | ||
| out['v_mp'] = ivp[1] | ||
| out['p_mp'] = ivp[2] | ||
| return out | ||
|
|
||
|
|
||
|
|
||
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
descent (but also decent!)
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
✔️