MAINT: rename singlediode_methods.py to just singlediode.py

* closes pvlib#515
* import pvlib in pvsystem and use pvlib.singlediode to differentiate
from existing pvsystem.singldiode() method already there!
* rename test_singlediode_methods.py to test_singlediode.py
* update documentation and comments

Author: mikofski

docs/sphinx/source/api.rst

@@ -213,11 +213,11 @@ Low-level functions for solving the single diode equation.
 .. autosummary::
    :toctree: generated/
 
-   singlediode_methods.estimate_voc
-   singlediode_methods.bishop88
-   singlediode_methods.bishop88_i_from_v
-   singlediode_methods.bishop88_v_from_i
-   singlediode_methods.bishop88_mpp
+   singlediode.estimate_voc
+   singlediode.bishop88
+   singlediode.bishop88_i_from_v
+   singlediode.bishop88_v_from_i
+   singlediode.bishop88_mpp
 
 SAPM model
 ----------

docs/sphinx/source/whatsnew/v0.6.0.rst

@@ -32,32 +32,32 @@ Enhancements
   ``method`` in ``('lambertw', 'newton', 'brentq')``, default is ``'lambertw'``,
   to select a method to solve the single diode equation for points on the IV
   curve. Selecting either ``'brentq'`` or ``'newton'`` as the method uses
-  :func:`~pvlib.singlediode_methods.bishop88` with the corresponding method.
+  :func:`~pvlib.singlediode.bishop88` with the corresponding method.
   (:issue:`410`)
 * Implement new methods ``'brentq'`` and ``'newton'`` for solving the single
   diode equation for points on the IV curve. ``'brentq'`` uses a bisection
   method (Brent, 1973) that may be slow but guarantees a solution. ``'newton'``
   uses the Newton-Raphson method and may be faster but is not guaranteed to
   converge. However, ``'newton'`` should be safe for well-behaved IV curves.
   (:issue:`408`)
-* Implement :func:`~pvlib.singlediode_methods.bishop88` for explicit calculation
+* Implement :func:`~pvlib.singlediode.bishop88` for explicit calculation
   of arbitrary IV curve points using diode voltage instead of cell voltage. If
   ``method`` is either ``'newton'`` or ``'brentq'`` and ``ivcurve_pnts`` in
   :func:`~pvlib.pvsystem.singlediode` is provided, the IV curve points will be
   log spaced instead of linear.
-* Implement :func:`~pvlib.singlediode_methods.estimate_voc` to estimate open
+* Implement :func:`~pvlib.singlediode.estimate_voc` to estimate open
   circuit voltage by assuming :math:`R_{sh} \to \infty` and :math:`R_s=0` as an
   upper bound in bisection method for :func:`~pvlib.pvsystem.singlediode` when
   method is either ``'newton'`` or ``'brentq'``.
 * Add :func:`~pvlib.pvsystem.max_power_point` method to compute the max power
   point using the new ``'brentq'`` method.
-* Add new module ``pvlib.singlediode_methods`` with low-level functions for
+* Add new module ``pvlib.singlediode`` with low-level functions for
   solving the single diode equation such as:
-  :func:`~pvlib.singlediode_methods.bishop88`,
-  :func:`~pvlib.singlediode_methods.estimate_voc`,
-  :func:`~pvlib.singlediode_methods.bishop88_i_from_v`,
-  :func:`~pvlib.singlediode_methods.bishop88_v_from_i`, and
-  :func:`~pvlib.singlediode_methods.bishop88_mpp`.
+  :func:`~pvlib.singlediode.bishop88`,
+  :func:`~pvlib.singlediode.estimate_voc`,
+  :func:`~pvlib.singlediode.bishop88_i_from_v`,
+  :func:`~pvlib.singlediode.bishop88_v_from_i`, and
+  :func:`~pvlib.singlediode.bishop88_mpp`.
 * Add PVSyst thin-film recombination losses for CdTe and a:Si (:issue:`163`)
 * Python 3.7 officially supported. (:issue:`496`)
 

pvlib/__init__.py

@@ -11,4 +11,4 @@
 from pvlib import pvsystem
 from pvlib import spa
 from pvlib import modelchain
-from pvlib import singlediode_methods
+from pvlib import singlediode

