From bbe8ad2a4b024d41e19cfa42153700653f705ba3 Mon Sep 17 00:00:00 2001 From: Cliff Hansen Date: Wed, 27 Nov 2019 14:23:32 -0700 Subject: [PATCH 01/16] start on desoto, pvsyst --- pvmismatch/pvmismatch_lib/pvcell.py | 57 ++++++++++++++++++++++------- 1 file changed, 44 insertions(+), 13 deletions(-) diff --git a/pvmismatch/pvmismatch_lib/pvcell.py b/pvmismatch/pvmismatch_lib/pvcell.py index 080e449..7a2e6ac 100644 --- a/pvmismatch/pvmismatch_lib/pvcell.py +++ b/pvmismatch/pvmismatch_lib/pvcell.py @@ -13,10 +13,14 @@ from scipy.optimize import newton # Defaults +MODEL = '2diode' 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 +N1 = 1.0 # [unitless] diode one ideality factor +N2 = 2.0 # [unitless] diode two ideality factor +MU_GAMMA = 0.0003 # [1/K] temperature coefficient of N1 (pvsyst model) ISC0_T0 = 6.3056 # [A] reference short circuit current TCELL = 298.15 # [K] cell temperature ARBD = 1.036748445065697E-4 # reverse breakdown coefficient 1 @@ -24,6 +28,7 @@ VRBD_ = -5.527260068445654 # [V] reverse breakdown voltage NRBD = 3.284628553041425 # reverse breakdown exponent EG = 1.1 # [eV] band gap of cSi +DEG_DT = -0.0002677 # [eV/K] temperature coefficient of EG (desoto model) ALPHA_ISC = 0.0003551 # [1/K] short circuit current temperature coefficient EPS = np.finfo(np.float64).eps @@ -31,6 +36,7 @@ class PVcell(object): """ Class for PV cells. + :param diode_model: name of diode model (str) '2diode', 'desoto', 'pvsyst' :param Rs: series resistance [ohms] :param Rsh: shunt resistance [ohms] :param Isat1_T0: first saturation diode current at ref temp [A] @@ -50,15 +56,22 @@ class PVcell(object): _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, + def __init__(self, model=MODEL, Rs=RS, Rsh=RSH, Isat1_T0=ISAT1_T0, + Isat2_T0=ISAT2_T0, N1=N1, N2=N2, 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 + if MODEL in ['2diode', 'desoto', 'pvsyst']: + self.diode_model = model + else: + raise ValueError('model must be one of ''2diode'', ''desoto'' or ' + ' ''pvsyst''; % provided'.format(model)) 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.N1 = N1 #: [unitless] diode one ideality factor + self.N2 = N2 #: [unitless] diode two ideality factor 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 @@ -126,9 +139,14 @@ def Aph(self): # Aph is undefined (0/0) if there is no irradiance if self.Isc == 0: return np.nan # short current (SC) conditions (Vcell = 0) + if self.model=='pvsyst': + # temperature adjustment to diode factor + N1 = self.N1 * self.MU_GAMMA * (self.Tcell - self.pvconst.T0) + elif self.model in ['desoto', '2diode']: + N1 = self.N1 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.) + Idiode1_sc = self.Isat1 * (np.exp(Vdiode_sc / N1 / self.Vt) - 1.) + Idiode2_sc = self.Isat2 * (np.exp(Vdiode_sc / self.N2 / 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 @@ -140,8 +158,18 @@ def Isat1(self): """ _Tstar = self.Tcell ** 3. / self.pvconst.T0 ** 3. # scaled temperature _inv_delta_T = 1. / self.pvconst.T0 - 1. / self.Tcell # [1/K] + if self.model == 'pvsyst': + # temperature adjustment to diode factor + N1 = self.N1 * self.MU_GAMMA * (self.Tcell - self.pvconst.T0) + Eg = self.Eg + elif self.model == 'desoto': + N1 = 1.0 # desoto doesn't use diode factor in band gap term + Eg = self.Eg * (1 - 0.0002677) * (self.Tcell - self.pvconst.T0) + elif self.model == '2diode': + N1 = self.N1 + Eg = self.Eg _expTstar = np.exp( - self.Eg * self.pvconst.q / self.pvconst.k * _inv_delta_T + Eg * self.pvconst.q / N1 / self.pvconst.k * _inv_delta_T ) return self.Isat1_T0 * _Tstar * _expTstar # [A] Isat1(Tcell) @@ -150,13 +178,16 @@ 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) - + if self.model=='2diode': + _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.N2 / self.pvconst.k * _inv_delta_T + ) + return self.Isat2_T0 * _Tstar * _expTstar # [A] Isat2(Tcell) + else: + return 0.0 + @property def Isc0(self): """ From 2fdc4dc753e78c31b31d1a7e9cfd4f2a0be69ce6 Mon Sep 17 00:00:00 2001 From: Cliff Hansen Date: Fri, 29 Nov 2019 14:44:16 -0700 Subject: [PATCH 02/16] Rsh update --- pvmismatch/pvmismatch_lib/pvcell.py | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/pvmismatch/pvmismatch_lib/pvcell.py b/pvmismatch/pvmismatch_lib/pvcell.py index 7a2e6ac..ef96696 100644 --- a/pvmismatch/pvmismatch_lib/pvcell.py +++ b/pvmismatch/pvmismatch_lib/pvcell.py @@ -15,7 +15,9 @@ # Defaults MODEL = '2diode' RS = 0.004267236774264931 # [ohm] series resistance -RSH = 10.01226369025448 # [ohm] shunt resistance +RSH = 10.01226369025448 # [ohm] shunt resistance at STC +RSH0 = RSH / 10 # [ohm] shunt resistance at 0 irradiance (pvsyst model) +RSH_EXP = -5.5 # [unitless] exponent relating Rsh to irradiance (pvsyst model) ISAT1_T0 = 2.286188161253440E-11 # [A] diode one saturation current ISAT2_T0 = 1.117455042372326E-6 # [A] diode two saturation current N1 = 1.0 # [unitless] diode one ideality factor @@ -38,7 +40,9 @@ class PVcell(object): :param diode_model: name of diode model (str) '2diode', 'desoto', 'pvsyst' :param Rs: series resistance [ohms] - :param Rsh: shunt resistance [ohms] + :param Rsh: shunt resistance at STC condition [ohms] + :param Rsh0: shunt resistance at 0 irradiance (pvsyst) [ohms] + :param Rshexp: exponent relating Rsh to irradiance (pvsyst) [unitless] :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] @@ -56,7 +60,8 @@ class PVcell(object): _calc_now = False #: if True ``calcCells()`` is called in ``__setattr__`` - def __init__(self, model=MODEL, Rs=RS, Rsh=RSH, Isat1_T0=ISAT1_T0, + def __init__(self, model=MODEL, Rs=RS, Rsh=RSH, Rsh0=RSH0, Rshexp=RSH_EXP, + Isat1_T0=ISAT1_T0, Isat2_T0=ISAT2_T0, N1=N1, N2=N2, Isc0_T0=ISC0_T0, aRBD=ARBD, bRBD=BRBD, VRBD=VRBD_, nRBD=NRBD, Eg=EG, alpha_Isc=ALPHA_ISC, Tcell=TCELL, Ee=1., pvconst=PVconstants()): @@ -67,11 +72,13 @@ def __init__(self, model=MODEL, Rs=RS, Rsh=RSH, Isat1_T0=ISAT1_T0, raise ValueError('model must be one of ''2diode'', ''desoto'' or ' ' ''pvsyst''; % provided'.format(model)) self.Rs = Rs #: [ohm] series resistance - self.Rsh = Rsh #: [ohm] shunt resistance + self.Rsh_E0 = RSH #: [ohm] shunt resistance at STC + self.Rsh_0 = RSH0 #: [ohm] shunt resistance at 0 irradiance (pvsyst) + self.Rshexp = RSH_EXP #: [unitless] exponent for _Rsh (pvsyst) self.Isat1_T0 = Isat1_T0 #: [A] diode one sat. current at T0 self.Isat2_T0 = Isat2_T0 #: [A] diode two saturation current - self.N1 = N1 #: [unitless] diode one ideality factor - self.N2 = N2 #: [unitless] diode two ideality factor + self.N1_T0 = N1 #: [unitless] diode one ideality factor at T0 + self.N2_T0 = N2 #: [unitless] diode two ideality factor 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 From e06d9a8db7c9d1151be3afc34ed77cbc121c38ab Mon Sep 17 00:00:00 2001 From: Cliff Hansen Date: Sat, 30 Nov 2019 10:51:09 -0700 Subject: [PATCH 03/16] implement Rsh, Vt and Eg properties --- pvmismatch/pvmismatch_lib/pvcell.py | 155 +++++++++++++++++----------- 1 file changed, 93 insertions(+), 62 deletions(-) diff --git a/pvmismatch/pvmismatch_lib/pvcell.py b/pvmismatch/pvmismatch_lib/pvcell.py index ef96696..2210cb0 100644 --- a/pvmismatch/pvmismatch_lib/pvcell.py +++ b/pvmismatch/pvmismatch_lib/pvcell.py @@ -15,13 +15,13 @@ # Defaults MODEL = '2diode' RS = 0.004267236774264931 # [ohm] series resistance -RSH = 10.01226369025448 # [ohm] shunt resistance at STC -RSH0 = RSH / 10 # [ohm] shunt resistance at 0 irradiance (pvsyst model) +RSH_STC = 10.01226369025448 # [ohm] shunt resistance at STC +RSH_0 = RSH_STC / 10 # [ohm] shunt resistance at 0 irradiance (pvsyst model) RSH_EXP = -5.5 # [unitless] exponent relating Rsh to irradiance (pvsyst model) ISAT1_T0 = 2.286188161253440E-11 # [A] diode one saturation current ISAT2_T0 = 1.117455042372326E-6 # [A] diode two saturation current -N1 = 1.0 # [unitless] diode one ideality factor -N2 = 2.0 # [unitless] diode two ideality factor +N1_0 = 1.0 # [unitless] diode one ideality factor +N2_0 = 2.0 # [unitless] diode two ideality factor MU_GAMMA = 0.0003 # [1/K] temperature coefficient of N1 (pvsyst model) ISC0_T0 = 6.3056 # [A] reference short circuit current TCELL = 298.15 # [K] cell temperature @@ -29,7 +29,7 @@ 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 +EG_0 = 1.1 # [eV] band gap of cSi DEG_DT = -0.0002677 # [eV/K] temperature coefficient of EG (desoto model) ALPHA_ISC = 0.0003551 # [1/K] short circuit current temperature coefficient EPS = np.finfo(np.float64).eps @@ -40,9 +40,9 @@ class PVcell(object): :param diode_model: name of diode model (str) '2diode', 'desoto', 'pvsyst' :param Rs: series resistance [ohms] - :param Rsh: shunt resistance at STC condition [ohms] - :param Rsh0: shunt resistance at 0 irradiance (pvsyst) [ohms] - :param Rshexp: exponent relating Rsh to irradiance (pvsyst) [unitless] + :param Rsh_STC: shunt resistance at STC condition [ohms] + :param Rsh_0: shunt resistance at 0 irradiance (pvsyst) [ohms] + :param Rsh_exp: exponent relating Rsh to irradiance (pvsyst) [unitless] :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] @@ -50,7 +50,11 @@ class PVcell(object): :param bRBD: reverse breakdown coefficient 2 :param VRBD: reverse breakdown voltage [V] :param nRBD: reverse breakdown exponent - :param Eg: band gap [eV] + :param Eg_0: band gap at STC [eV] + :param dEg_dT: temperature dependence of band gap [eV/K] + :param N1_0: diode one ideality factor [unitless] + :param N2_0: diode two ideality factor [unitless] + :param mu_gamma: temperature coeff for diode one ideality factor [1/K] :param alpha_Isc: short circuit current temp coeff [1/K] :param Tcell: cell temperature [K] :param Ee: incident effective irradiance [suns] @@ -60,10 +64,11 @@ class PVcell(object): _calc_now = False #: if True ``calcCells()`` is called in ``__setattr__`` - def __init__(self, model=MODEL, Rs=RS, Rsh=RSH, Rsh0=RSH0, Rshexp=RSH_EXP, - Isat1_T0=ISAT1_T0, - Isat2_T0=ISAT2_T0, N1=N1, N2=N2, Isc0_T0=ISC0_T0, aRBD=ARBD, - bRBD=BRBD, VRBD=VRBD_, nRBD=NRBD, Eg=EG, alpha_Isc=ALPHA_ISC, + def __init__(self, model=MODEL, Rs=RS, Rsh_STC=RSH_STC, Rsh_0=RSH_0, + Rsh_exp=RSH_EXP, Isat1_T0=ISAT1_T0, Isat2_T0=ISAT2_T0, + Isc0_T0=ISC0_T0, aRBD=ARBD, bRBD=BRBD, VRBD=VRBD_, nRBD=NRBD, + Eg_0=EG_0, dEg_dT=DEG_DT, N1_0=N1_0, N2_0=N2_0, + mu_gamma=MU_GAMMA, alpha_Isc=ALPHA_ISC, Tcell=TCELL, Ee=1., pvconst=PVconstants()): # user inputs if MODEL in ['2diode', 'desoto', 'pvsyst']: @@ -72,19 +77,21 @@ def __init__(self, model=MODEL, Rs=RS, Rsh=RSH, Rsh0=RSH0, Rshexp=RSH_EXP, raise ValueError('model must be one of ''2diode'', ''desoto'' or ' ' ''pvsyst''; % provided'.format(model)) self.Rs = Rs #: [ohm] series resistance - self.Rsh_E0 = RSH #: [ohm] shunt resistance at STC - self.Rsh_0 = RSH0 #: [ohm] shunt resistance at 0 irradiance (pvsyst) - self.Rshexp = RSH_EXP #: [unitless] exponent for _Rsh (pvsyst) + self.Rsh_STC = Rsh_STC #: [ohm] shunt resistance at STC + self.Rsh_0 = Rsh_0 #: [ohm] shunt resistance at 0 irradiance (pvsyst) + self.Rsh_exp = Rsh_exp #: [unitless] exponent for _Rsh (pvsyst) self.Isat1_T0 = Isat1_T0 #: [A] diode one sat. current at T0 self.Isat2_T0 = Isat2_T0 #: [A] diode two saturation current - self.N1_T0 = N1 #: [unitless] diode one ideality factor at T0 - self.N2_T0 = N2 #: [unitless] diode two ideality factor 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.Eg_0 = Eg_0 #: [eV] band gap at STC + self.dEg_dT = dEg_dT #: [eV/K] temperature coeff of band gap + self.N1_0 = N1_0 #: [unitless] diode one ideality factor at T0 + self.N2_0 = N2_0 #: [unitless] diode two ideality factor + self.mu_gamma = mu_gamma #: [1/K] temp. coeff for diode one ideality 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 @@ -138,6 +145,34 @@ def Vt(self): def Isc(self): return self.Ee * self.Isc0 + @property + def N1(self): + if self.model == 'pvsyst': + return self.N1_0 + self.mu_gamma * (self.Tcell - self.pvconst.T0) + return self.N1_0 + + @property + def N2(self): + return self.N2 + + @property + def Eg(self): + if self.model == 'desoto': + return self.Eg_0 + self.dEg_dT * (self.Tcell - self.pvconst.T0) + return self.Eg_0 + + @property + def Rsh(self): + if self.model == 'desoto': + return self.Rsh_STC / self.Ee + elif self.model == 'desoto': + rsh_tmp = self.Rsh_STC - self.Rsh_0 * np.exp(self.Rsh_exp) / \ + (1. - np.exp(self.Rsh_exp)) + rsh_base = np.maximum(0.0, rsh_tmp) + return rsh_base + (self.Rsh_0 - rsh_base) * \ + np.exp(self.Rsh_exp * self.Ee) + return self.Rsh_STC + @property def Aph(self): """ @@ -146,13 +181,8 @@ def Aph(self): # Aph is undefined (0/0) if there is no irradiance if self.Isc == 0: return np.nan # short current (SC) conditions (Vcell = 0) - if self.model=='pvsyst': - # temperature adjustment to diode factor - N1 = self.N1 * self.MU_GAMMA * (self.Tcell - self.pvconst.T0) - elif self.model in ['desoto', '2diode']: - N1 = self.N1 Vdiode_sc = self.Isc * self.Rs # diode voltage at SC - Idiode1_sc = self.Isat1 * (np.exp(Vdiode_sc / N1 / self.Vt) - 1.) + Idiode1_sc = self.Isat1 * (np.exp(Vdiode_sc / self.N1 / self.Vt) - 1.) Idiode2_sc = self.Isat2 * (np.exp(Vdiode_sc / self.N2 / self.Vt) - 1.) Ishunt_sc = Vdiode_sc / self.Rsh # diode voltage at SC # photogenerated current coefficient @@ -165,18 +195,8 @@ def Isat1(self): """ _Tstar = self.Tcell ** 3. / self.pvconst.T0 ** 3. # scaled temperature _inv_delta_T = 1. / self.pvconst.T0 - 1. / self.Tcell # [1/K] - if self.model == 'pvsyst': - # temperature adjustment to diode factor - N1 = self.N1 * self.MU_GAMMA * (self.Tcell - self.pvconst.T0) - Eg = self.Eg - elif self.model == 'desoto': - N1 = 1.0 # desoto doesn't use diode factor in band gap term - Eg = self.Eg * (1 - 0.0002677) * (self.Tcell - self.pvconst.T0) - elif self.model == '2diode': - N1 = self.N1 - Eg = self.Eg _expTstar = np.exp( - Eg * self.pvconst.q / N1 / self.pvconst.k * _inv_delta_T + self.Eg * self.pvconst.q / self.N1 / self.pvconst.k * _inv_delta_T ) return self.Isat1_T0 * _Tstar * _expTstar # [A] Isat1(Tcell) @@ -209,11 +229,15 @@ 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. - ) + if self.model == '2diode': # does not use ideality factors + 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. + ) + else: + C = self.Aph * self.Isc / self.Isat1 + return self.N1 * self.Vt * np.log(1. + C) def _VocSTC(self): """ @@ -221,17 +245,23 @@ def _VocSTC(self): 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. - ) + Vt_sc = self.pvconst.k * self.pvconst.T0 / self.pvconst.q + if self.model == '2diode': + Idiode1_sc = self.Isat1_T0 * (np.exp(Vdiode_sc / Vt_sc) - 1.) + Idiode2_sc = self.Isat2_T0 * (np.exp(Vdiode_sc / 2. / Vt_sc) - 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 Vt_sc * np.log( + ((-self.Isat2_T0 + np.sqrt(delta)) / 2. / self.Isat1_T0) ** 2. + ) + else: + Isat = self.Isat1_T0 * ( + np.exp(Vdiode_sc / Vt_sc / self.N1_0) - 1.) + return self.N1_0 * Vt_sc * np.log(1. + self.Isc0_T0 / Isat) @property def Igen(self): @@ -266,15 +296,15 @@ def calcCell(self): Vquad4 = Vff + delta_Voc * np.flipud(self.pvconst.negpts) 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.) + Idiode1 = self.Isat1 * (np.exp(Vdiode / self.N1 / self.Vt) - 1.) + Idiode2 = self.Isat2 * (np.exp(Vdiode / self.N2 / 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 + 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 @@ -293,7 +323,7 @@ def calcCell(self): # http://en.wikipedia.org/wiki/William_Shockley @staticmethod - def f_Icell(Icell, Vcell, Igen, Rs, Vt, Isat1, Isat2, Rsh): + def f_Icell(Icell, Vcell, Igen, Rs, Vt, Isat1, Isat2, Rsh, N1, N2): """ Objective function for Icell. :param Icell: cell current [A] @@ -308,8 +338,8 @@ def f_Icell(Icell, Vcell, Igen, Rs, Vt, Isat1, Isat2, Rsh): """ # 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 + Idiode1 = Isat1 * (np.exp(Vdiode / N1 / Vt) - 1.) # diode current + Idiode2 = Isat2 * (np.exp(Vdiode / N2 / Vt) - 1.) # diode current Ishunt = Vdiode / Rsh # shunt current return Igen - Idiode1 - Idiode2 - Ishunt - Icell @@ -320,12 +350,13 @@ def calcIcell(self, Vcell): :return: Icell """ args = (np.float64(Vcell), self.Igen, self.Rs, self.Vt, - self.Isat1, self.Isat2, self.Rsh) + self.Isat1, self.Isat2, self.Rsh, self.N1, self.N2) 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 f_Vcell(Vcell, Icell, Igen, Rs, Vt, Isat1, Isat2, Rsh, N1, N2): + return PVcell.f_Icell(Icell, Vcell, Igen, Rs, Vt, Isat1, Isat2, Rsh, + N1, N2) def calcVcell(self, Icell): """ @@ -334,7 +365,7 @@ def calcVcell(self, Icell): :return: Vcell """ args = (np.float64(Icell), self.Igen, self.Rs, self.Vt, - self.Isat1, self.Isat2, self.Rsh) + self.Isat1, self.Isat2, self.Rsh, self.N1, self.N2) return newton(self.f_Vcell, x0=self.Voc, args=args) def plot(self): From c40d98c5b7433e06eeedffb439d5f122dfd62a81 Mon Sep 17 00:00:00 2001 From: Cliff Hansen Date: Sat, 30 Nov 2019 11:10:10 -0700 Subject: [PATCH 04/16] correct Isat1 --- pvmismatch/pvmismatch_lib/pvcell.py | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/pvmismatch/pvmismatch_lib/pvcell.py b/pvmismatch/pvmismatch_lib/pvcell.py index 2210cb0..3fb577c 100644 --- a/pvmismatch/pvmismatch_lib/pvcell.py +++ b/pvmismatch/pvmismatch_lib/pvcell.py @@ -195,9 +195,20 @@ def Isat1(self): """ _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.N1 / self.pvconst.k * _inv_delta_T - ) + k_b = self.pvconst.k / self.pvconst.q + if self.model == 'pvsyst': # include diode factor + _expTstar = np.exp( + self.Eg / k_b / self.N1 * _inv_delta_T + ) + elif self.model == 'desoto': + + _expTstar = np.exp( + self.Eg_0 / k_b / self.pvconst.T0 - self.Eg / k_b / self.Tcell + ) + else: + _expTstar = np.exp( + self.Eg / k_b * _inv_delta_T + ) return self.Isat1_T0 * _Tstar * _expTstar # [A] Isat1(Tcell) @property From 54df6a9be32ee5a4eb6b945a7c829f0525399515 Mon Sep 17 00:00:00 2001 From: Cliff Hansen Date: Sat, 30 Nov 2019 11:15:11 -0700 Subject: [PATCH 05/16] proofread --- pvmismatch/pvmismatch_lib/pvcell.py | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/pvmismatch/pvmismatch_lib/pvcell.py b/pvmismatch/pvmismatch_lib/pvcell.py index 3fb577c..93023c1 100644 --- a/pvmismatch/pvmismatch_lib/pvcell.py +++ b/pvmismatch/pvmismatch_lib/pvcell.py @@ -71,7 +71,7 @@ def __init__(self, model=MODEL, Rs=RS, Rsh_STC=RSH_STC, Rsh_0=RSH_0, mu_gamma=MU_GAMMA, alpha_Isc=ALPHA_ISC, Tcell=TCELL, Ee=1., pvconst=PVconstants()): # user inputs - if MODEL in ['2diode', 'desoto', 'pvsyst']: + if model in ['2diode', 'desoto', 'pvsyst']: self.diode_model = model else: raise ValueError('model must be one of ''2diode'', ''desoto'' or ' @@ -153,7 +153,7 @@ def N1(self): @property def N2(self): - return self.N2 + return self.N2_0 @property def Eg(self): @@ -207,7 +207,7 @@ def Isat1(self): ) else: _expTstar = np.exp( - self.Eg / k_b * _inv_delta_T + self.Eg / k_b /self.N1 * _inv_delta_T ) return self.Isat1_T0 * _Tstar * _expTstar # [A] Isat1(Tcell) @@ -219,12 +219,10 @@ def Isat2(self): if self.model=='2diode': _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.N2 / self.pvconst.k * _inv_delta_T - ) + _expTstar = np.exp(self.Eg * self.pvconst.q / self.pvconst.k / + self.N2 * _inv_delta_T) return self.Isat2_T0 * _Tstar * _expTstar # [A] Isat2(Tcell) - else: - return 0.0 + return 0.0 @property def Isc0(self): From d3caebbc984acb17dbdc19c0ae9565067fd39eb1 Mon Sep 17 00:00:00 2001 From: Cliff Hansen Date: Fri, 3 Jan 2020 10:18:52 -0700 Subject: [PATCH 06/16] correct PVCell.diode_model attribute --- pvmismatch/pvmismatch_lib/pvcell.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/pvmismatch/pvmismatch_lib/pvcell.py b/pvmismatch/pvmismatch_lib/pvcell.py index bdcb1f0..3179ba3 100644 --- a/pvmismatch/pvmismatch_lib/pvcell.py +++ b/pvmismatch/pvmismatch_lib/pvcell.py @@ -147,7 +147,7 @@ def Isc(self): @property def N1(self): - if self.model == 'pvsyst': + if self.diode_model == 'pvsyst': return self.N1_0 + self.mu_gamma * (self.Tcell - self.pvconst.T0) return self.N1_0 @@ -157,15 +157,15 @@ def N2(self): @property def Eg(self): - if self.model == 'desoto': + if self.diode_model == 'desoto': return self.Eg_0 + self.dEg_dT * (self.Tcell - self.pvconst.T0) return self.Eg_0 @property def Rsh(self): - if self.model == 'desoto': + if self.diode_model == 'desoto': return self.Rsh_STC / self.Ee - elif self.model == 'desoto': + elif self.diode_model == 'desoto': rsh_tmp = self.Rsh_STC - self.Rsh_0 * np.exp(self.Rsh_exp) / \ (1. - np.exp(self.Rsh_exp)) rsh_base = np.maximum(0.0, rsh_tmp) @@ -196,11 +196,11 @@ def Isat1(self): _Tstar = self.Tcell ** 3. / self.pvconst.T0 ** 3. # scaled temperature _inv_delta_T = 1. / self.pvconst.T0 - 1. / self.Tcell # [1/K] k_b = self.pvconst.k / self.pvconst.q - if self.model == 'pvsyst': # include diode factor + if self.diode_model == 'pvsyst': # include diode factor _expTstar = np.exp( self.Eg / k_b / self.N1 * _inv_delta_T ) - elif self.model == 'desoto': + elif self.diode_model == 'desoto': _expTstar = np.exp( self.Eg_0 / k_b / self.pvconst.T0 - self.Eg / k_b / self.Tcell @@ -216,7 +216,7 @@ def Isat2(self): """ Diode two saturation current at Tcell in amps. """ - if self.model=='2diode': + if self.diode_model=='2diode': _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 / @@ -238,7 +238,7 @@ def Voc(self): Estimate open circuit voltage of cells. Returns Voc : numpy.ndarray of float, estimated open circuit voltage """ - if self.model == '2diode': # does not use ideality factors + if self.diode_model == '2diode': # does not use ideality factors C = self.Aph * self.Isc + self.Isat1 + self.Isat2 delta = self.Isat2 ** 2. + 4. * self.Isat1 * C return self.Vt * np.log( @@ -255,7 +255,7 @@ def _VocSTC(self): """ Vdiode_sc = self.Isc0_T0 * self.Rs # diode voltage at SC Vt_sc = self.pvconst.k * self.pvconst.T0 / self.pvconst.q - if self.model == '2diode': + if self.diode_model == '2diode': Idiode1_sc = self.Isat1_T0 * (np.exp(Vdiode_sc / Vt_sc) - 1.) Idiode2_sc = self.Isat2_T0 * (np.exp(Vdiode_sc / 2. / Vt_sc) - 1.) Ishunt_sc = Vdiode_sc / self.Rsh # diode voltage at SC From 7de0a40f7bc5ce8e5e4ff336fc79d6f972e0f514 Mon Sep 17 00:00:00 2001 From: Cliff Hansen Date: Fri, 3 Jan 2020 10:31:44 -0700 Subject: [PATCH 07/16] add notebooks --- notebooks/basic_iv_curves.ipynb | 175 ++++++++++++++++++++++++++++++++ 1 file changed, 175 insertions(+) create mode 100644 notebooks/basic_iv_curves.ipynb diff --git a/notebooks/basic_iv_curves.ipynb b/notebooks/basic_iv_curves.ipynb new file mode 100644 index 0000000..3f4d622 --- /dev/null +++ b/notebooks/basic_iv_curves.ipynb @@ -0,0 +1,175 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# add capability to import from parent director\n", + "import sys, os\n", + "sys.path.insert(1, os.path.join(sys.path[0], '..'))\n", + "\n", + "import pvmismatch as pvm\n", + "import numpy as np\n", + "\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Setting PV system layout cell and module parameters\n", + "str_len = 6 # number of modules in a string\n", + "str_num = 3 # number of (parallel connected) strings in the array\n", + "v_bypass = np.float64(-0.5) # [V] trigger voltage of bypass diode\n", + "cell_area = np.float64(246.49) # [cm^2] cell area\n", + "Isc0_T0 = 9.68 # [A] reference short circuit current\n", + "ncols_per_substr=[2]*3 # 3 bypass diodes with 2 series connected cell-columns\n", + "nrows=10 # number of cell rows in the module\n", + "\n", + "# Building PV modules and system\n", + "pv_mod_pattern = pvm.pvmodule.standard_cellpos_pat(nrows=nrows,\n", + " ncols_per_substr=ncols_per_substr)\n", + "pv_mod = pvm.pvmodule.PVmodule(cell_pos=pv_mod_pattern, pvcells=None,\n", + " pvconst=None, Vbypass=v_bypass, cellArea=cell_area)\n", + "\n", + "pv_cells = pv_mod.pvcells\n", + "for c in pv_cells:\n", + " c.update(Isc0_T0 = Isc0_T0) # updating short circuit currents\n", + "\n", + "pv_mod.setSuns(cells=list(range(0, len(pv_cells))), Ee=[1]*len(pv_cells))\n", + "\n", + "pv_str = pvm.pvstring.PVstring(numberMods=str_len, pvmods=[pv_mod]*str_len)\n", + "\n", + "pv_sys = pvm.pvsystem.PVsystem(numberStrs=str_num, pvstrs=[pv_str]*str_num,\n", + " numberMods=[str_len]*str_num,\n", + " pvmods=[pv_mod]*str_len)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pv_cells[0].plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzs3Xl8VNX9//HXOyEQIIEACQmyhX0JIgKKKCigLO62tSq2Lm2tXbTan22/WrtpW1vtYmvV1upXK7ZVtK1+tW6ASkQUF8CVTdkXIWEVwprl8/vj3uAYsgyZSWZCPs/HYx6Zu537yQ3MZ865554jM8M555xLNimJDsA555yrjico55xzSckTlHPOuaTkCco551xS8gTlnHMuKXmCcs45l5Q8QbkmSVK+JJPUIp77JlpTijUakhZJGleP474kaWYDhOSaEE9QrsFJWi3pgKTsKuvfCT+M8xMTWd0k3STpHzVs+6GkOdWszw5/3yE1HNdf0r8kbZH0iaT3JF0nKTXe8cci/Nv0jaUMMysws8I6znNIUjazf5rZpFjO7Zo+T1CusawCplYuSDoaaJ24cOLi78CJknpVWX8R8L6ZfVD1AEl9gDeAdcDRZtYe+CIwEsiMZ3CJrIUdKTVAl1ieoFxj+TtwacTyZcBDkTtIai/pIUmbJa2R9GNJKeG2VEm/C2sdK4Ezqxy7WtJpEcu11XzaS7pf0kZJGyT9sj61FzNbD7wEXFJl06XAtBoOuxl4zcyuM7ONYTnLzOxiM9sRsd+XJK0Nf98fRcR+vKR5knaE8d8lqWXEdpN0laSPgI/CdXdIWidpp6QFksZG7J8q6UZJKyTtCrd3j6gZviupRNKF4f5nhTXfHZJekzQ0oqzVkq6X9B6wW1KLyL9LGPv8MI4iSbeHh1aea0d4rtGSLpc0N6LsAkmzJG0Lj72xjjLdEcATlGssrwPtJA0Kk8GFQNUEcifQHugNnELwQf+VcNvXgbOAYwlqG+fHEMs0oAzoG5Y3CbgihrIOJihJA4BhwCM17H8a8O8oyh0DDABOBX4qaVC4vhz4f0A2MDrc/u0qx54HjAIGh8tvhTF1BB4G/iUpPdx2HUHN9gygHfBVYI+ZnRxuP8bMMszsUUnDgQeAbwCdgL8CT0lqFXHuqQRfHrLMrKxKXHcAd5hZO6AP8Fi4vvJcWeG55kUeJCkTeAF4HjiK4O/2Yh1luiOAJyjXmCprUROBpcCGyg0RSeuHZrbLzFYDv+fTD/8LgD+a2Toz2wb8uj4BSMoFTge+a2a7zawY+ANBs1x9PAHkSjoxXL4UeM7MNtewfydgYxTl3mxme83sXeBd4BgAM1tgZq+bWVl4jf5KkMwj/drMtpnZ3vCYf5jZ1vCY3wOtCJIfBIn5x2EtzszsXTPbWkNMXwf+amZvmFm5mU0D9gMnROzzp/BvtLea40uBvpKyzazEzF6P4jpA8MVkk5n93sz2hf8+3oixTNcEeIJyjenvwMXA5VRp3iOoEbQE1kSsWwN0Dd8fRXDfJnJbffQE0oCNYTPVDoIP+c51HRg2hZWEr3sAzGwP8C/gUkkCvkTNzXsAW4EuUcS5KeL9HiAjjKG/pKclbZK0E/gVwbWLFHmdkPQ9SUvCDhk7CGqplcd0B1ZEEQ8E1+57ldctLKs7wd+m2nNX8TWgP7BU0luSzoryvLXFWN8yXRPgCco1GjNbQ9BZ4gzg8SqbtxB8G+4Zsa4Hn9ayNhJ8UEVui7QbaBOxnFdDGOsIvvVnm1lW+GpnZgVRxP+rsAkqw8y+GbFpGkENbyJBR4enaynmBeALdZ2rFn8hqH32C5u1bgRUNdTKN+H9puvD+DqYWRbwScQx6wiaxqKxDrgl4rplmVkbM4tszqxxegQz+8jMphJ8GbgN+LektrUdU1eMtZTpjgCeoFxj+xowwcx2R640s3KC+we3SMqU1JPg/kjlfarHgGskdZPUAbihSrnvABdJSpNU4z2qsGPCTOD3ktpJSpHUR1LVZrLD8QqwA7gXmG5mB2rZ92cEPf9+KykPQFJfSf+QlBXFuTKBnUCJpIHAt6LYvwzYDLSQ9FOCe02V/hf4haR+CgyV1CncVkRwP7DSfcA3JY0K920r6czwHlGdJH1ZUo6ZVRBcLwjuqW0GKqqcK9LTQJ6k70pqFf77GFVHme4IUK+uoJL+FMVuO83sx/Up3x25zKy25qTvEHSUWAnsI/hAfCDcdh9BU867BB/QvwMmRBz7E4KOCduBlwk6A3Ss4TyXArcCiwk+wFcSfPuuFzMzSQ8RJJ+qTZdV910haTTwS2CRgu7Yq4G/AbuAupLU9wkS4f8AbwOP8tnrUNUM4DngQ4Ja5h/4bDPc7QT3pGYSNPstBT4XbrsJmCapNXClmT0m6evAXUA/YC8wl0974dVlCnC7pDYETbQXmdk+AEm3AK9KSgv3O8jMdkmaSNAh4mcENeA/EnTXr7FM1/SpPhMWSloD/LSO3W4ws0F17OOcc85Vq74P0/0h7MFTo7AZxjnnnKuXetWgai1QOs7M3oproc4555qduAxHImkwwXMkUwl6CI2MR7nOOeear3onqLCX1dTwVUbQPXhk+PCgc845F5P69uJ7jeBhv+nA+Wb2kaRVjZ2csrOzLT8/P65l7t69m7Ztk/sxCo8xPjzG+PAY46M5xbhgwYItZpZT545mdtgv4ElgLUF30xPDdSvrU1YsrxEjRli8zZ49O+5lxpvHGB8eY3x4jPHRnGIE5lsUn/H1elDXzM4FjgYWAjdLWgV0kHR8fcpzzjnnqqr3SBJm9omZPWBmEwlGTv4p8EdJtY3F1Wi27z7A8uJdVFTEt5eic865xhGXoY7MrNjM7jSzEwmmCUi4R+ev47Tb57C/rCLRoTjnnKuHeiUoSTfVtM2CAUFr3cc555yrS327mV8RDvVfExE8F3VTPct3zjnXzNU3Qd1HMMhmXfs455xz9VKvBGVmN8c7EOeccy6SzwflnHMuKXmCcs45l5Q8QTnnnEtK9R2L706gxidgzeyaekfknHPOUf9efPPjGoVzzjlXRX178dU6m65zzjkXK78H5ZxzLil5gnLOOZeUPEE555xLSnFNUJK+LelCSfWeSt4555yD+NegRDDdxuNxLtc551wzE1NNR1IvM1tVuWxmd1dd55xzztVHrDWo/1Sz7t8xlumcc87VeySJgUAB0F7S5yM2tQPS4xGYc8655q2+TXwDgLOALODsiPW7gK/HGpRzzjlX35EkngSelDTazOYdzrGSugMPAXlABXCvmd0hqSPwKJAPrAYuMLPt9YnPOedc0xdrd/Dlkm4kSCoHyzKzr9ZyTBnwPTNbKCkTWCBpFnA58KKZ3SrpBuAG4PoY43POOddExZqgngReAV4AyqM5wMw2AhvD97skLQG6AucC48LdpgGFeIJyzrlmK9YE1cbM6p1EJOUDxwJvALlh8sLMNkrqHGNszjnnmjCZ1TitU90HS78EXjOzZ+txbAbwMnCLmT0uaYeZZUVs325mHao57krgSoDc3NwR06dPr7b8Z1ce4LEPS/nrxDa0SlXUcZWUlJCRkXGYv03j8hjjw2OMD48xPppTjOPHj19gZiPr3NHM6v0i6LVXAewDdobLO6M4Lg2YAVwXsW4Z0CV83wVYVlc5I0aMsJr8pXC59bz+aduzv6zGfaoze/bsw9o/ETzG+PAY48NjjI/mFCMw36LIMTE9qGtmmWaWYmbpZtYuXG5X2zGSBNwPLDGz2yM2PQVcFr6/jOD+lnPOuWYqpgSlwJcl/SRc7i7p+DoOOwm4BJgg6Z3wdQZwKzBR0kfAxHDZOedcMxVrJ4k/EzTxTQB+AZQAdwPH1XSAmc0lGFS2OqfGGI9zzrkjRKwJapSZDZf0NoCZbZfUMg5xOeeca+ZiHSy2VFIqYACScghqVM4551xMYk1QfwKeADpLugWYC/wq5qicc841ezE18ZnZPyUtILh3JOA8M1sSl8icc841a/VOUJJSgPfMbAiwNH4hOeecczE08ZlZBfCupB5xjMc555wDYu/F1wVYJOlNYHflSjM7J8ZynXPONXOxJqib4xKFc845V0Us96BSgZ+Y2WlxjMc555wDYrsHVQ7skdQ+jvE455xzQOxNfPuA98MZcSPvQV0TY7nOOeeauVgT1DPhyznnnIurWB/UnRavQJxzzrlIMSUoSasIx+GLZGa9YynXOeeci7WJL3LK3nTgi0DHGMt0zjnnYp5Rd2vEa4OZ/ZFgbijnnHMuJrE28Q2PWEwhqFFlxhSRc845R+xNfL+PeF8GrAYuiLFM55xzLuZefOPjFYhzzjkXqV73oCRdJ+lr1az/jqTvxh6Wc8655q6+nSS+Cvy9mvX3htucc865mNQ3QZmZHahm5X6CmXWdc865mNS7m7mk3GjW1XDsA5KKJX0Qsa6jpFmSPgp/dqhvbM4555q++iao3wLPSDpFUmb4Ggf8F/hdFMc/CEypsu4G4EUz6we8GC4755xrpurVi8/MHpK0Gfg5MIRguKNFwM/M7Lkojp8jKb/K6nOBceH7aUAhcH194nPOOdf0yeyQofQa58RBgnrazIaEyzvMLCti+3YzO6SZT9KVwJUAubm5I6ZPn15t+c+uOsBjy0rJbq3P3BRTxEJ1N8sqKipISUn57LYajjnk+Gj3+0w81W+tKWaAivJyUlJTaz9PlWNqiqG288SyX3l5OalhjFWPqf16RLlfDRe76jG1/R3Lyspo0eLQ72jR/K6HnCfK/Wo6pqb9yqvEGNV5Dvnbq6ZNNZYb7X4AZaWltEhLi+rf4uH8fWpS098nBUhJEakK1qcKUsKfpQcO0Dq91cF1KRHbUxQck5oCaSmQlqLgZ2rwvmXqp+taphKWH/9b7SUlJWRkZMS93HiKV4zjx49fYGYj69ov1gd1G52Z3UvQW5CRI0fauHHjqt2vR0EJFRkrKK+wyuM+LeOQMj99X1RUROfc3DqPiVxhEQuRZVXN/TXuV0s8VHPMlq1b6dSpU5Vjqo+19vNU/+XEavjdDtlWyzXYsWMHWVlZh5432rJriLO2a2U1bKjuGAN2799FRpu21Zd1yN+u+niqqu2aHFKWHVpe1Wu1Z88e2rRJr/VvV/PfO7q/XVWHW/b+/eW0bJla5zFV/xIx/72r7FdRYZRbBeUVRlmFVTm3gEP6ddWLBG3SUmnXOo3M9BZkpqfRLvxZudyhTRo5ma3onJke/mxFVpu0WhNbYWEhNX2eJYvGjjGZElSRpC5mtlFSF6A4lsJ652Twuy8ec9jHBX+AY2M5dYMLYjwu0WHUKohxdKLDqFUQ49hEh1Er/9CqvyBhGeUVxuyX53DiSWPC5BUkscpXWYVRUWEcKK/gQFkF+0or2F9WfvDn/rIK9pcGP/eVBuv3HChn575Sdu0rZde+MraUHGDVlt3s3FfGrn2llJYf+g0gLVXkZLSiS1ZrenZsQ89ObcnPDn92apOAK5T8kilBPQVcBtwa/nwyseE455qylBSRgkhLhdYtRPvWaY1yXjNj94FyinfuY/Ou/RTv2n/wZ/GufXy8Yy/zVm7l8bc3fOa4Dq3EsavfYnCXdgw+qh1Hd21Ptw6tG6Q5samIdbDYXOBXwFFmdrqkwcBoM7u/juMeIegQkS1pPfAzgsT0WDhCxVqCqTucc65JkURGqxZk5GTQO6fm+zX7SstZt20Pq7fuYeXmEgrf/YgN2/fy8oebD96ayGuXzqjeHTm+V0dG9epEn5y2zSphxVqDehD4G/CjcPlD4FGg1gRlZlNr2HRqjPE451yTkJ6WSr/cTPrlZgK5DLB1jBt3MvtKy/mwaBfvrtvBG6u28dqKrTz5zscAdM5sxamDOnPqwFxO6ptN64h7f0eiWBNUtpk9JumHAGZWJqk8DnE551yzlJ6WytBuWQztlsUlo/MxM1Zv3cObq7Yy58Mt/PfdjTzy5jrS01I4uV8O5x3blQkDO5OeduQlq1gT1G5JnQg720g6Afgk5qicc84BQZNhr+y29Mpuy4XH9eBAWQVvrtrGrMWbeO6DTcxcXERmegvOGtqF80d0Y3iPDkdMM2CsCeo6gs4NfSS9CuQA58cclXPOuWq1bJHCmH7ZjOmXzU/PLuC1FVt4YuEGnnznYx55cx2Du7TjshN7cs4xXZt8E2Cs80EtlHQKMIDgQYNlZlYal8icc87VKjVFjO2Xw9h+OfxifxlPvfsx015bzfX/eZ9fPbuUi0f14GtjepGd0SrRodZLvRKUpM/XsKm/JMzs8Rhics45d5jatmrB1ON7cNFx3Xlz1TYefG0197y8gr+9uoqLj+/JN07pTW679ESHeVjqW4M6u5ZtBniCcs65BJDEqN6dGNW7E8uLS/hz4XKmzVvNP15fw5dO6ME1E/rRoW3LRIcZlfoOFvuVeAfinHMuvvp2zuD2C4bx3VP7c9fsj5j22mr+vWA93x7Xl6+clJ/0Pf9ifVD3p9WtN7Ofx1Kuc865+OnRqQ2/Of8Yrhjbm9ueW8ptzy/loXmr+eEZgzh7aJek7fVX7wkLQ7sjXuXA6UB+jGU655xrAP1zM7n/8uOYfuUJdMpoyTWPvM2lD7zJqi27Ex1atWLtxff7yGVJvyPodu6ccy5JndC7E09eNYZ/vrGG3z6/jMl/nMO3x/Xhm6f0Sapmv1hrUFW1AXrHuUznnHNxlpoiLh2dz4vfO4XJBXn88YWPOP2OV5i/eluiQzsopgQl6X1J74WvRcAy4I74hOacc66hdW6Xzp1Tj+XvXzue0vIKLvjrPG57fin7yxI/al2sI0mcFfG+DCgys7IYy3TOOdfIxvbL4fnvnswv/ruYvxSuYPbSYv540TAG5rVLWEz1qkFJ6iipI7Ar4rUXaBeud84518RktGrBbecP5X8vHcmWkv2cc+er3PPypzOTN7b61qAWEDyQK6AHsD18n0Uwl1OvuETnnHOu0Z02OJcZPU7mxife59bnlvLq8i384cJhjR5HvWpQZtbLzHoDM4CzzSzbzDoRNPn5KBLOOdfEdcpoxT1fHsGvPnc0b6zaxpl/eoVl2xr3vlSsvfiOM7NnKxfM7DnglBjLdM45lwQkcfGoHjzx7RNpnZbKbW/t4y+FK6hopCa/WBPUFkk/lpQvqaekHwFb4xGYc8655FBwVHv++50xjMhN5bbnl3Ll3+ezc1/DT1wRa4KaSjAH1BPA/wGdw3XOOeeOIJnpaXz7mFbcfE4Bhcs287m7X23wEShiSlBmts3MriVo1htrZteaWfI85eWccy5uJHHZifn844pRbNt9gHPvmsvLH25usPPF+qDu0ZLeBt4HFklaIGlIfEJzzjmXjE7o3Ymnrh7DUVmt+crf3uS+OSsxi/99qVib+P4KXGdmPc2sJ/A94N76FiZpiqRlkpZLuiHG2JxzzjWQ7h3b8J9vncjkgjxueXYJ3/vXu3EffSLWBNXWzGZXLphZIdC2PgVJSgXuJhgRfTAwVdLgGONzzjnXQNq2asHdFw/nu6f14/GFG7j0/jfZsedA3MqPNUGtlPSTsBdfvqQfA6vqWdbxwHIzW2lmB4DpwLkxxuecc64BpaSI757WnzsuGsbba3fw+T+/xpqt8ek8EetYfF8FbiZ4OFfAHKC+s+12BdZFLK8HRlXdSdKVwJXhYomkZfU8X02ygS1xLjPePMb48Bjjw2OMjyMixo+A/B/UWU7PaE4W63xQ24FrYikjQnVTOh5y183M7iWG+1x1BiHNN7ORDVV+PHiM8eExxofHGB8e46HqlaAk1TopoZmdU49i1wPdI5a7AR/XoxznnHNHgPrWoEYTNMc9ArxB9bWfw/UW0E9SL2ADcBFwcRzKdc451wTVN0HlARMJRo24GHgGeMTMFtU3EDMrk3Q1wQC0qcADsZQXgwZrPowjjzE+PMb48Bjjw2OsQrE+XCWpFUGi+i3wczO7Mx6BOeeca97q3UkiTExnEiSnfOBP+FQbzjnn4qReNShJ04AhwHPAdDP7IN6BOeeca97q+6DuJUB/4FrgNUk7w9cuSTvjF17jaQrDLElaLel9Se9Imp/oeCpJekBSsaQPItZ1lDRL0kfhzw5JGONNkjaE1/MdSWckML7ukmZLWiJpkaRrw/VJcx1riTFprmMYT7qkNyW9G8Z5c7i+l6Q3wmv5qKSWSRjjg5JWRVzLxp/G9rNxpkp6W9LT4XLjXkMza/Yvgk4ZK4DeQEvgXWBwouOqJs7VQHai46gmrpOB4cAHEet+A9wQvr8BuC0JY7wJ+H6ir18YSxdgePg+E/iQYMivpLmOtcSYNNcxjE1ARvg+jaCn8QnAY8BF4fp7gG8lYYwPAucn+hpGxHkd8DDwdLjcqNcw1qGOjhQ+zFIMzGwOUHWalXOBaeH7acB5jRpUFTXEmDTMbKOZLQzf7wKWEIyukjTXsZYYk4oFSsLFtPBlwATg3+H6RF/LmmJMGpK6EfQz+N9wWTTyNfQEFahumKWk+49H8A94ZjityZV17p1YuWa2EYIPNoLJLJPR1ZLeC5sAE9oMWUlSPnAswbfqpLyOVWKEJLuOYdPUO0AxMIughWSHmZWFuyT8/3jVGM2s8lreEl7LP4Sd0RLlj8D/ABXhcica+Rp6ggpENcxSEjjJzIYTjPh+laSTEx1QE/cXoA8wDNgI/D6x4YCkDOA/wHfNLCnv51YTY9JdRzMrN7NhBCPSHA8Mqm63xo2qysmrxKhgLr0fAgOB44COwPWJiE3SWUCxmS2IXF3Nrg16DT1BBZrEMEtm9nH4sxh4guA/XrIqktQFIPxZnOB4DmFmReGHRAVwHwm+npLSCD74/2lmlY9sJNV1rC7GZLuOkcxsB1BIcH8nS1LlozVJ8388IsYpYTOqmdl+4G8k7lqeBJwjaTXBLY8JBDWqRr2GnqACB4dZCnulXATUOt5gY5PUVlJm5XtgEpDM3fufAi4L318GPJnAWKpV+cEf+hwJvJ5h+/79wBIzuz1iU9Jcx5piTKbrCCApR1JW+L41cBrB/bLZwPnhbom+ltXFuDTiy4gI7u8k5Fqa2Q/NrJuZ5RN8Hr5kZl+ika9hzCNJHCnCrrF/5NNhlm5JcEifIak3Qa0JggesH06WGCU9AowjGIq/CPgZ8H8EPX56AGuBL5pZwjop1BDjOIJmKSPoIfmNyvs9CYhvDPAK8D6ftvnfSHCPJymuYy0xTiVJriOApKEEN/BTCb6EP2ZmPw//D00naDp7G/hyWFNJphhfAnIImtPeAb4Z0ZkiISSNI+ileVZjX0NPUM4555KSN/E555xLSp6gnHPOJSVPUM4555KSJyjnnHNJyROUc865pOQJyjnnXFLyBOWccy4peYJyzjmXlDxBOeecS0qeoJxzziUlT1DOOeeSkico55xzSckTlGtSJOVLsog5aeKyb7KRdJOkfyQ6jniQNFbSsnoe+5yky+re0x2JPEG5BiNptaQDkrKrrH8nTBz5iYmsbmGCKJVUImmHpNckja5h36WSvlrN+mslza/lHBdLmh+eY2P4YTwmnr9HrCRdLmluLGWY2StmNiCKcx2SlM3sdDObFsv5XdPlCco1tFUE8wUBIOlooHXiwjksj5pZBsH8PHOBx8OJ5KqaBlxazfpLwm2HkHQdwfxjvwJyCeZ7+jNwbhzirnquhNUgm2Lt1SUPT1Cuof2dz354XwY8FLmDpPaSHpK0WdIaST+WlBJuS5X0O0lbJK0Ezqxy7GpJp0Us19g0Fp7n/rC2skHSLyWl1vULmFkpQaLJAzrV8DuOkdQz4lyDgKHAI9XFAfwcuMrMHjez3WZWamb/NbMfROzaMrwuuyQtkjQyoowbJK0Ity2W9LmIbZdLelXSHyRtA26S1EfSS5K2htfyn5UzuobHdJf0ePg32CrprvB3uAcYXVmTDPdtFf5N1koqknRPOCssksZJWi/pekmbgL9Vros41/Xh9d8laZmkUyVNIZj88MLwXO+G+xZKuiLi2K9LWhLxew+vqcy6/q4u+XmCcg3tdaCdpEFhMrgQqJpA7gTaA72BUwgS2lfCbV8HzgKOBUby6XTT9TENKAP6huVNAq6o9QiCD2TgcmC9mW2put3M1hNMhX1JxOpLgWer2x8YDaTz6QzJNTmHYPbSLIKp3++K2LYCGEtw3W4G/qHPTr0+ClgJdAZuIZih9dfAUcAgoDtwU/j7pQJPA2uAfKArMN3MlgDfBOaZWYaZVSa024D+BLPo9g33/2nEufMIZlztCVwZ+QtJGgBcDRxnZpnAZGC1mT1PUJt8NDzXMVUvhqQvhjFfCrQLr8/Wmsqs9oq6JsUTlGsMlbWoicBSYEPlhoik9UMz22Vmq4Hf8+mH/QXAH81sXTjV+a/rE4CkXOB04LthjaUY+ANwUS2HXRDWGtYBI4Dzatl3WmXMYe3vS9TQvEdQC9tiZmV1hD3XzJ41s3KCa3jwQ9vM/mVmH5tZhZk9CnwEHB9x7MdmdqeZlZnZXjNbbmazzGy/mW0Gbif4MkB43FHAD8Jrs8/Mqr3vFDZxfh34f2a2zcx2ESSWyOtYAfwsPNfeKkWUA62AwZLSzGy1ma2o4zpUugL4jZm9ZYHlZrYmxjJdEvP2YdcY/g7MAXpRpXkPyAZaEnx7r7SG4Fs5BB+c66psq4+eQBqwMeI2UkqVsqt6zMy+XHWlpEVheQCnm9krwOPAnyWdALQJX8/UUO5WIFtSizqS1KaI93uA9MpjJF0KXEdQ4wHIILiWlT7ze0nqDPyJoNaVSfC7bw83dwfWRJEwIbgf1wZYEHEdBUQ2lW42s33VHWxmyyV9l6AmVCBpBnCdmX0cxbm7E9Qc41mmS2Jeg3INLvyWuwo4g+CDPNIWoJRPP/Ah6DBQWcvaSPDBFLkt0m6CD8xKeTWEsQ7YD2SbWVb4amdmBVH/IiEzKwiboTLC5ISZ7QH+TVBTvISgiexADUXMA/ZRe42sRuG9rvsImrU6hU1vHxAkioNhVjns1+G6oWbWDvhyxP7rgB41dGioWs4WYC9QEHEd24edSWo65rMFmj1sZmMI/uZG0GRY53FhnH0Os0zXhHmCco3la8AEM9sduTJsvnoMuEVSZvjhex2f3qd6DLhGUjdJHYAbqpT7DnCRpLSwE0G196jMbCMwE/i9pHacDfySAAAgAElEQVSSUsKOA6dUt389TSNorvwCNTfvYWafENyzuVvSeZLahPGfLuk3UZynLcGH8GYASV8BhtRxTCZQAuyQ1BWI7IzxJsEXgVsltZWULumkcFsR0E1SyzD2CoLk+IewVoakrpImRxE3kgZImhDe19tHkOzKI86VHzaRVud/ge9LGqFAX0k96yjTNWG1JihJw6N4Hd1Ywbqmy8xWmFlNzwR9h6AmtJKgO/fDwAPhtvuAGcC7wEIOrYH9hOBb9XaCzgIP1xLGpQTNiYvD/f8NdKll/8M1B/gE2GBmb9W2o5ndTpCIf0yQaNYR1Ij+r66TmNligvt08wg+1I8GXq3jsJuB4WF8zxBxHcMvCWcTdHhYC6wnSLQALwGLgE2SKjt8XA8sB16XtBN4AajzOadQK+BWgprYJoJOHDeG2/4V/twqaWHVA83sXwQdPh4GdhFcq451lOmaMJnVXKuWtAt4i882HVTVy8zy4xyXc865Zq6uThJvmdmE2naQ9FIc43HOOeeAOmpQzjnnXKLUWoOS9H8EbduvEdSmauqV5JxzzsVVXfegzgJODF9DCR6yrExYr5lZUWME6ZxzrvmJuokvfOL/WGAcwfAnvcysznHMGlJ2drbl5+fHtczdu3fTtm3buJYZbx5jfHiM8eExxkdzinHBggVbzCynrv2imVMnm09rUScQjCH2AkEX14TKz89n/vwaZzOol8LCQsaNGxfXMuPNY4wPjzE+PMb4aE4xSopqRJi67kF9RPDcxH8InkX5pZmVxBydc845V4e6alAPENSavkDwMOAQSfOAt8OH+5xzztWgosIwggdJJVC104m5mtSaoMzs4MjRkvoTNPN9HRgrabOZ1ThMjKR0gifrW4Xn+beZ/UxSL4IpBDoSjAxwiZkdCIcpeYhg1OitwIXhyNbOOZd0tu8+wMotu1m/fQ/rtu1h3ba9rN+xh227S9m5N3jt2v/Z8XdbtkihQ5s0OrRpSZf26fTPzaRfbiYDcjMpr/BHfqqKajRzSb0JhuQfRVCjyiEYlqY2+wnGXiuRlAbMlfQcwfAufzCz6ZLuIRij7S/hz+1m1lfSRQSDPV5YU+HOOdcYKiqMddv3sPjjnSzeuPPgz42ffHbA9uyMlnTr0IauWekM6pJJu/Q02rVOI1XCMMxgX2k52/ccYNvuUtZv38Ory7dyoLwCgNYtYMz6+Ywf0JnTh+TRoW3LRPy6SaWue1BPECSkTwg6RbwK3BmOBVYrC7oHVt6vSgtfBkwALg7XTyMYIv8vBFNd3xSu/zdwlySZP0nsnGtEu/eX8fbaHcxfs40Fa7bzztodB2tCqSmiT05bRvXqyOCj2tEnJ4PuHdvQrUNr2rQ8/NmLysorWLMtSH7/eeV9lm7ayazFRfz0yQ8YN6AzXxvTixN6d2y2TYN1PQd1DsHzTtXNClp34UHX9AUEg1DeDfwWeN3M+obbuwPPmdkQSR8AU8LZSZG0AhhV9dySriScpTM3N3fE9OnT6xNajUpKSsjIyKh7xwTyGOPDY4yPph7j7lJj6bZylm4r58PtFazbVUGFBfeNumWm0Dcrhfx2KfRol0LXjBRapjZMsigpKaFt27as3VXB6xvLmbuhlF0HoFe7FM7qk8bwzqkJT1Tx+luPHz9+gZmNrGu/ulJ+tVNcR5I03MwOGXkYDo6SPExSFsH01oOq262yqFq2RZZ5L3AvwMiRIy3e3TKbU1fPhuQxxofHGB+RMe4rLWfh2u28unwLc5dv5f31O6gwSE9L4djuHThnZAdG5nfk2B5ZtEtPS0iMl4Vx/mfheu6bs5I7397D6N6duPncAvrnZjZaTLXF2BjqSlB/kzSO2kczv5/gAd4amdkOSYUEzYVZETOJdgMqZ71cTzAx3fpw4rT2wLY6fwPnnKtFRYWx+pNy7nl5Ba8u38Kbq7axv6yC1BQxrHsWV0/ox5i+2QzrnkXLFskzRV56WipfGtWTi47rwcNvruV3M5Zx+h2vcMXYXlw3sT+tWiR0nIRGUVeCak/QRFdbgtpc3UpJOUBpmJxaA6cRdHyYTTCp3HSCLwpPhoc8FS7PC7e/5PefnHP18cneUl75aDMvLS3m5WWb2br7ALCU/rkZXDyqB2P6ZnN8r45kNmINqb5SU8QlJ/TkzKO7cNtzS/nryyuZ8+EW/nTRMPolsDbVGOrqZp4fQ9ldgGnhfagU4DEze1rSYmC6pF8CbxPUwAh//l3ScoKa00UxnNs514yYGcuLS3hpaTEvLS1m/prtlFcYWW3SOKV/DrkVW7nirDF0bpee6FDrrWPbltx2/lAmDs7l+v+8x3l3v8qfph7LqYNyEx1agzn8bidRMrP3qKbpz8xWEnRZr7p+H/DFhorHOXdk2VdazryVW5kdJqX12/cCMDAvk2+c3JsJAzszrHsWLVJTKCwsbNLJKdJpg3N5putYrnjoLa54aD43nj6IK8b2SngHiobQYAnKOefi7eMde5m9rJjZS4t5dflW9paWk56Wwpi+2XxrXB/GD+jMUVmtEx1mg8trn86/vnEi3/vXO9zy7BI27dzHj88cdMQlKU9QzrmkVV5hvL12+8Gmu6WbdgHQrUNrLhjZjfEDO3NC706kpx35HQaqat0ylbumDufnmYu5f+4q9hwo55bzhpCScuQkqboe1O0M3EjwHNP7wK/NbGdjBOaca54+2VtK4bIgIb384WZ27CklNUWM7NmBH54+kAkDO9O3c8YRV1uoj5QU8bOzB9OmZSp/LlxBeloKPz1r8BFzbeqqQT1E0IvvTuAs4E/A5Q0ck3OumdmwYy+zFm1i1pIi3li5jbIKo1PblkwY2JkJAzsztl8O7Vsnf4+7RJDEDyYPYH9ZBffPXUV2RiuuGt830WHFRV0JKs/MfhS+nyGp2gdynXPucJgZiz4OhvWZtbiIxRuDhpk+OW25YmxvJg7O5djuWUdUc1VDksSPzhjE1pL9/HbGMnIyWnHBcd0THVbM6kpQktSBT5+DSo1cNjN/kNY5F5XS8greWLmNWYs38cKSYjbs2IsEI3oETXcTB+fSOye5h0xKZikp4jfnH8PW3Qe48Yn36dmpDaN6d0p0WDGpz4O6lbUoA3o3RFDOuSPDrn2lFC7bzKzFRcxeVsyufWW0apHC2H45XHtqPyYM6kx2RqtEh3nEaNkihbsuHs7n7n6Vb/9zIU9efRLdOrRJdFj11pAP6jrnmqFNn+xj1pKg6W7eii2Ulhsd27ZkSkEeEwfnMrZfDq1bNr9ed42lfes07rtsJOfdFSSpf3/zxKQawulweDdz51xMzCyYJmJREbOWFPHe+k8AyO/UhstPzGdSQR7De3Qg1e8nNZo+ORn85vyhfOufC/n9rGX88PTqxulOfp6gnHOHray8grdWb2fW4iL+u3Avm2e8AsCw7ln8YPIAJg3O9a7gCXb60V2YenwP/vrySsb0zWZsv5xEh3TYPEE556Kye38Zcz4M7ie9tKyYHXtKadkihYEdUvh/UwZz2qDOR8xwQkeKn541mLdWb+O6x97l+WvH0qmJ3e/zBOWcq9GWkv28sLiImYuLmLt8CwfKKmjfOo1TB3Zm4uBcTu6fw1vz5jJuVI9Eh+qq0bplKndOPZZz7prLTf9dzJ1Ta50ZKenUK0FJWhK+vdvM7opjPM65BFu7dQ8zF29ixqJNzF+zHbNgaKEvjerBxMG5HJ/fkRapTfOme3M0qEs7vjOhH7fP+pCzhnZhckFeokOKWr0SlJkNktSJYAJC51wTVvnQ7MzFRcxctOngeHeDurTjmgn9mFyQx6AumX4/qQn71rg+PPfBJn70xAec0KsT7ds0jVE56kxQ4XxOM8zstMj1ZrYVeKahAnPONZyy8grmr9nOjEWbmLmoiA079pIiGNmzIz8+cxCTBufRo1PTfX7GfVZaagq/PX8o59w1l9tnLePmc4ckOqSo1JmgzKxc0h5J7c3sk8YIyjkXf/tKy3nloy3MXLSJF5YUsT3s5DC2bzbXnNqXUwfl+kOzR7AhXdvzpVE9+fvra7jwuB4MPqpdokOqU7RNfPuA9yXNAnZXrjSzaxokKudcXHyyp5QXlxYxc1ERL3+4mb2l5WSmt+DUgZ2ZVJDHKf1zaNvK+0o1F9+fNIBn3t/Iz576gMe+MTrpm22j/Zf5DN6c51yTsPGTvcxaXMSMRZsOjgye264VXxjRlckFeYzq1anJjizgYtO+TRrXTxnA9f95nyfe3sDnh3dLdEi1iipBmdk0Sa2BHma2LJpjJHUnmK4jD6gA7jWzOyR1BB4F8oHVwAVmtl1BKr8DOAPYA1xuZj56unN1MDOWF5cc7OTwbjiSQ++ctnz95N5MLshjaNf2PjK4A+CLI7rz8JvruPW5pUwZkkeblslbg44qMklnA78DWgK9JA0Dfm5m59RyWBnwPTNbKCkTWBA2EV4OvGhmt0q6AbgBuB44HegXvkYBfwl/OueqqKgw3lm/gxmLNjFrURErtwQt78d0z+J/pgxg0uA8+nb2kcHdoVJSxE/OHMT598zj/ldW8Z1T+yU6pBpFmzpvAo4HCgHM7B1JvWo7wMw2AhvD97vCZ6e6AucC48LdpoVlXh+uf8jMDHhdUpakLmE5zjV7B8oqmLdyKzMXbWLW4iKKd+2nRYoY3acTXzkpn4mD88hr7yM5uLqNzO/I5IJc7nl5BVNH9UjazjEK8kEdO0lvmNkoSW+b2bHhuvfMbGhUJ5HygTnAEGCtmWVFbNtuZh0kPQ3camZzw/UvAteb2fwqZV0JXAmQm5s7Yvr06dGEELWSkhIyMpL7m6fHGB9NIcYtO0pYuS+dhUVlvLu5nL1l0CoVjs5OZXhuC47JSaVtWmKb7prCdfQYD7WxpIIfvbqXcd1bcOng6BJUvGIcP378AjMbWdd+0dagPpB0McGEhf2Aa4DXojlQUgbwH+C7Zrazll4j1W04JHua2b3AvQAjR460cePGRRNG1AoLC4l3mfHmMcZHssa4edd+XlwSDC8058PdlFXsp2Pblpw9LBgF4KS+2aSnJc90Fcl6HSN5jNV7v/R9/jV/HT+fenxU80Y1dozRJqjvAD8C9gOPAM8Dv6zrIElpBMnpn2b2eLi6qLLpTlIXoDhcvx6InKO4G/BxlPE516St3boneGh28WeHFzq1ewu+OnkkI/M7+nQVLu6uHt+Xf89fz92zV/Drzx+d6HAOEW2CyjOzHxEkqaiEvfLuB5aY2e0Rm54CLgNuDX8+GbH+aknTCTpHfOL3n9yRqrbhha49tR+TBgfDC7388stNftpul7yOymrNhcd155E31/LtcX3o3jG5Rg+JNkE9KKkr8BbBvaRXzOz9Oo45CbiE4AHfd8J1NxIkpsckfQ1YC3wx3PYsQRfz5QTdzL8S9W/hXBNQOYfSzMVVhhfKD4YXmlyQl3QfEO7I9+3xfXj0rXXcPXs5t34hqm4FjSba56BOltQSOI6gB94zkjLMrGMtx8yl+vtKAKdWs78BV0UTj3NNReXwQjMWbeLFiOGFTu6XzbWn9uPUQZ2b3Bw97sjSpX1rLjq+Ow+/sZarxvdNqi9J0T4HNQYYG76ygKeBVxowLuearNqGF5pckMfJPryQSzLfHteX6W+t48+FyXUvKtr/JS8D84FfA8+a2YGGC8m5pidyeKHXV26jPBxe6PwR3ZhUkOvDC7mkltc+nS8M78Z/Fq7nuon9yclMjlp9tAmqE8E9pZOBayRVAPPM7CcNFplzSaym4YX65LTlGyf3ZpIPL+SamK+P7cX0t9Yy7bXVfH/ygESHA0R/D2qHpJUE3cC7AScCTWPGK+fipKbhhYb58ELuCNA7J4PJg/N4aN5qvjWuT1I0Q0d7D2oFsAyYC9wDfMWb+VxzUOvwQmN6MXFQrg8v5I4Y3zilN88v2sT0t9bxtTG1jmbXKKJNkf3MrKJBI3EuSZTsL6NwWTEzFxUxe2kxu/aX0aZlKuMG5DC5II9xAzrTvrU3ILgjz7E9OnB8r47c/8pKLh3dk7TUxN43jTZBHSXpToL7UEZQk7rWzNY3WGTONaLK4YVmLNrEq8u3cqC8gk5tW3LG0V2YVJCbdMMLOddQvnlKb7764HyeeW8j5x3bNaGxRJug/gY8zKcP1X45XDexIYJyrjEU76ngvjkrDxle6JLRPZlckMeInh18eCHX7Izr35ne2W2ZNm91k0lQOWb2t4jlByV9tyECcq6hHDq80F5gCYOrDC+U7NNgO9eQUlLEJaN7cvN/F/Pe+h0M7ZZV90ENJNoEtUXSlwkGigWYCmxtmJCci5/ahheaOrAl3z7npKR6ct65ZHD+iG78bsYyHnxtNbdfMCxhcUSboL4K3AX8geAe1GvhOueSTrTDCxUWFnpycq4amelpfGFEN6a/uY4bzxiUsAkNo01Qe+qY3t25hPpkbykvLS1ixgefDi/ULr0Fpw7KZdLgXB9eyLnDdOnofB6at4bpb67l6gmJmRa+1v+xks4GHgDKJJUDF5hZVBMVOtfQinbuO3g/ad6KrZRVGJ0zW/GFEV2ZXJDHCb07JbybrHNNVd/OGYzpm80/Xl/LN07pk5D/S3V9pbwFGGtmSyWNAn4DnNLwYTlXvVVbdjNj0SZmLNrE22t3ANA7uy1XjO3NpIJchnXL8uGFnIuTy07M5+sPzefFJUVMGdKl0c9fV4IqM7OlAGb2hqTMRojJuYMqe95VJqUPi0oAOLpre74/qT+TC4LhhbznnXPxN35ADnnt0pn+1rqkTFCdJV1X03KVmXKdi4uaet4d36sjPzt7MJMK8uia1TrRYTp3xGuRmsIFI7tx5+zlbNixt/HPX8f2+4DMWpadi4t9peXMrex5t7SYbbsPfNrz7rR+nDYol45tWyY6TOeanS+O7M6ds5fzr/nrGNbI/YxqPZ2Z3dxYgbjmZ+e+UmYvLWbGok0ULtvMngPlZLZqwYRBwcR+p3jPO+cSrnvHNozpm81jb61j6AmN21Giwf73S3oAOAsoNrMh4bqOwKNAPrCaoFfgdgU3EO4AzgD2AJeb2cKGis0lTvGufeHEfkXMW7GF0nIjJ7MV5x0b9Lwb3dsn9nMu2Vx0XA+uenghH2xpxYRGPG9Dfj19kODh3oci1t0AvGhmt0q6IVy+Hjgd6Be+RgF/CX+6I8CarZU974pYuDYY8y6/Uxu+elIvJhXkcWx373nnXDKbODiXTm1b8vL6Mq5pxPM2WIIyszmS8qusPhcYF76fBhQSJKhzgYfMzIDXJWVJ6mJmGxsqPtdwzIw1O8u5fdaH4Zh3uwAoOKod/++0oOdd/1zveedcU9GyRQpfGNGN+19ZyeZd+xttSngFOaGOnaRc4FfAUWZ2uqTBwGgzu7+O4/KBpyOa+HaYWVbE9u1m1kHS08CtZjY3XP8icL2Zza+mzCuBKwFyc3NHTJ8+PbrfNEolJSVkZCT3rKjJGGOFGR9tr2BBURkLi8vZstcQ0L9DCsNzWzC8cyo5bZKr6S4Zr2NVHmN8eIyx+7ikghvn7uWiAS2Z0iu2+dDGjx+/wMxG1rVftDWoBwmm1/hRuPwhwb2kWhPUYajuq3S1mdPM7gXuBRg5cqSNGzcuTiEECgsLiXeZ8ZYsMe4vK+fV5VuY8UERLywpYuvuA7RMTWFMvxx6ttjB1eedTKcEjeEVjWS5jrXxGOPDY4yP+95/jvd2pnPruLGNcr5oE1S2mT0m6YcAZlY59NHhKqpsupPUBSgO168Hukfs1w34uB7luwa2a18ps5dtDnreLS1m94FyMlq1YPzAzkwuyGXcgM5ktGpBYWFhUicn59zhO+moFvxjyU6WbtrJwLx2DX6+aBPUbkmdCGs1kk4APqnH+Z4CLgNuDX8+GbH+aknTCTpHfOL3n5LH5l37eSGcbfa1cLbZ7IyWnDPsKCYV5HFin060auGzzTp3pBvVpQXTl5XyxMIN/PCM5ElQ1xEkkT6SXgVygPNrO0DSIwQdIrIlrQd+RpCYHpP0NWAtn87Q+yxBF/PlBN3Mv3J4v4aLt3Xb9hwcXqhyttnuHVtz2YnBbLPH9vDZZp1rbjJbinEDcvi/dzbwP1MGNvhnQFQJyswWSjoFGEBwv2iZmZXWcczUGjadWs2+BlwVTSyuYZgZSzftOtgdfMnGnQAMCmebnVyQx8A8n23Wuebu88O78cKSYl5bsYWx/XIa9Fx1Tbfx+Ro29ZeEmT3eADG5RlJeYSxcu50ZH2xi5uIi1m7bgwQje3bgx2cOYtLgPHp08gn9nHOfmjCwM5npLXhi4YbEJijg7Fq2GeAJqonZX1bOayu2MnPRJmYtLmJLSdDz7sS+nfjWuD6cNii30Z5xcM41PelpqZw1tAtPvvMxv9hf1qDDkdU1Fp/fCzoClOwvo3BZMTMWFVG4tJhd+8to2zKVcQODMe/GD8ghMz225xqcc83H54d345E31zFj0SY+P7xbg50nqtQn6afVrTezn8c3HBcvW0sqe94VMXf5Fg6UVdCpbUvOOLoLk4fkcmKfbNLTvOedc+7wjezZga5Zrfnvux8nPkEBuyPepxMMArsk/uG4WKzbtoeZi4Pu4PNXb6PCoFuH1lxyQk8mDc5lZH5H73nnnIuZJM4a2oX7565ix54DZLVpmKlwou3F9/sqwf2OoNu5SyAzY1nRLmYuCpLSoo+DnncD8zK5ekI/JhfkMrhLO+9555yLu7OGHsVf56xkxqJNXHhcjwY5R33vbrUBesczEBedigrjo+3lvPbsEmYs2sSarUHPu+E9OnDjGQOZNDiP/Oy2iQ7TOXeEG9K1HT07teHp9zYmNkFJep9Px8ZLJXhQ1+8/NZIDZRXMW7mVGWHPu8279pOWuorRfbK58uTeTBycS+fM9ESH6ZxrRiqb+e55eSVbSvaT3QBDm0Vbgzor4n0ZUGRmZXGPxh20e38ZL38YjHn30tJidu0ro03LVMYNyKG7tnPV50+hnfe8c84l0FlDj+Lu2St47oNNXHJCz7iXX9eDuh3Dt7uqbGoXPqi7Le4RNWPbdh/ghSVFzFy0iTkfBT3vOrRJY0pBHpML8hjTL+h5V1hY6MnJOZdwA/My6ZPTlqff/bjxExSwgKBpT0APYHv4PotgLL1ecY+omdmwYy8zwzHv3lwV9LzrmtWai4/vweSCPI7L70CL1OSaR8k556Cyme8o/vTSRxTt3Eduu/jeaqjrQd1eYRD3AE+Z2bPh8unAaXGNpJkwMz4qLjk4vND7G4JB4fvnZnDV+L5MGpzHkK7e88451zScfUwX7njxI559fyNfOSm+dZZo70EdZ2bfrFwws+ck/SKukRzBKiqMd9bvYMaiTcxcVMSqLcFjZcf2yOKG0wcyuSCPXt7zzjnXBPXtnMnAvEyefi9xCWqLpB8D/yBo8vsysDWukRxhSssreD2i513Rzv20SBGj+3Tiq2N6MWlwbtyrw845lwhnHN2F22d9SPHOfXSO4+datAlqKsF8Tk+Ey3PCdS7CngNlzPlwMzMWFfHikiJ27iujdVoqp/TPYfKQXCYMyKV9G+/c4Jw7skwZksftsz5kxuKiuHaWiHYkiW3AtZLaARVmVhK3CJq4HXsO8MKSYmYs2sScDzezv6yCrDZpTBycx+SCXE7un+Nj3jnnjmj9OmfQO7stM+Lc3TzaB3WPBh4COobLW4DLzOyDuEXShHy8Yy+zwjHv3li1jfIKo0v7dC46rjuTC/I4vldH73nnnGs2JDF5SB73zlkZ17H5om3i+ytwnZnNDoMZB9wLnBiXKJqA5cW7mBGOeffe+qDnXd/OGXzzlN5MLsjj6K7tveedc67ZmlKQx18KV/DCkmLOHxGfEc6jTVBtK5MTgJkVSop7tzNJU4A7CIZT+l8zuzXe54iWmfHu+k/CKdA3sXJz0PPumO5Z/M+UAUwuyKNPTkaiwnPOuaQytFt7urRP5/kPNjV6glop6SfA38PlLwOr4hJBSFIqcDcwEVgPvCXpKTNbHM/z1Ka0vILFW8t56ckPmLmoiE0795GaIk7o3ZHLT8xn4uBcurRv3VjhOOdckyGJyQV5PPzmWnbHaabdaEv4KnAzwRTvIujFF+/Zdo8HlpvZSgBJ04FzgQZNUHsPlDPno2DMuxeXFPPJ3lLS09Zxcr8cflAwgFMHdW6wuU6cc+5IMmVIHg++tprCZZs5c2iXmMuTmdW9VyOQdD4wxcyuCJcvAUaZ2dVV9rsSuDJcHAAsi3Mo2cCWOJcZbx5jfHiM8eExxkdzirGnmeXUtVNdg8XWOimhmZ1zuFHVdrrqTlHNOe8l6KDRICTNN7ORDVV+PHiM8eExxofHGB8e46HqauIbDawDHgHeoPokEi/rge4Ry92AjxvwfM4555JYXQkqj6DTwlTgYuAZ4BEzW9QAsbwF9JPUC9gAXBSe0znnXDNU69OkZlZuZs+b2WXACcByoFDSd+IdSDgB4tXADGAJ8FgDJcK6NFjzYRx5jPHhMcaHxxgfHmMVdXaSkNQKOJOgFpUPPAU8YGYbGjw655xzzVatCUrSNGAI8BwwvbkObeScc67x1ZWgKoDd4WLkjgLMzNo1YGzOOeeasbruQaWYWWb4ahfxyjzSkpOkKZKWSVou6YZEx1MdSaslvS/pHUnzEx1PJUkPSCqW9EHEuo6SZkn6KPzZIQljvEnShvB6viPpjATG113SbElLJC2SdG24PmmuYy0xJs11DONJl/SmpHfDOG8O1/eS9EZ4LR+VlLAn8GuJ8UFJqyKu5bBExRjGkyrpbUlPh8uNeg19yG0+M8zS6cBgYKqkwYmNqkbjzWxYkj0v8SAwpcq6G4AXzawf8GK4nEgPcmiMAH8Ir+cwM3u2kWOKVAZ8z8wGEXRIuir8N5hM17GmGCF5riPAfmCCmR0DDAOmSDoBuI0gzn7AduBrSRgjwA8iruU7iQsRgGsJOq1VatRr6AkqcHCYJTM7AFQOs+SiYGZzgG1VVp8LTAvfT1G+ckMAAAcfSURBVAPOa9Sgqqghxv/f3rnG2FlVYfh5YxsLFNukFgJtSIUfQGgmFFITQsWWAAppTIxVasA0/jAaBdIfjYiYADX8UgGriHgpKOpU5FIbCAKxF6yRCKVkarXEUBpCbFoxgNzijdcfe52Zj9PvnJmOdL5vxvUkzTlnn71nr7PSs9fZt3e1Btv7bT8Vz1+lDArzaJEf+9jYKlzo5KybHv8MnA/cE+VN+7KXja1B0nzKAbkfxGsxwT7MAFWYR7mQ3OEFWvjFo/wHfkTSjpB8ajPH294PZWADjmvYnl5cIWkolgAbXYbsIGkBsIhyOb6VfuyyEVrmx1iaeho4CDwKPAu8HNdZoAXf8W4bbXd8eWP48uY4Rd0UtwBfBN6K13OYYB9mgCqMSWapBZxr+yzKUuQXJJ3XtEGTnNuAUyhLLPuBbzRrDkiaCdwLrLb996btqaPGxtb5Me5wnklRpHk/cHpdtYm1qqvzLhslLQSuAU4DFlMSxF7dhG2SlgMHbe+oFtdUPaI+zABVmBQyS7b/Eo8HgfspX7y2ckDSCQDxeLBhew7B9oEYJN4Cvk/D/pQ0nTLw/9T2fVHcKj/W2dg2P1ax/TKwlbJnNltSRz2nNd/xio0fjmVU2/4HcAfN+fJc4COS9lG2PM6nzKgm1IcZoArDMktxKmUl5UJya5B0jKRjO8+Bi4A230vbBKyK56uAXzZoSy2dgT/4KA36M9b3fwj8yfZNlbda48deNrbJjwCS5kqaHc+PAi6g7JdtAVZEtaZ9WWfjnsqPEVH2dxrxpe1rbM+3vYAyHm62fRkT7MPWpNtomjgaewslm+962zc2bNLbkHQyZdYERUPxZ22xUdIgsJQixX8AuA7YCNwNnAQ8D3zcdmOHFHrYuJSyLGVgH/DZzn5PA/YtAX4D7GJkzf/LlD2eVvixj42fpCV+BJA0QNnAfxflR/jdttfGd2gDZelsJ3B5zFTaZONmYC5lOe1p4HOVwxSNIGkpsMb28on2YQaoJEmSpJXkEl+SJEnSSjJAJUmSJK0kA1SSJEnSSjJAJUmSJK0kA1SSJEnSSjJAJZMeSZZ0V+X1NEl/7SgwH8bf2SfpvaPUuVPSin51KnWXSvpdV9k0ScOXb0frQ9JqSUePpb93AklbJX2oq2y1pO90lS2Q9GZI9fRtJ+mUUOZu9Lh0MvnIAJVMBV4HFsaFR4ALgTZkfH4MmB+6dR0uAP5wGPeEVgMTFqCAQcrFzCoro7ybZ0Oqp28729V6STJmMkAlU4WHKMrLUC6ODg+oKjmVNoYA5+NxSRJJcyQ9Evlubie0xmJ2UM0btUbS9d0dSjpb0rYQ7324e1YU0j+/AC6tFA8P9pLODHuGJN3fLbIq6SrgRGCLpC1RdpukJ1XJIRTll0jaI2m7pHUayd9zTAi4PhGfczSV/nuA5R2R0giuJwLbj1C7JOlJBqhkqrABWClpBjDAiMo2wA3ATtsDFOWDH0f5dcB224sokkInjbWz0KT7FrDC9tnAeqBO2WN4ZhGD9yUULTvCjqvDrl1hzzC211G0zpbZXhbF10YusAHgg5IG4jPfDlxsewlFiaDDtRSZmsXAMuBrIZVVi+2/Ab9nJHfWSuDnHuVG/3jbJUk/MkAlUwLbQ8ACyuypO2HeEuCuqLcZmCNpFnAe8JMof5CSgG2snAosBB6NfZivUMQzu+16Apgp6VSKCv3jtl+K/mfb3hZVfxT2jMYnJD1FkZk5g5Jg8zRgr+3nok51Oe4i4Eth41ZgBqMH4upyXa/lvXeyXZLUMm30KkkyadgEfJ2isTenUt4vTUDdL/x/8/YfbzNq6gjYbfucMdi1gTJgn87/MGhLeh+wBlgcQe7OsK3u81Xt/JjtZw6jq43ATZLOAo7qJCk8gu2SpJacQSVTifXAWtu7usofAy6DYeHLFyOPUbX8YqCzB3QAOC72qN4NLK/p6xlgrqRzov10SWf0sGsQuJySsmATgO1XgJckfSDqfArYVtP2VeDYeP4eyoGQVyQdT5mRAewBTq4cxqjueT0MXBnq2EhaFI/zJP26ztgQJ91K8eeYA+p42yVJL3IGlUwZbL8AfLPmreuBOyQNAW8wkr7iBmAwlsy2UdTCsf0vSWsp+1jPUQJAd1//jKPg62K5bhpFDX93Td0/SnoD2GH79cpbq4DvxjHyvcCna2z/HvCQpP22l0naGX3sBX4bf/9NSZ8HfiXpRcpeUIevhl1DEaT2UQLuCZSZYi8Ggfs49GTeaIy3XZIcQqqZJ8kUQNJM269FELoV+LPtm/vUvwJ43va48p7FbO0B2wsPo81rtmeOp7/k/5Nc4kuSqcFn4iDEbmAW5VRfT2x/e7zBKfgPMKtzUbcfnYu6lKXTJBkzOYNKkiRJWknOoJIkSZJWkgEqSZIkaSUZoJIkSZJWkgEqSZIkaSUZoJIkSZJW8l9S9WRcgLdXUAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pv_mod.plotMod()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pv_sys.plotSys()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 5ee310fc60ee42c235bb8800bbeed638648937e1 Mon Sep 17 00:00:00 2001 From: Cliff Hansen Date: Sun, 5 Jan 2020 09:32:59 -0700 Subject: [PATCH 08/16] correct model kwarg for pvcell --- notebooks/basic_iv_curves.ipynb | 39 ++++++++++++++++------------- pvmismatch/pvmismatch_lib/pvcell.py | 11 ++++---- 2 files changed, 28 insertions(+), 22 deletions(-) diff --git a/notebooks/basic_iv_curves.ipynb b/notebooks/basic_iv_curves.ipynb index 3f4d622..428eb60 100644 --- a/notebooks/basic_iv_curves.ipynb +++ b/notebooks/basic_iv_curves.ipynb @@ -2,11 +2,11 @@ "cells": [ { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ - "# add capability to import from parent director\n", + "# add capability to import from parent directory\n", "import sys, os\n", "sys.path.insert(1, os.path.join(sys.path[0], '..'))\n", "\n", @@ -35,11 +35,18 @@ "pv_mod_pattern = pvm.pvmodule.standard_cellpos_pat(nrows=nrows,\n", " ncols_per_substr=ncols_per_substr)\n", "pv_mod = pvm.pvmodule.PVmodule(cell_pos=pv_mod_pattern, pvcells=None,\n", - " pvconst=None, Vbypass=v_bypass, cellArea=cell_area)\n", - "\n", + " pvconst=None, Vbypass=v_bypass, cellArea=cell_area)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ "pv_cells = pv_mod.pvcells\n", "for c in pv_cells:\n", - " c.update(Isc0_T0 = Isc0_T0) # updating short circuit currents\n", + " c.update(diode_model = 'desoto', Isc0_T0 = Isc0_T0) # updating short circuit currents\n", "\n", "pv_mod.setSuns(cells=list(range(0, len(pv_cells))), Ee=[1]*len(pv_cells))\n", "\n", @@ -52,25 +59,21 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] }, { "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -78,7 +81,9 @@ } ], "source": [ - "pv_cells[0].plot()" + "pv_cells[0].plot()\n", + "\n", + "print(pv_mod.pvcells[0])" ] }, { diff --git a/pvmismatch/pvmismatch_lib/pvcell.py b/pvmismatch/pvmismatch_lib/pvcell.py index 3179ba3..67ebb0d 100644 --- a/pvmismatch/pvmismatch_lib/pvcell.py +++ b/pvmismatch/pvmismatch_lib/pvcell.py @@ -64,18 +64,19 @@ class PVcell(object): _calc_now = False #: if True ``calcCells()`` is called in ``__setattr__`` - def __init__(self, model=MODEL, Rs=RS, Rsh_STC=RSH_STC, Rsh_0=RSH_0, + def __init__(self, diode_model=MODEL, Rs=RS, Rsh_STC=RSH_STC, Rsh_0=RSH_0, Rsh_exp=RSH_EXP, Isat1_T0=ISAT1_T0, Isat2_T0=ISAT2_T0, Isc0_T0=ISC0_T0, aRBD=ARBD, bRBD=BRBD, VRBD=VRBD_, nRBD=NRBD, Eg_0=EG_0, dEg_dT=DEG_DT, N1_0=N1_0, N2_0=N2_0, mu_gamma=MU_GAMMA, alpha_Isc=ALPHA_ISC, Tcell=TCELL, Ee=1., pvconst=PVconstants()): # user inputs - if model in ['2diode', 'desoto', 'pvsyst']: - self.diode_model = model + if diode_model in ['2diode', 'desoto', 'pvsyst']: + self.diode_model = diode_model else: - raise ValueError('model must be one of ''2diode'', ''desoto'' or ' - ' ''pvsyst''; % provided'.format(model)) + raise ValueError('diode_model must be one of ''2diode'',' + ' ''desoto'' or ''pvsyst'';' + '% provided'.format(diode_model)) self.Rs = Rs #: [ohm] series resistance self.Rsh_STC = Rsh_STC #: [ohm] shunt resistance at STC self.Rsh_0 = Rsh_0 #: [ohm] shunt resistance at 0 irradiance (pvsyst) From 38a7a6031c5ec459fc441631b46e7106906dfc76 Mon Sep 17 00:00:00 2001 From: Cliff Hansen Date: Sun, 5 Jan 2020 09:34:01 -0700 Subject: [PATCH 09/16] save changes --- notebooks/basic_iv_curves.ipynb | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/notebooks/basic_iv_curves.ipynb b/notebooks/basic_iv_curves.ipynb index 428eb60..f690664 100644 --- a/notebooks/basic_iv_curves.ipynb +++ b/notebooks/basic_iv_curves.ipynb @@ -40,13 +40,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "pv_cells = pv_mod.pvcells\n", "for c in pv_cells:\n", - " c.update(diode_model = 'desoto', Isc0_T0 = Isc0_T0) # updating short circuit currents\n", + " c.update(diode_model = '2diode', Isc0_T0 = Isc0_T0) # updating short circuit currents\n", "\n", "pv_mod.setSuns(cells=list(range(0, len(pv_cells))), Ee=[1]*len(pv_cells))\n", "\n", @@ -59,21 +59,21 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n" + "2diode\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAa8AAAEYCAYAAADrpHnMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzsnXecVNXZ+L/PbAV2l7awS0e6gGJBsKCCHbuxxJqgJsbEJCaaosY38Y0mMSax5PdqYokxJmosicbYEFRABUXARlV6XcrSdoGt8/z+OGfgMkzb3Zm5M7vn+9n57C2nPPfc85zntHuOqCoOh8PhcGQTAb8FcDgcDoejqTjj5XA4HI6swxkvh8PhcGQdzng5HA6HI+twxsvhcDgcWYczXg6Hw+HIOrLWeIlIfxFREcm159NE5Bt+y9VaEZFJIvKe33IkAxHpKyLVIpLTDL9/FpH/SYVcqaIt6IqIrBSRU/yWA0BExovIWr/lSBZWVwY0w99tIvJYKmSCDDBeInK5iMyxCbRBRF4XkXFJjuMOEam3cWwXkZkickwy40g3sQogEZksIr+McP08EakIFWIR7p8uIjNEpEpENovIdBE5N9myt4RkFAyqulpVi1S1MU5cBxhsVb1eVe9sSfzNxQddCf1+ksw40o2IPCEid0W597CIPBnh+qEiUisiXaL4GyMir9nyZKuIzBaRq5Mte0sIr7Q0F6sry+PEdYBequqvVTVllSRfjZeI3ATcD/waKAP6Ag8B56UgumdVtQgoBd4Bnk9BHDFpaSZqAk8AV4mIhF2/CnhKVRvCPYjIRZg0eRLojXkfPwfOSbZwaUyHjIq7JfihK57fPU0NIFXpnIJwnwC+IiIdwq5/DXhFVbdGkOEY4G1gOjAI6Ap8G5iYZNmcrsRCVX35AR2BauDiGG4CwC3AMqASeA7oYu/1BxTItefTgG9ECecO4B+e8+HWbzfPtbOBT4DtwEzgUHv9FuCFsPAeAP7oeY6/ABuAdcBdQI69Nwl4H7gP2GrvDcJk+h3AFkxBEQp3GDDFul0CXBIjbWI9bzsb/gmea52BGmBUBPcCrAZ+HCO+ScB7wO+BbcAKYKLn/tXAIqAKWA58y3NvPLAW+ClQAfzdyvMKsNmG9wrQ2+OnC/BXYL29/xLQAdgDBG3eqQZ6JphPrrXPOCNC3plkZa6yz3UFcLBNr0Ybz3br9gngLo+c59l8s9PGf0a0MLNRV8Lu9QRexuTPpcA3w/y9APzDpsV37bsqtfdvBxqAEnt+F3C/PT4L+Nj6WwPc4Qn3gPdnr18FrLLP+jNgJXBKFLn3e2cR7i8BvuY5z8Hku3OjuH8PeDBGeOMx+f1mYBOmbLjac785z/s8Rnd2YPLwiDB9/4NNjx1WvnbWv7JPV46x7q/B6Oo2YDLQzxOWAjcAXwIrPNcG2eMzgYWYfL0O+BHR9XK/vASMw5St2+1zT4oWZkJ60VyFaukPOMNm5twYbn4AfIBpCRQADwPPtEQhgXzgbozhCPk9wmaysTbjfh2jDAVAP2A3+5Qux2bGo+35S1auDkB3YDa24MYUYA3A94Bcm6GewShbACgExlm3HewLvdq6PcLKOCLKM0V9Xnv/UeAxz/m3gE+iuB1m0/KgGOFNAuqBb9o0+DZGwcWjkAMxhvBEm2ZHeJS5AfitTdN2mNrqhUB7oBijnC954nsVeBZj5PKAE70FQzPyyZM2jdt58469thMYat33CKW5feb3wuJ6AlsQAmMwhcWp9n32smkZNcxs0pUI96ZjWnuFwGGYisfJHn/1wPk2LdphCtkL7f03MYZ1oj2fAVzgeaeHWH+HAhuB82O8v+GYAvIE+6z32vRprvH6GTDVc366fba8CG7bYyo0E2KEN97K80tM3j0Tow+dm/O89vo1GD0pwLTAP/HE96B9p70wunmsdbffe7duz8dUPA7G5P/bgZme+4qpQHfxxO01XhuA4+1xZ/bX8XC9vIN95W5fjHG6zKZJV+CwWGHG1YvmKlRLf5jabUUcN4uwyuEpBOptou/3YoivkHUYi9+Iqa2N99z/E3BnmJ8l7Csw38PWzDAF1TJ7XAbUhl6yvXYZ8I49ngSsDgv3SeARPK0Me/2rwLth1x4GfhHlmaI+r70/DlOwhjLg+8APo7g9zqZlYYzwJgFLw5RYgfIo7l8CbvRk7Lo44R8GbPO85yBW2cPcRVKSRPLJAM/9vXkHU0BsxxjSdhGeOZbxehi4L4KMUcPMMl0J/XoCfTC6U+xx+xvgCY+/GWFh3Qn80cpQAdyIqTgW4mmVRZDh/lC6Rnl/Pwf+GZbedTTfePW1adXbnj8FPBDFbS8rz7AY4Y23z+c1GpuwFd6mPm8E952sm44YA7iHyD0q+713e+114FrPeQBjWPvZcwVOCgvHa7xWYyrCJQno5R3sM163Ai9GeZ6IYcb7+TnmVQmUxulX7Qe8aAdFt2MUtBFjNJrKc6rayfqdDxwZFs/NoXhsXH0wSgvwNMYoAVxuz0P+8oANHn8PY1pgIdaEyfETTOtktogsEJFrPGGNDZPhCqA83oPZgfvQ4PoVAKr6Hqb2eJ6dKXSUR+5wKu3/HnGiqggdqOpue1hkZZgoIh/YwevtmNpmqcfvZlWt8cjc3g6WrxKRnZiaeCc7A7APsFVVt8V7dksi+ST8PYSeYxem4nA95j2+KiLDEoy3D6Y1kcwwI+GLrnh+6zG6sFVVqzzuVmEK8xDhaTwdU6gdAXyOqdGfCByNqQhtARCRsSLyjp0ktAOTbqVhYXnD7uk9t+ldSQKImS0a0pXbrP9Qd/KVIlKEaZ38LUoQ2zAVq3i6Uqn7jy3vZp+uNOl5RSRHRO4WkWVWV1baW6X2V0iEfBiFfsADnnyyFVMexXqPXi7E6PYqO6Er0YlvEXWlJWH6abxmYcYUzo/hZg2mm8GrSIWquq65kVqF+RZwh4iEMuAa4Fdh8bRX1Wfs/eeB8SLSG7iAfUZgDablVerxV6KqI7xRhsVfoarfVNWeVo6HRGSQDWt6mAxFqvrtBJ5pou4bXH/Kc+tJzMDzVcCbqroxShBLbPwXxosrEiJSAPwLMx5WZisJr2GUYq+YYd5uBoYCY1W1BNMFhPWzBugiIp0iRBceDiSWTyL5MzdUJ6vqqZgCaTGmyzWmH0+8A5sYZnPwRVfCWI95J8Wea30xYxQhwtNrJuYdX4DJ2wutn7Mwhi3E05ixtD6q2hH4M/vnnfCwN2AKQ8BUhDDdUHFRM1s0pCu/9tz6G0ZXLsSM9cyL4n835n00S1csTX3eyzFjq6dgWlv97XXBDC3UEDkfRtOVb4Xlk3aqOjOOP3ND9SNVPQ9TQX8JM7Ya048n3mi6Ei3MmPhmvFR1B6b5/6CInG9r4nm2Bh+a3fRn4Fci0g9ARLqJSItnV6nqYsxAZWgK8KPA9bZGJCLSQUTOCimqqm7GdLX8FZOxF9nrGzB9+X8QkRIRCYjIQBE5MVrcInKxNYJganGKqSG/AgwRkatsOuSJyFEicnALHvVJTIb/JtFrkqhpu98E/I+IXO15lnEi8kgC8eRj+tg3Aw0iMhE4LY6fYkx3x3Yx05F/4ZFnA6Z74yER6WzTImTcNgJdRaSjJ6xm5xMRKRORc+1ss1rMWEpoCv1GoLeI5Efx/hfgahE52aZXLxEZFifMJuOnrnhkWIMxRr8RkUIRORQzqeCpGH52A3MxEwBCxmomptLmNV7FmFZdjYiMwRTWsXgBONvmz3zM2FJLy7J/YQzi/xJDVyw/ASaJyI9FpCuAiIwSkX8mGFdTn7cYk48qMd31e42uqgaBx4F7RaSnbaUdYyuUmzGtRO83Wn8GbhWREVbujiJycSJCi0i+iFwhIh1VtR4zruvVlXC99PIUcIqIXCIiuSLSVUQOixNmTHydKq+q92IKzdsxCb0GM0vpJevkAUwN5U0RqcIMSI9NUvS/A64Tke6qOgdTwP8fxqAsxYx3eHkaYwjCu96+him8F1q/LxC7S+Eo4EMRqcY8242qusJ2x5wGXIqp5Vawb4JDs1DVlZjCooONK5bbFzBdXdfY+DdiZoT9J4F4qoDvY2pM2zDKGDM+TD9/O0zN8QPgjbD7V2HGIRZjxgt+YONajJn0stx2ffSkZfkkgGkFrsd0oZwIfMfeextYAFSIyJYIzz0bM8HmPsz44nRMt0ysMJuFz7oS4jJMrX898CJmPHZKHD/TMV3rsz3nxZhuuhDfAX5p5f45cWreqroAYxCfxrTCtmFm9zUb2/UYMmBRDbJ1OxM4yf6Wi8hWzDj2awlG16TnxVRCV2FauQsx79bLjzDdsh9h8ttvgYCtPPwKeN/qytGq+qK9/0/bBTmfpk3xvwpYaf1eD1wJUfVyL7Zr9kyMXmzFzNAdFSvMeIRmijkcDofDkTX4vsKGw+FwOBxNxRkvh8PhcGQdzng5HA6HI+twxsvhcDgcWUdmL7zYQkpLS7V///4Ju9+1axcdOoSvz3kgK7fsoiGoDOpe1ALpmk+icmYC2STr3Llzt6hqN7/l8INOnTrpoEGD/BYjKtmQj9qKjJmiJ63aePXv3585c+Yk7H7atGmMHz8+rrvr/z6X5VuqefOHUT/nSimJypkJZJOsIrLKbxn8oqysrEm6km6yIR+1FRkzRU9ct2EzaJ+fw+66Zn9z6nA4HI4WkrKWl/3gLKYTYIOqDkmVDKmiXX4ONfXOeDlaTkv0REQex2zls0lVR9prXTCr8ffHrIF3SRPWiHQ4soZUtryW2XX+ov2KgV0pjD9ltMtzLS9H0miJnjyB2S7Fyy3AW6o6GHjLnjscrY5UGq9EFq5syeKWvtE+P4c99Y241UkcSaDZeqKqMzBL7Xg5j31r8/2N2Iv5OhxZS8q6DVV1eaTrInIccLmq3hDNTabTLj8XVaipD9IuP8dvcRxZTAr0pMwubIyqbhCR7tEcish1wHUA3bp1Y9q0aU2IJr1UV1dntHzgZEw3aZltKCKHYRZrvQSzJfq/0xFvqmhvDdbuugZnvBxJI916oqqPYBaUZfCQoXrUMeMQAUEQCclkzgMCIoKErkn4Dh6ppa3M5Es12SBjoqRywsYQzArpl2GW8n8WsxDwhFTFmS46FJhk21XbSFd/PvVytBJSoCcbRaSHbXX1wKzIH5fVVUFG/GJykyMzxs0Ys4A1dOy9ts8QhtxEPbbu2Wso9/dbW1tL4QdvIwKBCH4JOw+5gXCj6wnXez3cnQ0wsJ/7cMMeisscV1bW8I9VH8F+zwy5gQD5uQHyc+z/3LDznAAFeQGKCnLp2C5vv1+XDvnk5rhJ4ZFIZctrMfAucI6qLgUQkR+mML60UWSNV1Vtvc+SOFoBydaTl4GvA3fb/3G3tAHoXCDcOnEYCqiCooSGdFXNcdBz3WwOrwe4D7mxf3v9hrvTCH5D56AEg/tf37ChgrLyLnvDDe4XrhLarH5f+NaNJ8xw9yE3HCBb2PNoMKLfUBqEnrmqVqnfXrPXXSjchmCQusYgdQ2eX2OQ+sb4Y+Y5AaG8pJDendvRp0t7hpUXc0ivjozs1XFvJbqtksqnvxBTo3xHRN4A/smBu4VmJSWFJtmqaxriuHQ44tJsPRGRZ4DxQKmIrMVs6Hk38JyIXAusBhLaaLBjgfCtEyNudJsRTJu2jfHjD/NbjJiYLrnjE3YfDKoxao1BauuDVNc2sGNP/X6/jTtqWLttN+u272HGF5t5Ya7ZtiwvRxhzUBdOGlbGuaN60q242dv+ZS2pnLDxIvCi3U32fOCHQJmI/Al4UVXfTFXcqaYoZLxqnfFytIyW6ImqXhbl1snJl9SRbAIBoTCQQ2FeDhSSkAHaXFXL/HU7+GB5JW8v3sSdryzkt68v5qxDe3DdCQM4uEdJGiTPDFLemaqqu1T1KVU9G+iN2UEzq789CXUbOuPlSBatUU8cyadbcQEThnXn1jMPZspNJzL1phO5fGxf3lxQwZl/fJdb//05O2vaxnBGWkcCVXWrqj6sqielM95kE2p5VbluQ0cKaC164kg9g7oXcce5I5h5y8lcc9xBPDdnDRPvf5ePV7f+RVVSZrxEZF4y3GQixQV5gGt5OVpOa9YTR/ro2D6P/zl7OM9ffwyBAFz6yAe8Mb/Cb7FSSionbBwsIp/FuC9AxxTGnzIK8wLkBMRN2HAkg1arJ470c0Tfzrz0neP4xpNzuOHpeTx0xRGcPqLcb7FSQiqN17AE3GTlAoEiQlFBLlVtpG/ZkVJarZ44/KFrUQH/uHYsVzz2Id97+mOe+uZYjurfxW+xkk4qZxtmxJ4vqaKoIJcq123oaCGtXU8c/tChIJcnrj6KCx6ayXeemser3xtH95JCv8VKKhn56baIPC4im0RkvufaHSKyTkQ+sb8z/ZSxuDCXnXuc8XI4HJlJp/b5/OnKI6iqqefm5z9tdQuJZ6TxIvJWDwD3qeph9vdammXaj87t89m+u85PERwOhyMmw8pL+NlZw3n3yy08P2et3+IklYw0XlG2esgoOnfIY5szXg6HI8O5Ykxfxh7UhbteXUh1XetpfaVyYd4q7PJf4bcAVdXmfAr+XRH5GjAHuDnSDrHebR7KysqatPx/U7YL2L29lk07GnzZXiCbtjXIJln9IEV64nDsJRAQ7jx/JGfcP4P/LDNbb7cGUjlhozjJQf4JuBOj6HcCfwCuiRDv3m0eRo8erU1Z/r8p2wV8VLuYd9ct58QTT3TbQ8Qgm2T1gxToicNxAEPKirl0TF+enb2aVZW76Ne1g98itZiM7DaMhKpuVNVGVQ0CjwJj/JSnc/t8GoPKTvetl8PhyAJ+cMpgAgJ/mrbMb1GSQtYYL7s3UYgLgPnR3KaDTu3zAdi2y417ORyOzKd7cSEn9M7lX/PWsm77Hr/FaTEZabzsVg+zgKEistZu73CPiHxuVyOYgFl92ze6FhnjVbmr1k8xHA6HI2HOPCgPVXj8vRV+i9JiMnI3syhbPfwl7YLEoKzYfPC3caczXg6HIzvo2i7AGSPLeX7OGm4+bQjt8zPSBCRE2lteIjJVRF4Xkaye9FLeMWS8anyWxNEaaS164sg8vn5sf3bWNPCfT9b7LUqL8KPb8GvA7UA/H+JOGp3b55GXI67l5UgVrUJPHJnH6H6dObhHCU9/uNpvUVpEyo2XiNzoPVfV9cA4VX0w1XGnEhGhe3EhFTuyf+DT4T+tVU8cmYeIcNGRvfl83Q6WbqryW5xmk46W19cjXJuUhnhTTt8u7VmzzRkvR1JotXriyDzOGdWDgMCLH6/zW5Rmk8oVNi4DLgcOEpGXPbeKgcpUxZtO+pe2Z8rCjX6L4chi2oKeODKP7sWFHD+4Gy99vJ6bTx1KIJDehRaSQSqnmswENgClmNUwQlQBsTbfyxr6de3Aluo6dtbUU1KY57c4juyk1euJIzO54PBe/ODZT/ho5VbGDujqtzhNJtX7ea0CjklVHH4zqFsRAF9UVDG6FW725kg9bUFPHJnJaSPKaJ+fw38+XZ+VxisdEza+IiJfisgOEdkpIlUisjPV8aaDkb3M7uwL1reKx3H4SGvWE0dm0j4/lwlDuzNl4UaCwexbbT4dEzbuAc5V1Y6qWqKqxa1lpeyykgK6Fxcwb/UBi9s7HE2l1eqJI3M5ZXh3NlfV8tm6HX6L0mTSYbw2quqiNMSTdkSEYwZ25f2llTRmYc3FkVG0Wj1xZC4ThnYnJyBMWVjhtyhNJh3Ga46IPCsil9muka+IyFfSEG9aOG14OVuqa5nxxWa/RXFkN61aTxyZSaf2+Yzp3yUrZ02nw3iVALuB04Bz7K/VLHlz6vAySosK+NuslX6L4shuWrWeODKXU4aX8cXGalZV7vJblCaR8lUZVfXqVMfhJ/m5Aa4+rj+/m7yElz9dz7mjevotkiMLae164shcThtexp2vLGTqok1cO+4gv8VJmHTMNhwiIm+JyHx7fqiI3B7Hz+Misinkx17rIiJT7IysKSLSOdWyJ8p1Jwzg8L6duPm5T/jLeyuobWj0WyRHltEcPXE4kkGfLu0Z0K0D736ZXUMf6eg2fBS4FagHUNXPgEvj+HkCOCPs2i3AW6o6GHjLnmcEeTkBnpg0huMGlXLnKwsZfddUbnhqHg++s5TXPt/A3FXbWLa5mi3VtdQ3Bv0W15GZNEdPHI6kMG5QKR8u30pdQ/aUT+nYzKW9qs4W2W/5kYZYHlR1hoj0D7t8HjDeHv8NmAb8NCkSJoGO7fP466SjeH9pJS9/uo73vtzCq59viOg2PydAQW6AgrwcCnIDFOYFKMjN2fs/LzdAfo6QGwiQlxsgL0fICwTIyzXXKtbX8VHtYnIDAfLt/b1uA0JeTpTj3AC59lp+pOPcAPk5AfJyAuRk4XIxWU6T9cThSBbjBpXy5KxVzFu9jaOz5IPldBivLSIyEFAAEbkIsxxOUylT1Q0AqrpBRLonUcakICKMG1zKuMGlAFTXNrByyy42V9eyc08923eb3576RmobGqmpD1Lb0Eit/R86372nkYbGIPWNQeob1f4P0tCo1DUGqa1rYOrq5TSkcHq+iGlRGmMm5HqO83IC9twax5wAuTmy1/B5DefmjbVMr1pg3e1z7z3Ot/73nlsjHTrOywlYQx0lPhteWMGfbSRLTxyOJnP0wK7kBIT3l25xxsvDDcAjwDARWQesAK5IVWQich1wHUBZWRnTpk1L2G91dXWT3CcsE9DR/vrl0oxUD+Dt4a2urqeoqANBVRoVGoPQEIRGhYag2v+e8yA0hNypeu5BYwT3DR73jUG1fhpp1Ma99xsbobEedtvwQv4bw/zXB4PM2rDShKXmlypyBHICkLv3v5Ab8F4TcgXPNTH/7X2fSaqeiMhKzPqIjUCDqo5OhpCO1klJYR6jenfk3S+3cPNpQ/0WJyFSarxEJACMVtVTRKQDEFDV5m4gs1FEethWVw9gUyRHqvoIphBg9OjROn78+IQjmDZtGk1x7xfZIiccKGswqNQHTYuyoTFIXah12RCkIRikrmFfS9Pb6gw/r7P+Q9frrP/QcailWr83jn0t15CfhsYgNZ4w/SLJeuJlgqpuSUI4jjbAuEGl/N87S9mxp56O7TJ/ofGUGi9VDYrId4HnVLWlHxG8jNnz6G77/z8tlc+RfgIBoSCQQ0E62vxNRH7iT7xJ1hOHo1kcN6iUP769lFnLKjljZLnf4sQlHUXIFBH5EfAssFcxVXVrNA8i8gxmckapiKwFfoExWs+JyLXAauDiVArtcKSZJutJHBR4U0QUeNj2SOyHt4u9W7duKekyTxap6tJPJtkuY0NQyQvAv9/9lMIti9MrWDNIh/G6xv6/wXNNgQHRPKjqZVFunZwsoRyODKPJehKH41R1vZ3YNEVEFqvqDK8Dbxf70KFDm9TFnm6yoau8Nch4xJez2FDXyPjx49InVDNJx5jXlar6firjcTiymVToiaqut/83iciLwBhgRmxfjrbOmIO68OA7S6mubaAoE/v2PaT0I2VVDQK/T2UcDke2k2w9EZEOIlIcOsaslzg/ti+HA0b370JQ4eMs2OYpHStsvCkiF0qWf4TjcKSYZOpJGfCeiHwKzAZeVdU3khCuo5VzRN9OBAQ+WtHcodb0kY524U1AB6BBRGownz2p22jP4diPpOmJqi4HRiVZPkcboLgwj+E9S5i90hkvVLU41XE4HNmO0xNHpnBU/y48M3s1dQ1B8nPT0TnXPFJuvETkhEjXw2c+ORxtGacnjkzhqP5d+Ov7K5m/fgdH9M2YzTsOIB3dhj/2HBdiZj3NBU5KQ9wOR7bg9MSREYzuZwzWx6u3t23jparneM9FpA9wT6rjdTiyCacnjkyhe0khPToW8uma7X6LEhM/OjTXAiN9iNfhyCacnjh8Y1TvTny6NrONVzrGvP4fdpsHjLE8DPg01fE6HNmE0xNHJjGqTyfeWFDBtl11dO6Q77c4EUnHmNccz3ED8IxbccPhOACnJ46MYVSfjgB8unY744dm3NaJQAqNl4h0A7qp6t/Cro8QkW6qujlVcTsc2YLTE0cmcmjvTojAJ2sy13ilcszr/wHdIlzvDTyQwngdjmzC6Ykj4ygqyGVw96KMnrSRSuN1iKpOD7+oqpOBQ1MYr8ORTTg9cWQkZtLGDlRTuP15C0il8Yq1FWezt+kUkZUi8rmIfCIic+L7cDgympToicPRUkb16cTWXXWs3bbHb1Eikkrj9aWInBl+UUQmAstbGPYEVT1MVUe3MByHw29SqScOR7M5rE8nwIx7ZSKpnG34Q+AVEbkEs1IAwGjgGODsFMbrcGQTTk8cGcnQ8mLycwN8umY754zq6bc4B5Ay46WqX4jIIcDl7PvYcjrwLVWtaUnQxNje3Lu1eVlZWZO25c6Gbbwhe+SE7JLVD1KoJw5Hi8jLCTCyZ0nGfqyc0u+8VLUW+GuSg425vbl3a/PRo0c3aWvzbNjGG7JHTsguWf0iRXricLSYkb068q+5awkGlUAgs7ZkzNz17qPg3d4cCG1v7nA4HI4kM6JnCbvqGlm1dbffohxAVhkvt725w+FwpI8RPc1KGwvW7/BZkgPJKuOF297c4XA40sbgsiJyA8KC9Tv9FuUAUrk81OfsW2h0v1uY7c2b/AGm297c0dpIhZ44HMmiIDeHwWXFbct44ab5OhyJ4PTEkdGM6FnCtCWbUFVEMmfSRiqnyq9KVdgOR2vB6Ykj0xnRs4QX5q5lU1UtZSWFfouzl1R2G1axrzskZK6Vfd0hJamK2+HIFpyeODId76SNNmG8VLU4VWE7HK0FpyeOTOfgHiaLLli3k5OGlfkszT7SMttQRMaJyNX2uFREDkpHvA5HNuH0xJGJFBfm0b9r+4ybtJFy4yUivwB+CtxqL+UD/0h1vA5HNuH0xJHJjOjZkYUb2pjxAi4AzgV2wd4VMlxXicOxP05PHBnL8J4lrN66m5019X6Lspd0GK86NbuZKexdGcPhcOyP0xNHxjK8h5k3tKSiymdJ9pEO4/WciDwMdBKRbwJTgUfTEK/DkU04PXFkLMPspI3FGdR1mNJV5QFU9fciciqwExgK/FxVp6Q6Xocjm3B64shkyksKKSnMZXEGtbxS+Z3XIKBMVd+3SjjFXj9BRAaq6rJUxe1wZAtOTxwrgHnQAAAgAElEQVTZgIgwrEdJRhmvVHYb3g9EetLd9p7D4XB64sgShpUXt5kxr/6q+ln4RVWdA/RPYbwORzbh9MSRFQwrL6G6tsFvMfaSSuMVax2Rds0NVETOEJElIrJURG5pbjgOR4bg9MSRFQwtz6wvN1JpvD6ys6b2Q0SuBeY2J0ARyQEeBCYCw4HLRGR4i6R0OPzF6YkjK8g045XK2YY/AF4UkSvYp4SjMSsHXNDMMMcAS+2+XojIP4HzgIUtlNXh8AunJ46soKggl75d2pMp2yCkcmHejcCxIjIBGGkvv6qqb7cg2F7AGs/5WmCs14GIXAdcZ0+rRWRJE8IvBba0QL50kS1yQnbJOjTdEfqlJ3CArtSKyPwWxJlqsiEftRUZ+yVDkJaSju+83gHeSVJwkXZC228XWlV9BHikWYGLzFHV0c3xm06yRU7IPln9ijvdemLj3Ksrmf6eMl0+cDKmm7SsKp9E1gJ9POe9gfU+yeJwZCpOTxytnmwzXh8Bg0XkIBHJBy4FXvZZJocj03B64mj1pLzbMJmoaoOIfBeYDOQAj6vqgiRG0azuRh/IFjnByZp2mqknmf7smS4fOBnTipiFrB0Oh8PhyB6yrdvQ4XA4HA5nvBwOh8ORfTjjFYaIfM8uq7NARO7xW554iMiPRERFpNRvWaIhIr8TkcUi8pmIvCginfyWyUtbWkop3rOKSIGIPGvvfygi/TNMvptEZKHNS2+JSNq/OUo0v4jIRVY30zo1PRH5ROQSm44LROTpdMqXNFTV/ewPmIDZBLDAnnf3W6Y48vbBDMqvAkr9lieGnKcBufb4t8Bv/ZbJI1sOsAwYgFnV4lNguN9y+fWswHeAP9vjS4FnM0y+CUB7e/ztdMrXlPwCFAMzgA+A0ZkkHzAY+BjobM8zupyL9nMtr/35NnC3qtYCqOomn+WJx33AT4jwAWomoapvqmpoOeoPMN8dZQp7l1JS1TogtJRSaySRZz0P+Js9fgE4WUQiffTsi3yq+o6q7ranfuSlRPPLncA9QE06hSMx+b4JPKiq2yAryrmIOOO1P0OA4213yXQROcpvgaIhIucC61T1U79laSLXAK/7LYSHSEsp9fJJllSTyLPudWMrHDuArmmRrunv4lrSn5fiyigihwN9VPWVdApmSSQNhwBDROR9EflARM5Im3RJJKu+80oGIjIVKI9w62eY9OgMHA0cBTwnIgPUtq3TTRxZb8N0x2UEsWRV1f9YNz8DGoCn0ilbHBJaSqmVkMiz+pkeCcctIldiFjA+MaUSRYg6wrW9MopIANMjMildAoWRSBrmYroOx2Naru+KyEhV3Z5i2ZJKmzNeqnpKtHsi8m3g39ZYzRaRIGYhy83pks9LNFlF5BDgIOBT26PTG5gnImNUtSKNIu4lVroCiMjXgbOBk/2qDEShLS2llMizhtysFZFcoCOwNT3iJfYuROQUTAXuxFAXfxqJJ2MxZoHlaVY3y4GXReRcNRuM+i1fyM0HqloPrLCLlw/GrMySPfg96JZJP+B64Jf2eAim+S1+y5WA3CvJ7AkbZ2C24+jmtywRZMsFlmMqA6EB7hF+y+XXswI3sP+EjecyTL7DMRMSBmdqGoa5n0Z6J2wkkoZnAH+zx6W2nOvqV75s7q/Ntbzi8DjwuN0aog74uto37GgR/wcUAFNsbfQDVb3eX5EMmvolxzKGaM8qIr8E5qjqy8BfgL+LyFJMi+vSDJPvd0AR8LzNS6tV9dwMk9E3EpRvMnCaiCwEGoEfq2qlf1I3D7c8lMPhcDiyDjfb0OFwOBxZhzNeDofD4cg6nPFyOBwOR9bhjJfD4XA4sg5nvBwOh8ORdTjj5XA4HI6swxkvh8PhcGQdzng5HA6HI+twxsvhcDgcWYczXg6Hw+HIOpzxcjgcDkfW4YyXw+FwOLKOrDReItJfRNTuN4SITBORb/gtV1uhNaW3iNwmIo8102+1iAxItkzJoi3oiYistPt7ZRwi8oSI3OW3HMlARK4QkTeb6XeBiIxPskj+Gi8RuVxE5thCYIOIvC4i45Icxx0iUm/j2C4iM0XkmGTGkW5sIVRjn2mLiPxbRHpEcNdLRBpEZGCEey+KyO+jhJ9v0+1LEdllC4jHRaR/8p+m+SSjcFDVX6tq3AI9UsGvqkWqurwl8SeCD3oS+v0kmXGkG5s/6uyzbBWRKSIyLIK7Qls2nBTh3n0i8kKU8EVEvi8i862erBWR5+1msRmDfbf/aEkYqvqUqsbduT2STqrqCFWd1pL4I+Gb8RKRm4D7gV8DZUBf4CHgvBRE96yqFmE2XnsHeD4FccQkVPtNIt+1zzQE6ITZenw/VHUd8BZwVZgsXYAzgb9FCfsF4FzgcsxOuqOAucDJyRLeI0tOssNsQtwZv5+dH3ri+d3T1ABSlaYtCPceqye9gU3AE+EOVLUGeBb4WlicOcBlRNeTB4Abge8DXTC6+BJwVjNljYqfeTVj9cSPHTAxBWI1cHEMNwHgFsyuqZXAc0AXe68/oECu7tut9BtRwrkD+IfnfLj1281z7WzgE2A7MBM41F6/BXghLLwHgD96nuMvwAZgHXAXkGPvTQLexxiVrfbeIGA6sAPYgiksQuEOA6ZYt0uAS2KkzX7Pi9n9dn4Ut5cDy8KufQeYF8X9KcAeoE+c+O+0z1cFvIlnJ2dM5aDCPucMPDu5YgqPPwGvAbtsfGcBHwM7Mbu63hEW3zj7Xrbb+5OA64B6zKah1cB/rduewL+AzcAK4PtheeEF4B82rm948wdQaO9V2rg+whiMX2E27auxcf2fda/AIHvcDvgDsMo+93v2WsQwM11Pwu71BF7G5M2lwDdjpOl3bf4ptfdvBxqAEnt+F3C/PY763j2yXwusBmbY61fZNK4EfobZRfyUKHI/AdzlOT8LqI7i9lhMXm7vuXYmxuDlRnA/2OaJMTHezRPAg8CrNuwPgYFhZcka+/xzgePj5NUxwCybjzZgNnnN9/gZwb4yZCNwG2bX5DqMrlQDnzaz7JoEvGfvi723CZPXPwNGEl0n974jzAaZt2Hya5V97j7RwoypH4koUbJ/NkEbImUKj5sfAB9gakwFwMPAMy1RSsy22HdjDEfI7xE2wcbahP26TewCoB+wm32Kl2Nf9tH2/CUrVwegOzAb+JYnAzQA38Nszd0OeAajcAFMoTbOuu2AycRXW7dHWBkjbi/ufV5Ma/Jt4O9R3LazmWGc59os4AdR3N8NTI/z/qbZzDfEhj8NuNtz/xqg2Kbh/cAnYQq9AzjOkw7jgUPs+aEYxTvfuu+LyeSXAXlAV+CwKIVTAKMMP7fvegBmS/TTPXmhHjjfum0Xlj++BfwXaG/f9ZGed783zT3xeY3Xg9ZNL+v3WPv8UcPMVD2JcG86prVXCByGqRicHCNNZwAX2vtv2rwy0Z7PAC6wx7Hee0j2JzH60Q5T8awGTrDPeq9Nn7jGC7P78tPAuzHS8gvgSs/5M1hDG8Ht9cCqOO/vCUzhPwaj108B//TcvxKTn3OBmzEVvsIY6XokcLR13x9YhNVjjL5tsOEU2vOx0d4tTS+7JrHPeJ2O0bNOGKNzMNAjkk7aayvZZ7x+DHwODLV+R9k0iBpm1PRNRImS/QOuACriuFmEVRB73sO+zNCLa4pS1mFqK42YGtt4z/0/AXeG+VkCnGiP3wO+Zo9PxbZiMDXyWqCdx99lwDueDLA6LNwngUeA3mHXv0qYUtmM9YsozzQNY1S3Y2pNT+FpSUZw/xjwiD0ebNOjexS3j+JRsBjx3+45/w7wRhS3ney76ujJ3E/GCf9+4D57fCvwYhR3+ykKpgISnua3An/15IUZEfJHyHhdg6flHeGZIxovTOGyBxgVwV/UMDNYT0K/nphacSNQ7HH7G+CJGGl6J/BHK0MFpmvtbkyhurdVFue9h2Qf4Ln/c/Yv/DtYmWMZrxr7LBWY1uPASG6t+9uBN+1xCUbHDo/i9mfAB3HezRPAY57zM4HFMdxvC+WhSOkawf0PsLqBKXs+jvFuvb1PzSm7JrHPeJ2EMfRHA4FYOmmvrWSf8VoCnBdBxqhhRvv5NeZVCZTG6UvtB7xoB1K3Y5S0EZPwTeU5Ve1k/c7H1GC88dwcisfG1QejuGBqa5fZ48vtechfHrDB4+9hTC0mxJowOX6CqVXMtjNwrvGENTZMhiuA8hjP9H1V7aSqvVT1ClXdLCJ9vQPuHrd/Ay4RkUJMt8sbqropSriVmAIwHhWe492Ymi0ikiMid4vIMhHZicm4YFqIIfZLFxEZKyLviMhmEdmBqdWG3PfB1NwToR/QMywdb2P/PBP+Trz8HZgM/FNE1ovIPSKSl0C8pZiCOZKczQ0TfNITz289Rg+2qmqVx90qTAszRHiaTse0qo7A1LKnACdiCqalqroF4r73SGH39J6r6i5MGsXi9/ZZylX1XFVdZuP2Tkzpa90+CUwQkV7ARVbWj6OE2yI9sTLcLCKLRGSHfXcdia0nQ0TkFRGpsLr1a5qvJ00tu/aiqm9juiwfBDaKyCMiUpJg3BHlbE6YfhmvWZga0fkx3KzBdDV4lalQzSSEZmGV5lvAHZ7ZeWuAX4XF015Vn7H3nwfGi0hv4AL2Ga81mNpLqcdfiaqO8EYZFn+Fqn5TVXtaOR4SkUE2rOlhMhSp6reb+Hyr1TPg7rn+LkbZzsN0VTwZI5ipwBj7vM3hchvPKRhl7G+vi1fUMD9PY2rFfVS1I/Bnj/s1wAGzJaOEswZYEZaOxap6Zgw/+26o1qvq/6rqcEy339nsG8SP6g/TxVsTSc44YcbDFz0JYz3QRUSKPdf6Ylr8IcLTZiamW+gCTL5eaP2chTFsIWK990hhb8AUfgCISHtMl1OT0f0npqy211YD72IqjlcRW0/eAnqLyOjmxC8ixwM/BS4BOtvK9Q5i68mfgMXAYFUtwVTMmqsnTSq7DghQ9Y+qeiRmnG0Ipjswrr9YcsYIMyK+GC9V3YHpAnhQRM4XkfYikiciE0UkNMPpz8CvRKQfgIh0E5EWz7BS1cWYmnBoGvCjwPW2Figi0kFEzgopq6puxnS3/BVTMC6y1zdg+vP/ICIlIhIQkYEicmK0uEXkYo9R2IZ50Y3AK8AQEbnKpkOeiBwlIge39Hk9PAn8FtON999ojlR1Kqam/KKIHCkiuSJSLCLXe1qKsSjGKEYlZpzn1wn62aqqNSIyBmMAQzwFnCIil1hZuorIYfbeRsy4VojZwE4R+amItLOtwJEiclQCMiAiE0TkEDvLbCem+60xSlx7UdUg8Dhwr4j0tPEeIyIFccKMiZ964pFhDcYY/UbMlPJDMZMonorhZzdm/OIG9hmrmZgKm9d4xXrvkXgBOFtExolIPvBLkl+G/Q0z6eQ4Yj/jl5hxwGdEZLyYz0sKReRSEbklgXiKMeNKm4FcEfk5pqsynp+dQLWYKf/eyu0rQLmI/MDmu2IRGWvvbQT6i0jAyt7kssuLLZvG2h6EXZgKVlw9sTwG3Ckig215e6jV6VhhRsS3qfKqei9wE6afeTPGIn8XM5AIZibOy8CbIlKFGZQeGyGo5vA74DoR6a6qc4BvYpqs2zCzqSaFuX8a05J4Ouz61zATAxZavy8QuyvhKOBDMV16LwM3quoK2yVzGnAppqZbgTE0Bc19wAg8ian9PquqtXHcXoSZDfgspjY4HxiNaZUlEs8qTM18Iea9xeM7wC/te/45ZsYcsLc2fCZmIHorZlboKHv7L8Bw2/Xxkqo2AudgJhWswLSIHsO0ABOhHPMOd2K636ZjZnuByY8Xicg2EfljBL8/wnSRfWTl/C1Gv2KFGRef9STEZZgW9HrgRcxY7JQ4fqZjuqZme86LMRM2QkR975FQ1QUYg/g0phW2DVjblAdJgBeAzsBbtpCPxffZ19W1HdMddgExKoceJgOvY8Z5VmEK61hd2mDy2OWYCUyPYvQTAFuGnIrJ/xXAl8AEezv0aVCliMyzx00tu7yU2Pi3sW/mZ+ib0f10MoLfezHv+U2MTvwFMyEkVpgRETtY5nA4HA5H1pCVy0M5HA6Ho23jjJfD4XA4sg5nvBwOh8ORdTjj5XA4HI6sIzMXXEwSpaWl2r9//4Td79q1iw4dOqROoCSRLXJCZsm6p76RnXvq2bmngZoGMwu3MC+HjoV5lLTLZcFnn2xR1W4+i+kLnTp10kGDBvktRlQyKR9Fo63IOHfu3IzQk1ZtvPr378+cOXMSdj9t2jTGjx+fOoGSRLbICf7K2hhU5qzcyuQFG3lzYQVbtu0hV+D0fl04bUQZp48op0+X9nvdi8gqXwTNAMrKypqkK+kmG/J8W5ExU/SkVRsvR9ujpr6Rmcu2MHn+RqYu2kjlrjrycwKMG1zKdycM4pThZZQWJfPzOYfD4QcxjVeUjzHD2amqtydJHoejyVTV1PPOks1MXlDBtMWb2FXXSFFBLhOGdef0EWWMH9qdooLsqqc53XM4YhNPo8/DfPkei1swX/87HGljc1UtUxdtZPKCCmYuraSuMUhpUT7nHtaT00aUc+zArhTk+rbPZTJwuudwxCCe8bpPVaPtIgqAiHROojwOR1RWV+5m8oIKJi+oYO7qbahCny7t+Nox/Th9ZDlH9O1MTiB8XdesxemewxGDeMYrpvIAqOr9SZLF4dgPVWXRhqq9BmtxhdmV4+AeJdx48mBOH1HOsPJiRFqNwfLidM/hiEE847VERDZjVoR+H5ipql+kXixHW0VV+XTtDl6fv4E35lewqnI3IjC6X2duP+tgThteTt+u7eMHlP043XM4YhDTeKlqdxEZgtmH6FjgRyLSDbNy9fuqek8s/w5HIjQGlbmrtvH6/A1Mnl/B+h015AaEYwZ25VsnDOTU4WV0K25bMwSd7jkcsYk7BcvW9r4AnhCRgZjtKW7EbOHhFMjRLBoag3y4YqsxWAs2srmqlvzcACcMLuWm04Zy6sFldGyf6IbDrROnew5HdOJNlQ/V+o7B7GC6HFPzuxKYF8Orw3EAtQ2NzFxayevzNzBl4Ua27a6nXV4OE4Z144yRPThpWPZNaU8VTvccjtjEKynewyjKvcBLdodUhyNh6hqVN+ZX8Mb8Dby1aBNVtQ0UFeRy8sHdmTiyBycO6Ua7/Kye0p4qnO45HDGIZ7x6sq/P/XoRycUo1CxglqouT7F8jiykuraBdxZv4o35FUxduJvaxrl0ap/HGSPLmXhIOccNKs32b7DSgdM9hyMG8SZsVAD/tj9EpD1wDfC/wEGAK4EcAOzYXc/URRt5fX4FM77cTF1DkNKiAo7tmcu1px3J2AFdyMtxmxgkSkt1T0Q6AY8BIwEFrlHVWamU2eFIJ/HGvDpi+txDNcDDgaXAfzHTdx1tmMrqWt5caAzWzKVbaAgqPToWcvmYvkwcWc7o/l14d8Z0xg0u9VvUrCMJuvcA8IaqXiQi+UCb+L7A0XaI1224FDNIPBO4E5itqntSLpUjY9m4s4bJCyp4/fMKPlxRSVChb5f2XDvuIM4YWc6o3p0ItJ5VLvyk2bonIiXACcAkAFWtA+pSI6bD4Q/xug1937PF4T8VO2p4ff4GXvt8A3NWmWWZBnUv4oYJgzhjZDnDe5S01lUufKOFujcA2Az8VURGAXOBG1V1l9eRiFwHXAfQrVs3pk2b1oIoU0t1dXVGywdOxnQTr9vwDlW9o6VuHNlHJIM1tKyYH5w8hDMPKWdwWbHfIrZqWqh7ucARwPdU9UMReQCziO//eB2p6iPAIwBDhw7VTN6Lqq3slZVqskHGRInXbfgNEdkZ474AlwJ3JE0ih294DdZHK7cBMKy8mB+eMoQzD+nBoO5FPkvYpmiJ7q0F1qrqh/b8BYzxcjhaDfGM16NAvCr2o0mSxeEDIYP16memhQXGYN10qjNYPtNs3VPVChFZIyJDVXUJcDKwMNkCOhx+Em/M63/TJYgjfTiDlfkkQfe+BzxlZxouB65uuVQOR+bg1uJpI1TsqOG1z/eNYYExWDefOoQzD+3BwG7OYLUmVPUTYLTfcjgcqcIZr1aMM1gOh6O1kpDxEpFSVd2SamEcLccZrNaF0z2HIzLxpsqfAzwONIhII3CJqs5Mi2SOhHEGq/XhdM/hiE28ltevgONVdbGIjMXsIXRi6sVyxGNzVS2vz9/Afz9dv9+0dmewWg1O9xxx2bG7njmrtrJ0UzUrK3exp66Rwrwc+nZtz7EDSzm0V8dWu+JNPOPVoKqLAezHju7LVB/ZtquONxZU8PeP9rB48lSCCkPKirjp1CGc5QxWa8PpniMim6tq+c8n65i8oIJ5q7fTGFQAunbIp0NBLrvrGthSXQcsYUC3Dtx48mDOHdWz1a2CE894dReRm6Kdq+q9qRHLEWJnTT1TFmzkv5+t570vzeK3Ze2FGyYM4uxDezK03JVprRSne469qCqzllfy1/dX8s7iTTQEleE9Svj2iQM5fnApw8pL9tt5fNuuOt5avInH3l3Ojf/8hNc/r+Ceiw/18QmST1M/Uk7kw0lHC9ld18DURZt45dP1TFuymbrGIL06tePa4w/inEN7svmLeUyYMNRvMR2pxemeg/rGIK99voFH313O/HU76dohn2vHHcRFR/aOuURb5w75XHRkb75yeC8ee28597yxhCsf+5DrhmgapU8t7iPlDKGmvpFpSzbz38/W8/aiTeypb6R7cQFXHN2Xc0b15PA+nfY2+6d92bqa/44DcbrXtqlvDPLivHX88e0vWbttDwO6deDurxzC+Yf3ojAv8W0UAwHhuhMGMrBbEd9+ah73V8OpJzW2is1g3XdePtLQGOTdpVv47yfreXPhRqprG+jSIZ8Lj+zF2Yf25Kj+XchppYOtDofjQBqDyksfG6O1qnI3o3p35BfnjODkYd1bNPHi5IPLuO+Sw7jh6Xn8738X8usLDkmi1P6QccZLRO4AvonZ0gHgNlV9zd67FbgWaAS+r6qTfRGyBagqn6/bwb/nreOVz9azpbqOksJczjyknLMP7cmxA7uS63YcdjjaFMGg8urnG7hv6hcs37yLET1L+MvXR3PSsO5Jm2hx1qE9eGVWHk9/uJrTR5Rz4pDs3vEq44yX5T5V/b33gogMx6yiPQLoCUwVkSGq2uiHgE1lzdbdvPTxOl78ZB3LN+8iPyfAyQd35/zDezF+aLdW0Yx3OBxNZ+ayLfzmtcV8vm4Hw8qL+fOVR3L6iLKUzA68YFAeX+4q4NZ/fcbUm0+kfX6mmoD4NEtyETkPqPBsuZAOzgP+qaq1wAoRWQqMAWalUYYm0dAY5K3Fm3jqw9XM+MI0JMcc1IXrjh/AxJE99psd5HAkgk+650gBSyqquPv1RbyzZDO9OrXjvq+O4rxRvVL6XVZ+jvCbrxzCxX+exV/eXcH3Th6csrhSTXPN7ljgEBHJVdWJyRTI8l0R+RowB7hZVbcBvTDboodYa6/th3d32LKysibtGpqsXUbrg8qMtQ28uryerTVK5wLh/EF5jOuVS2m7Wti9nI9nL292+Nm0G2o2yZolpFr3HCmmYkcN9035gufnrqGoIJfbzhzG147p36SJGC3hqP5dOH1EGQ/PWM5lY/tSWlSQlniTTVzjJSIB4Gjv0jSqeltLIhWRqUB5hFs/A/4E3Amo/f8H4BrM5nvhHDDv07s77OjRo5u0O2wydhl9Z8kmfvHvz1m/o47R/Tpz9wkDOGlY96SOY2XTbqjZJGumkQrdc/hHVU09D09fzmPvLScYhGuOO4gbJgyic4f8tMvy49OH8ebC6Tz+3gp+csawtMefDOIaL1UNisgfgGOSFamqnpKIOxF5FHjFnq4F+nhu9wbWJ0umlqKq3P36Yh6esZyhZcX846JRHDeoa6v7qt2RPlKhe470U9cQ5JnZq3ngrS/ZuquO8w7ryY9OG0qfLu19k2lQ9yImjizn7x+s4jsTBlFUkH1jX4k2B94UkQslDSWxiPTwnF4AzLfHLwOXikiBiBwEDAZmp1qeRPn9m0t4eMZyrhjbl/989zjGDS51hsuRDJqteyKSIyIfi8gr8V07ko2q8vrnGzjtvun84uUFDCkr4uXvHscDlx7uq+EKcd0JA6mqaeCfs1f7LUqzSNTc3gR0ABpFZA+mC09VtSQFMt0jIodhugRXAt/CRLZARJ7DbGfeANyQKTMNZ6/YykPTlvHV0X246/yRzmg5kklLdO9GYBGQCj11xODztTu489WFzF6xlSFlRfx10lGMH9oto8qGw/p0YnS/zjz14WquHXdQRsmWCAkZL1VN27I0qnpVjHu/wqy2nVH8bvJienZsx8/PGZ51GcCR2TRX90SkN3AWRl9uiuPckSQ27qzhnjeW8O+P19KlfT6/umAkXx3dJ2O/3bxsTF9ufv5TPli+lWMGdvVbnCaR6GaUAlwBHKSqd4pIH6CHqmZMt51fLFi/g49WbuP2sw6mQxb2Gzsymxbo3v3AT4ixHqJ3Zm63bt0yelZops9arW1UXl6yiylT3iIYhIn98zh7QC7t96zgvXdX+C3eXsLTsahRaZcLD7zyEbWjCv0TrBkkWto+BASBkzAzAKuBB4GjUiRX1vDSx+vIzw1w8ZF94jt2OJpOk3VPRM4GNqnqXBEZH82dd2bu0KFDmzQzN91k6qzVYFB56ZN13PPGEip2CmceUs4tZxxM367+j2lFIlI6Xlj1OS/MXcvoY8Zl1cSNRNuyY1X1BqAGwH53lf75nRnIB8u3cnifTu6DY0eqaI7uHQecKyIrgX8CJ4nIP1IqZRtkzsqtXPDQ+9z03Kd0Lyng1jGFPHTFkRlruKJx3mG9qKkPMnXhRr9FaRKJGq96EcnBflclIt0wtcE2TVVNPQvW72DsQV38FsXRemmy7qnqraraW1X7Y5ZUe1tVr0y5pG2ENVt3c8NT87joz7PYuLOWey8ZxUvfOY6hXbJzibcj+3amZ8dC/vtpxnx5lBCJthH/CLyI2RDvV8BFwLNL7WQAABVeSURBVO0pkypLmLNqG0GFsQOya6DTkVU43csQqmrqefCdZTz+/gpyRPjBKYO57oQBWb0+IJhtU84e1ZO/vr+CHbvrs6YXKdHZhk+JyFzgZMxU3fNVdVFKJcsCFq7fCcCoPp18lsTRWmmp7qnqNGBaaqRrGzQGlWc/WsO9U5awpbqOrxzRi5+cPozyjtk1wSEWE0eW88iM5Uz7YhPnHXbAqnsZSaKzDX8JvAs8oaq7UitS9rB0UzU9OhZm1SCnI7twuucv7325hbteXcjiiiqO6t+ZxycdxaG9W19ldVTvTnTtkM9bi1qZ8cJ8LHwZ8EcRqcIo0wxV/U+qBMsGlm2uZlD3Ir/FcLRuVuJ0L+0s21zNr19dxFuLN9GnSzseuuIIJo4sb7XfcQYCwoRh3XlzQQUNjcGM/S7NS6Ldho8Dj4tIOXAJ8CPM9yFp+3g5E1mzdTcjD+kR36HD0Uyc7qWX7bvruH/ql/zjg1UU5uVwy8RhTDo2fSu++8nJw7rzwty1zF21LSvG8RPtNnwMGA5sxNT8LgLmpVCujGd3XQPbdtfTq1M7v0VxtGKc7qWH+sYgf5+1igfe+pKqmnouHdOXm04dkrXbhTSH44d0Iy9HeGvxptZjvICuQA6wHdgKbFHVhpRJlQWs314D4IyXI9U43Ushqspbizbx69cWsXzLLo4fXMrPzjqYYeVtbznIooJcjh7QlbcWbeS2Mw/2W5y4JNpteAGAiBwMnA68IyI5qto7lcJlMuu37wGgpzNejhTidC91LNqwk7teXcj7SysZ0K0Dj08azYSh3VvtuFYijB/anTtfWcjabbvp3TmzP7ZOtNvwbOB44ASgM/A2pgujzbKpqhaA7sVtp1vBkX6c7iWfzVW13DtlCc9+tIaSdnnccc5wrji6H3lZMEkh1Rw3yHQXzlpWycWjW4HxAiYCM4AHVDW7PsNOEZXVxniVOuPlSC1O95JETX0jj7+/gofeWUZNfSOTjj2IG08enDUf5aaDId2L6dIhn1nLK7l4dGav15pot+ENIlIGHCUiRwCzVXVTakXLbCp31VGQG6BDfuufheTwD6d7LUdVeeWzDdz9+mLWbd/DKQeXcduZwxjQzX3mEk4gIBwzoCuzllWiqhndhZpQO1lELsbsWnwxZrruhyJyUSoFy3S2VNdSWlSQ0S/Xkf043WsZn6zZzkV/nsX3nvmY4sJcnv7GWB77+mhnuGJw9MCubNhRw6rK3X6LEpNEuw1vB44K1fjs4qBTgRdSJVims3VXHV2L3ML6jpTjdK8ZrN++h3veWMxLn6yntKiA3154CBcd2YecgKtsxuNYuynlzGWV9C/t4LM00UnUeAXCuioqSXxF+lZJZbUzXo604HSvCeyqbeDh6ct45N3lBBVumDCQb48f5JZwawIDSjvQvbiAWcsruXxsX7/FiUqib/QNEZkMPGPPvwq8lhqRsoNtu+vc0lCOdOB0LwGCQeVf89byu8lL2FRVyzmjevLTM4Zm/HTvTEREOHZgV95bmtnjXolO2PixiHwFGIdZ2foRVX0xpZJlODv31NOxnZul5EgtTvfi8+HySu58dSHz1+3ksD6d+NOVR3Jkv85+i5XVjO7fhZc+Wc/qrbvp1zUzuw7jGi8ROR8YBHyuqjelXqTMJxhUqmobKCl0XRGO1OF0LzarKnfxm9cW88aCCnp2LOSBSw/jnEN7EnDjWi3miL7G+M9bvS07jZeIPASMAGYCd4rIGFW9My2SZTDVdQ2oQolreTlSREt0T0T6AE8C5Zhdlx9R1QdSJmya2VlTz/+9vZQn3l9Jbo5w86lD+MbxA2jnPltJGkPLi+mQn8O8Vdu54PDMXMwlXtPhBGCUqjaKSHvMl/1t3njt3FMP/7+9cw+yorrz+Ocr78eACMhT8BEeEnygiIlJFKIQNuWj2GIju8bS0tXS1WwlxqQ2ujHGlFnzKJ8xETZqTFYBY7RCNKviY3ytKIiKPFVEFMSIUYFxgGGG3/7R5w6X8Q73ztxHd9/5faqmpvt0n77f7tu//t3+nXN+B3deTlkpxvYage+a2VJJNcBLkhaa2cpyia0EjU27mbv4XW5Y+Dof1zcw85jhXP61MQzqUz2TQiaFTvuJow7an6XvfBy3lFbJ57wazKwJwMzqldSWuwqzJeO8urvzcspGu23PzDYBm8LyNkmrgGFAap3X8g+b+OnNz/D63+o4/pAD+OGp4xg/rG/csqqaY0b04zdPraW+oZGeXZPXRJJP0VhJy8KygMPCugAzsyPLqi6hbN0eJfXu0yN5X6hTNZTE9iQdDEwAXsix7UKiucEYOHAgtbW1xasuMZvqdjNvTQOvbm7iwJ7iWxO6ccyBO/jwjZepfSNudXtTV1eXyGuYTVs0dt7SSNNu466/PMXh/ZMXks339C1LXvyQNeDqcPxJZrYka9sPgPOBJuDfzeyRUD4duIloeojfmtl15dBWCFt3+JuXU3aKtj1JvYE/Ad82s60tt5vZHGAOwJgxY2zy5MnFfmTJ2FK/i5ufeIO7/u9tenTpxJljunLN2V+lW+fkPUQz1NbWkqRrmIu2aDzq0wZuXLoQ6z+SyZM/V15h7WCfzsvM1pfpc5cD/wjMzi6UNA6YRdRQPRR4TNLosPlWYCqwAVgsaUFcMfxMm5d3lXfKRbG2J6kLkeO628zuL42q8tPYtJu5L77D9QtfZ8v2XZx53Ai+O200y5c8n2jHVY3069WVQwf0Yun6T+KWkpNY4l5mtgrINfjtDGCeme0E1kl6E5gUtr1pZm+FevPCvrE4r207orBhjXeVdxJIaB+7HVhlZtfHradQnn59Mz95cCVvfFDHFw/tzw9PHce4oR1vUsgkMWFEP2rXfJDIwcpJe/oOAxZlrW8IZQDvtig/PtcBsuP4gwYNalMMutB48PK1DQAsWfQcnWMYU5KG2HqGNGmtIr4EnA28JumVUHaFmSUyM8fazXX89KFVPL76A0b278nss49l2rhBiXtYdkSOGbk/f1q6IZGDlcvmvCQ9RjTOpCVXmtmfW6uWo8zIncvNch0gO44/ceLENsXxC40Hv7BjNV3fWscpX51S8LFLSRpi6xnSpLVaMLNnyW1LiWJL/S5uevwNfv981K51xdfHcs4JB3t4MEEcNXx/AF7buCVdzkvSa+R2Enl7PJnZKe3QswHIngFtOJCZgK+18opTv7ORnt3cwJzyUYztJZ3W2rUG9PaJXZPG6EE1dOkklm/cyqlHDo1bzl7ke/M6tSIq9rAAuEfS9UQdNkYRzWUkYJSkQ4CNRJ06/qXC2pqp29lErwSOe3CqikrbXkXwdq100bXzfowZXMPyjVvilvIZYultKGkGcAswEHhI0itm9jUzWyHpXqKOGI3AJZmBmpIuBR4h6ip/h5mtKIe2QqhvaKSXv3k5ZaSMPX1jwdu10sv4oX15eMX7ieu0kS9suI09oYuMamNP6KJdP5lCVuycmbHN7Frg2hzlfyUhU0F82tCUyBHnTvVQLturNN6ulX7GD+vLvMXvsvGT7YmaYibfm1dNpYSkifqd/ubllJe02563a1UPmTRcyzduSY/zykbSl4FRZnanpAFAjZmtK5+05FK3s5EDeiXnS3Sqm7TZnrdrVRdjB9fQab+o08b08UPiltNMQc5L0o+AicAY4E6gK/A/RONJOhz1DU308mnFnQqQJttr2a415+xjmertWqmne5dOjDqwN8vfS1anjUKfwDOIknsuBTCz98JUCx2SKMuyhw2dipB42/N2repn/LC+zZk2kkKhzqvBzEySAUhK1mi1CvPpTn/zcipGYm2vsWk394R2ra3bdzFr0ggum+rtWtXIEcP6ct9LG3h/6464pTRT6BP4Xkmzgf0lXQCcB/x3+WQll6bdxvZdPs7LqRiJtL2W7VpXnTaOw4d4u1a18vnQZrlq02cmJ4iNgp7AZvZLSVOBrUSx96vMbGFZlSWU+oYoKa/3NnQqQdJsb+3mOq59aBVPeLtWh2L04ChSvWrTtpiV7CHfOK/PAYPM7LlgMAtD+YmSDjOztZUQmSTqG5oA6OFtXk4ZSZrtebtWx6ZP9y4M79eD1e+nxHkBNwJX5CivD9tOK7mihLM9OC/vsOGUmUTYnrdrORnGDu7D6hSFDQ82s2UtC81sSZhevMOxfVd48+rizsspK7HbnrdrOdkcPqSGJ9d8ELeMZvI5r+772NajlELSQsZ5dXPn5ZSX2GzP27WcXIwd3Iem3enpKr9Y0gVmtlfvJknnAy+VT1Zy2eFvXk5lKMr2JE0HbiJKZP1bM7suXx1v13L2xdghiRpemNd5fRt4QNJZ7DGYiUSj/GeUU1hSyTiv7u68nPLSbtuT1Am4FZhKNEfeYkkLzGxla3W2Nhgn/fJJb9dyWuXg/r3o1jnXvMDxkC8x79+AEyRNAcaH4ofM7ImyK0so2xt2A9C9S3K+RKf6KNL2JgFvmtlbAJLmAWcQTTWUk492GJMH9/F2LadVOu0nxgyu4fW4hQSUpHQfpUbSZqAt8yINAD4sk5xSkhadkC6tY9KezR1A0kxgupn9a1g/GzjezC5tsd+FwIVhdTywvKJC20Ya7qOOonGkmQ0shZhiqOo0EW29wJKWmNnEcukpFWnRCenTGreGEpGrZ8VnfqWa2RxgDiT/e0q6PnCNlcZjX45TfWwADspaHw68F5MWxykL7rwcp/pYDIySdIikrsAsYEHMmhynpFR12LAdzIlbQIGkRSe41opjZo2SLgUeIeoqf4eZrchTLennnnR94BorSlV32HAcx3GqEw8bOo7jOKnDnZfjOI6TOtx5tUDStyStkbRC0s/j1pMPSZdLMkkD4tbSGpJ+IWm1pGWSHpC0f9yaspE0PXznb0r6j7j1lJN85yqpm6T5YfsLlU7AXYC+yyStDPfS45JGVlJfIRqz9psZbLOiXdML0SfpG+E6rpB0TyX1lQwz87/wB0wBHgO6hfUD49aUR+9BRI3y64EBcevZh85pQOew/DPgZ3FrytLWCVgLHEqUeulVYFzcuuI6V+DfgNvC8ixgfsL0TQF6huWLK6mvLfcLUAM8DSwCJiZJHzAKeBnoF9YT/Zxr7c/fvPbmYuA6M9sJYGbJyf+fmxuA75NjAGqSMLNHzawxrC4iGneUFJpTKZlZA5BJpVSNFHKuZwB3heX7gJNVuXTyefWZ2ZNmVh9W47iXCr1ffgL8HNhRSXEUpu8C4FYz+xhS8ZzLiTuvvRkNfCWES56SdFzcglpD0unARjN7NW4tbeQ84H/jFpHFMODdrPUNoawaKeRcm/cJPzi2AP0roq7t38X5VP5eyqtR0gTgIDN7sJLCAoVcw9HAaEnPSVoUZiBIHR1unJekx4DBOTZdSXQ9+gFfAI4D7pV0qIV360qTR+sVROG4RLAvrWb257DPlUAjcHclteWhoFRKVUIh5xrn9Sj4syV9kyjL/kllVZTjo3OUNWuUtB9RROTcSglqQSHXsDNR6HAy0ZvrM5LGm9knZdZWUjqc8zKzU1rbJuli4P7grF6UtJsokeXmSunLpjWtko4ADgFeDRGd4cBSSZPM7P0KSmxmX9cVQNI5wKnAyXH9GGiFjpRKqZBzzeyzQVJnoC/wUWXkFfZdSDqF6AfcSZkQfwXJp7GGKMlxbbDNwcACSaebWSVyZxb6HS8ys13AOklriJzZ4groKx1xN7ol6Q+4CLgmLI8mev1W3LoK0P02ye6wMZ1oOo6BcWvJoa0z8BbRj4FMA/fn49YV17kCl7B3h417E6ZvAlGHhFFJvYYt9q+lsh02CrmG04G7wvKA8JzrH9d92d6/DvfmlYc7gDskLQcagHMsfMNOUfwK6AYsDL9GF5nZRfFKirD2pVJKJa2dq6RrgCVmtgC4HfiDpDeJ3rhmJUzfL4DewB/DvfSOmZ2eMI2xUaC+R4BpklYCTcD3zOzv8aluH54eynEcx0kd3tvQcRzHSR3uvBzHcZzU4c7LcRzHSR3uvBzHcZzU4c7LcRzHSR3uvEqApMGS5klaGzI1/1XS6Dx16sL/g0PX/Jbb10ka06LsRknf38cxJ0t6MGv5hPadUduRdK6kuS3KBkjaLKlbi/LakPX69Hz1JN0t6SNJMytxHk75cDtxOykl7ryKJCQtfQCoNbPDzGwcUeqmQUUeeh5ZY2xC2pmZwPwC608GKmaUwP3AVEk9s8pmAgssdxaEs8KYk33WM7OzgFjHzjjF43bSjNtJiXDnVTxTgF1mdlumwMxeMbNnACR9T9JiRfMP/bgNx53L3gNETwTeNrP1krpLulPSa5JeljQlu6KiOZguAr4j6RVJX5F0mqKEwy9LekzSoLDvQEkLJS2VNFvSeoW5wSR9U9KL4RizJXVqTayZbSWaAuK0rOJZ4Txapb31nNThdoLbSSlx51U844GXcm2QNI0oZ9gk4GjgWEknFnJQM1sG7JZ0VCjKvlEvCfscAfwzcJek7ll13wZuA24ws6PDA+JZ4AtmNoHo12omrPIj4AkzO4bol/GIoP1w4EzgS2Z2NNFI/LPyyG5+kEgaSpRi68kCTre99Zz04HayB7eTEuDpocrLtPD3cljvTWSkTxdYfy4wS9IKojl5rgrlXwZuATCz1ZLWE93I+2I4MF/SEKKcZ+uyjjUjHOthSR+H8pOBY4HFUcSHHkC+eX8eBH4tqQ/wDeA+M2sq4DzbW8+pDtxO3E7ajDuv4llBFHvOhYD/MrPZ7Tz2XOBR4Clgme2ZNK49kwPeAlxvZgskTQauznMsESXv/EGhH2Bm2yU9TGTks4DvlLOekyrcTgJuJ6XBw4bF8wTQTdIFmQJJx0k6iSgB5nmSeofyYZIOLPTAZrYW+DtwHXvHtp8mhCYU9dYaAaxpUX0b0fQMGfoCG8PyOVnlzxL9isuEb/qF8seBmRm9kg6QNDIs/17SpFZkzwUuI2qIX1TQiRZXz0kHbid743ZSJO68iiRknZ9B1BNobQhdXA28Z2aPAvcAz0t6jWha9ZpWD5abucBYojh7hl8DncIx5wPn5uip9BdgRqYhOmj6o6RngA+z9vsxUYbppcA/AJuAbWa2EvhP4FFJy4CFwJBQ58iwXy4eBYYC89uYkb+99ZwU4HbyGdxOisSzyndwFI0taQpTKXwR+E1oeG5t/z7A7Wb2T0V8Zi1wuRU4OZ+k3wEPmtl97f1MxykGt5Pk4W9ezgiixuZXgZuBC/a1s5ltLcYgAx8Bv5OUdx4mSXcTTfW+o8jPdJxicDtJGP7m5TiO46QOf/NyHMdxUoc7L8dxHCd1uPNyHMdxUoc7L8dxHCd1uPNyHMdxUsf/AwCo9KJqmUBnAAAAAElFTkSuQmCC\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -83,7 +83,7 @@ "source": [ "pv_cells[0].plot()\n", "\n", - "print(pv_mod.pvcells[0])" + "print(pv_mod.pvcells[0].diode_model)" ] }, { From 1355411144067fb7fd4d8782309d997907b3d549 Mon Sep 17 00:00:00 2001 From: Cliff Hansen Date: Mon, 6 Jan 2020 14:54:33 -0700 Subject: [PATCH 10/16] update notebook --- notebooks/basic_iv_curves.ipynb | 236 ++++++++++++++++++++++++++++---- 1 file changed, 207 insertions(+), 29 deletions(-) diff --git a/notebooks/basic_iv_curves.ipynb b/notebooks/basic_iv_curves.ipynb index f690664..ec699fe 100644 --- a/notebooks/basic_iv_curves.ipynb +++ b/notebooks/basic_iv_curves.ipynb @@ -2,13 +2,13 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "# add capability to import from parent directory\n", "import sys, os\n", - "sys.path.insert(1, os.path.join(sys.path[0], '..'))\n", + "sys.path.insert(1, os.path.join(os.path.abspath('.'), '..'))\n", "\n", "import pvmismatch as pvm\n", "import numpy as np\n", @@ -18,13 +18,11 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 68, "metadata": {}, "outputs": [], "source": [ "# Setting PV system layout cell and module parameters\n", - "str_len = 6 # number of modules in a string\n", - "str_num = 3 # number of (parallel connected) strings in the array\n", "v_bypass = np.float64(-0.5) # [V] trigger voltage of bypass diode\n", "cell_area = np.float64(246.49) # [cm^2] cell area\n", "Isc0_T0 = 9.68 # [A] reference short circuit current\n", @@ -40,13 +38,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ "pv_cells = pv_mod.pvcells\n", "for c in pv_cells:\n", - " c.update(diode_model = '2diode', Isc0_T0 = Isc0_T0) # updating short circuit currents\n", + " c.update(diode_model = 'desoto', aRBD=0.0, bRBD=0.0, Isc0_T0 = Isc0_T0) # updating short circuit currents\n", "\n", "pv_mod.setSuns(cells=list(range(0, len(pv_cells))), Ee=[1]*len(pv_cells))\n", "\n", @@ -59,93 +57,273 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2diode\n" + "\n", + "(9.684125625749223, 2.28618816125344e-11, 0.004267236774264931, 10.01226369025448, 0.025692570400413114)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ "pv_cells[0].plot()\n", "\n", - "print(pv_mod.pvcells[0].diode_model)" + "print(pv_mod.pvcells[0])\n", + "\n", + "(photocurrent, saturation_current, resistance_series, resistance_shunt, nNsVth) = pv_mod.pvcells[0].Igen, \\\n", + " pv_mod.pvcells[0].Isat1, pv_mod.pvcells[0].Rs, pv_mod.pvcells[0].Rsh, pv_mod.pvcells[0].N1 * pv_mod.pvcells[0].Vt\n", + "print((photocurrent, saturation_current, resistance_series, resistance_shunt, nNsVth))\n", + "\n", + "(V_pvm, I_pvm) = pv_mod.pvcells[0].Vcell, pv_mod.pvcells[0].Icell\n", + "I_pvm = I_pvm[(V_pvm>=0) & (V_pvm<=pv_mod.pvcells[0].Voc)]\n", + "V_pvm = V_pvm[(V_pvm>=0) & (V_pvm<=pv_mod.pvcells[0].Voc)]\n", + "\n", + "plt.figure()\n", + "plt.plot(V_pvm, I_pvm)\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 48, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", "text/plain": [ - "" + "[]" ] }, - "execution_count": 8, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ - "pv_mod.plotMod()" + "import pvlib\n", + "\n", + "v_pvl = V_pvm\n", + "i_pvl_brentq = pvlib.pvsystem.i_from_v(resistance_shunt, resistance_series, nNsVth, V_pvm, saturation_current, photocurrent,\n", + " method='brentq')\n", + "i_pvl_newton = pvlib.pvsystem.i_from_v(resistance_shunt, resistance_series, nNsVth, V_pvm, saturation_current, photocurrent,\n", + " method='newton')\n", + "i_pvl_lambertw = pvlib.pvsystem.i_from_v(resistance_shunt, resistance_series, nNsVth, V_pvm, saturation_current, photocurrent,\n", + " method='lambertw')\n", + "\n", + "plt.plot(v_pvl, i_pvl_brentq)\n", + "plt.plot(v_pvl, i_pvl_lambertw)\n", + "plt.plot(v_pvl, i_pvl_newton)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 49, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.763860724146582e-10\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "execution_count": 9, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(v_pvl, np.abs(i_pvl_brentq - I_pvm))\n", + "plt.plot(v_pvl, np.abs(i_pvl_newton - I_pvm))\n", + "plt.plot(v_pvl, np.abs(i_pvl_lambertw - I_pvm))\n", + "print(np.max(np.abs(i_pvl_lambertw - i_pvl_brentq)))" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 46, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzs3Xl8VNX5+PHPk4QthD0LCGEJSwBRFgVREYKA+76idV+ofrXWurRq/dlaW7W1rrXauoI7uNWl1ZbFILIoogFRCDsEBULYwxqS5/fHuQOTfUhmcmeS5/16ndedc+cuzxyGObnnnnuOqCrGGGNMtInzOwBjjDGmIlZBGWOMiUpWQRljjIlKVkEZY4yJSlZBGWOMiUpWQRljjIlKVkEZEwVEJFtErvM7jnAQkXtE5IUa7lsoIhnhjsnEJqugTNiJyDARmSUi20Rks4jMFJHBtTzmKhEZHa4YqzlXVxFREUmo4L2OIrJfRLpX8N77IvLXSo7ZWER+LyJLRWSn93leEpGu4f8ENSci40Xkj7U5hqo+qKrVVrYVVcqqmqSqK2pzflN/WAVlwkpEWgIfA38D2gIdgfuBvX7GFS6q+iMwFbg8eL2ItAVOAyZUsus7wFnApUAroD8wDxgV7hhFJD7cxzyEc5er1I2pMVW1ZClsCTga2FrJe02AzcARQetSgd1ACpCMq9y2etvNwP0R9SpQ4m1XCPza23coMMvbfj6QFXTcbOCP3vuFwEdAO+B1YDswF+haSZxdAQUSKnn/UmB5mXX/B3xTyfajvdjTqyi3bOABYCawA/gfkBz0/tvAemAb8DlweNB744Fngf8AO73znQ58633WPOD3Zc43LKjs8oCrgHFAEbAvUGbetocB7wIbgZXALUHH+T2u8n3NO9d13rrXvPebeu9t8s41F0gD/gQUA3u8cz3tba9AD+91M+BRYLX3ub/w1lV4TL+/+5bCn3wPwFL9SkBL74djAnAq0KbM+88Afw7K/zLoh/Ah4B9AIy+dAIj33ipgdNB+Hb3znIarxMZ4+RTv/WxgGdAdd8XyA7DE+/FOAF4BXq7kM3Sl6gqqmfeDOSxo3Wzg1kq2fxiYXk25ZQPLgV7e8bOBh4PevwZogavknwBygt4b78VzvFcWTYEs4AgvfySwATjH274zrhK8xCvndsCAoGP9MejYcbgrvfuAxkAGsAI42Xv/97hK7Rxv22aUrqB+jvvjIBGIB44CWgZ95uvKlENwBfV3b5uO3r7HeZ+/0mNaql/JmvhMWKnqdtxf5wo8D2wUkQ9FJM3bZAJwqYgEvnuX466QwP3QdQC6qGqRqs5Q75eqApcB/1HV/6hqiapOBr7GVVgBL6vqclXdBnyCu+qZoqr7cVckA2v4GXd7+18BICI9cT+Sb1SySztgXQiHfllVl3jHnwQMCDrnS6q6Q1X34iqA/iLSKmjfD1R1plcWe1Q1W1W/8/ILgDeBEd62PwOmqOqbXjlvUtWcSmIajKv0/6Cq+9TdH3oeGBu0zWxV/Zd3rt1l9i/yPn8PVS1W1Xned6RK3vfjGuCXqvqjt+8s7/PX6Jgm9lgFZcJOVRep6lWq2gnoh2siesJ770tcM9QIEekN9AA+9HZ9BHfV8z8RWSEid1Vxmi7AhSKyNZBwFWOHoG02BL3eXUE+qbrPIiKdvZ5lhSJSGPTWBOAiEWmKq2Q/VdX8Sg6zqUxclVkf9HpXID4RiReRh0VkuYhsx11NgmsSDcgrE/cxIvKZiGwUkW3ADUHbp+Ou1kLRBTisTDnfg2umq/DcZbwK/Bd4S0R+EpG/iEijEM6bjLsSrCjOmh7TxBiroExEqepiXLNRv6DVE3BXQJcD76jqHm/bHap6u6pmAGcCt4lIoBNB2SupPOBVVW0dlJqr6sNhjn+Nup5lSaqaFLR+Bq7iOdv7LK9UcZgpwBAR6VTDMC71zjMa11zZ1VsvwaGW2ecNXMWfrqqtcE2nge3zcE2fFamonFeWKecWqnpaFfscfMNdod2vqn1xTXRn4F15VrUfUIC7P1UuzmqOaeoRq6BMWIlIbxG5PfBjLCLpuHsdc4I2exU4lzI/7CJyhoj0EBHB3XAv9hK4q5/g52NeA84UkZO9K4ymIpJVi0qgJl4B/gy0xt0TqZCqTgEmA++LyFEikiAiLUTkBhG5JoTztMD1gtyEu+/yYIj7bFbVPSIyBFfJBbwOjBaRi7xY2olIoDmxbDl/BWwXkd+ISDOvrPuF+tiAiIwUkSO8noXbcc1zlf2bHqCqJcBLwGMicph33mNFpEk1xzT1SKUVlIgMCiEdUZfBmpiwAzgG+FJEduIqpoXA7YENVHUt8A3uL+gZQfv2xF1tFOI6HTyjqtneew8B93rNTHeoah7uquIeXO+yPOBO6vaPrldwHQ4mevdGqnIBrpfdRFyHhoW4Ho9TQjzPauBHXGePOVVvDrhehX8QkR24Dg6TAm+o6hrcvbrbcb0lc3Dd3gFeBPp65fwvVS3GXc0OwPXgKwBewF3JhaI9rpffdmARMB33xwXAk8AFIrJFRJ6qYN87gO9wvfQ24/4YiKvmmKYeCfSQKv+G+2LPpXQzQlndVLVrBOIy9ZyIvAT8pKr3+h2LMSY6VfVQ3VxVPbGqnUVkWpjjMQ2AN3rCedSwF50xpmGotDmkusop1G2MCSYiD+Catx5R1ZV+x2OMiV6VNvFVuLEbf+wSYKyq9qtue2OMMaamqr2hLCIdRORWEfkK+B735PYlEY/MGGNMg1ZVJ4nrcRVRJ1wPoEm4p9W71V14TuvWrbVHjx51fdqotnPnTpo3b+53GFHDyqM8K5PySpXJxo1umZLiX0A+8+s7Mm/evAJVrbbgq+ok8XdcV99LVfVrABEJvT0wjNLS0vj666/9OHXUys7OJisry+8wooaVR3lWJuVZmZTmV3mIyOpQtquqgjoMuBD3oFwa7grKhhMxxhhTJ6rqxVegqs+q6nDcnDXbgHwRWSQi1T7J7j3Z/5WIzBeR70Xkfm99NxH5UtzEbRNFpHHYPo0xxoRq9GiXTNQK6al7VV2rqn9V1aNww+qHMvncXuBEVe2Pewr9FBEZinsa/HFV7QlsAa6tWejGGFMLF1/skolaVQ51VNF6Vc1V1fur2sbbTlU1MPpzYH4fBU7EDVMCbtDQc2oQtzHG1M7117tkolZVvfjm4yY9q2qoo6mqWuloAN5gjvNwUyr8HTedwhxV7eG9nw58UtEzVSIyDjfDJykpKUdNmjSp7CYNWmFhIUlJ1c4W0WBYeZRnZVKelUlpfpXHyJEj56nq0dVtV1UniVa4yqWqCmpjVQf3BpocICKtgfeBPhVtVsm+zwHPAXTM6KUFLVw380AwIqWX7j0pt87lJWibMvtXsE/ZbYKL4OB+pY8dfMqysQXOQYXnkDL5yj9P8Dny5s+nf59+VW5z4NjlYiZ4q+r3L/u5KiozKb0+eNvgYweXaen1Um6b4H1LnV+kVEyCMHv2LPoMGkrQ4Ss4d8XnOPDPI8Gftfw5qv3Mle1b9gtZR6zHWnmlyiSwzM72KRr/Rft3pNIKKpyDwKrqVhHJBoYCrUUkwZvVtBPwU3X7F+xW7nh7frjCqT/mful3BNEle6rfEVTrkCrMMusr25eK1gvsLyqi8YzJB9bHx0G8iPfapTiBOAm89pbe+nhxr+O99SK4/SRom6D9Dh774PpG8XE0aRRHk/g4Gie41CQh3r321iU2jqd5kwSaN06geZN4kpok0LxJAomN4yNbuV91VeSObcKiqiuoWhGRFKDIq5ya4SZb+zPwGW7qgbeAK4EPqjtWp6Q4sn89kkBrpHoXXcGtk4GXgSbLg/ngI5Xer6Jtyh67qvcOrK9q/zJxVXzeqj5Pxfvn5OTQv/+AUuekqv0PocyCM5WVh5bZL/izlN7m4HEq2rdsjMHnCY4vuKiCYwqsz83NpWevXqXXVxBf8LHKnoNS68ufo+x6gvYN5TNXGE8V5UWp9aHFE/xvsvbHH+l4WAdKVClRKClRSlQpVqWkRCkOXldqyYHXxSXK/pIS9hVTapviEhf3wWO590pK3HaB9fuKS9i3v4S9+0s4VCIcqLSaN0mgTWJj2jZvTLvmbtm2eWPaJTUmtUVTDmvdjA6tmtK0UXzoJ7AKKupFrILCTXE9wbsPFQdMUtWPReQH3FTNfwS+xc0/U3WQcZDeNjGCocaePWviObZ7O7/DiBrZu1aQdUwXv8OIKtnZBWRlRceQmapKUfHBCiuQ9u4vZndRMYV797NzbzE79+73Xu/3Xh9ct2XXPvI27yInbytbdu5jf0n5uwPJSU3o2Lopndom0iMliV5pLeiVlkTX5OY0ii/TJ6yoyC0b2eOd0SpiFZSqLqCC6RRUdQUwJFLnNcZEHxGhcYLQOCEOmtT+eKrK9t372bRzLxu27+Wnrbv5aetufvTSwh+38Z/v1h24smwUL2QkJ5GasJd1iWsY1LkNvcae6VpHG/A9qGhX4xl16zLIxLw8GD/eZYqK3M3N17wJNHftcvmJE11+2zaXf+89ly8ocPmPvBm51693+U8/dfm8PJef4k1sumKFy0+f7vK5uS4/a5bLL1zo8nPnunxOjsvn5Lj83Lkuv3Chy8+a5fK5uS4/fbrLr1jh8lOmuHxenst/+qnLr1/v8h995PIFBS7/3nuQlUV8odeDf+JE9/6uXS7/2msuH/jrcPz4gzeDAZ5/vvTDic88A6eeejD/5JNw1lkH83/9K5x//sH8ww/D2LEH8w88AJdddjB/331w9dUH83ffDePGHczfcQfcdNPB/K23uhRw001um4Bx49wxAq6+2p0j4LLLXAwBY8e6GAPOP999hoCzznKfMeDUU10ZBIwe7cooICsrZr97LQPbh/m7x7ZtLu/jd09EaPXow2T86gaO7d6O84/qxC+mv8rDHz/Oq9cew/Q7R7K0+HO+yXubxy/uz3UnZPCr//6T0yb8jbvf+46Tn/icWWsL+X7TXt78ag0/bd3dIL97bebNc/m6/t0LUVVXUI9W8V7geSZjjIlKCfFxtG3emHMHdnIrpnRg7bKdfHZHFt+s3oIu7M3CLbu5+73vAHh6wU90Oqwd7TbvslsKUeKQ5oPyS2ZmpuYGamIDRH/30Lpm5VGelUl5pcpk1y5UlWWFJWTnbuQ/C9fx7ZqtAAzu2obLhnbhlH7taZJwCB0vYoyPg8XW+jkoY4ypv047DQF6ZmfTM60F1w/PIG/zLj5a8BOT5ubxy7dySE5qzNjBnblmWDfaNrdhQ+uaVVDGmIbpxhvLrUpvm8j/ZfXghuHd+WJZAa/MXs3fs5fx0syVXH5sF8adkEG7pDD08jAhsQrKGNMwVTFQbFycMLxXCsN7pbB0ww7+Nm0Zz32+gldnr+amkT24dli3Q3vmytRISKOZB/OmgLc/IYwxsW3btoM9EqvQM60FT10ykMm/GsGwHsk88t9cTnr8c6Yt3lAHQTZsh1xBAa8Ci0Xkr9VuaYwx0erss10KUY/UJJ674mheu/YYmiTEcc34r7l90ny27S6KYJAN2yE38anqaHEDZPWNQDzGGFM3brmlRrsN65nMv285gaenLeXv2cuZuayAv17Yn2E9k8McoKn2CkpEXq1g9Suq+n0E4jHGmLpx3nku1UDjhDhuOymT9//vOFo0TeDyl77kySlLKalg+CVTc6E08R0enBGRBOCoyIRjjDF1pKDg4CgZNXRkp9Z8cPPxnDugI49PWcLV4+eyfY81+YVLVUMd3S0iO4AjRWS7l3YAGwhhBHJjjIlqF1zgUi0lNk7g0Yv686dz+zFzWQEXPDuLtVt2hSFAU2kFpaoPqWoL4BFVbemlFqraTlXvrmw/Y4yJCbff7lIYiAg/O6YLr1wzhHXb9nDO32fx3drqewiaqlXbxKeqd4tIRxE5TkSGB1JdBGeMMRFz5pkuhdFxPZJ578bjaJIQx6XPz2He6s1hPX5DE0oniYeBmcC9wJ1euqPKnYwxJtqtX39w5PYw6pnWgnduPJbkFk24/MWvmLNiU9jP0VCE0kniXCBTVU9T1TO9dFa1exljTDQbO7b01DFh1KFVMyaOG0rH1s246uWvmLW8dp0xGqpQKqgVgE05aYypX+66y6UISW3ZlDfHDaVz20TGvTKPhT/aPalDFUoFtQvIEZF/ishTgRTpwIwxJqJOOcWlCEpOasIr1xxDq2aNuPKlr1hZsDOi56tvQqmgPgQeAGYB84JSlUQkXUQ+E5FFIvK9iPzSW99WRCaLyFJv2aY2H8AYY2okL+/gbMIR1L5VU165dggKXP7il+Rv3xPxc9YXofTimwBMAuao6oRACuHY+4HbVbUPMBS4SUT6AncBU1W1JzDVyxtjTN26/HKX6kD3lCTGXz2YzTv3cf2r89hTVFwn5411ofTiOxPIAT718gNE5MPq9lPVdar6jfd6B7AI6AicDQQquAnAOTUL3RhjauHee12qI0d2as1jF/Vnft5Wfvv+QmJhNnO/VTvlu4jMA04EslV1oLfuO1U9IuSTiHQFPgf6AWtUtXXQe1tUtVwzn4iMA8YBpKSkHDVp0qRQT9cgFBYWkpSU5HcYUcPKozwrk/KioUzeX7qPD5YXcUnvxpzc1d/+Z36Vx8iRI8M25ft+Vd3mBjA/IOSqX0SSgHeBW1V1e5njVEpVnwOeA8jMzNSsrKxQT9kgZGdnY2VykJVHeVYm5ZUqkxUr3DIjo05jGD5c2fP6PCb+sIHTjx/o6yjo0f4dCaWTxEIRuRSIF5GeIvI3XIeJaolII1zl9Lqqvuet3iAiHbz3OwD5NYjbGGNq55prXKpjcXHCYxcNoEdqErdO/Jb8HdZpojKhVFC/wI1ovhd4A9gG3FrdTt6cUS8Ci1T1saC3PgSu9F5fiQ08a4zxw/33u+SD5k0S+Pulgyjcu5/bJ823aToqUWUFJSLxwP2q+ltVHeyle1U1lCr/eOBy4EQRyfHSacDDwBgRWQqM8fLGGFO3RoxwySc901pw3xmHM2NpAc/PWOFbHNGsyntQqlosIjWa+0lVvwAqu+E0qibHNMaYsMnNdcvMTN9CuGRIOl8s28gj/81laEY7+qe3rn6nBiSUJr5vReRDEblcRM4LpIhHZowxkfTzn7vkIxHhoXOPJK1lU37x5rfs3Lvf13iiTSgVVFtgE66r+ZleOiOSQRljTMQ9+KBLPmuV2Ignxg4gb8su/vzpYr/DiSpVNvF596AWqOrjdRSPMcbUjeOO8zuCAwZ3bcs1x3fjxS9Wckq/9hzX3b+u59GkyisoVS0GbGoNY0z9s3ChS1HijpMy6ZbcnN+8u8Ca+jyhNPHNEpGnReQEERkUSBGPzBhjIunmm12KEs0ax/PIBUeydstuHv3fEr/DiQqhjCQRuA7+Q9A6xd2TMsaY2PTII35HUM7RXdvys2M6M37WSs4/qiOHH9bK75B8VW0Fpaoj6yIQY4ypU4MH+x1Bhe48qTefLlzPvf9ayLs3HEdcXGjDw9VH1VZQInJfRetV9Q8VrTfGmJiQk+OWAwb4G0cZrRIbcc9pfbht0nwmfp3HJUM6+x2Sb0K5B7UzKBUDpwJdIxiTMcZE3q23uhSFzh3YkWO6teXhTxazqXCv3+H4JpQmvkeD8yLyV9x4esYYE7ueeMLvCColIvzxnH6c+uQMHv5kMY9c2N/vkHwRyhVUWYlA3Y5Pb4wx4TZgQNQ17wXrmdaC607I4O15a/l61Wa/w/FFKDPqficiC7z0PZALPBn50IwxJoLmznUpit0yqgftWzblgY9/aJAjnofSzTx4WKP9wAZVtafIjDGx7c473TI729cwqpLYOIE7T87k9rfn88H8Hzl3YCe/Q6pTlVZQIjIYSFbVT8qsP1NEflLVeRGPzhhjIuXpp/2OICTnDuzI+Fmr+MunuZxyeAeaNY73O6Q6U1UT3yPAogrWL/LeM8aY2NWvn0tRLi5O+H9n9GXdtj280MDmjaqqgmqnqqvKrlTVZUC7iEVkjDF1YdYsl2LAkG5tObVfe56dvrxBTRFfVQXVrIr3moc7EGOMqVP33ONSjPjNKb3Zt7+Ep6ct8zuUOlNVBTVFRP4kIqXG2RCR+4FpkQ3LGGMi7J//dClGdE1uzsWD03njyzWs2bTL73DqRFUV1O24552Wici7XloGZAK31Ul0xhgTKZmZvk73XhO3jOpJQrzw+JSGMdp5pRWUqu5U1UuAMcB4L52kqmNVtbC6A4vISyKSLyILg9a1FZHJIrLUW7ap/UcwxpgamD7dpRiS1rIpVx3XjX/l/Miiddv9Difiqn1QV1VXqOpHXjqULiTjgVPKrLsLmKqqPYGpXt4YY+re737nUoy5cUR3WjRJ4JH/5vodSsTVZKijkKjq50DZ8TnOBiZ4rycA50Tq/MYYU6WXXnIpxrRKbMTPR3Rn2uJ8vl2zxe9wIkpUIzd8hoh0BT5W1X5efquqtg56f4uqVtjMJyLjgHEAKSkpR02aNCliccaiwsJCkpKS/A4jalh5lGdlUl59KZPd+5U7p++iW6t4bj+6aY2P41d5jBw5cp6qHl3ddqEMdYR3ryg9eHtV/abm4VVPVZ8DngPIzMzUrKysSJ4u5mRnZ2NlcpCVR3lWJuWVKpMpU9xy9Gjf4qmNVQnL+fOni2mZ0Z9BnWt2Oz/avyOhDBb7ALAAeAp41Et/reH5NohIB++4HYD8Gh7HGGNq549/dClGXXFsF9o2b8wTU5b6HUrEhHIFdRHQXVX3heF8HwJXAg97yw/CcExjjDl0r77qdwS10rxJAuOGZ/DwJ4uZt3oLR3Wpf52iQ+kksRBoXe1WZYjIm8BsIFNE1orItbiKaYyILMV1X3/4UI9rjDFhkZ7uUgy7fGjgKqp+PhcVyhXUQ8C33vNMB+YeVtWzqtrJe4aqIqNCD88YYyLk00/d8pSyT8PEjuCrqJy8rQxIP+RriagWSgU1Afgz8B1QEtlwjDGmjjzsNeDEcAUFcNnQLjzz2TKe+WwZz11Rbce4mBJKBVWgqk9FPBJjjKlLb73ldwRhkdQkgauO68pT05axdMMOeqa18DuksAnlHtQ8EXlIRI4VkUGBFPHIjDEmktq3d6keuOr4bjRrFM+z2cv9DiWsQrmCGugthwatU+DE8IdjjDF15KOP3PLMM/2NIwzaNm/MJUM6M2H2Kn41phfpbRP9DiksQhmLb2QFySonY0xse/RRl+qJ64d3I07guc/rz6y7oTyomyYiL4rIJ16+r9dl3BhjYtc777hUT3Ro1YzzBnZi4td5bNyxt/odYkAo96DGA/8FDvPyS4BbIxWQMcbUieRkl+qRn4/IoKi4hFdnr/I7lLAIpYJKVtVJeF3MVXU/UBzRqIwxJtLee8+leiQjJYnRfdJ4Zc5qdu+L/Z/pUCqonSLSDtcxAhEZCmyLaFTGGBNpTz3lUj0zbngGW3cV8c68PL9DqbVQevHdhhtDr7uIzARSgAsjGpUxxkTaB/VzKNCju7Shf3prXvxiJZce04X4OPE7pBoL5Qrqe2AEcBzwc+BwYHEkgzLGmIhr1cqlekZEGHdCBqs27WLyDxv8DqdWQqmgZqvqflX9XlUXqmoRbhBYY4yJXRMnulQPnXx4Gultm/HCjNjucl5pBSUi7UXkKKCZiAwMGkUiC6gfT4EZYxquZ591qR5KiI/jmuO78fXqLXwTw9PCV3UP6mTgKqATbpLCQEPmDuCeyIZljDER9p//+B1BRF10dDqPT17Ci1+sZNClsTlXVKUVlKpOACaIyPmq+m4dxmSMMZGXWL8bgpo3SWDskM68+MVK1m3bTYdWzfwO6ZCFcg+qk4i0FOcFEflGRE6KeGTGGBNJr73mUj12+dAuqCqvzl7tdyg1EkoFdY2qbgdOAlKBq7GZcI0xse6FF1yqx9LbJjKmbxpvfrWGPUWx9+BuKBVU4N7TacDLqjo/aJ0xxsSmyZNdqueuOq4bW3YV8WHOT36HcshCnQ/qf7gK6r8i0oJazqwrIqeISK6ILBORu2pzLGOMqZFGjVyq54ZmtKV3+xa8NHMlqup3OIcklArqWuAuYLCq7gIa45r5akRE4oG/A6cCfYFLRKRvTY9njDE1Mn68S/WciHD18V1ZvH4HX67c7Hc4hySUCmoS0AHYDqCqm1R1QS3OOQRYpqorVHUf8BZwdi2OZ4wxh66BVFAAZw/oSJvERrw8c6XfoRySUMbi+wfuiukpEXkbGK+qtRnqqCMQPIrhWuCYshuJyDhgnJfdKyILa3HO+igZKPA7iChi5VGelUl55ctEGs4t9RzguStKrfLrO9IllI2qraBUdQowRURaAZcAk0UkD3geeM0b+uhQVPRtKNcwqqrPAc8BiMjXqnr0IZ6nXrMyKc3Kozwrk/KsTEqL9vIIpYkPb7qNq4DrgG+BJ4FBQE26wKwF0oPynYDY615ijDEmoqq9ghKR94DewKvAmaq6zntrooh8XYNzzgV6ikg34EdgLHBpDY5jjDGmHgvlHtTTqjqtojdqcmmoqvtF5GbcNPLxwEuq+n01uz13qOdpAKxMSrPyKM/KpDwrk9Kiujyksn7xIjIYyFPV9V7+CuB8YDXwe1WNrf6KxhhjYkpV96D+CewDEJHhuOGNXsFN9x7Vta4xxpjYV1UTX3zQVdLFwHPeqObvikhO5EMzxhjTkFV1BRUvIoEKbBQQfB8qlHtXtWZDIjkiskpEvhORnEDHFBFpKyKTRWSpt4zNCV9CJCIviUh+8PNwlZWBN/L+U973ZoGIDPIv8sippEx+LyI/et+VHBE5Lei9u70yyRWRk/2JOnJEJF1EPhORRSLyvYj80lvfYL8nVZRJbHxPVLXCBPwWmAl8gOtaHrhf1QOYWdl+4Uq4DhTLgQzc8Erzgb6RPm80JmAVkFxm3V+Au7zXdwF/9jvOCJfBcNyjDQurKwPcuJGf4J65Gwp86Xf8dVgmvwfuqGDbvt7/oSZAN+//VrzfnyHM5dEBGOS9bgEs8T53g/2eVFEmMfE9qfQKSlX/BNwOjAeGqRc97qrrF5XtF0Y2JFLVzgYmeK8nAOf4GEvEqernQNmOOZWVwdnAK+rMAVqLSIe6ibTuVFImlTkbeEtV96rqSmAZ7v9YvaGq61T1G+/1DmARbuQHHcTGAAAgAElEQVSaBvs9qaJMKhNV35MqH9RV1Tmq+r6q7gxatyTwgSOsoiGRqirY+kyB/4nIPG8IKIA09Z5J85apvkXnn8rKoKF/d272mqxeCmr6bVBlIiJdgYHAl9j3BChXJhAD35OQRpLwSUhDIjUQx6vqINwI8Dd5vSpN5Rryd+dZoDswAFgHPOqtbzBlIiJJwLvAreomW6100wrWNZQyiYnvSTRXUDYkkkdVf/KW+cD7uEvuDYHmCG+Z71+EvqmsDBrsd0dVN6hqsaqW4MbLDDTPNIgyEZFGuB/i11X1PW91g/6eVFQmsfI9ieYK6sCQSCLSGDck0oc+x1TnRKS5uEkiEZHmwEnAQlxZXOltdiWuM0tDU1kZfAhc4fXSGgps04NDdNVrZe6hnIv7roArk7Ei0sQbZqwn8FVdxxdJIiLAi8AiVX0s6K0G+z2prExi5nvidy+TqhKul80SXE+S3/odj09lkIHrVTMf+D5QDkA7YCqw1Fu29TvWCJfDm7imiCLcX3nXVlYGuGaKv3vfm++Ao/2Ovw7L5FXvMy/A/dh0CNr+t16Z5AKn+h1/BMpjGK45agFuZokc7zekwX5PqiiTmPieVDrUkTHGGOOnaG7iM8YY04BZBWWMMSYqWQVljDEmKlkFZYwxJipZBWWMMSYqWQVljDEmKlkFZYwxJipZBWWMMSYqWQVljDEmKlkFZYwxJipZBWWMMSYqWQVljDEmKlkFZUyUEJGuIqIikuB3LOEgIt+LSFYN9vuZiPwvAiGZGGMVlAkbERkmIrNEZJuIbBaRmSIyuJbHXCUio8MVYzXnClQQhV5aJSJ3VbLt3SLyeQXrk0Vkn4j0q2S/XiLytogUeOW0QERuE5H4cH+e2vDKoUdtjqGqh6tqdjXnKVcpq+rrqnpSbc5t6geroExYiEhL4GPgb0BboCNwP7DXz7hqqLWqJgGXAPeJyCkVbPMqcJw3qVuwscB3qrqw7A4i0h34EsgDjlDVVsCFwNFAi3B+AD+vwurLFaDxn1VQJlx6Aajqm+qmkt6tqv9T1QXe7JybReSIwMYikioiu0Ukxbvq+FhEtnrbzRCROBF5FegMfORd0fza23eod6W2VUTmBzcjiUi2iPzRe79QRD4SkXYi8rqIbBeRuSLSNZQPpKqzcZNElrsaUtW1wDTg8jJvXQFMqOSQ9wOzVPU29WZuVdVcVb1UVbcGbfczEVnjXWX9NuizDRGR2d7nXiciT3uzTQfeVxG5SUSW4ibnQ0SeFJE877PPE5ETgraPF5F7RGS5iOzw3k8PujKc75Xhxd72Z4hIjnf+WSJyZNCxVonIb0RkAbBTRBKCr3692L/24tggIoHZXQPn2uqd61gRuUpEvgg69uEiMtn7bmwQkXuqOaapL/ye8dFS/UhAS2AT7sf5VKBNmfefAf4clP8l8JH3+iHgH0AjL50ABybTXAWMDtqvo3ee03B/YI3x8ine+9nAMqA70Ar4ATcr82ggAXgFeLmSz9AVN/toAm621eOBXcCoSrb/GbA0KJ8J7AvEUsH264GrqyjDwPmfB5oB/XFXoH28948ChnrxdQUWAbcG7a/AZNwVbDNv3WW4GWUTgNu9GJp6792Jm1U10/u8/YF2QcfqEXTsQUA+cAwQj5s6fRXQJOjfKQdIDzr3gX87YDZwufc6CRhatsyDznUV8IX3ugVu1uDbgaZe/piqjmmp/iS7gjJhoarbOTi99PPARhH5UETSvE0mAJeKSOA7dzmumQzclOUdgC6qWqSqM9T71anAZcB/VPU/qlqiqpOBr3EVVsDLqrpcVbcBnwDLVXWKqu4H3gYGVvNxCoDNwAvAXao6tZLt3gfSROQ4L38F8Imqbqxk+3a4H9vq3K/uCnQ+MB9XcaCq81R1jqruV9VVwD+BEWX2fUhVN6vqbm+f11R1k7fPo0ATXIUEcB1wr7qrOFXV+aq6qZKYrgf+qapfqrtCnoCrPIcGbfOUquYFzl1GEdBDRJJVtVBV54RQDgBnAOtV9VFV3aOqO1T1y1oe08SIQ24rFpGnQthsu6reW4N4TAxT1UW4v34Rkd7Aa8ATwCWq+qWI7ARGiMg6oAfwobfrI8Dvgf+JCMBzqvpwJafpAlwoImcGrWsEfBaU3xD0encF+aRqPkqyV5kd4DUr3eNlX1PVG1R1l4i8DVwhIrNxV1S3VXHcTbiKuDrrg17vCsQrIr2Ax3D3rBJx/3/nldk3r0zct+MqosNwfzy0BJK9t9OB5SHEA67crxSRXwSta+wdt8Jzl3Et8AdgsYisxFXCH4dw3qpirOkxTYyoyRXU2bj/FFWl88MVoIlNqroYGE/p+zcTcFdAlwPvqOoeb9sdqnq7qmYAZwK3iciowKHKHDoPeFVVWwel5lVUaOH6PA+qapKXbijzmS7CNTW2wHUUqcwUavd/41lgMdBTVVviKkwpG2rghXe/6TdefG1UtTWwLWifPFxTaCjygD+VKfdEVX2zonOXpapLVfUSIBX4M/COiDSvap/qYqzimKaeqEkF9biqTqgq4ZoeTAMiIr1F5HYR6eTl03G94IKbXV4FzsVVUq8E7XuGiPQQd/m0HSj2Erirn4ygY7wGnCkiJ3s3+ZuKSFbgvD6YAWwFngPeUtV9VWz7O1zPv0dEpD2A97lfE5HWIZyrBa58Cr0r1BtD2H4/sBFIEJH7cFdQAS8AD4hIT3GOFJF23ntly/154AYROcbbtrmInC4iIfU+FJHLRCRFVUtw5QXu33gjUFLmXME+BtqLyK3iOtu0EJFjqjmmqSdqUkFV1kPpAFV9ogbHNbFtB+4GeqApbw6wEHdzGzjQ8+0b3F/NM4L27Ym7uijE3fh+Rg8+P/MQcK/Xc+wOVc3DXcXfg/txy8Pd7Pflfqp3r+wVXBPYK9Vsuxw4Ftcx4HsR2Qa8i7uHtiOE090BXOpt+zwwsZrt/4u7B7cEWA3soXQz3GPAJOB/uIrvRVznDHBNrhO8cr9IVb/G3Yd6GtiC64hyVQgxB5yC+8yFwJPAWO+e0i7gT8BM71zB97RQ1R24q9MzcU2fS4GRVR3zEGIyUS7QUyr0HUTycT8Ms4CZuG6zSyIQm6mHROQl4Ce7R2mMqc4hV1Bw4GbtcUEpBfcX80xV/UtYIzT1hrjnj3KAgaq60t9ojDHRrkYVVKkDuKfjT8M919JRVZtVs4tpgETkAeBXuG7Qf/I7HmNM9KtJE1/gqulYXBfQFbirpznAN9XcJA4cozXuBm0/3P2Ia9Q9tW+MMcYANaugSnA3uh8D/uXd5DzUY0wAZqjqC+KGaknU0kO9GGOMaeBqUkG15+C9pyG4hwW/wfW+mq2qK6rZvyXu6fiMKkYLKKV169bao0etBlaud3bu3Enz5vbIR4CVR3lWJuWVKpON3oAfKSn+BeQzv74j8+bNK1DVags+HPegEoFrgFuBbqpa5bQBIjIA98zID7ghXOYBv1TVnZXtk5mZqbm5ubWKs77Jzs4mKyvL7zCihpVHeVYm5VmZlOZXeYjIPFU9utrtanAF1Qp3/ylwFTUQ90zELFwvvneq2f9o3P2q473hb57EDY30/8psNw4YB5CSknLUpEmTDinO+q6wsJCkpOpG7Gk4rDzKszIpz8qkNL/KY+TIkRGroDbiKphZXvqqksEhK9u/PTBHVbt6+RNwA3KeXtk+dgVVnv0lWJqVR3lWJuWVKpPR3jyYU6b4Fo/fov0K6pAHiw20G4pIV29E5eCTDlbVudXsv17c/DSZqpoLjMI19xljTN25+GK/IzDVqM3Ml++KyFmq+iOAiIzADYNyRNW7AfAL4HWvB98K4OpaxGGMMYfu+uv9jsBUozYV1A3Av7xpDwYBD1J6Tp5KqWoObsoAY4wxpkI1HmDTa8q7BTfQ5O+BMd5AnmGXmJcH48e7TFERZGXBa6+5/K5dLj/RGzdz2zaXf+89ly8ocPmPPnL59etd/tNPXT4vz+UD7dArVrj89Okun5vr8rNmufzChS4/12vJzMlx+Zwcl5871+UXLnT5WbNcPnAPbfp0l1/h9cafMsXl87yi+/RTl1/vTQn00UcuX1Dg8u+9B1lZxBcWuvzEie79Xd7jaK+95vJFRS4/frzLBzz//MG2d4BnnoFTTz2Yf/JJOOusg/m//hXOD5oh4uGHYezYg/kHHoDLLjuYv+8+uDrogvjuu2HcuIP5O+6Am246mL/1VpcCbrrJbRMwbpw7RsDVV7tzBFx2mYshYOxYF2PA+ee7zxBw1lnuMwaceqorg4DRo10ZBWRlxex3r2Vg+zB/99i2zeWj+Lunquy+49ds+tlV/HvBOl6YsYKvzr+G4vse5YZX53HlS1+xuU0qm9qkcslzc7j65a+YcdJFzDj7Sv42dSnvf7uWgkuvYv+vf3Pw+PXwu9dmnjedWF3/7oWoJhMWfkTpOVwScXPMvCgiqOpZFe9pjDHhpcCGbXtYvH47LVZvoXj1Zu5/agZrNu3ixpkrab17B/e88Q0A967dSlKJsnxjIYmN41ndvisCFJcoGwv3UlC4jx07S3h0shv7+sEf1rN91S4+emoGQ7q1Zdy2PaQcVlKrZidzaGrSi6/sFNOlqOr0WkVUAevFV5710CrNyqO8+lgm23YXsWDtVnLWbCUnbyvz126loPDg6GppLZuQ2b4l3dolkt7Wpc5tEzmsdTNaNk1g+vTp1ZbJnqJi1m7ZzbL8Qr77cSvz87Yxd9Vm9u4vIbFxPKcf0YELj05ncNc2eDNAx6z62Isv7BWQMcZUZO2WXcxZsZkvV2zimzVbWL7x4PP83VOaM6JXKkd0bEnvDi3p3b4FrRMbh37wQFNko0alVjdtFE+P1CR6pCZxSr/2gKu05qzYxCffrefjBT/x9ry1ZKa14JZRPTm1X3vi4mK7oopWNWni+1hVz6jtNsYYU1agQpqzYhNzVmxi7Rb3iGWbxEYM6tyGcwZ0ZEDn1hzZqTWtmjWq5mjVGDPGLbOzq920aaN4sjJTycpM5Xdn9eXfC9bxj+nLuemNb+iVlsSvT+7N6L5ptYvHlFOT5tRhIvJhFe8L0LeG8RhjGpAft+5m9vJNFVZIx3Rrx3XDujG0ezt6pbYI/1XKddfVaLfExglceHQ65w3qxL+/W8eTU5Zw3StfM6ZvGvefdTiHtbYZh8KlJhXU2SFsU+2UG8aYhmfn3v18uXITny8p4POlG1nhNdnVSYVUVnAPwBqIjxPO6n8Yp/Zrz4tfrOSJKUsY89h0HjzvCM4e0DFMQTZsdg/KGBMxJSXK9z9t5/OlG5mxdCPzVm+hqFhp2iiOoRnt+NkxXTiuezsy0+qgQior0D0+MbFWh2kUH8cNI7pz+hEd+NXEHH75Vg6zl2/id2ceTrPGVY6dbaphPSaNMWG1qXAv05ds5LPcjcxcVsDmna5BpW+Hllw7LIPhPZMZ1KUNTRv5/ON9mjeuQAj3oEKR3jaRt8YN5fEpS3gmeznf/7Sdl64aTEqLJmE5fkNkFZQxplYCV0mf5eYzbXE+89duRRWSk5qQlZnC8J4pHN8jOfp+qG+8MeyHTIiP486TezOocxtufuNbznt2JuOvHkL3FBtBvSZqVEGJyECgO/C9qi4Kb0jGmGi3Y08RXywtYNrifLKXbGTjjr2IQP9Orbl1VC9O7J3K4Ye1jO7u1xEcLHZUnzTeGjeUa8bP5fxnZzH+6iEMSG8dsfPVVzXpZn4fcBluosG/iMhDqvp8NbsZY2KYqhuBYdrifD5bvJG5qzazv0Rp2TSB4b1SOLF3KsN7pZCcFGVXSVUJDNnUqlVEDt8/vTXv/d9xXPbil1z+4pe8ef1Q+nWMzLnqq5pcQV0MDFDVXSLSDvgUsArKmHpmT1Exs5dvOtB0F+gC3rt9C64fnsHIzFQGdW5NQnyNh/T019leh+Qw3YOqSJd2zXnz+qFc/M85XPbil0wcdyyZ7VtE7Hz1TU0qqD2qugtAVTeJSIx+O40xZeVt3kW2VyHNWr6JvftLaNYonuN7JHNjVndGZqbWn+d8brmlTk7TqY3rPHHBP2Zx1ctf8d7/HUeHVvWkDCOsJhVU96AHdaVM3gaLNSaGFBWX8PWqLXyWm89ni/NZmu9Gye/SLpFLhnTmxN6pDOnW1v8ed5Fw3nl1dqr0tomMv3oIF/5jNle/PJdJNxxLy6a1HAmjAQjHg7p/rXArY0xU2rhjL9m5+XyWm8+MJQXs2LufRvHCMd3aMXZIZ0ZmppDREHqdBaYRSU6uk9P16dCSZy8bxNUvz+W2iTk8d/nR0d2JJArYg7rG1HOqyg/rtjN1UT5TF+czP28r4Eb+PqN/B7IyUzm+RzJJTRrYUycXXOCWEbwHVdYJPVP4f2f05Xcffs/fpi3jl6N71tm5Y1ED+0Ya0zDsKSpmwcb9TPnXd0xblM9P2/Yc6AZ+x0m9GNk7lb4dWsb8dBG1cvvtvpz2imO7MH/tVp6YuoQjO7ViZO9UX+KIBVZBGVNP5O/Yw2eL85myKJ8vlhawu6iYxMY/ckLPZG4d04uRmanR97Csn84805fTiggPnnsEi9bt4Pa35/PprSeQ2qKpL7FEO6ugjIlRpZruFm1g/lr3XE/H1s248OhOJO9bz7hzRtbPDg7hEJjavn37Oj9100bx/O2SAZzxty+44+0FjL9qsN2PqkDYKigReRA39fsLqrophO3jga+BH23uKGNCE3g2aeriDRU23Y3qk0bv9i0QEbKzC6xyqsrYsW5Zh/eggvVIbcG9p/fl3n8t5OVZq7h2WDdf4ohm4byC+go3/NHjwBUhbP9LYBHQMowxGFPvVNx0F29Nd7V1111+R8DPjulMdm4+f/l0ccPpPXkIajoWXzxwi6o+Hlinqv86hP07AacDfwJuq0kMxtRX1TXdndg7laEZ7ezqqLZOOcXvCA7cjxr92HTueu873rp+qDX1BRFVrdmOItmqmlXDfd8BHgJaAHdU1MQnIuOAcQApKSlHTZo0qUZx1leFhYUkJdlfWwGxXh77ipVFm4vJyS9m/sZiNu9RBMhoFceA1HgGpCbQKUkOqdddrJdJJASXSZP8fAD2pvrfi+7ztUW8tHAfV/ZtzMjOdfcAr1/fkZEjR85T1aOr2642TXwzReRpYCKwM7BSVb+paicROQPIV9V5IpJV2Xaq+hzwHEBmZqZmZVW6aYOUnZ2NlclBsVge+Tv2MM17Nql0010qo/qk1brpLhbLJNJKlUlg6dM9qGAjVMl98UveXb6NG88eSvtWddOrL9q/I7WpoI7zln8IWqfAidXsdzxwloicBjQFWorIa6pau/mXjYlyqm7epGmLK266G9UnjaEZbWmSYE13deLee/2O4IBAU9+Yxz/noU8W8eTYgX6HFBVqXEGp6sga7nc3cDeAdwV1h1VOpr4K9LqbsmgD0xbns87rdTcgvTV3npzJqD6pZKa1aNgPzPpl9Gi/IyilS7vm3DA8g6emLeOyoV0Y3LWt3yH5rsYVlIikAQ8Ch6nqqSLSFzhWVV8MW3TGxKD87XuY5vW6m7nsYNPd8J4p/GpMKif2To2teZPqqxUr3DIjw984gtyY1YN35q3ldx98z0e/GEZ8A+8wUZsmvvHAy8BvvfwS3P2okCsoVc0GsmsRgzG+CzTdTV2Uz7TF1nQXM665xi2j4B5UQLPG8dxzeh9ufuNb3vxqDZcN7eJ3SL6qTQWVrKqTRORuAFXdLyLFYYrLmKhmTXf1wP33+x1BhU4/ogOvdlvN45OXcM7Ajg1vEN8gtfnkO70ZdRVARIbiRpIwpl6qqOmueeN4TuiZwm1jUhlpTXexZcQIvyOokIhw92l9OOfvM3n+8xX8akwvv0PyTW0qqNuBD3ETFs4EUoALwhKVMVEguOlu6uINLAhqurvo6E6caE13sS031y0zM/2NowID0ltz2hHteWHGCi4b2qXBjhRSm15880RkBJCJm1k3V1WLwhaZMT7YU1TMrOUFTFmUz7RF+azfbk139dbPf+6WUXQPKtgdJ2Xy3+838PS0pdx/dj+/w/FFbXrxzQA+B2YAM61yMrGqqqa7UX2s6a7eevBBvyOoUkZKEhcPTueNr9Zw7bAMOrdL9DukOlebJr4rgWHA+cAjIrIXmKGqvwpLZMZESHVNd6P6pHGMNd3Vf8cdV/02PvvlqJ68O28tT3+2lL9c0N/vcOpcbZr4VojIbmCfl0YCfcIVmDHhVFnT3UBrumu4Fi50y37R23yW1rIplwzpzGtzVvOLE3uS3rZhXUXVpolvOVAAvIF79ukXqloSrsCMqa387XuYujifqYvy+WLZRvYUlVjTnTno5pvdMkrvQQXcMKI7b3y5hmeyl/PQeUf4HU6dqk0T31O4Jr5LgIHAdBH5XFWXhyUyYw5RVU13Fx+dbk13prRHHvE7gpC0b9WUiwen89bcNdx8Yg86tm7md0h1pjZNfE8CT4pIEnA18HugE2D/+02dCTTdvfL9Xu6aNc2a7kzoBg/2O4KQ3ZDVnbfmruEf2ct54JzobZIMt9o08T2Ku4JKAuYA9+F69BkTUQeb7jbwxbIC9hSV0DQeRvZJZlSfNLIyU6zpzlQvJ8ctBwzwN44QdGzdjAuOSmfi3DxuPrEHaS3rZjoOv9WmiW8O8BdV3RCuYIypSChNd3vXLmTMiUf5HKmJKbfe6pZRfg8q4IYRGbw1dw0TZq3i16f09jucOlGbJr63ReQsERnurZquqh+FKS7TwFXX6250nzR6pSUdaLrL/sma8MwheuIJvyM4JF3aNeeUw9vz2pzV3DSyB80bwBh9tWniewgYArzurbpFRI7z5nsy5pDl79jDZ4vzmfxD6V53w3ulWNOdCb8YaNor67oTMvhk4Xre/jqPq47v5nc4EVebKvh0YECga7mITAC+xZuM0JjqqCqL1+9g6qINTFmUT07eVsB63Zk6MneuW8ZQZ4mjurThqC5teHHmSi4b2oWE+Di/Q4qo2l4jtgY2e69b1fJYpgHYt7+EL1duYsoPrlL6cetuAPqnt+aOk3oxqk8avdtbrztTB+680y1j5B5UwPUnZHDDa/P47/cbOP3IDn6HE1G1qaAeAr4Vkc9wg8UOx66eTAW27NzHZ7nugdnpSzZSuHc/TRvFMaxHCr84sQcn9k4ltYH0SjJR5Omn/Y6gRsb0TaNru0Sem7HCKqjKqOqbIpINDMZVUL9R1fXhCszEtuUbC5nywwamLsrn69WbKVFIbdGEM/sfxug+qRzfI5mmjazpzvgoioc4qkp8nHDNsG7c98H35ORtZUB6a79DiphDrqBEJBW4B+gBfAc8pKrbwx2YiS37i0v4evWWA/eTVhbsBKBvh5bcPLIHo/um0e+wVsTFWdOdiRKzZrllDAwaW9Z5gzrxl09zeWX2Kgakx15nj1DV5ArqFWAe8DfgDNyQR1eFMSYTI7bvKWJ67kamLtrAZ7kb2ba7iMbxcRzbvR3XHN+VE/ukNahhWUyMuecet4yxe1AASU0SOG9QR976Ko/fntaHdvW0d2tNKqj2qvpb7/V/ReSbQ9lZRNJxlVx7oAR4zhs2ycSAvM27mLJoA1MWbeDLFZvZX6K0bd6Y0X3SGNM3lWE9U0hqAM9nmHrgn//0O4JauXxoF16ZvZqJX+fxf1k9/A4nImrySyIi0gZ33wkgPjivqpsr3dPZD9yuqt+ISAtgnohMVtUfahCLibDiEiUnbytTF7n7SbkbdgDQMzWJ607IYEzfVAaktyHemu5MrInCqd4PRc+0Fhyb0Y7X56zh58O718v/gzWpoFrhmviCSyNwFaVARlU7q+o6YJ33eoeILAI6AlZBRYld+/YzY2kBU37YwGe5+RQU7iM+ThjStS3/74y+jO6TSpd2zf0O05jamT7dLUeM8DeOWrji2C7c+Po3TFucz5i+aX6HE3aiqv6dXKQrbtr4fmU7WojIOGAcQEpKylGTJk2q8/iiWWFhIUlJSWE73uY9JeTkF5OTX8wPm4vZXwKJCXBkSjwDUhI4IiWe5o2i9y+0cJdHfWBlUl5wmQzwxuLLibEhj4IVlyh3TN9Nx6Q47hh86I9q+PUdGTly5DxVPbq67XyroLxpOqYDf1LV96raNjMzU3Nzc+smsBiRnZ1NVlZWjfcPDMA6+YcNTF28gYU/ur8PurRLZHSfNEb1SWVw17Y0ipEn1WtbHvWRlUl5pcpkxQq3zKiy0SfqPTV1KY9NXsL0O7MOuWXDr++IiIRUQflyN1tEGgHvAq9XVzmZ8NlTVMzs5ZuY4t1PWr99D3ECgzq34Ten9GZM31S6pyTZKA6mYYjxiingwqM78cSUJbz99VruODm276uVVecVlLhfvxeBRar6WF2fv6HZuGMvny3OZ8qiDcxYWsDuouJSA7COzEypt11UjanSlCluOXq0v3HUUodWzRjRK4V35q3lV2N61avOErWqoLzee+nBx1HV6rqdHw9cDnwnIt6MYdyjqv+pTSzGUVWWbCg80BU8J28rqnBYq6ZccFQnRvdNY6gNwGoM/PGPbhnjFRTAxYPTueG1b/h8yUZG9k71O5ywqc10Gw/gHtBdjuu9h7c8sar9VPULSvcANLW0b38JX63cfKBSWrvFG4C1Uyt+NboXo/qk0rdDS2u6MybYq6/6HUHYnNg7jeSkxrw1d41VUJ6LgO6qui9cwZjQFe5T3v92LVMW5fN57kZ27N1Pk4Q4hvVI5qaRbgDWhjIttDE1kp7udwRh0zghjvMGdeKlL1ayccdeUlrUj2b72lRQC3HTbeSHKRZTjRUbC5m6KJ/Jizbw9apdlOh8Ulo04fQjOzC6TxrH90imWWNrujMmJJ9+6pannOJvHGFy0dHpPPf5Ct7/di3jhnf3O5ywCMd0GwuBvYGVqnpWraMygBuAdd7qLUxdnM+UHzawwhuAtXf7Fpye0YhrTxnCkR1tAFZjauThh92ynlRQPVKTOLpLGybOzeP6EzLqRZN+bSqoCcCfcVbPFgQAAA91SURBVCOal4QnHLNjTxGfLylgyiI3isPWXUU0iheGZrTjquO7cmLvVDq1SSQ7O7teD7NvTMS99ZbfEYTdRYPT+fU7C/hmzVaO6tLG73BqrTYVVIGqPhW2SBqwvM273Fh3i/OZs2ITRcVKm8RGnNg7ldF90jihZzItmjbyO0xj6pf27f2OIOxOO6ID932wkPe/XdvgK6h5IvIQ8CGlm/gOaXTzhqikRJm/duuBB2YXr3cDsHZPac41w7oxuk8agzrbAKzGRNRHH7nlmWf6G0cYJTVJ4KS+7fl4wTruO+NwGifExkgwlalNBTXQWw4NWldtN/OGate+/XyxtICpi/KZujifgsK9xMcJg7u24d7T+zCqTxrdkm0AVmPqzKOPumU9qqAAzh3YkQ/n/0R2bj4nHR7bV4m1mfJ9ZDgDqY/Wb9vD1MXuKmnmsgL27i+hRdMERvRKYUzfNEb0SqF1YmO/wzSmYXrnHb8jiIgTeibTrnlj/pXzY8OtoEQkDXgQOExVTxWRvsCxqvpi2KKLMYEBWANNd9/9uA2A9LbNuPSYzozpk8bgbrEzAKsx9Vpyst8RRERCfBxn9j+MN75aw7bdRbRqFrv3r2vTxDceeBkIzK67BJiIG2evwdhTVMzsFZsOTOi3btsexBuA9denZDK6Txo9U20AVmOiznveONXnnedvHBFw7sCOjJ+1ik++W8fYIZ39DqfGalNBJavqJBG5G0BV94tIcZjiimqbCvcyLWgA1l37iklsHM8JPZO5bUwvRvZOJdkGYDUmuj3ldUKuhxXUkZ1akZHSnPe+/bHBVlA7RaQd3jh8IjIU2BaWqKKMqrI03xuA9YcNfOsNwNq+ZVPOG9SRUX3SODajHU0b2SgOxsSMDz7wO4KIERHOHdCRRycvYe2WXXRqk+h3SDVSmwrqNlwX8+4iMhNIAS4MS1RRoKi4hLkrNzPZa7pbs3kXAEd0bMWto9wArIcfZgOwGhOzWrXyO4KIOmegq6A+yPmJm0b28DucGqlNBfU9MALIxI1OngvE9N3/bbuKyF6Sz+QfNjB9yUZ27NlPY28A1p+PyGBU7zTat7IBWI2pFyZOdMuLL/Y3jghJb5vIoM6t+XjBugZZQc1W1UG4igoAEfkGGFTrqOrQyoKdTPWmqZi7agvFJUpyUmNO7dee0X3SGNYzmcTGvkw8bIyJpGefdct6WkEBnH7kYTzw8Q8s31hI95Qkv8M5ZIf8yysi7YGOQDMRGcjBuZ1aAlHf0FlconyzZgtTfnCV0vKNBwdgvWFEBqP7pNG/U2sbgNWY+u4/9X+O1NOP6MAf//0D/16wjltG9fQ7nENWk0uDk3ETFXYCHuVgBbUDuCc8YYVX4d79fL5koxuAdXE+W/5/e2ceJFV1xeHvxyLKojiyjUoEDJshioK4Ew2oSLTQSCJJXEAtkipJKRqrsFBDZakyKxGXGEQYXILGDAoilixxjaVxg2FGFHBJggNDiEbBBRRO/ri3oZmZ7pnpWbp7+nxVr+57t9+979xTt/v0Xd45SQ5YLznxCEYN7knvopy3rY7jNCUdW/93vtdB+3P8EUUsKassDANlZvOB+ZIuNLPSZpCpSdj44aesXBu2giccsHbt2J4zBgYHrCMHuANWxylo7r8/pBdfnF05mplvHV3MTxdXsK5qGwN6dsm2OA2iMYsrh0s6kDByupuw9jTNzJY1iWQNZPduo+z9j1i5torlb1TtccDar3snJp2ScMDalXbuxcFxHIA5c0Layg3UOV/vxYzHKlhStolrzywcA3W5md0q6WygBzCJ4FmixQzUZzt38fyGrXtCVfxn2w7aCIb3KWL62MGMGtyDfnm4MOg4TguwfHm2JWgRenTZnxP6FvF4WSVTR/fPq1djGmOgEq0cC8wzs9WqZ8sljQFuBdoCc8zslvo+dMvHn++JMPt8wgFrh3aMHNid0YN7cPqAHhzcyR2wOo5TB+0LZ4r/3KMP5cZHy3lz8zYGFx+YbXHqTWPjQS0D+gI3SOpCPSLrSmoL3AGcCWwEXpa02MzeSFVm5y6YtXI9K9ZWUbYxOKs4/OAD+N6IrzB6cE9G9C3K+7gnjuO0MCUlIZ04MZtStAhjhvTi5kXlPF62qWAM1BXAUOAdM/s0uj2aVI9yI4ANZvYOgKQHgXFASgNV+cluZq5Yx9DeXbn+7OCAdUBPd8DqOE4jKCAD1a1zB04+shtLyiq57qwBefPbKTPLrKD0V8Ka0xNmVufIKanceGCMmV0Zry8BTjCzKdXumwxMjpdDgPKMBG29dAO2ZluIHML1URPXSU1cJ/uSLX0cYWbd67qpMSOouwgjplmSHgZKzOzNepSrzXTXsJJmNhuYDSDpFTMb3ghZWx2uk31xfdTEdVIT18m+5Lo+Ml64MbMVZvYDwvby94Dlkl6QNElSutXHjUDvpOvDgcpM5XAcx3FaJ43aWRDXnSYCVwKvE3bmHQek27/5MtBfUl9J+wETCF7RHcdxHGcPjQn5vhAYBNwHnGdmm+JHD0l6JVW5GNhwCvAkYZv5XDOrSHV/ZHamcrZiXCf74vqoieukJq6TfclpfTRmk8Q3zexvTSyP4ziO4wAZTPFJOl5Sr4RxknSppEWSZkkqanoRHcdxnEIkkzWoPwE7ASSNBG4B7iWEe8/p4aLjOI6TP2RioNqa2Qfx/CJgtpmVmtlNQJOGbZQ0RtJbkjZImtaUdecTkt6TtEbSqsT6nqQiScslrY/pwdmWszmRNFfSFknlSXm16kCBWbHflEnKqyCa9SWFTmZIej/2lVWSxiZ9dkPUyVvRh2arQlJvSU9JWiupQtLVMb9g+0kaneRHPzGzBh2EF2bbxfM3gZHJnzW0vjTPaQu8DfQD9gNWA0c1Vf35dBC28Xerlvdrgvd4gGnAr7ItZzPrYCRhh2h5Ul6tOiD4h3yC8M7dicBL2Za/BXUyA/hJLfceFb9DHQjuyd4m/NnMejuaUB/FwHHxvAuwLra7YPtJGp3kRT/JZAS1AHhG0iLgM+A5AElfJUzzNRV7XCKZ2U4g4RLJCYwD5sfz+cD5WZSl2TGzZ4EPqmWn0sE44F4LvAh0lVTcMpK2HCl0kopxwINmtsPM3gU2EL5jrQYz22Rmr8XzbcBaQvTvgu0naXSSipzqJw02UGb2S+A6oAQ41aLZjXX9uOlE4zDg30nXG0mv2NaMAcskvRpdQAH0tLi1P6Y9siZd9kilg0LvO1PilNXcpKnfgtKJpD7AscBLeD8BaugE8qCfZPSirpm9aGaPmNknSXnrEpa6iaiXS6QC4RQzOw44B7gqbk5xUlPIfeePwJEER86bgN/F/ILRiaTOQClwjZl9nO7WWvIKRSd50U9yOUaFu0SKmFllTLcAjxCG3FWJ6YiYbsmehFkjlQ4Ktu+YWZWZ7bLgwPlu9k7PFIROopu1UuABM1sYswu6n9Smk3zpJ7lsoNwlEiCpk0KsLSR1As4ibFRZDFwWb7sMWJQdCbNKKh0sBi6Nu7ROBD6yvZ5OWjXV1lAuYG8UgMXABEkdJPUF+gP/aGn5mhNJAu4B1prZ75M+Kth+kkonedNPsr3LJN1B2GWzjrCTZHq25cmSDvoRdtWsBioSegAOAVYC62NalG1Zm1kPCwhTEV8Q/uVdkUoHhGmKO2K/WQMMz7b8LaiT+2Kbywg/NsVJ90+POnkLOCfb8jeDPk4lTEeVAaviMbaQ+0kaneRFP8nY1ZHjOI7jNCe5PMXnOI7jFDBuoBzHcZycxA2U4ziOk5O4gXIcx3FyEjdQjuM4Tk7iBsrJSyRNj96Zy6I35hMyqGOipEObQbYSST+slne+pKV1lNse0z6Svt/UcqV5bh9JGyW1qZa/StKIankJL9g/q6ucpKmS/iXp9pZoh9P6cAPl5B2STgLOJXhpPhoYzb7+w+rLRKDJDRTh/aQJ1fImxPz60AdoMQNlZu8R9HdaIk/SIKCLmdX2kuZMM7u5rnJmNhO4uTlld1o3bqCcfKQY2GpmOwDMbKuZVUoaJemRxE2SzpS0UFLbOKopV4irNVXSeGA48ED8x3+ApGGSnolOeZ9Mco/ztKSZkp6NcXWOj/Wul/SLWuRbAQxKKt+RYEQfjdfXRlnKJV1TS/lbgNOiXFPjSOU5Sa/F4+RYTxtJd8aR5BJJS2O7SNWWNFQ3qvU1qJmWc5y6yfabzn740dAD6Ex4I34dcCfwjZgvQoyy7vH6z8B5wDBgeVL5rjF9mug9AGgPvJBU9iJgbtJ9iRhCVxN8kxUTYuZsBA6pRcY7gKvj+QTg4Xg+jPAGf6fYjgrg2PjZ9pieDixJqqsjsH887w+8Es/HA0sJfzR7AR/GvJRtSaPTXgSvFIlYb2uBIbXcN4OkOEJ1lSOMUm/Pdp/xIz+PdnXYL8fJOcxsu6RhhKmlM4CHJE0zsxJJ9wEXS5oHnARcSgjU1k/SbcDjwLJaqh0IDAGWB/dltCX88CZI+IFcA1RY9Nkm6R2Cc83/VqtvAfAb4FaCgbo35p8K7IkEIGlhbMfraZrcHrhd0lBgFzAgqa6HLTj83CzpqXq2pQZmtllSBTBKUhXwhZmVpyvTmHKOUx/cQDl5iZntIoxsnpa0huAEtASYBzwGfE748f4S+FDSMcDZwFXAd4HLq1UpguE5KcUjd8R0d9J54rq279HfgeL43JPZOw1WWziDupgKVAHHEEZLn9dRV11tSUViuq6Khk3TZVrOcdLia1BO3iFpoKT+SVlDgX/CntAklcCNBIOFpG5AGzMrBW4ihEkH2EYYXUFwjNk9bsBAUntJX8tURjMz4C+ECK5LzSxhVJ4FzpfUUcE7/QXEqNRJJMsFcBCwKY6ULiGMiACeBy6Ma1E9CVODadsiaYqkKSnELiU4Er2IEMG6vmRaznHS4iMoJx/pDNwmqSvwJSEs9eSkzx8grL+8Ea8PA+YlbYe+IaYlwF2SPiNMB44HZkk6iPDd+ANhjShTFgDXA9MSGWb2mqQS9oYwmGNm1af3yoAvJa2OMt4JlEr6DvAUkAgUWgqMIoRKWEeIlPqRme2MmyVqa8sgwuiuBmb2P0kvEiLQvlvfRmZaznHqwr2ZO62O+N7N62Z2T7ZlaW4kdY5rcocQjN4pZrY5zf1LgG+b2c4MnzeDsJnjt/W8fyJhI0qqUZvjpMRHUE6rQtKrhBHGddmWpYVYEkeS+wE/T2ecAMzs3EY+bzswWdKBZpb2HSdJU4EfEUZ6jtNgfATlOI7j5CS+ScJxHMfJSdxAOY7jODmJGyjHcRwnJ3ED5TiO4+QkbqAcx3GcnOT/KaE3GJrqByQAAAAASUVORK5CYII=\n", + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(V_pvm, (I_pvm - i_pvl_brentq) / I_pvm)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4.49089099241462e-10\n", + "7.028155835087091e-12\n", + "2.7977620220553945e-14\n" + ] + }, + { + "data": { + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def sde_resid(v, i, iph, io, rs, rsh, nNsVth):\n", + " \"\"\"\n", + " Calculate the residual for current for a single diode equation at (v, i).\n", + " \"\"\"\n", + " return iph - io * np.expm1((v + i * rs) / nNsVth) - (v + i * rs) / rsh - i\n", + "\n", + "i_resid_lambertw = sde_resid(v_pvl, i_pvl_lambertw, iph=photocurrent, io=saturation_current,\n", + " rs=resistance_series, rsh=resistance_shunt, nNsVth=nNsVth)\n", + "i_resid_brentq = sde_resid(v_pvl, i_pvl_brentq, iph=photocurrent, io=saturation_current,\n", + " rs=resistance_series, rsh=resistance_shunt, nNsVth=nNsVth)\n", + "i_resid_newton = sde_resid(v_pvl, i_pvl_newton, iph=photocurrent, io=saturation_current,\n", + " rs=resistance_series, rsh=resistance_shunt, nNsVth=nNsVth)\n", + "\n", + "plt.plot(v_pvl, i_resid_brentq)\n", + "plt.plot(v_pvl, i_resid_newton)\n", + "plt.plot(v_pvl, i_resid_lambertw)\n", + "plt.legend(['Brentq', 'Newton', 'LambertW'])\n", + "plt.ylabel('Error in current')\n", + "plt.xlabel('Voltage')\n", + "print(np.max(np.abs(i_resid_brentq)))\n", + "print(np.max(np.abs(i_resid_newton)))\n", + "print(np.max(np.abs(i_resid_lambertw)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 67, "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ - "pv_sys.plotSys()" + "Vmod = pv_mod.Vmod\n", + "Imod = pv_mod.Imod\n", + "Voc = pv_mod.Voc.sum()\n", + "Imod = Imod[(Vmod>=0) & (Vmod<=Voc)]\n", + "Vmod = Vmod[(Vmod>=0) & (Vmod<=Voc)]\n", + "\n", + "plt.plot(Vmod, Imod)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "41.270548514676385\n" + ] + } + ], + "source": [ + "Ns = 60\n" ] }, { @@ -172,7 +350,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.6.8" } }, "nbformat": 4, From 6f416767eb4c1a9be1c5e7be19a181ff088760e7 Mon Sep 17 00:00:00 2001 From: Cliff Hansen Date: Thu, 16 Jan 2020 13:51:22 -0700 Subject: [PATCH 11/16] update notebook, correct pvcell.py --- notebooks/basic_iv_curves.ipynb | 1272 ++++++++++++++++++++++++++- pvmismatch/pvmismatch_lib/pvcell.py | 9 +- 2 files changed, 1235 insertions(+), 46 deletions(-) diff --git a/notebooks/basic_iv_curves.ipynb b/notebooks/basic_iv_curves.ipynb index ec699fe..d7488dd 100644 --- a/notebooks/basic_iv_curves.ipynb +++ b/notebooks/basic_iv_curves.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 34, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -18,11 +18,13 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# Setting PV system layout cell and module parameters\n", + "str_len = 6 # number of modules in a string\n", + "str_num = 3 # number of (parallel connected) strings in the array\n", "v_bypass = np.float64(-0.5) # [V] trigger voltage of bypass diode\n", "cell_area = np.float64(246.49) # [cm^2] cell area\n", "Isc0_T0 = 9.68 # [A] reference short circuit current\n", @@ -38,13 +40,13 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "pv_cells = pv_mod.pvcells\n", "for c in pv_cells:\n", - " c.update(diode_model = 'desoto', aRBD=0.0, bRBD=0.0, Isc0_T0 = Isc0_T0) # updating short circuit currents\n", + " c.update(diode_model = 'pvsyst', aRBD=0.0, bRBD=0.0, Isc0_T0 = Isc0_T0) # updating short circuit currents\n", "\n", "pv_mod.setSuns(cells=list(range(0, len(pv_cells))), Ee=[1]*len(pv_cells))\n", "\n", @@ -57,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -98,13 +100,17 @@ "\n", "print(pv_mod.pvcells[0])\n", "\n", - "(photocurrent, saturation_current, resistance_series, resistance_shunt, nNsVth) = pv_mod.pvcells[0].Igen, \\\n", - " pv_mod.pvcells[0].Isat1, pv_mod.pvcells[0].Rs, pv_mod.pvcells[0].Rsh, pv_mod.pvcells[0].N1 * pv_mod.pvcells[0].Vt\n", - "print((photocurrent, saturation_current, resistance_series, resistance_shunt, nNsVth))\n", + "(photocurrent, saturation_current, resistance_series, resistance_shunt, nVth) = \\\n", + " pv_mod.pvcells[0].Aph * pv_mod.pvcells[0].Isc, pv_mod.pvcells[0].Isat1, \\\n", + " pv_mod.pvcells[0].Rs, pv_mod.pvcells[0].Rsh, \\\n", + " pv_mod.pvcells[0].N1 * pv_mod.pvcells[0].Vt\n", + "\n", + "print((photocurrent, saturation_current, resistance_series, resistance_shunt, nVth))\n", "\n", "(V_pvm, I_pvm) = pv_mod.pvcells[0].Vcell, pv_mod.pvcells[0].Icell\n", - "I_pvm = I_pvm[(V_pvm>=0) & (V_pvm<=pv_mod.pvcells[0].Voc)]\n", - "V_pvm = V_pvm[(V_pvm>=0) & (V_pvm<=pv_mod.pvcells[0].Voc)]\n", + "u = (V_pvm>=0.) & (I_pvm>=0.)\n", + "I_pvm = I_pvm[u]\n", + "V_pvm = V_pvm[u]\n", "\n", "plt.figure()\n", "plt.plot(V_pvm, I_pvm)\n", @@ -113,16 +119,72 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 5, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1.77635684e-15 0.00000000e+00 1.77635684e-15 0.00000000e+00\n", + " 1.77635684e-15 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 1.77635684e-15 0.00000000e+00\n", + " 1.77635684e-15 0.00000000e+00 1.77635684e-15 1.77635684e-15\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 1.77635684e-15 1.77635684e-15 1.77635684e-15 1.77635684e-15\n", + " 1.77635684e-15 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 1.77635684e-15 0.00000000e+00 1.77635684e-15 1.77635684e-15\n", + " 1.77635684e-15 1.77635684e-15 0.00000000e+00 1.77635684e-15\n", + " 1.77635684e-15 1.77635684e-15 1.77635684e-15 1.77635684e-15\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 1.77635684e-15 1.77635684e-15 1.77635684e-15\n", + " 1.77635684e-15 1.77635684e-15 0.00000000e+00 1.77635684e-15\n", + " 1.77635684e-15 0.00000000e+00 1.77635684e-15 1.77635684e-15\n", + " 0.00000000e+00 0.00000000e+00 1.77635684e-15 1.77635684e-15\n", + " 0.00000000e+00 1.77635684e-15 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 1.77635684e-15 1.77635684e-15 1.77635684e-15 0.00000000e+00\n", + " 1.77635684e-15 0.00000000e+00 1.77635684e-15 1.77635684e-15\n", + " 0.00000000e+00 1.77635684e-15 0.00000000e+00 0.00000000e+00\n", + " 1.77635684e-15 1.77635684e-15 1.77635684e-15 5.32907052e-15\n", + " 5.32907052e-15 4.44089210e-15 3.55271368e-15 2.66453526e-15\n", + " 8.88178420e-15 5.32907052e-15 4.44089210e-15 5.32907052e-15\n", + " 8.88178420e-16 4.44089210e-15 2.66453526e-15 3.55271368e-15\n", + " 8.88178420e-15 5.77315973e-15 4.44089210e-15 6.66133815e-15\n", + " 3.55271368e-15 9.32587341e-15 8.88178420e-16 1.11022302e-14\n", + " 6.66133815e-15 3.55271368e-15 3.55271368e-15 7.99360578e-15\n", + " 1.19904087e-14 7.10542736e-15 9.32587341e-15 2.22044605e-15\n", + " 5.32907052e-15 2.66453526e-15 4.44089210e-16 4.88498131e-15\n", + " 1.28785871e-14 9.32587341e-15 3.99680289e-15 7.99360578e-15\n", + " 4.44089210e-15 5.77315973e-15 4.88498131e-15 3.55271368e-15\n", + " 1.19904087e-14 8.88178420e-16 0.00000000e+00 7.54951657e-15\n", + " 1.33226763e-15 3.10862447e-15 5.77315973e-15 8.88178420e-16\n", + " 8.88178420e-15 2.22044605e-15 1.33226763e-15 1.42108547e-14\n", + " 3.99680289e-15 9.32587341e-15 1.11022302e-14 0.00000000e+00\n", + " 1.33226763e-15 4.44089210e-16 8.88178420e-15 0.00000000e+00\n", + " 6.66133815e-15 4.88498131e-15 5.77315973e-15 2.66453526e-15\n", + " 7.54951657e-15 4.88498131e-15 5.32907052e-15 1.11022302e-14\n", + " 5.77315973e-15 4.44089210e-16 1.19904087e-14 2.66453526e-15\n", + " 9.32587341e-15 1.42108547e-14 7.54951657e-15 2.22044605e-15\n", + " 2.22044605e-15 1.33226763e-15 1.15463195e-14 7.99360578e-15\n", + " 1.46549439e-14 8.88178420e-16 2.22044605e-15 7.10542736e-15\n", + " 1.02140518e-14 1.59872116e-14 8.88178420e-16 0.00000000e+00\n", + " 4.44089210e-15 1.77635684e-15 4.44089210e-16 3.10862447e-15\n", + " 2.44249065e-15 2.66453526e-15 1.77635684e-15 1.59872116e-14\n", + " 3.33066907e-15 6.21724894e-15 3.55271368e-15 1.17683641e-14\n", + " 8.65973959e-15 1.99840144e-15 5.55111512e-15 3.77475828e-15\n", + " 2.66453526e-15 1.27675648e-14 1.25455202e-14 9.65894031e-15\n", + " 1.99840144e-15 8.88178420e-16 1.22124533e-14 1.09912079e-14\n", + " 2.55351296e-15 3.62210262e-15]\n" + ] + }, { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 48, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, @@ -143,33 +205,35 @@ "import pvlib\n", "\n", "v_pvl = V_pvm\n", - "i_pvl_brentq = pvlib.pvsystem.i_from_v(resistance_shunt, resistance_series, nNsVth, V_pvm, saturation_current, photocurrent,\n", + "i_pvl_brentq = pvlib.pvsystem.i_from_v(resistance_shunt, resistance_series, nVth, V_pvm, saturation_current, photocurrent,\n", " method='brentq')\n", - "i_pvl_newton = pvlib.pvsystem.i_from_v(resistance_shunt, resistance_series, nNsVth, V_pvm, saturation_current, photocurrent,\n", + "i_pvl_newton = pvlib.pvsystem.i_from_v(resistance_shunt, resistance_series, nVth, V_pvm, saturation_current, photocurrent,\n", " method='newton')\n", - "i_pvl_lambertw = pvlib.pvsystem.i_from_v(resistance_shunt, resistance_series, nNsVth, V_pvm, saturation_current, photocurrent,\n", + "i_pvl_lambertw = pvlib.pvsystem.i_from_v(resistance_shunt, resistance_series, nVth, V_pvm, saturation_current, photocurrent,\n", " method='lambertw')\n", "\n", + "print(np.abs(I_pvm - i_pvl_lambertw))\n", + "\n", "plt.plot(v_pvl, i_pvl_brentq)\n", - "plt.plot(v_pvl, i_pvl_lambertw)\n", - "plt.plot(v_pvl, i_pvl_newton)" + "plt.plot(v_pvl, i_pvl_newton)\n", + "plt.plot(v_pvl, i_pvl_lambertw)" ] }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "1.763860724146582e-10\n" + "1.5987211554602254e-14\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -184,27 +248,28 @@ "plt.plot(v_pvl, np.abs(i_pvl_brentq - I_pvm))\n", "plt.plot(v_pvl, np.abs(i_pvl_newton - I_pvm))\n", "plt.plot(v_pvl, np.abs(i_pvl_lambertw - I_pvm))\n", - "print(np.max(np.abs(i_pvl_lambertw - i_pvl_brentq)))" + "plt.legend(['brentq', 'newton', 'lambertw'])\n", + "print(np.max(np.abs(i_pvl_lambertw - I_pvm)))" ] }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 46, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -216,12 +281,14 @@ } ], "source": [ - "plt.plot(V_pvm, (I_pvm - i_pvl_brentq) / I_pvm)" + "plt.plot(V_pvm, (I_pvm - i_pvl_brentq) / I_pvm)\n", + "plt.plot(V_pvm, (I_pvm - i_pvl_newton) / I_pvm)\n", + "plt.plot(V_pvm, (I_pvm - i_pvl_lambertw) / I_pvm)" ] }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -235,7 +302,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAERCAYAAAB7FtAjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xt4VNW9//H3NyEQEAJyUauAQUW5BoQACmJVPEprxZ4Wq61a/aml1fZYa/t4qb+etp7zs7ZYsT6tB7HeTotYUSnW1rsgICAFFeQiohIxYBFQwCAgId/fH7MTkklIhjCz957M5/U8eTJ7z85a3xlxvrPW2mstc3dERETyog5ARETiQQlBREQAJQQREQkoIYiICKCEICIiASUEEREBsjAhmNn9ZvaRmS1PU3nPmNlWM3sq6XwvM3vVzNaY2V/MrHU66hMRiausSwjAg8DYNJY3EbikgfO/Bia5e2/gE+CKNNYpIhI7WZcQ3H0O8HHtc2Z2bPBNf4mZzTWzPgdQ3ovAp0nlGXAG8Fhw6iHgqwcXuYhIvLWKOoA0mQJ8z93XmNkI4G4SH+jN1QXY6u6VwXE5cNRBxigiEmtZnxDMrD0wEpie+GIPQJvgua8BtzTwZ+vd/ezGim3gnNb4EJEWLesTAolur63uPjj5CXd/AniiGWVuBjqZWaugldAd2HBwYYqIxFvWjSEkc/ftwFozOx8S/f9mNuggy3RgFjA+OHUpMPOgAhURiTnLttVOzWwacBrQFdgI/Bx4Cfgf4AtAAfCIuzfUVdRQeXOBPkB7YAtwhbs/a2bHAI8AnYHXgYvdfXd6X42ISHxkXUIQEZHMyPouIxERSY+sGlTu2rWrFxcXRx2GiEhWWbJkyWZ379bUdVmVEIqLi1m8eHHUYYiIZBUzez+V69RlJCIigBKCiIgElBBERATIsjGEhuzZs4fy8nJ27doVdSgtQmFhId27d6egoCDqUEQkZFmfEMrLy+nQoQPFxcXUWstImsHd2bJlC+Xl5fTq1SvqcEQkZFnfZbRr1y66dOmiZJAGZkaXLl3U2hLJUVmfEAAlgzTSeymSu1pEQhARaaleWLmRjdvDabUrIaRBWVkZAwYMyEi5Dz/8cNrLFZHsceX/Lmb85Pmh1KWEEJK9e/ce8N8oIYjkturFRz/4eGco9SkhpEllZSWXXnopJSUljB8/ns8++4zi4mJuueUWTjnlFKZPn867777L2LFjGTp0KKNHj+att94C4LLLLuOaa65h5MiRHHPMMTz2WGIr5xtvvJG5c+cyePBgJk2axM6dO7nwwgspKSnhggsuYMSIEVrKQ6QFC3sx6qy/7bS2X/5tBSs3bE9rmf2OLOLn5/Zv8rrVq1dz3333MWrUKC6//HLuvvtuIHFf/7x58wAYM2YMkydPpnfv3rz66qtcffXVvPTSSwB8+OGHzJs3j7feeotx48Yxfvx4brvtNm6//XaeeuopAO644w7atWvHsmXLWLZsGUOGDEnraxWR3NaiEkKUevTowahRowC4+OKLueuuuwC44IILAKioqGD+/Pmcf/75NX+ze/e+/Xa++tWvkpeXR79+/di4cWODdcyZM4drrrkGgJKSEkpKSjLyWkQkHsLeraZFJYRUvslnSvLtmtXHhxxyCABVVVV06tSJN954o8G/b9OmTc3jxjYt0m2hIrkj7A3MNIaQJuvWrWPBggUATJs2jVNOOaXO80VFRfTq1Yvp06cDif/QS5cubbTMDh068Omnn9Ycn3rqqUydOhWA5cuXs2zZsnS+BBGJmbBbCEoIadK3b18eeughSkpK+Pjjj7nqqqvqXTN16lTuu+8+Bg0aRP/+/Zk5c2ajZZaUlNCqVSsGDRrEpEmTuOqqq6ioqKCkpITf/OY3DB8+PFMvR0RyUIvqMopKcXExK1eurHe+rKysznGvXr145pln6l334IMP1jmuqKgAoKCggBdffLHOc4888kjN49NOO615AYtIVgj7LiO1EEREYspD7jRSCyGLzZ49O+oQRCSDcq6FYGb5Zva6mT0VdSwiIrks8oQA/BBYFXUQIiK5LtKEYGbdgXOAP0YZh4hIHOVal9GdwPVA1f4uMLMJZrbYzBZv2rQpvMhERCIW9qByZAnBzL4CfOTuSxq7zt2nuHupu5d269YtpOiiNXv2bObPD2e5WxGRalG2EEYB48ysDHgEOMPM/hxhPLGhhCAikENdRu5+k7t3d/di4ELgJXe/OKp4DkZZWRl9+/blO9/5Dv379+ess85i586dDS53vXfvXo455hjcna1bt5KXl8ecOXMAGD16NO+88w6TJ09m0qRJDB48mLlz5/L+++8zZswYSkpKGDNmDOvWrQP2v2y2iLQMWtzuYDx9I/zrzfSWecRA+NJtTV62Zs0apk2bxr333ss3vvENHn/8cR544IEGl7s+/vjjWblyJWvXrmXo0KHMnTuXESNGUF5eznHHHcf3vvc92rdvz09+8hMAzj33XL797W9z6aWXcv/993PNNdfw17/+FWh42WwRaRnCXtwuFgnB3WcDsyMO46D06tWLwYMHAzB06FDKysr2u9z16NGjmTNnDmvXruWmm27i3nvv5Ytf/CLDhg1rsOwFCxbwxBNPAHDJJZdw/fXX1zyXyrLZIiKpiEVCSJsUvslnSu3lq/Pz89m4ceN+l7sePXo0kydPZsOGDdxyyy1MnDiR2bNnc+qpp6ZUV+0lsFNdNltEso9WO20hGlvuesSIEcyfP5+8vDwKCwsZPHgw99xzD6NHjwbqL3s9cuTImkXtpk6dWm9pbRFpmXJmUDkX7G+56zZt2tCjRw9OOukkINFi+PTTTxk4cCCQGDOYMWNGzaDyXXfdxQMPPEBJSQl/+tOf+N3vfhfZaxKREIWcECybuhlKS0s9eVP5VatW0bdv34giapn0norEw7bP9jDolucAKLvtnGaXY2ZL3L20qevUQhARiamcmaksIiKN0xiCiIgAustIREQiooQgIhJTYd/0o4QgIhIT7s6vnl7Fig3bEsch16+EkAbt27dPSzm/+MUvuP322w+qjFtvvbXm8Y9+9CPuvPPOmuOzzz6bK6+8sub4xz/+MXfcccdB1Sci6bPj873c8/J7XHDPQkCDytJM7k5VVVWdhDBy5MiaZbSrqqrYvHkzK1asqHl+/vz5jBo1KvRYRaRhVRHPC1NCSKOKigrGjBnDkCFDGDhwYM3M5LKyMvr06cOVV17JgAEDuOiii3jhhRcYNWoUvXv3ZtGiRTVlLF26lDPOOIPevXtz77331pyfOHEiw4YNo6SkhJ///Oc15fbt25err76aIUOGcMUVV7Bz504GDx7MRRddxKhRo2oSwooVKxgwYAAdOnTgk08+Yffu3axatYoTTzwxxHdIRFJRvVpZ2PMQWtTidr9e9Gve+vittJbZp3Mfbhh+Q0rXFhYWMmPGDIqKiti8eTMnnXQS48aNA+Cdd95h+vTpTJkyhWHDhvHwww8zb948nnzySW699daa5ayXLVvGwoUL2bFjByeeeCLnnHMOy5cvZ82aNSxatAh3Z9y4ccyZM4eePXuyevVqHnjgAe6++24Apk+fXmdBvVatWrFu3Trmz5/PySefzPr161mwYAEdO3akpKSE1q1bp/X9EpHmq2kg7MsIoWpRCSFq7s5Pf/pT5syZQ15eHuvXr69ZkrpXr141axX179+fMWPGYGYMHDiQsrKymjLOO+882rZtS9u2bTn99NNZtGgR8+bN47nnnqv5Nl9RUcGaNWvo2bMnRx99dM2aSA2pbiXMnz+f6667jvXr1zN//nw6duzIyJEjM/dmiMgBq76rKKJ80LISQqrf5DNl6tSpbNq0iSVLllBQUEBxcTG7du0C6i5TnZeXV3Ocl5dHZWVlzXO1l7auPnZ3brrpJr773e/Wea6srIxDDjmk0ZiqxxHefPNNBgwYQI8ePfjtb39LUVERl19++UG9XhHJjOTPgbBoDCGNtm3bxmGHHUZBQQGzZs3i/fffP+AyZs6cya5du9iyZQuzZ89m2LBhnH322dx///1UVFQAsH79ej766KMG/76goIA9e/bUHI8aNYqnnnqKzp07k5+fT+fOndm6dSsLFizg5JNPbt4LFZGMqO4yqs4HYY8xt6gWQtQuuugizj33XEpLSxk8eDB9+vQ54DKGDx/OOeecw7p16/jZz37GkUceyZFHHsmqVatqPsDbt2/Pn//8Z/Lz8+v9/YQJEygpKWHIkCFMnTqVgQMHsnnzZr71rW/VXDNw4EAqKiro2rVr81+siKRd/SGEcDOClr+WevSeikRjS8Vuhv73CxzaroDX//MsNmzdycjbXgJa+PLXZlZoZovMbKmZrTCzX0YVi4hIHFR/Pc+LaAwhyi6j3cAZ7l5hZgXAPDN72t0XRhiTiEhk6o0hhFx/ZC0ET6gIDguCn2a9/mzq9oo7vZci0UkeM8ipxe3MLN/M3gA+Ap5391cbuGaCmS02s8WbNm2qV0ZhYSFbtmzRB1kauDtbtmyhsLAw6lBEclyiiZBTdxm5+15gsJl1AmaY2QB3X550zRRgCiQGlZPL6N69O+Xl5TSULOTAFRYW0r1796jDEMlNSV1GYYvFbafuvtXMZgNjgeVNXF5HQUEBvXr1ykhcIiJhqqpOCBHVH+VdRt2ClgFm1hY4E0jvQkQiIlkoFyemfQF4yMzySSSmR939qQjjERGJVPWgslWPIeTKaqfuvgzQ2ssiIoGqiMcQtJaRiEhMJN8tqR3TRERyVHUCqJ6pnDMT00REpK7kFkFOTUwTEZF9wh5ETqaEICISEzm7lpGIiNRVVb2FZkTzEJQQRERiYt8GOdHsqqyEICISE8ldRmFTQhARiYnqu4pq2gfqMhIRyU01XUaahyAiktvqz0MIt34lBBGRmKhZ3E5jCCIiua2qKvF73z1GustIRCQn1d9TOdz6m0wIZnZ+KudEROTg1FvcLm4JAbgpxXMiInIQop6HsN8NcszsS8CXgaPM7K5aTxUBlZkOTEQk19TrMorRjmkbgMXAOGBJrfOfAj/KZFAiIrmopoVANF1G+00I7r4UWGpmD7v7nhBjEhHJScmL24UtlTGE4Wb2vJm9bWbvmdlaM3vvYCs2sx5mNsvMVpnZCjP74cGWKSKSzaLdDaHxLqNq95HoIloC7E1j3ZXAj939NTPrACwxs+fdfWUa6xARyRr7BpVj1mVUyzZ3fzrdFbv7h8CHweNPzWwVcBSghCAiOane4nYxGlSuNsvMJgJPALurT7r7a+kKwsyKgROBVxt4bgIwAaBnz57pqlJEJHb2LW4XHMewhTAi+F1a65wDZ6QjADNrDzwOXOvu25Ofd/cpwBSA0tLSqLvYREQyJuwEkKzJhODup2eqcjMrIJEMprr7E5mqR0QkG1R3GeXFdflrMzvczO4zs6eD435mdsXBVmyJUZP7gFXufsfBliciku2qkmYqe8hNhlRuO30QeBY4Mjh+G7g2DXWPAi4BzjCzN4KfL6ehXBGRrFR/pnK4UhlD6Oruj5rZTQDuXmlmB337qbvPY99guoiI1MxUjkYqLYQdZtaFIFQzOwnYltGoRERyUFXSbUZxvMvoOuBJ4FgzewXoBozPaFQiIjmoZse0WmfC1GhCMLM8oBD4InACiThXa20jEZH0S17+OlYtBHevMrPfuvvJwIqQYhIRyUlVntxCCFcqYwjPmdnXzaJaf09EJDfsG0KIZh5CqmMIhwCVZraLRPJydy/KaGQiIrkm6S6jWHUZBa2C/u6+LqR4RERyVvJ+CLGamOaJaGaEFIuISE5L3jEtbKmMISw0s2EZj0REJMcltwfiOIZwOvBdM3sf2MG+MYSSjEYmIpJj3OsOIsRqDCHwpYxHISIi+xa3C47juEGO9iAQEQlF3UHlsKWSEP5OIkojMWu5F7Aa6J/BuEREck69QeW4dRm5+8Dax2Y2BPhuxiISEclR9fZDCLn+VO4yqiPYS1l3HYmIpJmTPA8h3PqbbCGY2XW1DvOAIcCmjEUkIpKjop6HkMoYQodajytJjCk8nplwRERyV72ZynG7y8jdfxlGICIiUlfYXUZNjiGY2fNm1qnW8aFm9mw6Kjez+83sIzNbno7yRESy2b79EKJZ7TSVQeVu7r61+sDdPwEOS1P9DwJj01SWiEhWy4b9EPaaWc/qAzM7mjQlLnefA3ycjrJERLJd/R3TYjaGANwMzDOzl4PjU4EJmQtJRCQ3xX5xO3d/JpiMdhKJlsyP3H1zxiMLmNkEggTUs2fPJq4WEclentxlFLd5CABBAngqw7Hsr+4pwBSA0tJSraskIi1W8qBy2A54prKIiGRGzUzlpOOwRJoQzGwasAA4wczKzeyKKOMREYlS/UHlcOtPqcvIzPKBw2tfn459lt39mwdbhohIS1FVkwCCeQhxSwhm9h/Az4GNQFVw2gHtmCYikkbJi9uFLZUWwg+BE9x9S6aDERHJZUk7aMZypvIHwLZMByIikus8eXG7GE5Mew+YbWZ/B3ZXn3T3OzIWlYhIDqr++K9e/jp2E9OAdcFP6+BHREQyIPkuo7Bp+WsRkZiotx9CXO4yMrM73f1aM/sbDbRc3H1cRiMTEckx9RNAfMYQ/hT8vj2MQEREcl29MYS4tBDcfUnw++X9XSMiIunjyfedhkxrGYmIxEQ2zEMQEZEQ7JupHE2XUaMJwczyzWxiWMGIiOSy+i2EGK126u57gaEW1eLcIiI5pCru8xCA14GZZjYd2FF90t2fyFhUIiI5qN5+CLUaCO6e8Y1zUkkInYEtwBm1zjmghCAikkbJO6bV7jDaXVlFYUF+RutPZaby/8loBCIiAtTfU7n24nZhJIQm7zIys+5mNsPMPjKzjWb2uJl1z2hUIiI5yPfNTKtnd+XejNefym2nDwBPAkcCRwF/C86JiEgaJc9Urm33nqp659ItlYTQzd0fcPfK4OdBoFuG4xIRyTmNLW4XlxbCZjO7OJiTkG9mF5MYZD5oZjbWzFab2TtmdmM6yhQRSac/zn2Pq/685MA2q9m1DTavgW3lsHdPyn+WXEXteQi7QmghpHKX0eXA74FJJFo084NzB8XM8oE/AP8GlAP/NLMn3X3lwZYtIpIuL7+9iblrNvPy25s47YTDGr5o51YomwdrX4b3ZsPmt/c917o9HHsGnPBl6P1vcEjX/dbVyBACuysjTgjBh/bXM7TU9XDgHXd/L6jrEeA8IO0J4bWVL7N+85r0FZjWyYNhr1ZyoNIXn6X7taZ9Xn+M/1ukPbQ0FthC/zu0K8inS/vWtN/+LkPa7ebxZ+dTUX4E+Xt3UZS3k/ZVFXy+eS2+5V1a71iPeRVV+W34rEt/dg66nD1tu5K3dzeF296j/YZFtHrvGXgadhX14rOug9jdoQd723TE81rXZIBt67cysO1W2u44lKXLlrOhbDN92/4LgO3bewCHZvQ1N5oQ3H2vmZ1HonWQbkeR2K+5WjkwIgP18OArv2RW602ZKFpEWrrOiZ81wOzyBp4vAopqtxw2wPYNsL12Ga2BI4KDnbBrYeInmQHFUAbMeD04V5z49cEHHWFgSXNfRUpS6TJ6xcx+D/yFujOVXzvIuhtqFdX7amBmE4AJAD179mxWRecPvZbSjXHuiUr37MO4l5dGaZ+5mb7yPMZvW0IaA0zzfweP+N/cpk9388Kqj7hoeE+mLlrH6N5dKe5yCJVVVazdupd/rK7g26f1587Z6zi73xEM6F50QOVb1R4Kdn1Cqz2fYl6JOYCDO9OXlDPgyCI+3rGbzyv3cnb/w+nWoTUlvc/JyGutLZWEMDL4fUutc07dmcvNUQ70qHXcHdiQfJG7TwGmAJSWljarLTl6yDhGow3eRCQ1ZZt38Id/zmZ7q+NZXfE23y4ewEUjjgZg/dadPPTaS/zjtSL27mjLtaecyvGHd0hb3fcsfYmtrTvy/Jp/8YPTj+PCs05IW9lNaWoMIQ/4H3d/NAN1/xPobWa9gPXAhcC3MlCPiMgB+UKnQgBeX7cVgMM6FNY8d1SntvTs3I5VH26n8yGt6X1Y+7TXv+7jz6hy6J3GRJOKplY7rQJ+kImK3b0yKPtZYBXwqLuvyERdIiIHok2rfA7r0IY3PqhOCG3qPH/SMZ1rfmdiwbkPPv4MgJ6d26W97MakMg/heTP7iZn1MLPO1T/pqNzd/+Hux7v7se7+/9JRpohIOhx1aFu27PgcgMOKkhNClzq/08kMtu+qBODwosImrk6vVOchAHy/1jkHjkl/OCIi8XBUp7a8vm4rZtC1fd2EcGa/w/nm8B6cM/ALGY2hU7uCjJafLJXVTnuFEYiISJwcdWhbADq3a01Bft3OlKLCAn71tczcAlrdA9W6VV7GVzdNtt8uIzO7vtbj85OeuzWTQYmIRO2oTomE0C1p/CAsndqG2zqAxscQLqz1+Kak58ZmIBYRkdiIOiEUxSwh2H4eN3QsItKiVHcZ1b7lNAzVS1+3ax1udxE0nhB8P48bOhYRaVGqWwiHF0XTQgh7/AAaH1QeZGbbSbQG2gaPCY7DTZkiIiHrUFjAxPElGbm1tDHVg8pt45QQ3D38aEREYuT80h5NX5QhUSSEVCamiYhIyNrGbAxBRERCVn3HThRjCEoIIiIxVFgQ/sezEoKISIxUL5bXupUSgohITvNgS9LW+UoIIiI5ba8SgoiIAFTuTSSEAnUZiYjktj17qwDqrbAaBiUEEZEY+bwykRBa54e/ZJwSgohIjFRWBV1GaiGIiOS2nOsyMrPzzWyFmVWZWWkUMYiIxNGeHBxUXg58DZgTUf0iIrEWxRhCk3sqZ4K7r4J9M/JERKSunOkyOhBmNsHMFpvZ4k2bNkUdjohIKFpFkBAy1kIwsxeAIxp46mZ3n5lqOe4+BZgCUFpaqp3aRCQntMprQV1G7n5mpsoWEWnp8iLoUo99l5GISC7Kj6CFENVtp/9uZuXAycDfzezZKOIQEYmrCIYQIrvLaAYwI4q6RUSyQX6e7jISEREgX2MIIiICEEEDQQlBRCSOcmZQWUREGqcuIxERASBPLQQREQG1EEREJKAxBBERAdRlJCIigSgWt1NCEBGJIS1uJyIigMYQREQkoLuMREQE0NIVIiISUJeRiIgAGlQWEZGAWggiIgJoUFlERAKaqSwiIpGJJCGY2UQze8vMlpnZDDPrFEUcIiKyT1QthOeBAe5eArwN3BRRHCIiEogkIbj7c+5eGRwuBLpHEYeIiOwThzGEy4Gn9/ekmU0ws8VmtnjTpk0hhiUikltaZapgM3sBOKKBp25295nBNTcDlcDU/ZXj7lOAKQClpaWegVBFRIQMJgR3P7Ox583sUuArwBh31we9iEjEMpYQGmNmY4EbgC+6+2dRxCAiInVFNYbwe6AD8LyZvWFmkyOKQ0REApG0ENz9uCjqFRGR/YvDXUYiIhIDSggiIgIoIYiISEAJQUREACUEEREJKCGIiAighCAiIgElBBERAZQQREQkoIQgIiKAEoKIiAQiWctIREQaNvnioRTkWyR1KyGIiMTI2AEN7SsWDnUZiYgIoIQgIiIBJQQREQGUEEREJKCEICIigBKCiIgElBBERARQQhARkYC5e9QxpMzMNgHvp3h5V2BzBsPJhGyLOdviBcUcFsUcjlRjPtrduzV1UVYlhANhZovdvTTqOA5EtsWcbfGCYg6LYg5HumNWl5GIiABKCCIiEmjJCWFK1AE0Q7bFnG3xgmIOi2IOR1pjbrFjCCIicmBacgtBREQOgBKCiIgAWZ4QzGysma02s3fM7MYGnm9jZn8Jnn/VzIrDj7JeTE3FfKqZvWZmlWY2PooYk6UQ83VmttLMlpnZi2Z2dBRxJsXUVMzfM7M3zewNM5tnZv2iiDMppkZjrnXdeDNzM4v8FskU3ufLzGxT8D6/YWZXRhFnUkxNvs9m9o3g3/QKM3s47BgbiKep93lSrff4bTPb2qyK3D0rf4B84F3gGKA1sBTol3TN1cDk4PGFwF+yIOZioAT4X2B8lrzPpwPtgsdXZcn7XFTr8TjgmbjHHFzXAZgDLARK4x4zcBnw+yjjbEbMvYHXgUOD48PiHnPS9f8B3N+curK5hTAceMfd33P3z4FHgPOSrjkPeCh4/Bgwxsyi2aw0ocmY3b3M3ZcBVVEE2IBUYp7l7p8FhwuB7iHHmCyVmLfXOjwEiPruilT+PQP8F/AbYFeYwe1HqjHHSSoxfwf4g7t/AuDuH4UcY7IDfZ+/CUxrTkXZnBCOAj6odVwenGvwGnevBLYBXUKJrmGpxBw3BxrzFcDTGY2oaSnFbGbfN7N3SXzAXhNSbPvTZMxmdiLQw92fCjOwRqT6b+PrQXfiY2bWI5zQ9iuVmI8HjjezV8xsoZmNDS26hqX8/2DQXdsLeKk5FWVzQmjom37yt7xUrglT3OJJRcoxm9nFQCkwMaMRNS2lmN39D+5+LHAD8H8zHlXjGo3ZzPKAScCPQ4uoaam8z38Dit29BHiBfS32qKQScysS3Uankfi2/Ucz65ThuBpzIJ8bFwKPufve5lSUzQmhHKj9baM7sGF/15hZK6Aj8HEo0TUslZjjJqWYzexM4GZgnLvvDim2/TnQ9/kR4KsZjahpTcXcARgAzDazMuAk4MmIB5abfJ/dfUutfw/3AkNDim1/Uv3cmOnue9x9LbCaRIKIyoH8e76QZnYXAVk9qNwKeI9E86h6oKV/0jXfp+6g8qNxj7nWtQ8Sj0HlVN7nE0kMevWOOt4DiLl3rcfnAovjHnPS9bOJflA5lff5C7Ue/zuwMAtiHgs8FDzuSqK7pkucYw6uOwEoI5hw3Ky6ovyPk4Y36svA28GH0c3BuVtIfEsFKASmA+8Ai4BjsiDmYSS+EewAtgArsiDmF4CNwBvBz5NZEPPvgBVBvLMa+/CNS8xJ10aeEFJ8n38VvM9Lg/e5TxbEbMAdwErgTeDCuMccHP8CuO1g6tHSFSIiAmT3GIKIiKSREoKIiABKCCIiElBCEBERQAlBREQCSgiSs8xstpmdnXTuWjO7ez/XF5vZ8uDxYDP7chhxioRFCUFy2TQSExZrS3Wm52AS94aLtBhKCJLLHgO+YmZtINECAI4E5pnZRDNbHuyZcEGroS/EAAAB7UlEQVTtPzKz1iQmBV0QrD9/gZkNN7P5ZvZ68PuE4Np2ZvZosLjbX4J9OUqD584yswXB/hfTzax9iK9dpJ5WUQcgEhV332Jmi0gsVTCTYM8M4GskWgCDSCxd8E8zm1Pr7z43s/8kMVP4BwBmVgSc6u6VwbpOtwJfJ7EnxyfuXmJmA0jMjMbMupJYUO9Md99hZjcA15FINCKRUEKQXFfdbVSdEC4HLgGmeWLFyI1m9jKJJUWWNVJOR+AhM+tNYiXKguD8KSSWycDdl5tZdRknAf2AV4ItOloDC9L4ukQOmLqMJNf9lcTGSUOAtu7+Gg0vN9yU/wJmufsAEovlFQbn91eWAc+7++Dgp5+7X9GMekXSRglBcpq7V5BYKO5+9g0mzyExPpBvZt2AU0ksjljbpySWpK7WEVgfPL6s1vl5wDcAgn2bBwbnFwKjzOy44Ll2ZnZ8Gl6SSLMpIYgkEsEgEvsiAMwg0T20lMTOU9e7+7+S/mYW0K96UJnErmu/MrNXSOyBW+1uoFvQVXRDUO42d99EInFMC55bCPTJxIsTSZVWOxXJIDPLBwrcfZeZHQu8CBzvib1xRWJFg8oimdUOmGVmBSTGDa5SMpC4UgtBREQAjSGIiEhACUFERAAlBBERCSghiIgIoIQgIiKB/w8xS8+YOJWOogAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -254,16 +321,16 @@ " return iph - io * np.expm1((v + i * rs) / nNsVth) - (v + i * rs) / rsh - i\n", "\n", "i_resid_lambertw = sde_resid(v_pvl, i_pvl_lambertw, iph=photocurrent, io=saturation_current,\n", - " rs=resistance_series, rsh=resistance_shunt, nNsVth=nNsVth)\n", + " rs=resistance_series, rsh=resistance_shunt, nNsVth=nVth)\n", "i_resid_brentq = sde_resid(v_pvl, i_pvl_brentq, iph=photocurrent, io=saturation_current,\n", - " rs=resistance_series, rsh=resistance_shunt, nNsVth=nNsVth)\n", + " rs=resistance_series, rsh=resistance_shunt, nNsVth=nVth)\n", "i_resid_newton = sde_resid(v_pvl, i_pvl_newton, iph=photocurrent, io=saturation_current,\n", - " rs=resistance_series, rsh=resistance_shunt, nNsVth=nNsVth)\n", + " rs=resistance_series, rsh=resistance_shunt, nNsVth=nVth)\n", "\n", "plt.plot(v_pvl, i_resid_brentq)\n", "plt.plot(v_pvl, i_resid_newton)\n", "plt.plot(v_pvl, i_resid_lambertw)\n", - "plt.legend(['Brentq', 'Newton', 'LambertW'])\n", + "plt.legend(['brentq', 'newton', 'lambertW'])\n", "plt.ylabel('Error in current')\n", "plt.xlabel('Voltage')\n", "print(np.max(np.abs(i_resid_brentq)))\n", @@ -273,22 +340,71 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 9, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[4.18332036e-13 4.18332036e-13 1.41179329e+01 2.65394398e+01\n", + " 2.94990578e+01 3.05834944e+01 3.12530092e+01 3.17322097e+01\n", + " 3.21092076e+01 3.24247031e+01 3.26963363e+01 3.29342441e+01\n", + " 3.31462463e+01 3.33383632e+01 3.35152204e+01 3.36803625e+01\n", + " 3.38364987e+01 3.39785595e+01 3.41150955e+01 3.42476392e+01\n", + " 3.43689905e+01 3.44888708e+01 3.46027584e+01 3.47126789e+01\n", + " 3.48201046e+01 3.49223410e+01 3.50240373e+01 3.51203865e+01\n", + " 3.52170039e+01 3.53088833e+01 3.54010016e+01 3.54895269e+01\n", + " 3.55776646e+01 3.56637130e+01 3.57483355e+01 3.58325946e+01\n", + " 3.59141211e+01 3.59971290e+01 3.60759388e+01 3.61566613e+01\n", + " 3.62345531e+01 3.63128457e+01 3.63906054e+01 3.64667898e+01\n", + " 3.65446380e+01 3.66190089e+01 3.66951847e+01 3.67699424e+01\n", + " 3.68445385e+01 3.69199690e+01 3.69932423e+01 3.70682938e+01\n", + " 3.71416084e+01 3.72155496e+01 3.72899139e+01 3.73629731e+01\n", + " 3.74378053e+01 3.75107997e+01 3.75849482e+01 3.76592460e+01\n", + " 3.77329181e+01 3.78083780e+01 3.78819070e+01 3.79570806e+01\n", + " 3.80320990e+01 3.81071785e+01 3.81836733e+01 3.82588434e+01\n", + " 3.83358378e+01 3.84122458e+01 3.84895155e+01 3.85675577e+01\n", + " 3.86452798e+01 3.87248880e+01 3.88033015e+01 3.88835501e+01\n", + " 3.89637571e+01 3.90448195e+01 3.91268299e+01 3.92088771e+01\n", + " 3.92927108e+01 3.93759123e+01 3.94611330e+01 3.95468213e+01\n", + " 3.96331252e+01 3.97202963e+01 3.98083651e+01 3.98973641e+01\n", + " 3.99873263e+01 4.00782783e+01 4.01702493e+01 4.02632846e+01\n", + " 4.03574151e+01 4.04526655e+01 4.05490819e+01 4.06466908e+01\n", + " 4.07455389e+01 4.08456524e+01 4.09470789e+01 4.10498294e+01\n", + " 4.11539730e+01 4.12595411e+01]\n", + "[9.68 9.68 9.65650784 9.63244556 9.60779931 9.58255493\n", + " 9.5566979 9.53021335 9.50308605 9.47530041 9.44684045 9.4176898\n", + " 9.38783169 9.35724897 9.32592405 9.2938389 9.26097509 9.22731372\n", + " 9.19283542 9.15752039 9.12134829 9.08429835 9.04634925 9.00747917\n", + " 8.96766577 8.92688614 8.88511684 8.84233385 8.79851258 8.75362781\n", + " 8.70765375 8.66056395 8.61233134 8.56292819 8.51232608 8.46049593\n", + " 8.40740792 8.35303153 8.29733549 8.24028778 8.18185559 8.12200532\n", + " 8.06070256 7.99791206 7.93359772 7.86772254 7.80024866 7.73113726\n", + " 7.66034862 7.58784203 7.51357579 7.4375072 7.35959253 7.27978695\n", + " 7.1980446 7.11431846 7.0285604 6.94072109 6.85075003 6.75859548\n", + " 6.66420446 6.56752268 6.46849456 6.36706314 6.26317012 6.15675573\n", + " 6.04775881 5.93611666 5.82176509 5.70463836 5.5846691 5.46178834\n", + " 5.33592542 5.20700796 5.07496183 4.93971111 4.80117802 4.6592829\n", + " 4.51394416 4.36507824 4.21259952 4.05642033 3.89645087 3.73259915\n", + " 3.56477095 3.39286976 3.21679675 3.03645067 2.85172781 2.66252195\n", + " 2.4687243 2.27022343 2.06690518 1.85865265 1.6453461 1.42686285\n", + " 1.20307729 0.97386073 0.73908137 0.49860421 0.25229096 0. ]\n" + ] + }, { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 67, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -302,28 +418,1098 @@ "source": [ "Vmod = pv_mod.Vmod\n", "Imod = pv_mod.Imod\n", - "Voc = pv_mod.Voc.sum()\n", - "Imod = Imod[(Vmod>=0) & (Vmod<=Voc)]\n", - "Vmod = Vmod[(Vmod>=0) & (Vmod<=Voc)]\n", + "# Voc = pv_mod.Voc.sum() # only an estimate of Voc, not precise\n", + "u = (Vmod>=0.) & (Imod>=0.)\n", + "Imod = Imod[u]\n", + "Vmod = Vmod[u]\n", "\n", + "print(Vmod)\n", + "print(Imod)\n", "plt.plot(Vmod, Imod)" ] }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "Ns = 60\n", + "Imod_brentq = pvlib.pvsystem.i_from_v(resistance_shunt=Ns*resistance_shunt, resistance_series=Ns*resistance_series,\n", + " nNsVth=Ns*nVth, voltage=Vmod, saturation_current=saturation_current,\n", + " photocurrent=photocurrent, method='brentq')\n", + "Imod_newton = pvlib.pvsystem.i_from_v(resistance_shunt=Ns*resistance_shunt, resistance_series=Ns*resistance_series,\n", + " nNsVth=Ns*nVth, voltage=Vmod, saturation_current=saturation_current,\n", + " photocurrent=photocurrent, method='newton')\n", + "Imod_lambertw = pvlib.pvsystem.i_from_v(resistance_shunt=Ns*resistance_shunt, resistance_series=Ns*resistance_series,\n", + " nNsVth=Ns*nVth, voltage=Vmod, saturation_current=saturation_current,\n", + " photocurrent=photocurrent, method='lambertw')\n", + "\n", + "plt.plot(Vmod, Imod)\n", + "plt.plot(Vmod, Imod_brentq)\n", + "plt.plot(Vmod, Imod_newton)\n", + "plt.plot(Vmod, Imod_lambertw)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "Imod_resid_brentq = sde_resid(v=Vmod, i=Imod_brentq, iph=photocurrent, io=saturation_current,\n", + " rs=resistance_series*Ns, rsh=resistance_shunt*Ns, nNsVth=nVth*Ns)\n", + "Imod_resid_newton = sde_resid(v=Vmod, i=Imod_newton, iph=photocurrent, io=saturation_current,\n", + " rs=resistance_series*Ns, rsh=resistance_shunt*Ns, nNsVth=nVth*Ns)\n", + "Imod_resid_lambertw = sde_resid(v=Vmod, i=Imod_lambertw, iph=photocurrent, io=saturation_current,\n", + " rs=resistance_series*Ns, rsh=resistance_shunt*Ns, nNsVth=nVth*Ns)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5,0,'Voltage')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(Vmod, Imod_resid_brentq)\n", + "plt.plot(Vmod, Imod_resid_newton)\n", + "plt.plot(Vmod, Imod_resid_lambertw)\n", + "plt.legend(['brentq', 'newton', 'lambertW'])\n", + "plt.ylabel('Error in current')\n", + "plt.xlabel('Voltage')" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9.679999999999998 9.68003793890756\n", + "9.68003793890756 nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "9.679999999999998 9.68003793890756\n", + "9.68003793890756 nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "9.656507866288223 9.656507875857933\n", + "9.656507875857933 9.602847417869235\n", + "9.602847417869235 74.77147425185561\n", + "74.77147425185561 nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "9.632447839563271 9.632447839572427\n", + "9.632447839572427 9.632447823332367\n", + "9.632447823332367 9.632476643356446\n", + "9.632476643356446 9.581113569662918\n", + "9.581113569662918 26.374824817370367\n", + "26.374824817370367 nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "nan nan\n", + "9.607870921138685 9.607870921142158\n", + "9.607870921142158 9.607870920237211\n", + "9.607870920237211 9.607871156662613\n", + "9.607871156662613 9.607809386593711\n", + "9.607809386593711 9.623926338516613\n", + "9.623926338516613 2.424852480229911\n", + "2.424852480229911 44.19924200722603\n", + "44.19924200722603 nan\n", + "nan nan\n", + "nan nan\n", + "9.58273714779705 9.582737147800772\n", + "9.582737147800772 9.582737147317722\n", + "9.582737147317722 9.582737210032864\n", + "9.582737210032864 9.582729067594773\n", + "9.582729067594773 9.583786125163712\n", + "9.583786125163712 9.44498240087919\n", + "9.44498240087919 17.88487512423844\n", + "17.88487512423844 nan\n", + "nan nan\n", + "nan nan\n", + "9.556708909488558 9.55670890949055\n", + "9.55670890949055 9.556708909322625\n", + "9.556708909322625 9.556708923503773\n", + "9.556708923503773 9.556707725792785\n", + "9.556707725792785 9.55680888107139\n", + "9.55680888107139 9.54825959762687\n", + "9.54825959762687 10.231100372200125\n", + "10.231100372200125 nan\n", + "nan nan\n", + "nan nan\n", + "9.530345299023962 9.530345299026154\n", + "9.530345299026154 9.530345298889253\n", + "9.530345298889253 9.530345307399807\n", + "9.530345307399807 9.530344778349168\n", + "9.530344778349168 9.53037766616269\n", + "9.53037766616269 9.52833289211859\n", + "9.52833289211859 9.65416265016569\n", + "9.65416265016569 nan\n", + "nan nan\n", + "nan nan\n", + "9.503435389900782 9.503435389900673\n", + "9.503435389900673 9.503435389906974\n", + "9.503435389906974 9.50343538959854\n", + "9.50343538959854 9.503435404680319\n", + "9.503435404680319 9.503434667246292\n", + "9.503434667246292 9.503470724454951\n", + "9.503470724454951 9.50170743612706\n", + "9.50170743612706 9.58733748587143\n", + "9.58733748587143 2.6172172098404314\n", + "2.6172172098404314 33.8380659208395\n", + "9.47564077308512 9.475640773086209\n", + "9.475640773086209 9.475640773042556\n", + "9.475640773042556 9.47564077478948\n", + "9.47564077478948 9.475640704859908\n", + "9.475640704859908 9.475643504181813\n", + "9.475643504181813 9.475531444663709\n", + "9.475531444663709 9.48001566520952\n", + "9.48001566520952 9.297913743492542\n", + "9.297913743492542 14.172395825038564\n", + "14.172395825038564 nan\n", + "9.447057141421727 9.447057141423139\n", + "9.447057141423139 9.447057141375543\n", + "9.447057141375543 9.44705714297988\n", + "9.44705714297988 9.447057088876809\n", + "9.447057088876809 9.447058913402353\n", + "9.447058913402353 9.446997384380996\n", + "9.446997384380996 9.449071999094867\n", + "9.449071999094867 9.378723510416112\n", + "9.378723510416112 11.398221200078538\n", + "11.398221200078538 nan\n", + "9.417874793011807 9.417874793012322\n", + "9.417874793012322 9.417874792996809\n", + "9.417874792996809 9.417874793448222\n", + "9.417874793448222 9.417874780338488\n", + "9.417874780338488 9.417875161055063\n", + "9.417875161055063 9.417864104738383\n", + "9.417864104738383 9.418185180842356\n", + "9.418185180842356 9.408854133203734\n", + "9.408854133203734 9.674302864789002\n", + "9.674302864789002 nan\n", + "9.388128396387977 9.388128396388089\n", + "9.388128396388089 9.388128396385369\n", + "9.388128396385369 9.388128396454443\n", + "9.388128396454443 9.388128394697306\n", + "9.388128394697306 9.388128439389856\n", + "9.388128439389856 9.388127302645781\n", + "9.388127302645781 9.38815621539329\n", + "9.38815621539329 9.387420785095257\n", + "9.387420785095257 9.406099472901197\n", + "9.406099472901197 8.91275648043541\n", + "9.357740297458095 9.357740297458138\n", + "9.357740297458138 9.357740297457639\n", + "9.357740297457639 9.35774029746874\n", + "9.35774029746874 9.357740297217834\n", + "9.357740297217834 9.357740302880408\n", + "9.357740302880408 9.357740175086528\n", + "9.357740175086528 9.357743059154144\n", + "9.357743059154144 9.357677970846167\n", + "9.357677970846167 9.359146727676011\n", + "9.359146727676011 9.32591585189279\n", + "9.326559167726055 9.326559167726879\n", + "9.326559167726879 9.326559167710007\n", + "9.326559167710007 9.326559168051215\n", + "9.326559168051215 9.326559161149882\n", + "9.326559161149882 9.326559300739333\n", + "9.326559300739333 9.32655647734088\n", + "9.32655647734088 9.326613584394027\n", + "9.326613584394027 9.325458411654022\n", + "9.325458411654022 9.348782480109067\n", + "9.348782480109067 8.859396850009455\n", + "9.294390232248873 9.294390232249505\n", + "9.294390232249505 9.294390232237765\n", + "9.294390232237765 9.294390232452205\n", + "9.294390232452205 9.294390228534724\n", + "9.294390228534724 9.294390300103181\n", + "9.294390300103181 9.294388992617767\n", + "9.294388992617767 9.294412879046757\n", + "9.294412879046757 9.293976483320426\n", + "9.293976483320426 9.301944277256776\n", + "9.301944277256776 9.154779064729745\n", + "9.261016995443109 9.261016995443551\n", + "9.261016995443551 9.261016995436446\n", + "9.261016995436446 9.261016995554309\n", + "9.261016995554309 9.26101699359744\n", + "9.26101699359744 9.261017026083472\n", + "9.261017026083472 9.261016486782015\n", + "9.261016486782015 9.26102543973321\n", + "9.26102543973321 9.260876809935747\n", + "9.260876809935747 9.263343768988056\n", + "9.263343768988056 9.222265731260986\n", + "9.227947789484704 9.22794778948506\n", + "9.22794778948506 9.227947789479538\n", + "9.227947789479538 9.227947789563515\n", + "9.227947789563515 9.227947788285347\n", + "9.227947788285347 9.227947807742959\n", + "9.227947807742959 9.227947511541005\n", + "9.227947511541005 9.227952020600014\n", + "9.227952020600014 9.227883379184734\n", + "9.227883379184734 9.228928222895531\n", + "9.228928222895531 9.213004194709793\n", + "9.193553152048283 9.193553152048342\n", + "9.193553152048342 9.193553152047453\n", + "9.193553152047453 9.193553152060025\n", + "9.193553152060025 9.193553151883856\n", + "9.193553151883856 9.193553154352607\n", + "9.193553154352607 9.193553119759294\n", + "9.193553119759294 9.193553604495417\n", + "9.193553604495417 9.193546812161172\n", + "9.193546812161172 9.193641988617724\n", + "9.193641988617724 9.192308207130257\n", + "9.157545593039643 9.157545593040131\n", + "9.157545593040131 9.157545593033776\n", + "9.157545593033776 9.157545593115922\n", + "9.157545593115922 9.157545592053332\n", + "9.157545592053332 9.157545605798054\n", + "9.157545605798054 9.157545428008573\n", + "9.157545428008573 9.15754772773323\n", + "9.15754772773323 9.1575179804975\n", + "9.1575179804975 9.157902753493508\n", + "9.157902753493508 9.152923912797917\n", + "9.12217113671625 9.12217113671631\n", + "9.12217113671631 9.122171136715531\n", + "9.122171136715531 9.12217113672505\n", + "9.12217113672505 9.12217113661063\n", + "9.12217113661063 9.122171137986317\n", + "9.122171137986317 9.122171121441959\n", + "9.122171121441959 9.12217132041022\n", + "9.12217132041022 9.122168927548383\n", + "9.122168927548383 9.122197704878184\n", + "9.122197704878184 9.121851610287854\n", + "9.084830593604632 9.084830593604687\n", + "9.084830593604687 9.084830593604215\n", + "9.084830593604215 9.084830593609489\n", + "9.084830593609489 9.084830593550349\n", + "9.084830593550349 9.08483059421248\n", + "9.08483059421248 9.08483058679957\n", + "9.08483058679957 9.084830669792776\n", + "9.084830669792776 9.084829740619904\n", + "9.084829740619904 9.084840143416377\n", + "9.084840143416377 9.08472367517897\n", + "9.047029949053154 9.047029949053186\n", + "9.047029949053186 9.047029949052964\n", + "9.047029949052964 9.047029949055185\n", + "9.047029949055185 9.04702994903215\n", + "9.04702994903215 9.047029949273314\n", + "9.047029949273314 9.047029946749614\n", + "9.047029946749614 9.04702997315757\n", + "9.04702997315757 9.047029696826066\n", + "9.047029696826066 9.047032588343503\n", + "9.047032588343503 9.047002331596948\n", + "9.008284101534425 9.00828410153453\n", + "9.00828410153453 9.008284101533503\n", + "9.008284101533503 9.008284101543548\n", + "9.008284101543548 9.008284101445001\n", + "9.008284101445001 9.008284102411627\n", + "9.008284102411627 9.008284092932143\n", + "9.008284092932143 9.008284185894405\n", + "9.008284185894405 9.008283274241592\n", + "9.008283274241592 9.008292214542099\n", + "9.008292214542099 9.008204539171155\n", + "8.968166297684414 8.968166297684611\n", + "8.968166297684611 8.968166297682835\n", + "8.968166297682835 8.968166297699153\n", + "8.968166297699153 8.96816629754896\n", + "8.96816629754896 8.968166298931779\n", + "8.968166298931779 8.968166286199168\n", + "8.968166286199168 8.968166403437376\n", + "8.968166403437376 8.968165323940767\n", + "8.968165323940767 8.968175263637638\n", + "8.968175263637638 8.968083741122637\n", + "8.92782521473413 8.927825214734227\n", + "8.927825214734227 8.927825214733282\n", + "8.927825214733282 8.92782521474147\n", + "8.92782521474147 8.927825214670397\n", + "8.927825214670397 8.927825215286934\n", + "8.927825215286934 8.927825209938648\n", + "8.927825209938648 8.927825256334055\n", + "8.927825256334055 8.927824853863095\n", + "8.927824853863095 8.927828345217224\n", + "8.927828345217224 8.927798058359226\n", + "8.885515967933845 8.88551596793425\n", + "8.88551596793425 8.885515967930726\n", + "8.885515967930726 8.885515967959588\n", + "8.885515967959588 8.885515967723336\n", + "8.885515967723336 8.885515969655588\n", + "8.885515969655588 8.885515953853092\n", + "8.885515953853092 8.885516083090153\n", + "8.885516083090153 8.885515026155675\n", + "8.885515026155675 8.885523670035266\n", + "8.885523670035266 8.88545297782031\n", + "8.843343382911014 8.843343382911096\n", + "8.843343382911096 8.84334338291043\n", + "8.84334338291043 8.843343382915537\n", + "8.843343382915537 8.843343382876018\n", + "8.843343382876018 8.843343383181871\n", + "8.843343383181871 8.843343380815497\n", + "8.843343380815497 8.843343399123654\n", + "8.843343399123654 8.843343257477763\n", + "8.843343257477763 8.843344353357491\n", + "8.843344353357491 8.843335874799715\n", + "8.798935227578596 8.798935227578836\n", + "8.798935227578836 8.798935227576978\n", + "8.798935227576978 8.798935227590576\n", + "8.798935227590576 8.798935227491029\n", + "8.798935227491029 8.798935228219822\n", + "8.798935228219822 8.79893522288458\n", + "8.79893522288458 8.79893526194131\n", + "8.79893526194131 8.798934976025393\n", + "8.798934976025393 8.798937069081198\n", + "8.798937069081198 8.798921746788583\n", + "8.754666592625247 8.754666592625346\n", + "8.754666592625346 8.754666592624623\n", + "8.754666592624623 8.754666592629675\n", + "8.754666592629675 8.754666592594596\n", + "8.754666592594596 8.754666592838397\n", + "8.754666592838397 8.754666591144423\n", + "8.754666591144423 8.754666602913963\n", + "8.754666602913963 8.754666521140754\n", + "8.754666521140754 8.754667089289445\n", + "8.754667089289445 8.754663141871895\n", + "8.70822001696865 8.708220016968713\n", + "8.708220016968713 8.708220016968436\n", + "8.708220016968436 8.7082200169701\n", + "8.7082200169701 8.708220016959277\n", + "8.708220016959277 8.708220017030628\n", + "8.708220017030628 8.70822001656004\n", + "8.70822001656004 8.70822001966378\n", + "8.70822001966378 8.708219999193116\n", + "8.708219999193116 8.708220134207727\n", + "8.708220134207727 8.708219243715684\n", + "8.661576479608641 8.661576479608616\n", + "8.661576479608616 8.661576479608755\n", + "8.661576479608755 8.66157647960795\n", + "8.66157647960795 8.661576479612918\n", + "8.661576479612918 8.66157647958178\n", + "8.66157647958178 8.661576479777292\n", + "8.661576479777292 8.661576478550272\n", + "8.661576478550272 8.661576486250999\n", + "8.661576486250999 8.661576437922148\n", + "8.661576437922148 8.661576741227524\n", + "8.613122019020697 8.613122019020565\n", + "8.613122019020565 8.61312201902148\n", + "8.61312201902148 8.613122019015986\n", + "8.613122019015986 8.613122019048816\n", + "8.613122019048816 8.61312201885272\n", + "8.61312201885272 8.61312202002435\n", + "8.61312202002435 8.613122013023942\n", + "8.613122013023942 8.613122054851335\n", + "8.613122054851335 8.613121804932474\n", + "8.613121804932474 8.613123298198797\n", + "8.563820761761276 8.563820761761281\n", + "8.563820761761281 8.563820761761281\n", + "8.5133614860916 8.513361486091723\n", + "8.513361486091723 8.513361486091028\n", + "8.513361486091028 8.513361486094858\n", + "8.513361486094858 8.513361486074045\n", + "8.513361486074045 8.513361486187188\n", + "8.513361486187188 8.513361485571847\n", + "8.513361485571847 8.513361488918278\n", + "8.513361488918278 8.513361470719769\n", + "8.513361470719769 8.513361569686175\n", + "8.513361569686175 8.513361031491158\n", + "8.46112305303359 8.461123053033726\n", + "8.461123053033726 8.461123053032948\n", + "8.461123053032948 8.461123053037083\n", + "8.461123053037083 8.46112305301552\n", + "8.46112305301552 8.461123053127583\n", + "8.461123053127583 8.461123052545458\n", + "8.461123052545458 8.461123055568887\n", + "8.461123055568887 8.461123039865992\n", + "8.461123039865992 8.461123121423013\n", + "8.461123121423013 8.461122697835327\n", + "8.40863709519163 8.408637095191688\n", + "8.408637095191688 8.408637095191356\n", + "8.408637095191356 8.408637095193049\n", + "8.408637095193049 8.408637095184668\n", + "8.408637095184668 8.408637095226323\n", + "8.408637095226323 8.40863709501924\n", + "8.40863709501924 8.408637096048277\n", + "8.408637096048277 8.408637090934691\n", + "8.408637090934691 8.408637116345854\n", + "8.408637116345854 8.408636990068835\n", + "8.35319033799328 8.353190337993437\n", + "8.353190337993437 8.35319033799263\n", + "8.35319033799263 8.353190337996406\n", + "8.353190337996406 8.353190337978505\n", + "8.353190337978505 8.353190338063566\n", + "8.353190338063566 8.35319033765936\n", + "8.35319033765936 8.353190339580232\n", + "8.353190339580232 8.353190330451534\n", + "8.353190330451534 8.353190373834835\n", + "8.353190373834835 8.353190167659662\n", + "8.298633260083813 8.298633260083859\n", + "8.298633260083859 8.298633260083692\n", + "8.298633260083692 8.298633260084442\n", + "8.298633260084442 8.298633260081056\n", + "8.298633260081056 8.29863326009643\n", + "8.29863326009643 8.298633260026385\n", + "8.298633260026385 8.298633260345559\n", + "8.298633260345559 8.298633258891167\n", + "8.298633258891167 8.298633265518285\n", + "8.298633265518285 8.298633235320867\n", + "8.240779339915601 8.240779339915685\n", + "8.240779339915685 8.240779339915324\n", + "8.240779339915324 8.240779339916907\n", + "8.240779339916907 8.240779339909997\n", + "8.240779339909997 8.240779339940163\n", + "8.240779339940163 8.240779339808341\n", + "8.240779339808341 8.240779340383915\n", + "8.240779340383915 8.240779337871066\n", + "8.240779337871066 8.240779348841906\n", + "8.240779348841906 8.24077930094396\n", + "8.183025354271432 8.18302535427156\n", + "8.18302535427156 8.18302535427095\n", + "8.18302535427095 8.18302535427353\n", + "8.18302535427353 8.183025354262707\n", + "8.183025354262707 8.183025354308054\n", + "8.183025354308054 8.183025354117982\n", + "8.183025354117982 8.183025354914598\n", + "8.183025354914598 8.183025351576049\n", + "8.183025351576049 8.183025365567374\n", + "8.183025365567374 8.183025306932064\n", + "8.123030778190499 8.123030778190559\n", + "8.123030778190559 8.12303077819031\n", + "8.12303077819031 8.123030778191337\n", + "8.123030778191337 8.123030778187202\n", + "8.123030778187202 8.123030778203825\n", + "8.123030778203825 8.123030778136972\n", + "8.123030778136972 8.123030778405969\n", + "8.123030778405969 8.123030777323647\n", + "8.123030777323647 8.123030781678025\n", + "8.123030781678025 8.123030764159548\n", + "8.061483260095068 8.061483260095072\n", + "8.061483260095072 8.061483260095072\n", + "7.999257030326158 7.999257030326157\n", + "7.999257030326157 7.999257030326157\n", + "7.933673595605406 7.933673595605382\n", + "7.933673595605382 7.933673595605438\n", + "7.933673595605438 7.9336735956052715\n", + "7.9336735956052715 7.933673595605826\n", + "7.933673595605826 7.933673595603828\n", + "7.933673595603828 7.933673595611099\n", + "7.933673595611099 7.93367359558504\n", + "7.93367359558504 7.9336735956781474\n", + "7.9336735956781474 7.9336735953455415\n", + "7.9336735953455415 7.933673596533654\n", + "7.869107157108216 7.8691071571082665\n", + "7.8691071571082665 7.869107157108044\n", + "7.869107157108044 7.869107157108849\n", + "7.869107157108849 7.869107157106046\n", + "7.869107157106046 7.869107157115704\n", + "7.869107157115704 7.86910715708254\n", + "7.86910715708254 7.869107157196545\n", + "7.869107157196545 7.869107156804383\n", + "7.869107156804383 7.869107158153624\n", + "7.869107158153624 7.869107153511486\n", + "7.8010113493737885 7.801011349373807\n", + "7.801011349373807 7.801011349373724\n", + "7.801011349373724 7.801011349374029\n", + "7.801011349374029 7.80101134937303\n", + "7.80101134937303 7.801011349376305\n", + "7.801011349376305 7.801011349365454\n", + "7.801011349365454 7.801011349401503\n", + "7.801011349401503 7.801011349282032\n", + "7.801011349282032 7.801011349677745\n", + "7.801011349677745 7.801011348367191\n", + "7.732229426744791 7.732229426744803\n", + "7.732229426744803 7.732229426744803\n", + "7.661645763444671 7.66164576344478\n", + "7.66164576344478 7.661645763444447\n", + "7.661645763444447 7.6616457634454465\n", + "7.6616457634454465 7.661645763442338\n", + "7.661645763442338 7.661645763451968\n", + "7.661645763451968 7.661645763422301\n", + "7.661645763422301 7.661645763513522\n", + "7.661645763513522 7.661645763232978\n", + "7.661645763232978 7.661645764096006\n", + "7.661645764096006 7.661645761440929\n", + "7.588271383307027 7.588271383307099\n", + "7.588271383307099 7.588271383306848\n", + "7.588271383306848 7.588271383307543\n", + "7.588271383307543 7.588271383305517\n", + "7.588271383305517 7.588271383311539\n", + "7.588271383311539 7.588271383293667\n", + "7.588271383293667 7.588271383346672\n", + "7.588271383346672 7.588271383189541\n", + "7.588271383189541 7.588271383655467\n", + "7.588271383655467 7.588271382273757\n", + "7.515050681406334 7.51505068140641\n", + "7.51505068140641 7.51505068140616\n", + "7.51505068140616 7.5150506814068825\n", + "7.5150506814068825 7.515050681404828\n", + "7.515050681404828 7.515050681410711\n", + "7.515050681410711 7.515050681393866\n", + "7.515050681393866 7.515050681442071\n", + "7.515050681442071 7.515050681304062\n", + "7.515050681304062 7.515050681699193\n", + "7.515050681699193 7.515050680568054\n", + "7.438049434789157 7.438049434789284\n", + "7.438049434789284 7.438049434788923\n", + "7.438049434788923 7.438049434789923\n", + "7.438049434789923 7.438049434787147\n", + "7.438049434787147 7.438049434794834\n", + "7.438049434794834 7.438049434773493\n", + "7.438049434773493 7.438049434832494\n", + "7.438049434832494 7.4380494346695345\n", + "7.4380494346695345 7.4380494351195034\n", + "7.4380494351195034 7.438049433876886\n", + "7.360857738081892 7.360857738081894\n", + "7.360857738081894 7.360857738081894\n", + "7.281018465548653 7.281018465548706\n", + "7.281018465548706 7.281018465548595\n", + "7.281018465548595 7.281018465548873\n", + "7.281018465548873 7.281018465548151\n", + "7.281018465548151 7.2810184655500105\n", + "7.2810184655500105 7.2810184655452375\n", + "7.2810184655452375 7.281018465557532\n", + "7.281018465557532 7.281018465525839\n", + "7.281018465525839 7.281018465607485\n", + "7.281018465607485 7.281018465397126\n", + "7.19869679975272 7.198696799752753\n", + "7.198696799752753 7.198696799752642\n", + "7.198696799752642 7.19869679975292\n", + "7.19869679975292 7.198696799752226\n", + "7.198696799752226 7.198696799753974\n", + "7.198696799753974 7.198696799749617\n", + "7.198696799749617 7.1986967997604685\n", + "7.1986967997604685 7.198696799733494\n", + "7.198696799733494 7.198696799800597\n", + "7.198696799800597 7.1986967996335585\n", + "7.115831549863268 7.115831549863281\n", + "7.115831549863281 7.115831549863281\n", + "7.028903109131381 7.028903109131433\n", + "7.028903109131433 7.028903109131266\n", + "7.028903109131266 7.028903109131683\n", + "7.028903109131683 7.02890310913074\n", + "7.02890310913074 7.028903109132932\n", + "7.028903109132932 7.028903109127826\n", + "7.028903109127826 7.028903109139676\n", + "7.028903109139676 7.028903109112146\n", + "7.028903109112146 7.028903109176142\n", + "7.028903109176142 7.028903109027309\n", + "6.942101338925636 6.942101338925613\n", + "6.942101338925613 6.9421013389256405\n", + "6.9421013389256405 6.942101338925613\n", + "6.942101338925613 6.9421013389256405\n", + "6.9421013389256405 6.942101338925613\n", + "6.942101338925613 6.9421013389256405\n", + "6.9421013389256405 6.942101338925613\n", + "6.942101338925613 6.9421013389256405\n", + "6.9421013389256405 6.942101338925613\n", + "6.942101338925613 6.9421013389256405\n", + "6.851890805930003 6.85189080593005\n", + "6.85189080593005 6.851890805929911\n", + "6.851890805929911 6.851890805930244\n", + "6.851890805930244 6.851890805929495\n", + "6.851890805929495 6.8518908059311325\n", + "6.8518908059311325 6.851890805927607\n", + "6.851890805927607 6.851890805935267\n", + "6.851890805935267 6.85189080591856\n", + "6.85189080591856 6.851890805954915\n", + "6.851890805954915 6.851890805875823\n", + "6.759435369971855 6.759435369971832\n", + "6.759435369971832 6.759435369971888\n", + "6.759435369971888 6.759435369971804\n", + "6.759435369971804 6.759435369971999\n", + "6.759435369971999 6.759435369971555\n", + "6.759435369971555 6.759435369972498\n", + "6.759435369972498 6.7594353699705\n", + "6.7594353699705 6.759435369974746\n", + "6.759435369974746 6.759435369965782\n", + "6.759435369965782 6.759435369984626\n", + "6.665716505489154 6.665716505489176\n", + "6.665716505489176 6.665716505489148\n", + "6.665716505489148 6.665716505489176\n", + "6.665716505489176 6.665716505489148\n", + "6.665716505489148 6.665716505489176\n", + "6.665716505489176 6.665716505489148\n", + "6.665716505489148 6.665716505489176\n", + "6.665716505489176 6.665716505489148\n", + "6.665716505489148 6.665716505489176\n", + "6.665716505489176 6.665716505489148\n", + "6.567613376203953 6.567613376203974\n", + "6.567613376203974 6.567613376203947\n", + "6.567613376203947 6.567613376203974\n", + "6.567613376203974 6.567613376203947\n", + "6.567613376203947 6.567613376203974\n", + "6.567613376203974 6.567613376203947\n", + "6.567613376203947 6.567613376203974\n", + "6.567613376203974 6.567613376203947\n", + "6.567613376203947 6.567613376203974\n", + "6.567613376203974 6.567613376203947\n", + "6.4699666067028865 6.46996660670294\n", + "6.46996660670294 6.469966606702801\n", + "6.469966606702801 6.469966606703023\n", + "6.469966606703023 6.469966606702635\n", + "6.469966606702635 6.469966606703384\n", + "6.469966606703384 6.4699666067019415\n", + "6.4699666067019415 6.469966606704716\n", + "6.469966606704716 6.469966606699388\n", + "6.469966606699388 6.469966606709573\n", + "6.469966606709573 6.469966606690119\n", + "6.368041236636866 6.368041236636903\n", + "6.368041236636903 6.368041236636875\n", + "6.368041236636875 6.368041236636903\n", + "6.368041236636903 6.368041236636875\n", + "6.368041236636875 6.368041236636903\n", + "6.368041236636903 6.368041236636875\n", + "6.368041236636875 6.368041236636903\n", + "6.368041236636903 6.368041236636875\n", + "6.368041236636875 6.368041236636903\n", + "6.368041236636903 6.368041236636875\n", + "6.26421759142268 6.264217591422701\n", + "6.264217591422701 6.264217591422673\n", + "6.264217591422673 6.264217591422701\n", + "6.264217591422701 6.264217591422673\n", + "6.264217591422673 6.264217591422701\n", + "6.264217591422701 6.264217591422673\n", + "6.264217591422673 6.264217591422701\n", + "6.264217591422701 6.264217591422673\n", + "6.264217591422673 6.264217591422701\n", + "6.264217591422701 6.264217591422673\n", + "6.158204624972614 6.158204624972657\n", + "6.158204624972657 6.158204624972546\n", + "6.158204624972546 6.158204624972741\n", + "6.158204624972741 6.158204624972408\n", + "6.158204624972408 6.15820462497299\n", + "6.15820462497299 6.158204624971992\n", + "6.158204624971992 6.158204624973712\n", + "6.158204624973712 6.158204624970687\n", + "6.158204624970687 6.158204624976015\n", + "6.158204624976015 6.158204624966719\n", + "6.048033437801331 6.0480334378013625\n", + "6.0480334378013625 6.048033437801335\n", + "6.048033437801335 6.0480334378013625\n", + "6.0480334378013625 6.048033437801335\n", + "6.048033437801335 6.0480334378013625\n", + "6.0480334378013625 6.048033437801335\n", + "6.048033437801335 6.0480334378013625\n", + "6.0480334378013625 6.048033437801335\n", + "6.048033437801335 6.0480334378013625\n", + "6.0480334378013625 6.048033437801335\n", + "5.9376531453636225 5.937653145363635\n", + "5.937653145363635 5.937653145363635\n", + "5.822427178083322 5.822427178083331\n", + "5.822427178083331 5.822427178083331\n", + "5.7059207582861 5.7059207582861164\n", + "5.7059207582861164 5.705920758286089\n", + "5.705920758286089 5.7059207582861164\n", + "5.7059207582861164 5.705920758286089\n", + "5.705920758286089 5.7059207582861164\n", + "5.7059207582861164 5.705920758286089\n", + "5.705920758286089 5.7059207582861164\n", + "5.7059207582861164 5.705920758286089\n", + "5.705920758286089 5.7059207582861164\n", + "5.7059207582861164 5.705920758286089\n", + "5.585925368761323 5.585925368761308\n", + "5.585925368761308 5.585925368761336\n", + "5.585925368761336 5.585925368761308\n", + "5.585925368761308 5.585925368761336\n", + "5.585925368761336 5.585925368761308\n", + "5.585925368761308 5.585925368761336\n", + "5.585925368761336 5.585925368761308\n", + "5.585925368761308 5.585925368761336\n", + "5.585925368761336 5.585925368761308\n", + "5.585925368761308 5.585925368761336\n", + "5.462522975543738 5.462522975543721\n", + "5.462522975543721 5.462522975543777\n", + "5.462522975543777 5.462522975543666\n", + "5.462522975543666 5.462522975543832\n", + "5.462522975543832 5.46252297554361\n", + "5.46252297554361 5.462522975543916\n", + "5.462522975543916 5.462522975543499\n", + "5.462522975543499 5.462522975544083\n", + "5.462522975544083 5.46252297554325\n", + "5.46252297554325 5.462522975544471\n", + "5.337436270892254 5.3374362708922645\n", + "5.3374362708922645 5.3374362708922645\n", + "5.207063493517305 5.207063493517318\n", + "5.207063493517318 5.207063493517318\n", + "5.07643799938903 5.076437999389028\n", + "5.076437999389028 5.076437999389028\n", + "4.9405037570140085 4.940503757014037\n", + "4.940503757014037 4.940503757014009\n", + "4.940503757014009 4.940503757014037\n", + "4.940503757014037 4.940503757014009\n", + "4.940503757014009 4.940503757014037\n", + "4.940503757014037 4.940503757014009\n", + "4.940503757014009 4.940503757014037\n", + "4.940503757014037 4.940503757014009\n", + "4.940503757014009 4.940503757014037\n", + "4.940503757014037 4.940503757014009\n", + "4.80238378349953 4.802383783499558\n", + "4.802383783499558 4.802383783499531\n", + "4.802383783499531 4.802383783499558\n", + "4.802383783499558 4.802383783499531\n", + "4.802383783499531 4.802383783499558\n", + "4.802383783499558 4.802383783499531\n", + "4.802383783499531 4.802383783499558\n", + "4.802383783499558 4.802383783499531\n", + "4.802383783499531 4.802383783499558\n", + "4.802383783499558 4.802383783499531\n", + "4.6605206224255875 4.660520622425614\n", + "4.660520622425614 4.660520622425587\n", + "4.660520622425587 4.660520622425614\n", + "4.660520622425614 4.660520622425587\n", + "4.660520622425587 4.660520622425614\n", + "4.660520622425614 4.660520622425587\n", + "4.660520622425587 4.660520622425614\n", + "4.660520622425614 4.660520622425587\n", + "4.660520622425587 4.660520622425614\n", + "4.660520622425614 4.660520622425587\n", + "4.51469902471077 4.514699024710763\n", + "4.514699024710763 4.514699024710763\n", + "4.366521747676676 4.366521747676719\n", + "4.366521747676719 4.366521747676636\n", + "4.366521747676636 4.366521747676747\n", + "4.366521747676747 4.366521747676608\n", + "4.366521747676608 4.366521747676747\n", + "4.366521747676747 4.366521747676608\n", + "4.366521747676608 4.366521747676747\n", + "4.366521747676747 4.366521747676608\n", + "4.366521747676608 4.366521747676747\n", + "4.366521747676747 4.366521747676608\n", + "4.212778346685114 4.212778346685158\n", + "4.212778346685158 4.212778346685075\n", + "4.212778346685075 4.212778346685158\n", + "4.212778346685158 4.212778346685075\n", + "4.212778346685075 4.212778346685158\n", + "4.212778346685158 4.212778346685075\n", + "4.212778346685075 4.212778346685158\n", + "4.212778346685158 4.212778346685075\n", + "4.212778346685075 4.212778346685158\n", + "4.212778346685158 4.212778346685075\n", + "4.05788314692865 4.05788314692867\n", + "4.05788314692867 4.057883146928642\n", + "4.057883146928642 4.05788314692867\n", + "4.05788314692867 4.057883146928642\n", + "4.057883146928642 4.05788314692867\n", + "4.05788314692867 4.057883146928642\n", + "4.057883146928642 4.05788314692867\n", + "4.05788314692867 4.057883146928642\n", + "4.057883146928642 4.05788314692867\n", + "4.05788314692867 4.057883146928642\n", + "3.8968709545674525 3.896870954567428\n", + "3.896870954567428 3.8968709545674556\n", + "3.8968709545674556 3.896870954567428\n", + "3.896870954567428 3.8968709545674556\n", + "3.8968709545674556 3.896870954567428\n", + "3.896870954567428 3.8968709545674556\n", + "3.8968709545674556 3.896870954567428\n", + "3.896870954567428 3.8968709545674556\n", + "3.8968709545674556 3.896870954567428\n", + "3.896870954567428 3.8968709545674556\n", + "3.7325998580345017 3.7325998580344866\n", + "3.7325998580344866 3.7325998580345146\n", + "3.7325998580345146 3.7325998580344866\n", + "3.7325998580344866 3.7325998580345146\n", + "3.7325998580345146 3.7325998580344866\n", + "3.7325998580344866 3.7325998580345146\n", + "3.7325998580345146 3.7325998580344866\n", + "3.7325998580344866 3.7325998580345146\n", + "3.7325998580345146 3.7325998580344866\n", + "3.7325998580344866 3.7325998580345146\n", + "3.5647732327373483 3.564773232737334\n", + "3.564773232737334 3.5647732327373616\n", + "3.5647732327373616 3.564773232737334\n", + "3.564773232737334 3.5647732327373616\n", + "3.5647732327373616 3.564773232737334\n", + "3.564773232737334 3.5647732327373616\n", + "3.5647732327373616 3.564773232737334\n", + "3.564773232737334 3.5647732327373616\n", + "3.5647732327373616 3.564773232737334\n", + "3.564773232737334 3.5647732327373616\n", + "3.3928735301808866 3.392873530180884\n", + "3.392873530180884 3.392873530180884\n", + "3.2168023839561464 3.2168023839561677\n", + "3.2168023839561677 3.2168023839561397\n", + "3.2168023839561397 3.2168023839561677\n", + "3.2168023839561677 3.2168023839561397\n", + "3.2168023839561397 3.2168023839561677\n", + "3.2168023839561677 3.2168023839561397\n", + "3.2168023839561397 3.2168023839561677\n", + "3.2168023839561677 3.2168023839561397\n", + "3.2168023839561397 3.2168023839561677\n", + "3.2168023839561677 3.2168023839561397\n", + "3.036456199504477 3.036456199504496\n", + "3.036456199504496 3.0364561995044403\n", + "3.0364561995044403 3.036456199504496\n", + "3.036456199504496 3.0364561995044403\n", + "3.0364561995044403 3.036456199504496\n", + "3.036456199504496 3.0364561995044403\n", + "3.0364561995044403 3.036456199504496\n", + "3.036456199504496 3.0364561995044403\n", + "3.0364561995044403 3.036456199504496\n", + "3.036456199504496 3.0364561995044403\n", + "2.851728292725812 2.851728292725821\n", + "2.851728292725821 2.851728292725821\n", + "2.6625237301719222 2.662523730171929\n", + "2.662523730171929 2.662523730171929\n", + "2.468741322508218 2.4687413225082335\n", + "2.4687413225082335 2.4687413225082055\n", + "2.4687413225082055 2.4687413225082335\n", + "2.4687413225082335 2.4687413225082055\n", + "2.4687413225082055 2.4687413225082335\n", + "2.4687413225082335 2.4687413225082055\n", + "2.4687413225082055 2.4687413225082335\n", + "2.4687413225082335 2.4687413225082055\n", + "2.4687413225082055 2.4687413225082335\n", + "2.4687413225082335 2.4687413225082055\n", + "2.27024409565732 2.2702440956573238\n", + "2.2702440956573238 2.2702440956573238\n", + "2.066922851368873 2.066922851368859\n", + "2.066922851368859 2.0669228513689144\n", + "2.0669228513689144 2.0669228513688314\n", + "2.0669228513688314 2.0669228513689144\n", + "2.0669228513689144 2.0669228513688314\n", + "2.0669228513688314 2.0669228513689144\n", + "2.0669228513689144 2.0669228513688314\n", + "2.0669228513688314 2.0669228513689144\n", + "2.0669228513689144 2.0669228513688314\n", + "2.0669228513688314 2.0669228513689144\n", + "1.8586818002665524 1.8586818002665353\n", + "1.8586818002665353 1.8586818002665353\n", + "1.645376401700064 1.645376401700087\n", + "1.645376401700087 1.6453764017000592\n", + "1.6453764017000592 1.645376401700087\n", + "1.645376401700087 1.6453764017000592\n", + "1.6453764017000592 1.645376401700087\n", + "1.645376401700087 1.6453764017000592\n", + "1.6453764017000592 1.645376401700087\n", + "1.645376401700087 1.6453764017000592\n", + "1.6453764017000592 1.645376401700087\n", + "1.645376401700087 1.6453764017000592\n", + "1.4269031269493535 1.4269031269493277\n", + "1.4269031269493277 1.4269031269493833\n", + "1.4269031269493833 1.4269031269493\n", + "1.4269031269493 1.4269031269493833\n", + "1.4269031269493833 1.4269031269493\n", + "1.4269031269493 1.4269031269493833\n", + "1.4269031269493833 1.4269031269493\n", + "1.4269031269493 1.4269031269493833\n", + "1.4269031269493833 1.4269031269493\n", + "1.4269031269493 1.4269031269493833\n", + "1.2031126046612108 1.2031126046612273\n", + "1.2031126046612273 1.2031126046611997\n", + "1.2031126046611997 1.2031126046612273\n", + "1.2031126046612273 1.2031126046611997\n", + "1.2031126046611997 1.2031126046612273\n", + "1.2031126046612273 1.2031126046611997\n", + "1.2031126046611997 1.2031126046612273\n", + "1.2031126046612273 1.2031126046611997\n", + "1.2031126046611997 1.2031126046612273\n", + "1.2031126046612273 1.2031126046611997\n", + "0.9738995159313504 0.9738995159313818\n", + "0.9738995159313818 0.9738995159313263\n", + "0.9738995159313263 0.9738995159313818\n", + "0.9738995159313818 0.9738995159313263\n", + "0.9738995159313263 0.9738995159313818\n", + "0.9738995159313818 0.9738995159313263\n", + "0.9738995159313263 0.9738995159313818\n", + "0.9738995159313818 0.9738995159313263\n", + "0.9738995159313263 0.9738995159313818\n", + "0.9738995159313818 0.9738995159313263\n", + "0.7391086464810588 0.7391086464810508\n", + "0.7391086464810508 0.7391086464810508\n", + "0.49866748451053056 0.4986674845105386\n", + "0.4986674845105386 0.4986674845105386\n", + "0.2523673899554364 0.25236738995544034\n", + "0.25236738995544034 0.25236738995544034\n", + "8.510551113793952e-05 8.51055111369151e-05\n", + "8.51055111369151e-05 8.51055111369151e-05\n", + "[ nan nan nan nan\n", + " nan nan nan nan\n", + " nan nan nan nan\n", + " nan nan nan nan\n", + " nan nan nan nan\n", + " nan nan nan nan\n", + " nan nan nan nan\n", + " nan nan nan nan\n", + " nan 8.56382076e+00 nan nan\n", + " nan nan nan nan\n", + " nan nan 8.06148326e+00 7.99925703e+00\n", + " nan nan nan 7.73222943e+00\n", + " nan nan nan nan\n", + " 7.36085774e+00 nan nan 7.11583155e+00\n", + " nan nan nan nan\n", + " nan nan nan nan\n", + " nan nan nan 5.93765315e+00\n", + " 5.82242718e+00 nan nan nan\n", + " 5.33743627e+00 5.20706349e+00 5.07643800e+00 nan\n", + " nan nan 4.51469902e+00 nan\n", + " nan nan nan nan\n", + " nan 3.39287353e+00 nan nan\n", + " 2.85172829e+00 2.66252373e+00 nan 2.27024410e+00\n", + " nan 1.85868180e+00 nan nan\n", + " nan nan 7.39108646e-01 4.98667485e-01\n", + " 2.52367390e-01 8.51055111e-05]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\cwhanse\\AppData\\Local\\Continuum\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:2: RuntimeWarning: invalid value encountered in log\n", + " \n" + ] + } + ], + "source": [ + "def _next_current(v, i, iph, io, rsh, rs, nNsVth):\n", + " next_X = np.log((v + iph * rs + io * rs ) / nNsVth - (1 + rs / rsh) * (v + i * rs) / nNsVth) - np.log(io * rs / nNsVth)\n", + " return (nNsVth * next_X - v) / rs\n", + "\n", + "eps = 5e-17\n", + "\n", + "def converge_current(v, i, iph, io, rsh, rs, nNsVth):\n", + " i_conv = np.nan * i\n", + " max_iter = 10\n", + " for k in range(len(i)):\n", + " converged = False\n", + " iter=0\n", + " i_last = i[k]\n", + " while not converged and (iter < max_iter):\n", + " iter += 1\n", + " i_next = _next_current(v[k], i_last, iph, io, rsh, rs, nNsVth)\n", + " print(i_last, i_next)\n", + " converged = np.abs(i_next - i_last) < eps\n", + " i_last = i_next\n", + " if converged:\n", + " i_conv[k] = i_next\n", + " return i_conv\n", + "\n", + "i_conv = converge_current(Vmod, Imod_lambertw, iph=photocurrent, io=saturation_current,\n", + " rsh=resistance_shunt*Ns, rs=resistance_series*Ns, nNsVth=nVth*Ns)\n", + "print(i_conv)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "41.270548514676385\n" + "[4.18332036e-13 4.18332036e-13 1.41179329e+01 2.65394398e+01\n", + " 2.94990578e+01 3.05834944e+01 3.12530092e+01 3.17322097e+01\n", + " 3.21092076e+01 3.24247031e+01 3.26963363e+01 3.29342441e+01\n", + " 3.31462463e+01 3.33383632e+01 3.35152204e+01 3.36803625e+01\n", + " 3.38364987e+01 3.39785595e+01 3.41150955e+01 3.42476392e+01\n", + " 3.43689905e+01 3.44888708e+01 3.46027584e+01 3.47126789e+01\n", + " 3.48201046e+01 3.49223410e+01 3.50240373e+01 3.51203865e+01\n", + " 3.52170039e+01 3.53088833e+01 3.54010016e+01 3.54895269e+01\n", + " 3.55776646e+01 3.56637130e+01 3.57483355e+01 3.58325946e+01\n", + " 3.59141211e+01 3.59971290e+01 3.60759388e+01 3.61566613e+01\n", + " 3.62345531e+01 3.63128457e+01 3.63906054e+01 3.64667898e+01\n", + " 3.65446380e+01 3.66190089e+01 3.66951847e+01 3.67699424e+01\n", + " 3.68445385e+01 3.69199690e+01 3.69932423e+01 3.70682938e+01\n", + " 3.71416084e+01 3.72155496e+01 3.72899139e+01 3.73629731e+01\n", + " 3.74378053e+01 3.75107997e+01 3.75849482e+01 3.76592460e+01\n", + " 3.77329181e+01 3.78083780e+01 3.78819070e+01 3.79570806e+01\n", + " 3.80320990e+01 3.81071785e+01 3.81836733e+01 3.82588434e+01\n", + " 3.83358378e+01 3.84122458e+01 3.84895155e+01 3.85675577e+01\n", + " 3.86452798e+01 3.87248880e+01 3.88033015e+01 3.88835501e+01\n", + " 3.89637571e+01 3.90448195e+01 3.91268299e+01 3.92088771e+01\n", + " 3.92927108e+01 3.93759123e+01 3.94611330e+01 3.95468213e+01\n", + " 3.96331252e+01 3.97202963e+01 3.98083651e+01 3.98973641e+01\n", + " 3.99873263e+01 4.00782783e+01 4.01702493e+01 4.02632846e+01\n", + " 4.03574151e+01 4.04526655e+01 4.05490819e+01 4.06466908e+01\n", + " 4.07455389e+01 4.08456524e+01 4.09470789e+01 4.10498294e+01\n", + " 4.11539730e+01 4.12595411e+01]\n", + "[9.68 9.68 9.65650784 9.63244556 9.60779931 9.58255493\n", + " 9.5566979 9.53021335 9.50308605 9.47530041 9.44684045 9.4176898\n", + " 9.38783169 9.35724897 9.32592405 9.2938389 9.26097509 9.22731372\n", + " 9.19283542 9.15752039 9.12134829 9.08429835 9.04634925 9.00747917\n", + " 8.96766577 8.92688614 8.88511684 8.84233385 8.79851258 8.75362781\n", + " 8.70765375 8.66056395 8.61233134 8.56292819 8.51232608 8.46049593\n", + " 8.40740792 8.35303153 8.29733549 8.24028778 8.18185559 8.12200532\n", + " 8.06070256 7.99791206 7.93359772 7.86772254 7.80024866 7.73113726\n", + " 7.66034862 7.58784203 7.51357579 7.4375072 7.35959253 7.27978695\n", + " 7.1980446 7.11431846 7.0285604 6.94072109 6.85075003 6.75859548\n", + " 6.66420446 6.56752268 6.46849456 6.36706314 6.26317012 6.15675573\n", + " 6.04775881 5.93611666 5.82176509 5.70463836 5.5846691 5.46178834\n", + " 5.33592542 5.20700796 5.07496183 4.93971111 4.80117802 4.6592829\n", + " 4.51394416 4.36507824 4.21259952 4.05642033 3.89645087 3.73259915\n", + " 3.56477095 3.39286976 3.21679675 3.03645067 2.85172781 2.66252195\n", + " 2.4687243 2.27022343 2.06690518 1.85865265 1.6453461 1.42686285\n", + " 1.20307729 0.97386073 0.73908137 0.49860421 0.25229096 0. ]\n" ] } ], "source": [ - "Ns = 60\n" + "print(Vmod)\n", + "print(Imod)" ] }, { diff --git a/pvmismatch/pvmismatch_lib/pvcell.py b/pvmismatch/pvmismatch_lib/pvcell.py index 67ebb0d..db8f552 100644 --- a/pvmismatch/pvmismatch_lib/pvcell.py +++ b/pvmismatch/pvmismatch_lib/pvcell.py @@ -183,11 +183,14 @@ def Aph(self): 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.N1 / self.Vt) - 1.) - Idiode2_sc = self.Isat2 * (np.exp(Vdiode_sc / self.N2 / self.Vt) - 1.) + Idiode1_sc = self.Isat1 * (np.expm1(Vdiode_sc / self.N1 / self.Vt)) + Idiode2_sc = self.Isat2 * (np.expm1(Vdiode_sc / self.N2 / self.Vt)) Ishunt_sc = Vdiode_sc / self.Rsh # diode voltage at SC # photogenerated current coefficient - return 1. + (Idiode1_sc + Idiode2_sc + Ishunt_sc) / self.Isc + if self.diode_model=='2diode': + return 1. + (Idiode1_sc + Idiode2_sc + Ishunt_sc) / self.Isc + else: + return 1. + (Idiode1_sc + Ishunt_sc) / self.Isc @property def Isat1(self): From 2c8b48dcc22c9418626774f705076b1f99c3b996 Mon Sep 17 00:00:00 2001 From: Cliff Hansen Date: Wed, 19 Feb 2020 15:41:07 -0700 Subject: [PATCH 12/16] update notebook --- notebooks/basic_iv_curves.ipynb | 1346 ++++--------------------------- 1 file changed, 177 insertions(+), 1169 deletions(-) diff --git a/notebooks/basic_iv_curves.ipynb b/notebooks/basic_iv_curves.ipynb index d7488dd..48bd01f 100644 --- a/notebooks/basic_iv_curves.ipynb +++ b/notebooks/basic_iv_curves.ipynb @@ -4,14 +4,25 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\cwhanse\\AppData\\Local\\Continuum\\Anaconda3\\lib\\site-packages\\pandas\\compat\\_optional.py:106: UserWarning: Pandas requires version '1.2.1' or newer of 'bottleneck' (version '1.1.0' currently installed).\n", + " warnings.warn(msg, UserWarning)\n" + ] + } + ], "source": [ "# add capability to import from parent directory\n", "import sys, os\n", "sys.path.insert(1, os.path.join(os.path.abspath('.'), '..'))\n", "\n", "import pvmismatch as pvm\n", + "import pvlib\n", "import numpy as np\n", + "import pandas as pd\n", "\n", "import matplotlib.pyplot as plt" ] @@ -126,71 +137,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "[1.77635684e-15 0.00000000e+00 1.77635684e-15 0.00000000e+00\n", - " 1.77635684e-15 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 1.77635684e-15 0.00000000e+00\n", - " 1.77635684e-15 0.00000000e+00 1.77635684e-15 1.77635684e-15\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 1.77635684e-15 1.77635684e-15 1.77635684e-15 1.77635684e-15\n", - " 1.77635684e-15 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 1.77635684e-15 0.00000000e+00 1.77635684e-15 1.77635684e-15\n", - " 1.77635684e-15 1.77635684e-15 0.00000000e+00 1.77635684e-15\n", - " 1.77635684e-15 1.77635684e-15 1.77635684e-15 1.77635684e-15\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 1.77635684e-15 1.77635684e-15 1.77635684e-15\n", - " 1.77635684e-15 1.77635684e-15 0.00000000e+00 1.77635684e-15\n", - " 1.77635684e-15 0.00000000e+00 1.77635684e-15 1.77635684e-15\n", - " 0.00000000e+00 0.00000000e+00 1.77635684e-15 1.77635684e-15\n", - " 0.00000000e+00 1.77635684e-15 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 1.77635684e-15 1.77635684e-15 1.77635684e-15 0.00000000e+00\n", - " 1.77635684e-15 0.00000000e+00 1.77635684e-15 1.77635684e-15\n", - " 0.00000000e+00 1.77635684e-15 0.00000000e+00 0.00000000e+00\n", - " 1.77635684e-15 1.77635684e-15 1.77635684e-15 5.32907052e-15\n", - " 5.32907052e-15 4.44089210e-15 3.55271368e-15 2.66453526e-15\n", - " 8.88178420e-15 5.32907052e-15 4.44089210e-15 5.32907052e-15\n", - " 8.88178420e-16 4.44089210e-15 2.66453526e-15 3.55271368e-15\n", - " 8.88178420e-15 5.77315973e-15 4.44089210e-15 6.66133815e-15\n", - " 3.55271368e-15 9.32587341e-15 8.88178420e-16 1.11022302e-14\n", - " 6.66133815e-15 3.55271368e-15 3.55271368e-15 7.99360578e-15\n", - " 1.19904087e-14 7.10542736e-15 9.32587341e-15 2.22044605e-15\n", - " 5.32907052e-15 2.66453526e-15 4.44089210e-16 4.88498131e-15\n", - " 1.28785871e-14 9.32587341e-15 3.99680289e-15 7.99360578e-15\n", - " 4.44089210e-15 5.77315973e-15 4.88498131e-15 3.55271368e-15\n", - " 1.19904087e-14 8.88178420e-16 0.00000000e+00 7.54951657e-15\n", - " 1.33226763e-15 3.10862447e-15 5.77315973e-15 8.88178420e-16\n", - " 8.88178420e-15 2.22044605e-15 1.33226763e-15 1.42108547e-14\n", - " 3.99680289e-15 9.32587341e-15 1.11022302e-14 0.00000000e+00\n", - " 1.33226763e-15 4.44089210e-16 8.88178420e-15 0.00000000e+00\n", - " 6.66133815e-15 4.88498131e-15 5.77315973e-15 2.66453526e-15\n", - " 7.54951657e-15 4.88498131e-15 5.32907052e-15 1.11022302e-14\n", - " 5.77315973e-15 4.44089210e-16 1.19904087e-14 2.66453526e-15\n", - " 9.32587341e-15 1.42108547e-14 7.54951657e-15 2.22044605e-15\n", - " 2.22044605e-15 1.33226763e-15 1.15463195e-14 7.99360578e-15\n", - " 1.46549439e-14 8.88178420e-16 2.22044605e-15 7.10542736e-15\n", - " 1.02140518e-14 1.59872116e-14 8.88178420e-16 0.00000000e+00\n", - " 4.44089210e-15 1.77635684e-15 4.44089210e-16 3.10862447e-15\n", - " 2.44249065e-15 2.66453526e-15 1.77635684e-15 1.59872116e-14\n", - " 3.33066907e-15 6.21724894e-15 3.55271368e-15 1.17683641e-14\n", - " 8.65973959e-15 1.99840144e-15 5.55111512e-15 3.77475828e-15\n", - " 2.66453526e-15 1.27675648e-14 1.25455202e-14 9.65894031e-15\n", - " 1.99840144e-15 8.88178420e-16 1.22124533e-14 1.09912079e-14\n", - " 2.55351296e-15 3.62210262e-15]\n" + "Difference between pvlib and PVMismatch IV curves\n", + "brentq : 1.763750812067144e-10\n", + "newton : 4.048317236993171e-12\n", + "lambertw : 1.5987211554602254e-14\n" ] }, { "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -199,37 +154,6 @@ "needs_background": "light" }, "output_type": "display_data" - } - ], - "source": [ - "import pvlib\n", - "\n", - "v_pvl = V_pvm\n", - "i_pvl_brentq = pvlib.pvsystem.i_from_v(resistance_shunt, resistance_series, nVth, V_pvm, saturation_current, photocurrent,\n", - " method='brentq')\n", - "i_pvl_newton = pvlib.pvsystem.i_from_v(resistance_shunt, resistance_series, nVth, V_pvm, saturation_current, photocurrent,\n", - " method='newton')\n", - "i_pvl_lambertw = pvlib.pvsystem.i_from_v(resistance_shunt, resistance_series, nVth, V_pvm, saturation_current, photocurrent,\n", - " method='lambertw')\n", - "\n", - "print(np.abs(I_pvm - i_pvl_lambertw))\n", - "\n", - "plt.plot(v_pvl, i_pvl_brentq)\n", - "plt.plot(v_pvl, i_pvl_newton)\n", - "plt.plot(v_pvl, i_pvl_lambertw)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.5987211554602254e-14\n" - ] }, { "data": { @@ -245,64 +169,52 @@ } ], "source": [ - "plt.plot(v_pvl, np.abs(i_pvl_brentq - I_pvm))\n", - "plt.plot(v_pvl, np.abs(i_pvl_newton - I_pvm))\n", - "plt.plot(v_pvl, np.abs(i_pvl_lambertw - I_pvm))\n", - "plt.legend(['brentq', 'newton', 'lambertw'])\n", - "print(np.max(np.abs(i_pvl_lambertw - I_pvm)))" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(V_pvm, (I_pvm - i_pvl_brentq) / I_pvm)\n", - "plt.plot(V_pvm, (I_pvm - i_pvl_newton) / I_pvm)\n", - "plt.plot(V_pvm, (I_pvm - i_pvl_lambertw) / I_pvm)" + "# Analysis with cell-level IV curves\n", + "\n", + "v_pvl = V_pvm\n", + "\n", + "# pvlib has three numerical methods to solve the single diode equation. Let's find which method gives the best agreement\n", + "# with PVMismatch, and which has the smallest error.\n", + "methods = ['brentq', 'newton', 'lambertw']\n", + "i_pvl = pd.DataFrame(index=methods, columns=['current'])\n", + "\n", + "for method in methods:\n", + " res = pvlib.pvsystem.i_from_v(resistance_shunt, resistance_series, nVth, V_pvm, saturation_current, photocurrent,\n", + " method=method)\n", + " i_pvl['current'][method] = res\n", + "\n", + "plt.figure()\n", + "for method in methods:\n", + " plt.plot(v_pvl, i_pvl['current'][method])\n", + "plt.legend(methods)\n", + "\n", + "plt.figure()\n", + "for method in methods:\n", + " plt.plot(v_pvl, np.abs(i_pvl['current'][method] - I_pvm))\n", + "plt.legend(methods)\n", + "\n", + "print(\"Difference between pvlib and PVMismatch IV curves\")\n", + "for method in methods:\n", + " print(method, ': ', np.max(np.abs(i_pvl['current'][method] - I_pvm)))\n" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "4.49089099241462e-10\n", - "7.028155835087091e-12\n", - "2.7977620220553945e-14\n" + "brentq : 4.49089099241462e-10\n", + "newton : 7.028155835087091e-12\n", + "lambertw : 2.7977620220553945e-14\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -320,27 +232,25 @@ " \"\"\"\n", " return iph - io * np.expm1((v + i * rs) / nNsVth) - (v + i * rs) / rsh - i\n", "\n", - "i_resid_lambertw = sde_resid(v_pvl, i_pvl_lambertw, iph=photocurrent, io=saturation_current,\n", - " rs=resistance_series, rsh=resistance_shunt, nNsVth=nVth)\n", - "i_resid_brentq = sde_resid(v_pvl, i_pvl_brentq, iph=photocurrent, io=saturation_current,\n", - " rs=resistance_series, rsh=resistance_shunt, nNsVth=nVth)\n", - "i_resid_newton = sde_resid(v_pvl, i_pvl_newton, iph=photocurrent, io=saturation_current,\n", - " rs=resistance_series, rsh=resistance_shunt, nNsVth=nVth)\n", + "i_resid = pd.DataFrame(index=methods, columns=['current'])\n", + "for method in methods:\n", + " i_resid['current'][method] = sde_resid(v_pvl, i_pvl['current'][method], iph=photocurrent,\n", + " io=saturation_current, rs=resistance_series,\n", + " rsh=resistance_shunt, nNsVth=nVth)\n", "\n", - "plt.plot(v_pvl, i_resid_brentq)\n", - "plt.plot(v_pvl, i_resid_newton)\n", - "plt.plot(v_pvl, i_resid_lambertw)\n", - "plt.legend(['brentq', 'newton', 'lambertW'])\n", + "plt.figure()\n", + "for method in methods:\n", + " plt.plot(v_pvl, i_resid['current'][method])\n", "plt.ylabel('Error in current')\n", "plt.xlabel('Voltage')\n", - "print(np.max(np.abs(i_resid_brentq)))\n", - "print(np.max(np.abs(i_resid_newton)))\n", - "print(np.max(np.abs(i_resid_lambertw)))\n" + "\n", + "for method in methods:\n", + " print(method, ':', np.max(np.abs(i_resid['current'][method])))\n" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -395,16 +305,16 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 9, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD8CAYAAABn919SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAGbhJREFUeJzt3X10XPV95/H3d2b0ZD1YMpafJNvyg2xkY2yDAiZmswGShtIQaNo0SUvKnu2G3WyzpWm6Kd2TPd2n9rSn3ZScPTndsglJdpOFJISkNEsS0gB5ggAyBmzjB2zjB1mWPX6UZVnWw3z3j7myZdmyZc1ofvPweZ3jo5k7997fRxf7M5c7d+41d0dERApfLHQAERHJDhW6iEiRUKGLiBQJFbqISJFQoYuIFAkVuohIkVChi4gUCRW6iEiRUKGLiBSJRC4Hmzlzpre0tORySBGRgrdhw4Yj7t54pflyWugtLS10dHTkckgRkYJnZnsnMp8OuYiIFAkVuohIkVChi4gUCRW6iEiRUKGLiBQJFbqISJFQoYuIFImCKPTvbOzka7+c0GmYIiIlqyAK/anXuvhmx/7QMURE8toVC93MHjWzw2a2edS0GWb2IzN7K/rZMLUxRUTkSiayh/4V4M4x0x4CfuzurcCPo+ciIhLQFQvd3X8KHBsz+R7gq9HjrwL3ZjmXiIhcpckeQ5/t7gcBop+zshdJREQmY8o/FDWzB8ysw8w6ksnkVA8nIlKyJlvoh8xsLkD08/B4M7r7I+7e7u7tjY1XvJyviIhM0mQL/Sng/ujx/cA/ZCeOiIhM1kROW3wMeBFYbmadZvZ7wF8C7zWzt4D3Rs9FRCSgK96xyN0/Os5Ld2Q5i4iIZCCnt6CbrJgZb3SeZPlnv48ZGEbMwMwwAAMDqmyAH/gnAMMBx849TkX/M+LY+ekGTgyHaL6R1yBlsfSKRy9jI+uNnVtvepqdX97OPx5ZNj1PDOx8JqJ5zz0fvZyNGsNGvz6yvtGvce719Bgj84+sg2ja6Nfs4nVf9Fos+g1inN/IF45jY5bBxoxxwXQwYhA7P80xzEbWH0uvzy5cj8XSv6tZlOnceuPREIZbPFq/YbF4tHkNI46bERu1TovW6dFjYjFs1HotmtcumD8+Kls6s8XS609vnpFxz6/fbOR3S68nFrPz67QYMUtvi5FtEosyWCyGEcNHpsXOrzM2si2izDFLjxuLxaLtJKWuIAr93962lKWza8BJF6o77pBycNKPAWLDA+w48F7wVLSkg6f/GH5+uo/UffTTU+kVR89Hz2+j5j+3jJ9fdvRjczBSo+Yf9dbi0Z+L1nF+mdFvH/jIW83o+S5c1sa8NnaZMW9HGKkLp0djxkhdsP6R12P4RdNGHsdIb5uYeRb+C0umhjzGIAkGLcEwCQZJMBQ9HrYEQ1bGsCUYtjJSsQQpK2M4VoZbglSsDI+V4fHoZ6wMj1dgFbVY1XTi1Q2UVTdQUdNAVe0MquuuoXZGIxWV00L/2jJGQRT6jQsbuHHhRK8u8OUpzVLKRt5IR95UU8BgNA339LTUcDRfKv0z5bgPp3/i0bQU7qlomRQpT0HKL1iOVAonlV4ulTq3LD58br1Er6eXT53PmBoGRq0rWi+eirKmzq0z/QulLpiXc4/HLp/OYCO5PJ0BT/9upEbezM/PO7KcjTyOxnTSv3N63nSmC9Y/kmXkzd5T0T5HKr2ukR2HKCepIWx4AFKD2PAAlhrCUoPEUoPpnz5ELDVIPDVIPDVAufcR9yHiPkjCh0j4EHGGSDBEmQ9RziDlNnTZvw/HqeVE7BpOlTfSXzWL4br5lM9qZXpzG3MXr6S6tn5q/iLKuAqi0CU/pA8jnHs2zlxlOUojU63/zGl6Tx6jr+coZ3qOcbb3OIOnjzPUd4JUb5JYbzflZw5Tc/Yw8/rfYubxE7AXeCW9fGdsHsmaa0nNXUv9te9i4cpbSJRXBP2dip0KXUQuqbKqmsqqapgzf0Lznzl9iu49b3J8/1b6u7ZSfmQz83o2Ma/nWdj+3+n7bgVvVq9laMl7WXTrh2mYPbH1ysSZe+6Ogba3t3tHR0fOxhORsNydrs69dG16juFdP6H56As0c4iUG1srr2dw1e+w4j0fo1zH4y/LzDa4e/sV51Ohi0iueCrFzi0dHHnpGyw48I80+SGOU8f2+R9m5Qf/PbUNs0NHzEsqdBHJa8PDw2z6+T/iv/yfrD3zIr1UsXnB77L6tz5LVU1d6Hh5ZaKFrpNXRSSIeDzOmn9+L2v/5Ae89RvPsGPajazb9/ec+ps1vPbM/wkdryCp0EUkuNZVN3PDZ/4fm973LU7F6ljzwifZ8LkP0nPiSOhoBUWFLiJ5Y9Utv8KCh17ixQUPcP3J5+l7eB27X/956FgFQ4UuInmlrLyCW/7lX7P77icAZ96T97Lpma+EjlUQVOgikpeWt99O7N88z+6yVla98CAvP/4XoSPlPRW6iOStWXPms+iP/olXp63npm1/xYb/+59CR8prKnQRyWtV06q57sHv8HL1u7lxx9/y8jd0+4XxqNBFJO+VV1Sw5sFvsbHqnbS/+Ze8/sOvhI6Ul1ToIlIQysvLufaT32JbWRvLX/hjdr3209CR8o4KXUQKRlV1DY3/6lsct3pqv3s/x5NdoSPlFRW6iBSUxjnNnP7g/2a6n+LAo/dF178XUKGLSAFaev072bDiT7juzAZeeey/ho6TN1ToIlKQbvnQp3l12nrW7Pgf7Nu2IXScvKBCF5GCZLEY8+//e3qtirPf/gSpocvfMq8UqNBFpGA1zp7PjrWfpXVwOx1P/HXoOMGp0EWkoN189wNsqriBtm2f59ihfaHjBKVCF5GCZrEYdb/xMBU+wO5vPBQ6TlAqdBEpeAuXraZjzm9xw9Gn2fXGL0LHCUaFLiJFYeWH/xsnrYa+p/9j6CjBqNBFpChMnzGTN5d8nFX9G9j+y6dDxwlChS4iRWPNr/8Rh5gBz/45uIeOk3MZFbqZfcrMtpjZZjN7zMwqsxVMRORqVdfUsnPZx1k+sJltJbiXPulCN7Mm4A+Adne/DogDH8lWMBGRybjhnj/gCPUMPV9656VnesglAVSZWQKYBujSZyISVFV1DTsW/wuuO7uR3SV2id1JF7q7HwD+BtgHHAROuvsz2QomIjJZK+9+kFNeRc+znwsdJacyOeTSANwDLALmAdVmdt8l5nvAzDrMrCOZTE4+qYjIBE1vmMEbs3+dVSefJ7l/R+g4OZPJIZf3AG+7e9LdB4EngXeOncndH3H3dndvb2xszGA4EZGJW3jXp3CMt7//+dBRciaTQt8HrDOzaWZmwB3A1uzEEhHJTHPLMl6vuZVlXd+lv683dJycyOQY+kvAE8CrwKZoXY9kKZeISMbKb/nX1NPLm898OXSUnMjoLBd3/zN3v9bdr3P3j7n72WwFExHJ1Mpb7mKPNVOz5Wuho+SEvikqIkUrFo9xYPGHWTa4jX1vvhw6zpRToYtIUVv+vo8z4Am6n/9foaNMORW6iBS1mbPmsqn2VpYdfpqz/X2h40wpFbqIFL1E+++mPxz9yROho0wpFbqIFL0V6z9AkgbibzwWOsqUUqGLSNErKytjx6w7aet9id5j3aHjTBkVuoiUhIZ191Fmw+x47uuho0wZFbqIlIS2Ne9kjzUxbcd3QkeZMip0ESkJFovR2XQXy/o3c7RrT+g4U0KFLiIlo+nW+4iZs+snxXnYRYUuIiVj0bVr2B1roW7390JHmRIqdBEpKd3N72PZwFaOdu8LHSXrVOgiUlJm3fwhYubs+dnjoaNknQpdRErKkrYb2WtNTNv1dOgoWadCF5GSYrEY+2ffTuuZ1zl94kjoOFmlQheRklO35h4SlmLnC0+GjpJVKnQRKTkr2m/jCNNJbft+6ChZpUIXkZKTSCTYWX8rS3p+ydBA8dxoTYUuIiWpfMVd1NHHtpd/GDpK1qjQRaQkLb/lbgY8wenNxXPYRYUuIiWpunY6WytXM/fwT0NHyRoVuoiUrN75t7Eg1Uly//bQUbJChS4iJWv2jR8AYP9LTwVOkh0qdBEpWUuWr+IAs0i8/WzoKFmhQheRkmWxGHsb1rHk9KsMDw6EjpMxFbqIlLRE6x1U08/u154PHSVjKnQRKWmt697PkMc4/kbhn76oQheRktYwYyY7y5ZR3/2L0FEypkIXkZJ3fM56lgzsoKfAr76oQheRklfbdgdxc/ZseCZ0lIxkVOhmVm9mT5jZNjPbama3ZCuYiEiuLL3hNs54Of3bnwsdJSOJDJf/PPADd/9NMysHpmUhk4hITlVWTeP1iuuYffSl0FEyMuk9dDOrA94FfAnA3Qfc/US2gomI5FLP3HeycHgvPUcOhI4yaZkcclkMJIEvm9lGM/uimVWPncnMHjCzDjPrSCaTGQwnIjJ16lfeAVDQx9EzKfQEcAPwd+6+FjgNPDR2Jnd/xN3b3b29sbExg+FERKZO6+r19HolAzsL9+qLmRR6J9Dp7iMHnZ4gXfAiIgWnsqKCtypX0Xi0I3SUSZt0obt7N7DfzJZHk+4A3sxKKhGRAE7PXcfC1D5OJjtDR5mUTM9D/3fA183sDWAN8BeZRxIRCaNhxW0AvP3qPwVOMjkZFbq7vxYdH7/e3e919+PZCiYikmtLV6+nzys4u/NnoaNMir4pKiISqaioZHdlGzOPbQgdZVJU6CIio/TMegeLhvbQe/Jo6ChXTYUuIjJKdeu7iJmzZ2Ph3cVIhS4iMsqiNe9i0OP07fx56ChXTYUuIjJKXV09uxJLqEsW3vnoKnQRkTGOzlhLS/92hgfPho5yVVToIiJjlLXcQqUNsnfLi6GjXBUVuojIGE3XvxuAo1sL67ouKnQRkTHmNbdwgFmUHXgldJSrokIXERnDzDhQu5rm3k3gHjrOhKnQRUQuYWheOzM5zuH9O0JHmTAVuojIJTS2rQdg/6bCOY6uQhcRuYSWlTfT5xUM7S2c+4yq0EVELqGsrJw95a00HHsjdJQJU6GLiIzjxDVraBncyeDZvtBRJkSFLiIyjrKFN1Fuw+zbUhiHXVToIiLjmLfynwFwbMcLgZNMjApdRGQc8+YvoptrSBx8NXSUCVGhi4iMw8zonNbGrJ7NoaNMiApdROQy+metocm7OXX8UOgoV6RCFxG5jJrFNwOwf1P+3/BChS4ichktq9aTcqN3d/5fqEuFLiJyGfUN17Av1kTl4Y2ho1yRCl1E5AoO165kXt+2vL/yogpdROQKhuesYSYnSHa9HTrKZanQRUSuoKE1/cFo55ZfBE5yeSp0EZEraFl5M4Me5+y+DaGjXJYKXUTkCiqn1bA3sZCaI/l95UUVuojIBBytbaO5fzueSoWOMq6MC93M4ma20cy+l41AIiL5aHjOaurp5UjXrtBRxpWNPfQHga1ZWI+ISN5qWPIOAA5ufTFwkvFlVOhm1gz8GvDF7MQREclPC1bcxKDH6d+bv1dezHQP/WHgM0D+HlQSEcmC6uoa9sYXUHU0f6+8OOlCN7P3A4fd/bLn8ZjZA2bWYWYdyWRyssOJiAR3tPZams5sz9tvjGayh74e+ICZ7QEeB243s6+NncndH3H3dndvb2xszGA4EZGwhmavZgY9HDuYn98YnXShu/ufunuzu7cAHwGedff7spZMRCTP1C1uB+DA1vy8x6jOQxcRmaCFK95Byo0z+/Lzg9FENlbi7s8Dz2djXSIi+aqurp49sSYqk5tCR7kk7aGLiFyFZM1yZp/ZETrGJanQRUSuwmDjKmb7UU4eORg6ykVU6CIiV6F20Q0A7N/6cuAkF1Ohi4hchflt6Wuj9+7Jv0vpqtBFRK5C/cw5dDOTsuSW0FEuokIXEblKB6uWMrN3e+gYF1Ghi4hcpTMz2mge7uTsmd7QUS6gQhcRuUplTWuIm3Ngx8bQUS6gQhcRuUqNrTcCcHxXfn0wqkIXEblKzYva6PUqUt359Y1RFbqIyFVKJBLsK1tE7YltoaNcQIUuIjIJJ+uW0TSwO69uGq1CFxGZBJ99HbX0cfTAztBRzlGhi4hMQl3LWgAO7ugInOQ8FbqIyCTMX54+06Vvf/58MKpCFxGZhOn1DXTaHMqPvhk6yjkqdBGRSTpctZSZp98KHeMcFbqIyCT1z7iWecNd9PedCh0FUKGLiExaRdP1xM3pzJNLAKjQRUQmqXFp+mYXx3er0EVEClrT4hX0eQXD3ZtDRwFU6CIikxaPx+ksW0jtyfy4abQKXUQkA8drljL37O7QMQAVuohIRlKNK5hBD8cPd4aOokIXEcnEtPnXA3BwR/hro6vQRUQyMHdp+poup/PgEgAqdBGRDDTOnc8x6rDk1tBRVOgiIpkwMw6UL2L6qfCXAFChi4hk6FRdK02De/DUcNAcKnQRkQzZrBVM4yxHOsPe7GLShW5m883sOTPbamZbzOzBbAYTESkUtQvTZ7oc2hn2EgCZ7KEPAZ929zZgHfD7ZrYiO7FERArHvNb0NV3OdIY902XShe7uB9391ejxKWAr0JStYCIihWLGjGvoZibxo9uC5sjKMXQzawHWAi9d4rUHzKzDzDqSyWQ2hhMRyTvdlYuo790VNEPGhW5mNcC3gT90956xr7v7I+7e7u7tjY2NmQ4nIpKX+qa30jTUSWpoMFiGjArdzMpIl/nX3f3J7EQSESk88dltVNgg3XvCfcEok7NcDPgSsNXdP5e9SCIihWd6dKZLcvdrwTJksoe+HvgYcLuZvRb9uStLuURECkpT62oA+ru2BMuQmOyC7v5zwLKYRUSkYNXWNdBls0gc3R4sg74pKiKSJcnKRcw4He5mFyp0EZEs6atvpWm4k6HBgSDjq9BFRLIkPruNchvm4NtvBhlfhS4ikiXTF6TPdDny9htBxlehi4hkybyl6UIfOBjmTBcVuohIltTW1dPFLMqO7QgyvgpdRCSLDle2UH/67SBjq9BFRLKob/rS6JouQzkfW4UuIpJFNutaKmyQQ/tz/wUjFbqISBbVzb8OgCO7X8/52Cp0EZEsmrc0fU2XM125PxddhS4ikkUNM2ZyiBnEj76V87FV6CIiWXaofCF1vbm/posKXUQky3rrljBvaB+eSuV0XBW6iEi2zVxGNf0cO7gnp8Oq0EVEsqymeQUA3Tk+00WFLiKSZXMWp8906TuQ2zNdVOgiIlnWOKeZk14Nydx+uUiFLiKSZRaL0VW2gJpTuT3TRYUuIjIFemoWM2tgX07HVKGLiEyB1DWtXMNJeo4dztmYKnQRkSlQNa8NgK6dubt7kQpdRGQKNC5K372oZ//mnI2pQhcRmQJzFiyj38tIJXN39yIVuojIFIgnEnTFm6g8uStnY6rQRUSmyPFpLTT278nZeCp0EZEpMlC/lDmpQ5ztP52T8VToIiJTpGzOcuLmdO/ekpPxVOgiIlOkfn76Il3H9hVAoZvZnWa23cx2mtlD2QolIlIM5i5O31/0bHduznSZdKGbWRz4AvCrwArgo2a2IlvBREQKXXVtPd3MJHEsN7ejy2QP/SZgp7vvdvcB4HHgnuzEEhEpDsmKBUzv25OTsTIp9CZg/6jnndE0ERGJ9NUuYu5gZ05uR5dJodslpvlFM5k9YGYdZtaRTCYzGE5EpPAkWz/EpwY/QbLnzJSPlUmhdwLzRz1vBrrGzuTuj7h7u7u3NzY2ZjCciEjhaWpbR/l1d3M2dal94OxKZLDsK0CrmS0CDgAfAX47K6lERIrE2gUNfOG3G3Iy1qQL3d2HzOyTwA+BOPCou+fmZEsREblIJnvouPvTwNNZyiIiIhnQN0VFRIqECl1EpEio0EVEioQKXUSkSKjQRUSKhApdRKRImPtF39afusHMksDeHAw1EziSg3EKkbbN+LRtxqdtM75cbJuF7n7Fr9rntNBzxcw63L09dI58pG0zPm2b8WnbjC+fto0OuYiIFAkVuohIkSjWQn8kdIA8pm0zPm2b8WnbjC9vtk1RHkMXESlFxbqHLiJScoqq0M3sTjPbbmY7zeyh0HlCM7NHzeywmW0eNW2Gmf3IzN6KfubmQs15xMzmm9lzZrbVzLaY2YPR9JLfNgBmVmlmL5vZ69H2+c/R9EVm9lK0fb5hZuWhs4ZgZnEz22hm34ue5812KZpCN7M48AXgV4EVwEfNbEXYVMF9BbhzzLSHgB+7eyvw4+h5qRkCPu3ubcA64PejvyvaNmlngdvdfTWwBrjTzNYBfwX8bbR9jgO/FzBjSA8CW0c9z5vtUjSFDtwE7HT33e4+ADwO3BM4U1Du/lPg2JjJ9wBfjR5/Fbg3p6HygLsfdPdXo8enSP/jbELbBgBP642elkV/HLgdeCKaXpLbx8yagV8Dvhg9N/JouxRToTcB+0c974ymyYVmu/tBSBcbMCtwnqDMrAVYC7yEts050WGF14DDwI+AXcAJdx+KZinVf18PA58BUtHza8ij7VJMhX6pO7DqFB4Zl5nVAN8G/tDde0LnySfuPuzua0jf/P0moO1Ss+U2VVhm9n7gsLtvGD35ErMG2y4Z3YIuz3QC80c9bwa6AmXJZ4fMbK67HzSzuaT3wEqOmZWRLvOvu/uT0WRtmzHc/YSZPU/6s4Z6M0tEe6Ol+O9rPfABM7sLqATqSO+x5812KaY99FeA1ugT53LgI8BTgTPlo6eA+6PH9wP/EDBLENFxzy8BW939c6NeKvltA2BmjWZWHz2uAt5D+nOG54DfjGYrue3j7n/q7s3u3kK6X551998hj7ZLUX2xKHrnfBiIA4+6+58HjhSUmT0GvJv01eAOAX8GfBf4JrAA2Ad8yN3HfnBa1MzsVuBnwCbOHwv9D6SPo5f0tgEws+tJf7gXJ73T9013/y9mtpj0yQYzgI3Afe5+NlzScMzs3cAfu/v782m7FFWhi4iUsmI65CIiUtJU6CIiRUKFLiJSJFToIiJFQoUuIlIkVOgiIkVChS4iUiRU6CIiReL/A4KDPdNSe6x6AAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -416,36 +326,44 @@ } ], "source": [ + "# Analysis with module-level IV curves\n", + "\n", "Vmod = pv_mod.Vmod\n", "Imod = pv_mod.Imod\n", - "# Voc = pv_mod.Voc.sum() # only an estimate of Voc, not precise\n", + "\n", + "plt.figure()\n", + "plt.plot(Vmod, Imod)\n", + "\n", + "# remove negative voltage and current\n", + "\n", "u = (Vmod>=0.) & (Imod>=0.)\n", "Imod = Imod[u]\n", "Vmod = Vmod[u]\n", "\n", "print(Vmod)\n", "print(Imod)\n", + "\n", "plt.plot(Vmod, Imod)" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 8, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "Difference between pvlib and PVMismatch IV curves\n", + "brentq : 0.0015364870781562345\n", + "newton : 0.0015364870781704454\n", + "lambertw : 0.0015364870781695572\n" + ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -458,54 +376,43 @@ ], "source": [ "Ns = 60\n", - "Imod_brentq = pvlib.pvsystem.i_from_v(resistance_shunt=Ns*resistance_shunt, resistance_series=Ns*resistance_series,\n", - " nNsVth=Ns*nVth, voltage=Vmod, saturation_current=saturation_current,\n", - " photocurrent=photocurrent, method='brentq')\n", - "Imod_newton = pvlib.pvsystem.i_from_v(resistance_shunt=Ns*resistance_shunt, resistance_series=Ns*resistance_series,\n", - " nNsVth=Ns*nVth, voltage=Vmod, saturation_current=saturation_current,\n", - " photocurrent=photocurrent, method='newton')\n", - "Imod_lambertw = pvlib.pvsystem.i_from_v(resistance_shunt=Ns*resistance_shunt, resistance_series=Ns*resistance_series,\n", - " nNsVth=Ns*nVth, voltage=Vmod, saturation_current=saturation_current,\n", - " photocurrent=photocurrent, method='lambertw')\n", "\n", - "plt.plot(Vmod, Imod)\n", - "plt.plot(Vmod, Imod_brentq)\n", - "plt.plot(Vmod, Imod_newton)\n", - "plt.plot(Vmod, Imod_lambertw)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "Imod_resid_brentq = sde_resid(v=Vmod, i=Imod_brentq, iph=photocurrent, io=saturation_current,\n", - " rs=resistance_series*Ns, rsh=resistance_shunt*Ns, nNsVth=nVth*Ns)\n", - "Imod_resid_newton = sde_resid(v=Vmod, i=Imod_newton, iph=photocurrent, io=saturation_current,\n", - " rs=resistance_series*Ns, rsh=resistance_shunt*Ns, nNsVth=nVth*Ns)\n", - "Imod_resid_lambertw = sde_resid(v=Vmod, i=Imod_lambertw, iph=photocurrent, io=saturation_current,\n", - " rs=resistance_series*Ns, rsh=resistance_shunt*Ns, nNsVth=nVth*Ns)" + "i_pvl_mod = pd.DataFrame(index=methods, columns=['current'])\n", + "\n", + "for method in methods:\n", + " i_pvl_mod['current'][method] = pvlib.pvsystem.i_from_v(resistance_shunt=Ns*resistance_shunt,\n", + " resistance_series=Ns*resistance_series,\n", + " nNsVth=Ns*nVth, voltage=Vmod,\n", + " saturation_current=saturation_current,\n", + " photocurrent=photocurrent, method=method)\n", + "\n", + "plt.figure()\n", + "for method in methods:\n", + " plt.plot(Vmod, i_pvl_mod['current'][method])\n", + "plt.legend(methods)\n", + "\n", + "print(\"Difference between pvlib and PVMismatch IV curves\")\n", + "for method in methods:\n", + " print(method, ': ', np.max(np.abs(i_pvl_mod['current'][method] - Imod)))" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 9, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "Text(0.5,0,'Voltage')" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "brentq : 4.9432680171435095e-12\n", + "newton : 5.062616992290714e-14\n", + "lambertw : 2.7533531010703882e-14\n" + ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -517,1000 +424,101 @@ } ], "source": [ - "plt.plot(Vmod, Imod_resid_brentq)\n", - "plt.plot(Vmod, Imod_resid_newton)\n", - "plt.plot(Vmod, Imod_resid_lambertw)\n", - "plt.legend(['brentq', 'newton', 'lambertW'])\n", + "i_pvl_resid = pd.DataFrame(index=methods, columns=['current'])\n", + "\n", + "for method in methods:\n", + " i_pvl_resid['current'][method] = sde_resid(v=Vmod, i=i_pvl_mod['current'][method],\n", + " iph=photocurrent, io=saturation_current,\n", + " rs=resistance_series*Ns, rsh=resistance_shunt*Ns,\n", + " nNsVth=nVth*Ns)\n", + "\n", + " \n", + "plt.figure()\n", + "for method in methods:\n", + " plt.plot(Vmod, i_pvl_resid['current'][method])\n", "plt.ylabel('Error in current')\n", - "plt.xlabel('Voltage')" + "plt.xlabel('Voltage')\n", + "\n", + "for method in methods:\n", + " print(method, ':', np.max(np.abs(i_pvl_resid['current'][method])))" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# The analysis above identifies 'lambertw' as having lowest discrepancy between pvlib and PVMismatch, and curves\n", + "# calculated with 'lambertw' as having smallest residual" + ] + }, + { + "cell_type": "code", + "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "9.679999999999998 9.68003793890756\n", - "9.68003793890756 nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "9.679999999999998 9.68003793890756\n", - "9.68003793890756 nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "9.656507866288223 9.656507875857933\n", - "9.656507875857933 9.602847417869235\n", - "9.602847417869235 74.77147425185561\n", - "74.77147425185561 nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "9.632447839563271 9.632447839572427\n", - "9.632447839572427 9.632447823332367\n", - "9.632447823332367 9.632476643356446\n", - "9.632476643356446 9.581113569662918\n", - "9.581113569662918 26.374824817370367\n", - "26.374824817370367 nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "nan nan\n", - "9.607870921138685 9.607870921142158\n", - "9.607870921142158 9.607870920237211\n", - "9.607870920237211 9.607871156662613\n", - "9.607871156662613 9.607809386593711\n", - "9.607809386593711 9.623926338516613\n", - "9.623926338516613 2.424852480229911\n", - "2.424852480229911 44.19924200722603\n", - "44.19924200722603 nan\n", - "nan nan\n", - "nan nan\n", - "9.58273714779705 9.582737147800772\n", - "9.582737147800772 9.582737147317722\n", - "9.582737147317722 9.582737210032864\n", - "9.582737210032864 9.582729067594773\n", - "9.582729067594773 9.583786125163712\n", - "9.583786125163712 9.44498240087919\n", - "9.44498240087919 17.88487512423844\n", - "17.88487512423844 nan\n", - "nan nan\n", - "nan nan\n", - "9.556708909488558 9.55670890949055\n", - "9.55670890949055 9.556708909322625\n", - "9.556708909322625 9.556708923503773\n", - "9.556708923503773 9.556707725792785\n", - "9.556707725792785 9.55680888107139\n", - "9.55680888107139 9.54825959762687\n", - "9.54825959762687 10.231100372200125\n", - "10.231100372200125 nan\n", - "nan nan\n", - "nan nan\n", - "9.530345299023962 9.530345299026154\n", - "9.530345299026154 9.530345298889253\n", - "9.530345298889253 9.530345307399807\n", - "9.530345307399807 9.530344778349168\n", - "9.530344778349168 9.53037766616269\n", - "9.53037766616269 9.52833289211859\n", - "9.52833289211859 9.65416265016569\n", - "9.65416265016569 nan\n", - "nan nan\n", - "nan nan\n", - "9.503435389900782 9.503435389900673\n", - "9.503435389900673 9.503435389906974\n", - "9.503435389906974 9.50343538959854\n", - "9.50343538959854 9.503435404680319\n", - "9.503435404680319 9.503434667246292\n", - "9.503434667246292 9.503470724454951\n", - "9.503470724454951 9.50170743612706\n", - "9.50170743612706 9.58733748587143\n", - "9.58733748587143 2.6172172098404314\n", - "2.6172172098404314 33.8380659208395\n", - "9.47564077308512 9.475640773086209\n", - "9.475640773086209 9.475640773042556\n", - "9.475640773042556 9.47564077478948\n", - "9.47564077478948 9.475640704859908\n", - "9.475640704859908 9.475643504181813\n", - "9.475643504181813 9.475531444663709\n", - "9.475531444663709 9.48001566520952\n", - "9.48001566520952 9.297913743492542\n", - "9.297913743492542 14.172395825038564\n", - "14.172395825038564 nan\n", - "9.447057141421727 9.447057141423139\n", - "9.447057141423139 9.447057141375543\n", - "9.447057141375543 9.44705714297988\n", - "9.44705714297988 9.447057088876809\n", - "9.447057088876809 9.447058913402353\n", - "9.447058913402353 9.446997384380996\n", - "9.446997384380996 9.449071999094867\n", - "9.449071999094867 9.378723510416112\n", - "9.378723510416112 11.398221200078538\n", - "11.398221200078538 nan\n", - "9.417874793011807 9.417874793012322\n", - "9.417874793012322 9.417874792996809\n", - "9.417874792996809 9.417874793448222\n", - "9.417874793448222 9.417874780338488\n", - "9.417874780338488 9.417875161055063\n", - "9.417875161055063 9.417864104738383\n", - "9.417864104738383 9.418185180842356\n", - "9.418185180842356 9.408854133203734\n", - "9.408854133203734 9.674302864789002\n", - "9.674302864789002 nan\n", - "9.388128396387977 9.388128396388089\n", - "9.388128396388089 9.388128396385369\n", - "9.388128396385369 9.388128396454443\n", - "9.388128396454443 9.388128394697306\n", - "9.388128394697306 9.388128439389856\n", - "9.388128439389856 9.388127302645781\n", - "9.388127302645781 9.38815621539329\n", - "9.38815621539329 9.387420785095257\n", - "9.387420785095257 9.406099472901197\n", - "9.406099472901197 8.91275648043541\n", - "9.357740297458095 9.357740297458138\n", - "9.357740297458138 9.357740297457639\n", - "9.357740297457639 9.35774029746874\n", - "9.35774029746874 9.357740297217834\n", - "9.357740297217834 9.357740302880408\n", - "9.357740302880408 9.357740175086528\n", - "9.357740175086528 9.357743059154144\n", - "9.357743059154144 9.357677970846167\n", - "9.357677970846167 9.359146727676011\n", - "9.359146727676011 9.32591585189279\n", - "9.326559167726055 9.326559167726879\n", - "9.326559167726879 9.326559167710007\n", - "9.326559167710007 9.326559168051215\n", - "9.326559168051215 9.326559161149882\n", - "9.326559161149882 9.326559300739333\n", - "9.326559300739333 9.32655647734088\n", - "9.32655647734088 9.326613584394027\n", - "9.326613584394027 9.325458411654022\n", - "9.325458411654022 9.348782480109067\n", - "9.348782480109067 8.859396850009455\n", - "9.294390232248873 9.294390232249505\n", - "9.294390232249505 9.294390232237765\n", - "9.294390232237765 9.294390232452205\n", - "9.294390232452205 9.294390228534724\n", - "9.294390228534724 9.294390300103181\n", - "9.294390300103181 9.294388992617767\n", - "9.294388992617767 9.294412879046757\n", - "9.294412879046757 9.293976483320426\n", - "9.293976483320426 9.301944277256776\n", - "9.301944277256776 9.154779064729745\n", - "9.261016995443109 9.261016995443551\n", - "9.261016995443551 9.261016995436446\n", - "9.261016995436446 9.261016995554309\n", - "9.261016995554309 9.26101699359744\n", - "9.26101699359744 9.261017026083472\n", - "9.261017026083472 9.261016486782015\n", - "9.261016486782015 9.26102543973321\n", - "9.26102543973321 9.260876809935747\n", - "9.260876809935747 9.263343768988056\n", - "9.263343768988056 9.222265731260986\n", - "9.227947789484704 9.22794778948506\n", - "9.22794778948506 9.227947789479538\n", - "9.227947789479538 9.227947789563515\n", - "9.227947789563515 9.227947788285347\n", - "9.227947788285347 9.227947807742959\n", - "9.227947807742959 9.227947511541005\n", - "9.227947511541005 9.227952020600014\n", - "9.227952020600014 9.227883379184734\n", - "9.227883379184734 9.228928222895531\n", - "9.228928222895531 9.213004194709793\n", - "9.193553152048283 9.193553152048342\n", - "9.193553152048342 9.193553152047453\n", - "9.193553152047453 9.193553152060025\n", - "9.193553152060025 9.193553151883856\n", - "9.193553151883856 9.193553154352607\n", - "9.193553154352607 9.193553119759294\n", - "9.193553119759294 9.193553604495417\n", - "9.193553604495417 9.193546812161172\n", - "9.193546812161172 9.193641988617724\n", - "9.193641988617724 9.192308207130257\n", - "9.157545593039643 9.157545593040131\n", - "9.157545593040131 9.157545593033776\n", - "9.157545593033776 9.157545593115922\n", - "9.157545593115922 9.157545592053332\n", - "9.157545592053332 9.157545605798054\n", - "9.157545605798054 9.157545428008573\n", - "9.157545428008573 9.15754772773323\n", - "9.15754772773323 9.1575179804975\n", - "9.1575179804975 9.157902753493508\n", - "9.157902753493508 9.152923912797917\n", - "9.12217113671625 9.12217113671631\n", - "9.12217113671631 9.122171136715531\n", - "9.122171136715531 9.12217113672505\n", - "9.12217113672505 9.12217113661063\n", - "9.12217113661063 9.122171137986317\n", - "9.122171137986317 9.122171121441959\n", - "9.122171121441959 9.12217132041022\n", - "9.12217132041022 9.122168927548383\n", - "9.122168927548383 9.122197704878184\n", - "9.122197704878184 9.121851610287854\n", - "9.084830593604632 9.084830593604687\n", - "9.084830593604687 9.084830593604215\n", - "9.084830593604215 9.084830593609489\n", - "9.084830593609489 9.084830593550349\n", - "9.084830593550349 9.08483059421248\n", - "9.08483059421248 9.08483058679957\n", - "9.08483058679957 9.084830669792776\n", - "9.084830669792776 9.084829740619904\n", - "9.084829740619904 9.084840143416377\n", - "9.084840143416377 9.08472367517897\n", - "9.047029949053154 9.047029949053186\n", - "9.047029949053186 9.047029949052964\n", - "9.047029949052964 9.047029949055185\n", - "9.047029949055185 9.04702994903215\n", - "9.04702994903215 9.047029949273314\n", - "9.047029949273314 9.047029946749614\n", - "9.047029946749614 9.04702997315757\n", - "9.04702997315757 9.047029696826066\n", - "9.047029696826066 9.047032588343503\n", - "9.047032588343503 9.047002331596948\n", - "9.008284101534425 9.00828410153453\n", - "9.00828410153453 9.008284101533503\n", - "9.008284101533503 9.008284101543548\n", - "9.008284101543548 9.008284101445001\n", - "9.008284101445001 9.008284102411627\n", - "9.008284102411627 9.008284092932143\n", - "9.008284092932143 9.008284185894405\n", - "9.008284185894405 9.008283274241592\n", - "9.008283274241592 9.008292214542099\n", - "9.008292214542099 9.008204539171155\n", - "8.968166297684414 8.968166297684611\n", - "8.968166297684611 8.968166297682835\n", - "8.968166297682835 8.968166297699153\n", - "8.968166297699153 8.96816629754896\n", - "8.96816629754896 8.968166298931779\n", - "8.968166298931779 8.968166286199168\n", - "8.968166286199168 8.968166403437376\n", - "8.968166403437376 8.968165323940767\n", - "8.968165323940767 8.968175263637638\n", - "8.968175263637638 8.968083741122637\n", - "8.92782521473413 8.927825214734227\n", - "8.927825214734227 8.927825214733282\n", - "8.927825214733282 8.92782521474147\n", - "8.92782521474147 8.927825214670397\n", - "8.927825214670397 8.927825215286934\n", - "8.927825215286934 8.927825209938648\n", - "8.927825209938648 8.927825256334055\n", - "8.927825256334055 8.927824853863095\n", - "8.927824853863095 8.927828345217224\n", - "8.927828345217224 8.927798058359226\n", - "8.885515967933845 8.88551596793425\n", - "8.88551596793425 8.885515967930726\n", - "8.885515967930726 8.885515967959588\n", - "8.885515967959588 8.885515967723336\n", - "8.885515967723336 8.885515969655588\n", - "8.885515969655588 8.885515953853092\n", - "8.885515953853092 8.885516083090153\n", - "8.885516083090153 8.885515026155675\n", - "8.885515026155675 8.885523670035266\n", - "8.885523670035266 8.88545297782031\n", - "8.843343382911014 8.843343382911096\n", - "8.843343382911096 8.84334338291043\n", - "8.84334338291043 8.843343382915537\n", - "8.843343382915537 8.843343382876018\n", - "8.843343382876018 8.843343383181871\n", - "8.843343383181871 8.843343380815497\n", - "8.843343380815497 8.843343399123654\n", - "8.843343399123654 8.843343257477763\n", - "8.843343257477763 8.843344353357491\n", - "8.843344353357491 8.843335874799715\n", - "8.798935227578596 8.798935227578836\n", - "8.798935227578836 8.798935227576978\n", - "8.798935227576978 8.798935227590576\n", - "8.798935227590576 8.798935227491029\n", - "8.798935227491029 8.798935228219822\n", - "8.798935228219822 8.79893522288458\n", - "8.79893522288458 8.79893526194131\n", - "8.79893526194131 8.798934976025393\n", - "8.798934976025393 8.798937069081198\n", - "8.798937069081198 8.798921746788583\n", - "8.754666592625247 8.754666592625346\n", - "8.754666592625346 8.754666592624623\n", - "8.754666592624623 8.754666592629675\n", - "8.754666592629675 8.754666592594596\n", - "8.754666592594596 8.754666592838397\n", - "8.754666592838397 8.754666591144423\n", - "8.754666591144423 8.754666602913963\n", - "8.754666602913963 8.754666521140754\n", - "8.754666521140754 8.754667089289445\n", - "8.754667089289445 8.754663141871895\n", - "8.70822001696865 8.708220016968713\n", - "8.708220016968713 8.708220016968436\n", - "8.708220016968436 8.7082200169701\n", - "8.7082200169701 8.708220016959277\n", - "8.708220016959277 8.708220017030628\n", - "8.708220017030628 8.70822001656004\n", - "8.70822001656004 8.70822001966378\n", - "8.70822001966378 8.708219999193116\n", - "8.708219999193116 8.708220134207727\n", - "8.708220134207727 8.708219243715684\n", - "8.661576479608641 8.661576479608616\n", - "8.661576479608616 8.661576479608755\n", - "8.661576479608755 8.66157647960795\n", - "8.66157647960795 8.661576479612918\n", - "8.661576479612918 8.66157647958178\n", - "8.66157647958178 8.661576479777292\n", - "8.661576479777292 8.661576478550272\n", - "8.661576478550272 8.661576486250999\n", - "8.661576486250999 8.661576437922148\n", - "8.661576437922148 8.661576741227524\n", - "8.613122019020697 8.613122019020565\n", - "8.613122019020565 8.61312201902148\n", - "8.61312201902148 8.613122019015986\n", - "8.613122019015986 8.613122019048816\n", - "8.613122019048816 8.61312201885272\n", - "8.61312201885272 8.61312202002435\n", - "8.61312202002435 8.613122013023942\n", - "8.613122013023942 8.613122054851335\n", - "8.613122054851335 8.613121804932474\n", - "8.613121804932474 8.613123298198797\n", - "8.563820761761276 8.563820761761281\n", - "8.563820761761281 8.563820761761281\n", - "8.5133614860916 8.513361486091723\n", - "8.513361486091723 8.513361486091028\n", - "8.513361486091028 8.513361486094858\n", - "8.513361486094858 8.513361486074045\n", - "8.513361486074045 8.513361486187188\n", - "8.513361486187188 8.513361485571847\n", - "8.513361485571847 8.513361488918278\n", - "8.513361488918278 8.513361470719769\n", - "8.513361470719769 8.513361569686175\n", - "8.513361569686175 8.513361031491158\n", - "8.46112305303359 8.461123053033726\n", - "8.461123053033726 8.461123053032948\n", - "8.461123053032948 8.461123053037083\n", - "8.461123053037083 8.46112305301552\n", - "8.46112305301552 8.461123053127583\n", - "8.461123053127583 8.461123052545458\n", - "8.461123052545458 8.461123055568887\n", - "8.461123055568887 8.461123039865992\n", - "8.461123039865992 8.461123121423013\n", - "8.461123121423013 8.461122697835327\n", - "8.40863709519163 8.408637095191688\n", - "8.408637095191688 8.408637095191356\n", - "8.408637095191356 8.408637095193049\n", - "8.408637095193049 8.408637095184668\n", - "8.408637095184668 8.408637095226323\n", - "8.408637095226323 8.40863709501924\n", - "8.40863709501924 8.408637096048277\n", - "8.408637096048277 8.408637090934691\n", - "8.408637090934691 8.408637116345854\n", - "8.408637116345854 8.408636990068835\n", - "8.35319033799328 8.353190337993437\n", - "8.353190337993437 8.35319033799263\n", - "8.35319033799263 8.353190337996406\n", - "8.353190337996406 8.353190337978505\n", - "8.353190337978505 8.353190338063566\n", - "8.353190338063566 8.35319033765936\n", - "8.35319033765936 8.353190339580232\n", - "8.353190339580232 8.353190330451534\n", - "8.353190330451534 8.353190373834835\n", - "8.353190373834835 8.353190167659662\n", - "8.298633260083813 8.298633260083859\n", - "8.298633260083859 8.298633260083692\n", - "8.298633260083692 8.298633260084442\n", - "8.298633260084442 8.298633260081056\n", - "8.298633260081056 8.29863326009643\n", - "8.29863326009643 8.298633260026385\n", - "8.298633260026385 8.298633260345559\n", - "8.298633260345559 8.298633258891167\n", - "8.298633258891167 8.298633265518285\n", - "8.298633265518285 8.298633235320867\n", - "8.240779339915601 8.240779339915685\n", - "8.240779339915685 8.240779339915324\n", - "8.240779339915324 8.240779339916907\n", - "8.240779339916907 8.240779339909997\n", - "8.240779339909997 8.240779339940163\n", - "8.240779339940163 8.240779339808341\n", - "8.240779339808341 8.240779340383915\n", - "8.240779340383915 8.240779337871066\n", - "8.240779337871066 8.240779348841906\n", - "8.240779348841906 8.24077930094396\n", - "8.183025354271432 8.18302535427156\n", - "8.18302535427156 8.18302535427095\n", - "8.18302535427095 8.18302535427353\n", - "8.18302535427353 8.183025354262707\n", - "8.183025354262707 8.183025354308054\n", - "8.183025354308054 8.183025354117982\n", - "8.183025354117982 8.183025354914598\n", - "8.183025354914598 8.183025351576049\n", - "8.183025351576049 8.183025365567374\n", - "8.183025365567374 8.183025306932064\n", - "8.123030778190499 8.123030778190559\n", - "8.123030778190559 8.12303077819031\n", - "8.12303077819031 8.123030778191337\n", - "8.123030778191337 8.123030778187202\n", - "8.123030778187202 8.123030778203825\n", - "8.123030778203825 8.123030778136972\n", - "8.123030778136972 8.123030778405969\n", - "8.123030778405969 8.123030777323647\n", - "8.123030777323647 8.123030781678025\n", - "8.123030781678025 8.123030764159548\n", - "8.061483260095068 8.061483260095072\n", - "8.061483260095072 8.061483260095072\n", - "7.999257030326158 7.999257030326157\n", - "7.999257030326157 7.999257030326157\n", - "7.933673595605406 7.933673595605382\n", - "7.933673595605382 7.933673595605438\n", - "7.933673595605438 7.9336735956052715\n", - "7.9336735956052715 7.933673595605826\n", - "7.933673595605826 7.933673595603828\n", - "7.933673595603828 7.933673595611099\n", - "7.933673595611099 7.93367359558504\n", - "7.93367359558504 7.9336735956781474\n", - "7.9336735956781474 7.9336735953455415\n", - "7.9336735953455415 7.933673596533654\n", - "7.869107157108216 7.8691071571082665\n", - "7.8691071571082665 7.869107157108044\n", - "7.869107157108044 7.869107157108849\n", - "7.869107157108849 7.869107157106046\n", - "7.869107157106046 7.869107157115704\n", - "7.869107157115704 7.86910715708254\n", - "7.86910715708254 7.869107157196545\n", - "7.869107157196545 7.869107156804383\n", - "7.869107156804383 7.869107158153624\n", - "7.869107158153624 7.869107153511486\n", - "7.8010113493737885 7.801011349373807\n", - "7.801011349373807 7.801011349373724\n", - "7.801011349373724 7.801011349374029\n", - "7.801011349374029 7.80101134937303\n", - "7.80101134937303 7.801011349376305\n", - "7.801011349376305 7.801011349365454\n", - "7.801011349365454 7.801011349401503\n", - "7.801011349401503 7.801011349282032\n", - "7.801011349282032 7.801011349677745\n", - "7.801011349677745 7.801011348367191\n", - "7.732229426744791 7.732229426744803\n", - "7.732229426744803 7.732229426744803\n", - "7.661645763444671 7.66164576344478\n", - "7.66164576344478 7.661645763444447\n", - "7.661645763444447 7.6616457634454465\n", - "7.6616457634454465 7.661645763442338\n", - "7.661645763442338 7.661645763451968\n", - "7.661645763451968 7.661645763422301\n", - "7.661645763422301 7.661645763513522\n", - "7.661645763513522 7.661645763232978\n", - "7.661645763232978 7.661645764096006\n", - "7.661645764096006 7.661645761440929\n", - "7.588271383307027 7.588271383307099\n", - "7.588271383307099 7.588271383306848\n", - "7.588271383306848 7.588271383307543\n", - "7.588271383307543 7.588271383305517\n", - "7.588271383305517 7.588271383311539\n", - "7.588271383311539 7.588271383293667\n", - "7.588271383293667 7.588271383346672\n", - "7.588271383346672 7.588271383189541\n", - "7.588271383189541 7.588271383655467\n", - "7.588271383655467 7.588271382273757\n", - "7.515050681406334 7.51505068140641\n", - "7.51505068140641 7.51505068140616\n", - "7.51505068140616 7.5150506814068825\n", - "7.5150506814068825 7.515050681404828\n", - "7.515050681404828 7.515050681410711\n", - "7.515050681410711 7.515050681393866\n", - "7.515050681393866 7.515050681442071\n", - "7.515050681442071 7.515050681304062\n", - "7.515050681304062 7.515050681699193\n", - "7.515050681699193 7.515050680568054\n", - "7.438049434789157 7.438049434789284\n", - "7.438049434789284 7.438049434788923\n", - "7.438049434788923 7.438049434789923\n", - "7.438049434789923 7.438049434787147\n", - "7.438049434787147 7.438049434794834\n", - "7.438049434794834 7.438049434773493\n", - "7.438049434773493 7.438049434832494\n", - "7.438049434832494 7.4380494346695345\n", - "7.4380494346695345 7.4380494351195034\n", - "7.4380494351195034 7.438049433876886\n", - "7.360857738081892 7.360857738081894\n", - "7.360857738081894 7.360857738081894\n", - "7.281018465548653 7.281018465548706\n", - "7.281018465548706 7.281018465548595\n", - "7.281018465548595 7.281018465548873\n", - "7.281018465548873 7.281018465548151\n", - "7.281018465548151 7.2810184655500105\n", - "7.2810184655500105 7.2810184655452375\n", - "7.2810184655452375 7.281018465557532\n", - "7.281018465557532 7.281018465525839\n", - "7.281018465525839 7.281018465607485\n", - "7.281018465607485 7.281018465397126\n", - "7.19869679975272 7.198696799752753\n", - "7.198696799752753 7.198696799752642\n", - "7.198696799752642 7.19869679975292\n", - "7.19869679975292 7.198696799752226\n", - "7.198696799752226 7.198696799753974\n", - "7.198696799753974 7.198696799749617\n", - "7.198696799749617 7.1986967997604685\n", - "7.1986967997604685 7.198696799733494\n", - "7.198696799733494 7.198696799800597\n", - "7.198696799800597 7.1986967996335585\n", - "7.115831549863268 7.115831549863281\n", - "7.115831549863281 7.115831549863281\n", - "7.028903109131381 7.028903109131433\n", - "7.028903109131433 7.028903109131266\n", - "7.028903109131266 7.028903109131683\n", - "7.028903109131683 7.02890310913074\n", - "7.02890310913074 7.028903109132932\n", - "7.028903109132932 7.028903109127826\n", - "7.028903109127826 7.028903109139676\n", - "7.028903109139676 7.028903109112146\n", - "7.028903109112146 7.028903109176142\n", - "7.028903109176142 7.028903109027309\n", - "6.942101338925636 6.942101338925613\n", - "6.942101338925613 6.9421013389256405\n", - "6.9421013389256405 6.942101338925613\n", - "6.942101338925613 6.9421013389256405\n", - "6.9421013389256405 6.942101338925613\n", - "6.942101338925613 6.9421013389256405\n", - "6.9421013389256405 6.942101338925613\n", - "6.942101338925613 6.9421013389256405\n", - "6.9421013389256405 6.942101338925613\n", - "6.942101338925613 6.9421013389256405\n", - "6.851890805930003 6.85189080593005\n", - "6.85189080593005 6.851890805929911\n", - "6.851890805929911 6.851890805930244\n", - "6.851890805930244 6.851890805929495\n", - "6.851890805929495 6.8518908059311325\n", - "6.8518908059311325 6.851890805927607\n", - "6.851890805927607 6.851890805935267\n", - "6.851890805935267 6.85189080591856\n", - "6.85189080591856 6.851890805954915\n", - "6.851890805954915 6.851890805875823\n", - "6.759435369971855 6.759435369971832\n", - "6.759435369971832 6.759435369971888\n", - "6.759435369971888 6.759435369971804\n", - "6.759435369971804 6.759435369971999\n", - "6.759435369971999 6.759435369971555\n", - "6.759435369971555 6.759435369972498\n", - "6.759435369972498 6.7594353699705\n", - "6.7594353699705 6.759435369974746\n", - "6.759435369974746 6.759435369965782\n", - "6.759435369965782 6.759435369984626\n", - "6.665716505489154 6.665716505489176\n", - "6.665716505489176 6.665716505489148\n", - "6.665716505489148 6.665716505489176\n", - "6.665716505489176 6.665716505489148\n", - "6.665716505489148 6.665716505489176\n", - "6.665716505489176 6.665716505489148\n", - "6.665716505489148 6.665716505489176\n", - "6.665716505489176 6.665716505489148\n", - "6.665716505489148 6.665716505489176\n", - "6.665716505489176 6.665716505489148\n", - "6.567613376203953 6.567613376203974\n", - "6.567613376203974 6.567613376203947\n", - "6.567613376203947 6.567613376203974\n", - "6.567613376203974 6.567613376203947\n", - "6.567613376203947 6.567613376203974\n", - "6.567613376203974 6.567613376203947\n", - "6.567613376203947 6.567613376203974\n", - "6.567613376203974 6.567613376203947\n", - "6.567613376203947 6.567613376203974\n", - "6.567613376203974 6.567613376203947\n", - "6.4699666067028865 6.46996660670294\n", - "6.46996660670294 6.469966606702801\n", - "6.469966606702801 6.469966606703023\n", - "6.469966606703023 6.469966606702635\n", - "6.469966606702635 6.469966606703384\n", - "6.469966606703384 6.4699666067019415\n", - "6.4699666067019415 6.469966606704716\n", - "6.469966606704716 6.469966606699388\n", - "6.469966606699388 6.469966606709573\n", - "6.469966606709573 6.469966606690119\n", - "6.368041236636866 6.368041236636903\n", - "6.368041236636903 6.368041236636875\n", - "6.368041236636875 6.368041236636903\n", - "6.368041236636903 6.368041236636875\n", - "6.368041236636875 6.368041236636903\n", - "6.368041236636903 6.368041236636875\n", - "6.368041236636875 6.368041236636903\n", - "6.368041236636903 6.368041236636875\n", - "6.368041236636875 6.368041236636903\n", - "6.368041236636903 6.368041236636875\n", - "6.26421759142268 6.264217591422701\n", - "6.264217591422701 6.264217591422673\n", - "6.264217591422673 6.264217591422701\n", - "6.264217591422701 6.264217591422673\n", - "6.264217591422673 6.264217591422701\n", - "6.264217591422701 6.264217591422673\n", - "6.264217591422673 6.264217591422701\n", - "6.264217591422701 6.264217591422673\n", - "6.264217591422673 6.264217591422701\n", - "6.264217591422701 6.264217591422673\n", - "6.158204624972614 6.158204624972657\n", - "6.158204624972657 6.158204624972546\n", - "6.158204624972546 6.158204624972741\n", - "6.158204624972741 6.158204624972408\n", - "6.158204624972408 6.15820462497299\n", - "6.15820462497299 6.158204624971992\n", - "6.158204624971992 6.158204624973712\n", - "6.158204624973712 6.158204624970687\n", - "6.158204624970687 6.158204624976015\n", - "6.158204624976015 6.158204624966719\n", - "6.048033437801331 6.0480334378013625\n", - "6.0480334378013625 6.048033437801335\n", - "6.048033437801335 6.0480334378013625\n", - "6.0480334378013625 6.048033437801335\n", - "6.048033437801335 6.0480334378013625\n", - "6.0480334378013625 6.048033437801335\n", - "6.048033437801335 6.0480334378013625\n", - "6.0480334378013625 6.048033437801335\n", - "6.048033437801335 6.0480334378013625\n", - "6.0480334378013625 6.048033437801335\n", - "5.9376531453636225 5.937653145363635\n", - "5.937653145363635 5.937653145363635\n", - "5.822427178083322 5.822427178083331\n", - "5.822427178083331 5.822427178083331\n", - "5.7059207582861 5.7059207582861164\n", - "5.7059207582861164 5.705920758286089\n", - "5.705920758286089 5.7059207582861164\n", - "5.7059207582861164 5.705920758286089\n", - "5.705920758286089 5.7059207582861164\n", - "5.7059207582861164 5.705920758286089\n", - "5.705920758286089 5.7059207582861164\n", - "5.7059207582861164 5.705920758286089\n", - "5.705920758286089 5.7059207582861164\n", - "5.7059207582861164 5.705920758286089\n", - "5.585925368761323 5.585925368761308\n", - "5.585925368761308 5.585925368761336\n", - "5.585925368761336 5.585925368761308\n", - "5.585925368761308 5.585925368761336\n", - "5.585925368761336 5.585925368761308\n", - "5.585925368761308 5.585925368761336\n", - "5.585925368761336 5.585925368761308\n", - "5.585925368761308 5.585925368761336\n", - "5.585925368761336 5.585925368761308\n", - "5.585925368761308 5.585925368761336\n", - "5.462522975543738 5.462522975543721\n", - "5.462522975543721 5.462522975543777\n", - "5.462522975543777 5.462522975543666\n", - "5.462522975543666 5.462522975543832\n", - "5.462522975543832 5.46252297554361\n", - "5.46252297554361 5.462522975543916\n", - "5.462522975543916 5.462522975543499\n", - "5.462522975543499 5.462522975544083\n", - "5.462522975544083 5.46252297554325\n", - "5.46252297554325 5.462522975544471\n", - "5.337436270892254 5.3374362708922645\n", - "5.3374362708922645 5.3374362708922645\n", - "5.207063493517305 5.207063493517318\n", - "5.207063493517318 5.207063493517318\n", - "5.07643799938903 5.076437999389028\n", - "5.076437999389028 5.076437999389028\n", - "4.9405037570140085 4.940503757014037\n", - "4.940503757014037 4.940503757014009\n", - "4.940503757014009 4.940503757014037\n", - "4.940503757014037 4.940503757014009\n", - "4.940503757014009 4.940503757014037\n", - "4.940503757014037 4.940503757014009\n", - "4.940503757014009 4.940503757014037\n", - "4.940503757014037 4.940503757014009\n", - "4.940503757014009 4.940503757014037\n", - "4.940503757014037 4.940503757014009\n", - "4.80238378349953 4.802383783499558\n", - "4.802383783499558 4.802383783499531\n", - "4.802383783499531 4.802383783499558\n", - "4.802383783499558 4.802383783499531\n", - "4.802383783499531 4.802383783499558\n", - "4.802383783499558 4.802383783499531\n", - "4.802383783499531 4.802383783499558\n", - "4.802383783499558 4.802383783499531\n", - "4.802383783499531 4.802383783499558\n", - "4.802383783499558 4.802383783499531\n", - "4.6605206224255875 4.660520622425614\n", - "4.660520622425614 4.660520622425587\n", - "4.660520622425587 4.660520622425614\n", - "4.660520622425614 4.660520622425587\n", - "4.660520622425587 4.660520622425614\n", - "4.660520622425614 4.660520622425587\n", - "4.660520622425587 4.660520622425614\n", - "4.660520622425614 4.660520622425587\n", - "4.660520622425587 4.660520622425614\n", - "4.660520622425614 4.660520622425587\n", - "4.51469902471077 4.514699024710763\n", - "4.514699024710763 4.514699024710763\n", - "4.366521747676676 4.366521747676719\n", - "4.366521747676719 4.366521747676636\n", - "4.366521747676636 4.366521747676747\n", - "4.366521747676747 4.366521747676608\n", - "4.366521747676608 4.366521747676747\n", - "4.366521747676747 4.366521747676608\n", - "4.366521747676608 4.366521747676747\n", - "4.366521747676747 4.366521747676608\n", - "4.366521747676608 4.366521747676747\n", - "4.366521747676747 4.366521747676608\n", - "4.212778346685114 4.212778346685158\n", - "4.212778346685158 4.212778346685075\n", - "4.212778346685075 4.212778346685158\n", - "4.212778346685158 4.212778346685075\n", - "4.212778346685075 4.212778346685158\n", - "4.212778346685158 4.212778346685075\n", - "4.212778346685075 4.212778346685158\n", - "4.212778346685158 4.212778346685075\n", - "4.212778346685075 4.212778346685158\n", - "4.212778346685158 4.212778346685075\n", - "4.05788314692865 4.05788314692867\n", - "4.05788314692867 4.057883146928642\n", - "4.057883146928642 4.05788314692867\n", - "4.05788314692867 4.057883146928642\n", - "4.057883146928642 4.05788314692867\n", - "4.05788314692867 4.057883146928642\n", - "4.057883146928642 4.05788314692867\n", - "4.05788314692867 4.057883146928642\n", - "4.057883146928642 4.05788314692867\n", - "4.05788314692867 4.057883146928642\n", - "3.8968709545674525 3.896870954567428\n", - "3.896870954567428 3.8968709545674556\n", - "3.8968709545674556 3.896870954567428\n", - "3.896870954567428 3.8968709545674556\n", - "3.8968709545674556 3.896870954567428\n", - "3.896870954567428 3.8968709545674556\n", - "3.8968709545674556 3.896870954567428\n", - "3.896870954567428 3.8968709545674556\n", - "3.8968709545674556 3.896870954567428\n", - "3.896870954567428 3.8968709545674556\n", - "3.7325998580345017 3.7325998580344866\n", - "3.7325998580344866 3.7325998580345146\n", - "3.7325998580345146 3.7325998580344866\n", - "3.7325998580344866 3.7325998580345146\n", - "3.7325998580345146 3.7325998580344866\n", - "3.7325998580344866 3.7325998580345146\n", - "3.7325998580345146 3.7325998580344866\n", - "3.7325998580344866 3.7325998580345146\n", - "3.7325998580345146 3.7325998580344866\n", - "3.7325998580344866 3.7325998580345146\n", - "3.5647732327373483 3.564773232737334\n", - "3.564773232737334 3.5647732327373616\n", - "3.5647732327373616 3.564773232737334\n", - "3.564773232737334 3.5647732327373616\n", - "3.5647732327373616 3.564773232737334\n", - "3.564773232737334 3.5647732327373616\n", - "3.5647732327373616 3.564773232737334\n", - "3.564773232737334 3.5647732327373616\n", - "3.5647732327373616 3.564773232737334\n", - "3.564773232737334 3.5647732327373616\n", - "3.3928735301808866 3.392873530180884\n", - "3.392873530180884 3.392873530180884\n", - "3.2168023839561464 3.2168023839561677\n", - "3.2168023839561677 3.2168023839561397\n", - "3.2168023839561397 3.2168023839561677\n", - "3.2168023839561677 3.2168023839561397\n", - "3.2168023839561397 3.2168023839561677\n", - "3.2168023839561677 3.2168023839561397\n", - "3.2168023839561397 3.2168023839561677\n", - "3.2168023839561677 3.2168023839561397\n", - "3.2168023839561397 3.2168023839561677\n", - "3.2168023839561677 3.2168023839561397\n", - "3.036456199504477 3.036456199504496\n", - "3.036456199504496 3.0364561995044403\n", - "3.0364561995044403 3.036456199504496\n", - "3.036456199504496 3.0364561995044403\n", - "3.0364561995044403 3.036456199504496\n", - "3.036456199504496 3.0364561995044403\n", - "3.0364561995044403 3.036456199504496\n", - "3.036456199504496 3.0364561995044403\n", - "3.0364561995044403 3.036456199504496\n", - "3.036456199504496 3.0364561995044403\n", - "2.851728292725812 2.851728292725821\n", - "2.851728292725821 2.851728292725821\n", - "2.6625237301719222 2.662523730171929\n", - "2.662523730171929 2.662523730171929\n", - "2.468741322508218 2.4687413225082335\n", - "2.4687413225082335 2.4687413225082055\n", - "2.4687413225082055 2.4687413225082335\n", - "2.4687413225082335 2.4687413225082055\n", - "2.4687413225082055 2.4687413225082335\n", - "2.4687413225082335 2.4687413225082055\n", - "2.4687413225082055 2.4687413225082335\n", - "2.4687413225082335 2.4687413225082055\n", - "2.4687413225082055 2.4687413225082335\n", - "2.4687413225082335 2.4687413225082055\n", - "2.27024409565732 2.2702440956573238\n", - "2.2702440956573238 2.2702440956573238\n", - "2.066922851368873 2.066922851368859\n", - "2.066922851368859 2.0669228513689144\n", - "2.0669228513689144 2.0669228513688314\n", - "2.0669228513688314 2.0669228513689144\n", - "2.0669228513689144 2.0669228513688314\n", - "2.0669228513688314 2.0669228513689144\n", - "2.0669228513689144 2.0669228513688314\n", - "2.0669228513688314 2.0669228513689144\n", - "2.0669228513689144 2.0669228513688314\n", - "2.0669228513688314 2.0669228513689144\n", - "1.8586818002665524 1.8586818002665353\n", - "1.8586818002665353 1.8586818002665353\n", - "1.645376401700064 1.645376401700087\n", - "1.645376401700087 1.6453764017000592\n", - "1.6453764017000592 1.645376401700087\n", - "1.645376401700087 1.6453764017000592\n", - "1.6453764017000592 1.645376401700087\n", - "1.645376401700087 1.6453764017000592\n", - "1.6453764017000592 1.645376401700087\n", - "1.645376401700087 1.6453764017000592\n", - "1.6453764017000592 1.645376401700087\n", - "1.645376401700087 1.6453764017000592\n", - "1.4269031269493535 1.4269031269493277\n", - "1.4269031269493277 1.4269031269493833\n", - "1.4269031269493833 1.4269031269493\n", - "1.4269031269493 1.4269031269493833\n", - "1.4269031269493833 1.4269031269493\n", - "1.4269031269493 1.4269031269493833\n", - "1.4269031269493833 1.4269031269493\n", - "1.4269031269493 1.4269031269493833\n", - "1.4269031269493833 1.4269031269493\n", - "1.4269031269493 1.4269031269493833\n", - "1.2031126046612108 1.2031126046612273\n", - "1.2031126046612273 1.2031126046611997\n", - "1.2031126046611997 1.2031126046612273\n", - "1.2031126046612273 1.2031126046611997\n", - "1.2031126046611997 1.2031126046612273\n", - "1.2031126046612273 1.2031126046611997\n", - "1.2031126046611997 1.2031126046612273\n", - "1.2031126046612273 1.2031126046611997\n", - "1.2031126046611997 1.2031126046612273\n", - "1.2031126046612273 1.2031126046611997\n", - "0.9738995159313504 0.9738995159313818\n", - "0.9738995159313818 0.9738995159313263\n", - "0.9738995159313263 0.9738995159313818\n", - "0.9738995159313818 0.9738995159313263\n", - "0.9738995159313263 0.9738995159313818\n", - "0.9738995159313818 0.9738995159313263\n", - "0.9738995159313263 0.9738995159313818\n", - "0.9738995159313818 0.9738995159313263\n", - "0.9738995159313263 0.9738995159313818\n", - "0.9738995159313818 0.9738995159313263\n", - "0.7391086464810588 0.7391086464810508\n", - "0.7391086464810508 0.7391086464810508\n", - "0.49866748451053056 0.4986674845105386\n", - "0.4986674845105386 0.4986674845105386\n", - "0.2523673899554364 0.25236738995544034\n", - "0.25236738995544034 0.25236738995544034\n", - "8.510551113793952e-05 8.51055111369151e-05\n", - "8.51055111369151e-05 8.51055111369151e-05\n", - "[ nan nan nan nan\n", - " nan nan nan nan\n", - " nan nan nan nan\n", - " nan nan nan nan\n", - " nan nan nan nan\n", - " nan nan nan nan\n", - " nan nan nan nan\n", - " nan nan nan nan\n", - " nan 8.56382076e+00 nan nan\n", - " nan nan nan nan\n", - " nan nan 8.06148326e+00 7.99925703e+00\n", - " nan nan nan 7.73222943e+00\n", - " nan nan nan nan\n", - " 7.36085774e+00 nan nan 7.11583155e+00\n", - " nan nan nan nan\n", - " nan nan nan nan\n", - " nan nan nan 5.93765315e+00\n", - " 5.82242718e+00 nan nan nan\n", - " 5.33743627e+00 5.20706349e+00 5.07643800e+00 nan\n", - " nan nan 4.51469902e+00 nan\n", - " nan nan nan nan\n", - " nan 3.39287353e+00 nan nan\n", - " 2.85172829e+00 2.66252373e+00 nan 2.27024410e+00\n", - " nan 1.85868180e+00 nan nan\n", - " nan nan 7.39108646e-01 4.98667485e-01\n", - " 2.52367390e-01 8.51055111e-05]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\cwhanse\\AppData\\Local\\Continuum\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:2: RuntimeWarning: invalid value encountered in log\n", - " \n" + "1.4569048007936902e-14\n", + "9.680000 9.680000\n", + "9.680000 9.680000\n", + "9.656508 9.656508\n", + "9.632448 9.632448\n", + "9.607871 9.607871\n", + " ... \n", + "0.973900 0.973900\n", + "0.739109 NaN\n", + "0.498667 0.498667\n", + "0.252367 0.252367\n", + "0.000085 0.000085\n", + "Length: 102, dtype: float64\n" ] } ], "source": [ - "def _next_current(v, i, iph, io, rsh, rs, nNsVth):\n", - " next_X = np.log((v + iph * rs + io * rs ) / nNsVth - (1 + rs / rsh) * (v + i * rs) / nNsVth) - np.log(io * rs / nNsVth)\n", - " return (nNsVth * next_X - v) / rs\n", + "# converge IV curves to remove small errors in current\n", + "\n", + "from scipy.optimize import newton\n", "\n", - "eps = 5e-17\n", + "def _fi(i, v, iph, io, rs, rsh, nNsVth):\n", + " return iph - io * np.expm1((v + i * rs) / nNsVth) - (v + i * rs) / rsh - i\n", + "\n", + "def _dfdi(i, v, iph, io, rs, rsh, nNsVth):\n", + " return -io * rs / nNsVth * np.exp(v / nNsVth) * np.exp(i * rs / nNsVth) - rs / rsh - 1\n", "\n", - "def converge_current(v, i, iph, io, rsh, rs, nNsVth):\n", - " i_conv = np.nan * i\n", - " max_iter = 10\n", - " for k in range(len(i)):\n", - " converged = False\n", - " iter=0\n", - " i_last = i[k]\n", - " while not converged and (iter < max_iter):\n", - " iter += 1\n", - " i_next = _next_current(v[k], i_last, iph, io, rsh, rs, nNsVth)\n", - " print(i_last, i_next)\n", - " converged = np.abs(i_next - i_last) < eps\n", - " i_last = i_next\n", - " if converged:\n", - " i_conv[k] = i_next\n", - " return i_conv\n", + "method = 'lambertw'\n", + "i_converged = pd.Series(index=i_pvl_mod['current'][method], data=np.nan)\n", + "for (v, i) in zip(Vmod, i_pvl_mod['current'][method]):\n", + " try:\n", + " i_converged[i] = newton(func=_fi, x0=i, fprime=_dfdi, args=(v, photocurrent, saturation_current, resistance_series*Ns,\n", + " resistance_shunt*Ns, nVth*Ns), tol=1e-16)\n", + " except:\n", + " i_converged[i] = np.nan\n", "\n", - "i_conv = converge_current(Vmod, Imod_lambertw, iph=photocurrent, io=saturation_current,\n", - " rsh=resistance_shunt*Ns, rs=resistance_series*Ns, nNsVth=nVth*Ns)\n", - "print(i_conv)" + "print(np.max(np.abs(i_converged - i_pvl_mod['current'][method])))\n", + "print(i_converged)" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 24, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "[4.18332036e-13 4.18332036e-13 1.41179329e+01 2.65394398e+01\n", - " 2.94990578e+01 3.05834944e+01 3.12530092e+01 3.17322097e+01\n", - " 3.21092076e+01 3.24247031e+01 3.26963363e+01 3.29342441e+01\n", - " 3.31462463e+01 3.33383632e+01 3.35152204e+01 3.36803625e+01\n", - " 3.38364987e+01 3.39785595e+01 3.41150955e+01 3.42476392e+01\n", - " 3.43689905e+01 3.44888708e+01 3.46027584e+01 3.47126789e+01\n", - " 3.48201046e+01 3.49223410e+01 3.50240373e+01 3.51203865e+01\n", - " 3.52170039e+01 3.53088833e+01 3.54010016e+01 3.54895269e+01\n", - " 3.55776646e+01 3.56637130e+01 3.57483355e+01 3.58325946e+01\n", - " 3.59141211e+01 3.59971290e+01 3.60759388e+01 3.61566613e+01\n", - " 3.62345531e+01 3.63128457e+01 3.63906054e+01 3.64667898e+01\n", - " 3.65446380e+01 3.66190089e+01 3.66951847e+01 3.67699424e+01\n", - " 3.68445385e+01 3.69199690e+01 3.69932423e+01 3.70682938e+01\n", - " 3.71416084e+01 3.72155496e+01 3.72899139e+01 3.73629731e+01\n", - " 3.74378053e+01 3.75107997e+01 3.75849482e+01 3.76592460e+01\n", - " 3.77329181e+01 3.78083780e+01 3.78819070e+01 3.79570806e+01\n", - " 3.80320990e+01 3.81071785e+01 3.81836733e+01 3.82588434e+01\n", - " 3.83358378e+01 3.84122458e+01 3.84895155e+01 3.85675577e+01\n", - " 3.86452798e+01 3.87248880e+01 3.88033015e+01 3.88835501e+01\n", - " 3.89637571e+01 3.90448195e+01 3.91268299e+01 3.92088771e+01\n", - " 3.92927108e+01 3.93759123e+01 3.94611330e+01 3.95468213e+01\n", - " 3.96331252e+01 3.97202963e+01 3.98083651e+01 3.98973641e+01\n", - " 3.99873263e+01 4.00782783e+01 4.01702493e+01 4.02632846e+01\n", - " 4.03574151e+01 4.04526655e+01 4.05490819e+01 4.06466908e+01\n", - " 4.07455389e+01 4.08456524e+01 4.09470789e+01 4.10498294e+01\n", - " 4.11539730e+01 4.12595411e+01]\n", - "[9.68 9.68 9.65650784 9.63244556 9.60779931 9.58255493\n", - " 9.5566979 9.53021335 9.50308605 9.47530041 9.44684045 9.4176898\n", - " 9.38783169 9.35724897 9.32592405 9.2938389 9.26097509 9.22731372\n", - " 9.19283542 9.15752039 9.12134829 9.08429835 9.04634925 9.00747917\n", - " 8.96766577 8.92688614 8.88511684 8.84233385 8.79851258 8.75362781\n", - " 8.70765375 8.66056395 8.61233134 8.56292819 8.51232608 8.46049593\n", - " 8.40740792 8.35303153 8.29733549 8.24028778 8.18185559 8.12200532\n", - " 8.06070256 7.99791206 7.93359772 7.86772254 7.80024866 7.73113726\n", - " 7.66034862 7.58784203 7.51357579 7.4375072 7.35959253 7.27978695\n", - " 7.1980446 7.11431846 7.0285604 6.94072109 6.85075003 6.75859548\n", - " 6.66420446 6.56752268 6.46849456 6.36706314 6.26317012 6.15675573\n", - " 6.04775881 5.93611666 5.82176509 5.70463836 5.5846691 5.46178834\n", - " 5.33592542 5.20700796 5.07496183 4.93971111 4.80117802 4.6592829\n", - " 4.51394416 4.36507824 4.21259952 4.05642033 3.89645087 3.73259915\n", - " 3.56477095 3.39286976 3.21679675 3.03645067 2.85172781 2.66252195\n", - " 2.4687243 2.27022343 2.06690518 1.85865265 1.6453461 1.42686285\n", - " 1.20307729 0.97386073 0.73908137 0.49860421 0.25229096 0. ]\n" - ] + "data": { + "text/plain": [ + "'1.1.0'" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" } ], - "source": [ - "print(Vmod)\n", - "print(Imod)" - ] + "source": [] }, { "cell_type": "code", From ec66a15e2a8fbc6511b9f6757d20f662c7bfd8c0 Mon Sep 17 00:00:00 2001 From: Cliff Hansen Date: Thu, 5 Mar 2020 13:08:24 -0700 Subject: [PATCH 13/16] update basic_iv_curves --- notebooks/basic_iv_curves.ipynb | 73 ++++++++++++++++++--------------- 1 file changed, 40 insertions(+), 33 deletions(-) diff --git a/notebooks/basic_iv_curves.ipynb b/notebooks/basic_iv_curves.ipynb index 48bd01f..e5001a0 100644 --- a/notebooks/basic_iv_curves.ipynb +++ b/notebooks/basic_iv_curves.ipynb @@ -305,7 +305,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 7, @@ -445,7 +445,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -455,27 +455,39 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "1.4569048007936902e-14\n", - "9.680000 9.680000\n", - "9.680000 9.680000\n", - "9.656508 9.656508\n", - "9.632448 9.632448\n", - "9.607871 9.607871\n", - " ... \n", - "0.973900 0.973900\n", - "0.739109 NaN\n", - "0.498667 0.498667\n", - "0.252367 0.252367\n", - "0.000085 0.000085\n", - "Length: 102, dtype: float64\n" + "9.680000 0.000000e+00\n", + "9.680000 0.000000e+00\n", + "9.656508 0.000000e+00\n", + "9.632448 -1.776357e-15\n", + "9.607871 0.000000e+00\n", + " ... \n", + "0.973900 -4.773959e-15\n", + "0.739109 NaN\n", + "0.498667 4.107825e-15\n", + "0.252367 1.276756e-15\n", + "0.000085 -1.456905e-14\n", + "Length: 102, dtype: float64\n", + "4.440892098500626e-16\n" ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEDCAYAAAA849PJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xl0ZHWZN/DvU2uSTtJJb0mvdEOvIDQtEUF0XMAR0QFFUNSZg2fwZXyPvK++M6Mv6hnHceYVPfqOzlHGQ4/iMI6y6CvSCgOyeRBF6AYamt6bZun0kvSWTtLZquo+7x93qXtvbqVu1a1UKqnv5xxOV27d1L1d2r/n/p7nt4iqgoiI6k9sqm+AiIimBgMAEVGdYgAgIqpTDABERHWKAYCIqE4xABAR1amaDwAicruI9IrISxX6vAdFpE9Efl3g/e+KyGAlrkVEVMtqPgAA+HcAl1fw874J4C+C3hCRLgBtFbwWEVHNqvkAoKpPADjhPiYiZ1lP8s+KyO9EZG0Jn/cogAH/cRGJwwwOn496z0RE00Fiqm+gTBsBfEpV94rImwH8K4B3RfzMmwBsUtXDIhL5BomIat20CwAi0gzgLQB+5mqo09Z7VwP4asCvHVTV90zwmYsAXAvgHRW9WSKiGjbtAgDMtFWfqp7vf0NVfwHgF2V85gYAKwHss4JKk4jsU9WVke6UiKiG1XwNwE9V+wG8IiLXAoCY1kf8zPtVtVNVl6vqcgBDbPyJaKar+QAgIncCeArAGhHpFpEbAHwcwA0i8gKA7QCuKuHzfgfgZwAutT6vYGqIiGgmEy4HTURUn2q+B0BERJOjpovA8+bN0+XLl0/1bRARTRvPPvvsMVWdH+bcmg4Ay5cvx5YtW6b6NoiIpg0ReS3suUwBERHVKQYAIqI6xQBARFSnGACIiOoUAwARUZ1iACAiqlMMAEREdYoBgIgohN9sP4KNT7w81bdRUQwAREQhPLKzB7c/+epU30ZFMQAQEYWgCsy0zQIZAIiIQlAAM6z9ZwAgIgrD7AHMrBDAAEBEFIJi5u2dwgBARBQGawBERPVJwQBARFSXVBUyw8rADABERCGwB0BEVKdUOQyUiKhucRgoEVEdmnmDQBkAiIhCMYvAMwsDABFRCArMuCIAAwARURgsAhMR1SeFhioCP767F7uO9FfhjqKrSAAQkctFZLeI7BORmwPe/4SIHBWRrdZ/n6zEdYmIqiXsMNDP3Pk87nrmwKTfTyUkon6AiMQB3Arg3QC6AWwWkU2qusN36t2qelPU6xERTYWw+wEYCsSmyXDRSvQALgSwT1X3q+oYgLsAXFWBzyUiqhmKcEtBGKqIT5PkeiVuczEAd3+n2zrm9yEReVFEfi4iSwt9mIjcKCJbRGTL0aNHK3B7RETRhe0B5Aytqx5A0N/UP2fiVwCWq+p5AB4BcEehD1PVjarapapd8+fPr8DtERFFF3YimKGKWKx+AkA3APcT/RIAh9wnqOpxVR21fvw3ABdU4LpERFUTdkewnKGI11EPYDOAVSKyQkRSAK4DsMl9gogsdP14JYCdFbguEVEVhZsJbBaBJ/1mKiLyKCBVzYrITQAeAhAHcLuqbheRrwLYoqqbAPxPEbkSQBbACQCfiHpdIqJqClMDMAwzUTRdUkCRAwAAqOoDAB7wHfuy6/UXAHyhEtciIpoKYfYDyKkZAOopBURENOOF2RHM0OnVA2AAICIKIUwPwDDMP8sZBjqazWFPzwBODWVKv7kyMQAQEYUQZikIJwVURst68OQw/vTbT+Dx3b2l/3KZGACIiEIwl4MOmQIqoweQTsYBmD2BamEAICIKIcyGMM4ooHICQMJsjseyRsm/Wy4GACKikIqOAjLsFFDpASBlBYBRBgAiouhGMjkcOTWCkUzxtMpIJofDp4YLpmBUgaFR85xCchFGAaUZAIiIKucjtz2Fi255FI/uLF5Y3fLqSVx8y2N4sftU4PsKxe6eAbz1G48X/Ayr/S9rJnAqzgBARFQxrx4fQks6gXMXzy56rvP0HiLNoxq8NJyTAiqjBiAiSCViLAITEVXCSCaHj120DMvmNhU9t9gIHnebnzUmDgDlTgRLJ2IsAhMRRZUzFKNZA03JcCveFBvB4wkAueAAYJ9T7lIQ6USMKSAioqiGxrIAgKZUPNT59kN9oRE86toRIGsEN9L5InDYu/RKJ+IYzTAAEBFFMjxm5tIbQwYAO31T6OHd3QPIFUsBRegBjOUYAIiIIhmyAkDYHoDqxGP43U1+pmAKqPx5AIA5F2A0xJDVSmEAIKIZKR8AwtUAcsWWcSjSA1BVjFjpmyg9ANYAiIgiKrUG4E/f/PL5g1h+8/0YHDU/x10DyASkaa7/0WZ8+LanPJ9RqnQizlFARERRlZ4CMv+0sze3PbEfAPDqsdOe94HgHkBLOoFhK30TKQXEeQBERNEMlVkEthvvlgYzdTQwYvcA8oLmAbQ1JZ3X5e4HwxQQEVEF5FNAIecB+GoArU4AMDdocc/+DRoG2t6Ucl6XPREsyYlgRESR2T2AWaHnAXhn8TanJ+gBBIwCcvcA/BPBHt/Vi3V/9yBeOhi8zpAtFWcPgIgoslLnARi+WbwtDWaDnu8B5M8NTgHlewD+GkDWUAxnciiwhJCDRWAiogooeRioMwrI/DmoBmA/2OcCU0D5HoB/EJCdPio2OIhFYCKiChgayyKViIUekaO+FJC9QcuANQwUqkhaazyUmgIynBFGE98Li8BENCM9vf84rvn+H5zUjG0kk8NHbnsKz71+MvD3nnr5OP78B08jkzNw6+P78K2HdmNPzwCu+f4fsPNwPz5w6+9x4vQYfv3iIVzwjw/jK5u2AzB7AEFDQL+yaTuu/N6TnmNX3fp7/OcfXwcAXPS1R/HIjh6n0XZSQACScbMBL5YCOjk0hq5/ehj3Pt9t/m7IHkC1i8Dh+kZERBH99JnXseW1k9h6oA8XnzXXOb7jcD+efuUENr9yAm9c1j7u936/7xie3HcMvQOjeHhHD7KGgWVzm7DltZP45daD2HqgD3t6BvDsaydx/PQYntx3DABwwRntgfn/06NZHB0Y9Rx74UCf8zprKE6cHnMa7QvOmAPArAEk4jEAucAA4A42WUNxbHAMmax5nn12sR5AKh5H1lBkc4Z1rcnFHgARTbpMzsDju8xduZ4/4H3S33NkAADQN5wJ/F27sT4+OIqTQ2MYHss56+V0nzC3ZxwYyTpPzqetlM0HNizGF69YN+7zEvGYpwEPmtTVNzyGnKFIxATXXLAEgDkTOBm3U0Djn9KTrgbb/siE1WMwCvQAPvZvf8SX7t3m/JxOWhvDV2lBOAYAIpp0m189gf6RLESA51/v87y3u8cKAEPBAaB3YAQAcHxwDCcGxzCSMZw1d7pPDgEw0zT+AFBIIiaeBjxov+C+oQwM9Y7nV504BWTXDID83gL2U3yhrSKPD47h2GC+N2LvC1ytNBADABFNukd29CKViOE9Z3fi+df7PJOq9jgBYCzwd3utHsChU8MYGM1iJJNzGu2DfWYPoH844zw1nx7LFdyyETCfyt1FXH8AaErFcWo4A0PV02CbKSArAAQUgVOeHoAVAGLeHgDgjQDxmHh6IKkqbwzPAEBEk0pV8fDOI3jrynm4ZOVcHBscRffJYef93UcGARTuAdgpoL095nnDmRxGrKGSxwbNoOFOAdk7gRWSjMeQcQ3jHPGdO2dWCn3DGRiGekbzKPJpnqCZwIEpIN8jv78HkIyLZ2lpO4iwB0BEM8Le3kEcODGMy9Z1YINV5N1qFV1PnM6nQE4G9AByhjrv7+01ewrDmRyGx7wNZL8rBQTAWcEzSML31O1ff3/OrBT6hzPIqXqKtuoaBhpUN4jHvOcC+aCQrwF4I4BZj8jft329YhPGKoUBgIgm1cM7egAAl65bgDWdLWhIxpw6gJ3+6WhN41RAEfj46VHnaXqP1QNQNRt8t4GRrKdwOjRaeDJVImY+dduN9IhvC8b2phT6hjJQHV+0nSgF5OakgOLeBt3fA7DvxWZfz6hSBGAAIKJJ9cjOHqxfMhsdrQ1IxmM4b3GbMxLIDgBvXjE3MAXkHq7pfu2vF/SPZDxpnwl7AHHvU/yIb+Zte1MSfcNjMFTHTSJLOCmgYgHAOj8W8/wsvhpAMh7z9CbsAFClDgADABFNnt6BEWw90IfL1nU4x85f1obtB/sxms1h95EBzG5MYk1ni5nb96Vj7ALwnFkpz3F/sBgYySKTM5wG9PTYRAHAO5LHfc2YABuWtePC5XORM/wpICAZs3934hy94aSA7B5A8DDQuG9EUj4FxB4AEU1zj+/qhSpw2dn5ALBhaRvGcgZ2HOrHnp4BrOlocZZR8KeBjvabAeDsha2e4/56Qb9VBLaXZJ6oB+As52AFgNGMtwG+/i3L8X8/vH78MFDPPIAiPYACw0D9AcBfBHZ+nzUAIpruHt7Ri8VtjVjb2eIcswvBz73eh91HBrC6sxltjWbD7W/Yj1oF4HULWzzH/YFiYDhjBQAzkEw0F8BO69hP3p4egKvBN4zCw0CDisBu/lFA9naS/pnAiVhwEbhaSSAGACKaFMNjOTy57yjefXaHZ/RL5+wGLJzdgIdeOoL+kaynB+BP7fT2j6C1IYFFbY2e4/7z+q0isJ0qmqgIbKdl7Cdvdw3A3eAbOn4YqD1MMxMyBZSfCWweDyoqZwOLwBN+fMUwABDRpPj9vmMYyRh4tyv9Y9uwrA3PvHoCALB6ogAwMIoFrQ2Y25wGkG8g3UXYplTcGQYaJgU0rgjsSgG5G/ycqidwqWq+B1AkBWR/tl0Ezo8C8vcAxPN3sYvE02oYqIhcLiK7RWSfiNwc8H5aRO623n9aRJZX4rpEVLse2dmDloYELlwxZ9x7G5bmF30zA4DZcPtH9/QOjGJ+cxrzms33O1oaxn3W4rZGjGUNDI5knQAwUQrITstkrBTQqKcI7C36esb2Ix88MkUe0e0GPOlfC8h/L/GYrwhsX2uapIBEJA7gVgDvBXA2gI+KyNm+024AcFJVVwL4NoBvRL0uEdUuw1A8srMX71izwDND1rZhWRsAYEFLGu2zUmhrtHoA/iLwwCgWtKYxz+oBLGobHwCWtJvpoYHRLJrScaQSMQyWMgrINXzUXQPI+WoAULMBN5dvCJsCitm/CmD8RLBkXDzBxEkBVWlF6EosB30hgH2quh8AROQuAFcB2OE65yoAX7Fe/xzA90REdJLGOn3qx89WbTU9Ks/cWSms6WzB2s5WrOlswfyW9FTfEpXgmVdO4IdP7g8cwQKYhdVjg6O4bN2CwPffsHg2EjHBGqs43JSKIxWPOUXgezYfwIPbj+BQ3zDec06HKwA04jlrEllrQwL9I1ksbs/XB1KJGJrTiYI1gM/97AXs7TUnlN1wx2b878vXeorA7id+Q9UJCN95ZA/2HzuNcxbPhqri1sdfxn9725mePQDc7G/FHjZaaBhoIhbzrSzqLRpPtkoEgMUADrh+7gbw5kLnqGpWRE4BmAvgmP/DRORGADcCwLJly8q6oWODo1XdVYdKo1C82H0KP3u22zk2r9kMCGs6WrG2swVrF7Zg1YKW0Pu5UnXkDMX3f7sP//zwHsxtTqOzdfwTue1tq+bhXWuDA0BDMo6/evuZWGcN7xQRzG5K4pRVA/jBk/vR0z+KcxbPxrvWdqC9KYmPXrgUb1+9AL9+8bD5+avnwzAUF66Y62zmko7H0JSKF0wBPbnvmPPe/qOn8aPfv4ILzsino/xFYDsltK3b3MxdAHzkTcuw7WDfhIXaXIFhoONqAHFvDcBJAVWpBlCJABC0w4H/9sOcYx5U3QhgIwB0dXWV9TX8/L+/pZxfoyo7NjiK3UcGsOvIAHYf6ceuIwP46TOvOUU5EWD53FlY29li9RZasKazFcvmNIXe5o8qp3dgBH999wt4ct8xXLl+Eb529bloTpffhHzuPWs9P7c1Jq0lGBTdJ4fxkTctxd//2TnO+7dcfZ5nCYgz5jTh85evxdP7jzvH7B5AoSJwJqdoTMXRb+3zayjgfgB3N9CGkW+Q7dSNCHDL1ecW/bvpuFFABWoAMf8ooOoWgSsRALoBLHX9vATAoQLndItIAsBsACcqcG2axuY1pzFvZRqXrJznHMsZitdPDGH3kX7sPDzgBIgHtx9x/lE0JuNY3dFs9hg6W7HOChD2SBGqvCf3HsNn796KwdEMvvGhc/HhrqXj8tlRtTelcHJoDH1DGQyN5bDYN/QTABoS+R5hQ9J83dKQ34s3lTB7AENjwSmgrGFgVjp/PtS77o4nALh6AE4gCPl38c8DKLQn8PjF4Ozbmj4poM0AVonICgAHAVwH4GO+czYBuB7AUwCuAfDYZOX/aXqLxwQr5s3CinmzcPkbFjrHh8ay2Nsz6ASEXUf68ejOXtyzxZ1GSpvpI6fH0IpVHc1OQ0Gly+YM/Muje/G9x/dh5fxm/OSTb3by9pU2uymJAyeGnKWil7Q3jTsnGRdnDf1GJwDkm7FUPIZZ6QQGRoJ7ANlc/vcAcw6Ae1LXuBqAEwDsHkC4EDB+GKjVA/DVw5OuhelEpOrzACIHACunfxOAhwDEAdyuqttF5KsAtqjqJgA/BPBjEdkH88n/uqjXpfrSlEpg/dI2rF/a5jl+dMBOI/VbqaQB/PiPrzk1oJgAy+dZaaSOVqxdaAaIpe1NnhEfNN7hU8P4zJ1b8cyrJ/DhriX4ypXnoCk1eduItzclsa07g4N95i5fS9rH9wBEBA2JGE6P5dBgbZ/oTkOlEnE0pxPo6R8JvEYmZ3geCIbHcoGLsQFmI2wHBCmxB5BfDtqb0gkaBgqYASMRF9c8gOnTA4CqPgDgAd+xL7tejwC4thLXInKb35LG/JY03rrKm0Z69fhpT31h+6F+/NdL+TRSUyqOVR0tTvrI7jH4Fx2rV4/t6sHf3PMCRrMGvv2R9fjghiWTfs02KwVk9wCWBvQAAKAxFcfpsRzSVkM+yxMAYmhKJXC6wCigrDG+B+BOAcULDAONlRgBctZKok5Ov8BSEM6yFIYiEa/+aqCTF86Jpkg8JjhrfjPOmt+MK871ppH29Ax66gu/2dGDuzbnB7EtaEl7Cs5rO1uwckH9pJHGsga+9Zvd2PjEfqxb2IpbP7YBZ85vrsq1ZzcmMZo18PLRQTSnE2htDG6e7P8t7D/de/GaReB44GqgqoqcoU7PAQCGxwxPD2BcDWBcDyBcBMjm1LMbWKGlIPx7DOeLwNOoB0A0HTSlEjh/aRvOd6WRVBVHB0exy1Vw3t3Tjzuees3ZYSoeEyyf24S1VkCwewtL2htnVBrpwIkh/I87n8fWA334i4vOwJfet66qgc+exbvt4CksaW8smG93AkBi/ASzVDyGpnQicBioPWfBPbR4NJPzFYHz5wfXAML9XTI59UyAK7wUhL26qDXyzXf+ZGMAoLomIljQ0oAFLQ34k9XznePZnIFXjw956gvbDp7C/dsOO+fMSsWx2u4tdLRg7UIzQBSaHFTLHnzpMD738xcBBf7142/09JyqxV4PaPeRAbzd9b+FX6OvB+CWtoaBZnKK0WwOadeoIXu0TcMERWD/MNC4lFYD+OY15+E/n34dOcNwhoAChXf48i9MZ19/2hSBiWaiRDyGlQuasXJBM953Xr4xHBzNYk+P2Vuwg8N/vXQEdz6TTyN1tKY9w1PXWGkkd2NUK0YyOdzywE7c8dRrWL9kNr770Tdi2dzg3Ptks5eDyOQ0cAiozU7hBAUAexgoYK4I6v7OnR5A0nvMvZewpwag6jT8YXsA13YtxbVdS/HFe7c5T/duQcNAgfyoIacGwBQQUe1pTifwxmXteOOy/OxRVUXvwGh+QtthM5X0o5ePO0uSxGOCM+fNGldfmCjVMdleOXYaN/30OWw/1I9PvnUFPn/5Wk8+vdrcPaegIaC2fA0gIAWUiDlF4cHRLNpdRX07zeIPHKddcwbGr/4Zs45b74euARjeGoCvgbfZAcdemI5FYKJpRkTQ0dqAjtYGT+rCTCOd9kxoe6G7z1nKADADijmprRXrFlqppM5WzG5KBl2qYu7behBf/MU2JBMx/PD6Lly6bvySzdXW5vo7Bw0BtdlP8O4neXtuQCoewyxrqKp/MphdaG30BYAhV8HYvW6doa4nf5RWA8jm1JMCsht0fw9gXBEY3pnDk40BgGiSmGmkFqxc0II/W58/PjiadVJIu4/0Y+eRATyw7TDufOZ155zO1gasXZhfAmNtZyvOmt8c+Ql9eCyHf/jVdty1+QDetLwd/3LdhnGbrUyV9pJ7APmGPBWPYdjIWT0A87h/OQj7Kdu/vpR7yKi7gc4Z7hSQ+WfoIrDhLQIXXgrCVwSu7oZgDABE1dacTuCCM9o9i5CpKnr6Rz0T2nYdGcAf9uXTSImY4Mz5s5z0kT0iaXFbuDTS3p4BfPqnz2Fv7yBueudKfPayVU6KoxY0JGNIJWIYyxqeFT797Cf4dNI7/HM4k/OkgIZ8Q0HtNXfGpYBcgSLmSwHZKRr/k3sx/hTQRHsCA+OLwEwBEdUREUHn7AZ0zm7AO9bkV9DM5Ay8cuy0U1/YfWQAz712Er96Ib/cVks64ZrMZo5GWt3RgtlWUVVV8bNnu/Hl+15CczqB//jLC/G2VYVH2UwVEUFbY9LM3U+QAgsqAts9I3cKyD8UND8KyBv03Kki9zDQnHsYqPMr4QJBJqee4JpfDto/ESy4CMwUEBEhGY9hdUcLVne0AOsXOccHRjLY02Oti2TVGH71wiH85Ol8o7dodgPWdLZARPDYrl685ay5+M5152NBwK5ataK9KYW2puSEPZqGlD0PwJsCstkpIHdq58d/fA2bXzkx7vcA4GDfsPN6/Gqg9s8l1gAMw3m6B8wn+qApI3adwN5jmPMAiKioloYkLjhjDi44I7/doqri8KmRcUtsHz41gr9+92p8+p0ra34Z7QtXzCla5zh38WxsWNbmaWD/9j2r8b/ufgFzm1POE/2wa6OX7z66F70DowDyS0fc+CdnYuMT+wtex5wIZr4uZzXQhG9huaCglnRqAN4eAnsARFQSEcGitkYsamvEOwtsxFLr/vEDbyh6zvvPW4T3n7fIc+yDG5Y46xU1JuPY/7UrPLO077vpElx8y2MAzNrBq19/HwCgt38Ev9yaT6e5m10joAYQtgfwH395oWcsv+rEPQB/EZg1ACKiMriXVba5h34mXRO04r7JWu5G21wMrry1gOz7sBka/Lv+YaCxKkeA2hkCQEQ0SdwFY/f4fHcaCfC2u6r5TeJL7QH4KTTwd+0AlPXVAKqVAmIAIKIZL+2qK7gb/YQ/ALja3ZyrBlDqfgB+qsHBI+HMBPYvBVHmhUrEAEBEM547HeNeo8e/Xs+4GkCZO4L5qWtIqZs9WSw7RfMAGACIqK64n/oT/sqs69HbMFybwUe8pntZiaB7ce8LbJ7PFBARUcW5l2iIT1AD8AwDjUWrARiqgUHEDkBZpoCIiCaf+6nfHhFk1wXWdbY677mHgZYzCsitYA0g7i0COykgzgMgIqo8Tw/AauDfvnoBvnnNec7yGQCQc6WAIo8CKjARrLO1Ac988VK0WtflPAAiokkUPAxUPXsHAPZicOZr74IQpSu0FEQ8JljQml+aI98DKPNCJWIKiIjqimcUkNXCBzW4nsXgIvYACi0F4cd5AEREkygZMAooqME1DHcAMI+VPww0uAfgV+0UEAMAEdUV9zLNdgAIanA9QzcjDgc1V3oI0QOochGYAYCI6op7FFDcCgZGQHtruGoA0RdR1XA9APts1gCIiCrPPQooGSv8xJ0zxtcAym2XzUllxc/LX4c9ACKiirnqfHMJafeeCPFY4VE33sXg7GPlNcyK4KUg/JwdwYyJz6sUDgMlorrwrWvX46tXevcbSDopoPEN+72ffgvmzkoDKL/4azOXgy7OnmjGeQBERBWUjMcwu8mb9LDnBAQ92J+zaLbzOuoSDeZM4PA9ABaBiYgm2UTDQN2i1gDMmcDFz+NaQEREVWJPCivW3to1gHInaJkzgUsYBsoiMBHR5IrHw427L3cROJsRsgcQYw+AiKg67NVAizW4lagBhOoBwE5JlXedUjEAEFHdipdYAyhXof0Axl/H/JMpICKiSWavC1SsuY3Y/kPDfoZTa4h2vbAYAIiobuV7AOHOL3siWOjVQKtbBIgUAERkjog8LCJ7rT/bC5yXE5Gt1n+bolyTiKhSYiGT+/ldA8oTdjXQfAqoOqL2AG4G8KiqrgLwqPVzkGFVPd/678qI1yQiqggJmXLJr9JZ3nUMDbsUhNUjqVIOKGoAuArAHdbrOwB8IOLnERFVTdjF16LWAMK251F7GqWKGgA6VPUwAFh/LihwXoOIbBGRP4oIgwQR1ZSwi6+VOzon7DDQam8JWXQtIBF5BEBnwFtfKuE6y1T1kIicCeAxEdmmqi8XuN6NAG4EgGXLlpVwCSKi0tgNbrFhoFHX6Q+7FER+FFB1IkDRAKCqlxV6T0R6RGShqh4WkYUAegt8xiHrz/0i8lsAGwAEBgBV3QhgIwB0dXVVqydERHUodGon6lpACNsDKPMCZYqaAtoE4Hrr9fUA7vOfICLtIpK2Xs8DcAmAHRGvS0QUWWtjEgCwtrNlUq8TdikICdkjqZSoy0F/HcA9InIDgNcBXAsAItIF4FOq+kkA6wDcJiIGzIDzdVVlACCiKbe4rRH3/NXFOHfx7AnPi54CCrkcdMTrlCpSAFDV4wAuDTi+BcAnrdd/AHBulOsQEU2WC1fMKXpOvu0ur2UOvxREdTeE4UxgIqIioq4GCoTL70uVi8AMAEREIUWZCFbKtpJcDpqIqEZUZjno4udFXXW0VAwARERF5GfoRqkBhN8TeLosBUFENONFXg5aw30Gi8BERDUq2jDQ4ufZp7AITERUIyTyTOCwq4Fa57MITERUG6JO0DLC9gCYAiIiqk3lrwYargcAmIGi3J3HSsUAQERUhDOGP0IPIPS1wBQQEVHNiLwlJMKP8Y+JlN3TKBUDABFREdGHgYbcD8C6VpWmATAAEBGFVW5uPuyOYICZbmIKiIioRkQsAVibwoe8FlgEJiKqGfYyDlGGgSLkiqII/ciQAAAILUlEQVQiHAZKRFQzKlEDCNsDiImwB0BEVGvKHgUUciIYYPYTWAQmIqoxZReBQy4FAbAITERUU0rZzCVI2KUgzGuVP+O4VAwAREQhlZ8CCr8jGGcCExHVkIh7wps1gJDnxmIsAhMR1Yz8PIByawAlTAQDi8BERDUjzHaOEzFKWgqCawEREdWcaJvCh10MjjUAIqKaEXWnLnNT+NBXYwqIiKhW5JeDLn8xuNCjgMS8UjUwABARFVHN5aCZAiIiqkFl1wCAElYDFRgcBkpEVBuibtZu1gBYBCYimnacGkCUUUAhW1sRFoGJiGrGn6yej0vXLsDfvX9dWb9fyn4AQPXWAkpU5SpERNNYQzKOH37iTRE+oYT9AGKo2o4w7AEQEU0yo5Q9gVkEJiKaOUpbCoJbQhIRzRilLQXBIjAR0YxRSkrH3A+AKSAiopmhlBrAdEkBici1IrJdRAwR6ZrgvMtFZLeI7BORm6Nck4houil5Oehp0gN4CcDVAJ4odIKIxAHcCuC9AM4G8FEROTvidYmIpo35LWm0NIQbdV/NLSEjzQNQ1Z1A0VXuLgSwT1X3W+feBeAqADuiXJuIaLr47efeGfrcmMiMWgpiMYADrp+7rWOBRORGEdkiIluOHj066TdHRFRLREorGkdRtAcgIo8A6Ax460uqel+IawR1Dwr+7VR1I4CNANDV1VWtWggRUU0wt4SsjqIBQFUvi3iNbgBLXT8vAXAo4mcSEc1IM20Y6GYAq0RkhYikAFwHYFMVrktENO3IdFkOWkQ+KCLdAC4GcL+IPGQdXyQiDwCAqmYB3ATgIQA7Adyjqtuj3TYR0cwUq6UU0ERU9V4A9wYcPwTgCtfPDwB4IMq1iIjqQTWLwJwJTERUQ6o5D4ABgIiohlRzFBADABFRDTGLwEwBERHVnZk2E5iIiEISsAhMRFSXps08ACIiqiyzCMweABFR3TFTQNW5FgMAEVENEUHVtgRjACAiqiExpoCIiOqTuRREda7FAEBEVENi02hPYCIiqjD2AIiI6hDXAiIiqlOxKi4HygBARFRDOA+AiKhOcSYwEVGdinEtICKieiVMARER1aMYN4QhIqpPXA6aiKhOCVgEJiKqS7EYewBERHVJINwSkoioLknVtgNgACAiqiUxqV4EYAAgIqoh5lIQTAEREdWdGFNARET1SYRFYCKiulTF1aAZAIiIaomIMAAQEdUj4VpARET1ScAiMBFRXYoxBUREVJ9EOA+AiKgumVtCVkeiStchIqIQzl08e3oUgUXkWhHZLiKGiHRNcN6rIrJNRLaKyJYo1yQimsk+9uZl+PqHzqvKtaL2AF4CcDWA20Kc+05VPRbxekREVCGRAoCq7gTMnBUREU0v1SoCK4DfiMizInLjRCeKyI0iskVEthw9erRKt0dEVH+K9gBE5BEAnQFvfUlV7wt5nUtU9ZCILADwsIjsUtUngk5U1Y0ANgJAV1dXtYrhRER1p2gAUNXLol5EVQ9Zf/aKyL0ALgQQGACIiKg6Jj0FJCKzRKTFfg3gT2EWj4mIaApFHQb6QRHpBnAxgPtF5CHr+CIRecA6rQPAkyLyAoBnANyvqg9GuS4REUUXdRTQvQDuDTh+CMAV1uv9ANZHuQ4REVWeVGvGWTlE5CiA18r89XkAOO+gOH5PxfE7CoffUziT/T2doarzw5xY0wEgChHZoqoFZyeTid9TcfyOwuH3FE4tfU9cDI6IqE4xABAR1amZHAA2TvUNTBP8norjdxQOv6dwauZ7mrE1ACIimthM7gEQEdEEGACIiOrUjAsAInK5iOwWkX0icvNU30+tEJHbRaRXRF5yHZsjIg+LyF7rz/apvMdaICJLReRxEdlpbXb0Ges4vysXEWkQkWdE5AXre/oH6/gKEXna+p7uFpHUVN/rVBORuIg8LyK/tn6ume9oRgUAEYkDuBXAewGcDeCjInL21N5Vzfh3AJf7jt0M4FFVXQXgUevnepcF8Dequg7ARQA+bf1/iN+V1yiAd6nqegDnA7hcRC4C8A0A37a+p5MAbpjCe6wVnwGw0/VzzXxHMyoAwFxldJ+q7lfVMQB3Abhqiu+pJljLb5/wHb4KwB3W6zsAfKCqN1WDVPWwqj5nvR6A+Q93Mfhdeahp0Poxaf2nAN4F4OfW8br/nkRkCYD3AfiB9bOghr6jmRYAFgM44Pq52zpGwTpU9TBgNnwAFkzx/dQUEVkOYAOAp8HvahwrtbEVQC+AhwG8DKBPVbPWKfz3B3wHwOcBGNbPc1FD39FMCwBBe1NynCuVTESaAfw/AJ9V1f6pvp9apKo5VT0fwBKYve91QadV965qh4i8H0Cvqj7rPhxw6pR9R1E3ha813QCWun5eAuDQFN3LdNAjIgtV9bCILIT5JFf3RCQJs/H/iar+wjrM76oAVe0Tkd/CrJm0iUjCesKt939/lwC4UkSuANAAoBVmj6BmvqOZ1gPYDGCVVWVPAbgOwKYpvqdatgnA9dbr6wGE3eJzxrJytD8EsFNV/9n1Fr8rFxGZLyJt1utGAJfBrJc8DuAa67S6/p5U9QuqukRVl8Nsix5T1Y+jhr6jGTcT2Iq23wEQB3C7qv6fKb6lmiAidwJ4B8ylaHsA/D2AXwK4B8AyAK8DuFZV/YXiuiIibwXwOwDbkM/bfhFmHYDflUVEzoNZwIzDfJC8R1W/KiJnwhx8MQfA8wD+XFVHp+5Oa4OIvAPA36rq+2vpO5pxAYCIiMKZaSkgIiIKiQGAiKhOMQAQEdUpBgAiojrFAEBEVKcYAIiI6hQDABFRnfr/M6viLGyCF+wAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ @@ -487,7 +499,7 @@ " return iph - io * np.expm1((v + i * rs) / nNsVth) - (v + i * rs) / rsh - i\n", "\n", "def _dfdi(i, v, iph, io, rs, rsh, nNsVth):\n", - " return -io * rs / nNsVth * np.exp(v / nNsVth) * np.exp(i * rs / nNsVth) - rs / rsh - 1\n", + " return -io * rs / nNsVth * np.exp((v + i * rs) / nNsVth) - rs / rsh - 1\n", "\n", "method = 'lambertw'\n", "i_converged = pd.Series(index=i_pvl_mod['current'][method], data=np.nan)\n", @@ -496,28 +508,23 @@ " i_converged[i] = newton(func=_fi, x0=i, fprime=_dfdi, args=(v, photocurrent, saturation_current, resistance_series*Ns,\n", " resistance_shunt*Ns, nVth*Ns), tol=1e-16)\n", " except:\n", - " i_converged[i] = np.nan\n", + " pass\n", + "\n", + "print(i_converged - i_pvl_mod['current'][method])\n", "\n", - "print(np.max(np.abs(i_converged - i_pvl_mod['current'][method])))\n", - "print(i_converged)" + "plt.figure()\n", + "plt.plot(Vmod, i_converged - i_pvl_mod['current'][method])\n", + "\n", + "after = sde_resid(v=Vmod, i=i_converged, iph=photocurrent, io=saturation_current,\n", + " rs=resistance_series*Ns, rsh=resistance_shunt*Ns, nNsVth=nVth*Ns)\n", + "print(np.max(np.abs(after)))" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'1.1.0'" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [] }, { From 6c51f79e323ef1242d0b473349f97e62bc5fe4f1 Mon Sep 17 00:00:00 2001 From: Cliff Hansen Date: Wed, 11 Mar 2020 15:27:38 -0600 Subject: [PATCH 14/16] script to check convergence of IV curves using pvlib --- local_test_converge.py | 57 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) create mode 100644 local_test_converge.py diff --git a/local_test_converge.py b/local_test_converge.py new file mode 100644 index 0000000..0d95203 --- /dev/null +++ b/local_test_converge.py @@ -0,0 +1,57 @@ +# -*- coding: utf-8 -*- +""" +Created on Wed Jan 8 14:43:04 2020 + +@author: cwhanse +""" + +import numpy as np +import matplotlib.pyplot as plt + +rsh = 600 +rs = 0.25 +iph = 9.7 +io = 2.3e-11 +a = 1.5 + + +def g1(v, i, iph, io, rsh, rs, a): + X = (v + i * rs)/ a + c1 = rsh / (rsh + rs) + a1 = (v + iph * rs + io * rs) / a + a2 = io * rs / a + return c1 * (a1 - a2 * np.exp(X)) + + +def dg1(v, i, iph, io, rsh, rs, a): + X = (v + i * rs)/ a + c1 = rsh / (rsh + rs) + a2 = io * rs / a + return - a2 / c1 * np.exp(X) + + +def g2(v, i, iph, io, rsh, rs, a): + X = (v + i * rs)/ a + c1 = 1 + rs / rsh + a1 = (v + iph * rs + io * rs) / a + a2 = io * rs / a + return np.log(a1 - c1 * X) - np.log(a2) + + +def dg2(v, i, iph, io, rsh, rs, a): + X = (v + i * rs)/ a + c1 = 1 + rs / rsh + a1 = (v + iph * rs + io * rs) / a + return -c1 / (a1 - c1 * X) + + +y1 = g1(Vmod, Imod, iph, io, rsh, rs, a) +y2 = g2(Vmod, Imod, iph, io, rsh, rs, a) + +dy1 = dg1(Vmod, Imod, iph, io, rsh, rs, a) +dy2 = dg2(Vmod, Imod, iph, io, rsh, rs, a) + +plt.plot(Vmod, y1, Vmod, y2) +plt.show() +plt.plot(Vmod, dy1, Vmod, dy2) +plt.show() From 4596fed8d807001554e9b5c78346f17ad1b91b08 Mon Sep 17 00:00:00 2001 From: Cliff Hansen Date: Thu, 12 Mar 2020 15:35:54 -0600 Subject: [PATCH 15/16] checking irradiance mismatch --- .../check_mismatch_ivcurve_with_pvlib.py | 139 ++++++++++ notebooks/irradiance_mismatch_iv_curves.ipynb | 250 ++++++++++++++++++ 2 files changed, 389 insertions(+) create mode 100644 notebooks/check_mismatch_ivcurve_with_pvlib.py create mode 100644 notebooks/irradiance_mismatch_iv_curves.ipynb diff --git a/notebooks/check_mismatch_ivcurve_with_pvlib.py b/notebooks/check_mismatch_ivcurve_with_pvlib.py new file mode 100644 index 0000000..f4c59e7 --- /dev/null +++ b/notebooks/check_mismatch_ivcurve_with_pvlib.py @@ -0,0 +1,139 @@ +# -*- coding: utf-8 -*- +""" +Created on Wed Mar 11 14:16:42 2020 + +@author: cwhanse +""" + +# add capability to import from parent directory +import sys, os +sys.path.insert(1, os.path.join(os.path.abspath('.'), '..')) + +import pvmismatch as pvm +import numpy as np +import pvlib +import matplotlib.pyplot as plt + + +# Setting PV system layout cell and module parameters +v_bypass = np.float64(-0.5) # [V] trigger voltage of bypass diode +cell_area = np.float64(246.49) # [cm^2] cell area +Isc0_T0 = 9.68 # [A] reference short circuit current +ncols_per_substr=[2]*3 # 3 bypass diodes each in parallel with 2 series connected cell-columns +nrows=10 # number of cell rows in the module + +pvconst = pvm.pvconstants.PVconstants(npts=1000) + +# Building PV modules and system +pv_mod_pattern = pvm.pvmodule.standard_cellpos_pat(nrows=nrows, + ncols_per_substr=ncols_per_substr) +pv_mod = pvm.pvmodule.PVmodule(cell_pos=pv_mod_pattern, pvcells=None, + pvconst=pvconst, Vbypass=v_bypass, cellArea=cell_area) + +for c in pv_mod.pvcells: + c.update(diode_model = 'pvsyst', aRBD=0.0, bRBD=0.0, Isc0_T0 = Isc0_T0) # updating short circuit currents + + +# Set mismatch by different irradiance conditions +# bottom 2 rows of cells are shaded +low_irrad = 0.5 + +low_irrad_cells = [8, 9, 19, 18] +hi_irrad_cells = list(range(0, len(pv_mod.pvcells))) +for c in low_irrad_cells: + hi_irrad_cells.remove(c) + +pv_mod.setSuns(cells=hi_irrad_cells, Ee=[1]*len(hi_irrad_cells)) +pv_mod.setSuns(cells=low_irrad_cells, Ee=[low_irrad]*len(low_irrad_cells)) + + +# remove negative voltage and current +# ============================================================================= +# u = (pv_mod.Vmod>=0.) & (pv_mod.Imod>=0.) +# +# plt.figure() +# plt.plot(pv_mod.Vmod[u], pv_mod.Imod[u], 'r.') +# plt.title('Module IV curve') +# plt.show() +# +# uu = (pv_mod.Vmod > 30) & (pv_mod.Imod>=0.) # focus on segment towards Voc +# +# plt.figure() +# plt.plot(pv_mod.Vmod[uu], pv_mod.Imod[uu], 'b.') +# plt.title('Module IV curve - Voc end') +# plt.show() +# ============================================================================= + +# ============================================================================= +# # plot IV curve for string with shaded cells +# plt.figure() +# plt.plot(pv_mod.Vsubstr[0], pv_mod.Isubstr[0], 'k.') +# plt.title('IV curve for substring with mismatched cells') +# plt.show() +# +# +# plt.figure() +# for idx in range(0, 59): +# # v = (pv_mod.pvcells[idx].Vcell>=0.) & (pv_mod.pvcells[idx].Icell>=0.) +# # plt.plot(pv_mod.pvcells[idx].Vcell[v], pv_mod.pvcells[idx].Icell[v]) +# plt.plot(pv_mod.pvcells[idx].Vcell, pv_mod.pvcells[idx].Icell) +# plt.title('IV curves for each cell') +# plt.show() +# ============================================================================= + +idxs = [r['idx'] for c in pv_mod.cell_pos[0] for r in c] + +Icells = [] +Vcells = [] +for idx in idxs: + Icells.append(pv_mod.pvcells[idx].Icell) + Vcells.append(pv_mod.pvcells[idx].Vcell) +Icells = np.asarray(Icells).squeeze() +Vcells = np.asarray(Vcells).squeeze() + + +# parallel calculation using pvlib +# first verify IV curves for each cell +tol = 5e-14 + +result = {} + +for i in [0, 9]: + icell = pvlib.pvsystem.i_from_v(resistance_shunt=pv_mod.pvcells[i].Rsh, + resistance_series=pv_mod.pvcells[i].Rs, + nNsVth=pv_mod.pvcells[i].N1*pv_mod.pvcells[i].Vt, + voltage=pv_mod.pvcells[i].Vcell.flatten(), + saturation_current=pv_mod.pvcells[i].Isat1, + photocurrent=pv_mod.pvcells[i].Igen) + # save that for later + result[i] = (pv_mod.pvcells[i].Vcell.flatten(), icell) + if np.max(np.abs(icell - Icells[i, :].flatten())) < tol: + print('Cell {} current matches'.format(i)) + else: + print('Cell {} current does not match'.format(i)) + +# now create the substring IV curve +full_sun_v = result[0][0] +full_sun_i = result[0][1] + +low_sun_v = result[9][0] +low_sun_i = result[9][1] + +all_i = np.flipud(np.sort(np.append(full_sun_i, low_sun_i))) +full_sun_v_ext = np.interp(all_i, np.flipud(full_sun_i), np.flipud(full_sun_v)) +low_sun_v_ext = np.interp(all_i, np.flipud(low_sun_i), np.flipud(low_sun_v)) +all_v = full_sun_v_ext * 18 + low_sun_v_ext * 2 + +plt.figure() +plt.plot(low_sun_v_ext, all_i) +plt.plot(full_sun_v_ext, all_i) +plt.title('Cell-level IV curves from pvlib') +plt.legend(['low sun', 'full sun']) +plt.show() + +plt.figure() +plt.plot(all_v, all_i, 'r.') +plt.plot(pv_mod.Vsubstr[0], pv_mod.Isubstr[0], 'k.') +plt.title('Substring IV curves') +plt.legend(['pvlib', 'PVMismatch']) +plt.show() diff --git a/notebooks/irradiance_mismatch_iv_curves.ipynb b/notebooks/irradiance_mismatch_iv_curves.ipynb new file mode 100644 index 0000000..6aed54b --- /dev/null +++ b/notebooks/irradiance_mismatch_iv_curves.ipynb @@ -0,0 +1,250 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\cwhanse\\AppData\\Local\\Continuum\\Anaconda3\\lib\\site-packages\\pandas\\compat\\_optional.py:106: UserWarning: Pandas requires version '1.2.1' or newer of 'bottleneck' (version '1.1.0' currently installed).\n", + " warnings.warn(msg, UserWarning)\n" + ] + } + ], + "source": [ + "# add capability to import from parent directory\n", + "import sys, os\n", + "sys.path.insert(1, os.path.join(os.path.abspath('.'), '..'))\n", + "\n", + "import pvmismatch as pvm\n", + "import pvlib\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# Setting PV system layout cell and module parameters\n", + "v_bypass = np.float64(-0.5) # [V] trigger voltage of bypass diode\n", + "cell_area = np.float64(246.49) # [cm^2] cell area\n", + "Isc0_T0 = 9.68 # [A] reference short circuit current\n", + "ncols_per_substr=[2]*3 # 3 bypass diodes each in parallel with 2 series connected cell-columns\n", + "nrows=10 # number of cell rows in the module\n", + "\n", + "pvconst = pvm.pvconstants.PVconstants(npts=1000)\n", + "\n", + "# Building PV modules and system\n", + "pv_mod_pattern = pvm.pvmodule.standard_cellpos_pat(nrows=nrows,\n", + " ncols_per_substr=ncols_per_substr)\n", + "pv_mod = pvm.pvmodule.PVmodule(cell_pos=pv_mod_pattern, pvcells=None,\n", + " pvconst=pvconst, Vbypass=v_bypass, cellArea=cell_area)\n", + "\n", + "for c in pv_mod.pvcells:\n", + " c.update(diode_model = 'pvsyst', aRBD=0.0, bRBD=0.0, Isc0_T0 = Isc0_T0) # updating short circuit currents\n" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [], + "source": [ + "# Set mismatch by different irradiance conditions\n", + "\n", + "# bottom 2 rows of cells are shaded\n", + "low_irrad = 0.5\n", + "\n", + "low_irrad_cells = [8, 9, 19, 18]\n", + "hi_irrad_cells = list(range(0, len(pv_cells)))\n", + "for c in low_irrad_cells:\n", + " hi_irrad_cells.remove(c)\n", + "\n", + "pv_mod.setSuns(cells=hi_irrad_cells, Ee=[1]*len(hi_irrad_cells))\n", + "pv_mod.setSuns(cells=low_irrad_cells, Ee=[low_irrad]*len(low_irrad_cells))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# remove negative voltage and current\n", + "\n", + "u = (pv_mod.Vmod>=0.) & (pv_mod.Imod>=0.)\n", + "\n", + "plt.plot(pv_mod.Vmod[u], pv_mod.Imod[u], 'r.')\n", + "plt.show()\n", + "\n", + "uu = (pv_mod.Vmod > 30) & (pv_mod.Imod>=0.) # focus on segment towards Voc\n", + "\n", + "plt.plot(pv_mod.Vmod[uu], pv_mod.Imod[uu], 'b.')\n", + "plt.show()\n", + "\n", + "# plot IV curve for string with shaded cells\n", + "plt.plot(pv_mod.Vsubstr[0], pv_mod.Isubstr[0], 'k.')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "for idx in range(0, 59):\n", + " v = (pv_mod.pvcells[idx].Vcell>=0.) & (pv_mod.pvcells[idx].Icell>=0.)\n", + " plt.plot(pv_mod.pvcells[idx].Vcell[v], pv_mod.pvcells[idx].Icell[v])\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "idxs = [r['idx'] for c in pv_mod.cell_pos[0] for r in c]\n", + "\n", + "Icells = []\n", + "Vcells = []\n", + "for idx in idxs:\n", + " Icells.append(pv_mod.pvcells[idx].Icell)\n", + " Vcells.append(pv_mod.pvcells[idx].Vcell)\n", + "Icells = np.asarray(Icells).squeeze()\n", + "Vcells = np.asarray(Vcells).squeeze()\n", + "\n", + "Imod, Vmod = pvconst.calcSeries(Icells, Vcells, pv_mod.Isc[idxs].mean(), Isub.max())\n", + "\n", + "u = (Vmod>=0.) & (Imod>=0.)\n", + "plt.plot(Vmod[u], Imod[u], '.')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 2d0d0e8be848e86c7389827b24ad87836073cef8 Mon Sep 17 00:00:00 2001 From: Cliff Hansen Date: Fri, 13 Mar 2020 13:55:18 -0600 Subject: [PATCH 16/16] confirm accuracy with cell, substring, module --- .../check_mismatch_ivcurve_with_pvlib.py | 137 ++++++++++-------- 1 file changed, 77 insertions(+), 60 deletions(-) diff --git a/notebooks/check_mismatch_ivcurve_with_pvlib.py b/notebooks/check_mismatch_ivcurve_with_pvlib.py index f4c59e7..d96e62a 100644 --- a/notebooks/check_mismatch_ivcurve_with_pvlib.py +++ b/notebooks/check_mismatch_ivcurve_with_pvlib.py @@ -14,13 +14,23 @@ import pvlib import matplotlib.pyplot as plt +from scipy.interpolate import interp1d # Setting PV system layout cell and module parameters v_bypass = np.float64(-0.5) # [V] trigger voltage of bypass diode cell_area = np.float64(246.49) # [cm^2] cell area Isc0_T0 = 9.68 # [A] reference short circuit current -ncols_per_substr=[2]*3 # 3 bypass diodes each in parallel with 2 series connected cell-columns +# set columns per substring, ncol, and number of substrings, nsub, as [ncol]*nsub +ncols_per_substr=[2]*3 nrows=10 # number of cell rows in the module +# total number of series-connected cells in a substring is nrows * +# [ncol]*nsub is nsub bypass diodes each in parallel with ncol*nrow series-connected cells +VBYPASS = np.float64(-0.5) +MODULE_BYPASS = None + +num_substrings = len(ncols_per_substr) +cells_per_substring = [[k + p*nrows*s for k in range(nrows * s)] for p, s in + enumerate(ncols_per_substr)] pvconst = pvm.pvconstants.PVconstants(npts=1000) @@ -35,51 +45,17 @@ # Set mismatch by different irradiance conditions -# bottom 2 rows of cells are shaded -low_irrad = 0.5 +# one cell at bottom row of each substring is shaded +low_irrad_cells = [9, 29, 49] +low_irrad = [0.7, 0.5, 0.3] -low_irrad_cells = [8, 9, 19, 18] hi_irrad_cells = list(range(0, len(pv_mod.pvcells))) for c in low_irrad_cells: hi_irrad_cells.remove(c) pv_mod.setSuns(cells=hi_irrad_cells, Ee=[1]*len(hi_irrad_cells)) -pv_mod.setSuns(cells=low_irrad_cells, Ee=[low_irrad]*len(low_irrad_cells)) - - -# remove negative voltage and current -# ============================================================================= -# u = (pv_mod.Vmod>=0.) & (pv_mod.Imod>=0.) -# -# plt.figure() -# plt.plot(pv_mod.Vmod[u], pv_mod.Imod[u], 'r.') -# plt.title('Module IV curve') -# plt.show() -# -# uu = (pv_mod.Vmod > 30) & (pv_mod.Imod>=0.) # focus on segment towards Voc -# -# plt.figure() -# plt.plot(pv_mod.Vmod[uu], pv_mod.Imod[uu], 'b.') -# plt.title('Module IV curve - Voc end') -# plt.show() -# ============================================================================= - -# ============================================================================= -# # plot IV curve for string with shaded cells -# plt.figure() -# plt.plot(pv_mod.Vsubstr[0], pv_mod.Isubstr[0], 'k.') -# plt.title('IV curve for substring with mismatched cells') -# plt.show() -# -# -# plt.figure() -# for idx in range(0, 59): -# # v = (pv_mod.pvcells[idx].Vcell>=0.) & (pv_mod.pvcells[idx].Icell>=0.) -# # plt.plot(pv_mod.pvcells[idx].Vcell[v], pv_mod.pvcells[idx].Icell[v]) -# plt.plot(pv_mod.pvcells[idx].Vcell, pv_mod.pvcells[idx].Icell) -# plt.title('IV curves for each cell') -# plt.show() -# ============================================================================= +pv_mod.setSuns(cells=low_irrad_cells, Ee=low_irrad) + idxs = [r['idx'] for c in pv_mod.cell_pos[0] for r in c] @@ -98,7 +74,9 @@ result = {} -for i in [0, 9]: +cells_to_check = low_irrad_cells.copy() +cells_to_check.append(hi_irrad_cells[0]) +for i in cells_to_check: icell = pvlib.pvsystem.i_from_v(resistance_shunt=pv_mod.pvcells[i].Rsh, resistance_series=pv_mod.pvcells[i].Rs, nNsVth=pv_mod.pvcells[i].N1*pv_mod.pvcells[i].Vt, @@ -107,33 +85,72 @@ photocurrent=pv_mod.pvcells[i].Igen) # save that for later result[i] = (pv_mod.pvcells[i].Vcell.flatten(), icell) - if np.max(np.abs(icell - Icells[i, :].flatten())) < tol: + if np.max(np.abs(icell - pv_mod.pvcells[i].Icell.flatten())) < tol: print('Cell {} current matches'.format(i)) else: print('Cell {} current does not match'.format(i)) -# now create the substring IV curve -full_sun_v = result[0][0] -full_sun_i = result[0][1] +for i in cells_to_check: + plt.figure() + plt.plot(result[i][0], result[i][1], 'k.') + plt.title('IV curve for cell {}'.format(c)) + plt.show() -low_sun_v = result[9][0] -low_sun_i = result[9][1] +# now create the substring IV curves -all_i = np.flipud(np.sort(np.append(full_sun_i, low_sun_i))) -full_sun_v_ext = np.interp(all_i, np.flipud(full_sun_i), np.flipud(full_sun_v)) -low_sun_v_ext = np.interp(all_i, np.flipud(low_sun_i), np.flipud(low_sun_v)) -all_v = full_sun_v_ext * 18 + low_sun_v_ext * 2 +full_sun_v = result[0][0] +full_sun_i = result[0][1] -plt.figure() -plt.plot(low_sun_v_ext, all_i) -plt.plot(full_sun_v_ext, all_i) -plt.title('Cell-level IV curves from pvlib') -plt.legend(['low sun', 'full sun']) -plt.show() +substring_result = {} +for s, cell_list in enumerate(cells_per_substring): + all_i = np.array(full_sun_i) + for idx in cell_list: + if idx in low_irrad_cells: + all_i = np.append(all_i, result[idx][1]) + all_i = np.flipud(np.sort(all_i)) + all_v = np.zeros_like(all_i) + for idx in cell_list: + if idx in low_irrad_cells: + i = result[idx][1] + v = result[idx][0] + else: + i = full_sun_i + v = full_sun_v + f_interp = interp1d(np.flipud(i), np.flipud(v), kind='linear', + fill_value='extrapolate') + all_v += f_interp(all_i) + if VBYPASS: + all_v = all_v.clip(min=VBYPASS) + substring_result[s] = (all_v, all_i) + +for s in substring_result: + plt.figure() + plt.plot(substring_result[s][0], substring_result[s][1], 'r.') + plt.plot(pv_mod.Vsubstr[s], pv_mod.Isubstr[s], 'k.') + plt.title('IV curve for substring {}'.format(s)) + plt.legend(['pvlib', 'PVMismatch']) + plt.show() + +# assemble module IV curve + +module_i = np.array([]) +for s in substring_result.keys(): + module_i = np.append(module_i, substring_result[s][1]) +module_i = np.flipud(np.sort(module_i)) + +module_v = np.zeros_like(module_i) +for s in substring_result: + f_interp = interp1d(np.flipud(substring_result[s][1]), + np.flipud(substring_result[s][0]), kind='linear', + fill_value='extrapolate') + module_v += f_interp(module_i) + +if MODULE_BYPASS: + module_v = module_v.clip(min=VBYPASS) plt.figure() -plt.plot(all_v, all_i, 'r.') -plt.plot(pv_mod.Vsubstr[0], pv_mod.Isubstr[0], 'k.') -plt.title('Substring IV curves') +plt.plot(module_v, module_i, 'r.') +plt.plot(pv_mod.Vmod, pv_mod.Imod, 'k.') +plt.title('IV curve for module') plt.legend(['pvlib', 'PVMismatch']) plt.show()