""" calculate moduli for ramps  before and after preconditioning
 hysteresis
# input needed = csv file with data file names, individual extracted information csv, thickness/length, area of cross section  
repeatability results are plotted and saved (.svg and .csv)  """



import sys
import matplotlib.pyplot as plt
import csv
import numpy as np
import pylab as pl
import scipy
import BasicUtilities
import statistics

def USAGE(argv):
 print
 print ('USAGE: ') + argv[0] + ' <at least one data file required>'
 print

def main(argv):

 if len(argv)<2:
        USAGE(argv)
        sys.exit(1)
        
 sample_names = []
 output_file_names = []
 dimensions = []
 area_cross_section = []
 
 input_filename = argv[1]
 infile = open(input_filename, 'r')
 for line in infile: # read each line to extract individual test information
     line = line.rstrip('\n')
     line=line.split()
     sample_names.append(line[0])
     output_file_names.append(line[1])
     dimensions.append(line[2])
     area_cross_section.append(line[3])
 

 num = len(sample_names)
 
 output_filename = sample_names[0][0:18]
 input_tags = ""
 for i in range (0,num):
     input_tags = input_tags + sample_names[i][20:21] # grabbing test numbers from input file names 


 disp1 = [[] for x in range (num)]
 load1 = [[] for x in range (num)]
 disp2 = [[] for x in range (num)] # unload
 load2 = [[] for x in range (num)] # unload
 disp3 = [[] for x in range (num)]
 load3 = [[] for x in range (num)]
 disp4 = [[] for x in range (num)] # unload
 load4 = [[] for x in range (num)] # unload
 strain1 = [[] for x in range (num)]
 stress1 = [[] for x in range (num)]
 strain2 = [[] for x in range (num)] # unload
 stress2 = [[] for x in range (num)] # unload
 strain3 = [[] for x in range (num)]
 stress3 = [[] for x in range (num)]
 strain4 = [[] for x in range (num)] # unload
 stress4 = [[] for x in range (num)] # unload
 
 all_low_strain_mod_before_pc = []
 all_mid_strain_mod_before_pc = []
 all_high_strain_mod_before_pc = []
 all_low_strain_mod_after_pc = []
 all_mid_strain_mod_after_pc = []
 all_high_strain_mod_after_pc = []
 
 for i in range(1,num+1):
    f_name = sample_names[i-1]
    infile  = open(f_name,'r')
#    print f_name
    for line in infile:
      line = line.rstrip('\n')
      line=line.split()
      line=map(float,line)
      # extract pre pc load and unload
      disp1[i-1].append(line[0])
      load1[i-1].append(line[2]) 
      disp2[i-1].append(line[3])
      load2[i-1].append(line[5]) 
      # extract post pc load and unload
      disp3[i-1].append(line[6])
      load3[i-1].append(line[8]) 
      disp4[i-1].append(line[9])
      load4[i-1].append(line[11])  
    infile.close()
    
    plt.figure(1)
    plt.plot(disp1[i-1],load1[i-1])
    plt.plot(disp2[i-1],load2[i-1])
    plt.plot(disp3[i-1],load3[i-1])
    plt.plot(disp4[i-1],load4[i-1])
    
    
    # extract information from output csv files to ditionary
    f_output = output_file_names[i-1]
    with open(f_output, mode='r') as f_output:
          reader = csv.reader(f_output)
          mydict = dict(reader)
    norm_pnt_pc = mydict["Experimental reference location pc, 10g"]
    
    

    
    # normalizing disp, load for loading before and after pc
    disp1[i-1],load1[i-1], id = BasicUtilities.norml_load_before_pc(disp1[i-1],load1[i-1],norm_pnt_pc,10)
#    disp2[i-1],load2[i-1] = BasicUtilities.norml_unload_before_pc(disp2[i-1],load2[i-1],norm_pnt_pc, id)
    
    
    disp3[i-1],load3[i-1],id  = BasicUtilities.norml_load_after_pc(disp3[i-1],load3[i-1],norm_pnt_pc,10,id)
#    disp4[i-1],load4[i-1] = BasicUtilities.norml_unload_after_pc(disp4[i-1],load4[i-1],norm_pnt_pc, id)
    
    
    
    plt.figure(2)
    plt.plot(disp1[i-1],load1[i-1])
#    plt.plot(disp2[i-1],load2[i-1])
    plt.plot(disp3[i-1],load3[i-1])
