def test_ASTRA_Elegant_C2V(quads, phase=4, charge=70):
global dir, lattice, scaling, bestdelta
dir = './SETUP/TOMP_SETUP'
lattice = Framework(dir, clean=True, verbose=False)
lattice.loadSettings('CLA10-BA1_TOMP_ASTRA.def')
lattice.change_Lattice_Code('C2V', 'elegant')
scaling = 6
if not os.name == 'nt':
lattice.defineASTRACommand(scaling=(scaling))
lattice.defineCSRTrackCommand(scaling=(scaling))
lattice.define_gpt_command(scaling=(scaling))
lattice['S02'].file_block['input'][
'prefix'] = '../SETUP/TOMP_SETUP_' + str(phase) + '_' + str(
charge) + '/'
lattice['S02'].sample_interval = 1 #2**(3*2)
dir = './test_EleC2V_' + str(phase) + '_' + str(charge)
lattice.setSubDirectory(dir)
lattices = lattice.latticeObjects.values()
# for l in lattices:
# if hasattr(l, 'headers'):
# if isinstance(l.headers, (dict)):
# if 'charge' in l.headers.keys():
# l.headers['charge'].space_charge_mode = False
optFuncVELA(quads, track=False)
lattice.track(startfile='S02', track=True)
basedir = 'dipole_scan'
framework = Framework(basedir, clean=True, verbose=False)
if not os.name == 'nt':
framework.defineGeneratorCommand(['/opt/ASTRA/generator'])
framework.defineASTRACommand(
['mpiexec', '-np',
str(ncpu), '/opt/ASTRA/astra_MPICH2.sh'])
framework.defineCSRTrackCommand([
'/opt/OpenMPI-1.4.3/bin/mpiexec', '-n',
str(ncpu), '/opt/CSRTrack/csrtrack_openmpi.sh'
])
framework.defineElegantCommand(['elegant'])
framework.loadSettings('Lattices/CLA10-BA1.def')
framework.change_Lattice_Code('All', 'elegant')
framework['S02'].prefix = '../../basefiles_4/'
etax = []
etax2 = []
kValues = np.arange(0, 3, 0.1)
for k in kValues: #np.arange(0,1,0.1):
print('setting k = ', k)
framework.modifyElement('EBT-BA1-MAG-QUAD-07', 'k1l', k)
framework.track(startfile='S02', endfile='BA1_dipole')
twiss.reset_dicts()
twiss.read_sdds_file(basedir + '/BA1_dipole.mat')
etax.append(twiss.elegant['R16'][-1])
etax2.append(twiss.elegant['T166'][-1])
print(k, twiss.elegant['R16'][-1], twiss.elegant['T166'][-1],
twiss.elegant['R16'][-1] / twiss.elegant['T166'][-1])
# framework.defineElegantCommand(['elegant'])
#
# framework.loadSettings('Lattices/clara400_v12_v3.def')
# framework['VBC'].file_block['input']['prefix'] = '../basefiles_5/'
# framework.track(startfile='VBC', endfile='S07')
################################ ELEGANT ######################################
framework = Framework('VBC_Elegant')
if not os.name == 'nt':
# framework.defineGeneratorCommand(['/opt/ASTRA/generator'])
framework.defineASTRACommand(ncpu=ncpu)
framework.defineCSRTrackCommand(ncpu=ncpu)
framework.loadSettings('Lattices/clara400_v12_v3.def')
framework.change_Lattice_Code('VBC', 'elegant')
framework.change_Lattice_Code('S06', 'elegant')
framework.change_Lattice_Code('L04', 'elegant')
framework.change_Lattice_Code('S07', 'elegant')
framework['VBC'].file_block['input']['prefix'] = '../basefiles_5/'
framework.track(startfile='VBC', endfile='S07')
################################ ASTRA ######################################
framework = Framework('Phase_Comparison_ASTRA')
if not os.name == 'nt':
# framework.defineGeneratorCommand(ncpu=ncpu)
framework.defineASTRACommand(ncpu=ncpu)
framework.defineCSRTrackCommand(ncpu=ncpu)
framework.loadSettings('Lattices/clara400_v12_v3.def')
def optimise_Lattice(phase=4, q=70, do_optimisation=False):
global dir, lattice, scaling, bestdelta
bestdelta = 1e10
dir = './SETUP/TOMP_SETUP'
lattice = Framework(dir, clean=False, verbose=False)
lattice.loadSettings('CLA10-BA1_TOMP_ASTRA.def')
lattice.change_Lattice_Code('S02', 'elegant')
lattice.change_Lattice_Code('C2V', 'elegant')
scaling = 6
if not os.name == 'nt':
lattice.defineASTRACommand(scaling=(scaling))
lattice.defineCSRTrackCommand(scaling=(scaling))
lattice.define_gpt_command(scaling=(scaling))
lattice['L01'].file_block['input']['prefix'] = '../basefiles_' + str(
scaling) + '_' + str(q) + '/'
quads = 0.107 * np.array([
21.11058462, -11.36377551, 24.69336696, -22.63264054, 56.07039682,
-51.58739658
])
quads = [
# lattice.getElement('CLA-S02-MAG-QUAD-01', 'k1l'),
# lattice.getElement('CLA-S02-MAG-QUAD-02', 'k1l'),
# lattice.getElement('CLA-S02-MAG-QUAD-03', 'k1l'),
# lattice.getElement('CLA-S02-MAG-QUAD-04', 'k1l'),
# lattice.getElement('CLA-C2V-MAG-QUAD-01', 'k1l'),
# lattice.getElement('CLA-C2V-MAG-QUAD-02', 'k1l'),
lattice.getElement('EBT-INJ-MAG-QUAD-07', 'k1l'),
lattice.getElement('EBT-INJ-MAG-QUAD-08', 'k1l'),
lattice.getElement('EBT-INJ-MAG-QUAD-09', 'k1l'),
lattice.getElement('EBT-INJ-MAG-QUAD-10', 'k1l'),
lattice.getElement('EBT-INJ-MAG-QUAD-11', 'k1l'),
lattice.getElement('EBT-INJ-MAG-QUAD-15', 'k1l'),
lattice.getElement('EBT-BA1-MAG-QUAD-01', 'k1l'),
lattice.getElement('EBT-BA1-MAG-QUAD-02', 'k1l'),
lattice.getElement('EBT-BA1-MAG-QUAD-03', 'k1l'),
lattice.getElement('EBT-BA1-MAG-QUAD-04', 'k1l'),
lattice.getElement('EBT-BA1-MAG-QUAD-05', 'k1l'),
lattice.getElement('EBT-BA1-MAG-QUAD-06', 'k1l'),
lattice.getElement('EBT-BA1-MAG-QUAD-07', 'k1l'),
]
quads = np.array([
1.813883341270411, -1.657984997152041, 2.436078305927638,
-1.3805803719324001, 5.757521138743945, -4.774512264530579,
1.5759640821849459, -1.5658635139945611, 0.4665090704522008,
-0.3701448642096947, 0.14139459095219498, 0.1294045271940972,
-0.26170990073523187, -0.972243028906357, 1.2999713197810956,
1.3880410074706666, 0.043801044316032774, -1.3992446074305926,
1.3604179976621753
])
quadsCHICANE = quads[:6]
# quadsCHICANE = np.array([ 1.81966806, -1.60694003, 2.52387281, -1.34318408, 5.75696896,
# -4.86231975,])
lattice['S02'].sample_interval = 2**(3 * 3)
if do_optimisation:
if phase is not None:
lattice['S02'].file_block['input'][
'prefix'] = '../TOMP_SETUP_' + str(phase) + '_' + str(q) + '/'
lattice['S02'].file_block['output']['end_element'] = 'CLA-C2V-MARK-02'
val = optFuncChicane(quadsCHICANE)
quadsCHICANE = setChicane(quadsCHICANE)
val = optFuncChicane(quadsCHICANE)
print val
print('Chicane = ', quadsCHICANE)
quads[:6] = quadsCHICANE
# exit()
lattice['S02'].file_block['output'][
'end_element'] = 'EBT-BA1-DIA-FCUP-01'
val = optFuncVELA(quads)
while val > 10:
print('################ CURRENT VALUE OF OPTIMISATION IS ', val,
' ##################')
quads = setVELA(quads)
val = optFuncVELA(quads)
else:
val = optFuncVELA(quads)
lattice['S02'].file_block['output']['end_element'] = 'EBT-BA1-DIA-FCUP-01'
lattice['S02'].sample_interval = 1
return quads
class fitnessFunc():
def __init__(self,
args,
tempdir,
scaling=4,
overwrite=True,
verbose=False,
summary=False):
self.cons = constraintsClass()
self.beam = rbf.beam()
self.twiss = rtf.twiss()
self.tmpdir = tempdir
self.verbose = verbose
self.summary = summary
self.parameters = list(args)
self.dirname = os.path.basename(self.tmpdir)
self.framework = Framework(self.dirname, clean=False, verbose=verbose)
self.framework.loadSettings('Lattices/clara400_v12_v3.def')
self.framework.change_Lattice_Code('All', 'elegant')
if not os.name == 'nt':
self.framework.defineASTRACommand([
'mpiexec', '-np',
str(3 * scaling), '/opt/ASTRA/astra_MPICH2.sh'
])
self.framework.defineGeneratorCommand(['/opt/ASTRA/generator.sh'])
self.framework.defineCSRTrackCommand([
'/opt/OpenMPI-1.4.3/bin/mpiexec', '-n',
str(3 * scaling), '/opt/CSRTrack/csrtrack_openmpi.sh'
])
self.framework.generator.number_of_particles = 2**(3 * scaling)
else:
self.framework.generator.number_of_particles = 2**(3 * 3)
self.framework.defineElegantCommand(['elegant'])
self.framework.setElementType('quadrupole', 'k1l', self.parameters)
def between(self, value, minvalue, maxvalue, absolute=True):
if absolute:
result = max([minvalue, min([maxvalue, abs(value)])])
else:
result = np.sign(value) * max(
[minvalue, min([maxvalue, abs(value)])])
return result
def calculateBeamParameters(self):
try:
twiss = self.twiss
self.framework['S02'].prefix = '../../basefiles_4/'
# print 'before tracking '
self.framework.track(startfile='S02')
# print 'after tracking '
constraintsList = {}
constraintsListQuads = {
'max_k': {
'type': 'lessthan',
'value': [abs(p) for p in self.parameters],
'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', 'VBC',
'S06', 'L04', 'S07'
]
])
constraintsListSigmas = {
'max_xrms': {
'type': 'lessthan',
'value': 1e3 * twiss['sigma_x'],
'limit': 1,
'weight': 10
},
'max_yrms': {
'type': 'lessthan',
'value': 1e3 * twiss['sigma_y'],
'limit': 1,
'weight': 10
},
'min_xrms': {
'type': 'greaterthan',
'value': 1e3 * twiss['sigma_x'],
'limit': 0.1,
'weight': 10
},
'min_yrms': {
'type': 'greaterthan',
'value': 1e3 * twiss['sigma_y'],
'limit': 0.1,
'weight': 10
},
'last_exn': {
'type': 'lessthan',
'value': 1e6 * twiss['enx'][-1],
'limit': 0.6,
'weight': 1
},
'last_eyn': {
'type': 'lessthan',
'value': 1e6 * twiss['eny'][-1],
'limit': 0.6,
'weight': 1
},
}
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':
1
},
'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': 'equalto',
'value':
1e3 * twiss.interpolate(dechirper_position, 'sigma_x'),
'limit': 0.1,
'weight': 10
},
'dechirper_sigma_y': {
'type': 'equalto',
'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':
20
},
}
constraintsList = merge_two_dicts(constraintsList,
constraintsListS07)
fitness = self.cons.constraints(constraintsList)
if self.verbose:
print self.cons.constraintsList(constraintsList)
if self.summary:
self.astra.createHDF5Summary(reference='Transverse_GA')
return fitness
except:
return 1e6
