def find_maintenance(filename): aux_file = File(filename, 'read') aux_tree = aux_file.get('t_hk_obox') maintenance_start = False maintenance_list = [] gps_time_list = [] ship_time_list = [] for entry in aux_tree: if entry.obox_is_bad > 0: continue if entry.obox_mode.encode('hex') == '04': if not maintenance_start: maintenance_start = True gps_time_list.append(entry.abs_gps_week * 604800 + entry.abs_gps_second) ship_time_list.append(entry.abs_ship_second) else: if maintenance_start: maintenance_start = False maintenance_list.append( ((ship_time_list[0] + ship_time_list[-1]) / 2, (gps_time_list[0] + gps_time_list[-1]) / 2)) gps_time_list = [] ship_time_list = [] return [(int(x[0]), "%d:%d" % (int(x[1] / 604800), int(x[1] % 604800))) for x in maintenance_list]
def read_timespan(filename): t_file = File(filename, 'read') m = ref_time.match(t_file.get('m_utc_span').GetTitle()) week1, second1, week2, second2 = int(m.group(1)), int(m.group(2)), int( m.group(3)), int(m.group(4)) t_file.close() return (week1 * 604800 + second1, week2 * 604800 + second2)
def find_orbitstart(filename): LAT_LEN = 500 lat_deque = deque() orbitstart_list = [] ppd_file = File(filename, 'read') ppd_tree = ppd_file.get('t_ppd') ready_flag = True pre_diff = 0.0 cur_diff = 0.0 for entry in ppd_tree: if entry.flag_of_pos != 0x55: continue lat_deque.append( (entry.latitude, entry.ship_time_sec, entry.utc_time_sec)) if len(lat_deque) < LAT_LEN: pre_diff = lat_deque[-1][0] - lat_deque[0][0] continue else: lat_deque.popleft() cur_diff = lat_deque[-1][0] - lat_deque[0][0] if ready_flag and pre_diff < 0 and cur_diff >= 0: orbitstart_list.append(((lat_deque[-1][1] + lat_deque[0][1]) / 2, (lat_deque[-1][2] + lat_deque[0][2]) / 2)) ready_flag = False if not ready_flag and pre_diff > 0 and cur_diff <= 0: ready_flag = True pre_diff = cur_diff return [(int(x[0]), "%d:%d" % (int(x[1] / 604800), int(x[1] % 604800))) for x in orbitstart_list]
def read_timespan(filename, dat_type): t_file = File(filename, 'read') m = ref_time.match(t_file.get(tnamed_dict[dat_type]).GetTitle()) week1, second1, week2, second2 = int(m.group(1)), int(m.group(2)), int( m.group(3)), int(m.group(4)) t_file.close() time_seconds_begin = week1 * 604800 + second1 time_seconds_end = week2 * 604800 + second2 beijing_time_begin = datetime(1980, 1, 6, 0, 0, 0) + timedelta( seconds=time_seconds_begin - leap_seconds_dict[dat_type] + 28800) beijing_time_end = datetime(1980, 1, 6, 0, 0, 0) + timedelta( seconds=time_seconds_end - leap_seconds_dict[dat_type] + 28800) return (beijing_time_begin, beijing_time_end)
def sci_1p_read_timespan(filename): t_file = File(filename, 'read') m_pedship = t_file.get('m_pedship') t_file.close() return m_pedship.GetTitle()
print 'Usage: ' + basename( sys.argv[0]) + ' <rate_file.root> <time_win.root>' exit(1) t_file_out = File(sys.argv[2], 'recreate') begin_time_mat = Matrix(25, 64) end_time_mat = Matrix(25, 64) max_count_mat = Matrix(25, 64) max_time_mat = Matrix(25, 64) max_index_mat = [x[:] for x in [[0] * 64] * 25] t_file_in = File(sys.argv[1], 'read') t_rate = [None] * 25 for idx in xrange(25): t_rate[idx] = t_file_in.get('t_rate_ct_%02d' % (idx + 1)) t_rate[idx].create_buffer() # =============================== max_count_mat.Zero() for idx in xrange(25): print 'Processing CT_' + str(idx + 1) + ' ...' for it, entry in enumerate(t_rate[idx]): for j in xrange(64): if entry.cnts_ps[j] > max_count_mat[idx][j]: max_count_mat[idx][j] = entry.cnts_ps[j] max_time_mat[idx][j] = entry.time_sec max_index_mat[idx][j] = it for idx in xrange(25):
from dateutil.tz import tzlocal from tqdm import tqdm parser = argparse.ArgumentParser( description='Convert platform parameters data to Level 1') parser.add_argument( "filename", help="ROOT file that stores decoded platform parameters data") parser.add_argument( "-o", dest="outfile", help="ROOT file to store platform parameters data of Level 1", default="TG2_PPD_file_L1.root") args = parser.parse_args() t_file_in = File(args.filename, 'read') t_tree_ppd_in = t_file_in.get('t_ppd') t_tree_ppd_in.create_buffer() m_shipspan = t_file_in.get('m_shipspan') m_utc_span = t_file_in.get('m_utc_span') t_file_out = File(args.outfile, 'recreate') t_tree_ppd_out = Tree("t_ppd", "platform parameters data") t_tree_ppd_out.create_branches({ "longitude": "D", "latitude": "D", "geocentric_d": "D", "ship_time_sec": "D", "utc_time_sec": "D", "utc_time_str": "C[32]", "flag_of_pos": "I", "det_z_ra": "D",
class ppd_file_r: def __init__(self): self.t_file_name = '' self.t_file_in = None self.t_tree_ppd = None self.begin_entry = 0 self.end_entry = 0 self.utc_time_span = '' self.first_utc_time_sec = 0.0 self.last_utc_time_sec = 0.0 self.begin_utc_time_sec = 0.0 self.end_utc_time_sec = 0.0 def __find_entry(self, utc_time_sec): head_entry = -1 head_entry_found = False while head_entry < self.t_tree_ppd.get_entries(): head_entry += 1 self.t_tree_ppd.get_entry(head_entry) if self.t_tree_ppd.flag_of_pos == 0x55 and self.t_tree_ppd.utc_time_sec > 0: head_entry_found = True break if not head_entry_found: return -1 if utc_time_sec < self.t_tree_ppd.utc_time_sec: return -1 tail_entry = self.t_tree_ppd.get_entries() tail_entry_found = False while tail_entry >= 0: tail_entry -= 1 self.t_tree_ppd.get_entry(tail_entry) if self.t_tree_ppd.flag_of_pos == 0x55 and self.t_tree_ppd.utc_time_sec > 0: tail_entry_found = True break if not tail_entry_found: return -1 if utc_time_sec > self.t_tree_ppd.utc_time_sec: return -1 while tail_entry - head_entry > 1: center_entry = int((head_entry + tail_entry) / 2) found_valid_center = False self.t_tree_ppd.get_entry(center_entry) if self.t_tree_ppd.flag_of_pos == 0x55 and self.t_tree_ppd.utc_time_sec > 0: found_valid_center = True tmp_center_entry = center_entry while not found_valid_center and tail_entry - tmp_center_entry > 1: tmp_center_entry += 1 self.t_tree_ppd.get_entry(tmp_center_entry) if self.t_tree_ppd.flag_of_pos == 0x55 and self.t_tree_ppd.utc_time_sec > 0: found_valid_center = True if not found_valid_center: tmp_center_entry = center_entry while not found_valid_center and tmp_center_entry - head_entry > 1: tmp_center_entry -= 1 self.t_tree_ppd.get_entry(tmp_center_entry) if self.t_tree_ppd.flag_of_pos == 0x55 and self.t_tree_ppd.utc_time_sec > 0: found_valid_center = True if not found_valid_center: break if utc_time_sec == self.t_tree_ppd.utc_time_sec: return tmp_center_entry elif utc_time_sec > self.t_tree_ppd.utc_time_sec: head_entry = tmp_center_entry else: tail_entry = tmp_center_entry return tail_entry def open_file(self, filename, begin, end): # cut data by utc time, utc_week:utc_second self.t_file_name = basename(filename) self.t_file_in = File(filename, 'read') self.t_tree_ppd = self.t_file_in.get('t_ppd') self.t_tree_ppd.create_buffer() self.utc_time_span = self.t_file_in.get('m_utc_span').GetTitle() m = re.compile( r'(\d+):(\d+)\[\d+\] => (\d+):(\d+)\[\d+\]; \d+/\d+').match( self.utc_time_span) self.first_utc_time_sec = float(m.group(1)) * 604800 + float( m.group(2)) self.last_utc_time_sec = float(m.group(3)) * 604800 + float(m.group(4)) if begin != 'begin': m = re.compile(r'(\d+):(\d+)').match(begin) self.begin_utc_time_sec = float(m.group(1)) * 604800 + float( m.group(2)) if self.begin_utc_time_sec - self.first_utc_time_sec < _MIN_DIFF: print 'WARNING: begin utc time is out of range: ' + str( self.begin_utc_time_sec - self.first_utc_time_sec) return False else: self.begin_utc_time_sec = -1 if end != 'end': m = re.compile(r'(\d+):(\d+)').match(end) self.end_utc_time_sec = float(m.group(1)) * 604800 + float( m.group(2)) if self.last_utc_time_sec - self.end_utc_time_sec < _MIN_DIFF: print 'WARNING: end utc time is out of range: ' + str( self.last_utc_time_sec - self.end_utc_time_sec) return False else: self.end_utc_time_sec = -1 if self.begin_utc_time_sec > 0 and self.end_utc_time_sec > 0 and self.end_utc_time_sec - self.begin_utc_time_sec < _MIN_DIFF: print 'WARNING: time span between begin and end utc time is too small: ' + str( self.end_utc_time_sec - self.begin_utc_time_sec) return False if self.begin_utc_time_sec > 0: self.begin_entry = self.__find_entry(self.begin_utc_time_sec) if self.begin_entry < 0: print "WARNING: cannot find begin entry." return False else: self.begin_entry = 0 if self.end_utc_time_sec > 0: self.end_entry = self.__find_entry(self.end_utc_time_sec) if self.end_entry < 0: print "WARNING: cannot find end entry." return False else: self.end_entry = self.t_tree_ppd.get_entries() return True def print_file_info(self): actual_start_entry = 0 for idx in xrange(self.begin_entry, self.end_entry): actual_start_entry = idx self.t_tree_ppd.get_entry(idx) if self.t_tree_ppd.flag_of_pos == 0x55 and self.t_tree_ppd.utc_time_sec > 0: break actual_begin_utc_time_sec = self.t_tree_ppd.utc_time_sec actual_end_entry = 0 for idx in xrange(self.end_entry - 1, self.begin_entry - 1, -1): actual_end_entry = idx self.t_tree_ppd.get_entry(idx) if self.t_tree_ppd.flag_of_pos == 0x55 and self.t_tree_ppd.utc_time_sec > 0: break actual_end_utc_time_sec = self.t_tree_ppd.utc_time_sec utc_time_span_str = '%d:%d[%d] => %d:%d[%d]' % ( int(actual_begin_utc_time_sec / 604800), int(actual_begin_utc_time_sec % 604800), actual_start_entry, int(actual_end_utc_time_sec / 604800), int(actual_end_utc_time_sec % 604800), actual_end_entry) print self.t_file_name print ' - UTC time span: { ' + utc_time_span_str + ' }' def close_file(self): self.t_file_in.close() self.t_file_in = None self.t_tree_ppd = None
import sys from os.path import basename from rootpy.io import File from rootpy.tree import Tree from rootpy.matrix import Matrix if len(sys.argv) < 4: print "USAGE: " + basename(sys.argv[0]) + " <time_win_mat.root> <decoded_file.root> <merged_file.root>" exit(1) time_win_filename = sys.argv[1] decoded_data_filename = sys.argv[2] merged_filename = sys.argv[3] t_file_time_win = File(time_win_filename, "read") begin_time_mat = t_file_time_win.get("begin_time_mat") end_time_mat = t_file_time_win.get("end_time_mat") max_count_mat = t_file_time_win.get("max_count_mat") t_file_time_win.close() t_file_merged_out = File(merged_filename, "recreate") t_beam_event_tree = Tree("t_beam_event", "Beam Event Data") t_beam_event_tree.create_branches({ 'type': 'I', 'trig_accepted': 'B[25]', 'time_aligned': 'B[25]', 'pkt_count': 'I', 'lost_count': 'I', 'trigger_bit': 'B[1600]', 'trigger_n': 'I', 'multiplicity': 'I[25]',
def aux_1m_read_timespan(filename): t_file = File(filename, 'read') m_ibox_gps = t_file.get('m_ibox_gps') t_file.close() return m_ibox_gps.GetTitle()
def sci_1m_read_timespan(filename): t_file = File(filename, 'read') m_ped_gps_frm = t_file.get('m_ped_gps_frm') t_file.close() return m_ped_gps_frm.GetTitle()
class sci_trigger_r: def __init__(self): self.t_file_name = '' self.t_file_in = None self.t_trigger = None self.m_phy_gps = '' self.begin_entry = 0 self.end_entry = 0 self.first_gps_time_sec = 0.0 self.last_gps_time_sec = 0.0 self.begin_gps_time_sec = 0.0 self.end_gps_time_sec = 0.0 self.start_week = 0 self.start_second = 0.0 self.stop_week = 0 self.stop_second = 0.0 self.gps_time_length = 0.0 def __find_entry(self, gps_time_sec): head_entry = -1 head_entry_found = False while head_entry < self.t_trigger.get_entries(): head_entry += 1 self.t_trigger.get_entry(head_entry) if self.t_trigger.abs_gps_valid: head_entry_found = True break if not head_entry_found: return -1 if gps_time_sec < self.t_trigger.abs_gps_week * 604800 + self.t_trigger.abs_gps_second: return -1 tail_entry = self.t_trigger.get_entries() tail_entry_found = False while tail_entry >= 0: tail_entry -= 1 self.t_trigger.get_entry(tail_entry) if self.t_trigger.abs_gps_valid: tail_entry_found = True break if not tail_entry_found: return -1 if gps_time_sec > self.t_trigger.abs_gps_week * 604800 + self.t_trigger.abs_gps_second: return -1 while tail_entry - head_entry > 1: center_entry = int((head_entry + tail_entry) / 2) found_valid_center = False self.t_trigger.get_entry(center_entry) if self.t_trigger.abs_gps_valid: found_valid_center = True tmp_center_entry = center_entry while not found_valid_center and tail_entry - tmp_center_entry > 1: tmp_center_entry += 1 self.t_trigger.get_entry(tmp_center_entry) if self.t_trigger.abs_gps_valid: found_valid_center = True if not found_valid_center: tmp_center_entry = center_entry while not found_valid_center and tmp_center_entry - head_entry > 1: tmp_center_entry -= 1 self.t_trigger.get_entry(tmp_center_entry) if self.t_trigger.abs_gps_valid: found_valid_center = True if not found_valid_center: break if gps_time_sec == self.t_trigger.abs_gps_week * 604800 + self.t_trigger.abs_gps_second: return tmp_center_entry elif gps_time_sec > self.t_trigger.abs_gps_week * 604800 + self.t_trigger.abs_gps_second: head_entry = tmp_center_entry else: tail_entry = tmp_center_entry return tail_entry def open_file(self, filename, begin, end): self.t_file_name = basename(filename) self.t_file_in = File(filename, 'read') self.t_trigger = self.t_file_in.get('t_trigger') self.t_trigger.activate([ 'abs_gps_week', 'abs_gps_second', 'abs_gps_valid', 'trig_accepted' ], True) self.t_trigger.create_buffer() self.m_phy_gps = self.t_file_in.get('m_phy_gps').GetTitle() m = re.compile( r'(\d+):(\d+)\[\d+\] => (\d+):(\d+)\[\d+\]; \d+/\d+').match( self.m_phy_gps) self.first_gps_time_sec = float(m.group(1)) * 604800 + float( m.group(2)) self.last_gps_time_sec = float(m.group(3)) * 604800 + float(m.group(4)) if begin != 'begin': m = re.compile(r'(\d+):(\d+)').match(begin) self.begin_gps_time_sec = float(m.group(1)) * 604800 + float( m.group(2)) if self.begin_gps_time_sec - self.first_gps_time_sec < _MIN_DIFF: print 'WARNING: begin gps time is out of range: ' + str( self.begin_gps_time_sec - self.first_gps_time_sec) return False else: self.begin_gps_time_sec = -1 if end != 'end': m = re.compile(r'(\d+):(\d+)').match(end) self.end_gps_time_sec = float(m.group(1)) * 604800 + float( m.group(2)) if self.last_gps_time_sec - self.end_gps_time_sec < _MIN_DIFF: print 'WARNING: end gps time is out of range: ' + str( self.last_gps_time_sec - self.end_gps_time_sec) return False else: self.end_gps_time_sec = -1 if self.begin_gps_time_sec > 0 and self.end_gps_time_sec > 0 and self.end_gps_time_sec - self.begin_gps_time_sec < _MIN_DIFF: print 'WARNING: time span between begin and end gps time is too small: ' + str( self.end_gps_time_sec - self.begin_gps_time_sec) return False if self.begin_gps_time_sec > 0: self.begin_entry = self.__find_entry(self.begin_gps_time_sec) if self.begin_entry < 0: print "WARNING: cannot find begin entry." return False else: self.begin_entry = 0 if self.end_gps_time_sec > 0: self.end_entry = self.__find_entry(self.end_gps_time_sec) if self.end_entry < 0: print "WARNING: cannot find end entry." return False else: self.end_entry = self.t_trigger.get_entries() for idx in xrange(self.begin_entry, self.end_entry): self.t_trigger.get_entry(idx) if self.t_trigger.abs_gps_valid: self.start_week = self.t_trigger.abs_gps_week self.start_second = self.t_trigger.abs_gps_second break for idx in xrange(self.end_entry - 1, self.begin_entry - 1, -1): self.t_trigger.get_entry(idx) if self.t_trigger.abs_gps_valid: self.stop_week = self.t_trigger.abs_gps_week self.stop_second = self.t_trigger.abs_gps_second break self.gps_time_length = (self.stop_week - self.start_week) * 604800 + ( self.stop_second - self.start_second) return True def print_file_info(self): actual_start_entry = 0 for idx in xrange(self.begin_entry, self.end_entry): actual_start_entry = idx self.t_trigger.get_entry(idx) if self.t_trigger.abs_gps_valid: break actual_begin_gps_week = self.t_trigger.abs_gps_week actual_begin_gps_second = self.t_trigger.abs_gps_second actual_end_entry = 0 for idx in xrange(self.end_entry - 1, self.begin_entry - 1, -1): actual_end_entry = idx self.t_trigger.get_entry(idx) if self.t_trigger.abs_gps_valid: break actual_end_gps_week = self.t_trigger.abs_gps_week actual_end_gps_second = self.t_trigger.abs_gps_second gps_time_span_str = '%d:%d[%d] => %d:%d[%d]' % ( int(actual_begin_gps_week), int(actual_begin_gps_second), actual_start_entry, int(actual_end_gps_week), int(actual_end_gps_second), actual_end_entry) print self.t_file_name print ' - GPS time span: { ' + gps_time_span_str + ' }' def close_file(self): self.t_file_in.close() self.t_file_in = None self.t_trigger = None
from rootpy.tree import Tree from rootpy.matrix import Matrix from tqdm import tqdm if len(sys.argv) < 4: print "USAGE: " + basename( sys.argv[0] ) + " <time_win_mat.root> <decoded_file.root> <merged_file.root>" exit(1) time_win_filename = sys.argv[1] decoded_data_filename = sys.argv[2] merged_filename = sys.argv[3] t_file_time_win = File(time_win_filename, "read") begin_time_mat = t_file_time_win.get("begin_time_mat") end_time_mat = t_file_time_win.get("end_time_mat") max_count_mat = t_file_time_win.get("max_count_mat") t_file_time_win.close() t_file_decoded_data = File(decoded_data_filename, "read") t_trigger = t_file_decoded_data.get("t_trigger") t_trigger.deactivate(['status_bit', 'trig_sig_con_bit'], True) t_trigger.create_buffer() t_modules = t_file_decoded_data.get("t_modules") t_modules.deactivate(['status_bit'], True) t_modules.create_buffer() t_file_merged_out = File(merged_filename, "recreate") t_beam_event = Tree("t_beam_event", "Beam Event Data") t_beam_event.create_branches({
import sys from rootpy import ROOT from rootpy.io import File from rootpy.tree import Tree from collections import deque from time_conv import gps_to_beijing if len(sys.argv) < 2: print "USAGE: " + sys.argv[0] + " <ppd_file.root>" exit(2) filename = sys.argv[1] print "list of maintenance (Beijing Time): " aux_file = File(filename, 'read') aux_tree = aux_file.get('t_hk_obox') maintenance_start = False gps_time_list = [] for entry in aux_tree: if entry.obox_is_bad > 0: continue if entry.obox_mode.encode('hex') == '04': if not maintenance_start: maintenance_start = True gps_time_list.append(entry.abs_gps_week * 604800 + entry.abs_gps_second) else: if maintenance_start: maintenance_start = False maintenance_gps = (gps_time_list[0] + gps_time_list[-1]) / 2 week_second = "%d:%d" % (maintenance_gps / 604800, maintenance_gps % 604800)
from rootpy.io import File from rootpy.tree import Tree if len(sys.argv) < 3: print 'Usage: ' + basename(sys.argv[0]) + ' <decoded_data.root> <rate_file.root>' exit(1) t_file_out = File(sys.argv[2], 'recreate') t_rate = [] for idx in xrange(25): tree = Tree('t_rate_ct_%02d' % (idx + 1), 'rate of module CT_%02d' % (idx + 1)) tree.create_branches({'time_sec': 'D', 'cnts_ps': 'F[64]'}) t_rate.append(tree) t_file_in = File(sys.argv[1], 'read') t_modules = t_file_in.get('t_modules') t_modules.activate(['is_bad', 'ct_num', 'trigger_bit', 'time_second'], True) #t_modules.create_buffer() #### read and fill data ##### counts = [] for idx in xrange(25): counts.append([0] * 64) first_flag = [True] * 25 pre_time = [0] * 25 for i,entry in enumerate(t_modules): if i % 10000 == 0: print i if entry.is_bad > 0: continue
def aux_1m_read_timespan(filename): t_file = File(filename, 'read') m_oboxship = t_file.get('m_oboxship') t_file.close() return m_oboxship.GetTitle()
def ppd_1n_read_timespan(filename): t_file = File(filename, 'read') m_shipspan = t_file.get('m_shipspan') t_file.close() return m_shipspan.GetTitle()
from rootpy.io import File from rootpy.tree import Tree from rootpy.plotting import Hist2D from rootpy.interactive import wait from cooconv import ijtox, ijtoy if len(sys.argv) < 2: print "USAGE: show_adc_per_kev.py <adc_per_kev.root>" exit(1) adc_per_kev_fn = sys.argv[1] adc_per_kev_file = File(adc_per_kev_fn, 'read') adc_per_kev = [None for i in xrange(25)] adc_sigma = [None for i in xrange(25)] for i in xrange(25): adc_per_kev[i] = adc_per_kev_file.get("adc_per_kev_vec_ct_%02d" % (i + 1)) adc_sigma[i] = adc_per_kev_file.get("adc_sigma_vec_ct_%02d" % (i + 1)) adc_per_kev_file.close() hist2d_adc_per_kev = Hist2D(40, 0, 40, 40, 0, 40) hist2d_adc_per_kev.SetDirectory(None) hist2d_adc_per_kev.SetName("hist2d_adc_per_kev") hist2d_adc_per_kev.SetTitle("ADC/KeV of 1600 Channels") hist2d_adc_per_kev.GetXaxis().SetNdivisions(40) hist2d_adc_per_kev.GetYaxis().SetNdivisions(40) for i in xrange(40): if (i % 8 == 0): hist2d_adc_per_kev.GetXaxis().SetBinLabel(i + 1, "%02d" % i) hist2d_adc_per_kev.GetYaxis().SetBinLabel(i + 1, "%02d" % i)