added long sim for bologna

Author: giadarol

test_instability/002_test_long_intstab_bologna/.nfs000000000041302b00000a3b

@@ -0,0 +1,116 @@
+import sys, os
+BIN=os.path.expanduser('../../../')
+sys.path.append(BIN)
+
+
+import numpy as np
+from scipy.constants import c, e
+
+
+jobid = 'LH0136'
+queue = '1nw'
+
+n_segments = 79
+N_turns = 512
+
+
+intensity = 1.300000e+11
+epsn_x = 2.5e-6
+epsn_y = 2.5e-6
+
+machine_configuration = 'HLLHC-injection'
+
+init_unif_edens_flag = 1
+init_unif_edens = 1.000000e+12
+N_MP_ele_init = 100000
+N_mp_max = N_MP_ele_init*4.
+
+x_kick_in_sigmas = 0.1
+y_kick_in_sigmas = 0.1
+
+
+chamb_type = 'polyg'
+x_aper = 2.300000e-02
+y_aper = 1.800000e-02
+filename_chm = 'LHC_chm_ver.mat'
+
+
+
+B_multip_per_eV = [1.190000e-12]
+B_multip_per_eV = np.array(B_multip_per_eV)
+
+
+# define the machine
+from LHC_custom import LHC
+machine = LHC(n_segments = n_segments, machine_configuration = machine_configuration)
+
+# compute sigma x and y
+inj_opt = machine.transverse_map.get_injection_optics()
+sigma_x = np.sqrt(inj_opt['beta_x']*epsn_x/machine.betagamma)
+sigma_y = np.sqrt(inj_opt['beta_y']*epsn_y/machine.betagamma)
+
+x_kick = x_kick_in_sigmas*sigma_x
+y_kick = y_kick_in_sigmas*sigma_y
+
+# define PIC grid size
+Dh_sc = .2e-3
+
+# define MP size
+nel_mp_ref_0 = init_unif_edens*4*x_aper*y_aper/N_MP_ele_init
+
+
+
+# define an electron cloud
+import PyECLOUD.PyEC4PyHT as PyEC4PyHT
+from PyHEADTAIL.particles.slicing import UniformBinSlicer
+slicer = UniformBinSlicer(n_slices = 64, n_sigma_z = 2.)
+ecloud = PyEC4PyHT.Ecloud(L_ecloud=machine.circumference/n_segments, slicer=slicer , 
+				Dt_ref=10e-12, pyecl_input_folder='./pyecloud_config',
+				chamb_type = chamb_type,
+				x_aper=x_aper, y_aper=y_aper,
+				filename_chm=filename_chm, Dh_sc=Dh_sc,
+				init_unif_edens_flag=init_unif_edens_flag,
+				init_unif_edens=init_unif_edens, 
+				N_mp_max=N_mp_max,
+				nel_mp_ref_0=nel_mp_ref_0,
+				B_multip=B_multip_per_eV*machine.p0/e*c)
+
+# install ecloud in the machine
+machine.install_after_each_transverse_segment(ecloud)
+
+# setup transverse losses (to "protect" the ecloud)
+import PyHEADTAIL.aperture.aperture as aperture
+apt_xy = aperture.EllipticalApertureXY(x_aper=ecloud.impact_man.chamb.x_aper, y_aper=ecloud.impact_man.chamb.y_aper)
+machine.one_turn_map.append(apt_xy)
+
+# generate a bunch 
+bunch = machine.generate_6D_Gaussian_bunch_matched(n_macroparticles=300000, intensity=intensity, 
+		epsn_x=epsn_x, epsn_y=epsn_y, sigma_z=1.35e-9/4*c)
+
+# apply initial displacement
+bunch.x += x_kick
+bunch.y += y_kick
+
+# define a bunch monitor 
+from PyHEADTAIL.monitors.monitors import BunchMonitor
+bunch_monitor = BunchMonitor('bunch_evolution.h5', N_turns, {'Comment':'PyHDTL simulation'}, 
+					write_buffer_every = 8)
+
+# simulate
+import time
+for i_turn in xrange(N_turns):
+	print '%s Turn %d'%(time.strftime("%d/%m/%Y %H:%M:%S", time.localtime()), i_turn)
+	machine.track(bunch, verbose = False)
+	bunch_monitor.dump(bunch)
+	
+
+
+
+
+
+
+
+
+	
+	
+

