def _compare_dirs_with_tfs_comparator(self, valid_dir, to_check_dir):
ignore_names = ["L", "NAME"]
for item in os.listdir(valid_dir):
if not item.startswith("sbs"): # Only check the SbS files
continue
valid_item = os.path.join(valid_dir, item)
to_check_item = os.path.join(to_check_dir, item)
self.assertTrue(os.path.isfile(to_check_item),
"File " + str(to_check_item) + " doesn't exist.")
if os.path.isfile(valid_item) and os.path.isfile(to_check_item):
try:
syserr = sys.stderr
sys.stderr = open(os.devnull, "w")
valid_twiss = metaclass.twiss(valid_item)
to_check_twiss = metaclass.twiss(to_check_item)
sys.stderr = syserr
self.assertTrue(
Utilities.tfs_comparator.compare_tfs(
valid_twiss,
to_check_twiss,
_MAX_RELATIVE_ERROR,
ignore_names=ignore_names),
"Difference found in file: " + to_check_item)
except:
raise
finally:
sys.stderr = syserr
def justtwiss():
#########################
global dictionary
system('madx < job.ORM.madx > scum')
x=twiss('twiss.orbit.dat')
y=twiss('twiss.all.dat')
return x, y
def writeparams(deltafamilie, variables, accel_path, app=0, path="./"):
if (app == 0):
mode = 'w'
if (app == 1):
mode = 'a'
a = datetime.datetime.fromtimestamp(time.time())
if accel_path[-5:] == "LHCB1":
path_B1tfs = os.path.join(accel_path, "varsKLvsK_B1.tfs")
twiss_kl = metaclass.twiss(path_B1tfs)
if accel_path[-5:] == "LHCB2":
path_B2tfs = os.path.join(accel_path, "varsKLvsK_B2.tfs")
twiss_kl = metaclass.twiss(path_B2tfs)
g = open(path + '/changeparameters', mode)
f = open(path + '/changeparameters.tfs', mode)
print >> f, "@", "APP", "%le", app
print >> f, "@", "PATH", "%s", path
print >> f, "@", "DATE", "%s", a.ctime()
print >> f, "*", "NAME", "DELTA"
print >> f, "$", "%s", "%le"
for i, var in enumerate(variables):
if var[0] == "l":
g.write(var[1:] + ' = ' + var[1:] + ' + ( ' +
str((deltafamilie[i] /
twiss_kl.LENGTH[twiss_kl.indx[var]])) + ' );\n')
f.write(var[1:] + ' ' +
str((deltafamilie[i] /
twiss_kl.LENGTH[twiss_kl.indx[var]])) + '\n')
else:
g.write(var + ' = ' + var + ' + ( ' + str(deltafamilie[i]) +
' );\n')
f.write(var + ' ' + str(deltafamilie[i]) + '\n')
g.close()
f.close()
def _compare_output_betas(self, output_path):
print "Comparing output..."
if len(self._errors[output_path]) == 0:
beta_x_twiss = metaclass.twiss(
os.path.join(output_path, "getbetax.out"))
beta_y_twiss = metaclass.twiss(
os.path.join(output_path, "getbetay.out"))
for index in range(len(beta_x_twiss.NAME)):
rel_error = abs(
(beta_x_twiss.BETX[index] - beta_x_twiss.BETXMDL[index]) /
beta_x_twiss.BETXMDL[index])
self.assertTrue(
rel_error < MAX_BETA_REL_ERR,
"Relative error too big found in: " +
beta_x_twiss.NAME[index] + " (" + str(rel_error) + ")")
for index in range(len(beta_y_twiss.NAME)):
rel_error = abs(
(beta_y_twiss.BETY[index] - beta_y_twiss.BETYMDL[index]) /
beta_y_twiss.BETYMDL[index])
self.assertTrue(
rel_error < MAX_BETA_REL_ERR,
"Relative error too big found in: " +
beta_y_twiss.NAME[index] + " (" + str(rel_error) + ")")
else:
print "Manual errors in the madx job: skipping betas check"
def writeparams(deltafamilie, variables, accel_path, app=0, path="./"):
if (app == 0):
mode = 'w'
if (app == 1):
mode = 'a'
a = datetime.datetime.fromtimestamp(time.time())
if accel_path[-5:] == "LHCB1":
path_B1tfs = os.path.join(accel_path, "varsKLvsK_B1.tfs")
twiss_kl = metaclass.twiss(path_B1tfs)
if accel_path[-5:] == "LHCB2":
path_B2tfs = os.path.join(accel_path, "varsKLvsK_B2.tfs")
twiss_kl = metaclass.twiss(path_B2tfs)
g = open (path+'/changeparameters', mode)
f = open (path+'/changeparameters.tfs', mode)
print >> f, "@", "APP", "%le", app
print >> f, "@", "PATH", "%s", path
print >> f, "@", "DATE", "%s", a.ctime()
print >> f, "*", "NAME", "DELTA"
print >> f, "$", "%s", "%le"
for i, var in enumerate(variables):
if var[0]=="l":
g.write(var[1:]+' = '+ var[1:] +' + ( '+str((deltafamilie[i]/twiss_kl.LENGTH[twiss_kl.indx[var]]))+' );\n')
f.write(var[1:]+' '+str((deltafamilie[i]/twiss_kl.LENGTH[twiss_kl.indx[var]]))+'\n')
else:
g.write(var+' = '+ var+' + ( '+str(deltafamilie[i])+' );\n')
f.write(var+' '+str(deltafamilie[i])+'\n')
g.close()
f.close()
def _get_tunes(fileslist):
'''
Reads in the driven tunes from the
file with dpp=0
Reads in the model tunes from the
twiss model (twiss.dat)
:param fileslist: dictionary of files, dpp used as key
:returns: (
:raise ValueError: If fileslist[0] does not exist
'''
if fileslist[0][0].endswith(".gz"):
fname = fileslist[0][0].replace(".gz", "")
end = '.gz'
else:
fname = fileslist[0][0]
end = ''
tw_x = metaclass.twiss(fname + '_linx' + end)
tw_y = metaclass.twiss(fname + '_liny' + end)
tw = metaclass.twiss(_InputData.twissfile)
qdx = tw_x.TUNEX[0]
qdy = tw_y.TUNEY[0]
qx = tw.Q1 % 1
qy = tw.Q2 % 1
qmx = tw.Q1
qmy = tw.Q2
return (qx, qy, qdx, qdy, qmx, qmy)
def plot(self):
if 1 in self._matcher_model._matcher.get_beams():
figure_b1_x = self._figures[0][0]
figure_b1_x.clear()
file_beam1_horizontal = metaclass.twiss(os.path.join(
self._matcher_model.get_beam1_output_path(), "sbs",
"sbsphasext_IP" + str(self._matcher_model.get_ip()) + ".out")
)
self._plot_match(figure_b1_x, file_beam1_horizontal, "X")
figure_b1_y = self._figures[0][1]
figure_b1_y.clear()
file_beam1_vertical = metaclass.twiss(os.path.join(
self._matcher_model.get_beam1_output_path(), "sbs",
"sbsphaseyt_IP" + str(self._matcher_model.get_ip()) + ".out")
)
self._plot_match(figure_b1_y, file_beam1_vertical, "Y")
if 2 in self._matcher_model._matcher.get_beams():
figure_b2_x = self._figures[1][0]
figure_b2_x.clear()
file_beam2_horizontal = metaclass.twiss(os.path.join(
self._matcher_model.get_beam2_output_path(), "sbs",
"sbsphasext_IP" + str(self._matcher_model.get_ip()) + ".out")
)
self._plot_match(figure_b2_x, file_beam2_horizontal, "X")
figure_b2_y = self._figures[1][1]
figure_b2_y.clear()
file_beam2_vertical = metaclass.twiss(os.path.join(
self._matcher_model.get_beam2_output_path(), "sbs",
"sbsphaseyt_IP" + str(self._matcher_model.get_ip()) + ".out")
)
self._plot_match(figure_b2_y, file_beam2_vertical, "Y")
def justtwiss():
#########################
global dictionary
system('madx < job.ORM.madx > scum')
x = twiss('twiss.orbit.dat')
y = twiss('twiss.all.dat')
return x, y
def lin_fit_data(path):
file_path_R = path+'R.dat'
file_path_L = path+'L.dat'
right_data = metaclass.twiss(file_path_R)
left_data = metaclass.twiss(file_path_L)
cleaned_xR = start_cleaning_data(right_data.K, right_data.TUNEX,right_data.TUNEX_ERR)
cleaned_yR = start_cleaning_data(right_data.K, right_data.TUNEY,right_data.TUNEY_ERR)
cleaned_xL = start_cleaning_data(left_data.K, left_data.TUNEX,left_data.TUNEX_ERR)
cleaned_yL = start_cleaning_data(left_data.K, left_data.TUNEY,left_data.TUNEY_ERR)
fitx_R, covx_r = np.polyfit(cleaned_xR[:,0], cleaned_xR[:,1], 1, cov=True, w = 1/cleaned_xR[:,2]**2)
fity_R, covy_r = np.polyfit(cleaned_yR[:,0], cleaned_yR[:,1], 1, cov=True, w = 1/cleaned_yR[:,2]**2)
fitx_L, covx_l = np.polyfit(cleaned_xL[:,0], cleaned_xL[:,1], 1, cov=True, w = 1/cleaned_xL[:,2]**2)
fity_L, covy_l = np.polyfit(cleaned_yL[:,0], cleaned_yL[:,1], 1, cov=True, w = 1/cleaned_yL[:,2]**2)
plot_fitting(fitx_L,fitx_R,fity_L,fity_R,left_data,right_data,path)
dK = 1.0e-5
K = np.average(left_data.K)
Q1 = np.average(right_data.TUNEX)
Q2 = np.average(right_data.TUNEY)
errx_r = np.sqrt(np.diag(covx_r)[0]) * dK
erry_r = np.sqrt(np.diag(covy_r)[0]) * dK
errx_l = np.sqrt(np.diag(covx_l)[0]) * dK
erry_l = np.sqrt(np.diag(covy_l)[0]) * dK
return fitx_L[0], fitx_R[0], fity_L[0], fity_R[0], errx_r, erry_r, errx_l, erry_l, K, dK, Q1, Q2 #kmod_data # Array with all dQ's (slopes of fit scaled with dK) and the dK spread. [xR, xL, yR, yL, dK ]
def _get_tunes(fileslist):
"""
Reads in the driven tunes from the
file with dpp=0
Reads in the model tunes from the
twiss model (twiss.dat)
:param fileslist: dictionary of files, dpp used as key
:returns: (
:raise ValueError: If fileslist[0] does not exist
"""
if fileslist[0][0].endswith(".gz"):
fname = fileslist[0][0].replace(".gz", "")
end = ".gz"
else:
fname = fileslist[0][0]
end = ""
tw_x = metaclass.twiss(fname + "_linx" + end)
tw_y = metaclass.twiss(fname + "_liny" + end)
tw = metaclass.twiss(_InputData.twissfile)
qdx = tw_x.TUNEX[0]
qdy = tw_y.TUNEY[0]
qx = tw.Q1 % 1
qy = tw.Q2 % 1
return (qx, qy, qdx, qdy)
def _get_twiss_for_one_of(directory, *file_names):
for file_name in file_names:
file_path = os.path.join(directory, file_name)
if os.path.isfile(file_path):
file_name_amplitude = "getampbeta" + file_name[7:]
file_path_amplitude = os.path.join(directory, file_name_amplitude)
return (metaclass.twiss(file_path), metaclass.twiss(file_path_amplitude))
raise IOError("None of the files exist:\n\t" + "\n\t".join(file_names))
def _get_kmod_files():
try:
kmod_path_x = twiss(_join_output_with("getkmodbetax.out"))
kmod_path_y = twiss(_join_output_with("getkmodbetay.out"))
except IOError:
kmod_path_x = None
kmod_path_y = None
return kmod_path_x, kmod_path_y
def _get_twiss_for_one_of(directory, *file_names):
for file_name in file_names:
file_path = os.path.join(directory, file_name)
if os.path.isfile(file_path):
file_name_amplitude = "getampbeta" + file_name[7:]
file_path_amplitude = os.path.join(directory, file_name_amplitude)
return (metaclass.twiss(file_path), metaclass.twiss(file_path_amplitude))
raise IOError("None of the files exist:\n\t" + "\n\t".join(file_names))
def _handle_data_for_lhc():
#.knob should always exist to be sent to LSA!
src = os.path.join(
os.path.join(_InputData.output_path, "changeparameters_couple.tfs"))
dst = os.path.join(
os.path.join(_InputData.output_path, "changeparameters_couple.knob"))
Utilities.iotools.copy_item(src, dst)
##### for bumps
if "bumps" in _InputData.variables_list:
print "passing trough bumps loop"
v = metaclass.twiss(
os.path.join(_InputData.output_path,
"changeparameters_couple.tfs")) # @UnusedVariable
# v will be used in Bumps.py. Don't do such things again!(vimaier)
Utilities.iotools.delete_item(
os.path.join(_InputData.output_path,
"changeparameters_couple.tfs"))
corrs = None # Will be assigned in exec Bumps.py (vimaier)
execfile(os.path.join(_InputData.path_to_optics_files_dir, "Bumps.py"))
execfile(
os.path.join(_InputData.path_to_optics_files_dir,
"mydictionary.py"))
tfs_file_writer = Utilities.tfs_file_writer.TfsFileWriter(
"changeparameters_couple.tfs", _InputData.output_path)
tfs_file_writer.add_column_names("NAME DELTA".split())
tfs_file_writer.add_column_datatypes("%s %le".split())
for vcorr in corrs:
tfs_file_writer.add_table_row([vcorr, corrs[vcorr]])
tfs_file_writer.write_to_file()
#####
v = metaclass.twiss(
os.path.join(_InputData.output_path, "changeparameters_couple.tfs"))
mad_script = open(
os.path.join(_InputData.output_path, "changeparameters_couple.madx"),
"w")
names = getattr(v, "NAME", [])
delta = getattr(v, "DELTA", [])
for i in range(len(names)):
if "bumps" in _InputData.variables_list:
if cmp(delta[i], 0) == 1:
mad_script.write(names[i] + "->KICK:=" + str(-delta[i]) +
";\n")
else:
mad_script.write(names[i] + "->KICK:=" + str(-delta[i]) +
";\n")
else:
if cmp(delta[i], 0) == 1:
mad_script.write(names[i] + " = " + names[i] + " " +
str(-delta[i]) + ";\n")
else:
mad_script.write(names[i] + " = " + names[i] + " + " +
str(-delta[i]) + ";\n")
mad_script.write("return;")
mad_script.close()
def generate_constraints_coupling(ip, use_errors, sbs_data_b1_path, sbs_data_b2_path, constraints_path=os.path.join(CURRENT_PATH, "match"), exclude_string=""):
sbs_coupling_data_beam1 = twiss(os.path.join(sbs_data_b1_path, 'sbs', 'sbscouple_IP' + ip + '.out'))
sbs_coupling_data_beam2 = twiss(os.path.join(sbs_data_b2_path, 'sbs', 'sbscouple_IP' + ip + '.out'))
constr_file_beam1 = open(os.path.join(constraints_path, 'constraintsb1.seqx'), 'w')
constr_file_beam2 = open(os.path.join(constraints_path, 'constraintsb2.seqx'), 'w')
exclude_list = _parse_exclude_string(exclude_string)
_write_constraints_file_coupling(sbs_coupling_data_beam1, constr_file_beam1, ip, 1, exclude_list, use_errors)
_write_constraints_file_coupling(sbs_coupling_data_beam2, constr_file_beam2, ip, 2, exclude_list, use_errors)
def run_gen_f_terms(ip, match_temporary_path, sbs_data_b1_path, sbs_data_b2_path):
sbs_coupling_data_beam1 = twiss(os.path.join(sbs_data_b1_path, 'sbs', 'sbscouple_IP' + ip + '.out'))
sbs_coupling_data_beam2 = twiss(os.path.join(sbs_data_b2_path, 'sbs', 'sbscouple_IP' + ip + '.out'))
fterms_b1_path = os.path.join(match_temporary_path, "f_terms_beam1.madx")
fterms_b2_path = os.path.join(match_temporary_path, "f_terms_beam2.madx")
with open(fterms_b1_path, "w") as fterms_b1_file:
for bpm_name in sbs_coupling_data_beam1.NAME:
fterms_b1_file.write("exec, get_f_terms_for(twiss, " + bpm_name + ");\n")
with open(fterms_b2_path, "w") as fterms_b2_file:
for bpm_name in sbs_coupling_data_beam2.NAME:
fterms_b2_file.write("exec, get_f_terms_for(twiss, " + bpm_name + ");\n")
def _parse_twiss_files(file_name):
startturn, endturn = _get_turns(file_name)
twx = metaclass.twiss(file_name + "_linx")
twy = metaclass.twiss(file_name + "_liny")
twx.keys.append("SDDS")
twy.keys.append("SDDS")
empty_list = numpy.empty([len(twx.NAME), endturn - startturn])
setattr(twx, "SDDS", empty_list)
empty_list = numpy.empty([len(twy.NAME), endturn - startturn])
setattr(twy, "SDDS", empty_list)
update_twisses_with_sdds(file_name, twx, twy)
return twx, twy
def merge_data(working_directory, ip ,beam):
IR = ip + beam
planes = ['X','Y']
sides = ['L','R']
for side in sides:
result = {'X':[],'Y':[]}
tdatax = metaclass.twiss(os.path.join(working_directory,IR+side+'X.tfs'))
tdatay = metaclass.twiss(os.path.join(working_directory,IR+side+'Y.tfs'))
kdata= metaclass.twiss(os.path.join(working_directory,ip+side+'K.tfs'))
K, Qx, Qxrms, Qy, Qyrms = pair(tdatax,tdatay,kdata)
write_tfs_files(K, Qx, Qxrms, Qy, Qyrms, working_directory, IR, side)
def _parse_twiss_files(file_name):
startturn, endturn = _get_turns(file_name)
twx = metaclass.twiss(file_name + "_linx")
twy = metaclass.twiss(file_name + "_liny")
twx.keys.append("SDDS")
twy.keys.append("SDDS")
empty_list = numpy.empty([len(twx.NAME),endturn-startturn])
setattr(twx, "SDDS", empty_list)
empty_list = numpy.empty([len(twy.NAME),endturn-startturn])
setattr(twy, "SDDS", empty_list)
update_twisses_with_sdds(file_name, twx, twy)
return twx,twy
def _parse_twiss_files(model, files):
model_twiss = metaclass.twiss(model)
lin_x_twiss_list = []
file_list = [file_name.strip() for file_name in files.strip("\"").split(",")]
for file_name in file_list:
if not file_name.endswith("_linx"):
file_name += "_linx"
if not os.path.isfile(file_name):
print >> sys.stderr, "Cannot find file_name: " + file_name + ". Aborting."
sys.exit()
else:
lin_x_twiss_list.append(metaclass.twiss(file_name))
return model_twiss, lin_x_twiss_list
def _get_twiss_instance_of_getcouple():
""" Loads either getcouple_free.out or getcouple.out or raises an Exception """
file_path_free = os.path.join(_InputData.output_path, "getcouple_free.out")
file_path = os.path.join(_InputData.output_path, "getcouple.out")
if os.path.isfile(file_path_free):
couple = metaclass.twiss(file_path_free)
print "Will use free coupling"
elif os.path.isfile(file_path):
couple = metaclass.twiss(file_path)
print "WARN: Free coupling not found!"
else:
raise ValueError("path", _InputData.output_path, " does not contain a getcouple_free.out or getcouple.out file")
return couple
def _get_twiss_instance_of_getcouple():
""" Loads either getcouple_free.out or getcouple.out or raises an Exception """
file_path_free = os.path.join(_InputData.output_path, "getcouple_free.out")
file_path = os.path.join(_InputData.output_path, "getcouple.out")
if os.path.isfile(file_path_free):
couple = metaclass.twiss(file_path_free)
print "Will use free coupling"
elif os.path.isfile(file_path):
couple = metaclass.twiss(file_path)
print "WARN: Free coupling not found!"
else:
raise ValueError("path", _InputData.output_path, " does not contain a getcouple_free.out or getcouple.out file")
return couple
def write_global_files(beam, kmod_dir, res_dir, mod_path):
bpms = np.array([])
betx = np.array([])
bety = np.array([])
betx_std = np.array([])
bety_std = np.array([])
IPs = ['ip1', 'ip5', 'ip8']
for ip in IPs:
pathx, pathy = get_paths(kmod_dir, beam, ip)
try:
datax = metaclass.twiss(pathx)
datay = metaclass.twiss(pathy)
except IOError:
print "Cannot find " + ip + " kmod data, won't copy those files."
continue
bpms = np.concatenate((bpms, datax.NAME))
betx = np.concatenate((betx, datax.BETX))
bety = np.concatenate((bety, datay.BETY))
betx_std = np.concatenate((betx_std, datax.BETXSTD))
bety_std = np.concatenate((bety_std, datay.BETYSTD))
betx_mod, bety_mod = get_model_beta(bpms, mod_path)
xdata = tfs_file_writer.TfsFileWriter.open(
os.path.join(res_dir, 'getkmodbetax.out'))
xdata.set_column_width(20)
xdata.add_column_names([
'NAME', 'S', 'COUNT', 'BETX', 'STDBETX', 'BETXMDL', 'ERRBETX',
'BETXRES', 'BETXSTDRES'
])
xdata.add_column_datatypes(
['%s', '%le', '%le', '%le', '%le', '%le', '%le', '%le', '%le'])
ydata = tfs_file_writer.TfsFileWriter.open(
os.path.join(res_dir, 'getkmodbetay.out'))
ydata.set_column_width(20)
ydata.add_column_names([
'NAME', 'S', 'COUNT', 'BETY', 'STDBETY', 'BETYMDL', 'ERRBETY',
'BETYRES', 'BETYSTDRES'
])
ydata.add_column_datatypes(
['%s', '%le', '%le', '%le', '%le', '%le', '%le', '%le', '%le'])
for i in range(len(bpms)):
xdata.add_table_row(
[bpms[i], 0, 0, betx[i], betx_std[i], betx_mod[i], 0, 0, 0])
ydata.add_table_row(
[bpms[i], 0, 0, bety[i], bety_std[i], bety_mod[i], 0, 0, 0])
xdata.write_to_file()
ydata.write_to_file()
def _parse_twiss_files(model, files):
model_twiss = metaclass.twiss(model)
lin_x_twiss_list = []
file_list = [
file_name.strip() for file_name in files.strip("\"").split(",")
]
for file_name in file_list:
if not file_name.endswith("_linx"):
file_name += "_linx"
if not os.path.isfile(file_name):
print >> sys.stderr, "Cannot find file_name: " + file_name + ". Aborting."
sys.exit()
else:
lin_x_twiss_list.append(metaclass.twiss(file_name))
return model_twiss, lin_x_twiss_list
def _parallel_get_systematic_errors_binary_file(model_twiss_path, run_data_path, output_path, pool, num_simulations, num_processes):
model_twiss = metaclass.twiss(model_twiss_path)
list_of_bpm = []
for i in model_twiss.NAME:
if "BPM" in i and i not in list_of_bpm:
list_of_bpm.append(i)
final_list = [{}, {}, 0] # This list is used to pass the parameters "by reference" to the callback method
chunksize = _compute_chunksize(num_simulations, num_processes)
print "Using chunk size:", chunksize
args = [(run_data_path, model_twiss, list_of_bpm, range(1, num_simulations + 1)[x:x + chunksize]) for x in xrange(0, num_simulations, chunksize)]
for run_data_path, model_twiss, list_of_bpm, sim_nums in args:
pool.apply_async(_get_error_bar_for_single_simulation, (run_data_path, model_twiss, list_of_bpm, sim_nums),
callback=lambda result: _merge_betas_dict(final_list, result))
pool.close()
pool.join()
sys.stdout.write("\n")
final_beta_hor, final_beta_ver, final_num_valid_data = final_list
for key, value in final_beta_hor.iteritems():
final_beta_hor[key] = value / final_num_valid_data
for key, value in final_beta_ver.iteritems():
final_beta_ver[key] = value / final_num_valid_data
np.save(os.path.join(output_path, 'bet_deviations'), [final_beta_hor, final_beta_ver])
def define_constraints(self):
constr_string = ""
for plane in ["x", "y"]:
sbs_data = metaclass.twiss(
os.path.join(
self.get_matcher_path(), "sbs", 'sbsphase' + plane + 't_' +
str(self._segment.label) + '.out'))
is_back = "b" in self._front_or_back
for index in range(0, len(sbs_data.NAME)):
name = sbs_data.NAME[index]
if name not in self._excluded_constraints_list:
if is_back is not True:
phase = sbs_data.PROPPHASEX[
index] if plane == "x" else sbs_data.PROPPHASEY[
index]
error = sbs_data.ERRPROPPHASEX[
index] if plane == "x" else sbs_data.ERRPROPPHASEY[
index]
else:
phase = sbs_data.BACKPHASEX[
index] if plane == "x" else sbs_data.BACKPHASEY[
index]
error = sbs_data.ERRBACKPHASEX[
index] if plane == "x" else sbs_data.ERRBACKPHASEY[
index]
constr_string += self._get_constraint_instruction(
self._name + '.dmu' + plane + name, phase, error)
return constr_string
def _get_tunes(model_file, fileslist):
"""
Reads in the driven tunes from the
file with dpp=0
Reads in the model tunes from the
twiss model (twiss.dat)
Args:
fileslist: dictionary of files, dpp used as key
Returns:
(qx, qy, qdx, qdy, qmx, qmy)
Raises:
ValueError: If fileslist[0] does not exist
"""
tw_x, tw_y = _load_from_file(fileslist[0][0])
tw = metaclass.twiss(model_file)
exp_qx = tw_x.Q1
exp_qy = tw_y.Q2
mdl_qx = tw.Q1
mdl_qy = tw.Q2
return (exp_qx, exp_qy, mdl_qx, mdl_qy)
def get_segment(cls, label, first_elem, last_elem, optics_file,
twiss_file):
segment_cls = type(cls.__name__ + "Segment",
(_PsboosterSegmentMixin, cls), {})
LOGGER.debug('twiss_file is <%s>', twiss_file)
tw = twiss(twiss_file)
LOGGER.debug('twiss_file has tunes %f %f ', tw.Q1, tw.Q2)
ring = _get_ring_from_seqname(tw.SEQUENCE)
#ring = cls.get_ring()
segment_inst = segment_cls()
bpms_file = _get_file_for_ring(ring)
bpms_file_data = tfs_pandas.read_tfs(bpms_file).set_index("NAME")
first_elem_s = bpms_file_data.loc[first_elem, "S"]
last_elem_s = bpms_file_data.loc[last_elem, "S"]
segment_inst.label = label
segment_inst.start = Element(first_elem, first_elem_s)
segment_inst.end = Element(last_elem, last_elem_s)
segment_inst.optics_file = optics_file
segment_inst.fullresponse = None
segment_inst.nat_tune_x = tw.Q1
segment_inst.nat_tune_y = tw.Q2
segment_inst.energy = tw.ENERGY
segment_inst.sequence = tw.SEQUENCE
segment_inst.ring = ring
segment_inst.kind = '' # '' means beta from phase, can be 'betaamp', in the future 'betakmod'
return segment_inst
def get_segment(cls, label, first_elem, last_elem, optics_file, twiss_file):
# this creates a new class called PsSegment
segment_cls = type(cls.__name__ + "Segment",
(_PsSegmentMixin,cls),
{})
segment_inst = segment_cls()
bpms_file = os.path.join(PS_DIR,str(CURRENT_YEAR),"sequence/bpms.tfs")
bpms_file_data = tfs_pandas.read_tfs(bpms_file).set_index("NAME")
first_elem_s = bpms_file_data.loc[first_elem, "S"]
last_elem_s = bpms_file_data.loc[last_elem, "S"]
segment_inst.label = label
segment_inst.start = Element(first_elem, first_elem_s)
segment_inst.end = Element(last_elem, last_elem_s)
segment_inst.optics_file = optics_file
segment_inst.fullresponse = None
LOGGER.debug('twiss_file is <%s>',twiss_file)
tw = twiss(twiss_file)
LOGGER.debug('twiss_file has tunes %f %f ',tw.Q1,tw.Q2)
segment_inst.nat_tune_x = tw.Q1
segment_inst.nat_tune_y = tw.Q2
segment_inst.energy = tw.ENERGY
segment_inst.kind = '' # '' means beta from phase, can be 'betaamp', in the future 'betakmod'
return segment_inst
def _get_beta_amp_data(directory, plane, free=True):
suffix = PLANE_SUFFIX[plane]
getampbeta = os.path.join(directory, "getampbeta" + suffix + ".out")
getampbetafree = os.path.join(directory, "getampbeta" + suffix + "_free.out")
if not free:
return metaclass.twiss(getampbeta)
return _get_twiss_for_one_of(getampbetafree, getampbeta)
def _get_calibrated_betas(plane):
amplitude_beta = None
calibration_data = None
try:
amplitude_beta = _get_twiss_for_one_of(
"getampbeta" + plane + "_free.out", "getampbeta" + plane + ".out")
calibration_data = twiss(
_join_output_with("calibration_" + plane + ".out"))
except IOError:
return None
calibrated_betas = CalibratedBetas(plane)
index_counter = 0
for bpm_name in calibration_data.NAME:
if bpm_name in amplitude_beta.NAME:
amp_index = amplitude_beta.indx[bpm_name]
amp_beta = getattr(amplitude_beta,
"BET" + plane.upper())[amp_index]
calibrated_betas.NAME.append(bpm_name)
calibrated_betas.S.append(amplitude_beta.S[amp_index])
calibrated_betas.indx[bpm_name] = index_counter
index_counter += 1
getattr(calibrated_betas, "BET" + plane.upper()).append(amp_beta)
try:
err_amp_beta = getattr(amplitude_beta,
"STDBET" + plane.upper())[amp_index]
except AttributeError:
err_amp_beta = getattr(amplitude_beta, "BET" + plane.upper() +
"STD")[amp_index]
getattr(calibrated_betas,
"BET" + plane.upper() + "STD").append(err_amp_beta)
mdl_amp_beta = getattr(amplitude_beta,
"BET" + plane.upper() + "MDL")[amp_index]
getattr(calibrated_betas,
"BET" + plane.upper() + "MDL").append(mdl_amp_beta)
return calibrated_betas
def __try_to_load_twiss_from_output(self, file_name):
try:
twiss_data = twiss(_join_output_with(file_name))
except ValueError:
print("Imposible to read twiss file ", file_name, file=sys.stderr)
return None
return twiss_data
def _get_tunes(model_file, fileslist):
"""
Reads in the driven tunes from the
file with dpp=0
Reads in the model tunes from the
twiss model (twiss.dat)
Args:
fileslist: dictionary of files, dpp used as key
Returns:
(qx, qy, qdx, qdy, qmx, qmy)
Raises:
ValueError: If fileslist[0] does not exist
"""
tw_x, tw_y = _load_from_file(fileslist[0][0])
tw = metaclass.twiss(model_file)
exp_qx = tw_x.Q1
exp_qy = tw_y.Q2
mdl_qx = tw.Q1
mdl_qy = tw.Q2
return (exp_qx, exp_qy, mdl_qx, mdl_qy)
def _get_beta_beat_file(self, beam, plane):
bb_path = getattr(self._matcher_model, "get_beam" + str(beam) + "_output_path")()
file_data = metaclass.twiss(os.path.join(
bb_path, "sbs",
"sbsbetabeat" + plane.lower() + "_IP" + str(self._matcher_model.get_ip()) + ".out")
)
return file_data
def _handle_data_for_sps():
v = metaclass.twiss(os.path.join(_InputData.output_path, "changeparameters_couple.tfs")) # @UnusedVariable
# v will be used in VBumps.py. Don't do such things again!(vimaier)
print '\nFor SPS, vertical bump file is imported:'
print os.path.join(_InputData.accel_path, "Coupling/VBumps.py")
vcorrs = None # Will be assigned in exec VBumps.py (vimaier)
vcorrsYASP = None # Will be assigned in exec VBumpsYASP.py (vimaier)
execfile(os.path.join(_InputData.accel_path, "Coupling", "VBumps.py")) # LOADS vcorrs
execfile(os.path.join(_InputData.accel_path, "Coupling", "VBumpsYASP.py")) # LOADS vcorrsYASP
#Output for YASP...
f = open(os.path.join(_InputData.output_path, "Coupling", "changeparameters_couple.yasp"), "w")
f.write("#PLANE V\n")
f.write("#UNIT RAD\n")
for vcorr in vcorrsYASP:
print >> f, "#SETTING", vcorr, vcorrsYASP[vcorr]
f.close()
#Output for Knob...
g = open(os.path.join(_InputData.output_path, "Coupling", "changeparameters_couple.knob"), "w")
h = open(os.path.join(_InputData.output_path, "Coupling", "changeparameters_couple.madx"), "w")
g.write("* NAME DELTA \n")
g.write("$ %s %le \n")
for vcorr in vcorrs:
print >> g, "K"+vcorr, vcorrs[vcorr]
print >> h, vcorr, "->KICK:=", vcorrs[vcorr], ";"
h.write('return;')
g.close()
h.close()
def MagnetSpecs(magnetname, beam):
if beam == 'B1':
twissfile = twissfilenameb1
else:
twissfile = twissfilenameb2
twiss = metaclass.twiss(twissfile)
if magnetname in twiss.NAME:
index = twiss.NAME.index(magnetname)
position = twiss.S[index]
k = twiss.K1L[index]
length = twiss.L[index]
Polarity = twiss.POLARITY[index]
elif magnetname+'.'+beam in twiss.NAME:
index = twiss.NAME.index(magnetname+'.'+beam)
position = twiss.S[index]
k = twiss.K1L[index]
length = twiss.L[index]
Polarity = twiss.POLARITY[index]
return position, k, length, Polarity
def run_gen_f_terms(ip, match_temporary_path, sbs_data_b1_path,
sbs_data_b2_path):
sbs_coupling_data_beam1 = twiss(
os.path.join(sbs_data_b1_path, 'sbs', 'sbscouple_IP' + ip + '.out'))
sbs_coupling_data_beam2 = twiss(
os.path.join(sbs_data_b2_path, 'sbs', 'sbscouple_IP' + ip + '.out'))
fterms_b1_path = os.path.join(match_temporary_path, "f_terms_beam1.madx")
fterms_b2_path = os.path.join(match_temporary_path, "f_terms_beam2.madx")
with open(fterms_b1_path, "w") as fterms_b1_file:
for bpm_name in sbs_coupling_data_beam1.NAME:
fterms_b1_file.write("exec, get_f_terms_for(twiss, " + bpm_name +
");\n")
with open(fterms_b2_path, "w") as fterms_b2_file:
for bpm_name in sbs_coupling_data_beam2.NAME:
fterms_b2_file.write("exec, get_f_terms_for(twiss, " + bpm_name +
");\n")
def ReturnDataofBPMinBetweenMagnets(magnetname1, magnetname2, BPMKeyword, beam):
results_name = []
results_pos = []
if beam == 'B1':
twissfile = twissfilenameb1
else:
twissfile = twissfilenameb2
twiss = metaclass.twiss(twissfile)
if IsInTwiss(magnetname1,beam) ==True:
index1 = twiss.NAME.index(magnetname1)
elif IsInTwiss(magnetname1+'.'+beam ,beam) ==True:
index1 = twiss.NAME.index(magnetname1+'.'+beam)
if IsInTwiss(magnetname2, beam) == True:
index2 = twiss.NAME.index(magnetname2)
elif IsInTwiss(magnetname2 + '.' + beam, beam) == True:
index2 = twiss.NAME.index(magnetname2 + '.' + beam)
for key, name, pos in zip(twiss.KEYWORD[min(index1, index2): max(index1, index2)], twiss.NAME[min(index1, index2): max(index1, index2)], twiss.S[min(index1, index2): max(index1, index2)]) :
if key == BPMKeyword:
results_name.append(name)
results_pos.append(pos)
return results_name, results_pos
def define_aux_vars(self):
phases_str = ""
variables_s_str = ""
sign = ""
if "b" in self._front_or_back:
sign = "-"
for beam in self.get_beams():
for plane in ["x", "y"]:
sbs_data_path = os.path.join(
self.get_match_data(beam).get_beam_match_sbs_path(),
"sbsphase" + plane + "t_IP" + str(self._ip) + ".out",
)
sbs_data = metaclass.twiss(sbs_data_path)
for name in sbs_data.NAME:
phases_str += self._name + ".dmu" + plane + name + " := "
phases_str += sign + "(table(twiss, " + name + ", mu" + plane + ") - "
phases_str += "table(" + self._get_nominal_table_name(beam) + ", " + name + ", mu" + plane + "));\n"
for variable in self.get_all_variables():
variables_s_str += self._name + "." + variable + "_0" + " = " + variable + ";\n"
return PhaseMatcher.DEF_CONSTR_AUX_VALUES_TEMPLATE % {
"SEQ_B1": "lhcb1_" + self._front_or_back + "_" + self._name,
"SEQ_B2": "lhcb2_" + self._front_or_back + "_" + self._name,
"INIT_VALS_B1": "b1_" + self._ini_end + "_" + self._name,
"INIT_VALS_B2": "b2_" + self._ini_end + "_" + self._name,
"B1_TABLE_NAME": self._get_nominal_table_name(1),
"B2_TABLE_NAME": self._get_nominal_table_name(2),
"PHASES": phases_str,
"S_VARIABLES": variables_s_str,
}
def _get_beta_data(directory, plane, free=True):
suffix = PLANE_SUFFIX[plane]
getbeta = os.path.join(directory, "getbeta" + suffix + ".out")
getbetafree = os.path.join(directory, "getbeta" + suffix + "_free.out")
if not free:
return metaclass.twiss(getbeta)
return _get_twiss_for_one_of(getbetafree, getbeta)
def define_aux_vars(self):
phases_str = ""
variables_s_str = ""
sign = ""
if "b" in self._front_or_back:
sign = "-"
for plane in ["x", "y"]:
sbs_data_path = os.path.join(
os.path.join(self.get_matcher_path(), "sbs"),
'sbsphase' + plane + 't_' + str(self._segment.label) + '.out')
sbs_data = metaclass.twiss(sbs_data_path)
for name in sbs_data.NAME:
phases_str += self._name + '.dmu' + plane + name + ' := '
phases_str += sign + "(table(twiss, " + name + ", mu" + plane + ") - "
phases_str += "table(" + self._get_nominal_table_name(
) + ", " + name + ", mu" + plane + "));\n"
for variable in self.get_variables():
variables_s_str += self._name + '.' + variable + '_0' + ' = ' + variable + ';\n'
beam = str(self.get_segment().get_beam())
return PhaseMatcher.DEF_CONSTR_AUX_VALUES_TEMPLATE % {
"SEQ":
"lhcb" + beam + "_" + self._front_or_back + "_" + self._name,
"INIT_VALS": "b" + beam + "_" + self._ini_end + "_" + self._name,
"TABLE_NAME": self._get_nominal_table_name(),
"PHASES": phases_str,
"S_VARIABLES": variables_s_str,
}
def _handle_data_for_sps():
v = metaclass.twiss(os.path.join(_InputData.output_path, "changeparameters_couple.tfs")) # @UnusedVariable
# v will be used in VBumps.py. Don't do such things again!(vimaier)
print '\nFor SPS, vertical bump file is imported:'
print os.path.join(_InputData.accel_path, "Coupling/VBumps.py")
vcorrs = None # Will be assigned in exec VBumps.py (vimaier)
vcorrsYASP = None # Will be assigned in exec VBumpsYASP.py (vimaier)
execfile(os.path.join(_InputData.accel_path, "Coupling", "VBumps.py")) # LOADS vcorrs
execfile(os.path.join(_InputData.accel_path, "Coupling", "VBumpsYASP.py")) # LOADS vcorrsYASP
#Output for YASP...
f = open(os.path.join(_InputData.output_path, "Coupling", "changeparameters_couple.yasp"), "w")
f.write("#PLANE V\n")
f.write("#UNIT RAD\n")
for vcorr in vcorrsYASP:
print >> f, "#SETTING", vcorr, vcorrsYASP[vcorr]
f.close()
#Output for Knob...
g = open(os.path.join(_InputData.output_path, "Coupling", "changeparameters_couple.knob"), "w")
h = open(os.path.join(_InputData.output_path, "Coupling", "changeparameters_couple.madx"), "w")
g.write("* NAME DELTA \n")
g.write("$ %s %le \n")
for vcorr in vcorrs:
print >> g, "K"+vcorr, vcorrs[vcorr]
print >> h, vcorr, "->KICK:=", vcorrs[vcorr], ";"
h.write('return;')
g.close()
h.close()
def main(input_path, input_path_model, output_path):
utils.iotools.create_dirs(output_path)
(beta_from_phase_x,
beta_from_amp_x) = _get_twiss_for_one_of(input_path, "getbetax_free.out",
"getbetax.out")
(beta_from_phase_y,
beta_from_amp_y) = _get_twiss_for_one_of(input_path, "getbetay_free.out",
"getbetay.out")
nominal_model = metaclass.twiss(input_path_model)
_configure_plots()
files_phase = (beta_from_phase_x, beta_from_phase_y)
files_amplitude = (beta_from_amp_x, beta_from_amp_y)
beam = _get_beam_from_model(nominal_model)
for i in range(len(PLANES)):
tfs_file = _get_tfs_file(output_path, PLANES[i], beam)
for ip in IPS:
(names_range, positions_range, amplitude_ratio_phasefit,
error_amplitude_ratio_phasefit, amplitude_ratio_measured,
error_amplitude_ratio_measured, beta_ratio_phasefit,
error_beta_ratio_phasefit
) = _compute_calibration_for_ip_and_plane(ip, PLANES[i],
files_phase[i],
files_amplitude[i],
nominal_model, beam,
output_path)
print_files(names_range, positions_range, amplitude_ratio_phasefit,
error_amplitude_ratio_phasefit,
amplitude_ratio_measured,
error_amplitude_ratio_measured, beta_ratio_phasefit,
error_beta_ratio_phasefit, beta_ratio_phasefit,
error_beta_ratio_phasefit, tfs_file)
tfs_file.write_to_file()
def FindKeywordBetweenMagnets(magnetname1, magnetname2, name, beam):
if beam == 'B1':
twissfile = twissfilenameb1
else:
twissfile = twissfilenameb2
twiss = metaclass.twiss(twissfile)
if IsInTwiss(magnetname1,beam) ==True:
index1 = twiss.NAME.index(magnetname1)
elif IsInTwiss(magnetname1+'.'+beam ,beam) ==True:
index1 = twiss.NAME.index(magnetname1+'.'+beam)
if IsInTwiss(magnetname2, beam) == True:
index2 = twiss.NAME.index(magnetname2)
elif IsInTwiss(magnetname2 + '.' + beam, beam) == True:
index2 = twiss.NAME.index(magnetname2 + '.' + beam)
if name in twiss.KEYWORD[min(index1, index2):max(index1, index2)]:
return True
else:
return False
def get_segment(cls, label, first_elem, last_elem, optics_file,
twiss_file):
# this creates a new class called PsSegment
segment_cls = type(cls.__name__ + "Segment", (_PsSegmentMixin, cls),
{})
segment_inst = segment_cls()
bpms_file = os.path.join(PS_DIR, str(CURRENT_YEAR),
"sequence/bpms.tfs")
bpms_file_data = tfs_pandas.read_tfs(bpms_file).set_index("NAME")
first_elem_s = bpms_file_data.loc[first_elem, "S"]
last_elem_s = bpms_file_data.loc[last_elem, "S"]
segment_inst.label = label
segment_inst.start = Element(first_elem, first_elem_s)
segment_inst.end = Element(last_elem, last_elem_s)
segment_inst.optics_file = optics_file
segment_inst.fullresponse = None
LOGGER.debug('twiss_file is <%s>', twiss_file)
tw = twiss(twiss_file)
LOGGER.debug('twiss_file has tunes %f %f ', tw.Q1, tw.Q2)
segment_inst.nat_tune_x = tw.Q1
segment_inst.nat_tune_y = tw.Q2
segment_inst.energy = tw.ENERGY
segment_inst.kind = '' # '' means beta from phase, can be 'betaamp', in the future 'betakmod'
return segment_inst
def __init__(self, measurement_path, w_path=None):
_set_output_path(measurement_path)
self.beta_x = _get_twiss_for_one_of("getbetax_free.out",
"getbetax.out")
self.QXX = self.beta_x.Q1
self.QYY = self.beta_x.Q2
self.beta_y = _get_twiss_for_one_of("getbetay_free.out",
"getbetay.out")
self.amplitude_beta_x = _get_calibrated_betas("x")
self.amplitude_beta_y = _get_calibrated_betas("y")
self.phase_x = _get_twiss_for_one_of("getphasex_free.out",
"getphasex.out")
self.phase_y = _get_twiss_for_one_of("getphasey_free.out",
"getphasey.out")
self.total_phase_x = _get_twiss_for_one_of("getphasetotx_free.out",
"getphasetotx.out")
self.total_phase_y = _get_twiss_for_one_of("getphasetoty_free.out",
"getphasetoty.out")
self.has_dispersion = False
self.has_coupling = False
self.couple_method = "_free"
### check if dispersion exist
if self.__try_to_load_dispersion_files():
self.has_dispersion = True
print("Dispersion files OK", self.dispersion_x.DX[0],
self.dispersion_x.NAME[0])
else:
self.has_dispersion = False
print(
"No dispersion files... will continue without taking into account dispersion"
)
### check if coupling exist
if self.__try_to_load_coupling_files():
self.has_coupling = True
self.couple_method = "driven"
else:
self.has_coupling = False
if _exists(_join_output_with("getcouple_free.out")):
self.couple = twiss(_join_output_with("getcouple_free.out"))
self.couple_method = "_free"
self.has_coupling = True
print("Free coupling found")
if not self.has_coupling:
print(
"No coupling file... will continue without taking into account coupling"
)
### check if chromatic exists
if w_path is None:
w_path = measurement_path
self.has_chromatic = self.__try_to_load_chromatic_files(w_path)
def calc_BPM_beta(path, ip, beam):
if ip == 'ip1' or ip == 'ip5':
L_ip2bpm = 21.564 # Length between IP and first BPM: BPMSW.1L1.B1, BPMSW.1R1.B1, BPMSW.1L5.B1, BPMSW.1R5.B1
elif ip == 'ip8' or ip == 'ip2':
L_ip2bpm = 21.595
ip_data = metaclass.twiss(os.path.join(path,'%s.results' %(ip+beam)))
bw = ip_data.BETAWAIST
bw_err = ip_data.BETAWAIST_ERR
w = ip_data.WAIST
w_err = ip_data.WAIST_ERR
label = ip_data.LABEL
IR = ip + beam
if IR_definitions[IR+'.X'][0] == 'foc':
w[0] = -w[0]
elif IR_definitions[IR+'.Y'][0] == 'foc':
w[1] = -w[1]
b_bpmR = bw + (L_ip2bpm - w)**2/bw
b_bpmL = bw + (L_ip2bpm + w)**2/bw
b_bpmR_err = []
b_bpmL_err = []
count = 0
for l in range(len(label)):
count += 1
rerr = []
lerr = []
we = np.linspace(-w_err[l] , w_err[l] ,2) + w[l]
bwe = np.linspace(-bw_err[l], bw_err[l],2) + bw[l]
for i in range(2):
for j in range(2):
rerr.append(bwe[i] + (L_ip2bpm - we[j])**2/bwe[i])
lerr.append(bwe[i] + (L_ip2bpm + we[j])**2/bwe[i])
b_bpmR_err.append((max(rerr)-min(rerr))/2.)
b_bpmL_err.append((max(lerr)-min(lerr))/2.)
beta_bpm = np.transpose(np.vstack((b_bpmL,b_bpmR)))
beta_bpm_err = np.transpose(np.vstack((b_bpmL_err,b_bpmR_err)))
bpms = which_bpms(ip+beam)
xdata = tfs_file_writer.TfsFileWriter.open(os.path.join(path, 'getkmodbetax_%s.out' %ip))
xdata.set_column_width(20)
xdata.add_column_names(['NAME', 'S' , 'COUNT', 'BETX', 'BETXSTD', 'BETXMDL' , 'MUXMDL' , 'BETXRES' , 'BETXSTDRES' ])
xdata.add_column_datatypes(['%s', '%le','%le','%le', '%le', '%le', '%le', '%le', '%le'])
ydata = tfs_file_writer.TfsFileWriter.open(os.path.join(path, 'getkmodbetay_%s.out' %ip))
ydata.set_column_width(20)
ydata.add_column_names(['NAME', 'S' , 'COUNT', 'BETY', 'BETYSTD', 'BETYMDL' , 'MUYMDL' , 'BETYRES' , 'BETYSTDRES'])
ydata.add_column_datatypes(['%s', '%le','%le','%le', '%le', '%le', '%le', '%le', '%le'])
for i in range(len(bpms)):
xdata.add_table_row([bpms[i], 0, 0, beta_bpm[0][i], beta_bpm_err[0][i], 0, 0, 0, 0 ])
ydata.add_table_row([bpms[i], 0, 0, beta_bpm[1][i], beta_bpm_err[1][i], 0, 0, 0, 0 ])
xdata.write_to_file()
ydata.write_to_file()
def __file_not_valid(name_twiss):
''' Checks if the given twiss file is empty, thus not valid. '''
try:
tw_f = metaclass.twiss(name_twiss)
return tw_f.has_no_bpm_data()
except ValueError:
# Probably empty file
return True
def __file_not_valid(name_twiss):
''' Checks if the given twiss file is empty, thus not valid. '''
try:
tw_f = metaclass.twiss(name_twiss)
return tw_f.has_no_bpm_data()
except ValueError:
# Probably empty file
return True
def _get_tune_data(directory, plane, free=True):
har_data = metaclass.twiss(_get_harmonic_path(directory, plane))
plane_index = {HOR: "1", VER: "2"}
if not free:
return (getattr(har_data, "Q" + plane_index[plane]),
getattr(har_data, "Q" + plane_index[plane] + "RMS"))
return (getattr(har_data, "NATQ" + plane_index[plane]),
getattr(har_data, "NATQ" + plane_index[plane] + "RMS"))
def _get_tune_data(directory, plane, free=True):
har_data = metaclass.twiss(_get_harmonic_path(directory, plane))
plane_index = {HOR: "1", VER: "2"}
if not free:
return (getattr(har_data, "Q" + plane_index[plane]),
getattr(har_data, "Q" + plane_index[plane] + "RMS"))
return (getattr(har_data, "NATQ" + plane_index[plane]),
getattr(har_data, "NATQ" + plane_index[plane] + "RMS"))
def _get_phase_data(directory, plane, free=True):
suffix = PLANE_SUFFIX[plane]
getphase = os.path.join(directory,
"getphasetot" + suffix + ".out")
getphasefree = os.path.join(directory,
"getphasetot" + suffix + "_free.out")
if not free:
return metaclass.twiss(getphase)
return _get_twiss_for_one_of(getphasefree, getphase)
def lin_fit_data(path, beam, working_directory, magnet1, magnet2, log, logfile, auto_clean):
file_path_1 = working_directory + '/' + magnet1 + '.' + beam + '.dat'
file_path_2 = working_directory + '/' + magnet2 + '.' + beam + '.dat'
left_data = metaclass.twiss(file_path_1)
right_data = metaclass.twiss(file_path_2)
if auto_clean == True:
cleaned_x1 = start_cleaning_data(left_data.K, left_data.TUNEX, left_data.TUNEX_ERR)
cleaned_y1 = start_cleaning_data(left_data.K, left_data.TUNEY, left_data.TUNEY_ERR)
cleaned_x2 = start_cleaning_data(right_data.K, right_data.TUNEX, right_data.TUNEX_ERR)
cleaned_y2 = start_cleaning_data(right_data.K, right_data.TUNEY, right_data.TUNEY_ERR)
else:
cleaned_x1 = automatic_cleaning_data(left_data.K, left_data.TUNEX, left_data.TUNEX_ERR)
cleaned_y1 = automatic_cleaning_data(left_data.K, left_data.TUNEY, left_data.TUNEY_ERR)
cleaned_x2 = automatic_cleaning_data(right_data.K, right_data.TUNEX, right_data.TUNEX_ERR)
cleaned_y2 = automatic_cleaning_data(right_data.K, right_data.TUNEY, right_data.TUNEY_ERR)
fitx_1, covx_1 = np.polyfit(cleaned_x1[:, 0], cleaned_x1[:, 1], 1, cov=True, w=1 / cleaned_x1[:, 2] ** 2)
fity_1, covy_1 = np.polyfit(cleaned_y1[:, 0], cleaned_y1[:, 1], 1, cov=True, w=1 / cleaned_y1[:, 2] ** 2)
fitx_2, covx_2 = np.polyfit(cleaned_x2[:, 0], cleaned_x2[:, 1], 1, cov=True, w=1 / cleaned_x2[:, 2] ** 2)
fity_2, covy_2 = np.polyfit(cleaned_y2[:, 0], cleaned_y2[:, 1], 1, cov=True, w=1 / cleaned_y2[:, 2] ** 2)
plot_fitting(fitx_1, fitx_2, fity_1, fity_2, left_data, right_data, path)
dK = 1.0e-5
K2 = np.average(cleaned_x2[:, 0])
K1 = np.average(cleaned_x1[:, 0])
Qx1 = np.average(cleaned_x1[:, 1])
Qy1 = np.average(cleaned_y1[:, 1])
Qx2 = np.average(cleaned_x2[:, 1])
Qy2 = np.average(cleaned_y2[:, 1])
errx_1 = np.sqrt(np.diag(covx_1)[0]) * dK
erry_1 = np.sqrt(np.diag(covy_1)[0]) * dK
errx_2 = np.sqrt(np.diag(covx_2)[0]) * dK
erry_2 = np.sqrt(np.diag(covy_2)[0]) * dK
return fitx_2[0], fitx_1[0], fity_2[0], fity_1[
0], errx_1, erry_1, errx_2, erry_2, K1, K2, dK, Qx1, Qy1, Qx2, Qy2 # kmod_data # Array with all dQ's (slopes of fit scaled with dK) and the dK spread. [xR, xL, yR, yL, dK ]
def _read_elements_positions(self):
self._elements_positions = {}
for beam in self._matcher.get_beams():
self._elements_positions[beam] = {}
segment_model = metaclass.twiss(
os.path.join(getattr(self, "get_beam" + str(beam) + "_output_path")(),
"sbs", "twiss_IP" + str(self.get_ip()) + ".dat")
)
for index in range(len(segment_model.NAME)):
self._elements_positions[beam][segment_model.S[index]] = segment_model.NAME[index]
def _handle_data_for_lhc():
#.knob should always exist to be sent to LSA!
src = os.path.join(os.path.join(_InputData.output_path, "changeparameters_couple.tfs"))
dst = os.path.join(os.path.join(_InputData.output_path, "changeparameters_couple.knob"))
Utilities.iotools.copy_item(src, dst)
##### for bumps
if "bumps" in _InputData.variables_list:
print "passing trough bumps loop"
v = metaclass.twiss(os.path.join(_InputData.output_path, "changeparameters_couple.tfs")) # @UnusedVariable
# v will be used in Bumps.py. Don't do such things again!(vimaier)
Utilities.iotools.delete_item(os.path.join(_InputData.output_path, "changeparameters_couple.tfs"))
corrs = None # Will be assigned in exec Bumps.py (vimaier)
execfile(os.path.join(_InputData.path_to_optics_files_dir, "Bumps.py"))
execfile(os.path.join(_InputData.path_to_optics_files_dir, "mydictionary.py"))
tfs_file_writer = Utilities.tfs_file_writer.TfsFileWriter("changeparameters_couple.tfs", _InputData.output_path)
tfs_file_writer.add_column_names("NAME DELTA".split())
tfs_file_writer.add_column_datatypes("%s %le".split())
for vcorr in corrs:
tfs_file_writer.add_table_row([vcorr, corrs[vcorr]])
tfs_file_writer.write_to_file()
#####
v = metaclass.twiss(os.path.join(_InputData.output_path, "changeparameters_couple.tfs"))
mad_script = open(os.path.join(_InputData.output_path, "changeparameters_couple.madx"), "w")
names = getattr(v, "NAME", [])
delta = getattr(v, "DELTA", [])
for i in range(len(names)):
if "bumps" in _InputData.variables_list:
if cmp(delta[i], 0) == 1:
mad_script.write(names[i] + "->KICK:=" + str(delta[i]) + ";\n")
else:
mad_script.write(names[i] + "->KICK:=" + str(delta[i]) + ";\n")
else:
if cmp(delta[i], 0) == 1:
mad_script.write(names[i] + " = " + names[i] + " + " + str(delta[i]) + ";\n")
else:
mad_script.write(names[i] + " = " + names[i] + " " + str(delta[i]) + ";\n")
mad_script.write("return;")
mad_script.close()
def _compare_output_betas(self, output_path):
print "Comparing output..."
if len(self._errors[output_path]) == 0:
beta_x_twiss = metaclass.twiss(os.path.join(output_path, "getbetax.out"))
beta_y_twiss = metaclass.twiss(os.path.join(output_path, "getbetay.out"))
for index in range(len(beta_x_twiss.NAME)):
rel_error = abs((beta_x_twiss.BETX[index] - beta_x_twiss.BETXMDL[index]) / beta_x_twiss.BETXMDL[index])
self.assertTrue(
rel_error < MAX_BETA_REL_ERR,
"Relative error too big found in: " + beta_x_twiss.NAME[index] + " (" + str(rel_error) + ")",
)
for index in range(len(beta_y_twiss.NAME)):
rel_error = abs((beta_y_twiss.BETY[index] - beta_y_twiss.BETYMDL[index]) / beta_y_twiss.BETYMDL[index])
self.assertTrue(
rel_error < MAX_BETA_REL_ERR,
"Relative error too big found in: " + beta_y_twiss.NAME[index] + " (" + str(rel_error) + ")",
)
else:
print "Manual errors in the madx job: skipping betas check"
def _loadtwiss_beta(varandpath):
(var, path) = varandpath
# print "Reading twiss." + var
x = 0
try:
x = metaclass.twiss(path + "/twiss." + var)
os.remove(path + "/twiss." + var)
except IOError as e:
print e
return []
return var, x
def __init__(self, matcher_name, matcher_dict, match_path):
super(AmpMatcher, self).__init__(matcher_name, matcher_dict, match_path)
self._sbs_amp_data = {}
for beam in self.get_beams():
self._sbs_amp_data[beam] = {}
for plane in ["x", "y"]:
sbs_amp_data_path = os.path.join(
self.get_match_data(beam).get_beam_match_sbs_path(),
'sbsampbetabeat' + plane + '_IP' + str(self._ip) + '.out'
)
self._sbs_amp_data[beam][plane] = metaclass.twiss(sbs_amp_data_path)
def _loadtwiss_coup(varandpath):
var, path = varandpath
# print "Reading twiss." + var
x = 0
try:
x = metaclass.twiss(path + "/twiss." + var)
x.Cmatrix()
os.remove(path + "/twiss." + var)
except IOError as e:
print e
return []
return var, x
