SHARE
TWEET

Untitled

a guest Jul 16th, 2019 56 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import pandas as pd
  2. import os
  3. from datetime import datetime
  4. import numpy as np
  5. import matplotlib.pyplot as plt
  6. import scipy
  7. import statsmodels.api as sm
  8. from scipy import stats
  9.  
  10. # read CSV files in folder "download" and store data into DataFrame
  11. def ReadCSV(path,l_csv):
  12.    
  13.     df_letture=pd.DataFrame(columns=["Data/Ora"])
  14.     df_letture=df_letture.set_index("Data/Ora")
  15.     d_letture={}
  16.    
  17.     for csv_file in l_csv:
  18.         csv_file=csv_file.strip()
  19.  
  20.         df_excel=pd.read_csv(path+'/'+csv_file,decimal=',',sep=';')
  21.  
  22.         # add n_centralina column data
  23.         n_centralina=csv_file[:-4]
  24.        
  25.         # purge columns names from units
  26.         l_col=[]
  27.         l_col_units=df_excel.columns.tolist()
  28.         for name in l_col_units:    
  29.             name = name.split()[0]  
  30.             l_col.append(name)
  31.         df_excel.columns=l_col
  32.        
  33.         l_datetime_obj=[]      
  34.         for elem in df_excel["Data/Ora"]:
  35.             datetime_obj = datetime.strptime(elem, '%d/%m/%Y %H:%M:%S')
  36.             l_datetime_obj.append(datetime_obj)
  37.        
  38.         df_excel["Data/Ora"]=l_datetime_obj
  39.         df_excel=df_excel.set_index("Data/Ora")
  40.         df_excel=df_excel.sort_index()
  41.        
  42.         # d_letture[n_centralina:df_letture]
  43.         d_letture[n_centralina]=df_excel
  44.    
  45.     return(d_letture)
  46.    
  47.  
  48. # create dictionary ZeroLett with zero measurement    
  49. def ZeroLett(d_letture):
  50.     d_letture_zero={}
  51.    
  52.     for n_centralina in d_letture.keys():
  53.         df_letture=d_letture[n_centralina]
  54.         df_letture=df_letture.sort_index()
  55.         d_letture_zero[n_centralina]=df_letture.iloc[0]
  56.  
  57.     return(d_letture_zero)    
  58.  
  59. # calculate delta between zero lecture and time t lecture
  60. def Delta(d_letture,d_letture_zero):
  61.     d_delta_instr={}
  62.    
  63.     for n_centralina in d_letture.keys():
  64.         df_delta=d_letture[n_centralina]-d_letture_zero[n_centralina]
  65.         d_delta_instr[n_centralina]=df_delta
  66.    
  67.     return(d_delta_instr)
  68.    
  69. # create dictionary with instruments location names
  70. def AssignLocationName(d_delta_instr):
  71.     d_loc_names={'CE1N':{'FESS1':'FESS_GIUNTO_1','FESS2':'FESS_GIUNTO_2'},
  72.              'CE1S':{'FESS1':'FESS_GIUNTO_1','FESS2':'FESS_GIUNTO_2','FESS100':'FESS_MURO_DX_SPALLA','INCL1':'INCL_SPALLA_1','INCL2':'INCL_PILA_1','INCL3':'INCL_PILA_2'},
  73.              'CE2N':{'FESS3':'FESS_GIUNTO_3','FESS4':'FESS_GIUNTO_4'},
  74.              'CE2S':{'FESS3':'FESS_GIUNTO_3','FESS4':'FESS_GIUNTO_4','INCL4':'INCL_PILA_3','INCL5':'INCL_PILA_4'},
  75.              'CE3N':{'FESS5':'FESS_GIUNTO_5','FESS6':'FESS_GIUNTO_6'},
  76.              'CE3S':{'FESS5':'FESS_GIUNTO_5','FESS6':'FESS_GIUNTO_6','INCL6':'INCL_PILA_5'},
  77.              'CE4N':{'FESS7':'FESS_GIUNTO_7','FESS8':'FESS_GIUNTO_8'},
  78.              'CE4S':{'FESS7':'FESS_GIUNTO_7','FESS8':'FESS_GIUNTO_8','INCL7':'INCL_PILA_6','INCL8':'INCL_PILA_7','INCL9':'INCL_SPALLA_2'}}
  79.    
  80.     d_delta=d_delta_instr.copy()
  81.     for n_centralina in d_loc_names.keys():
  82.         for n_str in d_loc_names[n_centralina].keys():
  83.             loc_name=d_loc_names[n_centralina][n_str]
  84.             for n_col in d_delta[n_centralina].columns:
  85.                 if n_str in n_col:
  86.                     new_name=n_col.replace(n_str,loc_name)
  87.                     d_delta[n_centralina]=d_delta[n_centralina].rename(columns = {n_col:new_name})
  88.                    
  89.     return(d_delta)
  90.        
  91. #calculate Ddaily average of each measure  
  92. def DailyAverage(d_delta):
  93.     d_delta_av={}
  94.     l_days_meas=[]
  95.    
  96.     for n_centralina in d_delta.keys():
  97.         l_days_meas=[]
  98.         l_datetime_meas=d_delta[n_centralina].index.tolist()
  99.        
  100.         for meas_time in l_datetime_meas:
  101.             if meas_time.date() not in l_days_meas:
  102.                 l_days_meas.append(meas_time.date())
  103.        
  104.         # initialize DataFrame average delta
  105.         df_delta_av=pd.DataFrame(columns=d_delta[n_centralina].columns)
  106.        
  107.         for day_meas in l_days_meas:
  108.             s_av=d_delta[n_centralina][d_delta[n_centralina].index.date==day_meas].mean()
  109.             df_delta_av=df_delta_av.append(s_av,ignore_index=True)
  110.        
  111.         df_delta_av['date']=l_days_meas
  112.         df_delta_av=df_delta_av.set_index('date')
  113.         d_delta_av[n_centralina]=df_delta_av
  114.        
  115.     return(d_delta_av)
  116.  
  117. def Fit_T_delta(d_delta):
  118.     d_fit_par={}
  119.     ref_date=datetime(2018,12,3)
  120.     d_ref_dates={'CE1N':{'FESS_GIUNTO_1XN':ref_date,'FESS_GIUNTO_1YN':ref_date,'FESS_GIUNTO_1ZN':ref_date,'FESS_GIUNTO_2XN':ref_date,'FESS_GIUNTO_2YN':ref_date,'FESS_GIUNTO_2ZN':ref_date,'TEMP1N':ref_date},
  121.                  'CE1S':{'FESS_GIUNTO_1XS':ref_date,'FESS_GIUNTO_1YS':ref_date,'FESS_GIUNTO_1ZS':ref_date,'FESS_GIUNTO_2XS':ref_date,'FESS_GIUNTO_2YS':ref_date,'FESS_GIUNTO_2ZS':ref_date,'FESS_GIUNTO_100P':ref_date,'FESS_MURO_DX_SPALLA':ref_date,'INCL_SPALLA_1Y':datetime(2018,10,13),'INCL_SPALLA_1X':ref_date,'INCL_PILA_1Y':ref_date,'INCL_PILA_1X':ref_date,'INCL_PILA_2Y':datetime(2019,4,30),'INCL_PILA_2X':ref_date,'TEMP1S':ref_date},
  122.                  'CE2N':{'FESS_GIUNTO_3XN':ref_date,'FESS_GIUNTO_3YN':ref_date,'FESS_GIUNTO_3ZN':ref_date,'FESS_GIUNTO_4XN':ref_date,'FESS_GIUNTO_4YN':ref_date,'FESS_GIUNTO_4ZN':ref_date,'TEMP2N':ref_date},
  123.                  'CE2S':{'FESS_GIUNTO_3XS':ref_date,'FESS_GIUNTO_3YS':ref_date,'FESS_GIUNTO_3ZS':ref_date,'FESS_GIUNTO_4XS':ref_date,'FESS_GIUNTO_4YS':ref_date,'FESS_GIUNTO_4ZS':ref_date,'INCL_PILA_3X':ref_date,'INCL_PILA_3Y':ref_date,'INCL_PILA_4X':ref_date,'INCL_PILA_4Y':ref_date,'TEMP2S':ref_date},
  124.                  'CE3N':{'FESS_GIUNTO_5XN':ref_date,'FESS_GIUNTO_5YN':ref_date,'FESS_GIUNTO_5ZN':ref_date,'FESS_GIUNTO_6XN':ref_date,'FESS_GIUNTO_6YN':ref_date,'FESS_GIUNTO_6ZN':ref_date,'TEMP3N':ref_date},
  125.                  'CE3S':{'FESS_GIUNTO_5XS':ref_date,'FESS_GIUNTO_5YS':ref_date,'FESS_GIUNTO_5ZS':ref_date,'FESS_GIUNTO_6XS':ref_date,'FESS_GIUNTO_6YS':ref_date,'FESS_GIUNTO_6ZS':ref_date,'INCL_PILA_5X':ref_date,'INCL_PILA_5Y':ref_date,'TEMP3S':ref_date},
  126.                  'CE4N':{'FESS_GIUNTO_7XN':ref_date,'FESS_GIUNTO_7YN':ref_date,'FESS_GIUNTO_7ZN':ref_date,'FESS_GIUNTO_8XN':ref_date,'FESS_GIUNTO_8YN':ref_date,'FESS_GIUNTO_8ZN':ref_date,'TEMP4N':ref_date},
  127.                  'CE4S':{'FESS_GIUNTO_7XS':ref_date,'FESS_GIUNTO_7YS':ref_date,'FESS_GIUNTO_7ZS':ref_date,'FESS_GIUNTO_8XS':ref_date,'FESS_GIUNTO_8YS':ref_date,'FESS_GIUNTO_8ZS':ref_date,'INCL_PILA_6X':ref_date,'INCL_PILA_6Y':ref_date,'INCL_PILA_7X':ref_date,'INCL_PILA_7Y':ref_date,'INCL_SPALLA_2X':ref_date,'INCL_SPALLA_2Y':ref_date,'TEMP4S':ref_date}}
  128.  
  129.     for n_centralina in d_delta.keys():
  130.         # initialize DataFrame fit parameters
  131.         df_fit_par=pd.DataFrame(columns=d_delta[n_centralina].columns)
  132.         for column_name in d_delta[n_centralina].columns:
  133.             # find temperature column
  134.             if "TEMP"==column_name[:4]:
  135.                 T_col_name=column_name
  136.                
  137.         for column_name in d_delta[n_centralina].columns:
  138.             #find reference date for interpolation
  139.             ref_date_i=d_ref_dates[n_centralina][column_name]
  140.             x=d_delta[n_centralina][T_col_name][d_delta[n_centralina].index<ref_date_i].values  
  141.             y=d_delta[n_centralina][column_name][d_delta[n_centralina].index<ref_date_i].values
  142.             z=np.polyfit(x,y,1)
  143.             df_fit_par[column_name]=z
  144.        
  145.         d_fit_par[n_centralina]=df_fit_par
  146.        
  147.     return(d_fit_par)
  148.    
  149. def Delta_T_comp(d_delta,d_fit_par):
  150.     d_delta_comp={}
  151.    
  152.     for n_centralina in d_delta.keys():        
  153.         # initialize DataFrame average delta
  154.         df_delta_comp=pd.DataFrame(columns=d_delta[n_centralina].columns, index=d_delta[n_centralina].index)
  155.         # find column temperature name
  156.         for column_name in d_delta[n_centralina].columns:
  157.             if "TEMP"==column_name[:4]:
  158.                 T_col_name=column_name
  159.                
  160.         for column_name in d_delta[n_centralina].columns:
  161.             lett_temp=d_delta[n_centralina][T_col_name].values            
  162.             lett=d_delta[n_centralina][column_name].values            
  163.             lett_comp=lett-d_fit_par[n_centralina][column_name][0]*lett_temp
  164.             df_delta_comp[column_name]=lett_comp
  165.            
  166.         d_delta_comp[n_centralina]=df_delta_comp
  167.        
  168.     return(d_delta_comp)
  169.  
  170. def Plot_t_delta_incl(d_delta,d_delta_av,d_delta_comp):
  171.        
  172.     for n_centralina in d_delta:
  173.         # find temperature column name and tiltimeter columns names
  174.         l_col_incl=[]
  175.         l_n_incl=[]
  176.         for column_name in d_delta[n_centralina].columns:
  177.             if "TEMP"==column_name[:4]:
  178.                 T_col_name=column_name
  179.             elif "INCL"==column_name[:4]:
  180.                 l_col_incl.append(column_name)
  181.                 n_incl=int(''.join(x for x in column_name if x.isdigit()))
  182.                 if n_incl not in l_n_incl:
  183.                     l_n_incl.append(n_incl)
  184.                    
  185.         if l_n_incl:               # check if list is not empty
  186.             for n_incl in l_n_incl:
  187.                 l_data=[name for name in l_col_incl if str(n_incl) in name]
  188.                 l_data_pila=[name for name in l_data if "PILA" in name]
  189.                 l_data_spalla=[name for name in l_data if "SPALLA" in name]
  190.  
  191.                 if l_data_pila:
  192.                     t=d_delta[n_centralina][l_data_pila[0]].index
  193.                     t_av=d_delta_av[n_centralina][l_data_pila[0]].index
  194.                     data1 = d_delta[n_centralina][l_data_pila[0]]
  195.                     data2 = d_delta[n_centralina][l_data_pila[1]]
  196.                     data3=d_delta_av[n_centralina][l_data_pila[0]]
  197.                     data4=d_delta_av[n_centralina][l_data_pila[1]]
  198.                     #data5=d_delta_comp[n_centralina][l_data_pila[0]]
  199.                     #data6=d_delta_comp[n_centralina][l_data_pila[1]]
  200.                     dataT = d_delta[n_centralina][T_col_name].values
  201.                
  202.                     fig, ax1 = plt.subplots()
  203.                     color0 = 'tab:orange'
  204.                     color1 = 'tab:blue'
  205.                     ax1.set_xlabel('time')
  206.                     ax1.set_ylabel('rotazione [°]')
  207.                     ax1.plot(t, data1, color=color0, label=l_data_pila[0],linewidth=0.5)
  208.                     ax1.plot(t, data2, color=color1, label=l_data_pila[1],linewidth=0.5)
  209.                     ax1.plot(t_av, data3, color=color0, label=l_data_pila[0]+'av',linewidth=1.0)
  210.                     ax1.plot(t_av, data4, color=color1, label=l_data_pila[1]+'av',linewidth=1.0)
  211.                     #ax1.plot(t, data5, color=color0, label=l_data_pila[0]+'comp',linewidth=1.0,linestyle="--")
  212.                     #ax1.plot(t, data6, color=color1, label=l_data_pila[1]+'comp',linewidth=1.0,linestyle="--")
  213.                     ax1.tick_params(axis='y')
  214.  
  215.                     # set y axis limits            
  216.                     ax1.set_ylim([-0.2,0.2])
  217.                    
  218.                     plt.grid(True, which='major',axis='both', linestyle='--',dashes=[10, 10], linewidth=0.5)
  219.                     leg=plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3,
  220.                                    ncol=2, mode="expand", borderaxespad=0.,fontsize=8)
  221.                
  222.                     for line in leg.get_lines():
  223.                         line.set_linewidth(2)
  224.            
  225.                     ax2 = ax1.twinx()  # instantiate a second axes that shares the same x-axis
  226.            
  227.                     color = 'tab:grey'
  228.                     ax2.set_ylabel('T [°C]', color=color)
  229.                     ax2.plot(t, dataT, color=color, label="TEMPERATURE", linewidth=0.5,alpha=0.4)
  230.                     ax2.tick_params(axis='y', labelcolor=color)
  231.                     ax2.set_ylim([-25,25])
  232.                    
  233.                     fig.tight_layout()
  234.                     fig.canvas.set_window_title(l_data_pila[0][:-1])
  235.                     plt.show()
  236.                    
  237.                 if l_data_spalla:
  238.                     t=d_delta[n_centralina][l_data_spalla[0]].index
  239.                     t_av=d_delta_av[n_centralina][l_data_spalla[0]].index
  240.                     data1 = d_delta[n_centralina][l_data_spalla[0]]
  241.                     data2 = d_delta[n_centralina][l_data_spalla[1]]
  242.                     data3=d_delta_av[n_centralina][l_data_spalla[0]]
  243.                     data4=d_delta_av[n_centralina][l_data_spalla[1]]
  244.                     #data5=d_delta_comp[n_centralina][l_data_spalla[0]]
  245.                     #data6=d_delta_comp[n_centralina][l_data_spalla[1]]
  246.                     dataT = d_delta[n_centralina][T_col_name].values
  247.                
  248.                     fig, ax1 = plt.subplots()
  249.                     color0 = 'tab:orange'
  250.                     color1 = 'tab:blue'
  251.                     ax1.set_xlabel('time')
  252.                     ax1.set_ylabel('rotazione [°]')
  253.                     ax1.plot(t, data1, color=color0, label=l_data_spalla[0],linewidth=0.5)
  254.                     ax1.plot(t, data2, color=color1, label=l_data_spalla[1],linewidth=0.5)
  255.                     ax1.plot(t_av, data3, color=color0, label=l_data_spalla[0]+'av',linewidth=1.0)
  256.                     ax1.plot(t_av, data4, color=color1, label=l_data_spalla[1]+'av',linewidth=1.0)
  257.                     #ax1.plot(t, data5, color=color0, label=l_data_spalla[0]+'comp',linewidth=1.0,linestyle="--")
  258.                     #ax1.plot(t, data6, color=color1, label=l_data_spalla[1]+'comp',linewidth=1.0,linestyle="--")
  259.                     ax1.tick_params(axis='y')
  260.  
  261.                     # set y axis limits            
  262.                     ax1.set_ylim([-0.2,0.2])
  263.                    
  264.                     plt.grid(True, which='major',axis='both', linestyle='--',dashes=[10, 10], linewidth=0.5)
  265.                     leg=plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3,
  266.                                    ncol=2, mode="expand", borderaxespad=0.,fontsize=8)
  267.                
  268.                     for line in leg.get_lines():
  269.                         line.set_linewidth(2)
  270.            
  271.                     ax2 = ax1.twinx()  # instantiate a second axes that shares the same x-axis
  272.            
  273.                     color = 'tab:grey'
  274.                     ax2.set_ylabel('T [°C]', color=color)
  275.                     ax2.plot(t, dataT, color=color, label="TEMPERATURE", linewidth=0.5,alpha=0.4)
  276.                     ax2.tick_params(axis='y', labelcolor=color)
  277.                     ax2.set_ylim([-25,25])
  278.                    
  279.                     fig.tight_layout()
  280.                     fig.canvas.set_window_title(l_data_spalla[0][:-1])
  281.                     plt.show()
  282.                    
  283. def Plot_t_delta_comp_incl(d_delta_comp, d_delta_av_comp):
  284.        
  285.     for n_centralina in d_delta_comp:
  286.         # find temperature column name and tiltimeter columns names
  287.         l_col_incl=[]
  288.         l_n_incl=[]
  289.         for column_name in d_delta_comp[n_centralina].columns:
  290.             if "TEMP"==column_name[:4]:
  291.                 T_col_name=column_name
  292.             elif "INCL"==column_name[:4]:
  293.                 l_col_incl.append(column_name)
  294.                 n_incl=int(''.join(x for x in column_name if x.isdigit()))
  295.                 if n_incl not in l_n_incl:
  296.                     l_n_incl.append(n_incl)
  297.                    
  298.         if l_n_incl:                    # check if list is not empty
  299.             for n_incl in l_n_incl:
  300.                 l_data=[name for name in l_col_incl if str(n_incl) in name]
  301.                 l_data_pila=[name for name in l_data if "PILA" in name]
  302.                 l_data_spalla=[name for name in l_data if "SPALLA" in name]
  303.  
  304.                 if l_data_pila:
  305.                     t=d_delta_comp[n_centralina][l_data_pila[0]].index
  306.                     t_av=d_delta_av_comp[n_centralina][l_data_pila[0]].index
  307.                     data1 = d_delta_comp[n_centralina][l_data_pila[0]]
  308.                     data2 = d_delta_comp[n_centralina][l_data_pila[1]]
  309.                     data3=d_delta_av_comp[n_centralina][l_data_pila[0]]
  310.                     data4=d_delta_av_comp[n_centralina][l_data_pila[1]]
  311.                     dataT = d_delta_comp[n_centralina][T_col_name].values
  312.                
  313.                     fig, ax1 = plt.subplots()
  314.                     color0 = 'tab:orange'
  315.                     color1 = 'tab:blue'
  316.                     ax1.set_xlabel('time')
  317.                     ax1.set_ylabel('rotazione [°]')
  318.                     ax1.plot(t, data1, color=color0, label=l_data_pila[0]+'comp',linewidth=0.5)
  319.                     ax1.plot(t, data2, color=color1, label=l_data_pila[1]+'comp',linewidth=0.5)
  320.                     ax1.plot(t_av, data3, color=color0, label=l_data_pila[0]+'av'+'comp',linewidth=1.0)
  321.                     ax1.plot(t_av, data4, color=color1, label=l_data_pila[1]+'av'+'comp',linewidth=1.0)
  322.                     ax1.tick_params(axis='y')
  323.  
  324.                     # set y axis limits            
  325.                     ax1.set_ylim([-0.2,0.2])
  326.                    
  327.                     plt.grid(True, which='major',axis='both', linestyle='--',dashes=[10, 10], linewidth=0.5)
  328.                     leg=plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3,
  329.                                    ncol=2, mode="expand", borderaxespad=0.,fontsize=8)
  330.                
  331.                     for line in leg.get_lines():
  332.                         line.set_linewidth(2)
  333.                     '''
  334.                    ax2 = ax1.twinx()  # instantiate a second axes that shares the same x-axis
  335.                    
  336.                    color = 'tab:grey'
  337.                    ax2.set_ylabel('T [°C]', color=color)
  338.                    ax2.plot(t, dataT, color=color, label="TEMPERATURE", linewidth=0.5,alpha=0.4)
  339.                    ax2.tick_params(axis='y', labelcolor=color)
  340.                    ax2.set_ylim([-25,25])
  341.                    '''
  342.                     fig.tight_layout()
  343.                     fig.canvas.set_window_title(l_data_pila[0][:-1]+"comp")
  344.                     plt.show()
  345.                    
  346.                 if l_data_spalla:
  347.                     t=d_delta_comp[n_centralina][l_data_spalla[0]].index
  348.                     t_av=d_delta_av_comp[n_centralina][l_data_spalla[0]].index
  349.                     data1 = d_delta_comp[n_centralina][l_data_spalla[0]]
  350.                     data2 = d_delta_comp[n_centralina][l_data_spalla[1]]
  351.                     data3=d_delta_av_comp[n_centralina][l_data_spalla[0]]
  352.                     data4=d_delta_av_comp[n_centralina][l_data_spalla[1]]
  353.                     dataT = d_delta_comp[n_centralina][T_col_name].values
  354.                
  355.                     fig, ax1 = plt.subplots()
  356.                     color0 = 'tab:orange'
  357.                     color1 = 'tab:blue'
  358.                     ax1.set_xlabel('time')
  359.                     ax1.set_ylabel('rotazione [°]')
  360.                     ax1.plot(t, data1, color=color0, label=l_data_spalla[0]+'comp',linewidth=0.5)
  361.                     ax1.plot(t, data2, color=color1, label=l_data_spalla[1]+'comp',linewidth=0.5)
  362.                     ax1.plot(t_av, data3, color=color0, label=l_data_spalla[0]+'av'+'comp',linewidth=1.0)
  363.                     ax1.plot(t_av, data4, color=color1, label=l_data_spalla[1]+'av'+'comp',linewidth=1.0)
  364.                     ax1.tick_params(axis='y')
  365.  
  366.                     # set y axis limits            
  367.                     ax1.set_ylim([-0.2,0.2])
  368.                    
  369.                     plt.grid(True, which='major',axis='both', linestyle='--',dashes=[10, 10], linewidth=0.5)
  370.                     leg=plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3,
  371.                                    ncol=2, mode="expand", borderaxespad=0.,fontsize=8)
  372.                
  373.                     for line in leg.get_lines():
  374.                         line.set_linewidth(2)
  375.                     '''
  376.                    ax2 = ax1.twinx()  # instantiate a second axes that shares the same x-axis
  377.            
  378.                    color = 'tab:grey'
  379.                    ax2.set_ylabel('T [°C]', color=color)
  380.                    ax2.plot(t, dataT, color=color, label="TEMPERATURE", linewidth=0.5,alpha=0.4)
  381.                    ax2.tick_params(axis='y', labelcolor=color)
  382.                    ax2.set_ylim([-25,25])
  383.                    '''
  384.                     fig.canvas.set_window_title(l_data_spalla[0][:-1]+"comp")
  385.                     fig.tight_layout()    
  386.                     plt.show()
  387.                                      
  388.  
  389. def PearsonCorr(d_delta):
  390.     d_coeff_Pear={}
  391.     for n_centralina in d_delta:
  392.         df_coeff=pd.DataFrame(columns=d_delta[n_centralina].columns)
  393.         # find temperature column name and crack width gauge columns names
  394.         l_col_fess=[]
  395.         l_n_fess=[]
  396.         for column_name in d_delta[n_centralina].columns:
  397.             if "TEMP"==column_name[:4]:
  398.                 T_col_name=column_name
  399.             elif "FESS"==column_name[:4]:
  400.                 l_col_fess.append(column_name)
  401.                 n_fess=int(''.join(x for x in column_name if x.isdigit()))
  402.                 if n_fess not in l_n_fess:
  403.                     l_n_fess.append(n_fess)
  404.                    
  405.         if l_n_fess:     # check if list is not empty
  406.             for n_fess in l_n_fess:
  407.                 if n_fess != 100:
  408.                     l_data=[name for name in l_col_fess if str(n_fess) in name]  
  409.                     T = d_delta[n_centralina][T_col_name]
  410.                     data1 = d_delta[n_centralina][l_data[0]]
  411.                     data2 = d_delta[n_centralina][l_data[1]]
  412.                     data3 = d_delta[n_centralina][l_data[2]]
  413.                     c1=scipy.stats.pearsonr(T, data1)
  414.                     c2=scipy.stats.pearsonr(T, data2)
  415.                     c3=scipy.stats.pearsonr(T, data3)
  416.                     df_coeff[l_data[0]]=c1
  417.                     df_coeff[l_data[1]]=c2
  418.                     df_coeff[l_data[2]]=c3
  419.                    
  420.             d_coeff_Pear[n_centralina]=df_coeff
  421.            
  422.     return(d_coeff_Pear)
  423.  
  424.  
  425.  
  426. def Plot_t_delta_fess(d_delta,d_delta_av,d_delta_comp,d_coeff_Pear):
  427.  
  428.     for n_centralina in d_delta:        
  429.         # find temperature column name and crack width gauge columns names
  430.         l_col_fess=[]
  431.         l_n_fess=[]
  432.         for column_name in d_delta[n_centralina].columns:
  433.             if "TEMP"==column_name[:4]:
  434.                 T_col_name=column_name
  435.             elif "FESS"==column_name[:4]:
  436.                 l_col_fess.append(column_name)
  437.                 n_fess=int(''.join(x for x in column_name if x.isdigit()))
  438.                 if n_fess not in l_n_fess:
  439.                     l_n_fess.append(n_fess)
  440.         if l_n_fess:     # check if list is not empty
  441.             for n_fess in l_n_fess:
  442.                 if n_fess != 100:
  443.                     l_data=[name for name in l_col_fess if str(n_fess) in name]
  444.                     t = d_delta[n_centralina][l_data[0]].index
  445.                     t_av=d_delta_av[n_centralina][l_data[0]].index
  446.                     data1 = d_delta[n_centralina][l_data[0]]
  447.                     data2 = d_delta[n_centralina][l_data[1]]
  448.                     data3 = d_delta[n_centralina][l_data[2]]
  449.                     data4 = d_delta_av[n_centralina][l_data[0]]
  450.                     data5 = d_delta_av[n_centralina][l_data[1]]
  451.                     data6 = d_delta_av[n_centralina][l_data[2]]
  452.                     dataT = d_delta[n_centralina][T_col_name].values
  453.              
  454.                     fig, ax1 = plt.subplots()
  455.  
  456.                     color = 'tab:orange'
  457.                     ax1.set_xlabel('time')
  458.                     ax1.set_ylabel('spostamento [mm]', color=color)
  459.                     ax1.plot(t, data1, color=color, label=l_data[0],linewidth=0.5)
  460.                     ax1.plot(t_av, data4, color=color, label=l_data[0]+'av',linewidth=0.5)
  461.                     ax1.tick_params(axis='y', labelcolor=color)
  462.  
  463.                     color = 'tab:blue'
  464.                     ax1.set_xlabel('time')
  465.                     ax1.set_ylabel('spostamento [mm]', color=color)
  466.                     ax1.plot(t, data2, color=color, label=l_data[1],linewidth=0.5)
  467.                     ax1.plot(t_av, data5, color=color, label=l_data[1]+'av',linewidth=0.5)
  468.                     ax1.tick_params(axis='y', labelcolor=color)
  469.            
  470.                     color = 'tab:green'
  471.                     ax1.set_xlabel('time')
  472.                     ax1.set_ylabel('spostamento [mm]', color=color)
  473.                     ax1.plot(t, data3, color=color, label=l_data[2],linewidth=0.5)
  474.                     ax1.plot(t_av, data6, color=color, label=l_data[2]+'av',linewidth=0.5)
  475.                     ax1.tick_params(axis='y', labelcolor=color)
  476.            
  477.                     ax1.set_ylim([-15,15])
  478.                    
  479.                     textstr1=l_data[0]+' '+'c_Pear='+str(round(d_coeff_Pear[n_centralina][l_data[0]][0],2))
  480.                     textstr2=l_data[1]+' '+'c_Pear='+str(round(d_coeff_Pear[n_centralina][l_data[1]][0],2))
  481.                     textstr3=l_data[2]+' '+'c_Pear='+str(round(d_coeff_Pear[n_centralina][l_data[2]][0],2))
  482.                     ax1.text(0.05, 0.95,'%s\n%s\n%s'%(textstr1,textstr2,textstr3),
  483.                              transform=ax1.transAxes,fontsize=6,
  484.                              verticalalignment='top')
  485.        
  486.                     plt.grid(True, which='major',axis='both', linestyle='--',dashes=[10, 10], linewidth=0.5)
  487.                     leg=plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3,
  488.                                ncol=3, mode="expand", borderaxespad=0.,fontsize=8)
  489.                    
  490.                     for line in leg.get_lines():
  491.                         line.set_linewidth(2)
  492.        
  493.                     ax2 = ax1.twinx()  # instantiate a second axes that shares the same x-axis
  494.  
  495.                     color = 'tab:grey'
  496.                     ax2.set_ylabel('T [°C]', color=color)
  497.                     ax2.plot(t, dataT, color=color, label="TEMPERATURE", linewidth=0.5, alpha=0.4)
  498.                     ax2.tick_params(axis='y', labelcolor=color)
  499.                     ax2.set_ylim([-25,25])
  500.  
  501.                     fig.canvas.set_window_title(l_data[0][:-2]+l_data[0][-1])
  502.                     fig.tight_layout()    
  503.                     plt.show()
  504.  
  505. def Plot_T_delta(d_delta,d_delta_av,d_fit_par):
  506.    
  507.     for n_centralina in d_delta:
  508.        
  509.         # find temperature column name and tiltimeter columns names
  510.         l_col_incl=[]
  511.         l_n_incl=[]
  512.         for column_name in d_delta[n_centralina].columns:
  513.             if "TEMP"==column_name[:4]:
  514.                 T_col_name=column_name
  515.             elif "INCL"==column_name[:4]:
  516.                 l_col_incl.append(column_name)
  517.                 n_incl=int(''.join(x for x in column_name if x.isdigit()))
  518.                 if n_incl not in l_n_incl:
  519.                     l_n_incl.append(n_incl)
  520.                    
  521.         if l_n_incl:               # check if list is not empty
  522.             for n_incl in l_n_incl:
  523.                 l_data=[name for name in l_col_incl if str(n_incl) in name]
  524.                 l_data_pila=[name for name in l_data if "PILA" in name]
  525.                 l_data_spalla=[name for name in l_data if "SPALLA" in name]
  526.  
  527.                 if l_data_pila:
  528.                     T = d_delta[n_centralina][T_col_name]
  529.                     data1 = d_delta[n_centralina][l_data_pila[0]]
  530.                     data2= d_delta[n_centralina][l_data_pila[1]]
  531.    
  532.                     p1 = np.poly1d(d_fit_par[n_centralina][l_data_pila[0]])
  533.                     p2 = np.poly1d(d_fit_par[n_centralina][l_data_pila[1]])
  534.                     xp = np.linspace(min(T), max(T), 100)
  535.  
  536.                     fig, ax1 = plt.subplots()
  537.    
  538.                     color0 = 'tab:orange'
  539.                     color1 = 'tab:blue'
  540.                     ax1.set_xlabel('TEMPERATURE')
  541.                     ax1.set_ylabel('rotazione [°]', color=color0)
  542.                     ax1.scatter(T, data1, s=1, color=color0, label=l_data_pila[0])
  543.                     ax1.scatter(T, data2, s=1, color=color1, label=l_data_pila[1])
  544.                     ax1.plot(xp,p1(xp),color=color0)
  545.                     ax1.plot(xp,p2(xp), color=color1)
  546.                     ax1.tick_params(axis='y')
  547.                     #ax1.set_ylim()
  548.    
  549.                     plt.grid(True, which='major',axis='both', linestyle='--',dashes=[10, 10], linewidth=0.5)
  550.                     plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3,
  551.                                ncol=2, mode="expand", borderaxespad=0.)
  552.                    
  553.                     fig.canvas.set_window_title(l_data_pila[0][:-1]+"T-delta")
  554.                     fig.tight_layout()      # otherwise the right y-label is slightly clipped
  555.                     plt.show()
  556.                    
  557.                 if l_data_spalla:
  558.                     T = d_delta[n_centralina][T_col_name]
  559.                     data1 = d_delta[n_centralina][l_data_spalla[0]]
  560.                     data2= d_delta[n_centralina][l_data_spalla[1]]
  561.    
  562.                     p1 = np.poly1d(d_fit_par[n_centralina][l_data_spalla[0]])
  563.                     p2 = np.poly1d(d_fit_par[n_centralina][l_data_spalla[1]])
  564.                     xp = np.linspace(min(T), max(T), 100)
  565.  
  566.                     fig, ax1 = plt.subplots()
  567.    
  568.                     color0 = 'tab:orange'
  569.                     color1 = 'tab:blue'
  570.                     ax1.set_xlabel('TEMPERATURE')
  571.                     ax1.set_ylabel('rotazione [°]', color=color0)
  572.                     ax1.scatter(T, data1, s=1, color=color0, label=l_data_spalla[0])
  573.                     ax1.scatter(T, data2, s=1, color=color1, label=l_data_spalla[1])
  574.                     ax1.plot(xp,p1(xp),color=color0)
  575.                     ax1.plot(xp,p2(xp), color=color1)
  576.                     ax1.tick_params(axis='y')
  577.                     #ax1.set_ylim()
  578.    
  579.                     plt.grid(True, which='major',axis='both', linestyle='--',dashes=[10, 10], linewidth=0.5)
  580.                     plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3,
  581.                                ncol=2, mode="expand", borderaxespad=0.)
  582.                    
  583.                     fig.canvas.set_window_title(l_data_spalla[0][:-1]+" T-delta")
  584.                     fig.tight_layout()      # otherwise the right y-label is slightly clipped
  585.                     plt.show()
  586.  
  587. '''
  588. def DataDecomposition(d_delta):
  589.  
  590.    #for n_centralina in d_delta.keys():
  591.    n_centralina="CE1N"
  592.    #for n_inst in d_delta[n_centralina].columns:
  593.    n_inst='FESS_GIUNTO_1XN'
  594.    decomposition = sm.tsa.seasonal_decompose(d_delta[n_centralina][n_inst], model='additive)
  595.    fig = decomposition.plot()
  596.    fig.canvas.set_window_title(n_inst)
  597.    fig.tight_layout()
  598.    plt.show()
  599. '''
  600. def main():
  601.    
  602.     path="./download"
  603.     l_csv=os.listdir(path)
  604.     d_letture=ReadCSV(path,l_csv)
  605.     d_letture_zero=ZeroLett(d_letture)
  606.     d_delta_instr=Delta(d_letture,d_letture_zero)
  607.     d_delta=AssignLocationName(d_delta_instr)
  608.     d_delta_av=DailyAverage(d_delta)
  609.     d_fit_par=Fit_T_delta(d_delta)
  610.     d_delta_comp=Delta_T_comp(d_delta,d_fit_par)
  611.     d_delta_av_comp=DailyAverage(d_delta_comp)
  612.     d_coeff_Pear=PearsonCorr(d_delta)
  613.     Plot_t_delta_incl(d_delta,d_delta_av,d_delta_comp)
  614.     Plot_t_delta_comp_incl(d_delta_comp, d_delta_av_comp)
  615.     Plot_t_delta_fess(d_delta,d_delta_av,d_delta_comp,d_coeff_Pear)
  616.     Plot_T_delta(d_delta,d_delta_av,d_fit_par)    
  617.    
  618. # call the main function
  619. if __name__ == "__main__":
  620.     main()
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top