PVconst behavior

[bmeyers]

If building a PVsystem from PVcell, PVmodule, and PVstring instances, there is an option for the user to set pvconst each time. If the user does not set the kwarg, the instance of that class defaults to the default PVConstant() instance. This is confusing. For instance, if it set npts=1001 in my creation of my PVcell object, and then pass that object to my PVmodule instantiation and then my PVsystem instantiation, I would expect npts to propogate, but it does not.

[mikofski]

Also, if one sets npts after PVconstants is created, it's effect is counter intuitive, because it doesn't update self.pts, self.Imod_negpts, self.negpts, and self.Imod_pts which are used to combine curves. This is kinda of a big deal actually! Because there's actually nothing stopping a user from doing this, I just thought of trying it myself right now!

An easy fix, I think, is to move these methods out of the constructor, and make npts a property so that setting it, automatically updates the other values. Something like this:

def __init__(self, npts=NPTS):
    # set number of points in IV curve(s)
    self._npts = None
    self.pts = None
    """array of points with decreasing spacing from 0 to 1"""
    self.Imod_negpts = None
    """array of points with decreasing spacing from 1 to just less than but
    not including zero"""
    self.negpts = None
    """array of points with increasing spacing from 1 to just less than but
    not including zero"""
    self.Imod_pts = None
    """array of points with increasing spacing from 0 to 1"""
    # call property setter
    self.npts = npts  #: number of points in IV curves

@property
def npts(self):
    """number of points in IV curves""""
    return self._npts

@npts.setter
def npts(self, npts):
    self._npts = npts  # number of points in IV curves
    # point spacing from 0 to 1, used for Vcell, Vmod, Vsys and Istring
    # decrease point spacing as voltage approaches Voc by using logspace
    pts = (11. - np.logspace(np.log10(11.), 0., self.npts)) / 10.
    pts[0] = 0.  # first point must be exactly zero
    self.pts = pts.reshape((self.npts, 1))
    negpts = (11. - np.logspace(np.log10(11. - 1. / float(self.npts)),
                                0., self.npts)) / 10.
    negpts = negpts.reshape((self.npts, 1))
    self.Imod_negpts = 1 + 1. / float(self.npts) / 10. - negpts
    """array of points with decreasing spacing from 1 to just less than but
    not including zero"""
    self.negpts = np.flipud(negpts)  # reverse the order
    """array of points with increasing spacing from 1 to just less than but
    not including zero"""
    # shift and concatenate pvconst.negpts and pvconst.pts
    # so that tight spacing is around MPP and RBD
    self.Imod_pts = 1 - np.flipud(self.pts)
    """array of points with increasing spacing from 0 to 1"""

[mikofski]

also regarding the original issue, there was some code in pvstring.py that did reset pvconst to be the same for all cells and modules in the string, but I changed it in #61 to raise an exception if pvconst is not identical, because setting pvconst would trigger a recalc - true, we could now set the _calc_now flag to False and avoid that, but maybe you do want a recalc if you are resetting pvconst with a different one that has a different number of npts, so if you turned _calc_now off, then you would have a weird mismatch between them, eg: Icells could be one length, and npts another!

Also, it was weird that it was only implemented in pvstring.py and not in pvmodule.py or pvsystem.py.

[mikofski]

yay! it's working, but make sure you have the correct version, the newest, v3.2.1
🎉 😀 🌈 🦄

In [1]: import pvmismatch

In [2]: pvmismatch.__version__
Out[2]: '3.2.1'

In [3]: from pvmismatch import *

In [4]: pvc = pvcell.PVcell()

In [5]: pvm = pvmodule.PVmodule(pvcells=pvc)

In [6]: pvc.pvconst is pvm.pvconst
Out[6]: True