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)
