def setup_pic(fname, magnify=2., N_nodes_discard=10, symmetric_slice_2D=True):
ob = mfm.myloadmat_to_obj(fname)
Dh_magnify = (ob.xg[1] - ob.xg[0]) / magnify
x_magnify = -ob.xg[N_nodes_discard]
y_magnify = -ob.yg[N_nodes_discard]
if symmetric_slice_2D:
pic_rho = symmetrize(ob.rho[0, :, :])
pic_phi = symmetrize(ob.phi[0, :, :])
else:
pic_rho = ob.rho[0, :, :].copy()
pic_phi = ob.phi[0, :, :].copy()
xg_out = ob.xg.copy()
yg_out = ob.yg.copy()
zg_out = ob.zg.copy()
del ob
chamb = poly.polyg_cham_geom_object({
'Vx':
np.array([xg_out[-1], xg_out[0], xg_out[0], xg_out[-1]]),
'Vy':
np.array([yg_out[-1], yg_out[-1], yg_out[0], yg_out[0]]),
'x_sem_ellip_insc':
1e-3,
'y_sem_ellip_insc':
1e-3
})
pic = PyPICSC.PyPIC_Scatter_Gather(xg=xg_out, yg=yg_out)
pic.phi = pic_phi
#pic.efx = ob.Ex[0, :, :]
#pic.efy = ob.Ey[0, :, :]
pic.rho = pic_rho
pic.chamb = chamb
#Ex_picint, _ = pic.gather(x_tint, y_tint)
# Internal pic
picdg = AddInternalGrid(pic,
x_min_internal=-x_magnify,
x_max_internal=x_magnify,
y_min_internal=-y_magnify,
y_max_internal=y_magnify,
Dh_internal=Dh_magnify,
N_nodes_discard=N_nodes_discard)
picinside = picdg.pic_internal
picinside.rho = np.reshape(pic.gather_rho(picinside.xn, picinside.yn),
(picinside.Nxg, picinside.Nyg))
picinside.solve(flag_verbose=True, pic_external=pic)
#rho_insideint = picinside.gather_rho(x_tint, y_tint)
#Ex_inside, _ = picinside.gather(x_tint, y_tint)
#phi_inside = picinside.gather_phi(x_tint, y_tint)
return pic, picinside, zg_out
def get_simulation_ob(device_name, sey, coast_str='0.5'):
sim_ident = '%s_%s_%s_%s_sey%.2f_coast%s' % (beam_snapshot.split('.mat')[0], machine_name, device_name, beam_name, sey, coast_str)
ob = mlo.myloadmat_to_obj(main_folder + '/' + sim_ident+'/Pyecltest.mat')
t_bun = np.arange(0.,np.max(ob.t), ob.b_spac)
L_imp_t = np.cumsum(ob.En_imp_eV_time-ob.En_emit_eV_time); #in eV
L_imp = np.interp(t_bun, ob.t, L_imp_t) #in eV
Ek = np.interp(t_bun, ob.t, ob.En_kin_eV_time);
sim_loss_per_meter = (np.diff(L_imp) + np.diff(Ek))*qe/T_rev; #watt/m
return sim_loss_per_meter, ob, t_bun
def get_slice(picoutside, picinside, fname, islice):
ob = mfm.myloadmat_to_obj(fname)
rho = ob.rho[islice, :, :].copy()
phi = ob.phi[islice, :, :].copy()
del ob
picoutside.phi = phi
picoutside.rho = rho
picinside.rho = np.reshape(
picoutside.gather_rho(picinside.xn, picinside.yn),
(picinside.Nxg, picinside.Nyg))
picinside.solve(flag_verbose=True, pic_external=picoutside)
phi_refined = picinside.gather_phi(picinside.xn, picinside.yn)
return phi_refined.reshape(picinside.Nxg, picinside.Nyg)
def __init__(self,
fname_sim_db,
sey,
varname_hl='hl',
rescaling_factor=1.):
self.varname_hl = varname_hl
self.rescaling_factor = rescaling_factor
ob_all = mfm.myloadmat_to_obj(fname_sim_db, squeeze=False)
ob_all = mds.downsel_scan(ob_all, {}, varname_list=[varname_hl])
self.database = mds.downsel_scan(ob_all, {'sey': sey},
varname_list=[varname_hl])
self.matrix = getattr(self.database, self.varname_hl + '_sqz')
# Build heat load functions (and change units)
self.interpolating_function = interpolate.RectBivariateSpline(
self.database.int * 1e11,
self.database.bl * 1e-9 / 4,
self.matrix * rescaling_factor,
kx=2,
ky=2).ev
N_rings = 100
# sim_folder = '../HL-LHC_coupled_bunch_450GeV_2.3e11_144b_sey1.5_both_planes'
# tag = 'HL_sey1.5_xy'
# b_spac = 25e-9
# N_slots_bsp = 5
# flag_movie = True
# movie_range = (0, 1000)
# vmax_movie = 2e11
# corr_turn = 1
# N_turns_part = 500
# N_rings = 100
i_turn = 300
obbea = mfm.myloadmat_to_obj(tag+'_matrices.mat')
x_mat = obbea.mean_x
y_mat = obbea.mean_y
n_mat = obbea.macroparticlenumber
n_turns = x_mat.shape[0]
mask_bunch = n_mat[1, :]>0
n_bunches = np.sum(mask_bunch)
bslots = np.where(mask_bunch)[0]/N_slots_bsp
plt.close('all')
ms.mystyle_arial(fontsz=16, dist_tick_lab=5)
figrt = plt.figure(2000)
coast_strs = ['1.0', '0.5', '0.0']
coast_linestyle_dict = {\
'1.0': '-',
'0.5': '-.',
'0.0': ':'
}
l_hc = magnet_length['AVG_ARC'][0]
l_dip = 3 * magnet_length['special_HC_D2'][0]
l_quad = magnet_length['special_HC_Q1'][0]
l_drift = l_hc - l_dip - l_quad
#beam_snapshot = 'Fill5219_cut0.920h_450GeV_for_triplets_B1.mat'
beam_snapshot = 'Fill5219_cut1.800h_6500GeV_for_triplets_%s.mat' % args.beam
ob_snapshot = mlo.myloadmat_to_obj(beam_snapshot_folder+'/'+beam_snapshot)
meas_loss_per_meter = ob_snapshot.bunch_power_loss/23./2./8./l_hc
meas_loss_per_hc = meas_loss_per_meter * l_hc
sey_vect = np.arange(1.10,1.501,.05)
if 'B1' in beam_snapshot:
colorbeam = 'b'
elif 'B2' in beam_snapshot:
colorbeam = 'r'
else:
raise ValueError('Beam type (B1 or B2) could not be infered from the name of the snapshot')
N_sims = len(sey_vect)
def get_simulation_ob(device_name, sey, coast_str='0.5'):
# fname = 'intensity_2.3e11ppb_Qp_Koct_comparison_feedback'
# ylim = 6.
# ylim_zoom = .3
# tag = 'HL_2.3e11_144b_Koct-4.5'
# tag = 'HL_2.3e11_144b_Koct-4.5_fb'
# tag = 'HL_2.3e11_144b_Qp15_Koct-4.5'
# tag = 'HL_2.3e11_144b_Qp15_Koct-4.5_fb'
# tag = 'HL_2.3e11_144b_sey1.5'
# tag = 'HL_2.3e11_144b_sey1.5_xy'
colorlist = ['#004488', '#BB5566', '#DDAA33', '#44AA99', '#AA4499', '#999933']
obs = [mfm.myloadmat_to_obj(tag + '_matrices.mat') for tag in tags]
plt.close('all')
from matplotlib import rc
rc('font', **{'family': 'sans-serif', 'sans-serif': ['arial'], 'size': 14})
# ms.mystyle_arial(fontsz=16)
fig = plt.figure(1)
ax1 = fig.add_subplot(111)
fig2 = plt.figure(2)
ax2 = fig2.add_subplot(111)
fig3 = plt.figure(3)
fig3.set_facecolor('w')
yg_e = pic_out.yg[Nd:-Nd]
zg_e = zg[2:-2]
n_slices = len(zg)
print('Number of slices: {}'.format(n_slices))
nx = pic_out.Nxg - 2 * Nd
ny = pic_out.Nyg - 2 * Nd
#x0 = pic.out.xg[Nd]
#y0 = pic.out.yg[Nd]
#z0 = pic.out.zg[1:-2]
del pic_out
del pic_in
del slices
phi_e = np.zeros([n_slices, nx, ny, 8])
for i in range(1, n_slices - 3):
print('Reading Slice: %d' % i)
ob = mfm.myloadmat_to_obj('temp/slice%d.mat' % i)
phi_e[i - 1, :, :, :] = ob.phi_slice_exact[:, :, :]
del ob
dd = {'xg': xg_e, 'yg': yg_e, 'zg': zg_e, 'phi': phi_e}
print('Begin saving..')
compression_opts = 0
mfm_stl.dict_to_h5(dd,
'refined_exact_pinch.h5',
compression_opts=compression_opts)
#sio.savemat('refined_exact_pinch.mat',dd, oned_as = 'row')
import numpy as np
from scipy.interpolate import interp2d
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D #Needed to allow projection='3d'
from matplotlib import cm
import myfilemanager as mfm
from cpymad.madx import Madx
ob = mfm.myloadmat_to_obj('twiss_res.mat')
ob1 = mfm.myloadmat_to_obj('gradient_discent.mat')
cost_func = ob1.cost_func
XX, YY = np.meshgrid(ob.str_factor, ob.str_factor)
make_avi = True
i_cut = 14
plt.close('all')
import mystyle as ms
ms.mystyle(fontsz=14, dist_tick_lab=None, mpl_v1_style=False)
fig1 = plt.figure(1, figsize=(1. * 8, 1. * 6))
ax = plt.subplot2grid(shape=(5, 1),
loc=(0, 0),
rowspan=5,
import numpy as np
import matplotlib.pyplot as plt
import scipy.io as sio
import myfilemanager as mfm
import mystyle as ms
from TricubicInterpolation import tricubic_interpolation as ti
import PyPIC.PyPIC_Scatter_Gather as PyPICSC
import PyPIC.geom_impact_poly as poly
from PyPIC.MultiGrid import AddInternalGrid
ob = mfm.myloadmat_to_obj('pinch_cut.mat')
interp2d = True
i_slice = 250
z_obs = ob.zg[i_slice]
x_magnify = 5e-4
y_magnify = 4.5e-4
Dh_magnify = 5e-6
if interp2d:
for kk, zz in enumerate(ob.zg):
ob.rho[kk, :, :] = ob.rho[i_slice, :, :]
ob.phi[kk, :, :] = ob.phi[i_slice, :, :]
ob.Ex[kk, :, :] = ob.Ex[i_slice, :, :]
ob.Ey[kk, :, :] = ob.Ey[i_slice, :, :]
slices = bunch.get_slices(ecloud_singlegrid.slicer)
pl.close('all')
pic_singlegrid = ecloud_singlegrid.spacech_ele.PyPICobj
pic_multigrid = ecloud_multigrid.spacech_ele.PyPICobj
# Plot field at probes
import matplotlib.gridspec as gridspec
fig = pl.figure(1, figsize=(7, 8))
fig.patch.set_facecolor('w')
gs1 = gridspec.GridSpec(1, 1)
gs2 = gridspec.GridSpec(2, 1)
sp1 = fig.add_subplot(gs1[0])
obcham = mlm.myloadmat_to_obj('LHC_chm_ver.mat')
sp1.plot(obcham.Vx * 1e3, obcham.Vy * 1e3, 'b')
sp1.plot(ecloud_singlegrid.x_probes * 1e3,
ecloud_singlegrid.y_probes * 1e3,
'or',
markersize=3)
sp1.plot(x_beam_offset, y_beam_offset, '*k', markersize=4)
for ii in xrange(pic_multigrid.n_grids):
sp1.plot(pic_multigrid.pic_list[ii].pic_internal.chamb.Vx * 1e3,
pic_multigrid.pic_list[ii].pic_internal.chamb.Vy * 1e3, '.-k')
sp1.set_ylabel('y [mm]')
sp1.set_xlabel('x [mm]')
sp1.axis('equal')
ms.sciy()
ms.scix()
sp1.grid('on')
import numpy as np
import matplotlib.pyplot as plt
import scipy.io as sio
import myfilemanager as mfm
ob = mfm.myloadmat_to_obj('pinch_pic_data_mean2.mat')
i_zero = np.argmin(np.abs(ob.xg))
j_zero = np.argmin(np.abs(ob.yg))
N_keep_h = 100
N_keep_v = 90
dict_new_file = {}
dict_new_file['Ex'] = ob.Ex[:, i_zero - N_keep_h:i_zero + N_keep_h + 1,
j_zero - N_keep_v:j_zero + N_keep_v + 1]
dict_new_file['Ey'] = ob.Ey[:, i_zero - N_keep_h:i_zero + N_keep_h + 1,
j_zero - N_keep_v:j_zero + N_keep_v + 1]
dict_new_file['phi'] = ob.phi[:, i_zero - N_keep_h:i_zero + N_keep_h + 1,
j_zero - N_keep_v:j_zero + N_keep_v + 1]
dict_new_file['rho'] = ob.rho[:, i_zero - N_keep_h:i_zero + N_keep_h + 1,
j_zero - N_keep_v:j_zero + N_keep_v + 1]
dict_new_file['xg'] = ob.xg[i_zero - N_keep_h:i_zero + N_keep_h + 1]
dict_new_file['yg'] = ob.yg[j_zero - N_keep_v:j_zero + N_keep_v + 1]
dict_new_file['zg'] = ob.zg
sio.savemat('pinch_cut.mat', dict_new_file, oned_as='row')
import numpy as np
from scipy.interpolate import interp2d
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D #Needed to allow projection='3d'
from matplotlib import cm
import myfilemanager as mfm
ob = mfm.myloadmat_to_obj('twiss_res.mat')
target_betax_max = 200.
target_betax_min = 45.
cost_func = np.sqrt((ob.betax_max-target_betax_max)**2/target_betax_max**2 \
+ (ob.betax_min-target_betax_min)**2/target_betax_min**2)
i_max, j_max = np.unravel_index(np.argmin(cost_func), cost_func.shape)
start_point = (1.5, 1.2)
start_point = (1.8, 1.6)
start_point = (1.8, 1.0)
#start_point = (1.1, 1.7)
Gx_map, Gy_map = np.gradient(cost_func)
Gx_map_norm = Gx_map / np.sqrt(Gx_map**2 + Gy_map**2)
Gy_map_norm = Gy_map / np.sqrt(Gx_map**2 + Gy_map**2)
XX, YY = np.meshgrid(ob.str_factor, ob.str_factor)
cost_interp = interp2d(XX, YY, cost_func.T, kind='linear')
from __future__ import print_function
import sys
sys.path.append('../NAFFlib')
import matplotlib.pyplot as plt
import numpy as np
import NAFFlib as NAFF
import myfilemanager as mfm
tag = 'HL_1.1e11_144b'
ob = mfm.myloadmat_to_obj(tag + '_matrices.mat')
x_mat = ob.mean_x
y_mat = ob.mean_y
n_mat = ob.macroparticlenumber
mask_bunch = n_mat[1, :] > 0
N_bunches = np.sum(mask_bunch)
x_mat_m = x_mat[:, mask_bunch]
y_mat_m = y_mat[:, mask_bunch]
n_mat_m = n_mat[:, mask_bunch]
plt.close('all')
fig1 = plt.figure(1)
axx = plt.subplot(3, 1, 1)
axx.plot(x_mat_m)
axy = plt.subplot(3, 1, 2, sharex=axx)
