def createdictionary_timeinterval(dps, start_time, stop_time):
    values = getWinCCData(dps, start_time, stop_time)
    if values:
        dict_interval['interval'] = {"start":start_time}
        states = getWinCCData(dpStates, start_time, stop_time)
        if states:
            for states_row in states:
                dict_interval['interval'][states_row[2]] = states_row[1][:-7]
        print "Retrieving %d datapoints." % len(dps)
        for values_row in values:
            if not values_row[0] in dict_interval['interval']:
                #Initialize empty dictionaries and listst
                dict_interval['interval'][values_row[0]] = {}
                dict_interval['interval'][values_row[0]]['utc_time'] = []
                dict_interval['interval'][values_row[0]]['offset_time'] = []
                dict_interval['interval'][values_row[0]]['values'] = []
                
            #Store UTC time (to understand the one hour correction)
            utc_time = int(utc_mktime( (datetime.strptime(values_row[1][:-7], '%Y-%m-%d %H:%M:%S')).timetuple() ))
            dict_interval['interval'][values_row[0]]['utc_time'].append(utc_time)
            #Store time elapsed since beginning of run (in s)
            if 'PHYSICS' in dict_interval['interval']:
                init_time = int(utc_mktime( (datetime.strptime(dict_interval['interval']['physics'], '%Y-%m-%d %H:%M:%S')).timetuple() ))
                sb_time = (utc_time - init_time) / (60.0*60.0)
            else:
                init_time = int(utc_mktime( start_time.timetuple() ))
                sb_time = (utc_time - init_time) / (60.0)
            dict_interval['interval'][values_row[0]]['offset_time'].append(sb_time)
            #Store values at those times
            dict_interval['interval'][values_row[0]]['values'].append(values_row[2])

    return dict_interval
def createdictionary_singleRun(dps, runnumber, dict_run):
    #Create the key for that runnumber if not already there, if not, don't
    if str(runnumber) not in dict_run:
        print "Updating Run Numbers"
        #Get fillnumbers and states per fillnumber
        runnumbers = getWinCCData(dpRunNumbers, runI_start, runI_end)
        #Nested dictionaries for fill number
        if runnumbers:
            for row in runnumbers:
                str_key_curr = str(int(row[2]))
                if str_key_curr not in dict_run:
                    dict_run[str_key_curr] = {"start":row[1][:-7]}
    else:
        print "No need to update Run Numbers"
    
    #Fill up the values for that key 
    str_key_curr = str(runnumber)
    str_key_next = str(runnumber+1)
    if str_key_curr and str_key_next in dict_run:
        values = getWinCCData(dps, dict_run[str_key_curr]['start'], dict_run[str_key_next]['start'])
        if values:
            print "Retrieving %d datapoints" % len(dps)
            dict_json = {}
            utc_time_list = []
            run_time_list = []
            values_list = []
            prev_dp = values[0][0]
            for values_row in values:
                if prev_dp != values_row[0]:
                    #Write list in shelve if dp changes
                    dict_run[str_key_curr+'/'+prev_dp+'/utc_time'] = utc_time_list
                    dict_run[str_key_curr+'/'+prev_dp+'/offset_time'] = run_time_list
                    dict_run[str_key_curr+'/'+prev_dp+'/values'] = values_list
                    dict_run[str_key_curr+'/'+prev_dp+'/uncertainties'] = []
                    dict_run[str_key_curr+'/'+prev_dp+'/binning'] = []
                    dict_run[str_key_curr+'/'+prev_dp+'/axis_title'] = prev_dp
                    utc_time_list = []
                    run_time_list = []
                    values_list = []
                #Store UTC time (to understand the one hour correction)
                utc_time = int(utc_mktime( (datetime.strptime(values_row[1][:-7], '%Y-%m-%d %H:%M:%S')).timetuple() ))
                utc_time_list.append(utc_time)
                #Store time elapsed since beginning of run (in s)
                init_time = int(utc_mktime( (datetime.strptime(dict_run[str_key_curr]['start'], '%Y-%m-%d %H:%M:%S')).timetuple() ))
                run_time = (utc_time - init_time)/(60.0)
                run_time_list.append(run_time)
                #Store values at those times
                values_list.append(values_row[2])
                prev_dp = values_row[0]

            #Write last list in shelve
            dict_run[str_key_curr+'/'+prev_dp+'/utc_time'] = utc_time_list
            dict_run[str_key_curr+'/'+prev_dp+'/offset_time'] = run_time_list
            dict_run[str_key_curr+'/'+prev_dp+'/values'] = values_list
            dict_run[str_key_curr+'/'+prev_dp+'/uncertainties'] = []
            dict_run[str_key_curr+'/'+prev_dp+'/binning'] = []
            dict_run[str_key_curr+'/'+prev_dp+'/axis_title'] = prev_dp 
    else:
        print "For some reason, run numbers are not present in dictionary"

    return dict_run