#    plt.plot(disp4[i-1],load4[i-1])
    
    # hysteresis
    

   # stress-strain calculation and clip for relevant data 
    strain1[i-1] = [c/ float(dimensions[i-1]) for c in disp1[i-1]]
    stress1[i-1] = [c/float(area_cross_section[i-1]) for c in load1[i-1]]
    stress1[i-1] = [c*0.0098 for c in stress1[i-1]]
    
    peak = max(stress1[i-1])
    kx = [iv for iv, jg in enumerate(stress1[i-1]) if jg == peak] # find all indices at which peak value is present in list
    yj = kx[0] # pick 1st index at which max disp appears     
    strain1[i-1] = strain1[i-1][:yj]
    stress1[i-1] = stress1[i-1][:yj]
    
    sk = BasicUtilities.find_nearest(strain1[i-1],0)  
    strain1[i-1] = strain1[i-1][sk:yj]
    stress1[i-1] = stress1[i-1][sk:yj]
    
    
    strain3[i-1] = [c/ float(dimensions[i-1]) for c in disp3[i-1]]
    stress3[i-1] = [c/float(area_cross_section[i-1]) for c in load3[i-1]]
    stress3[i-1] = [c*0.0098 for c in stress3[i-1]]
    
    peak = max(stress3[i-1])
    kx1 = [iv for iv, jg in enumerate(stress3[i-1]) if jg == peak] # find all indices at which peak value is present in list   
    yj1 = kx1[0] # pick 1st index at which max disp appears 
    strain3[i-1] = strain3[i-1][:yj1]
    stress3[i-1] = stress3[i-1][:yj1]
    
    sk1 = BasicUtilities.find_nearest(strain1[i-1],0)  
    strain3[i-1] = strain3[i-1][sk1:yj1]
    stress3[i-1] = stress3[i-1][sk1:yj1]
    
    plt.figure(4)
    plt.plot(strain1[i-1],stress1[i-1], label = ('test' + str(i)) + ' before PC')
    plt.plot(strain3[i-1],stress3[i-1],'--', label = ('test' + str(i)) + ' after PC')
    plt.legend(loc=2)
    plt.legend(loc=2)
    plt.xlabel('strain')
    plt.ylabel('stress, MPa')
    
    
    
    # moduli before and after pc for high strain (upper half of strain)
    ln = len(stress1[i-1])
    mod_before_pc, inter =  np.polyfit(strain1[i-1][(ln/2): ln-1],stress1[i-1][(ln/2): ln-1],1) # second half of the curve
    print 'mod_before_pc', mod_before_pc
    
    ln1 = len(stress3[i-1])
    mod_after_pc, inter =  np.polyfit(strain3[i-1][(ln1/2): ln1-1],stress3[i-1][(ln1/2): ln1-1],1) # second half of the curve
    print 'mod_after_pc', mod_after_pc
    
    
    # separate loading curves before and after pc in three and calculate low, mid and high strain moduli  
    low_strain_mod_before_pc, inter =  np.polyfit(strain1[i-1][0 : (ln/3)],stress1[i-1][0 : (ln/3)],1)
    mid_strain_mod_before_pc, inter =  np.polyfit(strain1[i-1][(ln/3): (2*ln/3)],stress1[i-1][(ln/3): (2*ln/3)],1)
    high_strain_mod_before_pc, inter =  np.polyfit(strain1[i-1][(2*ln/3): ln-1],stress1[i-1][(2*ln/3): ln-1],1)
    
    
    low_strain_mod_after_pc, inter =  np.polyfit(strain3[i-1][0 : (ln1/3)],stress3[i-1][0 : (ln1/3)],1)
    mid_strain_mod_after_pc, inter =  np.polyfit(strain3[i-1][(ln1/3): (2*ln1/3)],stress3[i-1][(ln1/3): (2*ln1/3)],1)
    high_strain_mod_after_pc, inter =  np.polyfit(strain3[i-1][(2*ln1/3): ln1-1],stress3[i-1][(2*ln1/3): ln1-1],1)
    
    
#    print 'low_strain_mod_before_pc', low_strain_mod_before_pc
#    print 'low_strain_mod_after_pc', low_strain_mod_after_pc
#   
    # values for all tests 
    

    
    all_low_strain_mod_before_pc.append(low_strain_mod_before_pc)
    all_mid_strain_mod_before_pc.append(mid_strain_mod_before_pc)
    all_high_strain_mod_before_pc.append(high_strain_mod_before_pc)
    all_low_strain_mod_after_pc.append(low_strain_mod_after_pc)
    all_mid_strain_mod_after_pc.append(mid_strain_mod_after_pc)
    all_high_strain_mod_after_pc.append(high_strain_mod_after_pc)
    
