def baseline_calib(board_name):
channels = db.find_board_by_name(board_name)["channels"] # zero based
TDC = db.find_board_by_name(board_name)["tdc_addr"]
db.enable_board(board_name)
tdc_daq.enable_tdc_channels_of_active_boards()
ptc.init_active_boards()
baselines = np.zeros(len(channels))
ptc.set_all_baselines(TDC,channels,baselines)
print( "TDC" )
print( TDC )
print( "channels" )
print( channels )
print( "no_events" )
print( no_events )
tot_means = tdc_daq.get_tot(TDC,channels,no_events)
print( "tot means:" )
print( tot_means )
target_tot = tot_means.mean()
print("target tot: {:f}".format(target_tot))
print("start auto correction procedure")
for step_width in [8,4,4,3,2,1,1,0.5,0.5,0.5,0.5,0.5]:
print("step width: {:02f}".format(step_width))
for index in range(0,len(channels)):
if (tot_means[index] < target_tot):
baselines[index]+=step_width
else:
baselines[index]-=step_width
baselines[index]=np.max([baselines[index],-15])
baselines[index]=np.min([baselines[index],15])
ptc.set_all_baselines(TDC,channels,baselines)
print( "get new tot values" )
tot_means = tdc_daq.get_tot(TDC,channels,no_events)
print( tot_means )
print( "deltas to target tot" )
print( tot_means - target_tot )
print( "deltas to target tot in percent" )
print( (tot_means - target_tot)/target_tot*100. )
print( "final baselines" )
print( np.floor(baselines) )
print( "save baselines in calib file" )
db.update_calib_json_by_name(board_name,{"baselines": np.floor(baselines).tolist() })
def init_boards_by_name(board_list):
setup = db.get_setup_json()
pktime = setup["asic_settings"]["default"]["pktime"]
gain = setup["asic_settings"]["default"]["gain"]
threshold = setup["asic_settings"]["default"]["threshold"]
standby_pktime = setup["asic_settings"]["standby"]["pktime"]
standby_gain = setup["asic_settings"]["standby"]["gain"]
standby_threshold = setup["asic_settings"]["standby"]["threshold"]
for board_name in board_list:
print("init board " + board_name)
board_info = db.find_board_by_name(board_name)
conn = board_info["tdc_connector"]
tdc_addr = board_info["tdc_addr"]
standby = False
if "standby" in board_info:
if board_info["standby"]:
standby = True
if tdc_addr[0:2].lower() == "0x":
if standby:
init_board(tdc_addr, conn, standby_pktime, standby_gain,
standby_threshold)
else:
init_board(tdc_addr, conn, pktime, gain, threshold)
return
def gen_baseline_report(board_name,**kwargs):
import pandas as pd
import numpy as np
calib_json = db.get_calib_json_by_name(board_name,**kwargs)
if "baselines" in calib_json:
baselines = calib_json["baselines"]
baseline_mean = baselines
if "baseline_mean" in calib_json:
baseline_mean = calib_json["baseline_mean"]
baseline_stddev = calib_json["baseline_stddev"]
ch_error = calib_json["ch_error"]
bl_range = calib_json["bl_range"]
board_info = db.find_board_by_name(board_name)
channels = board_info["channels"]
noise_scan_raw = calib_json["noise_scan_raw"]
noise_scan_x = calib_json["bl_range"]
df = pd.DataFrame(
np.transpose(np.array([board_info["board_chan"],baselines,baseline_mean,baseline_stddev,ch_error])),
index= channels, columns=["board_chan","baseline","bl_mean","bl_stddev","error"]
)
report = df.to_string()
report += "\n\n\n"
report += df.describe().to_string()
report += "\n\n\n"
report += "\n\n\n"
board_chan = 0
for scan in noise_scan_raw:
report += misc.ascii_hist(scan,xdata=noise_scan_x,title="PT "+board_name+" ch "+str(board_chan).rjust(2))
report += "\n"*10
board_chan += 1
return report
else:
return 0
def individual_channel_baseline_noise_scan(board_name):
board_info = db.find_board_by_name(board_name)
channels = board_info["channels"] # zero based
TDC = board_info["tdc_addr"]
connector = board_info["tdc_connector"]
db.enable_board(board_name)
#ptc.init_active_boards()
ptc.init_board_by_name(board_name)
scan_time = 0.2
ptc.set_threshold_for_board(TDC,connector,0)
result_matrix = []
x = range(-15,16)
for i in x:
print( "threshold scan of board "+board_name )
rates = []
print( "setting baseline "+str(i) )
for ch in range(0,16):
print( "probing channel "+str(ch) )
ptc.set_all_baselines(TDC,channels, [-15]*len(channels) )
ptc.set_baseline(TDC,channels[ch],i)
ch_rate = tdc_daq.scaler_rate(TDC,channels,scan_time)[ch]
rates.append(ch_rate)
print( "rates" )
print( rates )
result_matrix.append(rates)
return (x, result_matrix)
def baseline_noise_scan(board_name):
board_info = db.find_board_by_name(board_name)
channels = board_info["channels"] # zero based
TDC = board_info["tdc_addr"]
connector = board_info["tdc_connector"]
db.enable_board(board_name)
#ptc.init_active_boards()
ptc.init_board_by_name(board_name)
scan_time = 0.2
ptc.set_threshold_for_board(TDC,connector,0)
result_matrix = []
x = range(-15,16)
for i in x:
print( "threshold scan of board "+board_name )
ptc.set_all_baselines(TDC,channels, [i]*len(channels) )
rates = tdc_daq.scaler_rate(TDC,channels,scan_time)
print( "rates" )
print( rates )
result_matrix.append(rates)
return (x, result_matrix)
def threshold_noise_scan(board_name):
board_info = db.find_board_by_name(board_name)
channels = board_info["channels"] # zero based
TDC = board_info["tdc_addr"]
connector = board_info["tdc_connector"]
db.enable_board(board_name)
#ptc.init_active_boards()
ptc.init_board_by_name(board_name)
scan_time = 0.2
x = range(0,32)
global_settings = db.get_global_settings()
if "threshold_noise_scan_limit" in global_settings:
threshold_noise_scan_limit = global_settings["threshold_noise_scan_limit"]
x = range(0,threshold_noise_scan_limit)
## set baselines to maximum, so we start scanning below the baseline
## and hopefully capture the full noise
ptc.set_all_baselines(TDC,channels, [15]*len(channels) )
result_matrix = []
for i in x:
print( "threshold scan of board "+board_name )
ptc.set_threshold_for_board(TDC,connector,i)
rates = tdc_daq.scaler_rate(TDC,channels,scan_time)
print( "rates" )
print( rates )
result_matrix.append(rates)
return (x, result_matrix)
def set_threshold_for_board_by_name(board_name, thresh):
setup = db.get_setup_json()
board_info = db.find_board_by_name(board_name)
conn = board_info["tdc_connector"]
tdc_addr = board_info["tdc_addr"]
set_threshold_for_board(tdc_addr, conn, thresh)
return
def slow_control_test(board_name):
scan_time = 0.2
board_info = db.find_board_by_name(board_name)
channels = board_info["channels"] # zero based
TDC = board_info["tdc_addr"]
connector = board_info["tdc_connector"]
db.enable_board(board_name)
init_board_by_name(board_name)
print("slow control test of board " + board_name)
set_threshold_for_board(TDC, connector, 0)
rates_lo_thr = tdc_daq.scaler_rate(TDC, channels, scan_time)
set_threshold_for_board(TDC, connector, 127)
rates_hi_thr = tdc_daq.scaler_rate(TDC, channels, scan_time)
state_hi_thr = tdc_daq.read_ch_state(TDC, channels)
print("rates low thr")
print(rates_lo_thr)
print("rates high thr")
print(rates_hi_thr)
print("state high thr")
print(state_hi_thr)
## restore threshold again - a bit dirty but faster than complete init again
setup = db.get_setup_json()
#pktime = setup["asic_settings"]["default"]["pktime"]
#gain = setup["asic_settings"]["default"]["gain"]
threshold = setup["asic_settings"]["default"]["threshold"]
#standby_pktime = setup["asic_settings"]["standby"]["pktime"]
#standby_gain = setup["asic_settings"]["standby"]["gain"]
standby_threshold = setup["asic_settings"]["standby"]["threshold"]
standby = False
if "standby" in board_info:
if board_info["standby"]:
standby = True
if standby:
set_threshold_for_board(TDC, connector, standby_threshold)
else:
set_threshold_for_board(TDC, connector, threshold)
## end of restore threshold
if state_hi_thr == [1] * len(channels) and rates_hi_thr == [0] * len(
channels) and rates_lo_thr != [0] * len(channels):
return 1
else:
return 0
def calib_t1_offsets_of_board(board_name):
# we clear old offsets of board first
db.clear_t1_offsets_of_board(board_name)
ptc.init_board_by_name(board_name)
no_pulses = 1000
## run record_tree_data() first ##
board_info = db.find_board_by_name(board_name)
t1, tot, counts = calib_t1_offsets(board_info["tdc_addr"],
board_info["channels"], no_pulses)
# record efficiency in calib for debugging
counts_array = np.array(counts)
efficiency_array = counts_array / no_pulses
calib_json_update = {"t1_calib_efficiency": efficiency_array.tolist()}
db.update_calib_json_by_name(board_name, calib_json_update)
def dialog_slow_control_test(board_list):
d = Dialog(dialog="dialog")
d.set_background_title("view boards")
choices = []
info_format = "{:>6s} {:>4s} {:>6s} {:>6s} {:>6s} {:>6s}"
info = info_format.format("TDC", "CONN", "BL cal", "t1 cal", "active", "SloCon")
choices += [("board",info)]
test_results = ptc.slow_control_test_boards(board_list)
for board_name in board_list:
board_info = db.find_board_by_name(board_name)
board_calib = db.get_calib_json_by_name(board_name)
bl_calib = " - "
if board_info["baseline_is_calibrated"] == 1:
bl_calib = "yes"
elif board_info["baseline_is_calibrated"] == -1:
bl_calib = "err"
t1_calib = " - "
if board_info["t1_is_calibrated"]:
t1_calib = "yes"
active = " - "
if board_info["active"]:
active = "yes"
sctest = "err"
if test_results[board_name] == 1:
sctest = " ok"
info = info_format.format(board_info["tdc_addr"], str(board_info["tdc_connector"]), bl_calib, t1_calib, active, sctest )
choices += [(board_name,info)]
code, tag = d.menu("slow control test - active boards",
choices= choices, height="30", menu_height="28", width="70")
def enable_tdc_channels_of_active_boards():
### disable all daq channels of listed TDCs
for tdc_addr in db.tdc_list():
tdc_json = db.get_tdc_json(str(tdc_addr))
channels = tdc_json["channels"]
if tdc_addr[0:2].lower() == "0x":
disable_channels(tdc_addr, range(0, channels))
for board_name in db.active_board_list():
board_info = db.find_board_by_name(board_name)
channels = board_info["channels"]
tdc_addr = board_info["tdc_addr"]
standby = False
if "standby" in board_info:
if board_info["standby"]:
standby = True
if tdc_addr[0:2].lower() == "0x":
if not (standby):
enable_channels(tdc_addr, channels)
return
code, choice = dbd.dialog_board_list()
## view tdc list ##
if tag == "25":
code, choice = dbd.dialog_tdc_list()
## view hub list ##
if tag == "26":
code, choice = dbd.dialog_hub_list()
## calib t1 offsets ##
if tag == "12":
code_9, choice_9 = dbd.dialog_board_list()
if code_9 == d.DIALOG_OK:
board_name = choice_9
board_info = db.find_board_by_name(board_name)
#if board_info["baseline_is_calibrated"]:
d.msgbox(
"1. Make sure DABC is running. 2. Supply the same pulse to all inputs of board {:s} simultaneously to calibrate t1 offsets"
.format(board_name))
td.calib_t1_offsets_of_board(board_name)
#else:
# d.msgbox("t1 calibration not possible. Please calibrate baselines first, or the walk effect might skew your t1 calibration.")
calib = db.get_calib_json_by_name(board_name)
board_t1_offsets = db.get_t1_offsets_of_board(board_name)
t1_calib_efficiency = calib["t1_calib_efficiency"]
code_17, text = dbd.dialog_editbox(
"## board t1 offsets:\n\n" +
json.dumps(board_t1_offsets, indent=2, sort_keys=True) +
"\n\n## board t1 calib efficiency:\n\n" +
def reset_board_by_name(board_name):
board_info = db.find_board_by_name(board_name)
conn = board_info["tdc_connector"]
tdc_addr = board_info["tdc_addr"]
if tdc_addr[0:2].lower() == "0x":
reset_board(tdc_addr, conn)
def dialog_board_list(**kwargs):
width = str(100)
height = str(30)
menu_height = str(28)
list_height = menu_height
checklist = kwargs.get("checklist","")
selection = kwargs.get("selection","")
check_enable = False
check_standby = False
check_select = False
if checklist == "enable":
check_enable = True
if checklist == "standby":
check_standby = True
if checklist == "select":
check_select = True
empty_selection = False
if selection == "none":
empty_selection = True
d = Dialog(dialog="dialog")
d.set_background_title("view boards")
if check_enable:
d.set_background_title("enable/disable boards")
if check_standby:
d.set_background_title("set boards to standby")
if check_select:
d.set_background_title("select one or more boards")
choices = []
info_format = "{:>6s} {:>4s} {:>7s} {:>5} {:>12s} {:>6s} {:>6s} {:>6s} {:>7s}"
info = info_format.format("TDC", "CONN","chamber","layer","FPC ABCD", "BL cal", "t1 cal", "active","standby")
if check_enable or check_standby or check_select:
choices += [("board",info, False)]
else:
choices += [("board",info)]
board_list = db.board_list()
for board_name in board_list:
board_info = db.find_board_by_name(board_name)
board_calib = db.get_calib_json_by_name(board_name)
bl_calib = " - "
if board_info["baseline_is_calibrated"] == 1:
bl_calib = "yes"
elif board_info["baseline_is_calibrated"] == -1:
bl_calib = "err"
t1_calib = " - "
if board_info["t1_is_calibrated"]:
t1_calib = "yes"
active = " - "
active_bool = False
if board_info["active"]:
active = "yes"
active_bool = True
standby = " - "
standby_bool = False
if "standby" in board_info:
if board_info["standby"]:
standby = "yes"
standby_bool = True
info = info_format.format(
board_info["tdc_addr"],
str(board_info["tdc_connector"]),
str(board_info["chamber"]),
str(board_info["layer"]),
str(board_info["fpc_a"]).rjust(2)+","+
str(board_info["fpc_b"]).rjust(2)+","+
str(board_info["fpc_c"]).rjust(2)+","+
str(board_info["fpc_d"]).rjust(2),
bl_calib, t1_calib, active, standby )
if check_enable:
if empty_selection:
choices += [(board_name,info, False)]
else:
choices += [(board_name,info, active_bool)]
elif check_standby:
choices += [(board_name,info, standby_bool)]
elif check_select:
choices += [(board_name,info, False)]
else:
choices += [(board_name,info)]
if check_enable:
code, active_boards = d.checklist("enable/disable boards", choices=choices, width=width, height=height, list_height=list_height)
if code == d.DIALOG_OK:
for board_name in board_list:
db.disable_board(board_name)
for board_name in active_boards:
if not(board_name == "board"):
db.enable_board(board_name)
elif check_standby:
code, standby_boards = d.checklist("set board standby", choices= choices, width=width,height=height,list_height=list_height)
if code == d.DIALOG_OK:
for board_name in board_list:
db.unset_standby_board(board_name)
for board_name in standby_boards:
if not(board_name == "board"):
db.set_standby_board(board_name)
elif check_select:
code, selected_boards = d.checklist("select one or more boards", choices= choices, width=width,height=height,list_height=list_height)
return code, selected_boards
else:
code, tag = d.menu("select a board:",
choices= choices ,width=width,height=height,menu_height=menu_height)
return code, tag
def get_t1_tot_of_board(board_name):
## run record_tree_data() first ##
board_info = db.find_board_by_name(board_name)
return get_t1_tot(board_info["tdc_addr"], board_info["channels"])