pvlib/pvsystem.py

@@ -20,7 +20,7 @@
 from pvlib.tools import _build_kwargs
 from pvlib.location import Location
 from pvlib import irradiance, atmosphere
-from pvlib import singlediode_methods
+import pvlib  # FIXME: import singlediode module from pvlib
 
 
 # not sure if this belongs in the pvsystem module.
@@ -1963,7 +1963,7 @@ def singlediode(photocurrent, saturation_current, resistance_series,
     open-circuit.
 
     If the method is either ``'newton'`` or ``'brentq'`` and ``ivcurve_pnts``
-    are indicated, then :func:`pvlib.singlediode_methods.bishop88` is used to
+    are indicated, then :func:`pvlib.singlediode.bishop88` is used to
     calculate the points on the IV curve points at diode voltages from zero to
     open-circuit voltage with a log spacing that gets closer as voltage
     increases. If the method is ``'lambertw'`` then the calculated points on
@@ -2029,12 +2029,12 @@ def singlediode(photocurrent, saturation_current, resistance_series,
     --------
     sapm
     calcparams_desoto
-    pvlib.singlediode_methods.bishop88
+    pvlib.singlediode.bishop88
     """
     # Calculate points on the IV curve using the LambertW solution to the
     # single diode equation
     if method.lower() == 'lambertw':
-        out = singlediode_methods._lambertw(
+        out = pvlib.singlediode._lambertw(
             photocurrent, saturation_current, resistance_series,
             resistance_shunt, nNsVth, ivcurve_pnts
         )
@@ -2047,19 +2047,19 @@ def singlediode(photocurrent, saturation_current, resistance_series,
         # equation for the diode voltage V_d then backing out voltage
         args = (photocurrent, saturation_current, resistance_series,
                 resistance_shunt, nNsVth)  # collect args
-        v_oc = singlediode_methods.bishop88_v_from_i(
+        v_oc = pvlib.singlediode.bishop88_v_from_i(
             0.0, *args, method=method.lower()
         )
-        i_mp, v_mp, p_mp = singlediode_methods.bishop88_mpp(
+        i_mp, v_mp, p_mp = pvlib.singlediode.bishop88_mpp(
             *args, method=method.lower()
         )
-        i_sc = singlediode_methods.bishop88_i_from_v(
+        i_sc = pvlib.singlediode.bishop88_i_from_v(
             0.0, *args, method=method.lower()
         )
-        i_x = singlediode_methods.bishop88_i_from_v(
+        i_x = pvlib.singlediode.bishop88_i_from_v(
             v_oc / 2.0, *args, method=method.lower()
         )
-        i_xx = singlediode_methods.bishop88_i_from_v(
+        i_xx = pvlib.singlediode.bishop88_i_from_v(
             (v_oc + v_mp) / 2.0, *args, method=method.lower()
         )
 
@@ -2069,7 +2069,7 @@ def singlediode(photocurrent, saturation_current, resistance_series,
                     (11.0 - np.logspace(np.log10(11.0), 0.0,
                                         ivcurve_pnts)) / 10.0
             )
-            ivcurve_i, ivcurve_v, _ = singlediode_methods.bishop88(vd, *args)
+            ivcurve_i, ivcurve_v, _ = pvlib.singlediode.bishop88(vd, *args)
 
     out = OrderedDict()
     out['i_sc'] = i_sc
@@ -2125,7 +2125,7 @@ def max_power_point(photocurrent, saturation_current, resistance_series,
     curve. This function uses Brent's method by default because it is
     guaranteed to converge.
     """
-    i_mp, v_mp, p_mp = singlediode_methods.bishop88_mpp(
+    i_mp, v_mp, p_mp = pvlib.singlediode.bishop88_mpp(
         photocurrent, saturation_current, resistance_series,
         resistance_shunt, nNsVth, method=method.lower()
     )
@@ -2205,7 +2205,7 @@ def v_from_i(resistance_shunt, resistance_series, nNsVth, current,
     Energy Materials and Solar Cells, 81 (2004) 269-277.
     '''
     if method.lower() == 'lambertw':
-        return singlediode_methods._lambertw_v_from_i(
+        return pvlib.singlediode._lambertw_v_from_i(
             resistance_shunt, resistance_series, nNsVth, current,
             saturation_current, photocurrent
         )
@@ -2215,9 +2215,9 @@ def v_from_i(resistance_shunt, resistance_series, nNsVth, current,
         # equation for the diode voltage V_d then backing out voltage
         args = (current, photocurrent, saturation_current,
                 resistance_series, resistance_shunt, nNsVth)
-        V = singlediode_methods.bishop88_v_from_i(*args, method=method.lower())
+        V = pvlib.singlediode.bishop88_v_from_i(*args, method=method.lower())
         # find the right size and shape for returns
-        size, shape = singlediode_methods._get_size_and_shape(args)
+        size, shape = pvlib.singlediode._get_size_and_shape(args)
         if size <= 1:
             if shape is not None:
                 V = np.tile(V, shape)
@@ -2293,7 +2293,7 @@ def i_from_v(resistance_shunt, resistance_series, nNsVth, voltage,
     Energy Materials and Solar Cells, 81 (2004) 269-277.
     '''
     if method.lower() == 'lambertw':
-        return singlediode_methods._lambertw_i_from_v(
+        return pvlib.singlediode._lambertw_i_from_v(
             resistance_shunt, resistance_series, nNsVth, voltage,
             saturation_current, photocurrent
         )
@@ -2303,9 +2303,9 @@ def i_from_v(resistance_shunt, resistance_series, nNsVth, voltage,
         # equation for the diode voltage V_d then backing out voltage
         args = (voltage, photocurrent, saturation_current, resistance_series,
                 resistance_shunt, nNsVth)
-        I = singlediode_methods.bishop88_i_from_v(*args, method=method.lower())
+        I = pvlib.singlediode.bishop88_i_from_v(*args, method=method.lower())
         # find the right size and shape for returns
-        size, shape = singlediode_methods._get_size_and_shape(args)
+        size, shape = pvlib.singlediode._get_size_and_shape(args)
         if size <= 1:
             if shape is not None:
                 I = np.tile(I, shape)

pvlib/singlediode_methods.py renamed to pvlib/singlediode.py

@@ -6,13 +6,13 @@
 
 This module can be executed from the command line to generate a high precision
 dataset of I-V curve points to test the explicit single diode calculations
-:func:`pvlib.singlediode_methods.bishop88`::
+:func:`pvlib.singlediode.bishop88`::
 
     $ python test_numeric_precision.py
 
 This generates a file in the pvlib data folder, which is specified by the
 constant ``DATA_PATH``. When the test is run using ``pytest`` it will compare
-the values calculated by :func:`pvlib.singlediode_methods.bishop88` with the
+the values calculated by :func:`pvlib.singlediode.bishop88` with the
 high-precision values generated with SymPy.
 """
 
@@ -21,7 +21,7 @@
 import numpy as np
 import pandas as pd
 from pvlib import pvsystem
-from pvlib.singlediode_methods import bishop88, estimate_voc
+from pvlib.singlediode import bishop88, estimate_voc
 
 logging.basicConfig()
 LOGGER = logging.getLogger(__name__)

pvlib/test/test_numerical_precision.py

@@ -4,7 +4,7 @@
 
 import numpy as np
 from pvlib import pvsystem
-from pvlib.singlediode_methods import bishop88, estimate_voc, VOLTAGE_BUILTIN
+from pvlib.singlediode import bishop88, estimate_voc, VOLTAGE_BUILTIN
 import pytest
 from conftest import requires_scipy
 

pvlib/test/test_singlediode_methods.py renamed to pvlib/test/test_singlediode.py

@@ -255,8 +255,8 @@ def _build_kwargs(keys, input_dict):
 
 
 # FIXME: remove _array_newton when SciPy-1.2.0 is released
-# pvlib.singlediode_methods.bishop88_i_from_v(..., method='newton') and other
-# functions in singlediode_methods call scipy.optimize.newton with a vector
+# pvlib.singlediode.bishop88_i_from_v(..., method='newton') and other
+# functions in singlediode call scipy.optimize.newton with a vector
 # unfortunately wrapping the functions with np.vectorize() was too slow
 # a vectorized newton method was merged into SciPy but isn't released yet, so
 # in the meantime, we just copied the relevant code: "_array_newton" for more