#    print all_low_strain_mod_before_pc
  
    
 
 
 pc_Plot = output_filename + '_' +  input_tags + '_pc_ramps_repeat'+ '.svg'
 plt.savefig(pc_Plot) 
 plt.show()
 
 # stats
 
 mean_low_strain_mod_before_pc = statistics.mean(all_low_strain_mod_before_pc)
 SD_low_strain_mod_before_pc = statistics.stdev(all_low_strain_mod_before_pc)
 cov_low_strain_mod_before_pc = (SD_low_strain_mod_before_pc / mean_low_strain_mod_before_pc) * 100
    
 mean_mid_strain_mod_before_pc = statistics.mean(all_mid_strain_mod_before_pc)
 SD_mid_strain_mod_before_pc = statistics.stdev(all_mid_strain_mod_before_pc)
 cov_mid_strain_mod_before_pc = (SD_mid_strain_mod_before_pc / mean_mid_strain_mod_before_pc) * 100
    
 mean_high_strain_mod_before_pc = statistics.mean(all_high_strain_mod_before_pc)
 SD_high_strain_mod_before_pc = statistics.stdev(all_high_strain_mod_before_pc)
 cov_high_strain_mod_before_pc = (SD_high_strain_mod_before_pc / mean_high_strain_mod_before_pc) * 100
    
 mean_low_strain_mod_after_pc = statistics.mean(all_low_strain_mod_after_pc)
 SD_low_strain_mod_after_pc = statistics.stdev(all_low_strain_mod_after_pc)
 cov_low_strain_mod_after_pc = (SD_low_strain_mod_after_pc / mean_low_strain_mod_after_pc) * 100
    
 mean_mid_strain_mod_after_pc = statistics.mean(all_mid_strain_mod_after_pc)
 SD_mid_strain_mod_after_pc = statistics.stdev(all_mid_strain_mod_after_pc)
 cov_mid_strain_mod_after_pc = (SD_mid_strain_mod_after_pc / mean_mid_strain_mod_after_pc) * 100
    
 mean_high_strain_mod_after_pc = statistics.mean(all_high_strain_mod_after_pc)
 SD_high_strain_mod_after_pc = statistics.stdev(all_high_strain_mod_after_pc)
 cov_high_strain_mod_after_pc = (SD_high_strain_mod_after_pc / mean_high_strain_mod_after_pc) * 100
 
 # save to csv 
    
 output_file = output_filename + '_' + input_tags + '_output_pc_ramps_repeat' # repeatability output file
 out_datafile_id = open(output_file + '.csv', 'w')
 out_writer = csv.writer(out_datafile_id)
     
 out_writer.writerow(['all_low_strain_mod_before_pc', all_low_strain_mod_before_pc ])
 out_writer.writerow(['all_mid_strain_mod_before_pc', all_mid_strain_mod_before_pc ])
 out_writer.writerow(['all_high_strain_mod_before_pc', all_high_strain_mod_before_pc ])
 out_writer.writerow(['all_low_strain_mod_after_pc', all_low_strain_mod_after_pc ])
 out_writer.writerow(['all_mid_strain_mod_after_pc', all_mid_strain_mod_after_pc ])
 out_writer.writerow(['all_high_strain_mod_after_pc', all_high_strain_mod_after_pc ])
    
#    
 out_writer.writerow(['mean_low_strain_mod_before_pc', mean_low_strain_mod_before_pc ])
 out_writer.writerow(['SD_low_strain_mod_before_pc', SD_low_strain_mod_before_pc ])
 out_writer.writerow(['cov_low_strain_mod_before_pc', cov_low_strain_mod_before_pc ])
    
    
 out_writer.writerow(['mean_mid_strain_mod_before_pc', mean_mid_strain_mod_before_pc ])
 out_writer.writerow(['SD_mid_strain_mod_before_pc', SD_mid_strain_mod_before_pc ])
 out_writer.writerow(['cov_mid_strain_mod_before_pc', cov_mid_strain_mod_before_pc ])  


 out_writer.writerow(['mean_high_strain_mod_before_pc', mean_high_strain_mod_before_pc ])
 out_writer.writerow(['SD_high_strain_mod_before_pc', SD_high_strain_mod_before_pc ])
 out_writer.writerow(['cov_high_strain_mod_before_pc', cov_high_strain_mod_before_pc ])
    
   
 out_writer.writerow(['mean_low_strain_mod_after_pc', mean_low_strain_mod_after_pc ])
 out_writer.writerow(['SD_low_strain_mod_after_pc', SD_low_strain_mod_after_pc ])
 out_writer.writerow(['cov_low_strain_mod_after_pc', cov_low_strain_mod_after_pc ])
    
 out_writer.writerow(['mean_mid_strain_mod_after_pc', mean_mid_strain_mod_after_pc ])
 out_writer.writerow(['SD_mid_strain_mod_after_pc', SD_mid_strain_mod_after_pc ])
 out_writer.writerow(['cov_mid_strain_mod_after_pc', cov_mid_strain_mod_after_pc ])


 out_writer.writerow(['mean_high_strain_mod_after_pc', mean_high_strain_mod_after_pc ])
 out_writer.writerow(['SD_high_strain_mod_after_pc', SD_high_strain_mod_after_pc ])
 out_writer.writerow(['cov_high_strain_mod_after_pc', cov_high_strain_mod_after_pc ])
    
 print 'done writing'
 
if __name__=="__main__":
 main(sys.argv)