first physics test is running

but no output yet

Author: giadarol

test_physics/000_test_with_ecloud.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)
+
+myCPUring.run()

test_physics/Simulation_with_eclouds.py

@@ -7,6 +7,9 @@
 epsn_x = 2.5e-6
 epsn_y = 2.5e-6
 
+filename = '../../PyECLOUD/testing/tests_PyEC4PyHT/headtail_for_test/test_protons/SPS_Q20_proton_check_dipole_3kicks_20150212_prb.dat'
+B_multip = [0.5]
+
 
 class Simulation(object):
 	def __init__(self):
@@ -15,15 +18,15 @@ def __init__(self):
 	def init_all(self):
 
 		n_slices = 64
-		
 		self.n_slices = n_slices
 
-		n_segments=3
+		n_segments = 3
+		self.n_segments = n_segments
 
 		from machines_for_testing import SPS
-		machine = SPS(n_segments = n_segments, 
+		self.machine = SPS(n_segments = n_segments, 
 			machine_configuration = 'Q20-injection', accQ_x=20., accQ_y=20., 
-					RF_at=RF_at='end_of_transverse')
+					RF_at='end_of_transverse')
 
 
 		# We suppose that all the object that cannot be slice parallelized are at the end of the ring
@@ -46,32 +49,36 @@ def init_all(self):
 		init_unif_edens=2e11
 		N_MP_ele_init = 100000
 		N_mp_max = N_MP_ele_init*4.
-
+		
 		# define apertures and Dh_sc to simulate headtail 
-		inj_optics = machine.transverse_map.get_injection_optics()
-		sigma_x = np.sqrt(inj_optics['beta_x']*epsn_x/machine.betagamma)
-		sigma_y = np.sqrt(inj_optics['beta_y']*epsn_y/machine.betagamma)
+		inj_optics = self.machine.transverse_map.get_injection_optics()
+		sigma_x = np.sqrt(inj_optics['beta_x']*epsn_x/self.machine.betagamma)
+		sigma_y = np.sqrt(inj_optics['beta_y']*epsn_y/self.machine.betagamma)
 		x_aper  = 20*sigma_x
 		y_aper  = 20*sigma_y
 		Dh_sc = 2*x_aper/128/2
+		
+		# initial MP size
+		nel_mp_ref_0 = init_unif_edens*4*x_aper*y_aper/N_MP_ele_init
 
 		import PyECLOUD.PyEC4PyHT as PyEC4PyHT
 		my_new_part = []
 		self.my_list_eclouds = []
 		for ele in self.mypart:
 			my_new_part.append(ele)
 			if ele in self.machine.transverse_map:
-				ecloud_new = PyEC4PyHT.Ecloud(L_ecloud=machine.circumference/N_kicks, 
+				ecloud_new = PyEC4PyHT.Ecloud(slice_by_slice_mode=True,
+						L_ecloud=self.machine.circumference/n_segments, 
 						slicer=None, 
-						Dt_ref=25e-12, pyecl_input_folder='./drift_sim',
+						Dt_ref=25e-12, 
+						pyecl_input_folder='../../PyECLOUD/testing/tests_PyEC4PyHT/drift_sim/',
 						x_aper=x_aper, y_aper=y_aper, Dh_sc=Dh_sc,
 						init_unif_edens_flag=init_unif_edens_flag,
 						init_unif_edens=init_unif_edens, 
 						N_MP_ele_init=N_MP_ele_init,
 						N_mp_max=N_mp_max,
 						nel_mp_ref_0=nel_mp_ref_0,
 						B_multip=B_multip)
-					slice_by_slice_mode=True)
 				my_new_part.append(ecloud_new)
 				self.my_list_eclouds.append(ecloud_new)
 		self.mypart = my_new_part
@@ -89,17 +96,16 @@ def init_master(self):
 		print 'Bunch initialized.'
 
 		#replace particles with HDTL ones
-		filename = 'headtail_for_test/test_protons/SPS_Q20_proton_check_dipole_3kicks_20150212_prb.dat'
 		n_part_per_turn = 5000
 		appo = np.loadtxt(filename)
