def _write_chromatic_w_for_plane(file_chromatic, plane, element_name, bpms_list, measured_chromatic_w,
input_model, model_propagation, model_cor, model_back_propagation, model_back_cor,
save_path, is_element):
summary_data = []
for bpm in bpms_list:
bpm_s = bpm[0]
bpm_name = bpm[1]
model_s = input_model.S[input_model.indx[bpm_name]]
model_w = getattr(input_model, "W" + plane)[input_model.indx[bpm_name]]
model_phi = getattr(input_model, "PHI" + plane)[input_model.indx[bpm_name]]
w_prop = getattr(model_propagation, "W" + plane)[model_propagation.indx[bpm_name]]
phi_prop = getattr(model_propagation, "PHI" + plane)[model_propagation.indx[bpm_name]]
err_w_prop = 1e-8 # TODO: Propagate
err_phi_prop = 1e-8 # TODO: Propagate
w_back = getattr(model_back_propagation, "W" + plane)[model_back_propagation.indx[bpm_name]]
phi_back = getattr(model_back_propagation, "PHI" + plane)[model_back_propagation.indx[bpm_name]]
err_w_back = 1e-8 # TODO: Propagate
err_phi_back = 1e-8 # TODO: Propagate
if not is_element:
w_cor = getattr(model_cor, "W" + plane)[model_cor.indx[bpm_name]]
phi_cor = getattr(model_cor, "PHI" + plane)[model_cor.indx[bpm_name]]
err_w_cor = 1e-8 # TODO: Propagate
err_phi_cor = 1e-8 # TODO: Propagate
w_back_cor = getattr(model_back_cor, "W" + plane)[model_back_cor.indx[bpm_name]]
phi_back_cor = getattr(model_back_cor, "PHI" + plane)[model_back_cor.indx[bpm_name]]
err_w_back_cor = 1e-8 # TODO: Propagate
err_phi_back_cor = 1e-8 # TODO: Propagate
file_chromatic.add_table_row([bpm_name, bpm_s,
w_prop, err_w_prop, phi_prop, err_phi_prop,
w_cor, err_w_cor, phi_cor, err_phi_cor,
w_back, err_w_back, phi_back, err_phi_back,
w_back_cor, err_w_back_cor, phi_back_cor, err_phi_back_cor,
model_w, model_phi, model_s])
else:
average_w, final_err_w = weighted_average_for_SbS_elements(w_prop, err_w_prop, w_back, err_w_prop)
average_phi, final_err_phi = weighted_average_for_SbS_elements(phi_prop, err_phi_prop, phi_back, err_phi_prop)
file_chromatic.add_table_row([bpm_name, bpm_s, average_w, final_err_w, average_phi, final_err_phi, model_w, model_phi, model_s])
if element_name == bpm_name:
summary_data = [bpm_name, bpm_s, average_w, final_err_w, average_phi, final_err_phi, model_w, model_phi, model_s]
file_chromatic.write_to_file()
return summary_data
def _write_C_terms(file_C_terms, element_name, is_element, bpms_list, measured_coupling, input_model, model_propagation, model_back_propagation, model_cor, model_back_cor):
summary_data = []
for bpm in bpms_list:
bpm_s = bpm[0]
bpm_name = bpm[1]
prop_c11, prop_c12, prop_c21, prop_c22 = model_propagation.C[model_propagation.indx[bpm_name]]
err_prop_c11, err_prop_c12, err_prop_c21, err_prop_c22 = [1e-8, 1e-8, 1e-8, 1e-8] # TODO: propagate errors
back_c11, back_c12, back_c21, back_c22 = model_back_propagation.C[model_back_propagation.indx[bpm_name]]
err_back_c11, err_back_c12, err_back_c21, err_back_c22 = [1e-8, 1e-8, 1e-8, 1e-8] # TODO: propagate errors
if not is_element:
model_s = measured_coupling.S[measured_coupling.indx[bpm_name]]
cor_c11, cor_c12, cor_c21, cor_c22 = model_cor.C[model_cor.indx[bpm_name]]
err_cor_c11, err_cor_c12, err_cor_c21, err_cor_c22 = [1e-8, 1e-8, 1e-8, 1e-8] # TODO: propagate errors
back_cor_c11, back_cor_c12, back_cor_c21, back_cor_c22 = model_back_cor.C[model_back_cor.indx[bpm_name]]
err_back_cor_c11, err_back_cor_c12, err_back_cor_c21, err_back_cor_c22 = [1e-8, 1e-8, 1e-8, 1e-8] # TODO: propagate errors
file_C_terms.add_table_row([bpm_name, bpm_s,
prop_c11, err_prop_c11, prop_c12, err_prop_c12, prop_c21, err_prop_c21, prop_c22, err_prop_c22,
cor_c11, err_cor_c11, cor_c12, err_cor_c12, cor_c21, err_cor_c21, cor_c22, err_cor_c22,
back_c11, err_back_c11, back_c12, err_back_c12, back_c21, err_back_c21, back_c22, err_back_c22,
back_cor_c11, err_back_cor_c11, back_cor_c12, err_back_cor_c12, back_cor_c21, err_back_cor_c21, back_cor_c22, err_back_cor_c22,
model_s])
else:
model_s = input_model.S[input_model.indx[bpm_name]]
average_c11, final_err_c11 = weighted_average_for_SbS_elements(prop_c11, err_prop_c11, back_c11, err_back_c11)
average_c12, final_err_c12 = weighted_average_for_SbS_elements(prop_c12, err_prop_c12, back_c12, err_back_c12)
average_c21, final_err_c21 = weighted_average_for_SbS_elements(prop_c21, err_prop_c21, back_c21, err_back_c21)
average_c21, final_err_c21 = weighted_average_for_SbS_elements(prop_c22, err_prop_c22, back_c22, err_back_c22)
file_C_terms.add_table_row([bpm_name, bpm_s,
average_c11, final_err_c11, average_c12, final_err_c12, average_c21, final_err_c21, average_c21, final_err_c21,
model_s])
if bpm_name == element_name:
summary_data = [bpm_name, bpm_s,
average_c11, final_err_c11, average_c12, final_err_c12, average_c21, final_err_c21, average_c21, final_err_c21,
model_s]
file_C_terms.write_to_file()
return summary_data
def _write_normalized_hor_dispersion(file_norm_disp_x, element_name, bpms_list, measured_norm_disp, input_model, model_cor, model_propagation, model_back_propagation, model_back_cor, is_element):
summary_data = []
for bpm in bpms_list:
bpm_s = bpm[0]
bpm_name = bpm[1]
prop_norm_disp = model_propagation.DX[model_propagation.indx[bpm_name]] / sqrt(model_propagation.BETX[model_propagation.indx[bpm_name]])
back_prop_norm_disp = model_back_propagation.DX[model_back_propagation.indx[bpm_name]] / sqrt(model_back_propagation.BETX[model_back_propagation.indx[bpm_name]])
prop_norm_disp_err = 1e-8 # TODO: Propagate
back_prop_norm_disp_err = 1e-8 # TODO: Propagate
if not is_element:
model_s = measured_norm_disp.S[measured_norm_disp.indx[bpm_name]]
model_norm_disp = measured_norm_disp.NDXMDL[measured_norm_disp.indx[bpm_name]]
norm_disp_diff = measured_norm_disp.NDX[measured_norm_disp.indx[bpm_name]] - prop_norm_disp
back_norm_disp_diff = measured_norm_disp.NDX[measured_norm_disp.indx[bpm_name]] - back_prop_norm_disp
corr_norm_disp = model_cor.DX[model_cor.indx[bpm_name]] / sqrt(model_cor.BETX[model_cor.indx[bpm_name]])
corr_norm_disp_diff = corr_norm_disp - prop_norm_disp
err_corr_norm_disp = 1e-8 # TODO: Propagate
back_corr_norm_disp = model_back_cor.DX[model_back_cor.indx[bpm_name]] / sqrt(model_back_cor.BETX[model_back_cor.indx[bpm_name]])
back_corr_norm_disp_diff = back_corr_norm_disp - back_prop_norm_disp
err_back_corr_norm_disp = 1e-8 # TODO: Propagate
file_norm_disp_x.add_table_row([bpm_name, bpm_s, norm_disp_diff, prop_norm_disp_err, corr_norm_disp_diff, err_corr_norm_disp, back_norm_disp_diff, back_prop_norm_disp_err, back_corr_norm_disp_diff, err_back_corr_norm_disp, model_norm_disp, model_s])
else:
model_s = input_model.S[input_model.indx[bpm_name]]
model_norm_disp = input_model.DX[input_model.indx[bpm_name]] / sqrt(input_model.BETX[input_model.indx[bpm_name]])
average_norm_disp, final_norm_disp_err = weighted_average_for_SbS_elements(prop_norm_disp, prop_norm_disp_err, back_prop_norm_disp, back_prop_norm_disp_err)
file_norm_disp_x.add_table_row([bpm_name, bpm_s, average_norm_disp, final_norm_disp_err, model_norm_disp, model_s])
if bpm_name == element_name:
summary_data = [average_norm_disp, final_norm_disp_err, model_norm_disp]
file_norm_disp_x.write_to_file()
return summary_data
def _write_normalized_hor_dispersion(file_norm_disp_x, element_name, bpms_list, measured_norm_disp, input_model, model_cor, model_propagation, model_back_propagation, model_back_cor, is_element):
summary_data = []
for bpm in bpms_list:
bpm_s = bpm[0]
bpm_name = bpm[1]
prop_norm_disp = model_propagation.DX[model_propagation.indx[bpm_name]] / sqrt(model_propagation.BETX[model_propagation.indx[bpm_name]])
back_prop_norm_disp = model_back_propagation.DX[model_back_propagation.indx[bpm_name]] / sqrt(model_back_propagation.BETX[model_back_propagation.indx[bpm_name]])
prop_norm_disp_err = 1e-8 # TODO: Propagate
back_prop_norm_disp_err = 1e-8 # TODO: Propagate
if not is_element:
model_s = measured_norm_disp.S[measured_norm_disp.indx[bpm_name]]
model_norm_disp = measured_norm_disp.NDXMDL[measured_norm_disp.indx[bpm_name]]
norm_disp_diff = measured_norm_disp.NDX[measured_norm_disp.indx[bpm_name]] - prop_norm_disp
back_norm_disp_diff = measured_norm_disp.NDX[measured_norm_disp.indx[bpm_name]] - back_prop_norm_disp
corr_norm_disp = model_cor.DX[model_cor.indx[bpm_name]] / sqrt(model_cor.BETX[model_cor.indx[bpm_name]])
corr_norm_disp_diff = corr_norm_disp - prop_norm_disp
err_corr_norm_disp = 1e-8 # TODO: Propagate
back_corr_norm_disp = model_back_cor.DX[model_back_cor.indx[bpm_name]] / sqrt(model_back_cor.BETX[model_back_cor.indx[bpm_name]])
back_corr_norm_disp_diff = back_corr_norm_disp - back_prop_norm_disp
err_back_corr_norm_disp = 1e-8 # TODO: Propagate
file_norm_disp_x.add_table_row([bpm_name, bpm_s, norm_disp_diff, prop_norm_disp_err, corr_norm_disp_diff, err_corr_norm_disp, back_norm_disp_diff, back_prop_norm_disp_err, back_corr_norm_disp_diff, err_back_corr_norm_disp, model_norm_disp, model_s])
else:
model_s = input_model.S[input_model.indx[bpm_name]]
model_norm_disp = input_model.DX[input_model.indx[bpm_name]] / sqrt(input_model.BETX[input_model.indx[bpm_name]])
average_norm_disp, final_norm_disp_err = weighted_average_for_SbS_elements(prop_norm_disp, prop_norm_disp_err, back_prop_norm_disp, back_prop_norm_disp_err)
file_norm_disp_x.add_table_row([bpm_name, bpm_s, average_norm_disp, final_norm_disp_err, model_norm_disp, model_s])
if bpm_name == element_name:
summary_data = [average_norm_disp, final_norm_disp_err, model_norm_disp]
file_norm_disp_x.write_to_file()
return summary_data
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_dispersion_for_plane(file_dispersion, plane, element_name, bpms_list, measured_dispersion, input_model, model_cor, model_propagation, model_back_propagation, model_back_cor, is_element):
summary_data = []
first_bpm = bpms_list[0][1]
last_bpm = bpms_list[-1][1]
for bpm in bpms_list:
bpm_s = bpm[0]
bpm_name = bpm[1]
delta_phase = (getattr(model_propagation, "MU" + plane)[model_propagation.indx[bpm_name]]) % 1
delta_phase_back = (getattr(model_back_propagation, "MU" + plane)[model_back_propagation.indx[bpm_name]]) % 1
normal_prop_disp = getattr(model_propagation, "D" + plane)[model_propagation.indx[bpm_name]]
back_prop_disp = getattr(model_back_propagation, "D" + plane)[model_back_propagation.indx[bpm_name]]
prop_disp_p = getattr(model_propagation, "DP" + plane)[model_propagation.indx[bpm_name]]
back_prop_disp_p = getattr(model_back_propagation, "DP" + plane)[model_back_propagation.indx[bpm_name]]
prop_disp_p_err = 1e-8 # TODO: Propagate?
back_prop_disp_p_err = 1e-8 # TODO: Propagate?
normal_prop_disp_err = _propagate_error_dispersion(getattr(measured_dispersion, "STDD" + plane)[measured_dispersion.indx[first_bpm]],
getattr(model_propagation, "BET" + plane)[model_propagation.indx[first_bpm]],
getattr(model_propagation, "BET" + plane)[model_propagation.indx[bpm_name]],
delta_phase,
getattr(model_propagation, "ALF" + plane)[model_propagation.indx[first_bpm]])
back_prop_disp_err = _propagate_error_dispersion(getattr(measured_dispersion, "STDD" + plane)[measured_dispersion.indx[last_bpm]],
getattr(model_back_propagation, "BET" + plane)[model_back_propagation.indx[last_bpm]],
getattr(model_back_propagation, "BET" + plane)[model_back_propagation.indx[bpm_name]],
delta_phase_back,
getattr(model_back_propagation, "ALF" + plane)[model_back_propagation.indx[last_bpm]])
if not is_element:
model_s = measured_dispersion.S[measured_dispersion.indx[bpm_name]]
model_disp = (getattr(measured_dispersion, "D" + plane + "MDL"))[measured_dispersion.indx[bpm_name]]
model_disp_p = (getattr(measured_dispersion, "DP" + plane + "MDL"))[measured_dispersion.indx[bpm_name]]
prop_disp_diff = getattr(measured_dispersion, "D" + plane)[measured_dispersion.indx[bpm_name]] - normal_prop_disp
back_prop_disp_diff = getattr(measured_dispersion, "D" + plane)[measured_dispersion.indx[bpm_name]] - back_prop_disp
measured_disp_std = getattr(measured_dispersion, "STDD" + plane)[measured_dispersion.indx[bpm_name]]
prop_disp_diff_err = math.sqrt(measured_disp_std ** 2 + normal_prop_disp_err ** 2)
back_prop_disp_diff_err = math.sqrt(measured_disp_std ** 2 + back_prop_disp_err ** 2)
delta_phase_corr = (getattr(model_cor, "MU" + plane)[model_cor.indx[bpm_name]]) % 1
delta_phase_back_corr = (getattr(model_back_cor, "MU" + plane)[model_back_cor.indx[bpm_name]]) % 1
corr_disp = getattr(model_cor, "D" + plane)[model_cor.indx[bpm_name]]
corr_disp_err = _propagate_error_dispersion(getattr(measured_dispersion, "STDD" + plane)[measured_dispersion.indx[last_bpm]],
getattr(model_cor, "BET" + plane)[model_cor.indx[last_bpm]],
getattr(model_cor, "BET" + plane)[model_cor.indx[bpm_name]],
delta_phase_corr,
getattr(model_back_propagation, "ALF" + plane)[model_cor.indx[last_bpm]])
corr_disp_diff = corr_disp - normal_prop_disp
corr_disp_diff_err = math.sqrt(measured_disp_std ** 2 + corr_disp_err ** 2)
back_corr_prop_disp = getattr(model_back_cor, "D" + plane)[model_back_cor.indx[bpm_name]]
back_corr_prop_disp_err = _propagate_error_dispersion(getattr(measured_dispersion, "STDD" + plane)[measured_dispersion.indx[last_bpm]],
getattr(model_back_cor, "BET" + plane)[model_back_cor.indx[last_bpm]],
getattr(model_back_cor, "BET" + plane)[model_back_cor.indx[bpm_name]],
delta_phase_back_corr,
getattr(model_back_cor, "ALF" + plane)[model_back_cor.indx[last_bpm]])
back_corr_disp_diff = back_corr_prop_disp - back_prop_disp
back_corr_disp_diff_err = math.sqrt(measured_disp_std ** 2 + back_corr_prop_disp_err ** 2)
measured_disp_p_std = getattr(measured_dispersion, "STDD" + plane)[measured_dispersion.indx[bpm_name]]
prop_disp_p_diff = getattr(measured_dispersion, "DP" + plane)[measured_dispersion.indx[bpm_name]] - prop_disp_p
prop_disp_p_diff_err = math.sqrt(measured_disp_p_std ** 2 + prop_disp_p_err ** 2)
back_prop_disp_p_diff = getattr(measured_dispersion, "DP" + plane)[measured_dispersion.indx[bpm_name]] - back_prop_disp_p
back_prop_disp_p_diff_err = math.sqrt(measured_disp_p_std ** 2 + back_prop_disp_p_err ** 2)
corr_disp_p = getattr(model_cor, "DP" + plane)[model_cor.indx[bpm_name]]
corr_disp_p_err = 1e-8 # TODO: propagate?
corr_disp_p_diff = corr_disp_p - prop_disp_p
corr_disp_p_diff_err = math.sqrt(measured_disp_p_std ** 2 + corr_disp_p_err ** 2)
back_corr_disp_p = getattr(model_back_cor, "DP" + plane)[model_back_cor.indx[bpm_name]]
back_corr_disp_p_err = 1e-8 # TODO: propagate?
back_corr_disp_p_diff = back_corr_disp_p - back_prop_disp_p
back_corr_disp_p_diff_err = math.sqrt(measured_disp_p_std ** 2 + back_corr_disp_p_err ** 2)
file_dispersion.add_table_row([bpm_name, bpm_s,
prop_disp_diff, prop_disp_diff_err, corr_disp_diff, corr_disp_diff_err,
back_prop_disp_diff, back_prop_disp_diff_err, back_corr_disp_diff, back_corr_disp_diff_err,
prop_disp_p_diff, prop_disp_p_diff_err, corr_disp_p_diff, corr_disp_p_diff_err,
back_prop_disp_p_diff, back_prop_disp_p_diff_err, back_corr_disp_p_diff, back_corr_disp_p_diff_err,
model_disp, model_disp_p, model_s])
else:
model_s = input_model.S[input_model.indx[bpm_name]]
model_disp = (getattr(input_model, "D" + plane))[input_model.indx[bpm_name]]
model_disp_p = (getattr(input_model, "DP" + plane))[input_model.indx[bpm_name]]
average_disp, final_disp_err = weighted_average_for_SbS_elements(normal_prop_disp, normal_prop_disp_err, back_prop_disp, back_prop_disp_err)
average_disp_p, final_disp_p_err = weighted_average_for_SbS_elements(prop_disp_p, prop_disp_p_err, back_prop_disp_p, back_prop_disp_p_err)
file_dispersion.add_table_row([bpm_name, bpm_s, average_disp, final_disp_err, average_disp_p, final_disp_p_err, model_disp, model_disp_p, model_s])
if bpm_name == element_name:
summary_data = [bpm_name, bpm_s, average_disp, final_disp_err, average_disp_p, final_disp_p_err, model_disp, model_disp_p, model_s]
file_dispersion.write_to_file()
return summary_data
def _write_C_terms(file_C_terms, element_name, is_element, bpms_list,
measured_coupling, input_model, model_propagation,
model_back_propagation, model_cor, model_back_cor):
summary_data = []
for bpm in bpms_list:
bpm_s = bpm[0]
bpm_name = bpm[1]
prop_c11, prop_c12, prop_c21, prop_c22 = model_propagation.C[
model_propagation.indx[bpm_name]]
err_prop_c11, err_prop_c12, err_prop_c21, err_prop_c22 = [
1e-8, 1e-8, 1e-8, 1e-8
] # TODO: propagate errors
back_c11, back_c12, back_c21, back_c22 = model_back_propagation.C[
model_back_propagation.indx[bpm_name]]
err_back_c11, err_back_c12, err_back_c21, err_back_c22 = [
1e-8, 1e-8, 1e-8, 1e-8
] # TODO: propagate errors
if not is_element:
model_s = measured_coupling.S[measured_coupling.indx[bpm_name]]
cor_c11, cor_c12, cor_c21, cor_c22 = model_cor.C[
model_cor.indx[bpm_name]]
err_cor_c11, err_cor_c12, err_cor_c21, err_cor_c22 = [
1e-8, 1e-8, 1e-8, 1e-8
] # TODO: propagate errors
back_cor_c11, back_cor_c12, back_cor_c21, back_cor_c22 = model_back_cor.C[
model_back_cor.indx[bpm_name]]
err_back_cor_c11, err_back_cor_c12, err_back_cor_c21, err_back_cor_c22 = [
1e-8, 1e-8, 1e-8, 1e-8
] # TODO: propagate errors
file_C_terms.add_table_row([
bpm_name, bpm_s, prop_c11, err_prop_c11, prop_c12,
err_prop_c12, prop_c21, err_prop_c21, prop_c22, err_prop_c22,
cor_c11, err_cor_c11, cor_c12, err_cor_c12, cor_c21,
err_cor_c21, cor_c22, err_cor_c22, back_c11, err_back_c11,
back_c12, err_back_c12, back_c21, err_back_c21, back_c22,
err_back_c22, back_cor_c11, err_back_cor_c11, back_cor_c12,
err_back_cor_c12, back_cor_c21, err_back_cor_c21, back_cor_c22,
err_back_cor_c22, model_s
])
else:
model_s = input_model.S[input_model.indx[bpm_name]]
average_c11, final_err_c11 = weighted_average_for_SbS_elements(
prop_c11, err_prop_c11, back_c11, err_back_c11)
average_c12, final_err_c12 = weighted_average_for_SbS_elements(
prop_c12, err_prop_c12, back_c12, err_back_c12)
average_c21, final_err_c21 = weighted_average_for_SbS_elements(
prop_c21, err_prop_c21, back_c21, err_back_c21)
average_c21, final_err_c21 = weighted_average_for_SbS_elements(
prop_c22, err_prop_c22, back_c22, err_back_c22)
file_C_terms.add_table_row([
bpm_name, bpm_s, average_c11, final_err_c11, average_c12,
final_err_c12, average_c21, final_err_c21, average_c21,
final_err_c21, model_s
])
if bpm_name == element_name:
summary_data = [
bpm_name, bpm_s, average_c11, final_err_c11, average_c12,
final_err_c12, average_c21, final_err_c21, average_c21,
final_err_c21, model_s
]
file_C_terms.write_to_file()
return summary_data
def _write_f_terms(file_f_terms, element_name, is_element, bpms_list,
measured_coupling, input_model, model_propagation,
model_back_propagation, model_cor, model_back_cor):
summary_data = []
first_bpm = bpms_list[0][1]
last_bpm = bpms_list[-1][1]
(f1001ab_ini, f1001_std_ini, p1001_ini, p1001_std_ini, f1001ab_end,
f1001_std_end, p1001_end,
p1001_std_end) = _get_start_end_f1001(measured_coupling, first_bpm,
last_bpm)
(f1010ab_ini, f1010_std_ini, p1010_ini, p1010_std_ini, f1010ab_end,
f1010_std_end, p1010_end,
p1010_std_end) = _get_start_end_f1010(measured_coupling, first_bpm,
last_bpm)
if input_model is not None:
input_model.Cmatrix()
for bpm in bpms_list:
bpm_s = bpm[0]
bpm_name = bpm[1]
delta_phase_prop_x = model_propagation.MUX[
model_propagation.indx[bpm_name]] % 1
delta_phase_prop_y = model_propagation.MUY[
model_propagation.indx[bpm_name]] % 1
f1001_prop = model_propagation.f1001[model_propagation.indx[bpm_name]]
err_f1001re_prop = _propagate_error_coupling_1001_re(
f1001ab_ini, p1001_ini, delta_phase_prop_x, delta_phase_prop_y,
f1001_std_ini, p1001_std_ini)
err_f1001im_prop = _propagate_error_coupling_1001_im(
f1001ab_ini, p1001_ini, delta_phase_prop_x, delta_phase_prop_y,
f1001_std_ini, p1001_std_ini)
err_f1001abs_prop = f1001_std_ini
f1010_prop = model_propagation.f1010[model_propagation.indx[bpm_name]]
err_f1010re_prop = _propagate_error_coupling_1010_re(
f1010ab_ini, p1010_ini, delta_phase_prop_x, delta_phase_prop_y,
f1010_std_ini, p1010_std_ini)
err_f1010im_prop = _propagate_error_coupling_1010_im(
f1010ab_ini, p1010_ini, delta_phase_prop_x, delta_phase_prop_y,
f1010_std_ini, p1010_std_ini)
err_f1010abs_prop = f1010_std_ini
delta_phase_back_x = model_back_propagation.MUX[
model_back_propagation.indx[bpm_name]] % 1
delta_phase_back_y = model_back_propagation.MUY[
model_back_propagation.indx[bpm_name]] % 1
f1001_back = model_back_propagation.f1001[
model_back_propagation.indx[bpm_name]]
err_f1001re_back = _propagate_error_coupling_1001_re(
f1001ab_end, p1001_end, delta_phase_back_x, delta_phase_back_y,
f1001_std_end, p1001_std_end)
err_f1001im_back = _propagate_error_coupling_1001_im(
f1001ab_end, p1001_end, delta_phase_back_x, delta_phase_back_y,
f1001_std_end, p1001_std_end)
err_f1001abs_back = f1001_std_end
f1010_back = model_back_propagation.f1010[
model_back_propagation.indx[bpm_name]]
err_f1010re_back = _propagate_error_coupling_1010_re(
f1010ab_end, p1010_end, delta_phase_back_x, delta_phase_back_y,
f1010_std_end, p1010_std_end)
err_f1010im_back = _propagate_error_coupling_1010_im(
f1010ab_end, p1010_end, delta_phase_back_x, delta_phase_back_y,
f1010_std_end, p1010_std_end)
err_f1010abs_back = f1010_std_end
if not is_element:
model_s = measured_coupling.S[measured_coupling.indx[bpm_name]]
model_f1001r = measured_coupling.MDLF1001R[
measured_coupling.indx[bpm_name]]
model_f1001i = measured_coupling.MDLF1001I[
measured_coupling.indx[bpm_name]]
model_f1010r = measured_coupling.MDLF1010R[
measured_coupling.indx[bpm_name]]
model_f1010i = measured_coupling.MDLF1010I[
measured_coupling.indx[bpm_name]]
meas_abs_f1001 = measured_coupling.F1001W[
measured_coupling.indx[bpm_name]]
meas_q1001 = measured_coupling.Q1001[
measured_coupling.indx[bpm_name]]
meas_f1001r = measured_coupling.F1001R[
measured_coupling.indx[bpm_name]]
meas_f1001i = measured_coupling.F1001I[
measured_coupling.indx[bpm_name]]
err_meas_abs_f1001 = measured_coupling.FWSTD1[
measured_coupling.indx[bpm_name]]
err_meas_q1001 = measured_coupling.Q1001STD[
measured_coupling.indx[bpm_name]]
err_meas_f1001r = _propagate_error_coupling_1001_re(
meas_abs_f1001, meas_q1001, 0., 0., err_meas_abs_f1001,
err_meas_q1001)
err_meas_f1001i = _propagate_error_coupling_1001_im(
meas_abs_f1001, meas_q1001, 0., 0., err_meas_abs_f1001,
err_meas_q1001)
meas_abs_f1010 = measured_coupling.F1010W[
measured_coupling.indx[bpm_name]]
meas_q1010 = measured_coupling.Q1010[
measured_coupling.indx[bpm_name]]
meas_f1010r = measured_coupling.F1010R[
measured_coupling.indx[bpm_name]]
meas_f1010i = measured_coupling.F1010I[
measured_coupling.indx[bpm_name]]
err_meas_abs_f1010 = measured_coupling.FWSTD1[
measured_coupling.indx[bpm_name]]
err_meas_q1010 = measured_coupling.Q1010STD[
measured_coupling.indx[bpm_name]]
err_meas_f1010r = _propagate_error_coupling_1010_re(
meas_abs_f1010, meas_q1010, 0., 0., err_meas_abs_f1010,
err_meas_q1010)
err_meas_f1010i = _propagate_error_coupling_1010_im(
meas_abs_f1010, meas_q1010, 0., 0., err_meas_abs_f1010,
err_meas_q1010)
delta_phase_corr_x = model_cor.MUX[model_cor.indx[bpm_name]] % 1
delta_phase_corr_y = model_cor.MUY[model_cor.indx[bpm_name]] % 1
f1001_corr = model_cor.f1001[model_cor.indx[bpm_name]]
err_f1001re_corr = _propagate_error_coupling_1001_re(
f1001ab_ini, p1001_ini, delta_phase_corr_x, delta_phase_corr_y,
f1001_std_ini, p1001_std_ini)
err_f1001im_corr = _propagate_error_coupling_1001_im(
f1001ab_ini, p1001_ini, delta_phase_corr_x, delta_phase_corr_y,
f1001_std_ini, p1001_std_ini)
err_f1001abs_corr = f1001_std_ini
f1010_corr = model_cor.f1010[model_cor.indx[bpm_name]]
err_f1010re_corr = _propagate_error_coupling_1010_re(
f1010ab_ini, p1010_ini, delta_phase_corr_x, delta_phase_corr_y,
f1010_std_ini, p1010_std_ini)
err_f1010im_corr = _propagate_error_coupling_1010_im(
f1010ab_ini, p1010_ini, delta_phase_corr_x, delta_phase_corr_y,
f1010_std_ini, p1010_std_ini)
err_f1010abs_corr = f1010_std_ini
delta_phase_back_corr_x = model_back_cor.MUX[
model_back_cor.indx[bpm_name]] % 1
delta_phase_back_corr_y = model_back_cor.MUY[
model_back_cor.indx[bpm_name]] % 1
f1001_back_corr = model_back_cor.f1001[
model_back_cor.indx[bpm_name]]
err_f1001re_back_corr = _propagate_error_coupling_1001_re(
f1001ab_end, p1001_end, delta_phase_back_corr_x,
delta_phase_back_corr_y, f1001_std_end, p1001_std_end)
err_f1001im_back_corr = _propagate_error_coupling_1001_im(
f1001ab_end, p1001_end, delta_phase_back_corr_x,
delta_phase_back_corr_y, f1001_std_end, p1001_std_end)
err_f1001abs_back_corr = f1001_std_end
f1010_back_corr = model_back_cor.f1010[
model_back_cor.indx[bpm_name]]
err_f1010re_back_corr = _propagate_error_coupling_1010_re(
f1010ab_end, p1010_end, delta_phase_back_corr_x,
delta_phase_back_corr_y, f1010_std_end, p1010_std_end)
err_f1010im_back_corr = _propagate_error_coupling_1010_im(
f1010ab_end, p1010_end, delta_phase_back_corr_x,
delta_phase_back_corr_y, f1010_std_end, p1010_std_end)
err_f1010abs_back_corr = f1010_std_end
file_f_terms.add_table_row([
bpm_name, bpm_s, meas_abs_f1001, err_meas_abs_f1001,
meas_f1001r, err_meas_f1001r, meas_f1001i, err_meas_f1001i,
meas_abs_f1010, err_meas_abs_f1010, meas_f1010r,
err_meas_f1010r, meas_f1010i, err_meas_f1010i,
abs(f1001_corr), err_f1001abs_corr, f1001_corr.real,
err_f1001re_corr, f1001_corr.imag, err_f1001im_corr,
abs(f1010_corr), err_f1010abs_corr, f1010_corr.real,
err_f1010re_corr, f1010_corr.imag, err_f1010im_corr,
abs(f1001_back), err_f1001abs_back, f1001_back.real,
err_f1001re_back, f1001_back.imag, err_f1001im_back,
abs(f1010_back), err_f1010abs_back, f1010_back.real,
err_f1010re_back, f1010_back.imag, err_f1010im_back,
abs(f1001_back_corr), err_f1001abs_back_corr,
f1001_back_corr.real, err_f1001re_back_corr,
f1001_back_corr.imag, err_f1001im_back_corr,
abs(f1010_back_corr), err_f1010abs_back_corr,
f1010_back_corr.real, err_f1010re_back_corr,
f1010_back_corr.imag, err_f1010im_back_corr, model_f1001r,
model_f1001i, model_f1010r, model_f1010i, model_s
])
else:
model_s = input_model.S[input_model.indx[bpm_name]]
model_f1001r = input_model.f1001[input_model.indx[bpm_name]].real
model_f1001i = input_model.f1001[input_model.indx[bpm_name]].imag
model_f1010r = input_model.f1010[input_model.indx[bpm_name]].real
model_f1010i = input_model.f1010[input_model.indx[bpm_name]].imag
average_f1001ab, final_f1001abs_err = weighted_average_for_SbS_elements(
abs(f1001_prop), err_f1001abs_prop, abs(f1001_back),
err_f1001abs_back)
average_f1001re, final_f1001re_err = weighted_average_for_SbS_elements(
f1001_prop.real, err_f1001re_prop, f1001_back.real,
err_f1001re_back)
average_f1001im, final_f1001im_err = weighted_average_for_SbS_elements(
f1001_prop.imag, err_f1001im_prop, f1001_back.imag,
err_f1001im_back)
average_f1010ab, final_f1010abs_err = weighted_average_for_SbS_elements(
abs(f1010_prop), err_f1010abs_prop, abs(f1010_back),
err_f1010abs_back)
average_f1010re, final_f1010re_err = weighted_average_for_SbS_elements(
f1010_prop.real, err_f1010re_prop, f1010_back.real,
err_f1010re_back)
average_f1010im, final_f1010im_err = weighted_average_for_SbS_elements(
f1010_prop.imag, err_f1010im_prop, f1010_back.imag,
err_f1010im_back)
file_f_terms.add_table_row([
bpm_name, bpm_s, average_f1001ab, final_f1001abs_err,
average_f1001re, final_f1001re_err, average_f1001im,
final_f1001im_err, average_f1010ab, final_f1010abs_err,
average_f1010re, final_f1010re_err, average_f1010im,
final_f1010im_err, model_f1001r, model_f1001i, model_f1010r,
model_f1010i, model_s
])
if bpm_name == element_name:
summary_data = [
bpm_name, bpm_s, average_f1001ab, final_f1001abs_err,
average_f1001re, final_f1001re_err, average_f1001im,
final_f1001im_err, average_f1010ab, final_f1010abs_err,
average_f1010re, final_f1010re_err, average_f1010im,
final_f1010im_err, model_f1001r, model_f1001i,
model_f1010r, model_f1010i, model_s
]
file_f_terms.write_to_file()
return summary_data
def _write_chromatic_w_for_plane(file_chromatic, plane, element_name,
bpms_list, measured_chromatic_w, input_model,
model_propagation, model_cor,
model_back_propagation, model_back_cor,
save_path, is_element):
summary_data = []
for bpm in bpms_list:
bpm_s = bpm[0]
bpm_name = bpm[1]
model_s = input_model.S[input_model.indx[bpm_name]]
model_w = getattr(input_model, "W" + plane)[input_model.indx[bpm_name]]
model_phi = getattr(input_model,
"PHI" + plane)[input_model.indx[bpm_name]]
w_prop = getattr(model_propagation,
"W" + plane)[model_propagation.indx[bpm_name]]
phi_prop = getattr(model_propagation,
"PHI" + plane)[model_propagation.indx[bpm_name]]
err_w_prop = 1e-8 # TODO: Propagate
err_phi_prop = 1e-8 # TODO: Propagate
w_back = getattr(model_back_propagation,
"W" + plane)[model_back_propagation.indx[bpm_name]]
phi_back = getattr(model_back_propagation, "PHI" +
plane)[model_back_propagation.indx[bpm_name]]
err_w_back = 1e-8 # TODO: Propagate
err_phi_back = 1e-8 # TODO: Propagate
if not is_element:
w_cor = getattr(model_cor, "W" + plane)[model_cor.indx[bpm_name]]
phi_cor = getattr(model_cor,
"PHI" + plane)[model_cor.indx[bpm_name]]
err_w_cor = 1e-8 # TODO: Propagate
err_phi_cor = 1e-8 # TODO: Propagate
w_back_cor = getattr(model_back_cor,
"W" + plane)[model_back_cor.indx[bpm_name]]
phi_back_cor = getattr(model_back_cor, "PHI" +
plane)[model_back_cor.indx[bpm_name]]
err_w_back_cor = 1e-8 # TODO: Propagate
err_phi_back_cor = 1e-8 # TODO: Propagate
file_chromatic.add_table_row([
bpm_name, bpm_s, w_prop, err_w_prop, phi_prop, err_phi_prop,
w_cor, err_w_cor, phi_cor, err_phi_cor, w_back, err_w_back,
phi_back, err_phi_back, w_back_cor, err_w_back_cor,
phi_back_cor, err_phi_back_cor, model_w, model_phi, model_s
])
else:
average_w, final_err_w = weighted_average_for_SbS_elements(
w_prop, err_w_prop, w_back, err_w_prop)
average_phi, final_err_phi = weighted_average_for_SbS_elements(
phi_prop, err_phi_prop, phi_back, err_phi_prop)
file_chromatic.add_table_row([
bpm_name, bpm_s, average_w, final_err_w, average_phi,
final_err_phi, model_w, model_phi, model_s
])
if element_name == bpm_name:
summary_data = [
bpm_name, bpm_s, average_w, final_err_w, average_phi,
final_err_phi, model_w, model_phi, model_s
]
file_chromatic.write_to_file()
return summary_data
def _write_dispersion_for_plane(file_dispersion, plane, element_name, bpms_list, measured_dispersion, input_model, model_cor, model_propagation, model_back_propagation, model_back_cor, is_element):
summary_data = []
first_bpm = bpms_list[0][1]
last_bpm = bpms_list[-1][1]
for bpm in bpms_list:
bpm_s = bpm[0]
bpm_name = bpm[1]
delta_phase = (getattr(model_propagation, "MU" + plane)[model_propagation.indx[bpm_name]]) % 1
delta_phase_back = (getattr(model_back_propagation, "MU" + plane)[model_back_propagation.indx[bpm_name]]) % 1
normal_prop_disp = getattr(model_propagation, "D" + plane)[model_propagation.indx[bpm_name]]
back_prop_disp = getattr(model_back_propagation, "D" + plane)[model_back_propagation.indx[bpm_name]]
prop_disp_p = getattr(model_propagation, "DP" + plane)[model_propagation.indx[bpm_name]]
back_prop_disp_p = getattr(model_back_propagation, "DP" + plane)[model_back_propagation.indx[bpm_name]]
prop_disp_p_err = 1e-8 # TODO: Propagate?
back_prop_disp_p_err = 1e-8 # TODO: Propagate?
normal_prop_disp_err = _propagate_error_dispersion(getattr(measured_dispersion, "STDD" + plane)[measured_dispersion.indx[first_bpm]],
getattr(model_propagation, "BET" + plane)[model_propagation.indx[first_bpm]],
getattr(model_propagation, "BET" + plane)[model_propagation.indx[bpm_name]],
delta_phase,
getattr(model_propagation, "ALF" + plane)[model_propagation.indx[first_bpm]])
back_prop_disp_err = _propagate_error_dispersion(getattr(measured_dispersion, "STDD" + plane)[measured_dispersion.indx[last_bpm]],
getattr(model_back_propagation, "BET" + plane)[model_back_propagation.indx[last_bpm]],
getattr(model_back_propagation, "BET" + plane)[model_back_propagation.indx[bpm_name]],
delta_phase_back,
getattr(model_back_propagation, "ALF" + plane)[model_back_propagation.indx[last_bpm]])
if not is_element:
model_s = measured_dispersion.S[measured_dispersion.indx[bpm_name]]
model_disp = (getattr(measured_dispersion, "D" + plane + "MDL"))[measured_dispersion.indx[bpm_name]]
model_disp_p = (getattr(measured_dispersion, "DP" + plane + "MDL"))[measured_dispersion.indx[bpm_name]]
prop_disp_diff = getattr(measured_dispersion, "D" + plane)[measured_dispersion.indx[bpm_name]] - normal_prop_disp
back_prop_disp_diff = getattr(measured_dispersion, "D" + plane)[measured_dispersion.indx[bpm_name]] - back_prop_disp
measured_disp_std = getattr(measured_dispersion, "STDD" + plane)[measured_dispersion.indx[bpm_name]]
prop_disp_diff_err = math.sqrt(measured_disp_std ** 2 + normal_prop_disp_err ** 2)
back_prop_disp_diff_err = math.sqrt(measured_disp_std ** 2 + back_prop_disp_err ** 2)
delta_phase_corr = (getattr(model_cor, "MU" + plane)[model_cor.indx[bpm_name]]) % 1
delta_phase_back_corr = (getattr(model_back_cor, "MU" + plane)[model_back_cor.indx[bpm_name]]) % 1
corr_disp = getattr(model_cor, "D" + plane)[model_cor.indx[bpm_name]]
corr_disp_err = _propagate_error_dispersion(getattr(measured_dispersion, "STDD" + plane)[measured_dispersion.indx[last_bpm]],
getattr(model_cor, "BET" + plane)[model_cor.indx[last_bpm]],
getattr(model_cor, "BET" + plane)[model_cor.indx[bpm_name]],
delta_phase_corr,
getattr(model_back_propagation, "ALF" + plane)[model_cor.indx[last_bpm]])
corr_disp_diff = corr_disp - normal_prop_disp
corr_disp_diff_err = math.sqrt(measured_disp_std ** 2 + corr_disp_err ** 2)
back_corr_prop_disp = getattr(model_back_cor, "D" + plane)[model_back_cor.indx[bpm_name]]
back_corr_prop_disp_err = _propagate_error_dispersion(getattr(measured_dispersion, "STDD" + plane)[measured_dispersion.indx[last_bpm]],
getattr(model_back_cor, "BET" + plane)[model_back_cor.indx[last_bpm]],
getattr(model_back_cor, "BET" + plane)[model_back_cor.indx[bpm_name]],
delta_phase_back_corr,
getattr(model_back_cor, "ALF" + plane)[model_back_cor.indx[last_bpm]])
back_corr_disp_diff = back_corr_prop_disp - back_prop_disp
back_corr_disp_diff_err = math.sqrt(measured_disp_std ** 2 + back_corr_prop_disp_err ** 2)
measured_disp_p_std = getattr(measured_dispersion, "STDD" + plane)[measured_dispersion.indx[bpm_name]]
prop_disp_p_diff = getattr(measured_dispersion, "DP" + plane)[measured_dispersion.indx[bpm_name]] - prop_disp_p
prop_disp_p_diff_err = math.sqrt(measured_disp_p_std ** 2 + prop_disp_p_err ** 2)
back_prop_disp_p_diff = getattr(measured_dispersion, "DP" + plane)[measured_dispersion.indx[bpm_name]] - back_prop_disp_p
back_prop_disp_p_diff_err = math.sqrt(measured_disp_p_std ** 2 + back_prop_disp_p_err ** 2)
corr_disp_p = getattr(model_cor, "DP" + plane)[model_cor.indx[bpm_name]]
corr_disp_p_err = 1e-8 # TODO: propagate?
corr_disp_p_diff = corr_disp_p - prop_disp_p
corr_disp_p_diff_err = math.sqrt(measured_disp_p_std ** 2 + corr_disp_p_err ** 2)
back_corr_disp_p = getattr(model_back_cor, "DP" + plane)[model_back_cor.indx[bpm_name]]
back_corr_disp_p_err = 1e-8 # TODO: propagate?
back_corr_disp_p_diff = back_corr_disp_p - back_prop_disp_p
back_corr_disp_p_diff_err = math.sqrt(measured_disp_p_std ** 2 + back_corr_disp_p_err ** 2)
file_dispersion.add_table_row([bpm_name, bpm_s,
prop_disp_diff, prop_disp_diff_err, corr_disp_diff, corr_disp_diff_err,
back_prop_disp_diff, back_prop_disp_diff_err, back_corr_disp_diff, back_corr_disp_diff_err,
prop_disp_p_diff, prop_disp_p_diff_err, corr_disp_p_diff, corr_disp_p_diff_err,
back_prop_disp_p_diff, back_prop_disp_p_diff_err, back_corr_disp_p_diff, back_corr_disp_p_diff_err,
model_disp, model_disp_p, model_s])
else:
model_s = input_model.S[input_model.indx[bpm_name]]
model_disp = (getattr(input_model, "D" + plane))[input_model.indx[bpm_name]]
model_disp_p = (getattr(input_model, "DP" + plane))[input_model.indx[bpm_name]]
average_disp, final_disp_err = weighted_average_for_SbS_elements(normal_prop_disp, normal_prop_disp_err, back_prop_disp, back_prop_disp_err)
average_disp_p, final_disp_p_err = weighted_average_for_SbS_elements(prop_disp_p, prop_disp_p_err, back_prop_disp_p, back_prop_disp_p_err)
file_dispersion.add_table_row([bpm_name, bpm_s, average_disp, final_disp_err, average_disp_p, final_disp_p_err, model_disp, model_disp_p, model_s])
if bpm_name == element_name:
summary_data = [bpm_name, bpm_s, average_disp, final_disp_err, average_disp_p, final_disp_p_err, model_disp, model_disp_p, model_s]
file_dispersion.write_to_file()
return summary_data
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_f_terms(file_f_terms, element_name, is_element, bpms_list, measured_coupling, input_model, model_propagation, model_back_propagation, model_cor, model_back_cor):
summary_data = []
first_bpm = bpms_list[0][1]
last_bpm = bpms_list[-1][1]
(f1001ab_ini, f1001_std_ini, p1001_ini, p1001_std_ini,
f1001ab_end, f1001_std_end, p1001_end, p1001_std_end) = _get_start_end_f1001(measured_coupling, first_bpm, last_bpm)
(f1010ab_ini, f1010_std_ini, p1010_ini, p1010_std_ini,
f1010ab_end, f1010_std_end, p1010_end, p1010_std_end) = _get_start_end_f1010(measured_coupling, first_bpm, last_bpm)
if input_model is not None:
input_model.Cmatrix()
for bpm in bpms_list:
bpm_s = bpm[0]
bpm_name = bpm[1]
delta_phase_prop_x = model_propagation.MUX[model_propagation.indx[bpm_name]] % 1
delta_phase_prop_y = model_propagation.MUY[model_propagation.indx[bpm_name]] % 1
f1001_prop = model_propagation.f1001[model_propagation.indx[bpm_name]]
err_f1001re_prop = _propagate_error_coupling_1001_re(f1001ab_ini, p1001_ini, delta_phase_prop_x, delta_phase_prop_y, f1001_std_ini, p1001_std_ini)
err_f1001im_prop = _propagate_error_coupling_1001_im(f1001ab_ini, p1001_ini, delta_phase_prop_x, delta_phase_prop_y, f1001_std_ini, p1001_std_ini)
err_f1001abs_prop = f1001_std_ini
f1010_prop = model_propagation.f1010[model_propagation.indx[bpm_name]]
err_f1010re_prop = _propagate_error_coupling_1010_re(f1010ab_ini, p1010_ini, delta_phase_prop_x, delta_phase_prop_y, f1010_std_ini, p1010_std_ini)
err_f1010im_prop = _propagate_error_coupling_1010_im(f1010ab_ini, p1010_ini, delta_phase_prop_x, delta_phase_prop_y, f1010_std_ini, p1010_std_ini)
err_f1010abs_prop = f1010_std_ini
delta_phase_back_x = model_back_propagation.MUX[model_back_propagation.indx[bpm_name]] % 1
delta_phase_back_y = model_back_propagation.MUY[model_back_propagation.indx[bpm_name]] % 1
f1001_back = model_back_propagation.f1001[model_back_propagation.indx[bpm_name]]
err_f1001re_back = _propagate_error_coupling_1001_re(f1001ab_end, p1001_end, delta_phase_back_x, delta_phase_back_y, f1001_std_end, p1001_std_end)
err_f1001im_back = _propagate_error_coupling_1001_im(f1001ab_end, p1001_end, delta_phase_back_x, delta_phase_back_y, f1001_std_end, p1001_std_end)
err_f1001abs_back = f1001_std_end
f1010_back = model_back_propagation.f1010[model_back_propagation.indx[bpm_name]]
err_f1010re_back = _propagate_error_coupling_1010_re(f1010ab_end, p1010_end, delta_phase_back_x, delta_phase_back_y, f1010_std_end, p1010_std_end)
err_f1010im_back = _propagate_error_coupling_1010_im(f1010ab_end, p1010_end, delta_phase_back_x, delta_phase_back_y, f1010_std_end, p1010_std_end)
err_f1010abs_back = f1010_std_end
if not is_element:
model_s = measured_coupling.S[measured_coupling.indx[bpm_name]]
model_f1001r = measured_coupling.MDLF1001R[measured_coupling.indx[bpm_name]]
model_f1001i = measured_coupling.MDLF1001I[measured_coupling.indx[bpm_name]]
model_f1010r = measured_coupling.MDLF1010R[measured_coupling.indx[bpm_name]]
model_f1010i = measured_coupling.MDLF1010I[measured_coupling.indx[bpm_name]]
meas_abs_f1001 = measured_coupling.F1001W[measured_coupling.indx[bpm_name]]
meas_q1001 = measured_coupling.Q1001[measured_coupling.indx[bpm_name]]
meas_f1001r = measured_coupling.F1001R[measured_coupling.indx[bpm_name]]
meas_f1001i = measured_coupling.F1001I[measured_coupling.indx[bpm_name]]
err_meas_abs_f1001 = measured_coupling.FWSTD1[measured_coupling.indx[bpm_name]]
err_meas_q1001 = measured_coupling.Q1001STD[measured_coupling.indx[bpm_name]]
err_meas_f1001r = _propagate_error_coupling_1001_re(meas_abs_f1001, meas_q1001, 0., 0., err_meas_abs_f1001, err_meas_q1001)
err_meas_f1001i = _propagate_error_coupling_1001_im(meas_abs_f1001, meas_q1001, 0., 0., err_meas_abs_f1001, err_meas_q1001)
meas_abs_f1010 = measured_coupling.F1010W[measured_coupling.indx[bpm_name]]
meas_q1010 = measured_coupling.Q1010[measured_coupling.indx[bpm_name]]
meas_f1010r = measured_coupling.F1010R[measured_coupling.indx[bpm_name]]
meas_f1010i = measured_coupling.F1010I[measured_coupling.indx[bpm_name]]
err_meas_abs_f1010 = measured_coupling.FWSTD1[measured_coupling.indx[bpm_name]]
err_meas_q1010 = measured_coupling.Q1010STD[measured_coupling.indx[bpm_name]]
err_meas_f1010r = _propagate_error_coupling_1010_re(meas_abs_f1010, meas_q1010, 0., 0., err_meas_abs_f1010, err_meas_q1010)
err_meas_f1010i = _propagate_error_coupling_1010_im(meas_abs_f1010, meas_q1010, 0., 0., err_meas_abs_f1010, err_meas_q1010)
delta_phase_corr_x = model_cor.MUX[model_cor.indx[bpm_name]] % 1
delta_phase_corr_y = model_cor.MUY[model_cor.indx[bpm_name]] % 1
f1001_corr = model_cor.f1001[model_cor.indx[bpm_name]]
err_f1001re_corr = _propagate_error_coupling_1001_re(f1001ab_ini, p1001_ini, delta_phase_corr_x, delta_phase_corr_y, f1001_std_ini, p1001_std_ini)
err_f1001im_corr = _propagate_error_coupling_1001_im(f1001ab_ini, p1001_ini, delta_phase_corr_x, delta_phase_corr_y, f1001_std_ini, p1001_std_ini)
err_f1001abs_corr = f1001_std_ini
f1010_corr = model_cor.f1010[model_cor.indx[bpm_name]]
err_f1010re_corr = _propagate_error_coupling_1010_re(f1010ab_ini, p1010_ini, delta_phase_corr_x, delta_phase_corr_y, f1010_std_ini, p1010_std_ini)
err_f1010im_corr = _propagate_error_coupling_1010_im(f1010ab_ini, p1010_ini, delta_phase_corr_x, delta_phase_corr_y, f1010_std_ini, p1010_std_ini)
err_f1010abs_corr = f1010_std_ini
delta_phase_back_corr_x = model_back_cor.MUX[model_back_cor.indx[bpm_name]] % 1
delta_phase_back_corr_y = model_back_cor.MUY[model_back_cor.indx[bpm_name]] % 1
f1001_back_corr = model_back_cor.f1001[model_back_cor.indx[bpm_name]]
err_f1001re_back_corr = _propagate_error_coupling_1001_re(f1001ab_end, p1001_end, delta_phase_back_corr_x, delta_phase_back_corr_y, f1001_std_end, p1001_std_end)
err_f1001im_back_corr = _propagate_error_coupling_1001_im(f1001ab_end, p1001_end, delta_phase_back_corr_x, delta_phase_back_corr_y, f1001_std_end, p1001_std_end)
err_f1001abs_back_corr = f1001_std_end
f1010_back_corr = model_back_cor.f1010[model_back_cor.indx[bpm_name]]
err_f1010re_back_corr = _propagate_error_coupling_1010_re(f1010ab_end, p1010_end, delta_phase_back_corr_x, delta_phase_back_corr_y, f1010_std_end, p1010_std_end)
err_f1010im_back_corr = _propagate_error_coupling_1010_im(f1010ab_end, p1010_end, delta_phase_back_corr_x, delta_phase_back_corr_y, f1010_std_end, p1010_std_end)
err_f1010abs_back_corr = f1010_std_end
file_f_terms.add_table_row([bpm_name, bpm_s,
meas_abs_f1001, err_meas_abs_f1001, meas_f1001r, err_meas_f1001r, meas_f1001i, err_meas_f1001i,
meas_abs_f1010, err_meas_abs_f1010, meas_f1010r, err_meas_f1010r, meas_f1010i, err_meas_f1010i,
abs(f1001_corr), err_f1001abs_corr, f1001_corr.real, err_f1001re_corr, f1001_corr.imag, err_f1001im_corr,
abs(f1010_corr), err_f1010abs_corr, f1010_corr.real, err_f1010re_corr, f1010_corr.imag, err_f1010im_corr,
abs(f1001_back), err_f1001abs_back, f1001_back.real, err_f1001re_back, f1001_back.imag, err_f1001im_back,
abs(f1010_back), err_f1010abs_back, f1010_back.real, err_f1010re_back, f1010_back.imag, err_f1010im_back,
abs(f1001_back_corr), err_f1001abs_back_corr, f1001_back_corr.real, err_f1001re_back_corr, f1001_back_corr.imag, err_f1001im_back_corr,
abs(f1010_back_corr), err_f1010abs_back_corr, f1010_back_corr.real, err_f1010re_back_corr, f1010_back_corr.imag, err_f1010im_back_corr,
model_f1001r, model_f1001i, model_f1010r, model_f1010i, model_s])
else:
model_s = input_model.S[input_model.indx[bpm_name]]
model_f1001r = input_model.f1001[input_model.indx[bpm_name]].real
model_f1001i = input_model.f1001[input_model.indx[bpm_name]].imag
model_f1010r = input_model.f1010[input_model.indx[bpm_name]].real
model_f1010i = input_model.f1010[input_model.indx[bpm_name]].imag
average_f1001ab, final_f1001abs_err = weighted_average_for_SbS_elements(abs(f1001_prop), err_f1001abs_prop, abs(f1001_back), err_f1001abs_back)
average_f1001re, final_f1001re_err = weighted_average_for_SbS_elements(f1001_prop.real, err_f1001re_prop, f1001_back.real, err_f1001re_back)
average_f1001im, final_f1001im_err = weighted_average_for_SbS_elements(f1001_prop.imag, err_f1001im_prop, f1001_back.imag, err_f1001im_back)
average_f1010ab, final_f1010abs_err = weighted_average_for_SbS_elements(abs(f1010_prop), err_f1010abs_prop, abs(f1010_back), err_f1010abs_back)
average_f1010re, final_f1010re_err = weighted_average_for_SbS_elements(f1010_prop.real, err_f1010re_prop, f1010_back.real, err_f1010re_back)
average_f1010im, final_f1010im_err = weighted_average_for_SbS_elements(f1010_prop.imag, err_f1010im_prop, f1010_back.imag, err_f1010im_back)
file_f_terms.add_table_row([bpm_name, bpm_s,
average_f1001ab, final_f1001abs_err, average_f1001re, final_f1001re_err, average_f1001im, final_f1001im_err,
average_f1010ab, final_f1010abs_err, average_f1010re, final_f1010re_err, average_f1010im, final_f1010im_err,
model_f1001r, model_f1001i, model_f1010r, model_f1010i, model_s])
if bpm_name == element_name:
summary_data = [bpm_name, bpm_s,
average_f1001ab, final_f1001abs_err, average_f1001re, final_f1001re_err, average_f1001im, final_f1001im_err,
average_f1010ab, final_f1010abs_err, average_f1010re, final_f1010re_err, average_f1010im, final_f1010im_err,
model_f1001r, model_f1001i, model_f1010r, model_f1010i, model_s]
file_f_terms.write_to_file()
return summary_data