def createdictionary_singleFill(dps, fillnumber):
    #Get fillnumbers and states per fillnumber
    fillnumbers = getWinCCData(dpFillNumbers, runI_start, runI_end)
    #Nested dictionaries for fill number
    if fillnumbers:
        for row in fillnumbers:
            dict_fill[int(row[2])] = {"start":row[1][:-7]}
            if int(row[2]) == fillnumber + 1:
                states = getWinCCData(dpStates, dict_fill[row[2]-1]['start'], dict_fill[row[2]]['start'])                
                if states:
                    for states_row in states:
                        dict_fill[row[2]-1][states_row[2]] = states_row[1][:-7]
                    #if states are present, get all values for that fill
                    values = getWinCCData(dps, dict_fill[row[2]-1]['start'], dict_fill[row[2]]['start'])
                    if values:
                        print "Retrieving %d datapoints." % len(dps)
                        for values_row in values:
                            if not values_row[0] in dict_fill[row[2]-1]: 
                            #Initialize empty dictionaries and list if not yet done for that dp
                                dict_fill[row[2]-1][values_row[0]] = {}
                                dict_fill[row[2]-1][values_row[0]]['utc_time'] = []
                                dict_fill[row[2]-1][values_row[0]]['offset_time'] = []
                                dict_fill[row[2]-1][values_row[0]]['values'] = []

                                #Different ways to generate times -- for the record
                                #print dates.date2num(datetime.strptime(values_row[1][:-7], '%Y-%m-%d %H:%M:%S')) -- Python generic time
                                #print int(utc_mktime( (datetime.strptime(values_row[1][:-7], '%Y-%m-%d %H:%M:%S')).timetuple() ))) -- UTC time
                                #local_dt = local.localize(((datetime.strptime(values_row[1][:-7], '%Y-%m-%d %H:%M:%S'))), is_dst = None)
                                #print local_dt.astimezone(pytz.utc) -- Local time

                            #Store UTC time
                            utc_time = int(utc_mktime( (datetime.strptime(values_row[1][:-7], '%Y-%m-%d %H:%M:%S')).timetuple() ))
                            dict_fill[row[2]-1][values_row[0]]['utc_time'].append(utc_time)
                            #Store time elapsed since STABLE BEAMS declaration (in s, positive if after SB, negative if before)
                            if 'PHYSICS' in  dict_fill[row[2]-1]:
                                init_time = int(utc_mktime( (datetime.strptime(dict_fill[row[2]-1]['physics'], '%Y-%m-%d %H:%M:%S')).timetuple() ))
                            else:
                                init_time = int(utc_mktime( (datetime.strptime(dict_fill[row[2]-1]['start'], '%Y-%m-%d %H:%M:%S')).timetuple() ))
                            sb_time = (utc_time - init_time) / (60.0*60.0)
                            dict_fill[row[2]-1][values_row[0]]['offset_time'].append(sb_time)
                            #Store value at that time
                            dict_fill[row[2]-1][values_row[0]]['values'].append(values_row[2])
                    
                    #Add list of RunNumber        
                    runnumbers = getWinCCData(dpRunNumbers, dict_fill[row[2]-1]['start'], dict_fill[row[2]]['start'])
                    
                    if runnumbers:
                        for runnumbers_row in runnumbers:
                            if not dpRunNumbers in dict_fill[row[2]-1]:
                                dict_fill[row[2]-1][dpRunNumbers] = {}
                                dict_fill[row[2]-1][dpRunNumbers]['utc_time'] = []
                                dict_fill[row[2]-1][dpRunNumbers]['offset_time'] = []
                                dict_fill[row[2]-1][dpRunNumbers]['values'] = []

                            #Store UTC time
                            utc_time = int(utc_mktime( (datetime.strptime(runnumbers_row[1][:-7], '%Y-%m-%d %H:%M:%S')).timetuple() ))
                            dict_fill[row[2]-1][dpRunNumbers]['utc_time'].append(utc_time)
                            #Store time elapsed since STABLE BEAMS declaration (in s)
                            if 'PHYSICS' in  dict_fill[row[2]-1]:
                                init_time = int(utc_mktime( (datetime.strptime(dict_fill[row[2]-1]['physics'], '%Y-%m-%d %H:%M:%S')).timetuple() ))
                                sb_time = (utc_time - init_time) / (60.0*60.0)
                            else:
                                init_time = int(utc_mktime( (datetime.strptime(dict_fill[row[2]-1]['start'], '%Y-%m-%d %H:%M:%S')).timetuple() ))
                                sb_time = (utc_time - init_time) / (60.0)
                            dict_fill[row[2]-1][dpRunNumbers]['offset_time'].append(sb_time)
                            #Store values at those times
                            dict_fill[row[2]-1][dpRunNumbers]['values'].append(runnumbers_row[2])

    #After massage, change fill numbers key from int(s) to str for usage in shelve
    for k in dict_fill.keys():
        dict_fill[str(k)] = dict_fill.pop(k)
    return dict_fill