-
-		parid = np.reshape(appo[:,0], (-1, n_part_per_turn))[::N_kicks,:]
-		x = np.reshape(appo[:,1], (-1, n_part_per_turn))[::N_kicks,:]
-		xp = np.reshape(appo[:,2], (-1, n_part_per_turn))[::N_kicks,:]
-		y = np.reshape(appo[:,3], (-1, n_part_per_turn))[::N_kicks,:]
-		yp =np.reshape(appo[:,4], (-1, n_part_per_turn))[::N_kicks,:]
-		z = np.reshape(appo[:,5], (-1, n_part_per_turn))[::N_kicks,:]
-		zp = np.reshape(appo[:,6], (-1, n_part_per_turn))[::N_kicks,:]
+		
+		parid = np.reshape(appo[:,0], (-1, n_part_per_turn))[::self.n_segments,:]
+		x = np.reshape(appo[:,1], (-1, n_part_per_turn))[::self.n_segments,:]
+		xp = np.reshape(appo[:,2], (-1, n_part_per_turn))[::self.n_segments,:]
+		y = np.reshape(appo[:,3], (-1, n_part_per_turn))[::self.n_segments,:]
+		yp =np.reshape(appo[:,4], (-1, n_part_per_turn))[::self.n_segments,:]
+		z = np.reshape(appo[:,5], (-1, n_part_per_turn))[::self.n_segments,:]
+		zp = np.reshape(appo[:,6], (-1, n_part_per_turn))[::self.n_segments,:]
 		self.N_turns = len(x[:,0])
 
 		# replace first particles with HEADTAIL ones

test_physics/machines_for_testing.py

