tools/data_processing/bl_steadiness.py

   1 #!/usr/bin/env python
   2 ##################################
   3 import os, sys, time
   4 import numpy
   5 import sets
   6
   7 import numpy
   8
   9 import home_prefix
  10
  11 #from bl_instance.build_bl import *
  12
  13 from tools.generic_utils.time_formats  import *
  14 from tools.generic_utils.time_intervals  import *
  15 from tools.archiving_extraction import paramdata_filename
  16 from splittingTime_byData import *
  17
  18 ###################################
  19 from bl_instance.build_bl import *
  20 ###################################
  21
  22
  23 ###############################################
  24 ##startShift_hour = '07:00:00'
  25 ##endShift_hour = '07:00:00'
  26
  27 STEADYPERIOD_MINLENGTH = 60*10 # = 10 min
  28 #steadyPeriod_maxLength_sec = 60*60*3 # = 3 hours
  29 ###############################################
  30
  31
  32 #################
  33 class bl_steady:
  34
  35     def __init__(self, _steady_params, _rel_timeInterval_sec, _abs_timeInterval_str, _monitor = 0):
  36
  37         self.steady_params = _steady_params       # dict{name:val}
  38         self.rel_timeInterval = _rel_timeInterval_sec
  39         self.abs_timeInterval = _abs_timeInterval_str
  40         self.monitor = _monitor # is needed to order params following the beam_path
  41
  42
  43     def __repr__(self):
  44
  45         params_str = ''
  46
  47         if self.monitor:
  48             params_in = True
  49             for p in self.monitor.beamAccess_params + self.monitor.blSteadiness_params:
  50                 if not p.name in self.steady_params.keys():
  51                     params_in = False
  52                     break
  53
  54             if params_in:
  55                 for p in self.monitor.beamAccess_params + self.monitor.blSteadiness_params:
  56                     params_str += p.name + ' = ' + str(self.steady_params[p.name]) + '\n'
  57             else:
  58                 for p_name in self.steady_params.keys():
  59                     params_str += p_name + ' = ' + str(self.steady_params[p_name]) + '\n'
  60         else:
  61             for p_name in self.steady_params.keys():
  62                 params_str += p_name + ' = ' + str(self.steady_params[p_name]) + '\n'
  63
  64         return ( '\n'+ str(self.rel_timeInterval) + ' -> ' + str(self.abs_timeInterval) + '\n'
  65                  + params_str )
  66
  67
  68
  69     def matches_condition(self, param_name, param_val, delta = -1):
  70
  71         if not param_name in self.steady_params.keys():
  72             print "Invalid param name in bl_steady.matches_condition"
  73             sys.exit(0)
  74
  75         if delta == -1:
  76             delta = 0
  77
  78         return abs(self.steady_params[param_name] - param_val) <= delta
  79
  80
  81
  82
  83 ###########################################################
  84 def get_blSteadyStates(params_data, overAll_timeInterval_str):
  85
  86     params_breakMoments_vals = {} ###
  87     latest_firstMoment = 0  # latest first data over all params
  88
  89     for p in params_data.keys():
  90         print p.name # DEBUG
  91
  92         if params_data[p][0][0] > latest_firstMoment:
  93             latest_firstMoment = params_data[p][0][0]
  94
  95         params_breakMoments_vals[p] = get_breakMoments_vals(p, params_data[p])
  96         print numpy.transpose(params_breakMoments_vals[p]) # DEBUG
  97
  98         'params_breakMoments_vals[p][0] = vector of moments (rel. time in sec.)'
  99         'params_breakMoments_vals[p][1] = vector of corresponding values'
 100
 101     print '\nlatest_firstMoment = ', latest_firstMoment, '\n' # DEBUG
 102
 103     for p in params_breakMoments_vals.keys():
 104         p_n = len(params_breakMoments_vals[p][0])
 105         m_inx = 0
 106         if p_n:
 107             while (params_breakMoments_vals[p][0][m_inx] < latest_firstMoment and
 108                    m_inx < p_n -1):
 109                 m_inx += 1
 110
 111
 112             if m_inx != 0:
 113
 114                 first_val = params_breakMoments_vals[p][1][m_inx-1] # keep this val for each param
 115
 116                 #for all params, remove all the stuff (moments and vals) preceeding the latest_firstMoment:
 117                 del params_breakMoments_vals[p][0][:m_inx]
 118                 del params_breakMoments_vals[p][1][:m_inx]
 119
 120                 params_breakMoments_vals[p][0].insert(0, latest_firstMoment)
 121                 params_breakMoments_vals[p][1].insert(0, first_val)
 122
 123             else:
 124                 params_breakMoments_vals[p][0].insert(0, latest_firstMoment)
 125                 params_breakMoments_vals[p][1].insert(0, params_data[p][0][1])
 126
 127         else:
 128             params_breakMoments_vals[p][0].append(latest_firstMoment)
 129             params_breakMoments_vals[p][1].append(params_data[p][0][1])
 130
 131
 132     overAll_breakMoments = []  ###
 133     for p in params_breakMoments_vals.keys():
 134         overAll_breakMoments += params_breakMoments_vals[p][0]
 135
 136     overAll_breakMoments = list(sets.Set(overAll_breakMoments))# removes duplicates
 137     overAll_breakMoments.sort()
 138     print "overAll_breakMoments = ", overAll_breakMoments, '\n' # DEBUG
 139
 140     params_steadyVals = {} ###
 141     for p in params_breakMoments_vals.keys():
 142
 143         p_valsNb = len(params_breakMoments_vals[p][0])
 144
 145
 146         params_steadyVals[p] = [params_breakMoments_vals[p][1][0]] # init: corresponding to the latest_firstMoment
 147
 148         overAll_i = 1 # 0 corresponds to the latest_firstMoment for all params
 149         for p_i in range(1, p_valsNb):
 150
 151             while overAll_breakMoments[overAll_i] < params_breakMoments_vals[p][0][p_i]:
 152                 params_steadyVals[p].append(params_breakMoments_vals[p][1][p_i-1])
 153                 overAll_i += 1
 154
 155         def f(x): return params_breakMoments_vals[p][1][p_valsNb-1]
 156
 157         params_steadyVals[p] += map(f, range( overAll_i,len(overAll_breakMoments) ))
 158
 159         print "params_steadyVals[", p.name, "] = ", params_steadyVals[p] # DEBUG
 160
 161     #print params_steadyVals # DEBUG
 162
 163     bl_steadyStates = []
 164     for mi in range(len(overAll_breakMoments)-1):
 165
 166         # if the interval is sufficiently long
 167         if overAll_breakMoments[mi+1] - overAll_breakMoments[mi] >= STEADYPERIOD_MINLENGTH:
 168
 169             steady_params = {}
 170
 171             curr_timeInterval_rel = (overAll_breakMoments[mi], overAll_breakMoments[mi+1])
 172
 173             curr_timeInterval_abs = rel2abs([curr_timeInterval_rel], overAll_timeInterval_str[0])[0]
 174
 175             for p in params_breakMoments_vals.keys():
 176                 #print mi, ' ', params_steadyVals[p][mi]
 177                 steady_params[p.name] = params_steadyVals[p][mi]
 178
 179             bl_steadyStates.append( bl_steady(steady_params, curr_timeInterval_rel, curr_timeInterval_abs, monitor) )
 180             #print bl_steadyStates[-1] # debug
 181
 182     # and at last ---
 183     last_moment = str2sec(overAll_timeInterval_str[1]) - str2sec(overAll_timeInterval_str[0])
 184     if last_moment - overAll_breakMoments[-1] >= STEADYPERIOD_MINLENGTH:
 185
 186         steady_params = {}
 187
 188         last_timeInterval_rel = (overAll_breakMoments[-1], last_moment)
 189         last_timeInterval_abs = rel2abs([last_timeInterval_rel], overAll_timeInterval_str[0])[0]
 190
 191         for p in params_breakMoments_vals.keys():
 192             steady_params[p.name] = params_steadyVals[p][-1]
 193
 194         bl_steadyStates.append( bl_steady(steady_params, last_timeInterval_rel, last_timeInterval_abs, monitor) )
 195         #print bl_steadyStates[-1] # debug
 196     # ---
 197
 198     return bl_steadyStates
 199
 200
 201 ############################
 202 if __name__ == '__main__':
 203
 204
 205     if len(sys.argv) < 2:
 206         print "Correct use: " + sys.argv[0] + " date_str('Y-m-d')  [data_path]"
 207         sys.exit(0)
 208
 209     date_str = sys.argv[1]
 210     year, month, day  =  date_str.split('-')
 211
 212     data_path = bl_instance_path + os.sep + 'extracted_data'
 213     if len(sys.argv) == 3:
 214         data_path = sys.argv[2]
 215
 216     month_dir  = data_path + os.sep + year + os.sep + month
 217     archived_dates = os.listdir(month_dir)
 218     #print archived_dates  # debug
 219
 220
 221     if not day in archived_dates:
 222         print " No data for ", date_str
 223         sys.exit(0)
 224
 225     day_dir = month_dir + os.sep + day
 226     #os.chdir(day)
 227     data_files = os.listdir(day_dir)
 228
 229
 230     for elem in beam_path:
 231         if isinstance(elem, beam_monitor)and not isinstance(elem, extractable_beamMonitor):
 232         # until the first beam monitor
 233
 234             monitor = elem # just a notation for better readability
 235             #print '\nMonitor: ', monitor.nickname  # DEBUG
 236
 237             monitor.define_blSteadiness(beam_path)
 238
 239             params_data = {}             ###
 240             for param in monitor.beamAccess_params + monitor.blSteadiness_params:
 241                 #print param.name # DEBUG
 242
 243                 for f in data_files:
 244                     if param.name.replace('/', '.') in f:
 245                         param_datafile = f
 246                         break
 247                 # supposing there is only one datafile for each param
 248
 249                 #print param_datafile # DEBUG
 250
 251                 param_data  = (numpy.loadtxt( day_dir + os.sep + param_datafile, usecols=(0,1), unpack=True )) # as 2 colomns
 252                 param_data = param_data.transpose()
 253                 #print len(param_data)
 254
 255
 256                 overAll_timeInterval_str = paramdata_filename.filename2timeInterval(day_dir + os.sep + param_datafile)
 257                 #print overAll_timeInterval_str # DEBUG
 258
 259                 params_data[param] = param_data
 260
 261             bl_steadyStates = get_blSteadyStates(params_data, overAll_timeInterval_str)
 262
 263             print bl_steadyStates
 264
 265 ##            for s in bl_steadyStates:
 266 ##                #if s.matches_condition( 'mono1/energy', 12.65, 0.0005):
 267 ##                if s.matches_condition( 'tdl.1/frontEndStateValue', 5.):
 268 ##                    print s
 269
 270
 271             break # only until the first beam monitor