def createdictionary_timeinterval(dps, start_time, stop_time, dict_interval):
    if 'interval' not in dict_interval.keys():
        dict_interval['interval'] = {}

    fillnumbers = getWinCCData(dpFillNumbers, start_time, stop_time)
    if fillnumbers:
        print 'Updating Fill Numbers'
        for row in fillnumbers:
            str_key_curr = row[2]
            dict_interval['interval'][(str_key_curr, start_time, stop_time)] = row[1][:-7]
    else:
        print 'No Fill Numbers updated in time interval'

    states = getWinCCData(dpStates, start_time, stop_time)
    if states:
        print 'Updating LHC states'
        for states_row in states:
            dict_interval['interval'][(states_row[2].lower(), start_time, stop_time)] = states_row[1][:-7]
    else:
        print 'No LHC states updated in time interval'

    values = getWinCCData(dps, start_time, stop_time)
    if values:
        print 'Retrieving %d datapoints' % len(dps)
        dict_json = {}
        utc_time_list = []
        run_time_list = []
        values_list = []
        prev_dp = values[0][0]
        for values_row in values:
            if prev_dp != values_row[0]:
                #Write list in shelve if dp changes
                dict_interval['interval'][(prev_dp, start_time, stop_time,'utc_time')] = utc_time_list
                dict_interval['interval'][(prev_dp, start_time, stop_time,'offset_time')] = run_time_list
                dict_interval['interval'][(prev_dp, start_time, stop_time,'values')] = values_list
                dict_interval['interval'][(prev_dp, start_time, stop_time,'uncertainties')] = ['','']
                dict_interval['interval'][(prev_dp, start_time, stop_time,'binning')] = ['','']
                splittitle = prev_dp.split('.')
                title = splittitle[len(splittitle)-2] + '/' + splittitle[len(splittitle)-1]
                dict_interval['interval'][(prev_dp, start_time, stop_time,'axis_title')] = [title,'']
                #Reset lists
                utc_time_list = []
                run_time_list = []
                values_list = []
            #Store UTC time (to understand the one hour correction)
            utc_time = int(mktimeUTC( (datetime.strptime(values_row[1][:-7], '%Y-%m-%d %H:%M:%S')).timetuple() ))
            utc_time_list.append(utc_time)
            #Store time elapsed since beginning of run (in s)
            if (start_time, stop_time, 'physics') in  dict_interval['interval'].keys():
                init_time = int(mktimeUTC( (datetime.strptime(dict_interval['interval'][(start_time, stop_time, 'physics')], '%Y-%m-%d %H:%M:%S')).timetuple() ))
                sb_time = (utc_time - init_time) / (60.0*60.0)
            else:
                init_time = start_time
                sb_time = (utc_time - init_time) / (60.0)
            run_time_list.append(sb_time)
            #Store values at those times
            values_list.append(values_row[2])
            prev_dp = values_row[0]
                
        #Write last list in shelve 
        dict_interval['interval'][(prev_dp, start_time, stop_time,'utc_time')] = utc_time_list
        dict_interval['interval'][(prev_dp, start_time, stop_time,'offset_time')] = run_time_list
        dict_interval['interval'][(prev_dp, start_time, stop_time,'values')] = values_list
        dict_interval['interval'][(prev_dp, start_time, stop_time,'uncertainties')] = ['','']
        dict_interval['interval'][(prev_dp, start_time, stop_time,'binning')] = ['','']
        splittitle = prev_dp.split('.')
        title = splittitle[len(splittitle)-2] + '/' + splittitle[len(splittitle)-1]
        dict_interval['interval'][(prev_dp, start_time, stop_time,'axis_title')] = [title,'']
        #Reset lists
        utc_time_list = []
        run_time_list = []
        values_list = []
        
 
    runnumbers = getWinCCData(dpRunNumbers, start_time, stop_time)
    prev_dp = dpRunNumbers[0]
    if runnumbers:
        print 'Updating Run Numbers'
        for values_row in runnumbers:
            #Store UTC time (to understand the one hour correction)
            utc_time = int(mktimeUTC( (datetime.strptime(values_row[1][:-7], '%Y-%m-%d %H:%M:%S')).timetuple() ))
            utc_time_list.append(utc_time)
            #Store time elapsed since beginning of run (in s)
            if (start_time, stop_time, 'physics') in  dict_interval['interval'].keys():
                init_time = int(mktimeUTC( (datetime.strptime(dict_interval['interval'][(start_time, stop_time, 'physics')], '%Y-%m-%d %H:%M:%S')).timetuple() ))
                sb_time = (utc_time - init_time) / (60.0*60.0)
            else:
                init_time = start_time
                sb_time = (utc_time - init_time) / (60.0)
            run_time_list.append(sb_time)

            #Store values at those times
            values_list.append(values_row[2])

        #Write last list in shelve 
        dict_interval['interval'][(prev_dp, start_time, stop_time,'utc_time')] = utc_time_list
        dict_interval['interval'][(prev_dp, start_time, stop_time,'offset_time')] = run_time_list
        dict_interval['interval'][(prev_dp, start_time, stop_time,'values')] = values_list
        dict_interval['interval'][(prev_dp, start_time, stop_time,'uncertainties')] = ['','']
        dict_interval['interval'][(prev_dp, start_time, stop_time,'binning')] = ['','']
        splittitle = prev_dp.split('.')
        title = splittitle[len(splittitle)-2] + '/' + splittitle[len(splittitle)-1]
        dict_interval['interval'][(prev_dp, start_time, stop_time,'axis_title')] = [title,'']
        #Reset lists
        utc_time_list = []
        run_time_list = []
        values_list = []    
    else:
        print 'No Run Numbers updated in time interval'

    return dict_interval