@@ -0,0 +1,226 @@
+from PyHEADTAIL.machines.synchrotron import BasicSynchrotron
+import numpy as np
+from scipy.constants import c, e, m_p
+
+class SPS(BasicSynchrotron):
+
+	def __init__(self, machine_configuration=None, optics_mode='smooth', **kwargs):
+		
+		
+		longitudinal_mode = 'linear' 
+		h_RF       	= 4620
+		mass 		= m_p
+		charge		= e
+		
+		if machine_configuration=='Q26-injection':
+			p0 		= 26e9 * e /c
+			p_increment 	= 0.
+			accQ_x		= 26.13
+			accQ_y		= 26.18
+			V_RF		= 2e6
+			dphi_RF		= 0.
+			alpha		= 0.00192
+			beta_x 		= 42.
+			D_x 		= 0
+			beta_y 		= 42.
+			D_y 		= 0 
+		elif machine_configuration=='Q20-injection':
+			p0 		= 26e9 * e /c
+			p_increment 	= 0.
+			accQ_x		= 20.13
+			accQ_y		= 20.18
+			V_RF		= 5.75e6
+			dphi_RF		= 0.
+			alpha		= 0.00308642
+			beta_x 		= 54.6
+			D_x 		= 0
+			beta_y 		= 54.6
+			D_y 		= 0 			
+		else:
+			raise ValueError('machine_configuration not recognized!')
+			
+		
+		
+		if optics_mode=='smooth':
+			if 's' in kwargs.keys(): raise ValueError('s vector cannot be provided if optics_mode = "smooth"')
+			
+			n_segments = kwargs['n_segments']
+			circumference = 1100*2*np.pi
+			
+			name = None
+			
+
+			
+			alpha_x 	= None
+			alpha_y 	= None
+			
+			s = None
+			
+		elif optics_mode=='non-smooth':
+			if 'n_segments' in kwargs.keys(): raise ValueError('n_segments cannot be provided if optics_mode = "non-smooth"')
+			n_segments = None
+			circumference = None
+			
+			name		= kwargs['name']
+			
+			beta_x 		= kwargs['beta_x']
+			beta_y 		= kwargs['beta_y'] 
+
+			try:
+				D_x 		= kwargs['D_x']	
+			except KeyError:
+				D_x 		= 0*np.array(kwargs['s'])
+			try:
+				D_y 		= kwargs['D_y']	
+			except KeyError:
+				D_y 		= 0*np.array(kwargs['s'])			
+					
+			alpha_x 	= kwargs['alpha_x']
+			alpha_y 	= kwargs['alpha_y']
+			
+			s = kwargs['s']
+		
+		else:
+			raise ValueError('optics_mode not recognized!')		
+
+		
+		# detunings
+		Qp_x		= 0
+		Qp_y		= 0
+		
+		app_x		= 0
+		app_y		= 0
+		app_xy		= 0
+		
+		i_octupole_focusing = None
+		i_octupole_defocusing = None
+		octupole_knob = None	
+		
+		for attr in kwargs.keys():
+			if kwargs[attr] is not None:
+				if type(kwargs[attr]) is list or type(kwargs[attr]) is np.ndarray:
+					str2print = '[%s ...]'%repr(kwargs[attr][0])
+				else:
+					str2print = repr(kwargs[attr])
+				self.prints('Synchrotron init. From kwargs: %s = %s'
+							% (attr, str2print))
+				temp =  kwargs[attr]
+				exec('%s = temp'%attr)
+				
+
+
+
+		
+		
+		super(SPS, self).__init__(optics_mode=optics_mode, circumference=circumference, n_segments=n_segments, s=s, name=name,
+             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)
+		
+class shortSPS(BasicSynchrotron):
+
+	def __init__(self, machine_configuration=None, optics_mode='smooth', **kwargs):
+		
+		
+		longitudinal_mode = 'linear' 
+		h_RF       	= 4620/6
+		mass 		= m_p
+		charge		= e
+		
+
+		if machine_configuration=='Q20-injection-like':
+			p0 		= 26e9 * e /c
+			p_increment 	= 0.
+			accQ_x		= 5.13
+			accQ_y		= 5.18
+			V_RF		= 5.75e6
+			dphi_RF		= 0.
+			alpha		= 6*0.00308642
+			beta_x 		= 54.6
+			D_x 		= 0
+			beta_y 		= 54.6
+			D_y 		= 0 			
+		else:
+			raise ValueError('machine_configuration not recognized!')
+			
+		
+		
+		if optics_mode=='smooth':
+			if 's' in kwargs.keys(): raise ValueError('s vector cannot be provided if optics_mode = "smooth"')
+			
+			n_segments = kwargs['n_segments']
+			circumference = 1100*2*np.pi/6.
+			
+			name = None
+			
+
+			
+			alpha_x 	= None
+			alpha_y 	= None
+			
+			s = None
+			
+		elif optics_mode=='non-smooth':
+			if 'n_segments' in kwargs.keys(): raise ValueError('n_segments cannot be provided if optics_mode = "non-smooth"')
+			n_segments = None
+			circumference = None
+			
+			name		= kwargs['name']
+			
+			beta_x 		= kwargs['beta_x']
+			beta_y 		= kwargs['beta_y'] 
+
+			try:
+				D_x 		= kwargs['D_x']	
+			except KeyError:
+				D_x 		= 0*np.array(kwargs['s'])
+			try:
+				D_y 		= kwargs['D_y']	
+			except KeyError:
+				D_y 		= 0*np.array(kwargs['s'])			
+					
+			alpha_x 	= kwargs['alpha_x']
+			alpha_y 	= kwargs['alpha_y']
+			
+			s = kwargs['s']
+		
+		else:
+			raise ValueError('optics_mode not recognized!')		
+
+		
+		# detunings
+		Qp_x		= 0
+		Qp_y		= 0
+		
+		app_x		= 0
+		app_y		= 0
+		app_xy		= 0
+		
+		i_octupole_focusing = None
+		i_octupole_defocusing = None
+		octupole_knob = None	
+		
+		for attr in kwargs.keys():
+			if kwargs[attr] is not None:
+				if type(kwargs[attr]) is list or type(kwargs[attr]) is np.ndarray:
+					str2print = '[%s ...]'%repr(kwargs[attr][0])
+				else:
+					str2print = repr(kwargs[attr])
+				self.prints('Synchrotron init. From kwargs: %s = %s'
+							% (attr, str2print))
+				temp =  kwargs[attr]
+				exec('%s = temp'%attr)
+				
+
+
+
+		
+		
+		super(shortSPS, self).__init__(optics_mode=optics_mode, circumference=circumference, n_segments=n_segments, s=s, name=name,
+             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)