def __init__(self, bpms_list, measured_beta, plane):
(self.beta_start, self.err_beta_start,
self.alfa_start, self.err_alfa_start,
self.beta_end, self.err_beta_end,
self.alfa_end, self.err_alfa_end) = sbs_beta_writer._get_start_end_betas(
bpms_list, measured_beta, plane
)
def __init__(self, bpms_list, measured_beta, plane):
(self.beta_start, self.err_beta_start, self.alfa_start,
self.err_alfa_start, self.beta_end, self.err_beta_end, self.alfa_end,
self.err_alfa_end) = sbs_beta_writer._get_start_end_betas(
bpms_list, measured_beta, plane)
def write_transverse_damper(propagated_models, element_name, input_model,
save_path, measured_hor_phase, measured_ver_phase,
measured_hor_beta, measured_ver_beta, accel):
'''
Function for getting the phase advance between the dampers and pick-ups
:Parameters:
'propagated_models.propagation': twiss?
containing propagation from BPM to damper
'propagated_models.back_propagation': twiss?
containing back propagation from BPM to damper
'element_name': string?
element name
'input_model': twiss
twiss input model
'save_path': string
where to save file
'measured_hor_phase':
measured phase advances
'measured_ver_phase':
measured phase advances
'errors':
twissmin,twissminb,twissmax,twissmaxb
:Return: None
nothing => writing to file in this function (new/appending)
'''
# initial
damper_map = {}
bpms_map = {}
file_transverse_damper = _get_transverse_damper_tfs_file(save_path, accel)
#beam1
damper_map['ADTKH.D5L4.B1'] = ['BPMWA.B5L4.B1', 'BPMWA.A5L4.B1']
damper_map['ADTKH.C5L4.B1'] = ['BPMWA.B5L4.B1', 'BPMWA.A5L4.B1']
damper_map['ADTKH.B5L4.B1'] = ['BPMWA.B5L4.B1', 'BPMWA.A5L4.B1']
damper_map['ADTKH.A5L4.B1'] = ['BPMWA.B5L4.B1', 'BPMWA.A5L4.B1']
damper_map['ADTKV.A5R4.B1'] = ['BPMWA.A5R4.B1', 'BPMWA.B5R4.B1']
damper_map['ADTKV.B5R4.B1'] = ['BPMWA.A5R4.B1', 'BPMWA.B5R4.B1']
damper_map['ADTKV.C5R4.B1'] = ['BPMWA.A5R4.B1', 'BPMWA.B5R4.B1']
damper_map['ADTKV.D5R4.B1'] = ['BPMWA.A5R4.B1', 'BPMWA.B5R4.B1']
bpms_map['LHCB1_1'] = ['BPMC.9L4.B1', 'BPMC.7L4.B1', 'BPMC.8L4.B1'] # H
bpms_map['LHCB1_2'] = ['BPMCA.7R4.B1', 'BPMC.9R4.B1', 'BPMC.8R4.B1'] # V
#beam2
damper_map['ADTKV.D5L4.B2'] = ['BPMWA.B5L4.B2', 'BPMWA.A5L4.B2']
damper_map['ADTKV.C5L4.B2'] = ['BPMWA.B5L4.B2', 'BPMWA.A5L4.B2']
damper_map['ADTKV.B5L4.B2'] = ['BPMWA.B5L4.B2', 'BPMWA.A5L4.B2']
damper_map['ADTKV.A5L4.B2'] = ['BPMWA.B5L4.B2', 'BPMWA.A5L4.B2']
damper_map['ADTKH.A5R4.B2'] = ['BPMWA.B5R4.B2', 'BPMWA.A5R4.B2']
damper_map['ADTKH.B5R4.B2'] = ['BPMWA.B5R4.B2', 'BPMWA.A5R4.B2']
damper_map['ADTKH.C5R4.B2'] = ['BPMWA.B5R4.B2', 'BPMWA.A5R4.B2']
damper_map['ADTKH.D5R4.B2'] = ['BPMWA.B5R4.B2', 'BPMWA.A5R4.B2']
bpms_map['LHCB2_1'] = ['BPMCA.7R4.B2', 'BPMC.9R4.B2', 'BPMC.8R4.B2'] # H
bpms_map['LHCB2_2'] = ['BPMC.9L4.B2', 'BPMC.7L4.B2', 'BPMC.8L4.B2'] # V
## main
if file_transverse_damper._TfsFileWriter__tfs_table.is_empty(
): # To check if the file is empty
for count in [1, 2]:
ref_bpm, end_bpm, eight_bpm = bpms_map[accel + "_" + str(count)]
# hor bpm_pair's
try:
in1x = measured_hor_phase.indx[ref_bpm]
except:
in1x = -1
if (in1x < len(measured_hor_phase.indx) - 1) and (
in1x != -1): # when BPM is not last
if measured_hor_phase.NAME[measured_hor_phase.indx[ref_bpm] +
1] == end_bpm:
in2x = 1
eightinphasex = 0
elif measured_hor_phase.NAME[measured_hor_phase.indx[ref_bpm] +
2] == end_bpm:
in2x = 1
eightinphasex = 1
else: # not in measurement
in2x = -1
eightinphasex = 0
elif (in1x != -1): # when BPM is last
if measured_hor_phase.NAME[0] == end_bpm:
in2x = 1
eightinphasex = 0
elif measured_hor_phase.NAME[1] == end_bpm:
in2x = 1
eightinphasex = 1
else: # not in measurement
in2x = -1
eightinphasex = 0
else:
in2x = -1
eightinphasex = 0
# ver bpm's
try:
in1y = measured_ver_phase.indx[ref_bpm]
except:
in1y = -1
if (in1y < len(measured_ver_phase.indx) - 1) and (
in1y != -1): # when BPM is not last
if measured_ver_phase.NAME[measured_ver_phase.indx[ref_bpm] +
1] == end_bpm:
in2y = 1
eightinphasey = 0
elif measured_ver_phase.NAME[measured_ver_phase.indx[ref_bpm] +
2] == end_bpm:
in2y = 1
eightinphasey = 1
else: # not in measurement
in2y = -1
eightinphasey = 0
elif in1y != -1: # when BPM is last
if measured_ver_phase.NAME[0] == end_bpm:
in2y = 1
eightinphasey = 0
elif measured_ver_phase.NAME[1] == end_bpm:
in2y = 1
eightinphasey = 1
else: # not in measurement
in2y = -1
eightinphasey = 0
else:
in2y = -1
eightinphasey = 0
###### H plane
if in1x != -1 and in2x != -1:
if eightinphasex == 1:
phaseh = "% .5f" % float(
measured_hor_phase.PHASEX[
measured_hor_phase.indx[ref_bpm]] +
measured_hor_phase.PHASEX[
measured_hor_phase.indx[eight_bpm]])
errphaseh = "% .5f" % float(
measured_hor_phase.STDPHX[
measured_hor_phase.indx[ref_bpm]] +
measured_hor_phase.STDPHX[
measured_hor_phase.indx[eight_bpm]])
phasemodelh = "% .5f" % float(
measured_hor_phase.PHXMDL[
measured_hor_phase.indx[ref_bpm]] +
measured_hor_phase.PHXMDL[
measured_hor_phase.indx[eight_bpm]])
else:
phaseh = "% .5f" % float(measured_hor_phase.PHASEX[
measured_hor_phase.indx[ref_bpm]])
errphaseh = "% .5f" % float(measured_hor_phase.STDPHX[
measured_hor_phase.indx[ref_bpm]])
phasemodelh = "% .5f" % float(measured_hor_phase.PHXMDL[
measured_hor_phase.indx[ref_bpm]])
else:
print "Horizontal plane not found for transverse dampers pick-ups"
phaseh = 'NIM'
errphaseh = 'NIM'
phasemodelh = 'NIM'
###### V plane
print in1y, in2y, eightinphasey
if (in1y != -1) and (in2y != -1):
if eightinphasey == 1:
phasev = "% .5f" % float(
measured_ver_phase.PHASEY[
measured_ver_phase.indx[ref_bpm]] +
measured_ver_phase.PHASEY[
measured_ver_phase.indx[eight_bpm]])
errphasev = "% .5f" % float(
measured_ver_phase.STDPHY[
measured_ver_phase.indx[ref_bpm]] +
measured_ver_phase.STDPHY[
measured_ver_phase.indx[eight_bpm]])
phasemodelv = "% .5f" % float(
measured_ver_phase.PHYMDL[
measured_ver_phase.indx[ref_bpm]] +
measured_ver_phase.PHYMDL[
measured_ver_phase.indx[eight_bpm]])
else:
phasev = "% .5f" % float(measured_ver_phase.PHASEY[
measured_ver_phase.indx[ref_bpm]])
errphasev = "% .5f" % float(measured_ver_phase.STDPHY[
measured_ver_phase.indx[ref_bpm]])
phasemodelv = "% .5f" % float(measured_ver_phase.PHYMDL[
measured_ver_phase.indx[ref_bpm]])
else:
print "Vertical plane not found for transverse dampers pick-ups"
phasev = 'NIM'
errphasev = 'NIM'
phasemodelv = 'NIM'
file_transverse_damper.add_table_row([
ref_bpm, end_bpm, input_model.S[input_model.indx[ref_bpm]],
input_model.S[input_model.indx[end_bpm]], phaseh, errphaseh,
phasemodelh, phasev, errphasev, phasemodelv
])
if element_name in damper_map:
bpm_pair = damper_map[element_name]
mux_bpm1_prop = propagated_models.propagation.MUX[
propagated_models.propagation.indx[bpm_pair[0]]]
mux_bpm2_prop = propagated_models.propagation.MUX[
propagated_models.propagation.indx[bpm_pair[1]]]
mux_elem_prop = propagated_models.propagation.MUX[
propagated_models.propagation.indx[element_name]]
muy_bpm1_prop = propagated_models.propagation.MUY[
propagated_models.propagation.indx[bpm_pair[0]]]
muy_bpm2_prop = propagated_models.propagation.MUY[
propagated_models.propagation.indx[bpm_pair[1]]]
muy_elem_prop = propagated_models.propagation.MUY[
propagated_models.propagation.indx[element_name]]
model_mux_bpm1 = input_model.MUX[input_model.indx[bpm_pair[0]]]
model_mux_bpm2 = input_model.MUX[input_model.indx[bpm_pair[1]]]
model_mux_elem = input_model.MUX[input_model.indx[element_name]]
model_muy_bpm1 = input_model.MUY[input_model.indx[bpm_pair[0]]]
model_muy_bpm2 = input_model.MUY[input_model.indx[bpm_pair[1]]]
model_muy_elem = input_model.MUY[input_model.indx[element_name]]
phase_advance_x_bpm1_prop = abs(mux_elem_prop - mux_bpm1_prop)
phase_advance_x_bpm2_prop = abs(mux_bpm2_prop - mux_elem_prop)
phase_advance_y_bpm1_prop = abs(muy_elem_prop - muy_bpm1_prop)
phase_advance_y_bpm2_prop = abs(muy_bpm2_prop - muy_elem_prop)
mux_bpm1_back = propagated_models.back_propagation.MUX[
propagated_models.back_propagation.indx[bpm_pair[0]]]
mux_bpm2_back = propagated_models.back_propagation.MUX[
propagated_models.back_propagation.indx[bpm_pair[1]]]
mux_elem_back = propagated_models.back_propagation.MUX[
propagated_models.back_propagation.indx[element_name]]
muy_bpm1_back = propagated_models.back_propagation.MUY[
propagated_models.back_propagation.indx[bpm_pair[0]]]
muy_bpm2_back = propagated_models.back_propagation.MUY[
propagated_models.back_propagation.indx[bpm_pair[1]]]
muy_elem_back = propagated_models.back_propagation.MUY[
propagated_models.back_propagation.indx[element_name]]
phase_advance_x_bpm1_back = abs(mux_bpm1_back - mux_elem_back)
phase_advance_x_bpm2_back = abs(mux_elem_back - mux_bpm2_back)
phase_advance_y_bpm1_back = abs(muy_bpm1_back - muy_elem_back)
phase_advance_y_bpm2_back = abs(muy_elem_back - muy_bpm2_back)
model_phase_advance_x_bpm1 = abs(model_mux_elem - model_mux_bpm1)
model_phase_advance_x_bpm2 = abs(model_mux_bpm2 - model_mux_elem)
model_phase_advance_y_bpm1 = abs(model_muy_elem - model_muy_bpm1)
model_phase_advance_y_bpm2 = abs(model_muy_bpm2 - model_muy_elem)
gather_betas_list = [[0, bpm_pair[0]], [0, bpm_pair[1]]
] # The function expects this kind of input
(beta_x_bpm1, err_beta_x_bpm1, alfa_x_bpm1, err_alfa_x_bpm1,
beta_x_bpm2, err_beta_x_bpm2, alfa_x_bpm2,
err_alfa_x_bpm2) = sbs_beta_writer._get_start_end_betas(
gather_betas_list, measured_hor_beta, "X")
(beta_y_bpm1, err_beta_y_bpm1, alfa_y_bpm1, err_alfa_y_bpm1,
beta_y_bpm2, err_beta_y_bpm2, alfa_y_bpm2,
err_alfa_y_bpm2) = sbs_beta_writer._get_start_end_betas(
gather_betas_list, measured_ver_beta, "Y")
err_phase_x_bpm1_prop = sbs_phase_writer._propagate_error_phase(
err_beta_x_bpm1, err_alfa_x_bpm1, phase_advance_x_bpm1_prop,
beta_x_bpm1, alfa_x_bpm1)
err_phase_x_bpm1_back = sbs_phase_writer._propagate_error_phase(
err_beta_x_bpm1, err_alfa_x_bpm1, phase_advance_x_bpm1_back,
beta_x_bpm1, alfa_x_bpm1)
err_phase_x_bpm2_prop = sbs_phase_writer._propagate_error_phase(
err_beta_x_bpm2, err_alfa_x_bpm2, phase_advance_x_bpm2_prop,
beta_x_bpm2, alfa_x_bpm2)
err_phase_x_bpm2_back = sbs_phase_writer._propagate_error_phase(
err_beta_x_bpm2, err_alfa_x_bpm2, phase_advance_x_bpm2_back,
beta_x_bpm2, alfa_x_bpm2)
err_phase_y_bpm1_prop = sbs_phase_writer._propagate_error_phase(
err_beta_y_bpm1, err_alfa_y_bpm1, phase_advance_y_bpm1_prop,
beta_y_bpm1, alfa_y_bpm1)
err_phase_y_bpm1_back = sbs_phase_writer._propagate_error_phase(
err_beta_y_bpm1, err_alfa_y_bpm1, phase_advance_y_bpm1_back,
beta_y_bpm1, alfa_y_bpm1)
err_phase_y_bpm2_prop = sbs_phase_writer._propagate_error_phase(
err_beta_y_bpm2, err_alfa_y_bpm2, phase_advance_y_bpm2_prop,
beta_y_bpm2, alfa_y_bpm2)
err_phase_y_bpm2_back = sbs_phase_writer._propagate_error_phase(
err_beta_y_bpm2, err_alfa_y_bpm2, phase_advance_y_bpm2_back,
beta_y_bpm2, alfa_y_bpm2)
# TODO: Is this OK?
average_phase_advance_x_bpm1, final_error_phase_advance_x_bpm1 = weighted_average_for_SbS_elements(
phase_advance_x_bpm1_prop, err_phase_x_bpm1_prop,
phase_advance_x_bpm1_back, err_phase_x_bpm1_back)
average_phase_advance_y_bpm1, final_error_phase_advance_y_bpm1 = weighted_average_for_SbS_elements(
phase_advance_y_bpm1_prop, err_phase_y_bpm1_prop,
phase_advance_y_bpm1_back, err_phase_y_bpm1_back)
average_phase_advance_x_bpm2, final_error_phase_advance_x_bpm2 = weighted_average_for_SbS_elements(
phase_advance_x_bpm2_prop, err_phase_x_bpm2_prop,
phase_advance_x_bpm2_back, err_phase_x_bpm2_back)
average_phase_advance_y_bpm2, final_error_phase_advance_y_bpm2 = weighted_average_for_SbS_elements(
phase_advance_y_bpm2_prop, err_phase_y_bpm2_prop,
phase_advance_y_bpm2_back, err_phase_y_bpm2_back)
file_transverse_damper.add_table_row([
bpm_pair[0], element_name,
input_model.S[input_model.indx[bpm_pair[0]]],
input_model.S[input_model.indx[element_name]],
"%.5f" % float(average_phase_advance_x_bpm1),
"%.5f" % float(final_error_phase_advance_x_bpm1),
"%.5f" % float(model_phase_advance_x_bpm1),
"%.5f" % float(average_phase_advance_y_bpm1),
"%.5f" % float(final_error_phase_advance_y_bpm1),
"%.5f" % float(model_phase_advance_y_bpm1)
])
file_transverse_damper.add_table_row([
element_name, bpm_pair[1],
input_model.S[input_model.indx[element_name]],
input_model.S[input_model.indx[bpm_pair[1]]],
"%.5f" % float(average_phase_advance_x_bpm2),
"%.5f" % float(final_error_phase_advance_x_bpm2),
"%.5f" % float(model_phase_advance_x_bpm2),
"%.5f" % float(average_phase_advance_y_bpm2),
"%.5f" % float(final_error_phase_advance_y_bpm2),
"%.5f" % float(model_phase_advance_y_bpm2)
])
else:
print "WARN: Element ", element_name, " Not found in damper_map"
file_transverse_damper.write_to_file()
def _write_phase_for_plane(file_phase, element_name, plane, bpms_list, measured_phase, measured_beta, model_propagation, model_cor, model_back_propagation, model_back_cor):
first_bpm = bpms_list[0][1]
last_bpm = bpms_list[-1][1]
(beta_start, err_beta_start, alfa_start, err_alfa_start,
beta_end, err_beta_end, alfa_end, err_alfa_end) = sbs_beta_writer._get_start_end_betas(bpms_list, measured_beta, plane)
# Fix for phase jump at the start of the ring
tune, fix_start_s = {}, None
first_bpm_on_ring = measured_phase.NAME[np.argmin(measured_phase.S)]
if first_bpm_on_ring in model_propagation.NAME:
fix_start_s = model_propagation.S[model_propagation.indx[first_bpm_on_ring]]
if "LHCB1" in model_propagation.SEQUENCE and first_bpm_on_ring in model_propagation.NAME:
tune["X"], tune["Y"] = measured_phase.Q1, measured_phase.Q2
elif "LHCB2" in model_propagation.SEQUENCE and first_bpm_on_ring in model_propagation.NAME:
tune["X"], tune["Y"] = measured_phase.Q1, measured_phase.Q2
for bpm in bpms_list:
bpm_s = bpm[0]
bpm_name = bpm[1]
model_s = measured_phase.S[measured_phase.indx[bpm_name]]
meas_phase = (getattr(measured_phase, "PHASE" + plane)[measured_phase.indx[bpm_name]] -
getattr(measured_phase, "PHASE" + plane)[measured_phase.indx[first_bpm]]) % 1
std_err_phase = getattr(measured_phase, "STDPH" + plane)[measured_phase.indx[bpm_name]]
model_prop_phase = (getattr(model_propagation, "MU" + plane)[model_propagation.indx[bpm_name]] -
getattr(model_propagation, "MU" + plane)[model_propagation.indx[first_bpm]]) % 1
model_cor_phase = (getattr(model_cor, "MU" + plane)[model_cor.indx[bpm_name]] -
getattr(model_cor, "MU" + plane)[model_cor.indx[first_bpm]]) % 1
meas_phase_back = (getattr(measured_phase, "PHASE" + plane)[measured_phase.indx[bpm_name]] -
getattr(measured_phase, "PHASE" + plane)[measured_phase.indx[last_bpm]]) % 1
model_back_propagation_phase = (getattr(model_back_propagation, "MU" + plane)[model_back_propagation.indx[last_bpm]] -
getattr(model_back_propagation, "MU" + plane)[model_back_propagation.indx[bpm_name]]) % 1
model_back_cor_phase = (getattr(model_back_cor, "MU" + plane)[model_back_cor.indx[last_bpm]] -
getattr(model_back_cor, "MU" + plane)[model_back_cor.indx[bpm_name]]) % 1
prop_phase_difference = (meas_phase - model_prop_phase) % 1
if prop_phase_difference > 0.5:
prop_phase_difference = prop_phase_difference - 1
back_prop_phase_difference = (meas_phase_back - model_back_propagation_phase) % 1
if back_prop_phase_difference > 0.5:
back_prop_phase_difference = back_prop_phase_difference - 1
if not fix_start_s is None:
if bpm_s >= fix_start_s:
prop_phase_difference += tune[plane]
elif bpm_s <= fix_start_s:
back_prop_phase_difference -= tune[plane]
prop_cor_phase = -getattr(model_propagation, "MU" + plane)[model_propagation.indx[bpm_name]] + getattr(model_cor, "MU" + plane)[model_cor.indx[bpm_name]]
back_cor_phase = getattr(model_back_propagation, "MU" + plane)[model_back_propagation.indx[bpm_name]] - getattr(model_back_cor, "MU" + plane)[model_back_cor.indx[bpm_name]]
prop_phase_error = _propagate_error_phase(err_beta_start, err_alfa_start, model_prop_phase, beta_start, alfa_start)
cor_phase_error = _propagate_error_phase(err_beta_start, err_alfa_start, model_cor_phase, beta_start, alfa_start)
back_phase_error = _propagate_error_phase(err_beta_end, err_alfa_end, model_back_propagation_phase, beta_end, alfa_end)
back_cor_phase_error = _propagate_error_phase(err_beta_end, err_alfa_end, model_back_cor_phase, beta_end, alfa_end)
# Error for the phase difference -> sqrt(e1**2 + e2**2 - 2cov(e1, e2)) and assuming no covariance
prop_meas_diff_error = np.sqrt(prop_phase_error ** 2 + std_err_phase ** 2)
prop_cor_diff_error = np.sqrt(prop_meas_diff_error ** 2 + cor_phase_error ** 2)
back_meas_diff_error = np.sqrt(back_phase_error ** 2 + std_err_phase ** 2)
back_cor_diff_error = np.sqrt(back_meas_diff_error ** 2 + back_cor_phase_error ** 2)
file_phase.add_table_row([bpm_name, bpm_s, meas_phase, std_err_phase, prop_phase_difference, prop_meas_diff_error, prop_cor_phase, prop_cor_diff_error, back_prop_phase_difference, back_meas_diff_error, back_cor_phase, back_cor_diff_error, model_s])
file_phase.write_to_file()
def _write_phase_for_plane(file_phase, element_name, plane, bpms_list,
measured_phase, measured_beta, model_propagation,
model_cor, model_back_propagation, model_back_cor):
first_bpm = bpms_list[0][1]
last_bpm = bpms_list[-1][1]
(beta_start, err_beta_start, alfa_start, err_alfa_start, beta_end,
err_beta_end, alfa_end,
err_alfa_end) = sbs_beta_writer._get_start_end_betas(
bpms_list, measured_beta, plane)
# Fix for phase jump at the start of the ring
tune, fix_start_s = {}, None
first_bpm_on_ring = measured_phase.NAME[np.argmin(measured_phase.S)]
if first_bpm_on_ring in model_propagation.NAME:
fix_start_s = model_propagation.S[
model_propagation.indx[first_bpm_on_ring]]
if "LHCB1" in model_propagation.SEQUENCE and first_bpm_on_ring in model_propagation.NAME:
tune["X"], tune["Y"] = measured_phase.Q1, measured_phase.Q2
elif "LHCB2" in model_propagation.SEQUENCE and first_bpm_on_ring in model_propagation.NAME:
tune["X"], tune["Y"] = measured_phase.Q1, measured_phase.Q2
for bpm in bpms_list:
bpm_s = bpm[0]
bpm_name = bpm[1]
model_s = measured_phase.S[measured_phase.indx[bpm_name]]
meas_phase = (getattr(measured_phase,
"PHASE" + plane)[measured_phase.indx[bpm_name]] -
getattr(measured_phase, "PHASE" +
plane)[measured_phase.indx[first_bpm]]) % 1
std_err_phase = getattr(measured_phase,
"STDPH" + plane)[measured_phase.indx[bpm_name]]
model_prop_phase = (getattr(model_propagation, "MU" +
plane)[model_propagation.indx[bpm_name]] -
getattr(model_propagation, "MU" + plane)[
model_propagation.indx[first_bpm]]) % 1
model_cor_phase = (
getattr(model_cor, "MU" + plane)[model_cor.indx[bpm_name]] -
getattr(model_cor, "MU" + plane)[model_cor.indx[first_bpm]]) % 1
meas_phase_back = (getattr(
measured_phase, "PHASE" + plane)[measured_phase.indx[bpm_name]] -
getattr(measured_phase, "PHASE" +
plane)[measured_phase.indx[last_bpm]]) % 1
model_back_propagation_phase = (
getattr(model_back_propagation,
"MU" + plane)[model_back_propagation.indx[last_bpm]] -
getattr(model_back_propagation,
"MU" + plane)[model_back_propagation.indx[bpm_name]]) % 1
model_back_cor_phase = (getattr(
model_back_cor, "MU" + plane)[model_back_cor.indx[last_bpm]] -
getattr(model_back_cor, "MU" + plane)[
model_back_cor.indx[bpm_name]]) % 1
prop_phase_difference = (meas_phase - model_prop_phase) % 1
if prop_phase_difference > 0.5:
prop_phase_difference = prop_phase_difference - 1
back_prop_phase_difference = (meas_phase_back -
model_back_propagation_phase) % 1
if back_prop_phase_difference > 0.5:
back_prop_phase_difference = back_prop_phase_difference - 1
if not fix_start_s is None:
if bpm_s >= fix_start_s:
prop_phase_difference += tune[plane]
elif bpm_s <= fix_start_s:
back_prop_phase_difference -= tune[plane]
prop_cor_phase = -getattr(model_propagation, "MU" + plane)[
model_propagation.indx[bpm_name]] + getattr(
model_cor, "MU" + plane)[model_cor.indx[bpm_name]]
back_cor_phase = getattr(
model_back_propagation,
"MU" + plane)[model_back_propagation.indx[bpm_name]] - getattr(
model_back_cor, "MU" + plane)[model_back_cor.indx[bpm_name]]
prop_phase_error = _propagate_error_phase(err_beta_start,
err_alfa_start,
model_prop_phase, beta_start,
alfa_start)
cor_phase_error = _propagate_error_phase(err_beta_start,
err_alfa_start,
model_cor_phase, beta_start,
alfa_start)
back_phase_error = _propagate_error_phase(
err_beta_end, err_alfa_end, model_back_propagation_phase, beta_end,
alfa_end)
back_cor_phase_error = _propagate_error_phase(err_beta_end,
err_alfa_end,
model_back_cor_phase,
beta_end, alfa_end)
# Error for the phase difference -> sqrt(e1**2 + e2**2 - 2cov(e1, e2)) and assuming no covariance
prop_meas_diff_error = np.sqrt(prop_phase_error**2 + std_err_phase**2)
prop_cor_diff_error = np.sqrt(prop_meas_diff_error**2 +
cor_phase_error**2)
back_meas_diff_error = np.sqrt(back_phase_error**2 + std_err_phase**2)
back_cor_diff_error = np.sqrt(back_meas_diff_error**2 +
back_cor_phase_error**2)
file_phase.add_table_row([
bpm_name, bpm_s, meas_phase, std_err_phase, prop_phase_difference,
prop_meas_diff_error, prop_cor_phase, prop_cor_diff_error,
back_prop_phase_difference, back_meas_diff_error, back_cor_phase,
back_cor_diff_error, model_s
])
file_phase.write_to_file()
def write_transverse_damper(propagated_models, element_name, input_model, save_path, measured_hor_phase, measured_ver_phase, measured_hor_beta, measured_ver_beta, accel):
'''
Function for getting the phase advance between the dampers and pick-ups
:Parameters:
'propagated_models.propagation': twiss?
containing propagation from BPM to damper
'propagated_models.back_propagation': twiss?
containing back propagation from BPM to damper
'element_name': string?
element name
'input_model': twiss
twiss input model
'save_path': string
where to save file
'measured_hor_phase':
measured phase advances
'measured_ver_phase':
measured phase advances
'errors':
twissmin,twissminb,twissmax,twissmaxb
:Return: None
nothing => writing to file in this function (new/appending)
'''
# initial
damper_map = {}
bpms_map = {}
file_transverse_damper = _get_transverse_damper_tfs_file(save_path, accel)
#beam1
damper_map['ADTKH.D5L4.B1'] = ['BPMWA.B5L4.B1', 'BPMWA.A5L4.B1']
damper_map['ADTKH.C5L4.B1'] = ['BPMWA.B5L4.B1', 'BPMWA.A5L4.B1']
damper_map['ADTKH.B5L4.B1'] = ['BPMWA.B5L4.B1', 'BPMWA.A5L4.B1']
damper_map['ADTKH.A5L4.B1'] = ['BPMWA.B5L4.B1', 'BPMWA.A5L4.B1']
damper_map['ADTKV.A5R4.B1'] = ['BPMWA.A5R4.B1', 'BPMWA.B5R4.B1']
damper_map['ADTKV.B5R4.B1'] = ['BPMWA.A5R4.B1', 'BPMWA.B5R4.B1']
damper_map['ADTKV.C5R4.B1'] = ['BPMWA.A5R4.B1', 'BPMWA.B5R4.B1']
damper_map['ADTKV.D5R4.B1'] = ['BPMWA.A5R4.B1', 'BPMWA.B5R4.B1']
bpms_map['LHCB1_1'] = ['BPMC.9L4.B1', 'BPMC.7L4.B1', 'BPMC.8L4.B1'] # H
bpms_map['LHCB1_2'] = ['BPMCA.7R4.B1', 'BPMC.9R4.B1', 'BPMC.8R4.B1'] # V
#beam2
damper_map['ADTKV.D5L4.B2'] = ['BPMWA.B5L4.B2', 'BPMWA.A5L4.B2']
damper_map['ADTKV.C5L4.B2'] = ['BPMWA.B5L4.B2', 'BPMWA.A5L4.B2']
damper_map['ADTKV.B5L4.B2'] = ['BPMWA.B5L4.B2', 'BPMWA.A5L4.B2']
damper_map['ADTKV.A5L4.B2'] = ['BPMWA.B5L4.B2', 'BPMWA.A5L4.B2']
damper_map['ADTKH.A5R4.B2'] = ['BPMWA.B5R4.B2', 'BPMWA.A5R4.B2']
damper_map['ADTKH.B5R4.B2'] = ['BPMWA.B5R4.B2', 'BPMWA.A5R4.B2']
damper_map['ADTKH.C5R4.B2'] = ['BPMWA.B5R4.B2', 'BPMWA.A5R4.B2']
damper_map['ADTKH.D5R4.B2'] = ['BPMWA.B5R4.B2', 'BPMWA.A5R4.B2']
bpms_map['LHCB2_1'] = ['BPMCA.7R4.B2', 'BPMC.9R4.B2', 'BPMC.8R4.B2'] # H
bpms_map['LHCB2_2'] = ['BPMC.9L4.B2', 'BPMC.7L4.B2', 'BPMC.8L4.B2'] # V
## main
if file_transverse_damper._TfsFileWriter__tfs_table.is_empty(): # To check if the file is empty
for count in [1, 2]:
ref_bpm, end_bpm, eight_bpm = bpms_map[accel + "_" + str(count)]
# hor bpm_pair's
try:
in1x = measured_hor_phase.indx[ref_bpm]
except:
in1x = -1
if (in1x < len(measured_hor_phase.indx) - 1) and (in1x != -1): # when BPM is not last
if measured_hor_phase.NAME[measured_hor_phase.indx[ref_bpm] + 1] == end_bpm:
in2x = 1
eightinphasex = 0
elif measured_hor_phase.NAME[measured_hor_phase.indx[ref_bpm] + 2] == end_bpm:
in2x = 1
eightinphasex = 1
else: # not in measurement
in2x = -1
eightinphasex = 0
elif (in1x != -1): # when BPM is last
if measured_hor_phase.NAME[0] == end_bpm:
in2x = 1
eightinphasex = 0
elif measured_hor_phase.NAME[1] == end_bpm:
in2x = 1
eightinphasex = 1
else: # not in measurement
in2x = -1
eightinphasex = 0
else:
in2x = -1
eightinphasex = 0
# ver bpm's
try:
in1y = measured_ver_phase.indx[ref_bpm]
except:
in1y = -1
if (in1y < len(measured_ver_phase.indx) - 1) and (in1y != -1): # when BPM is not last
if measured_ver_phase.NAME[measured_ver_phase.indx[ref_bpm] + 1] == end_bpm:
in2y = 1
eightinphasey = 0
elif measured_ver_phase.NAME[measured_ver_phase.indx[ref_bpm] + 2] == end_bpm:
in2y = 1
eightinphasey = 1
else: # not in measurement
in2y = -1
eightinphasey = 0
elif in1y != -1: # when BPM is last
if measured_ver_phase.NAME[0] == end_bpm:
in2y = 1
eightinphasey = 0
elif measured_ver_phase.NAME[1] == end_bpm:
in2y = 1
eightinphasey = 1
else: # not in measurement
in2y = -1
eightinphasey = 0
else:
in2y = -1
eightinphasey = 0
###### H plane
if in1x != -1 and in2x != -1:
if eightinphasex == 1:
phaseh = "% .5f" % float(measured_hor_phase.PHASEX[measured_hor_phase.indx[ref_bpm]] + measured_hor_phase.PHASEX[measured_hor_phase.indx[eight_bpm]])
errphaseh = "% .5f" % float(measured_hor_phase.STDPHX[measured_hor_phase.indx[ref_bpm]] + measured_hor_phase.STDPHX[measured_hor_phase.indx[eight_bpm]])
phasemodelh = "% .5f" % float(measured_hor_phase.PHXMDL[measured_hor_phase.indx[ref_bpm]] + measured_hor_phase.PHXMDL[measured_hor_phase.indx[eight_bpm]])
else:
phaseh = "% .5f" % float(measured_hor_phase.PHASEX[measured_hor_phase.indx[ref_bpm]])
errphaseh = "% .5f" % float(measured_hor_phase.STDPHX[measured_hor_phase.indx[ref_bpm]])
phasemodelh = "% .5f" % float(measured_hor_phase.PHXMDL[measured_hor_phase.indx[ref_bpm]])
else:
print "Horizontal plane not found for transverse dampers pick-ups"
phaseh = 'NIM'
errphaseh = 'NIM'
phasemodelh = 'NIM'
###### V plane
print in1y, in2y, eightinphasey
if (in1y != -1) and (in2y != -1):
if eightinphasey == 1:
phasev = "% .5f" % float(measured_ver_phase.PHASEY[measured_ver_phase.indx[ref_bpm]] + measured_ver_phase.PHASEY[measured_ver_phase.indx[eight_bpm]])
errphasev = "% .5f" % float(measured_ver_phase.STDPHY[measured_ver_phase.indx[ref_bpm]] + measured_ver_phase.STDPHY[measured_ver_phase.indx[eight_bpm]])
phasemodelv = "% .5f" % float(measured_ver_phase.PHYMDL[measured_ver_phase.indx[ref_bpm]] + measured_ver_phase.PHYMDL[measured_ver_phase.indx[eight_bpm]])
else:
phasev = "% .5f" % float(measured_ver_phase.PHASEY[measured_ver_phase.indx[ref_bpm]])
errphasev = "% .5f" % float(measured_ver_phase.STDPHY[measured_ver_phase.indx[ref_bpm]])
phasemodelv = "% .5f" % float(measured_ver_phase.PHYMDL[measured_ver_phase.indx[ref_bpm]])
else:
print "Vertical plane not found for transverse dampers pick-ups"
phasev = 'NIM'
errphasev = 'NIM'
phasemodelv = 'NIM'
file_transverse_damper.add_table_row([ref_bpm, end_bpm, input_model.S[input_model.indx[ref_bpm]], input_model.S[input_model.indx[end_bpm]], phaseh, errphaseh, phasemodelh, phasev, errphasev, phasemodelv])
if element_name in damper_map:
bpm_pair = damper_map[element_name]
mux_bpm1_prop = propagated_models.propagation.MUX[propagated_models.propagation.indx[bpm_pair[0]]]
mux_bpm2_prop = propagated_models.propagation.MUX[propagated_models.propagation.indx[bpm_pair[1]]]
mux_elem_prop = propagated_models.propagation.MUX[propagated_models.propagation.indx[element_name]]
muy_bpm1_prop = propagated_models.propagation.MUY[propagated_models.propagation.indx[bpm_pair[0]]]
muy_bpm2_prop = propagated_models.propagation.MUY[propagated_models.propagation.indx[bpm_pair[1]]]
muy_elem_prop = propagated_models.propagation.MUY[propagated_models.propagation.indx[element_name]]
model_mux_bpm1 = input_model.MUX[input_model.indx[bpm_pair[0]]]
model_mux_bpm2 = input_model.MUX[input_model.indx[bpm_pair[1]]]
model_mux_elem = input_model.MUX[input_model.indx[element_name]]
model_muy_bpm1 = input_model.MUY[input_model.indx[bpm_pair[0]]]
model_muy_bpm2 = input_model.MUY[input_model.indx[bpm_pair[1]]]
model_muy_elem = input_model.MUY[input_model.indx[element_name]]
phase_advance_x_bpm1_prop = abs(mux_elem_prop - mux_bpm1_prop)
phase_advance_x_bpm2_prop = abs(mux_bpm2_prop - mux_elem_prop)
phase_advance_y_bpm1_prop = abs(muy_elem_prop - muy_bpm1_prop)
phase_advance_y_bpm2_prop = abs(muy_bpm2_prop - muy_elem_prop)
mux_bpm1_back = propagated_models.back_propagation.MUX[propagated_models.back_propagation.indx[bpm_pair[0]]]
mux_bpm2_back = propagated_models.back_propagation.MUX[propagated_models.back_propagation.indx[bpm_pair[1]]]
mux_elem_back = propagated_models.back_propagation.MUX[propagated_models.back_propagation.indx[element_name]]
muy_bpm1_back = propagated_models.back_propagation.MUY[propagated_models.back_propagation.indx[bpm_pair[0]]]
muy_bpm2_back = propagated_models.back_propagation.MUY[propagated_models.back_propagation.indx[bpm_pair[1]]]
muy_elem_back = propagated_models.back_propagation.MUY[propagated_models.back_propagation.indx[element_name]]
phase_advance_x_bpm1_back = abs(mux_bpm1_back - mux_elem_back)
phase_advance_x_bpm2_back = abs(mux_elem_back - mux_bpm2_back)
phase_advance_y_bpm1_back = abs(muy_bpm1_back - muy_elem_back)
phase_advance_y_bpm2_back = abs(muy_elem_back - muy_bpm2_back)
model_phase_advance_x_bpm1 = abs(model_mux_elem - model_mux_bpm1)
model_phase_advance_x_bpm2 = abs(model_mux_bpm2 - model_mux_elem)
model_phase_advance_y_bpm1 = abs(model_muy_elem - model_muy_bpm1)
model_phase_advance_y_bpm2 = abs(model_muy_bpm2 - model_muy_elem)
gather_betas_list = [[0, bpm_pair[0]], [0, bpm_pair[1]]] # The function expects this kind of input
(beta_x_bpm1, err_beta_x_bpm1, alfa_x_bpm1, err_alfa_x_bpm1,
beta_x_bpm2, err_beta_x_bpm2, alfa_x_bpm2, err_alfa_x_bpm2) = sbs_beta_writer._get_start_end_betas(gather_betas_list, measured_hor_beta, "X")
(beta_y_bpm1, err_beta_y_bpm1, alfa_y_bpm1, err_alfa_y_bpm1,
beta_y_bpm2, err_beta_y_bpm2, alfa_y_bpm2, err_alfa_y_bpm2) = sbs_beta_writer._get_start_end_betas(gather_betas_list, measured_ver_beta, "Y")
err_phase_x_bpm1_prop = sbs_phase_writer._propagate_error_phase(err_beta_x_bpm1, err_alfa_x_bpm1, phase_advance_x_bpm1_prop, beta_x_bpm1, alfa_x_bpm1)
err_phase_x_bpm1_back = sbs_phase_writer._propagate_error_phase(err_beta_x_bpm1, err_alfa_x_bpm1, phase_advance_x_bpm1_back, beta_x_bpm1, alfa_x_bpm1)
err_phase_x_bpm2_prop = sbs_phase_writer._propagate_error_phase(err_beta_x_bpm2, err_alfa_x_bpm2, phase_advance_x_bpm2_prop, beta_x_bpm2, alfa_x_bpm2)
err_phase_x_bpm2_back = sbs_phase_writer._propagate_error_phase(err_beta_x_bpm2, err_alfa_x_bpm2, phase_advance_x_bpm2_back, beta_x_bpm2, alfa_x_bpm2)
err_phase_y_bpm1_prop = sbs_phase_writer._propagate_error_phase(err_beta_y_bpm1, err_alfa_y_bpm1, phase_advance_y_bpm1_prop, beta_y_bpm1, alfa_y_bpm1)
err_phase_y_bpm1_back = sbs_phase_writer._propagate_error_phase(err_beta_y_bpm1, err_alfa_y_bpm1, phase_advance_y_bpm1_back, beta_y_bpm1, alfa_y_bpm1)
err_phase_y_bpm2_prop = sbs_phase_writer._propagate_error_phase(err_beta_y_bpm2, err_alfa_y_bpm2, phase_advance_y_bpm2_prop, beta_y_bpm2, alfa_y_bpm2)
err_phase_y_bpm2_back = sbs_phase_writer._propagate_error_phase(err_beta_y_bpm2, err_alfa_y_bpm2, phase_advance_y_bpm2_back, beta_y_bpm2, alfa_y_bpm2)
# TODO: Is this OK?
average_phase_advance_x_bpm1, final_error_phase_advance_x_bpm1 = weighted_average_for_SbS_elements(phase_advance_x_bpm1_prop,
err_phase_x_bpm1_prop,
phase_advance_x_bpm1_back,
err_phase_x_bpm1_back)
average_phase_advance_y_bpm1, final_error_phase_advance_y_bpm1 = weighted_average_for_SbS_elements(phase_advance_y_bpm1_prop,
err_phase_y_bpm1_prop,
phase_advance_y_bpm1_back,
err_phase_y_bpm1_back)
average_phase_advance_x_bpm2, final_error_phase_advance_x_bpm2 = weighted_average_for_SbS_elements(phase_advance_x_bpm2_prop,
err_phase_x_bpm2_prop,
phase_advance_x_bpm2_back,
err_phase_x_bpm2_back)
average_phase_advance_y_bpm2, final_error_phase_advance_y_bpm2 = weighted_average_for_SbS_elements(phase_advance_y_bpm2_prop,
err_phase_y_bpm2_prop,
phase_advance_y_bpm2_back,
err_phase_y_bpm2_back)
file_transverse_damper.add_table_row([bpm_pair[0], element_name,
input_model.S[input_model.indx[bpm_pair[0]]],
input_model.S[input_model.indx[element_name]],
"%.5f" % float(average_phase_advance_x_bpm1),
"%.5f" % float(final_error_phase_advance_x_bpm1),
"%.5f" % float(model_phase_advance_x_bpm1),
"%.5f" % float(average_phase_advance_y_bpm1),
"%.5f" % float(final_error_phase_advance_y_bpm1),
"%.5f" % float(model_phase_advance_y_bpm1)])
file_transverse_damper.add_table_row([element_name, bpm_pair[1],
input_model.S[input_model.indx[element_name]],
input_model.S[input_model.indx[bpm_pair[1]]],
"%.5f" % float(average_phase_advance_x_bpm2),
"%.5f" % float(final_error_phase_advance_x_bpm2),
"%.5f" % float(model_phase_advance_x_bpm2),
"%.5f" % float(average_phase_advance_y_bpm2),
"%.5f" % float(final_error_phase_advance_y_bpm2),
"%.5f" % float(model_phase_advance_y_bpm2)])
else:
print "WARN: Element ", element_name, " Not found in damper_map"
file_transverse_damper.write_to_file()