def createdictionary_singleFill(dps, fillnumber, dict_fill):
    #Create the key for that runnumber if not already there, if not, don't
    if str(fillnumber) not in dict_fill:
        print 'Updating Fill Numbers'
        #Get fillnumbers and states per fillnumber
        fillnumbers = getWinCCData(dpFillNumbers, runI_start, runI_end)
        #Nested dictionaries for fill number
        if fillnumbers:
            for row in fillnumbers:
                str_key_curr = row[2]
                if str_key_curr not in dict_fill:
                    dict_fill[str_key_curr] = {'start':row[1][:-7]}
    else:
        print 'No need to update Fill Numbers'

    #Fill up the values for that key 
    str_key_curr = str(fillnumber)
    str_key_next = str(fillnumber+1)
    
    if str_key_curr and str_key_next in dict_fill:
        states = getWinCCData(dpStates, dict_fill[str_key_curr]['start'], dict_fill[str_key_next]['start'])                
        if states:
            print 'Updating LHC states'
            for states_row in states:
                dict_fill[str_key_curr][states_row[2].lower()] = states_row[1][:-7]

    #if states are present, get all values for that fill
    values = getWinCCData(dps, dict_fill[str_key_curr]['start'], dict_fill[str_key_next]['start'])
    if values:
        print 'Retrieving %d datapoints' % len(dps)
        dict_json = {}
        utc_time_list = []
        run_time_list = []
        values_list = []
        prev_dp = values[0][0]
        for values_row in values:
            if prev_dp != values_row[0]:
                #Write list in shelve if dp changes
                dict_fill[str_key_curr][(prev_dp,'utc_time')] = utc_time_list
                dict_fill[str_key_curr][(prev_dp,'offset_time')] = run_time_list
                dict_fill[str_key_curr][(prev_dp,'values')] = values_list
                dict_fill[str_key_curr][(prev_dp,'uncertainties')] = ['','']
                dict_fill[str_key_curr][(prev_dp,'binning')] = ['','']
                splittitle = prev_dp.split('.')
                title = splittitle[len(splittitle)-2] + '/' + splittitle[len(splittitle)-1]
                dict_fill[str_key_curr][(prev_dp,'axis_title')] = [title,'']
                #Reset lists
                utc_time_list = []
                run_time_list = []
                values_list = []
            #Store UTC time (to understand the one hour correction)
            utc_time = int(mktimeUTC( (datetime.strptime(values_row[1][:-7], '%Y-%m-%d %H:%M:%S')).timetuple() ))
            utc_time_list.append(utc_time)
            #Store time elapsed since beginning of run (in s)
            if 'physics' in  dict_fill[str_key_curr].keys():
                init_time = int(mktimeUTC( (datetime.strptime(dict_fill[str_key_curr]['physics'], '%Y-%m-%d %H:%M:%S')).timetuple() ))
                sb_time = (utc_time - init_time) / (60.0*60.0)
            else:
                init_time = int(mktimeUTC( (datetime.strptime(dict_fill[str_key_curr]['start'], '%Y-%m-%d %H:%M:%S')).timetuple() ))
                sb_time = (utc_time - init_time) / (60.0)
            run_time_list.append(sb_time)
            #Store values at those times
            values_list.append(values_row[2])
            prev_dp = values_row[0]
                
        #Write last list in shelve 
        dict_fill[str_key_curr][(prev_dp,'utc_time')] = utc_time_list
        dict_fill[str_key_curr][(prev_dp,'offset_time')] = run_time_list
        dict_fill[str_key_curr][(prev_dp,'values')] = values_list
        dict_fill[str_key_curr][(prev_dp,'uncertainties')] = ['','']
        dict_fill[str_key_curr][(prev_dp,'binning')] = ['','']
        splittitle = prev_dp.split('.')
        title = splittitle[len(splittitle)-2] + '/' + splittitle[len(splittitle)-1]
        dict_fill[str_key_curr][(prev_dp,'axis_title')] = [title,'']
        #Reset lists
        utc_time_list = []
        run_time_list = []
        values_list = []
 
    #Add list of RunNumber        
    runnumbers = getWinCCData(dpRunNumbers, dict_fill[str_key_curr]['start'], dict_fill[str_key_next]['start'])  
    prev_dp = dpRunNumbers[0]
    if runnumbers:
        print 'Adding list of Run Numbers'
        for values_row in runnumbers:
            #Store UTC time (to understand the one hour correction)
            utc_time = int(mktimeUTC( (datetime.strptime(values_row[1][:-7], '%Y-%m-%d %H:%M:%S')).timetuple() ))
            utc_time_list.append(utc_time)
            #Store time elapsed since beginning of run (in s)
            if 'physics' in  dict_fill[str_key_curr].keys():
                init_time = int(mktimeUTC( (datetime.strptime(dict_fill[str_key_curr]['physics'], '%Y-%m-%d %H:%M:%S')).timetuple() ))
                sb_time = (utc_time - init_time) / (60.0*60.0)
            else:
                init_time = int(mktimeUTC( (datetime.strptime(dict_fill[str_key_curr]['start'], '%Y-%m-%d %H:%M:%S')).timetuple() ))
                sb_time = (utc_time - init_time) / (60.0)
            run_time_list.append(sb_time)
                
            #Store values at those times
            values_list.append(values_row[2])

        #Write last list in shelve 
        dict_fill[str_key_curr][(prev_dp,'utc_time')] = utc_time_list
        dict_fill[str_key_curr][(prev_dp,'offset_time')] = run_time_list
        dict_fill[str_key_curr][(prev_dp,'values')] = values_list
        dict_fill[str_key_curr][(prev_dp,'uncertainties')] = ['','']
        dict_fill[str_key_curr][(prev_dp,'binning')] = ['','']
        splittitle = prev_dp.split('.')
        title = splittitle[len(splittitle)-2] + '/' + splittitle[len(splittitle)-1]
        dict_fill[str_key_curr][(prev_dp,'axis_title')] = [title,'']
        #Reset lists
        utc_time_list = []
        run_time_list = []
        values_list = []
    else:
        print 'For some reason, Fill Numbers are not present in dictionary'

    return dict_fill
Beispiel #6
0
#!/usr/bin/python

from oracle_wincc import getWinCCData
from datetime import datetime

dpPatterns = ['%OTDCSGASMON:Input_gas.Fit_spectra%', '%VTCS_PA_%', 'doesnotexist', '%HRCMATN01%Channel2%']
#dpPatterns = 'somedp'
ti = datetime(2015,03,23,17)
tf = '2015-03-23 17:15:00'
data = getWinCCData(dpPatterns, ti, tf)
if data:
    for row in data:
        print row