bifacial-radiance 0.5.1__py2.py3-none-any.whl

bifacial_radiance/mismatch.py

@@ -0,0 +1,461 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Mar 26 20:16:47 2019
+
+@author: sayala
+"""
+
+from deprecated import deprecated
+
+
+
+def _sensorupsampletocellsbyInterpolation(df, cellsy):
+    '''
+        
+    Function for when sensorsy in the results are less than cellsy desired.
+    Interpolates the dataframe.
+    
+    #2DO: improve interpolation with pandas. right onw it's row by row.
+    
+    _sensorupsampletocellsbyInterpolation(df, cellsy)
+    '''
+    
+    import pandas as pd
+    import numpy as np
+    
+    sensorsy = len(df)
+    
+    #2DO: Update this section to match bifacialvf
+    cellCenterPVM=[]                                    
+    for i in range (0, cellsy):
+        cellCenterPVM.append((i*sensorsy/cellsy+(i+1)*sensorsy/cellsy)/2)
+    
+    df2 = pd.DataFrame()
+    for j in range (0, len(df.keys())):
+        A = list(df[df.keys()[j]])
+        B= np.interp(cellCenterPVM, list(range(0,sensorsy)), A)
+        df2[df.keys()[j]]=B
+    
+    return df2
+    
+def _sensorsdownsampletocellsbyAverage(df, cellsy):
+    '''
+    df = dataframe with rows indexed by number (i.e. 0 to sensorsy) where sensorsy > cellsy
+    cellsy = int. usually 8 or 12.
+
+    example:
+    F_centeraverages = _sensorsdownsampletocellsbyAverage(F, cellsy)
+    '''
+    import numpy as np
+    import pandas as pd
+
+    edges=len(df)-np.floor(len(df)/(cellsy))*(cellsy)
+    edge1=int(np.floor(edges/2))
+    edge2=int(edges-edge1)
+    A = list(range(df.index[0]+edge1, df.index[-1]-edge2+2, int(np.floor(len(df)/(cellsy)))))
+    B = range(0,len(A)-1,1)
+    C = [df.iloc[A[x]:A[x+1]].mean(axis=0) for x in B]
+    df_centeraverages=pd.DataFrame(C)
+    
+    return df_centeraverages
+
+def _sensorsdownsampletocellbyCenter(df, cellsy):
+    '''
+    df = dataframe with rows indexed by number (i.e. 0 to sensorsy) where sensorsy > cellsy
+    cellsy = int. usually 8 or 12.
+
+    example:
+    F_centervalues = _sensorsdownsampletocellbyCenter(F, cellsy)
+    '''
+
+    import numpy as np
+
+    
+    edges=len(df)-np.floor(len(df)/(cellsy))*(cellsy)
+    edge1=int(np.floor(edges/2))
+    edge2=int(edges-edge1)
+    A = list(range(df.index[0]+edge1, df.index[-1]-edge2+2, int(np.floor(len(df)/(cellsy)))))
+    A = [int(x+(A[1]-A[0])*0.5) for x in A]
+    A = A[:-1]
+    df_centervalues=df.loc[A]
+    df_centervalues=df_centervalues.reset_index(drop=True)
+    
+    return df_centervalues
+    
+def _setupforPVMismatch(portraitorlandscape, sensorsy, numcells=72):
+    r''' Sets values for calling PVMismatch, for ladscape or portrait modes and 
+    
+    Example:
+    stdpl, cellsx, cellsy = _setupforPVMismatch(portraitorlandscape='portrait', sensorsy=100):
+    '''
+
+    import numpy as np
+
+        # cell placement for 'portrait'.
+    if numcells == 72:
+        stdpl=np.array([[0,	23,	24,	47,	48,	71],
+        [1,	22,	25,	46,	49,	70],
+        [2,	21,	26,	45,	50,	69],
+        [3,	20,	27,	44,	51,	68],
+        [4,	19,	28,	43,	52,	67],
+        [5,	18,	29,	42,	53,	66],
+        [6,	17,	30,	41,	54,	65],
+        [7,	16,	31,	40,	55,	64],
+        [8,	15,	32,	39,	56,	63],
+        [9,	14,	33,	38,	57,	62],
+        [10,	13,	34,	37,	58,	61],
+        [11,	12,	35,	36,	59,	60]])
+    
+    elif numcells == 96:
+        stdpl=np.array([[0,	23,	24,	47,	48,	71,	72,	95],
+            [1,	22,	25,	46,	49,	70,	73,	94],
+            [2,	21,	26,	45,	50,	69,	74,	93],
+            [3,	20,	27,	44,	51,	68,	75,	92],
+            [4,	19,	28,	43,	52,	67,	76,	91],
+            [5,	18,	29,	42,	53,	66,	77,	90],
+            [6,	17,	30,	41,	54,	65,	78,	89],
+            [7,	16,	31,	40,	55,	64,	79,	88],
+            [8,	15,	32,	39,	56,	63,	80,	87],
+            [9,	14,	33,	38,	57,	62,	81,	86],
+            [10,	13,	34,	37,	58,	61,	82,	85],
+            [11,	12,	35,	36,	59,	60,	83,	84]])
+    else:
+        print("Error. Only 72 and 96 cells modules supported at the moment. Change numcells to either of this options!")
+        return
+    
+    if portraitorlandscape == 'landscape':
+        stdpl = stdpl.transpose()
+    elif portraitorlandscape != 'portrait':
+        print("Error. portraitorlandscape variable must either be 'landscape' or 'portrait'")
+        return
+    
+    cellsx = len(stdpl[1]); cellsy = len(stdpl)
+    
+    return stdpl, cellsx, cellsy
+
+
+def calculatePVMismatch(pvsys, stdpl, cellsx, cellsy, Gpoat):
+    r''' calls PVMismatch with all the pre-generated values on bifacial_radiance
+    
+    Example:
+    PowerAveraged, PowerDetailed = def calculatePVMismatch(pvsys, stdpl, cellsx, cellsy, Gpoat)
+
+    '''
+
+    import numpy as np
+    
+    if np.mean(Gpoat) < 0.001:
+        PowerAveraged = 0
+        PowerDetailed = 0
+    else:                                   
+        # makes the system  # 1 module, in portrait mode.         
+        G=np.array([Gpoat]).transpose()
+        H = np.ones([1,cellsx]) 
+        array_det = np.dot(G,H) 
+        array_avg = np.ones([cellsy,cellsx])*np.mean(Gpoat)        
+                                
+        # ACtually do calculations
+        pvsys.setSuns({0: {0: [array_avg, stdpl]}})
+        PowerAveraged=pvsys.Pmp
+        
+        pvsys.setSuns({0: {0: [array_det, stdpl]}})
+        PowerDetailed=pvsys.Pmp
+
+    return PowerAveraged, PowerDetailed
+
+def mismatch_fit3(data):
+    '''
+    Electrical mismatch calculation following Progress in PV paper
+    Estimating and parameterizing mismatch power loss in bifacial photovoltaic systems
+    Chris Deline, Silvana Ayala Pelaez,Sara MacAlpine,Carlos Olalla
+    https://doi.org/10.1002/pip.3259
+
+    .. deprecated:: 0.4.3
+       This fitted model is deprecated in favor of :func:`mismatch_fit2` which has
+       better agreement with the experimental data.
+    
+    Parameters
+    ----------
+    data : np.ndarray, pd.Series, pd.DataFrame
+        Gtotal irradiance measurements. Each column is the irradiance for a module
+        at a specific time. 
+
+    Returns
+    -------
+    fit3 :  Float or pd.Series
+        Returns mismatch values for each module in percentage [%].
+    
+    Equation: 1/(n^2*Gavg)*Sum Sum (abs(G_i - G_j))
+    ## Note: starting with Pandas 1.0.0 this function will not work on Series objects.
+    '''
+    import numpy as np
+    import pandas as pd
+    
+    if type(data) == np.ndarray:
+        data = pd.DataFrame(data)
+    
+    datac = data[~np.isnan(data)]
+    mad = mad_fn(datac)  # (percentage)
+    mad2 = mad**2
+    
+    fit3 = 0.054*mad + 0.068*mad2
+    
+    if fit3.__len__() == 1:
+        if isinstance(fit3, pd.Series):
+            fit3 = float(fit3.iloc[0])
+        else:
+            fit3 = float(fit3)
+
+    return fit3
+
+
+def mismatch_fit2(data):
+    '''
+    Electrical mismatch calculation following Progress in PV paper
+    Estimating and parameterizing mismatch power loss in bifacial photovoltaic systems
+    Chris Deline, Silvana Ayala Pelaez,Sara MacAlpine,Carlos Olalla
+    https://doi.org/10.1002/pip.3259
+    
+    Parameters
+    ----------
+    data : np.ndarray, pd.Series, pd.DataFrame
+        Gtotal irradiance measurements. Each column is the irradiance for a module
+        at a specific time. 
+
+    Returns
+    -------
+    fit2 :  Float or pd.Series
+        Returns mismatch values for each module in percentage [%].
+    
+    Equation: 1/(n^2*Gavg)*Sum Sum (abs(G_i - G_j))
+    ## Note: starting with Pandas 1.0.0 this function will not work on Series objects.
+    '''
+    import numpy as np
+    import pandas as pd
+    
+    if type(data) == np.ndarray:
+        data = pd.DataFrame(data)
+    
+    datac = data[~np.isnan(data)]
+    mad = mad_fn(datac)  # (percentage)
+    mad2 = mad**2
+    
+    fit2 = 0.142*mad + 0.032*mad2
+    
+    if fit2.__len__() == 1:
+        if isinstance(fit2, pd.Series):
+            fit2 = float(fit2.iloc[0])
+        else:
+            fit2 = float(fit2)
+
+    return fit2
+
+    
+def mad_fn(data, axis='index'):
+    '''
+    Mean average deviation calculation for mismatch purposes.
+    
+    Parameters
+    ----------
+    data : np.ndarray or pd.Series or pd.DataFrame
+        Gtotal irradiance measurements. If data is a pandas.DataFrame, one 
+        MAD/Average is returned for each index, based on values across columns.
+        
+    axis : {0 or 'index', 1 or 'columns'}, default 'index'   
+        Calculate mean average deviation across rows (default) or columns for 2D data
+
+        * 0, or 'index' : MAD calculated across rows.
+        * 1, or 'columns' : MAD calculated across columns.
+    Returns
+    -------
+    scalar or pd.Series:   return MAD / Average [%]. Scalar for a 1D array, Series for 2D.
+    
+    
+    Equation: 1/(n^2*Gavg)*Sum Sum (abs(G_i - G_j)) * 100[%]
+
+    '''
+    import numpy as np
+    import pandas as pd
+    def _mad_1D(data):  #1D calculation of MAD
+        return (np.abs(np.subtract.outer(data,data)).sum()/float(data.__len__())**2 / np.mean(data))*100
+    if type(axis) == str:
+        try:
+            axis = {"index": 0, "rows": 0, 'columns':1}[axis]
+        except KeyError:
+            raise Exception('Incorrect index string in mad_fn. options: index, rows, columns.')
+            
+    ndim = data.ndim
+    if ndim == 2 and axis==0:
+        data = data.T
+    # Pandas returns a notimplemented error if this is a DataFrame.
+    if (type(data) == pd.Series):
+        data = data.to_numpy()
+    
+    if type(data) == pd.DataFrame:
+        temp = data.apply(pd.Series.to_numpy, axis=1)
+        return(temp.apply(_mad_1D))
+    elif ndim ==2: #2D array
+        return [_mad_1D(i) for i in data]
+    else:
+        return _mad_1D(data)
+
+
+@deprecated(reason='This analysis script will be moved to its own tutorial' +\
+            ' file in a future release.', version='0.5.0')
+def analysisIrradianceandPowerMismatch(testfolder, writefiletitle, portraitorlandscape, bififactor, numcells=72, downsamplingmethod='byCenter'):
+    r'''
+    Use this when sensorsy calculated with bifacial_radiance > cellsy
+    
+    Reads and calculates power output and mismatch for each file in the 
+    testfolder where all the bifacial_radiance irradiance results .csv are saved.
+    First load each file, cleans it and resamples it to the numsensors set in this function,
+    and then calculates irradiance mismatch and PVMismatch power output for averaged, minimum,
+    or detailed irradiances on each cell for the cases of A) only 12 or 8 downsmaples values are
+    considered (at the center of each cell), and B) 12 or 8 values are obtained from averaging
+    all the irradiances falling in the area of the cell (No edges or inter-cell spacing are considered
+    at this moment). Then it saves all the A and B irradiances, as well as the cleaned/resampled
+    front and rear irradiances.
+    
+    Ideally sensorsy in the read data is >> 12 to give results for the irradiance mismatch in the cell.
+    
+    Also ideally n
+     
+    Parameters
+    ----------
+    testfolder:   folder containing output .csv files for bifacial_radiance
+    writefiletitle:   .csv title where the output results will be saved. 
+    portraitorlandscape: 'portrait' or 'landscape', for PVMismatch input
+                      which defines the electrical interconnects inside the module. 
+    bififactor: bifaciality factor of the module. Max 1.0. ALL Rear irradiance values saved include the bifi-factor.
+    downsampling method: 1 - 'byCenter' - 2 - 'byAverage'
+    
+    Example:
+        
+    # User information.
+    import bifacial_radiance
+    testfolder=r'C:\Users\sayala\Documents\HPC_Scratch\EUPVSEC\HPC Tracking Results\RICHMOND\Bifacial_Radiance Results\PVPMC_0\results'
+    writefiletitle= r'C:\Users\sayala\Documents\HPC_Scratch\EUPVSEC\HPC Tracking Results\RICHMOND\Bifacial_Radiance Results\PVPMC_0\test_df.csv'
+    sensorsy=100
+    portraitorlandscape = 'portrait'
+    analysis.analysisIrradianceandPowerMismatch(testfolder, writefiletitle, portraitorlandscape, bififactor=1.0, numcells=72)
+
+    '''
+    from bifacial_radiance import load
+    import os, glob
+    import pandas as pd
+        
+    # Default variables 
+    numpanels=1 # 1 at the moment, necessary for the cleaning routine.
+    automatic=True
+    
+    #loadandclean
+    # testfolder = r'C:\Users\sayala\Documents\HPC_Scratch\EUPVSEC\PinPV_Bifacial_Radiance_Runs\HPCResults\df4_FixedTilt\FixedTilt_Cairo_C_0.15\results'
+    filelist = sorted(os.listdir(testfolder)) 
+    #filelist = sorted(glob.glob(os.path.join('testfolder','*.csv'))) 
+    print('{} files in the directory'.format(filelist.__len__()))
+
+    # Check number of sensors on data.
+    temp = load.read1Result(os.path.join(testfolder,filelist[0]))
+    sensorsy = len(temp)
+
+    # Setup PVMismatch parameters
+    stdpl, cellsx, cellsy = _setupforPVMismatch(portraitorlandscape=portraitorlandscape, sensorsy=sensorsy, numcells=numcells)
+
+    F=pd.DataFrame()
+    B=pd.DataFrame()
+    for z in range(0, filelist.__len__()):
+            data=load.read1Result(os.path.join(testfolder,filelist[z]))
+            [frontres, backres] = load.deepcleanResult(data, sensorsy=sensorsy, numpanels=numpanels, automatic=automatic)
+            F[filelist[z]]=frontres
+            B[filelist[z]]=backres          
+
+    B = B*bififactor
+    # Downsample routines:
+    if sensorsy > cellsy:
+        if downsamplingmethod == 'byCenter':
+            print("Sensors y > cellsy; Downsampling data by finding CellCenter method")
+            F = _sensorsdownsampletocellbyCenter(F, cellsy)
+            B = _sensorsdownsampletocellbyCenter(B, cellsy)
+        elif downsamplingmethod == 'byAverage':
+            print("Sensors y > cellsy; Downsampling data by Averaging data into Cells method")
+            F = _sensorsdownsampletocellsbyAverage(F, cellsy)
+            B = _sensorsdownsampletocellsbyAverage(B, cellsy)
+        else:
+            print ("Sensors y > cellsy for your module. Select a proper downsampling method ('byCenter', or 'byAverage')")
+            return
+    elif sensorsy < cellsy:
+        print("Sensors y < cellsy; Upsampling data by Interpolation")
+        F = _sensorupsampletocellsbyInterpolation(F, cellsy)
+        B = _sensorupsampletocellsbyInterpolation(B, cellsy)
+    elif sensorsy == cellsy:
+        print ("Same number of sensorsy and cellsy for your module.")
+        F = F
+        B = B
+
+    # Calculate POATs
+    Poat = F+B
+            
+    # Define arrays to fill in:
+    Pavg_all=[]; Pdet_all=[]
+    Pavg_front_all=[]; Pdet_front_all=[]
+    colkeys = F.keys()
+    
+    import pvmismatch
+    
+    if cellsx*cellsy == 72:
+        cell_pos = pvmismatch.pvmismatch_lib.pvmodule.STD72
+    elif cellsx*cellsy == 96:
+        cell_pos = pvmismatch.pvmismatch_lib.pvmodule.STD96
+    else:
+        print("Error. Only 72 and 96 cells modules supported at the moment. Change numcells to either of this options!")
+        return
+    
+    pvmod=pvmismatch.pvmismatch_lib.pvmodule.PVmodule(cell_pos=cell_pos)        
+    pvsys = pvmismatch.pvsystem.PVsystem(numberStrs=1, numberMods=1, pvmods=pvmod)  
+
+
+    # Calculate powers for each hour:
+    for i in range(0,len(colkeys)):        
+        Pavg, Pdet = calculatePVMismatch(pvsys = pvsys, stdpl=stdpl, cellsx=cellsx, cellsy=cellsy, Gpoat=list(Poat[colkeys[i]]/1000))
+        Pavg_front, Pdet_front = calculatePVMismatch(pvsys = pvsys, stdpl = stdpl, cellsx = cellsx, cellsy = cellsy, Gpoat= list(F[colkeys[i]]/1000))
+        Pavg_all.append(Pavg)
+        Pdet_all.append(Pdet)
+        Pavg_front_all.append(Pavg_front) 
+        Pdet_front_all.append(Pdet_front)
+    
+    ## Rename Rows and save dataframe and outputs.
+    F.index='FrontIrradiance_cell_'+F.index.astype(str)
+    B.index='BackIrradiance_cell_'+B.index.astype(str)
+    Poat.index='POAT_Irradiance_cell_'+Poat.index.astype(str)
+
+    # Statistics Calculatoins
+    dfst=pd.DataFrame()
+    dfst['MAD/G_Total'] = mad_fn(Poat)
+    dfst['Front_MAD/G_Total'] = mad_fn(F)
+    dfst['MAD/G_Total**2'] = dfst['MAD/G_Total']**2
+    dfst['Front_MAD/G_Total**2'] = dfst['Front_MAD/G_Total']**2
+    dfst['poat'] = Poat.mean()
+    dfst['gfront'] = F.mean()
+    dfst['grear'] = B.mean()
+    dfst['bifi_ratio'] =  dfst['grear']/dfst['gfront']
+    dfst['stdev'] = Poat.std()/ dfst['poat']
+    dfst.index=Poat.columns.astype(str)
+
+    # Power Calculations/Saving
+    Pout=pd.DataFrame()
+    Pout['Pavg']=Pavg_all
+    Pout['Pdet']=Pdet_all
+    Pout['Front_Pavg']=Pavg_front_all
+    Pout['Front_Pdet']=Pdet_front_all
+    Pout['Mismatch_rel'] = 100-(Pout['Pdet']*100/Pout['Pavg'])
+    Pout['Front_Mismatch_rel'] = 100-(Pout['Front_Pdet']*100/Pout['Front_Pavg'])   
+    Pout.index=Poat.columns.astype(str)
+
+    ## Save CSV as one long row
+    df_all = pd.concat([Pout, dfst, Poat.T, F.T, B.T], axis=1)
+    df_all.to_csv(writefiletitle)
+    print("Saved Results to ", writefiletitle)
+    
+
+    
+