def _write_Elegant(self):
wholestring = ''
etype = self._convertType_Elegant(self.objecttype)
string = self.objectname + ': ' + etype
k1 = self.k1 if self.k1 is not None else 0
for key, value in list(
merge_two_dicts({
'k1': k1
}, merge_two_dicts(self.objectproperties,
self.objectdefaults)).items()):
if not key is 'name' and not key is 'type' and not key is 'commandtype' and self._convertKeword_Elegant(
key) in elements_Elegant[etype]:
value = getattr(self, key) if hasattr(self, key) and getattr(
self, key) is not None else value
key = self._convertKeword_Elegant(key)
value = 1 if value is True else value
value = 0 if value is False else value
tmpstring = ', ' + key + ' = ' + str(value)
if len(string + tmpstring) > 76:
wholestring += string + ',&\n'
string = ''
string += tmpstring[2::]
else:
string += tmpstring
wholestring += string + ';\n'
return wholestring
def __init__(self, objectname=None, objecttype=None, **kwargs):
super(frameworkObject, self).__init__()
if 'global_parameters' in kwargs:
self.global_parameters = kwargs['global_parameters']
if objectname == None:
raise NameError('Command does not have a name')
if objecttype == None:
raise NameError('Command does not have a type')
setattr(self, 'objectdefaults', OrderedDict())
setattr(self, 'objectname', objectname)
setattr(self, 'objecttype', objecttype)
if self.objecttype in commandkeywords:
self.allowedkeywords = commandkeywords[self.objecttype]
elif self.objecttype in elementkeywords:
self.allowedkeywords = merge_two_dicts(
elementkeywords[self.objecttype]['keywords'],
elementkeywords['common']['keywords'])
if 'framework_keywords' in elementkeywords[self.objecttype]:
self.allowedkeywords = merge_two_dicts(
self.allowedkeywords,
elementkeywords[self.objecttype]['framework_keywords'])
else:
print(('Unknown type = ', objecttype))
raise NameError
self.allowedkeywords = [x.lower() for x in self.allowedkeywords]
for key, value in list(kwargs.items()):
self.add_property(key, value)
def calculateBeamParameters(self):
twiss = self.twiss
self.framework.change_Lattice_Code('All', 'elegant')
self.framework.defineElegantCommand(location=['elegant'])
self.framework[self.start_file].prefix = self.base_files
self.framework[self.start_file].sample_interval = 2**(3 * 4)
self.framework.track(startfile=self.start_file)
constraintsList = {}
twiss.reset_dicts()
for lat in ['PostBA1']:
quadkls = self.framework[lat].getElementType('quadrupole', 'k1l')
quadlengths = self.framework[lat].getElementType(
'quadrupole', 'length')
constraintsListQuads = {
'max_k_' + lat: {
'type': 'lessthan',
'value': [abs(k) for k, l in zip(quadkls, quadlengths)],
'limit': 5.0,
'weight': 75
},
}
constraintsList = merge_two_dicts(constraintsList,
constraintsListQuads)
twiss.read_elegant_twiss_files([self.dirname + '/PostBA1.twi'])
constraintsListTwiss = {
'max_betax': {
'type': 'lessthan',
'value': max(twiss['beta_x']),
'limit': 10,
'weight': 150
},
'max_betay': {
'type': 'lessthan',
'value': max(twiss['beta_y']),
'limit': 10,
'weight': 150
},
'dump_etax': {
'type': 'equalto',
'value': twiss['eta_x'][-1],
'limit': 0.67,
'weight': 5000
},
}
constraintsList = merge_two_dicts(constraintsList,
constraintsListTwiss)
self.constraintsList = constraintsList
fitness = self.cons.constraints(constraintsList)
if self.verbose:
print(self.cons.constraintsList(constraintsList))
return fitness
def calculateBeamParameters(self):
# try:
twiss = self.twiss
self.framework.change_Lattice_Code('All','elegant')
self.framework['S02'].prefix = self.base_files
self.framework.track(startfile='S02', endfile='FMS')
constraintsList = {}
quadkls = self.framework.getElementType('quadrupole','k1l')
quadlengths = self.framework.getElementType('quadrupole','length')
quadnames = self.framework.getElementType('quadrupole','objectname')
constraintsListQuads = {
'max_k': {'type': 'lessthan', 'value': [abs(k/l) for k, l, n in zip(quadkls, quadlengths, quadnames) if not 'FMS' in n], 'limit': 2.5, 'weight': 10},
}
constraintsList = merge_two_dicts(constraintsList, constraintsListQuads)
twiss.read_elegant_twiss_files( [ self.dirname+'/'+n+'.twi' for n in ['S02', 'L02', 'S03', 'L03', 'S04', 'L4H', 'S05', 'S06', 'L04', 'S07', 'FMS']])
constraintsListSigmas = {
'max_xrms': {'type': 'lessthan', 'value': 1e3*twiss['sigma_x'], 'limit': 1, 'weight': 5},
'max_yrms': {'type': 'lessthan', 'value': 1e3*twiss['sigma_y'], 'limit': 1, 'weight': 5},
'min_xrms': {'type': 'greaterthan', 'value': 1e3*twiss['sigma_x'], 'limit': 0.1, 'weight': 5},
'min_yrms': {'type': 'greaterthan', 'value': 1e3*twiss['sigma_y'], 'limit': 0.1, 'weight': 5},
'last_exn': {'type': 'lessthan', 'value': 1e6*twiss['enx'][-1], 'limit': 0.75, 'weight': 100},
'last_eyn': {'type': 'lessthan', 'value': 1e6*twiss['eny'][-1], 'limit': 0.75, 'weight': 100},
}
constraintsList = merge_two_dicts(constraintsList, constraintsListSigmas)
twiss.read_elegant_twiss_files(self.dirname+'/S07.twi')
tdc_position = self.framework['CLA-S07-TDC-01-R']['position_start'][2]
tdc_screen_position = self.framework['CLA-S07-DIA-SCR-03-W']['position_start'][2]
dechirper_position = self.framework['CLA-S07-DCP-01']['position_start'][2]
constraintsListS07 = {
# 'tdc_phase_advance': {'type': 'equalto', 'value': twiss.interpolate(tdc_screen_position,'muy') - twiss.interpolate(tdc_position,'muy'), 'limit': 0.25, 'weight': 0.5},
# 'tdc_screen_beta_y': {'type': 'greaterthan', 'value': twiss.extract_values('beta_y', tdc_position, tdc_screen_position), 'limit': 5, 'weight': 1},
'dechirper_sigma_x': {'type': 'lessthan', 'value': 1e3*twiss.interpolate(dechirper_position, 'sigma_x'), 'limit': 0.1, 'weight': 10},
'dechirper_sigma_y': {'type': 'lessthan', 'value': 1e3*twiss.interpolate(dechirper_position, 'sigma_y'), 'limit': 0.1, 'weight': 10},
'dechirper_sigma_xy': {'type': 'equalto', 'value': 1e3*twiss.interpolate(dechirper_position, 'sigma_y') - 1e3*twiss.interpolate(dechirper_position, 'sigma_x'), 'limit': 0.0, 'weight': 10},
}
constraintsList = merge_two_dicts(constraintsList, constraintsListS07)
fitness = self.cons.constraints(constraintsList)
if self.verbose:
print(self.cons.constraintsList(constraintsList))
return fitness
def add_Generator(self, default=None, **kwargs):
if default in astra_generator_keywords['defaults']:
self.generator = ASTRAGenerator(
self.executables, self.global_parameters,
**merge_two_dicts(
kwargs, astra_generator_keywords['defaults'][default]))
else:
self.generator = ASTRAGenerator(self.executables,
self.global_parameters, **kwargs)
self.latticeObjects['generator'] = self.generator
def __init__(self, elementName=None, elementType=None, **kwargs):
super(frameworkElement, self).__init__(elementName, elementType,
**kwargs)
self.add_default('length', 0)
self.add_property('position_errors', [0, 0, 0])
self.add_property('rotation_errors', [0, 0, 0])
self.add_default('global_rotation', [0, 0, 0])
self.add_default('starting_rotation', 0)
self.keyword_conversion_rules_elegant = keyword_conversion_rules_elegant[
'general']
if elementType in keyword_conversion_rules_elegant:
self.keyword_conversion_rules_elegant = merge_two_dicts(
self.keyword_conversion_rules_elegant,
keyword_conversion_rules_elegant[elementType])
def write(self):
output = '&INPUT\n'
try:
npart = eval(self.number_of_particles)
except:
npart = self.number_of_particles
if self.filename is None:
self.filename = 'laser.generator'
framework_dict = OrderedDict([
['FName', {
'value': self.filename,
'default': 'laser.generator'
}],
['q_total', {
'value': self.charge * 1e9,
'default': 0.25
}],
['Ipart', {
'value': npart,
'default': 2**(3 * 3)
}],
])
keyword_dict = OrderedDict()
for k in astra_generator_keywords['keywords']:
k = k.lower()
if getattr(self, k) is not None:
try:
val = eval(getattr(self, k))
except:
val = getattr(self, k)
keyword_dict[k] = {'value': val}
output += self._write_ASTRA(
merge_two_dicts(framework_dict, keyword_dict))
output += '\n/\n'
saveFile(
self.global_parameters['master_subdir'] + '/' + self.objectname +
'.in', output)
def calculate_constraints(self):
beam = self.beam
constraintsList = {}
quadkls = self.framework.getElementType('quadrupole', 'k1l')
quadlengths = self.framework.getElementType('quadrupole', 'length')
quadnames = self.framework.getElementType('quadrupole', 'objectname')
self.beam.read_HDF5_beam_file(self.dirname + '/CLA-S07-APER-01.hdf5')
self.beam.slice_length = 0.01e-12
t = 1e12 * (self.beam.t - np.mean(self.beam.t))
p = 1e-6 * (self.beam.cp - np.mean(self.beam.cp))
t_grid = np.linspace(min(t), max(t), 2**8)
p_grid = np.linspace(min(p), max(p), 2**8)
peakIPDF = self.beam.PDFI(
t, t_grid, bandwidth=self.beam.rms(t) / (2**3)) * 250
peakPPDF = self.beam.PDFI(p,
p_grid,
bandwidth=self.beam.rms(p) / (2**3))
peakICDF = self.beam.CDF(t,
t_grid,
bandwidth=self.beam.rms(t) / (2**3))
peakIFWHM, indexes = self.beam.FWHM(t_grid, peakIPDF, frac=0.5)
peakPFWHM, indexesp = self.beam.FWHM(p_grid, peakPPDF, frac=0.5)
peakIFWHM2, indexes2 = self.beam.FWHM(t_grid, peakIPDF, frac=2)
stdpeakIPDF = np.std(
peakIPDF[indexes2]
) #(max(peakIPDF[indexes2]) - min(peakIPDF[indexes2]))/np.mean(peakIPDF[indexes2]) # Flat-top in the distribution!
# print('stdpeakIPDF = ', stdpeakIPDF)
# print 'Peak Fraction = ', 100*peakICDF[indexes][-1]-peakICDF[indexes][0], stdpeakIPDF
self.beam.bin_time()
t = 1e12 * (self.beam.t - np.mean(self.beam.t))
dt = self.beam.slice_length * (max(t) - min(t))
sigmat = np.std(t)
sigmap = np.std(self.beam.p)
meanp = np.mean(self.beam.p)
fitp = 100 * sigmap / meanp
peakI, peakIstd, peakIMomentumSpread, peakIEmittanceX, peakIEmittanceY, peakIMomentum, peakIDensity = self.beam.sliceAnalysis(
)
peakI = max(peakIPDF)
# chirp = self.beam.chirp
chirp = 1e-6 * (max(self.beam.cp) - min(self.beam.cp))
slinac_fields = np.array([1e-6 * self.linac_fields[i] for i in [0, 1]])
x4hlinac_fields = np.array([1e-6 * self.linac_fields[i] for i in [2]])
xlinac_fields = np.array(
[1e-6 * self.linac_fields[i] for i in [4, 5, 6]])
self.twiss.read_elegant_twiss_files(self.dirname + '/CLARAX.twi')
ipindex = list(
self.twiss.elegant['ElementName']).index('CLA-S07-APER-01')
constraintsListXARA = {
# 'ip_enx': {'type': 'lessthan', 'value': 1e6*self.twiss.elegant['enx'][ipindex], 'limit': 2, 'weight': 0},
# 'ip_eny': {'type': 'lessthan', 'value': 1e6*self.twiss.elegant['eny'][ipindex], 'limit': 0.5, 'weight': 2.5},
'field_max_s': {
'type': 'lessthan',
'value': slinac_fields,
'limit': 32,
'weight': 300
},
'field_max_x': {
'type': 'lessthan',
'value': xlinac_fields,
'limit': 80,
'weight': 300
},
'field_max_x4h': {
'type': 'lessthan',
'value': x4hlinac_fields,
'limit': 35,
'weight': 300
},
'momentum_max': {
'type': 'lessthan',
'value': 0.511 * self.twiss.elegant['pCentral0'][ipindex],
'limit': 1050,
'weight': 250
},
'momentum_min': {
'type': 'greaterthan',
'value': 0.511 * self.twiss.elegant['pCentral0'][ipindex],
'limit': 990,
'weight': 150
},
'peakI_min': {
'type': 'greaterthan',
'value': abs(peakI),
'limit': 1000,
'weight': 2000
},
'peakI_max': {
'type': 'lessthan',
'value': abs(peakI),
'limit': 1025,
'weight': 2000
},
# 'peakIMomentumSpread': {'type': 'lessthan', 'value': peakIMomentumSpread, 'limit': 0.1, 'weight': 2},
'peakIEmittanceX': {
'type': 'lessthan',
'value': 1e6 * peakIEmittanceX,
'limit': 0.75,
'weight': 15
},
'peakIEmittanceY': {
'type': 'lessthan',
'value': 1e6 * peakIEmittanceY,
'limit': 0.75,
'weight': 1.5
},
'peakIFWHM': {
'type': 'lessthan',
'value': peakIFWHM,
'limit': 1,
'weight': 100
},
'stdpeakIFWHM': {
'type': 'lessthan',
'value': stdpeakIPDF,
'limit': 30,
'weight': 50
},
'peakIFraction': {
'type': 'greaterthan',
'value': 100 * peakICDF[indexes][-1] - peakICDF[indexes][0],
'limit': 90,
'weight': 20
},
'chirp': {
'type': 'lessthan',
'value': abs(chirp),
'limit': 0.5,
'weight': 25
},
}
constraintsList = merge_two_dicts(constraintsList, constraintsListXARA)
fitness = self.cons.constraints(constraintsList)
if self.plotting and fitness < self.bestfit:
ax[0][0].clear()
ax[0][1].clear()
ax[0][2].clear()
ax[1][0].clear()
ax[1][1].clear()
ax[1][2].clear()
exponent = np.floor(np.log10(np.abs(self.beam.slice_length)))
x = 10**(12) * np.array(
(self.beam.slice_bins - np.mean(self.beam.t)))
ax[0][0].plot(t_grid, peakIPDF, color='blue', alpha=0.5, lw=3)
ax[0][0].fill_between(t_grid[indexes],
peakIPDF[indexes],
0,
facecolor='gray',
edgecolor='gray',
alpha=0.4)
ax[0][0].set(xlabel='t (ps)', ylabel='I [A]')
ax[0][1].plot(p_grid, peakPPDF, color='blue', alpha=0.5, lw=3)
ax[0][1].fill_between(p_grid[indexesp],
peakPPDF[indexesp],
0,
facecolor='gray',
edgecolor='gray',
alpha=0.4)
ax[0][1].set(xlabel='cp (MeV/c)', ylabel='Vector Potential [V]')
ax[0][2].set_xlim(min(t) - dt, max(t) + dt)
t = 1e12 * (self.beam.t - np.mean(self.beam.t))
p = 1e-6 * self.beam.cp
ymax = max(p) + 1
ymin = min(p) - 1
if ymax - ymin < 5:
ymax = np.mean(p) + 2.5
ymin = np.mean(p) - 2.5
ax[0][2].hist2d(t,
p,
bins=(50, 50),
cmap=plt.cm.jet,
range=[[min(t), max(t)], [ymin, ymax]])
# ax[0][2].set_ylim(top=ymax, bottom=ymin)
ax[0][2].set(ylabel='cp [Mev]')
ax[1][0].plot(
x, 1e6 * self.beam.slice_normalized_horizontal_emittance)
ax[1][0].plot(x,
1e6 * self.beam.slice_normalized_vertical_emittance)
ax[1][0].set_ylim(top=3, bottom=0)
ax[1][0].set(ylabel='emit_x / emit_y [m]')
ax[1][0].grid()
ax[1][1].plot(self.twiss.elegant['s'],
0.511 * self.twiss.elegant['pCentral0'])
# ax[1][1].set_ylim(top=1100, bottom=0)
ax[1][1].set(ylabel='Momentum [MeV/c]')
ax[1][1].grid()
ax[1][2].plot(self.twiss.elegant['s'], 1e3 * self.twiss['sigma_x'])
ax[1][2].plot(self.twiss.elegant['s'], 1e3 * self.twiss['sigma_y'])
ax[1][2].set(ylabel='sigma_x / sigma_y [m]')
ax[1][2].grid()
# fig.canvas.draw_idle()
# plt.draw()
plt.pause(0.001)
if self.verbose:
print(self.cons.constraintsList(constraintsList))
return constraintsList
def calculate_constraints(self):
constraintsList = {}
quadkls = self.framework.getElementType('quadrupole', 'k1l')
quadlengths = self.framework.getElementType('quadrupole', 'length')
quadnames = self.framework.getElementType('quadrupole', 'objectname')
self.beam.read_HDF5_beam_file(self.dirname + '/CLA-FEH-FOCUS-01.hdf5')
self.beam.slice_length = 0.05e-12
t = 1e12 * (self.beam.t - np.mean(self.beam.t))
t_grid = np.linspace(min(t), max(t), 2**8)
peakIPDF = self.beam.PDF(t,
t_grid,
bandwidth=self.beam.rms(t) / (2**4))
peakICDF = self.beam.CDF(t,
t_grid,
bandwidth=self.beam.rms(t) / (2**4))
peakIFWHM, indexes = self.beam.FWHM(t_grid, peakIPDF, frac=4)
# peakIFWHM2, indexes2 = self.beam.FWHM(t_grid, peakIPDF, frac=10)
# stdpeakIPDF = (max(peakIPDF[indexes2]) - min(peakIPDF[indexes2]))/np.mean(peakIPDF[indexes2])
# print('stdpeakIPDF = ', stdpeakIPDF)
# print 'Peak Fraction = ', 100*peakICDF[indexes][-1]-peakICDF[indexes][0], peakICDF[indexes][-1], peakICDF[indexes][0]
#
# import matplotlib.pyplot as plt
# fig, ax = plt.subplots(1, 2, sharey=False,
# figsize=(13, 3))
#
# i=0
# ax[0].plot(t_grid, peakIPDF, color='blue', alpha=0.5, lw=3)
# ax[0].fill_between(t_grid[indexes], peakIPDF[indexes], 0, facecolor='gray', edgecolor='gray', alpha=0.4)
# ax[1].plot(t_grid, peakICDF, color='blue', alpha=0.5, lw=3)
# ax[1].fill_between(t_grid[indexes], peakICDF[indexes], 0, facecolor='gray', edgecolor='gray', alpha=0.4)
# plt.show()
# exit()
self.beam.bin_time()
sigmat = np.std(t)
sigmap = np.std(self.beam.p)
meanp = np.mean(self.beam.p)
# emitx = 1e6*self.beam.normalized_horizontal_emittance
# emity = 1e6*self.beam.normalized_horizontal_emittance
# density = self.beam.density
fitp = 100 * sigmap / meanp
peakI, peakIstd, peakIMomentumSpread, peakIEmittanceX, peakIEmittanceY, peakIMomentum, peakIDensity = self.beam.sliceAnalysis(
)
fhc_field = np.array([1e-6 * self.linac_fields[i] for i in [3]])
linac_fields = np.array(
[1e-6 * self.linac_fields[i] for i in [0, 1, 2, 4]])
self.twiss.read_elegant_twiss_files(self.dirname + '/FEBE.twi')
ipindex = list(
self.twiss.elegant['ElementName']).index('CLA-FEH-FOCUS-01')
ipindex2 = list(
self.twiss.elegant['ElementName']).index('CLA-FEH-FOCUS-02')
constraintsListFEBE = {
# 'ip_enx': {'type': 'lessthan', 'value': 1e6*self.twiss.elegant['enx'][ipindex], 'limit': 2, 'weight': 0},
# 'ip_eny': {'type': 'lessthan', 'value': 1e6*self.twiss.elegant['eny'][ipindex], 'limit': 0.5, 'weight': 2.5},
'field_max': {
'type': 'lessthan',
'value': linac_fields,
'limit': 32,
'weight': 3000
},
'field_max_fhc': {
'type': 'lessthan',
'value': fhc_field,
'limit': 50,
'weight': 3000
},
'momentum_max': {
'type': 'lessthan',
'value': 0.511 * self.twiss.elegant['pCentral0'][ipindex],
'limit': 260,
'weight': 250
},
'momentum_min': {
'type': 'greaterthan',
'value': 0.511 * self.twiss.elegant['pCentral0'][ipindex],
'limit': 240,
'weight': 150
},
# 'sigma_x_IP': {'type': 'lessthan', 'value': self.twiss.elegant['Sx'][ipindex], 'limit': 15e-6, 'weight': 15},
# 'sigma_y_IP': {'type': 'lessthan', 'value': self.twiss.elegant['Sy'][ipindex], 'limit': 8e-6, 'weight': 15},
'sigma_x_max': {
'type': 'lessthan',
'value': 1e3 * 6 * self.twiss.elegant['Sx'][:ipindex2],
'limit': 37,
'weight': 150
},
'sigma_y_max': {
'type': 'lessthan',
'value': 1e3 * 6 * self.twiss.elegant['Sy'][:ipindex2],
'limit': 37,
'weight': 150
},
'peakI_min': {
'type': 'greaterthan',
'value': abs(peakI),
'limit': 5000,
'weight': 100
},
# 'peakI_max': {'type': 'lessthan', 'value': abs(peakI), 'limit': 1050, 'weight': 20},
# 'peakIMomentumSpread': {'type': 'lessthan', 'value': peakIMomentumSpread, 'limit': 0.1, 'weight': 2},
'peakIEmittanceX': {
'type': 'lessthan',
'value': 1e6 * peakIEmittanceX,
'limit': 25,
'weight': 1.5
},
'peakIEmittanceY': {
'type': 'lessthan',
'value': 1e6 * peakIEmittanceY,
'limit': 1,
'weight': 1.5
},
'peakIFWHM': {
'type': 'lessthan',
'value': peakIFWHM,
'limit': 0.03,
'weight': 50
},
# 'stdpeakIFWHM': {'type': 'lessthan','value': stdpeakIPDF, 'limit': 1, 'weight': 0},
'peakIFraction': {
'type': 'greaterthan',
'value': 100 * peakICDF[indexes][-1] - peakICDF[indexes][0],
'limit': 75,
'weight': 25
},
}
constraintsList = merge_two_dicts(constraintsList, constraintsListFEBE)
# fitness = self.cons.constraints(constraintsList)
if self.verbose:
print(self.cons.constraintsList(constraintsList))
return constraintsList
def optFuncVELA(args, track=True):
global dir, lattice, bestdelta
try:
offset = 6
if offset > 0:
lattice.modifyElement('CLA-S02-MAG-QUAD-01', 'k1l', args[0])
lattice.modifyElement('CLA-S02-MAG-QUAD-02', 'k1l', args[1])
lattice.modifyElement('CLA-S02-MAG-QUAD-03', 'k1l', args[2])
lattice.modifyElement('CLA-S02-MAG-QUAD-04', 'k1l', args[3])
lattice.modifyElement('CLA-C2V-MAG-QUAD-01', 'k1l', args[4])
lattice.modifyElement('CLA-C2V-MAG-QUAD-02', 'k1l', args[5])
lattice.modifyElement('CLA-C2V-MAG-QUAD-03', 'k1l', args[4])
lattice.modifyElement('EBT-INJ-MAG-QUAD-07', 'k1l', args[offset + 0])
lattice.modifyElement('EBT-INJ-MAG-QUAD-08', 'k1l', args[offset + 1])
lattice.modifyElement('EBT-INJ-MAG-QUAD-09', 'k1l', args[offset + 2])
lattice.modifyElement('EBT-INJ-MAG-QUAD-10', 'k1l', args[offset + 3])
lattice.modifyElement('EBT-INJ-MAG-QUAD-11', 'k1l', args[offset + 4])
lattice.modifyElement('EBT-INJ-MAG-QUAD-15', 'k1l', args[offset + 5])
lattice.modifyElement('EBT-BA1-MAG-QUAD-01', 'k1l', args[offset + 6])
lattice.modifyElement('EBT-BA1-MAG-QUAD-02', 'k1l', args[offset + 7])
lattice.modifyElement('EBT-BA1-MAG-QUAD-03', 'k1l', args[offset + 8])
lattice.modifyElement('EBT-BA1-MAG-QUAD-04', 'k1l', args[offset + 9])
lattice.modifyElement('EBT-BA1-MAG-QUAD-05', 'k1l', args[offset + 10])
lattice.modifyElement('EBT-BA1-MAG-QUAD-06', 'k1l', args[offset + 11])
lattice.modifyElement('EBT-BA1-MAG-QUAD-07', 'k1l', args[offset + 12])
delta = 0
if track:
lattice.track(startfile='S02', endfile='S02', track=True)
constraintsList = {}
twiss.reset_dicts()
twiss.read_elegant_twiss_files(dir + '/S02.twi')
c2v1index = list(twiss['element_name']).index('CLA-C2V-MARK-01')
c2v2index = list(twiss['element_name']).index('CLA-C2V-MARK-02')
ipindex = list(twiss['element_name']).index('EBT-BA1-COFFIN-FOC')
constraintsListBA1 = {
'BA1_max_betax': {
'type': 'lessthan',
'value': twiss['beta_x'][c2v2index:ipindex],
'limit': 30,
'weight': 150
},
'BA1_max_betay': {
'type': 'lessthan',
'value': twiss['beta_y'][c2v2index:ipindex],
'limit': 30,
'weight': 150
},
'c2v_betax': {
'type': 'equalto',
'value': twiss['beta_x'][c2v1index],
'limit': twiss['beta_x'][c2v2index],
'weight': 10
},
'c2v_betay': {
'type': 'equalto',
'value': twiss['beta_y'][c2v1index],
'limit': twiss['beta_y'][c2v2index],
'weight': 10
},
'c2v_alphax': {
'type': 'equalto',
'value': twiss['alpha_x'][c2v1index],
'limit': -1 * twiss['alpha_x'][c2v2index],
'weight': 10
},
'c2v_alphay': {
'type': 'equalto',
'value': twiss['alpha_y'][c2v1index],
'limit': -1 * twiss['alpha_y'][c2v2index],
'weight': 10
},
'c2v_etax': {
'type': 'lessthan',
'value': abs(twiss['eta_x'][c2v2index]),
'limit': 1e-4,
'weight': 50
},
'c2v_etaxp': {
'type': 'lessthan',
'value': abs(twiss['eta_xp'][c2v2index]),
'limit': 1e-4,
'weight': 50
},
'ip_betax': {
'type': 'lessthan',
'value': twiss['beta_x'][ipindex],
'limit': 0.5,
'weight': 25
},
'ip_betay': {
'type': 'lessthan',
'value': twiss['beta_y'][ipindex],
'limit': 0.5,
'weight': 25
},
'ip_alphax': {
'type': 'equalto',
'value': twiss['alpha_x'][ipindex],
'limit': 0.,
'weight': 2.5
},
'ip_alphay': {
'type': 'equalto',
'value': twiss['alpha_y'][ipindex],
'limit': 0.,
'weight': 2.5
},
'ip_etax': {
'type': 'lessthan',
'value': abs(twiss['eta_x'][ipindex]),
'limit': 1e-4,
'weight': 50
},
'ip_etaxp': {
'type': 'lessthan',
'value': abs(twiss['eta_xp'][ipindex]),
'limit': 1e-4,
'weight': 50
},
'dump_etax': {
'type': 'equalto',
'value': twiss['eta_x'][-1],
'limit': 0.67,
'weight': 5000
},
'dump_betax': {
'type': 'lessthan',
'value': twiss['beta_x'][-1],
'limit': 20,
'weight': 1.5
},
'dump_betay': {
'type': 'lessthan',
'value': twiss['beta_y'][-1],
'limit': 20,
'weight': 1.5
},
}
constraintsList = merge_two_dicts(constraintsList,
constraintsListBA1)
cons = constraintsClass()
delta = cons.constraints(constraintsList)
updateOutput('VELA delta = ' + str(delta))
if delta < bestdelta:
bestdelta = delta
print('### New Best: ', delta)
# print(*args, sep = ", ")
print '[', ', '.join(map(str, args)), ']'
# print(cons.constraintsList(constraintsList))
except:
delta = 1e6
else:
return delta
def calculateBeamParameters(self):
twiss = self.twiss
self.framework[
self.start_file].prefix = self.CLARA_dir + '/basefiles_' + str(
self.scaling) + '/'
# print('prefix basedir = ', self.CLARA_dir, self.framework[self.start_file].prefix)
self.framework[self.start_file].sample_interval = 2**(3 * 2)
# print ('############### STARTING TRACKING ###############')
self.framework.track(startfile=self.start_file)
# print ('############### ENDING TRACKING ###############')
constraintsList = {}
twiss.reset_dicts()
for lat in ['CLARAX']:
quadkls = self.framework[lat].getElementType('quadrupole', 'k1l')
quadlengths = self.framework[lat].getElementType(
'quadrupole', 'length')
constraintsListQuads = {
'max_k_' + lat: {
'type': 'lessthan',
'value': [abs(k) for k, l in zip(quadkls, quadlengths)],
'limit': 2.0,
'weight': 75
},
}
constraintsList = merge_two_dicts(constraintsList,
constraintsListQuads)
twiss.read_elegant_twiss_files([self.dirname + '/CLARAX.twi'])
ipindex1 = list(twiss['element_name']).index('CLA-S05-MARK-01')
ipindex2 = list(twiss['element_name']).index('CLA-S06-MARK-01')
constraintsListFEBE = {
'min_sigmax_1': {
'type': 'greaterthan',
'value': 1e3 * twiss['sigma_x'][:ipindex1],
'limit': 0.25,
'weight': 15
},
'min_sigmax_2': {
'type': 'greaterthan',
'value': 1e3 * twiss['sigma_x'][ipindex2:],
'limit': 0.05,
'weight': 15
},
'min_sigmay_1': {
'type': 'greaterthan',
'value': 1e3 * twiss['sigma_y'][:ipindex1],
'limit': 0.25,
'weight': 15
},
'min_sigmay_2': {
'type': 'greaterthan',
'value': 1e3 * twiss['sigma_y'][ipindex2:],
'limit': 0.05,
'weight': 15
},
'max_sigmax_1': {
'type': 'lessthan',
'value': 1e3 * twiss['sigma_x'][:ipindex1],
'limit': 1,
'weight': 15
},
'max_sigmax_2': {
'type': 'lessthan',
'value': 1e3 * twiss['sigma_x'][ipindex2:],
'limit': 0.25,
'weight': 15
},
'max_sigmay_1': {
'type': 'lessthan',
'value': 1e3 * twiss['sigma_y'][:ipindex1],
'limit': 1,
'weight': 15
},
'max_sigmay_2': {
'type': 'lessthan',
'value': 1e3 * twiss['sigma_y'][ipindex2:],
'limit': 0.25,
'weight': 15
},
'max_emitx_2': {
'type': 'lessthan',
'value': 1e6 * twiss['enx'][ipindex2:],
'limit': 2.0,
'weight': 0
},
'max_emity_2': {
'type': 'lessthan',
'value': 1e6 * twiss['eny'][ipindex2:],
'limit': 0.6,
'weight': 15
},
}
constraintsList = merge_two_dicts(constraintsList, constraintsListFEBE)
self.beam.read_HDF5_beam_file(self.dirname + '/CLA-S07-APER-01.hdf5')
self.beam.slice_length = 0.01e-12
t = 1e12 * (self.beam.t - np.mean(self.beam.t))
t_grid = np.linspace(min(t), max(t), 2**8)
peakIPDF = self.beam.PDF(t,
t_grid,
bandwidth=self.beam.rms(t) / (2**4))
peakICDF = self.beam.CDF(t,
t_grid,
bandwidth=self.beam.rms(t) / (2**4))
peakIFWHM, indexes = self.beam.FWHM(t_grid, peakIPDF, frac=0.5)
peakIFWHM2, indexes2 = self.beam.FWHM(t_grid, peakIPDF, frac=2)
stdpeakIPDF = (max(peakIPDF[indexes2]) -
min(peakIPDF[indexes2])) / np.mean(peakIPDF[indexes2])
# print('stdpeakIPDF = ', stdpeakIPDF)
# print 'Peak Fraction = ', 100*peakICDF[indexes][-1]-peakICDF[indexes][0], stdpeakIPDF
self.beam.bin_time()
t = 1e12 * (self.beam.t - np.mean(self.beam.t))
dt = 0.05 * (max(t) - min(t))
self.constraintsList = constraintsList
fitness = self.cons.constraints(constraintsList)
if self.verbose:
print(self.cons.constraintsList(constraintsList))
if fitness < self.bestfit:
ax[0][0].clear()
ax[0][1].clear()
ax[0][2].clear()
ax[1][0].clear()
ax[1][1].clear()
ax[1][2].clear()
exponent = np.floor(np.log10(np.abs(self.beam.slice_length)))
x = 10**(12) * np.array(
(self.beam.slice_bins - np.mean(self.beam.t)))
ax[0][0].plot(x, self.beam.slice_peak_current)
ax[0][0].set(xlabel='t (ps)', ylabel='I [A]')
ax[0][1].plot(t_grid, peakIPDF, color='blue', alpha=0.5, lw=3)
ax[0][1].fill_between(t_grid[indexes],
peakIPDF[indexes],
0,
facecolor='gray',
edgecolor='gray',
alpha=0.4)
# ax[0][1].plot(t_grid, peakICDF, color='blue', alpha=0.5, lw=3)
# ax[0][1].fill_between(t_grid[indexes], peakICDF[indexes], 0, facecolor='gray', edgecolor='gray', alpha=0.4)
ax[0][2].set_xlim(min(t) - dt, max(t) + dt)
t = 1e12 * (self.beam.t - np.mean(self.beam.t))
p = 1e-6 * self.beam.cp
ymax = max(p) + 1
ymin = min(p) - 1
if ymax - ymin < 5:
ymax = np.mean(p) + 2.5
ymin = np.mean(p) - 2.5
ax[0][2].hist2d(t,
p,
bins=(50, 50),
cmap=plt.cm.jet,
range=[[min(t), max(t)], [ymin, ymax]])
# ax[0][2].set_ylim(top=ymax, bottom=ymin)
ax[0][2].set(ylabel='cp [Mev]')
ax[1][0].plot(twiss.elegant['s'], 1e6 * twiss.elegant['enx'])
ax[1][0].plot(twiss.elegant['s'], 1e6 * twiss.elegant['eny'])
ax[1][0].set_ylim(top=3, bottom=0)
ax[1][0].set(ylabel='emit_x / emit_y [m]')
ax[1][0].grid()
ax[1][1].plot(twiss.elegant['s'],
0.511 * twiss.elegant['pCentral0'])
# ax[1][1].set_ylim(top=1100, bottom=0)
ax[1][1].set(ylabel='Momentum [MeV/c]')
ax[1][1].grid()
ax[1][2].plot(twiss.elegant['s'], 1e3 * twiss['sigma_x'])
ax[1][2].plot(twiss.elegant['s'], 1e3 * twiss['sigma_y'])
ax[1][2].set(ylabel='sigma_x / sigma_y [m]')
ax[1][2].grid()
plt.draw()
plt.pause(0.001)
return fitness
def optFuncVELA(args):
global dir, lattice, bestdelta
try:
lattice.modifyElement('CLA-S02-MAG-QUAD-01', 'k1l', args[0])
lattice.modifyElement('CLA-S02-MAG-QUAD-02', 'k1l', args[1])
lattice.modifyElement('CLA-S02-MAG-QUAD-03', 'k1l', args[2])
lattice.modifyElement('CLA-S02-MAG-QUAD-04', 'k1l', args[3])
lattice.modifyElement('CLA-S02-MAG-QUAD-05', 'k1l', args[4])
lattice.track(startfile='S02', endfile='S02', track=True)
constraintsList = {}
twiss.reset_dicts()
twiss.read_elegant_twiss_files(dir + '/S02.twi')
ipindex = list(twiss['element_name']).index('CLA-VHEE-PHANTOM-01')
constraintsListVHEE = {
'ip_betax': {
'type': 'lessthan',
'value': twiss['beta_x'][ipindex],
'limit': 0.5,
'weight': 25
},
'ip_betay': {
'type': 'lessthan',
'value': twiss['beta_y'][ipindex],
'limit': 0.5,
'weight': 25
},
'ip_betaxy': {
'type': 'equalto',
'value': twiss['beta_x'][ipindex],
'limit': twiss['beta_y'][ipindex],
'weight': 25
},
'ip_alphax': {
'type': 'equalto',
'value': twiss['alpha_x'][ipindex],
'limit': 0.,
'weight': 2.5
},
'ip_alphay': {
'type': 'equalto',
'value': twiss['alpha_y'][ipindex],
'limit': 0.,
'weight': 2.5
},
'ip_etax': {
'type': 'lessthan',
'value': abs(twiss['eta_x'][ipindex]),
'limit': 1e-4,
'weight': 50
},
'ip_etaxp': {
'type': 'lessthan',
'value': abs(twiss['eta_xp'][ipindex]),
'limit': 1e-4,
'weight': 50
},
}
constraintsList = merge_two_dicts(constraintsList, constraintsListVHEE)
cons = constraintsClass()
delta = cons.constraints(constraintsList)
updateOutput('VELA delta = ' + str(delta))
if delta < bestdelta:
bestdelta = delta
print('### New Best: ', delta)
# print(*args, sep = ", ")
print '[', ', '.join(map(str, args)), ']'
# print(cons.constraintsList(constraintsList))
# if delta < 0.1:
# return 0
except Exception as e:
print('Error! = ', e)
delta = 1e6
else:
return delta
def calculateBeamParameters(self):
twiss = self.twiss
self.framework.change_Lattice_Code('All', 'elegant')
self.framework[self.start_file].prefix = self.base_files
self.framework[self.start_file].sample_interval = 2**(3 * 3)
# self.framework[self.start_file].betax = 31.83468426136683
# self.framework[self.start_file].betay = 31.793807462253913
# self.framework[self.start_file].alphax = -3.304548178432217
# self.framework[self.start_file].alphay = -3.2972860159598367
self.framework.track(startfile=self.start_file)
constraintsList = {}
quadkls = self.framework.getElementType('quadrupole', 'k1l')
quadlengths = self.framework.getElementType('quadrupole', 'length')
quadnames = self.framework.getElementType('quadrupole', 'objectname')
constraintsListQuads = {
'max_k': {
'type':
'lessthan',
'value': [
abs(k) for k, l, n in zip(quadkls, quadlengths, quadnames)
if not 'FEBE' in n
],
'limit':
1.0,
'weight':
300
},
}
# print self.cons.constraintsList(constraintsListQuads)
# constraintsList = merge_two_dicts(constraintsList, constraintsListQuads)
# twiss.read_elegant_twiss_files( [ self.dirname+'/'+n+'.twi' for n in ['S02', 'L02', 'S03', 'L03', 'S04', 'L4H', 'S05', 'S06', 'L04', 'S07', 'S07F']])
twiss.read_elegant_twiss_files(self.dirname + '/' + self.start_file +
'.twi')
indexVBC1 = list(twiss.elegant['ElementName']).index('CLA-S05-MARK-01')
indexVBC2 = list(twiss.elegant['ElementName']).index('CLA-VBC-MARK-01')
sigx = np.array(
list(twiss['sigma_x'][:indexVBC1]) +
list(twiss['sigma_x'][indexVBC2:]))
constraintsListSigmas = {
'max_xrms': {
'type': 'lessthan',
'value': max(1e3 * sigx),
'limit': 1,
'weight': 5
},
'max_yrms': {
'type': 'lessthan',
'value': max(1e3 * twiss['sigma_y']),
'limit': 1,
'weight': 5
},
'min_xrms': {
'type': 'greaterthan',
'value': min(1e3 * twiss['sigma_x']),
'limit': 0.025,
'weight': 5
},
'min_yrms': {
'type': 'greaterthan',
'value': min(1e3 * twiss['sigma_y']),
'limit': 0.025,
'weight': 5
},
'last_exn': {
'type': 'lessthan',
'value': 1e6 * twiss['enx'][-1],
'limit': 2,
'weight': 0
},
'last_eyn': {
'type': 'lessthan',
'value': 1e6 * twiss['eny'][-1],
'limit': 0.75,
'weight': 0
},
'max_betax': {
'type': 'lessthan',
'value': twiss['beta_x'],
'limit': 200,
'weight': 150
},
'max_betay': {
'type': 'lessthan',
'value': twiss['beta_y'],
'limit': 200,
'weight': 150
},
# 'max_alphax': {'type': 'lessthan', 'value': max(abs(twiss['alpha_x'])), 'limit': 20, 'weight': 5},
# 'max_alphay': {'type': 'lessthan', 'value': max(abs(twiss['alpha_y'])), 'limit': 20, 'weight': 5},
}
# print self.cons.constraintsList(constraintsListSigmas)
constraintsList = merge_two_dicts(constraintsList,
constraintsListSigmas)
# twiss.read_elegant_twiss_files(self.dirname+'/S07F.twi')
dechirper_position = self.framework['CLA-S07-DCP-01'][
'position_start'][2]
dcpindex = list(twiss.elegant['ElementName']).index('CLA-S07-DCP-01')
constraintsListS07 = {
'dechirper_sigma_x': {
'type': 'lessthan',
'value': 1e3 * twiss.elegant['Sx'][dcpindex],
'limit': 0.1,
'weight': 2
},
'dechirper_sigma_y': {
'type': 'lessthan',
'value': 1e3 * twiss.elegant['Sy'][dcpindex],
'limit': 0.1,
'weight': 2
},
'dechirper_sigma_xy': {
'type':
'equalto',
'value':
1e3 * twiss.elegant['Sy'][dcpindex] -
1e3 * twiss.elegant['Sx'][dcpindex],
'limit':
0.0,
'weight':
2
},
}
# constraintsList = merge_two_dicts(constraintsList, constraintsListS07)
# twiss.read_elegant_twiss_files( self.dirname+'/S07F.twi' )
constraintsListFEBEStart = {
# VALUES FOR NONIMAL FEBE
# 'betax': {'type': 'equalto', 'value': twiss['beta_x'][-1], 'limit': 0.706961, 'weight': 5},
# 'betay': {'type': 'equalto', 'value': twiss['beta_y'][-1], 'limit': 3.94176, 'weight': 5},
# 'alphax': {'type': 'equalto', 'value': twiss['alpha_x'][-1], 'limit': -1.40098, 'weight': 5},
# 'alphay': {'type': 'equalto', 'value': twiss['alpha_y'][-1], 'limit': 0.872449, 'weight': 5},
# VALUES FOR FODO FEBE
# 'betax': {'type': 'equalto', 'value': twiss['beta_x'][-1], 'limit': 1.15791, 'weight': 5},
# 'betay': {'type': 'equalto', 'value': twiss['beta_y'][-1], 'limit': 3.77078, 'weight': 5},
# 'alphax': {'type': 'equalto', 'value': twiss['alpha_x'][-1], 'limit': -0.955335, 'weight': 5},
# 'alphay': {'type': 'equalto', 'value': twiss['alpha_y'][-1], 'limit': 1.61446, 'weight': 5},
# VALUES FOR BROKEN FODO FEBE
'betax': {
'type': 'equalto',
'value': twiss['beta_x'][-1],
'limit': 0.748377,
'weight': 50
},
'betay': {
'type': 'equalto',
'value': twiss['beta_y'][-1],
'limit': 3.96107,
'weight': 50
},
'alphax': {
'type': 'equalto',
'value': twiss['alpha_x'][-1],
'limit': -0.61447,
'weight': 50
},
'alphay': {
'type': 'equalto',
'value': twiss['alpha_y'][-1],
'limit': 0.872954,
'weight': 50
},
# 'etax': {'type': 'equalto', 'value': twiss.elegant['etax'][-1], 'limit': 0., 'weight': 500},
# 'etaxp': {'type': 'equalto', 'value': twiss.elegant['etaxp'][-1], 'limit': 0., 'weight': 500},
}
# print self.cons.constraintsList(constraintsListFEBEStart)
constraintsList = merge_two_dicts(constraintsList,
constraintsListFEBEStart)
self.constraintsList = constraintsList
fitness = self.cons.constraints(constraintsList)
if self.verbose:
print(self.cons.constraintsList(constraintsList))
return fitness
def calculateBeamParameters(self):
twiss = self.twiss
self.framework.defineElegantCommand(location=['elegant'])
self.framework[self.start_file].prefix = self.base_files
self.framework[self.start_file].sample_interval = 2**(3 * 1)
# self.framework['FEBE'].betax = 0.74306
# self.framework['FEBE'].betay = 3.96111
# self.framework['FEBE'].alphax = -0.623844
# self.framework['FEBE'].alphay = 0.872959
self.framework.track(startfile=self.start_file)
constraintsList = {}
twiss.reset_dicts()
twiss.read_sdds_file(self.dirname + '/FEBE.mat')
# print((1e3*twiss.elegant['R56'][-1]))
constraintsListR56 = {
'isochronous': {
'type': 'lessthan',
'value': abs(1e3 * twiss.elegant['R56'][-1]),
'limit': 0.1,
'weight': 00
},
}
constraintsList = merge_two_dicts(constraintsList, constraintsListR56)
for lat in ['FEBE']:
quadkls = self.framework[lat].getElementType('quadrupole', 'k1l')
quadlengths = self.framework[lat].getElementType(
'quadrupole', 'length')
constraintsListQuads = {
'max_k_' + lat: {
'type': 'lessthan',
'value': [abs(k) for k, l in zip(quadkls, quadlengths)],
'limit': 2.0,
'weight': 75
},
}
constraintsList = merge_two_dicts(constraintsList,
constraintsListQuads)
twiss.read_elegant_twiss_files([self.dirname + '/FEBE.twi'])
ipindex1 = list(twiss['element_name']).index('CLA-FEH-FOCUS-01')
ipindex2 = list(twiss['element_name']).index('CLA-FEH-FOCUS-02')
constraintsListFEBE = {
'max_betax': {
'type': 'lessthan',
'value': max(twiss['beta_x']),
'limit': 25,
'weight': 150
},
'max_betay': {
'type': 'lessthan',
'value': max(twiss['beta_y']),
'limit': 25,
'weight': 150
},
'ip1_sigmax': {
'type': 'lessthan',
'value': 1e3 * twiss['sigma_x'][ipindex1],
'limit': 0.05,
'weight': 15
},
'ip1_sigmay': {
'type': 'lessthan',
'value': 1e3 * twiss['sigma_y'][ipindex1],
'limit': 0.05,
'weight': 15
},
# 'ip_sigmaxy': {'type': 'equalto', 'value': 1e3*twiss['sigma_y'][ipindex], 'limit': 1e3*twiss['sigma_x'][ipindex], 'weight': 25},
'ip1_alphax': {
'type': 'equalto',
'value': twiss['alpha_x'][ipindex1],
'limit': 0.,
'weight': 5
},
'ip1_alphay': {
'type': 'equalto',
'value': twiss['alpha_y'][ipindex1],
'limit': 0.,
'weight': 5
},
'ip1_etax': {
'type': 'equalto',
'value': twiss['eta_x'][ipindex1],
'limit': 0.,
'weight': 5000
},
'ip1_etaxp': {
'type': 'equalto',
'value': twiss['eta_xp'][ipindex1],
'limit': 0.,
'weight': 5000
},
'ip2_sigmax': {
'type': 'lessthan',
'value': 1e3 * twiss['sigma_x'][ipindex2],
'limit': 0.05,
'weight': 15
},
'ip2_sigmay': {
'type': 'lessthan',
'value': 1e3 * twiss['sigma_y'][ipindex2],
'limit': 0.05,
'weight': 15
},
# 'ip_sigmaxy': {'type': 'equalto', 'value': 1e3*twiss['sigma_y'][ipindex], 'limit': 1e3*twiss['sigma_x'][ipindex], 'weight': 25},
'ip2_alphax': {
'type': 'equalto',
'value': twiss['alpha_x'][ipindex2],
'limit': 0.,
'weight': 5
},
'ip2_alphay': {
'type': 'equalto',
'value': twiss['alpha_y'][ipindex2],
'limit': 0.,
'weight': 5
},
'ip2_etax': {
'type': 'equalto',
'value': twiss['eta_x'][ipindex2],
'limit': 0.,
'weight': 5000
},
'ip2_etaxp': {
'type': 'equalto',
'value': twiss['eta_xp'][ipindex2],
'limit': 0.,
'weight': 5000
},
}
constraintsList = merge_two_dicts(constraintsList, constraintsListFEBE)
# twiss.read_elegant_twiss_files( [ self.dirname+'/FEBE600.twi' ])
constraintsListFEBE600 = {
'max_betax_600': {
'type': 'lessthan',
'value': max(twiss['beta_x']),
'limit': 25,
'weight': 150
},
'max_betay_600': {
'type': 'lessthan',
'value': max(twiss['beta_y']),
'limit': 25,
'weight': 150
},
'dump_etax_600': {
'type': 'equalto',
'value': twiss['eta_x'][-1],
'limit': 0.,
'weight': 5000
},
}
constraintsList = merge_two_dicts(constraintsList,
constraintsListFEBE600)
self.constraintsList = constraintsList
fitness = self.cons.constraints(constraintsList)
if self.verbose:
print(self.cons.constraintsList(constraintsList))
return fitness
def calculateBeamParameters(self):
twiss = self.twiss
self.framework.change_Lattice_Code('All', 'elegant')
self.framework[self.start_file].prefix = self.base_files
self.framework[self.start_file].sample_interval = 2**(3 * 1)
self.framework.track(files=[self.start_file])
constraintsList = {}
quadkls = self.framework.getElementType('quadrupole', 'k1l')
quadlengths = self.framework.getElementType('quadrupole', 'length')
quadnames = self.framework.getElementType('quadrupole', 'objectname')
# twiss.read_elegant_twiss_files( [ self.dirname+'/'+n+'.twi' for n in ['S07', 'S07F']])
twiss.read_elegant_twiss_files(self.dirname + '/' + self.start_file +
'.twi')
constraintsListSigmas = {
'max_xrms': {
'type': 'lessthan',
'value': max(1e3 * twiss['sigma_x']),
'limit': 1,
'weight': 5
},
'max_yrms': {
'type': 'lessthan',
'value': max(1e3 * twiss['sigma_y']),
'limit': 1,
'weight': 5
},
'min_xrms': {
'type': 'greaterthan',
'value': min(1e3 * twiss['sigma_x']),
'limit': 0.05,
'weight': 50
},
'min_yrms': {
'type': 'greaterthan',
'value': min(1e3 * twiss['sigma_y']),
'limit': 0.05,
'weight': 50
},
'last_exn': {
'type': 'lessthan',
'value': 1e6 * twiss['enx'][-1],
'limit': 2,
'weight': 0
},
'last_eyn': {
'type': 'lessthan',
'value': 1e6 * twiss['eny'][-1],
'limit': 0.75,
'weight': 0
},
'max_betax': {
'type': 'lessthan',
'value': max(twiss['beta_x']),
'limit': 200,
'weight': 5
},
'max_betay': {
'type': 'lessthan',
'value': max(twiss['beta_y']),
'limit': 200,
'weight': 5
},
# 'max_alphax': {'type': 'lessthan', 'value': max(abs(twiss['alpha_x'])), 'limit': 10, 'weight': 5},
# 'max_alphay': {'type': 'lessthan', 'value': max(abs(twiss['alpha_y'])), 'limit': 10, 'weight': 5},
}
# print self.cons.constraintsList(constraintsListSigmas)
constraintsList = merge_two_dicts(constraintsList,
constraintsListSigmas)
# twiss.read_elegant_twiss_files(self.dirname+'/S07F.twi')
dechirper_position = self.framework['CLA-S07-DCP-01'][
'position_start'][2]
dcpindex = list(twiss.elegant['ElementName']).index('CLA-S07-DCP-01')
constraintsListS07 = {
'dechirper_sigma_x': {
'type': 'lessthan',
'value': 1e3 * twiss.elegant['Sx'][dcpindex],
'limit': 0.1,
'weight': 2
},
'dechirper_sigma_y': {
'type': 'lessthan',
'value': 1e3 * twiss.elegant['Sy'][dcpindex],
'limit': 0.1,
'weight': 2
},
'dechirper_sigma_xy': {
'type':
'equalto',
'value':
1e3 * twiss.elegant['Sy'][dcpindex] -
1e3 * twiss.elegant['Sx'][dcpindex],
'limit':
0.0,
'weight':
2
},
}
# constraintsList = merge_two_dicts(constraintsList, constraintsListS07)
twiss.read_elegant_twiss_files(self.dirname + '/PreFEBE.twi')
# print('beta_x = ', twiss.elegant['betax'])
constraintsListFEBEStart = {
# VALUES FOR NONIMAL FEBE
# 'betax': {'type': 'equalto', 'value': twiss['beta_x'][-1], 'limit': 0.706961, 'weight': 50},
# 'betay': {'type': 'equalto', 'value': twiss['beta_y'][-1], 'limit': 3.94176, 'weight': 50},
# 'alphax': {'type': 'equalto', 'value': twiss['alpha_x'][-1], 'limit': -1.40098, 'weight': 50},
# 'alphay': {'type': 'equalto', 'value': twiss['alpha_y'][-1], 'limit': 0.872449, 'weight': 50},
# VALUES FOR FODO FEBE
# 'betax': {'type': 'equalto', 'value': twiss['beta_x'][-1], 'limit': 1.15791, 'weight': 50},
# 'betay': {'type': 'equalto', 'value': twiss['beta_y'][-1], 'limit': 3.77078, 'weight': 50},
# 'alphax': {'type': 'equalto', 'value': twiss['alpha_x'][-1], 'limit': -0.955335, 'weight': 50},
# 'alphay': {'type': 'equalto', 'value': twiss['alpha_y'][-1], 'limit': 1.61446, 'weight': 50},
# VALUES FOR BROKEN FODO FEBE
'betax': {
'type': 'equalto',
'value': twiss['beta_x'][-1],
'limit': 0.748377,
'weight': 500
},
'betay': {
'type': 'equalto',
'value': twiss['beta_y'][-1],
'limit': 3.96107,
'weight': 500
},
'alphax': {
'type': 'equalto',
'value': twiss['alpha_x'][-1],
'limit': -0.61447,
'weight': 500
},
'alphay': {
'type': 'equalto',
'value': twiss['alpha_y'][-1],
'limit': 0.872954,
'weight': 500
},
# 'etax': {'type': 'equalto', 'value': twiss.elegant['etax'][-1], 'limit': 0., 'weight': 500},
# 'etaxp': {'type': 'equalto', 'value': twiss.elegant['etaxp'][-1], 'limit': 0., 'weight': 500},
}
# print self.cons.constraintsList(constraintsListFEBEStart)
constraintsList = merge_two_dicts(constraintsList,
constraintsListFEBEStart)
self.constraintsList = constraintsList
fitness = self.cons.constraints(constraintsList)
if self.verbose:
print(self.cons.constraintsList(constraintsList))
return fitness
