v-pvmismatch 0.0.8__py3-none-any.whl

v_PVMismatch/__init__.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+"""
+Initialization file for the vectorized PVMismatch (v_PVMismatch) Package.
+
+This package contains the basic library modules, methods, classes and
+attributes to model PV system mismatch.
+    >>> from v_pvmismatch import pvcell  # imports the PVcell methods
+    >>> # import pvcell, pvmodule, pvstring and pvsystem
+    >>> from v_pvmismatch import *
+"""
+# from v_pvmismatch.version import __version__
+
+from v_PVMismatch import (
+    utils,
+    circuit_comb,
+    vpvcell,
+    vpvmodule,
+    vpvstring,
+    vpvsystem,
+    pvmismatch
+)

v_PVMismatch/circuit_comb.py

@@ -0,0 +1,272 @@
+# -*- coding: utf-8 -*-
+"""Circuit combination and bypass diode configuration functions that are vectorized."""
+
+import numpy as np
+from scipy.interpolate import interp1d
+from pvmismatch import pvconstants
+
+# ------------------------------------------------------------------------------
+# CIRCUIT COMBINATION FUNCTIONS-------------------------------------------------
+
+DEFAULT_BYPASS = 0
+MODULE_BYPASS = 1
+CUSTOM_SUBSTR_BYPASS = 2
+
+
+def calcSeries(Curr, V, meanIsc, Imax, Imod_pts, Imod_negpts, npts):
+    """
+    Calculate IV curve for cells and substrings in series.
+
+    Given current and voltage in increasing order by voltage,
+    the average short circuit current and the max current at the breakdown voltage.
+
+    :param Curr: cell or substring currents [A]
+    :param V: cell or substring voltages [V]
+    :param meanIsc: average short circuit current [A]
+    :param Imax: maximum current [A]
+    :return: current [A] and voltage [V] of series
+
+    """
+    # make sure all inputs are numpy arrays, but don't make extra copies
+    Curr = np.asarray(Curr)  # currents [A]
+    V = np.asarray(V)  # voltages [V]
+    meanIsc = np.asarray(meanIsc)  # mean Isc [A]
+    Imax = np.asarray(Imax)  # max current [A]
+    # create array of currents optimally spaced from mean Isc to  max VRBD
+    Ireverse = (Imax - meanIsc) * Imod_pts + meanIsc
+    Imin = np.minimum(Curr.min(), 0.)  # minimum cell current, at most zero
+    # range of currents in forward bias from min current to mean Isc
+    Iforward = (Imin - meanIsc) * Imod_negpts + meanIsc
+    # create range for interpolation from forward to reverse bias
+    Itot = np.concatenate((Iforward, Ireverse), axis=0).flatten()
+    Vtot = np.zeros((2 * npts,))
+    # add up all series cell voltages
+    # t0 = time.time()
+    for i, v in zip(Curr, V):
+        # interp requires x, y to be sorted by x in increasing order
+        Vtot += pvconstants.npinterpx(Itot, np.flipud(i), np.flipud(v))
+    # print('Time elapsed to run loopy interp: ' + str(time.time() - t0) + ' s')
+    # Itot = np.repeat(Itot[:,np.newaxis], Curr.shape[0], axis=1).T
+    # t0 = time.time()
+    # Vtot = interp2d_wrap(np.flip(Curr, axis = 1), Itot, np.flip(V, axis = 1))
+    # Vtot = Vtot.sum(axis=1)
+    # print('Time elapsed to run vectorized interp: ' + str(time.time() - t0) + ' s')
+    return np.flipud(Itot), np.flipud(Vtot)
+
+
+def calcSeries_with_bypass(Curr, V, meanIsc, Imax, Imod_pts, Imod_negpts, npts, substr_bypass, run_bpact=True):
+    """
+    Calculate IV curve for cells and substrings in series.
+
+    Given current and voltage in increasing order by voltage,
+    the average short circuit current and the max current at
+    the breakdown voltage.
+
+    :param Curr: cell or substring currents [A]
+    :param V: cell or substring voltages [V]
+    :param meanIsc: average short circuit current [A]
+    :param Imax: maximum current [A]
+    :return: current [A] and voltage [V] of series
+    """
+    # make sure all inputs are numpy arrays, but don't make extra copies
+    Curr = np.asarray(Curr)  # currents [A]
+    V = np.asarray(V)  # voltages [V]
+    meanIsc = np.asarray(meanIsc)  # mean Isc [A]
+    Imax = np.asarray(Imax)  # max current [A]
+
+    # create array of currents optimally spaced from mean Isc to  max VRBD
+    Ireverse = (Imax - meanIsc) * Imod_pts + meanIsc
+    Imin = np.minimum(Curr.min(), 0.)  # minimum cell current, at most zero
+    # range of currents in forward bias from min current to mean Isc
+    Iforward = (Imin - meanIsc) * Imod_negpts + meanIsc
+    # create range for interpolation from forward to reverse bias
+    Itot = np.concatenate((Iforward, Ireverse), axis=0).flatten()
+    Vtot = np.zeros((2 * npts,))
+
+    # t0 = time.time()
+    # add up all series cell voltages
+    for i, v in zip(Curr, V):
+        # interp requires x, y to be sorted by x in increasing order
+        Vtot += pvconstants.npinterpx(Itot, np.flipud(i), np.flipud(v))
+
+    # Logic to check the shape of substr_bypass and ensure interpolations is done correctly
+    # Case 1 (Module): I, V, sb have same shape (n x npt)
+    # Case 2 (String): I, & V and sb have different dimensions (n x npt and m x n x npt)
+    if run_bpact:
+        if len(Curr.shape) == len(substr_bypass.shape):
+            bypassed_mod = []
+            for i, v, bypassed in zip(Curr, V, substr_bypass):
+                if ~bypassed.all():
+                    bp_interp = bypassed[0]*np.ones(Itot.shape)
+                else:
+                    interpolator = interp1d(np.flipud(i), np.flipud(bypassed),
+                                            kind='previous', fill_value='extrapolate')
+                    bp_interp = interpolator(Itot)
+                bp_interp = bp_interp.astype(bool)
+                bypassed_mod.append(np.flipud(bp_interp))
+            bypassed_mod = np.asarray(bypassed_mod)
+        else:
+            bypassed_mod = np.zeros((Curr.shape[0], substr_bypass.shape[1], 2 * npts))
+            idx_mod = 0
+            for i, v, bypassed_strs in zip(Curr, V, substr_bypass):
+                for idx_substr in range(bypassed_strs.shape[0]):
+                    bypassed = bypassed_strs[idx_substr, :]
+                    if ~bypassed.all() or bypassed.all():
+                        bp_interp = bypassed[0]*np.ones(Itot.shape)
+                    else:
+                        interpolator = interp1d(np.flipud(i), np.flipud(bypassed),
+                                                kind='previous', fill_value='extrapolate')
+                        bp_interp = interpolator(Itot)
+                    bp_interp = bp_interp.astype(bool)
+                    bypassed_mod[idx_mod, idx_substr, :] = np.flipud(bp_interp)
+                idx_mod += 1
+    else:
+        bypassed_mod = np.nan
+    return np.flipud(Itot), np.flipud(Vtot), bypassed_mod
+
+
+def calcParallel(Curr, V, Vmax, Vmin, negpts, pts, npts):
+    """
+    Calculate IV curve for cells and substrings in parallel.
+
+    :param Curr: currents [A]
+    :type: Curr: list, :class:`numpy.ndarray`
+    :param V: voltages [V]
+    :type: V: list, :class:`numpy.ndarray`
+    :param Vmax: max voltage limit, should be max Voc [V]
+    :param Vmin: min voltage limit, could be zero or Vrbd [V]
+    """
+    Curr, V = np.asarray(Curr), np.asarray(V)
+    Vmax = np.asarray(Vmax)
+    Vmin = np.asarray(Vmin)
+    Vreverse = Vmin * negpts
+    Vforward = Vmax * pts
+    Vtot = np.concatenate((Vreverse, Vforward), axis=0).flatten()
+    Itot = np.zeros((2 * npts,))
+    for i, v in zip(Curr, V):
+        Itot += pvconstants.npinterpx(Vtot, v, i)
+    return Itot, Vtot
+
+
+def calcParallel_with_bypass(Curr, V, Vmax, Vmin, negpts, pts, npts, substr_bypass, run_bpact=True):
+    """
+    Calculate IV curve for cells and substrings in parallel.
+
+    :param Curr: currents [A]
+    :type: Curr: list, :class:`numpy.ndarray`
+    :param V: voltages [V]
+    :type: V: list, :class:`numpy.ndarray`
+    :param Vmax: max voltage limit, should be max Voc [V]
+    :param Vmin: min voltage limit, could be zero or Vrbd [V]
+    """
+    Curr, V = np.asarray(Curr), np.asarray(V)
+    Vmax = np.asarray(Vmax)
+    Vmin = np.asarray(Vmin)
+    Vreverse = Vmin * negpts
+    Vforward = Vmax * pts
+    Vtot = np.concatenate((Vreverse, Vforward), axis=0).flatten()
+    Itot = np.zeros((2 * npts,))
+    for i, v in zip(Curr, V):
+        Itot += pvconstants.npinterpx(Vtot, v, i)
+
+    if run_bpact:
+        if len(Curr.shape) == len(substr_bypass.shape):
+            bypassed_mod = []
+            for i, v, bypassed in zip(Curr, V, substr_bypass):
+                if ~bypassed.all():
+                    bp_interp = bypassed[0]*np.ones(Vtot.shape)
+                else:
+                    interpolator = interp1d(v, bypassed, kind='previous',
+                                            fill_value='extrapolate')
+                    bp_interp = interpolator(Vtot)
+                bp_interp = bp_interp.astype(bool)
+                bypassed_mod.append(bp_interp)
+            bypassed_mod = np.asarray(bypassed_mod)
+            # bypassed_mod = interp2d_wrap(V, Vtot1, substr_bypass.astype(float), kind='previous')
+            # bypassed_mod = np.round(bypassed_mod).astype(bool)
+        else:
+            bypassed_mod = np.zeros((Curr.shape[0], substr_bypass.shape[1],
+                                    substr_bypass.shape[2], 2 * npts), dtype=bool)
+            idx_str = 0
+            for i, v, bypassed_strs in zip(Curr, V, substr_bypass):
+                idx_mod = 0
+                for idx_mod in range(bypassed_strs.shape[0]):
+                    for idx_substr in range(bypassed_strs.shape[1]):
+                        bypassed = bypassed_strs[idx_mod, idx_substr, :]
+                        if ~bypassed.all() or bypassed.all():
+                            bp_interp = bypassed[0]*np.ones(Vtot.shape)
+                        else:
+                            interpolator = interp1d(v, bypassed, kind='previous',
+                                                    fill_value='extrapolate')
+                            bp_interp = interpolator(Vtot)
+                        bp_interp = bp_interp.astype(bool)
+                        bypassed_mod[idx_str, idx_mod, idx_substr, :] = bp_interp
+                    idx_mod += 1
+                idx_str += 1
+    else:
+        bypassed_mod = np.nan
+
+    return Itot, Vtot, bypassed_mod
+
+
+def combine_parallel_circuits(IVprev_cols, pvconst,
+                              negpts, pts, Imod_pts, Imod_negpts, npts):
+    """
+    Combine crosstied circuits in a substring.
+
+    :param IVprev_cols: lists of IV curves of crosstied and series circuits
+    :return:
+    """
+    # combine crosstied circuits
+    Irows, Vrows = [], []
+    Isc_rows, Imax_rows = [], []
+    for IVcols in zip(*IVprev_cols):
+        Iparallel, Vparallel = zip(*IVcols)
+        Iparallel = np.asarray(Iparallel)
+        Vparallel = np.asarray(Vparallel)
+        Irow, Vrow = calcParallel(
+            Iparallel, Vparallel, Vparallel.max(),
+            Vparallel.min(), negpts, pts, npts
+        )
+        Irows.append(Irow)
+        Vrows.append(Vrow)
+        Isc_rows.append(np.interp(np.float64(0), Vrow, Irow))
+        Imax_rows.append(Irow.max())
+    Irows, Vrows = np.asarray(Irows), np.asarray(Vrows)
+    Isc_rows = np.asarray(Isc_rows)
+    Imax_rows = np.asarray(Imax_rows)
+    return calcSeries(
+        Irows, Vrows, Isc_rows.mean(), Imax_rows.max(),
+        Imod_pts, Imod_negpts, npts
+    )
+
+
+def parse_diode_config(Vbypass, cell_pos):
+    """
+    Parse diode configuration from the Vbypass argument.
+
+    :param Vbypass: Vbypass config
+    :type Vbypass: float|list|tuple
+    :param cell_pos:
+    :type cell_pos:
+    :return: bypass config
+    :rtype: str
+    """
+    try:
+        # check if float or list/tuple
+        num_bypass = len(Vbypass)
+    except TypeError:
+        # float passed - default case - Vbypass across every cell string
+        return DEFAULT_BYPASS
+    else:
+        # if only one value is passed in the list- assume only one
+        # bypass diode  across the PV module
+        if len(Vbypass) == 1:
+            return MODULE_BYPASS
+        # if more than 1 values are passed, apply them across
+        # the cell strings in ascending order
+        elif len(cell_pos) == num_bypass:
+            return CUSTOM_SUBSTR_BYPASS
+        else:
+            print("wrong number of bypass diode values passed : %d" %
+                  (len(Vbypass)))

