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