test_instability/002_test_long_intstab_bologna/000_instability_simulation_serial.py

@@ -0,0 +1,13 @@
+import sys, os
+BIN = os.path.expanduser("../../../")
+sys.path.append(BIN)
+BIN = os.path.expanduser("../../")
+sys.path.append(BIN)
+
+from ring_of_CPUs import RingOfCPUs
+from Simulation_with_eclouds import Simulation
+simulation_content = Simulation()
+
+myCPUring = RingOfCPUs(simulation_content, N_pieces_per_transfer=1)
+
+myCPUring.run()

test_instability/002_test_long_intstab_bologna/001_parallel_test.py

@@ -0,0 +1,36 @@
+import numpy as np 
+#~ import bunchh5_to_obj as bh5o
+import myfilemanager as mfm
+import mystyle as ms
+import pylab as pl
+from scipy.constants import c as ccc
+
+
+pl.close('all')
+ob = mfm.bunchh5_to_obj('bunch_evolution.h5')
+
+pl.figure(1)
+pl.subplot(2,3,1)
+pl.plot(ob.mean_x)
+ms.sciy()
+pl.subplot(2,3,4)
+spectrum_x = np.abs(np.fft.rfft(ob.mean_x))
+pl.semilogy(np.linspace(0, .5, len(spectrum_x)), spectrum_x)
+
+
+pl.subplot(2,3,2)
+pl.plot(ob.mean_y)
+ms.sciy()
+pl.subplot(2,3,5)
+spectrum_y = np.abs(np.fft.rfft(ob.mean_y))
+pl.semilogy(np.linspace(0, .5, len(spectrum_y)), spectrum_y)
+
+pl.subplot(2,3,3)
+pl.plot(ob.epsn_x)
+ms.sciy()
+pl.gca().ticklabel_format(useOffset=False)
+pl.subplot(2,3,6)
+pl.plot(ob.epsn_y)
+ms.sciy()
+pl.gca().ticklabel_format(useOffset=False)
+pl.show()

test_instability/002_test_long_intstab_bologna/003_recombined_plots_gianni.py

@@ -0,0 +1,57 @@
+from PyHEADTAIL.machines.synchrotron import BasicSynchrotron
+import numpy as np
+from scipy.constants import c, e, m_p
+
+class LHC(BasicSynchrotron):
+
+	def __init__(self, n_segments, machine_configuration):
+		
+		
+		circumference = 26658.8832
+
+		
+
+		if machine_configuration =='HLLHC-injection':
+			charge = e
+			mass = m_p
+			
+			alpha_x        = 0. 
+			beta_x         = 92.7 
+			D_x            = 0. 
+			alpha_y        = 0. 
+			beta_y         = 93.2 
+			D_y            = 0.
+
+			accQ_x        = 62.28
+			accQ_y        = 60.31
+
+			Qp_x           = 0
+			Qp_y           = 0
+
+			app_x          = 0.0000e-9
+			app_y          = 0.0000e-9
+			app_xy         = 0
+
+			alpha     	   = 3.4561e-04
+			
+			h_RF           = 35640
+			V_RF           = 8e6
+			dphi_RF        = 0.
+			
+			
+			longitudinal_mode = 'non-linear'
+			
+			p0 = 450.e9 * e /c
+			
+			p_increment       = 0.
+			
+		else:
+			raise ValueError('ERROR: unknown machine configuration', machine_configuration)
+
+		
+		super(LHC, self).__init__(optics_mode='smooth', circumference=circumference, n_segments=n_segments,
+             alpha_x=alpha_x, beta_x=beta_x, D_x=D_x, alpha_y=alpha_y, beta_y=beta_y, D_y=D_y,
+             accQ_x=accQ_x, accQ_y=accQ_y, Qp_x=Qp_x, Qp_y=Qp_y, app_x=app_x, app_y=app_y, app_xy=app_xy,
+             alpha_mom_compaction=alpha, longitudinal_mode=longitudinal_mode,
+             h_RF=np.atleast_1d(h_RF), V_RF=np.atleast_1d(V_RF), dphi_RF=np.atleast_1d(dphi_RF), p0=p0, p_increment=p_increment,
+             charge=charge, mass=mass, RF_at='end_of_transverse')