v_PVMismatch/pvmismatch/__init__.py

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+"""
+This is the PVMismatch Library. Configuration constants and classes like
+:class:`~pvmismatch.pvmismatch_lib.pvconstants.PVconstants`,
+:class:`~pvmismatch.pvmismatch_lib.pvcell.PVcell`,
+:class:`~pvmismatch.pvmismatch_lib.pvmodule.PVmodule`,
+:class:`~pvmismatch.pvmismatch_lib.pvstring.PVstring` and
+:class:`~pvmismatch.pvmismatch_lib.pvsystem.PVsystem`, objects are all defined
+here.
+"""
+
+from v_PVMismatch.pvmismatch import pvconstants, pvexceptions, pvcell, pvmodule, pvstring, pvsystem

v_PVMismatch/pvmismatch/pvcell.py

@@ -0,0 +1,339 @@
+# -*- coding: utf-8 -*-
+
+"""
+This module contains the :class:`~pvmismatch.pvmismatch_lib.pvcell.PVcell`
+object which is used by modules, strings and systems.
+"""
+
+from __future__ import absolute_import
+from future.utils import iteritems
+from pvmismatch.pvmismatch_lib.pvconstants import PVconstants
+import numpy as np
+from matplotlib import pyplot as plt
+from scipy.optimize import newton
+
+# Defaults
+RS = 0.004267236774264931  # [ohm] series resistance
+RSH = 10.01226369025448  # [ohm] shunt resistance
+ISAT1_T0 = 2.286188161253440E-11  # [A] diode one saturation current
+ISAT2_T0 = 1.117455042372326E-6  # [A] diode two saturation current
+ISC0_T0 = 6.3056  # [A] reference short circuit current
+TCELL = 298.15  # [K] cell temperature
+ARBD = 1.036748445065697E-4  # reverse breakdown coefficient 1
+BRBD = 0.  # reverse breakdown coefficient 2
+VRBD_ = -5.527260068445654  # [V] reverse breakdown voltage
+NRBD = 3.284628553041425  # reverse breakdown exponent
+EG = 1.1  # [eV] band gap of cSi
+ALPHA_ISC = 0.0003551  # [1/K] short circuit current temperature coefficient
+EPS = np.finfo(np.float64).eps
+
+class PVcell(object):
+    """
+    Class for PV cells.
+
+    :param Rs: series resistance [ohms]
+    :param Rsh: shunt resistance [ohms]
+    :param Isat1_T0: first saturation diode current at ref temp [A]
+    :param Isat2_T0: second saturation diode current [A]
+    :param Isc0_T0: short circuit current at ref temp [A]
+    :param aRBD: reverse breakdown coefficient 1
+    :param bRBD: reverse breakdown coefficient 2
+    :param VRBD: reverse breakdown voltage [V]
+    :param nRBD: reverse breakdown exponent
+    :param Eg: band gap [eV]
+    :param alpha_Isc: short circuit current temp coeff [1/K]
+    :param Tcell: cell temperature [K]
+    :param Ee: incident effective irradiance [suns]
+    :param pvconst: configuration constants object
+    :type pvconst: :class:`~pvmismatch.pvmismatch_lib.pvconstants.PVconstants`
+    """
+
+    _calc_now = False  #: if True ``calcCells()`` is called in ``__setattr__``
+
+    def __init__(self, Rs=RS, Rsh=RSH, Isat1_T0=ISAT1_T0, Isat2_T0=ISAT2_T0,
+                 Isc0_T0=ISC0_T0, aRBD=ARBD, bRBD=BRBD, VRBD=VRBD_,
+                 nRBD=NRBD, Eg=EG, alpha_Isc=ALPHA_ISC,
+                 Tcell=TCELL, Ee=1., pvconst=PVconstants()):
+        # user inputs
+        self.Rs = Rs  #: [ohm] series resistance
+        self.Rsh = Rsh  #: [ohm] shunt resistance
+        self.Isat1_T0 = Isat1_T0  #: [A] diode one sat. current at T0
+        self.Isat2_T0 = Isat2_T0  #: [A] diode two saturation current
+        self.Isc0_T0 = Isc0_T0  #: [A] short circuit current at T0
+        self.aRBD = aRBD  #: reverse breakdown coefficient 1
+        self.bRBD = bRBD  #: reverse breakdown coefficient 2
+        self.VRBD = VRBD  #: [V] reverse breakdown voltage
+        self.nRBD = nRBD  #: reverse breakdown exponent
+        self.Eg = Eg  #: [eV] band gap of cSi
+        self.alpha_Isc = alpha_Isc  #: [1/K] short circuit temp. coeff.
+        self.Tcell = Tcell  #: [K] cell temperature
+        self.Ee = Ee  #: [suns] incident effective irradiance on cell
+        self.pvconst = pvconst  #: configuration constants
+        self.Icell = None  #: cell currents on IV curve [A]
+        self.Vcell = None  #: cell voltages on IV curve [V]
+        self.Pcell = None  #: cell power on IV curve [W]
+        self.VocSTC = self._VocSTC()  #: estimated Voc at STC [V]
+        # set calculation flag
+        self._calc_now = True  # overwrites the class attribute
+
+    def __str__(self):
+        fmt = '<PVcell(Ee=%g[suns], Tcell=%g[K], Isc=%g[A], Voc=%g[V])>'
+        return fmt % (self.Ee, self.Tcell, self.Isc, self.Voc)
+
+    def __repr__(self):
+        return str(self)
+
+    def __setattr__(self, key, value):
+        # check for floats
+        try:
+            value = np.float64(value)
+        except (TypeError, ValueError):
+            pass  # fail silently if not float, eg: pvconst or _calc_now
+        super(PVcell, self).__setattr__(key, value)
+        # recalculate IV curve
+        if self._calc_now:
+            Icell, Vcell, Pcell = self.calcCell()
+            self.__dict__.update(Icell=Icell, Vcell=Vcell, Pcell=Pcell)
+
+    def update(self, **kwargs):
+        """
+        Update user-defined constants.
+        """
+        # turn off calculation flag until all attributes are updated
+        self._calc_now = False
+        # don't use __dict__.update() instead use setattr() to go through
+        # custom __setattr__() so that numbers are cast to floats
+        for k, v in iteritems(kwargs):
+            setattr(self, k, v)
+        self._calc_now = True  # recalculate
+
+    @property
+    def Vt(self):
+        """
+        Thermal voltage in volts.
+        """
+        return self.pvconst.k * self.Tcell / self.pvconst.q
+
+    @property
+    def Isc(self):
+        return self.Ee * self.Isc0
+
+    @property
+    def Aph(self):
+        """
+        Photogenerated current coefficient, non-dimensional.
+        """
+        # Aph is undefined (0/0) if there is no irradiance
+        if self.Isc == 0: return np.nan
+        # short current (SC) conditions (Vcell = 0)
+        Vdiode_sc = self.Isc * self.Rs  # diode voltage at SC
+        Idiode1_sc = self.Isat1 * (np.exp(Vdiode_sc / self.Vt) - 1.)
+        Idiode2_sc = self.Isat2 * (np.exp(Vdiode_sc / 2. / self.Vt) - 1.)
+        Ishunt_sc = Vdiode_sc / self.Rsh  # diode voltage at SC
+        # photogenerated current coefficient
+        return 1. + (Idiode1_sc + Idiode2_sc + Ishunt_sc) / self.Isc
+
+    @property
+    def Isat1(self):
+        """
+        Diode one saturation current at Tcell in amps.
+        """
+        _Tstar = self.Tcell ** 3. / self.pvconst.T0 ** 3.  # scaled temperature
+        _inv_delta_T = 1. / self.pvconst.T0 - 1. / self.Tcell  # [1/K]
+        _expTstar = np.exp(
+            self.Eg * self.pvconst.q / self.pvconst.k * _inv_delta_T
+        )
+        return self.Isat1_T0 * _Tstar * _expTstar  # [A] Isat1(Tcell)
+
+    @property
+    def Isat2(self):
+        """
+        Diode two saturation current at Tcell in amps.
+        """
+        _Tstar = self.Tcell ** 3. / self.pvconst.T0 ** 3.  # scaled temperature
+        _inv_delta_T = 1. / self.pvconst.T0 - 1. / self.Tcell  # [1/K]
+        _expTstar = np.exp(
+            self.Eg * self.pvconst.q / (2.0 * self.pvconst.k) * _inv_delta_T
+        )
+        return self.Isat2_T0 * _Tstar * _expTstar  # [A] Isat2(Tcell)
+    
+    @property
+    def Isc0(self):
+        """
+        Short circuit current at Tcell in amps.
+        """
+        _delta_T = self.Tcell - self.pvconst.T0  # [K] temperature difference
+        return self.Isc0_T0 * (1. + self.alpha_Isc * _delta_T)  # [A] Isc0
+
+    @property
+    def Voc(self):
+        """
+        Estimate open circuit voltage of cells.
+        Returns Voc : numpy.ndarray of float, estimated open circuit voltage
+        """
+        C = self.Aph * self.Isc + self.Isat1 + self.Isat2
+        delta = self.Isat2 ** 2. + 4. * self.Isat1 * C
+        return self.Vt * np.log(
+            ((-self.Isat2 + np.sqrt(delta)) / 2. / self.Isat1) ** 2.
+        )
+
+    def _VocSTC(self):
+        """
+        Estimate open circuit voltage of cells.
+        Returns Voc : numpy.ndarray of float, estimated open circuit voltage
+        """
+        Vdiode_sc = self.Isc0_T0 * self.Rs  # diode voltage at SC
+        Idiode1_sc = self.Isat1_T0 * (np.exp(Vdiode_sc / self.Vt) - 1.)
+        Idiode2_sc = self.Isat2_T0 * (np.exp(Vdiode_sc / 2. / self.Vt) - 1.)
+        Ishunt_sc = Vdiode_sc / self.Rsh  # diode voltage at SC
+        # photogenerated current coefficient
+        Aph = 1. + (Idiode1_sc + Idiode2_sc + Ishunt_sc) / self.Isc0_T0
+        # estimated Voc at STC
+        C = Aph * self.Isc0_T0 + self.Isat1_T0 + self.Isat2_T0
+        delta = self.Isat2_T0 ** 2. + 4. * self.Isat1_T0 * C
+        return self.Vt * np.log(
+            ((-self.Isat2_T0 + np.sqrt(delta)) / 2. / self.Isat1_T0) ** 2.
+        )
+
+    @property
+    def Igen(self):
+        """
+        Photovoltaic generated light current (AKA IL or Iph)
+        Returns Igen : numpy.ndarray of float, PV generated light current [A]
+
+        Photovoltaic generated light current is zero if irradiance is zero.
+        """
+        if self.Ee == 0: return 0
+        return self.Aph * self.Isc
+
+    def calcCell(self):
+        """
+        Calculate cell I-V curves.
+        Returns (Icell, Vcell, Pcell) : tuple of numpy.ndarray of float
+        """
+        Vreverse = self.VRBD * self.pvconst.negpts
+        Vff = self.Voc
+        delta_Voc = self.VocSTC - self.Voc
+        # to make sure that the max voltage is always in the 4th quadrant, add
+        # a third set of points log spaced with decreasing density, from Voc to
+        # Voc @ STC unless Voc *is* Voc @ STC, then use an arbitrary voltage at
+        # 80% of Voc as an estimate of Vmp assuming a fill factor of 80% and
+        # Isc close to Imp, or if Voc > Voc @ STC, then use Voc as the max
+        if delta_Voc == 0:
+            Vff = 0.8 * self.Voc
+            delta_Voc = 0.2 * self.Voc
+        elif delta_Voc < 0:
+            Vff = self.VocSTC
+            delta_Voc = -delta_Voc
+        Vquad4 = Vff + delta_Voc * self.pvconst.Vmod_q4pts
+        Vforward = Vff * self.pvconst.pts
+        Vdiode = np.concatenate((Vreverse, Vforward, Vquad4), axis=0)
+        Idiode1 = self.Isat1 * (np.exp(Vdiode / self.Vt) - 1.)
+        Idiode2 = self.Isat2 * (np.exp(Vdiode / 2. / self.Vt) - 1.)
+        Ishunt = Vdiode / self.Rsh
+        fRBD = 1. - Vdiode / self.VRBD
+        # use epsilon = 2.2204460492503131e-16 to avoid "divide by zero"
+        fRBD[fRBD == 0] = EPS
+        Vdiode_norm = Vdiode / self.Rsh / self.Isc0_T0
+        fRBD = self.Isc0_T0 * fRBD ** (-self.nRBD)
+        IRBD = (self.aRBD * Vdiode_norm + self.bRBD * Vdiode_norm ** 2) * fRBD 
+        Icell = self.Igen - Idiode1 - Idiode2 - Ishunt - IRBD
+        Vcell = Vdiode - Icell * self.Rs
+        Pcell = Icell * Vcell
+        return Icell, Vcell, Pcell
+
+    # diode model
+    #  *-->--*--->---*--Rs->-Icell--+
+    #  ^     |       |              ^
+    #  |     |       |              |
+    # Igen  Idiode  Ishunt         Vcell
+    #  |     |       |              |
+    #  |     v       v              v
+    #  *--<--*---<---*--<-----------=
+    # http://en.wikipedia.org/wiki/Diode_modelling#Shockley_diode_model
+    # http://en.wikipedia.org/wiki/Diode#Shockley_diode_equation
+    # http://en.wikipedia.org/wiki/William_Shockley
+
+    @staticmethod
+    def f_Icell(Icell, Vcell, Igen, Rs, Vt, Isat1, Isat2, Rsh):
+        """
+        Objective function for Icell.
+        :param Icell: cell current [A]
+        :param Vcell: cell voltage [V]
+        :param Igen: photogenerated current at Tcell and Ee [A]
+        :param Rs: series resistance [ohms]
+        :param Vt: thermal voltage [V]
+        :param Isat1: first diode saturation current at Tcell [A]
+        :param Isat2: second diode saturation current [A]
+        :param Rsh: shunt resistance [ohms]
+        :return: residual = (Icell - Icell0) [A]
+        """
+        # arbitrary current condition
+        Vdiode = Vcell + Icell * Rs  # diode voltage
+        Idiode1 = Isat1 * (np.exp(Vdiode / Vt) - 1.)  # diode current
+        Idiode2 = Isat2 * (np.exp(Vdiode / 2. / Vt) - 1.)  # diode current
+        Ishunt = Vdiode / Rsh  # shunt current
+        return Igen - Idiode1 - Idiode2 - Ishunt - Icell
+
+    def calcIcell(self, Vcell):
+        """
+        Calculate Icell as a function of Vcell.
+        :param Vcell: cell voltage [V]
+        :return: Icell
+        """
+        args = (np.float64(Vcell), self.Igen, self.Rs, self.Vt,
+                self.Isat1, self.Isat2, self.Rsh)
+        return newton(self.f_Icell, x0=self.Isc, args=args)
+
+    @staticmethod
+    def f_Vcell(Vcell, Icell, Igen, Rs, Vt, Isat1, Isat2, Rsh):
+        return PVcell.f_Icell(Icell, Vcell, Igen, Rs, Vt, Isat1, Isat2, Rsh)
+
+    def calcVcell(self, Icell):
+        """
+        Calculate Vcell as a function of Icell.
+        :param Icell: cell current [A]
+        :return: Vcell
+        """
+        args = (np.float64(Icell), self.Igen, self.Rs, self.Vt,
+                self.Isat1, self.Isat2, self.Rsh)
+        return newton(self.f_Vcell, x0=self.Voc, args=args)
+
+    def plot(self):
+        """
+        Plot cell I-V curve.
+        Returns cellPlot : matplotlib.pyplot figure
+        """
+        cell_plot = plt.figure()
+        plt.subplot(2, 2, 1)
+        plt.plot(self.Vcell, self.Icell)
+        plt.title('Cell Reverse I-V Characteristics')
+        plt.ylabel('Cell Current, I [A]')
+        plt.xlim(self.VRBD - 1, 0)
+        plt.ylim(0, self.Isc + 10)
+        plt.grid()
+        plt.subplot(2, 2, 2)
+        plt.plot(self.Vcell, self.Icell)
+        plt.title('Cell Forward I-V Characteristics')
+        plt.ylabel('Cell Current, I [A]')
+        plt.xlim(0, self.Voc)
+        plt.ylim(0, self.Isc + 1)
+        plt.grid()
+        plt.subplot(2, 2, 3)
+        plt.plot(self.Vcell, self.Pcell)
+        plt.title('Cell Reverse P-V Characteristics')
+        plt.xlabel('Cell Voltage, V [V]')
+        plt.ylabel('Cell Power, P [W]')
+        plt.xlim(self.VRBD - 1, 0)
+        plt.ylim((self.Isc + 10) * (self.VRBD - 1), -1)
+        plt.grid()
+        plt.subplot(2, 2, 4)
+        plt.plot(self.Vcell, self.Pcell)
+        plt.title('Cell Forward P-V Characteristics')
+        plt.xlabel('Cell Voltage, V [V]')
+        plt.ylabel('Cell Power, P [W]')
+        plt.xlim(0, self.Voc)
+        plt.ylim(0, (self.Isc + 1) * self.Voc)
+        plt.grid()
+        plt.tight_layout()
+        return cell_plot