Merge branch 'develop'

.gitignore

@@ -34,3 +34,6 @@ test_multipole
 *.beamc
 *.bak
 *.out
+Pyecltest_angle3D_electron1.mat
+Pyecltest_angle3D_electron2.mat
+Pyecltest_angle3D_electron3.mat

002_change_version_number.py

@@ -9,7 +9,7 @@
         with open(filename) as fid:
             content=fid.read()
         if '[email protected]' in content:
-            content=content.replace('PyECLOUD Version 6.7.2', 'PyECLOUD Version 6.7.2')
+            content=content.replace('PyECLOUD Version 7.0.0', 'PyECLOUD Version 7.0.0')
             with open(filename,'w') as fid:
                 fid.write(content)
 

003_change_preamble.py

@@ -20,7 +20,7 @@
 #
 #     This file is part of the code:
 #
-#                   PyECLOUD Version 6.7.2
+#                   PyECLOUD Version 7.0.0
 #
 #
 #     Main author:          Giovanni IADAROLA

MP_system.py

@@ -7,7 +7,7 @@
 #
 #     This file is part of the code:
 #
-#                   PyECLOUD Version 6.7.2
+#                   PyECLOUD Version 7.0.0
 #
 #
 #     Main author:          Giovanni IADAROLA

PyEC4PyHT.py

@@ -7,7 +7,7 @@
 #
 #     This file is part of the code:
 #
-#                   PyECLOUD Version 6.7.2
+#                   PyECLOUD Version 7.0.0
 #
 #
 #     Main author:          Giovanni IADAROLA
@@ -63,9 +63,9 @@ class MP_light(object):
 
 class Ecloud(object):
     def __init__(self, L_ecloud, slicer, Dt_ref, pyecl_input_folder='./', flag_clean_slices=False,
-                 slice_by_slice_mode=False, space_charge_obj=None, MP_e_mass=m_e, MP_e_charge=-e, **kwargs):
+                 slice_by_slice_mode=False, space_charge_obj=None, **kwargs):
 
-        print 'PyECLOUD Version 6.7.2'
+        print 'PyECLOUD Version 7.0.0'
 
         # These git commands return the hash and the branch of the specified git directory.
         path_to_git = os.path.dirname(os.path.abspath(__file__)) +'/.git'
@@ -96,20 +96,13 @@ def __init__(self, L_ecloud, slicer, Dt_ref, pyecl_input_folder='./', flag_clean
 
         (
         beamtim,
-        MP_e,
-        dynamics,
-        impact_man,
-        pyeclsaver,
-        gas_ion_flag,
-        resgasion,
-        t_ion,
         spacech_ele,
         t_sc_ON,
-        photoem_flag,
-        phemiss,
         flag_presence_sec_beams,
         sec_beams_list,
-        config_dict
+        config_dict,
+        flag_multiple_clouds,
+        cloud_list
         ) = init.read_input_files_and_init_components(pyecl_input_folder=pyecl_input_folder, skip_beam=True,
             skip_pyeclsaver=True, skip_spacech_ele=(space_charge_obj is not None),
             ignore_kwargs=extra_allowed_kwargs, **kwargs)
@@ -156,11 +149,29 @@ def __init__(self, L_ecloud, slicer, Dt_ref, pyecl_input_folder='./', flag_clean
 
         spacech_ele.flag_decimate = False
 
+        if flag_multiple_clouds:
+            raise ValueError('Multiple clouds not yet implemented in PyEC4PyHT!')
+        else:
+            cloud = cloud_list[0]
+
+            MP_e = cloud.MP_e
+            dynamics = cloud.dynamics
+            impact_man = cloud.impact_man
+            pyeclsaver = cloud.pyeclsaver
+            gas_ion_flag = cloud.gas_ion_flag
+            resgasion = cloud.resgasion
+            t_ion = cloud.t_ion
+            photoem_flag = cloud.photoem_flag
+            phemiss = cloud.phemiss
+
         self.MP_e = MP_e
         self.dynamics = dynamics
         self.impact_man = impact_man
         self.spacech_ele = spacech_ele
 
+        self.gas_ion_flag = gas_ion_flag
+        self.resgasion = resgasion
+
         self.save_ele_distributions_last_track = False
         self.save_ele_potential_and_field = False
         self.save_ele_potential = False

PyEC4PyHT_fastion.py

@@ -7,7 +7,7 @@
 #
 #     This file is part of the code:
 #
-#                   PyECLOUD Version 6.7.2
+#                   PyECLOUD Version 7.0.0
 #
 #
 #     Main author:          Giovanni IADAROLA
@@ -62,29 +62,23 @@ class MP_light(object):
 
 class Ecloud_fastion(Ecloud):
 
-    def __init__(self, L_ecloud, slicer, Dt_ref, MP_e_mass, MP_e_charge, pyecl_input_folder = './',
+    def __init__(self, L_ecloud, slicer, Dt_ref, pyecl_input_folder = './',
                 flag_clean_slices = False, slice_by_slice_mode = False, space_charge_obj = None,
                 beam_monitor = None, include_cloud_sc = False, ionize_only_first_bunch = False, **kwargs):
 
 
         super(Ecloud_fastion, self).__init__(L_ecloud, slicer, Dt_ref, pyecl_input_folder = pyecl_input_folder,
                                                 flag_clean_slices = flag_clean_slices, slice_by_slice_mode = slice_by_slice_mode,
-                                                space_charge_obj = space_charge_obj, MP_e_mass = MP_e_mass,
-                                                MP_e_charge = MP_e_charge, **kwargs)
+                                                space_charge_obj = space_charge_obj, **kwargs)
 
         self.beam_monitor = beam_monitor
-        self.gas_ion_flag = kwargs['gas_ion_flag']
         self.include_cloud_sc = include_cloud_sc
         self.ionize_only_first_bunch = ionize_only_first_bunch
 
         self.MP_e_field_state = self.spacech_ele.PyPICobj.get_state_object()
         self.MP_p_field_state = self.spacech_ele.PyPICobj.get_state_object()
 
-        if self.gas_ion_flag == 1:
-            chamb = self.impact_man.chamb
-            gas_ionization = residual_gas_ionization(kwargs['unif_frac'], kwargs['P_nTorr'], kwargs['sigma_ion_MBarn'],
-                                kwargs['Temp_K'], chamb, kwargs['E_init_ion'])
-            self.gas_ionization = gas_ionization
+        self.gas_ionization = self.resgasion
 
 
 
@@ -112,7 +106,7 @@ def track(self, beam):
         # Only track over slices with particles
         filled_slices = np.where(slices.n_macroparticles_per_slice > 0)[0]
 
-        for i in filled_slices[::-1]:
+        for i in xrange(slices.n_slices-1, -1, -1):
 
             # select particles in the bunch
             ix = slices.particle_indices_of_slice(i)
@@ -163,112 +157,107 @@ def generate_twin_ecloud_with_shared_space_charge(self):
     #@profile
     def _track_single_slice(self, beam, ix, dz):
 
-        #pass
-        if len(ix) > 0:
-
-            MP_e = self.MP_e
-            dynamics = self.dynamics
-            impact_man = self.impact_man
-            spacech_ele = self.spacech_ele
-            MP_e_state = self.MP_e_field_state
-            MP_p_state = self.MP_p_field_state
-
-            dt = dz / (beam.beta * c)
-
-            # define substep
-            if dt > self.Dt_ref:
-                N_sub_steps = int(np.round(dt / self.Dt_ref))
-            else:
-                N_sub_steps = 1
-
-            Dt_substep = dt / N_sub_steps
-            # print Dt_substep, N_sub_steps, dt
-
-            # beam particles
-            MP_p = MP_light()
-            MP_p.x_mp = beam.x[ix]
-            MP_p.y_mp = beam.y[ix]
-            MP_p.nel_mp = beam.x[ix] * 0. + beam.particlenumber_per_mp
-            MP_p.N_mp = len(beam.x[ix])
-            MP_p.charge = beam.charge
-
-            mean_x = np.mean(beam.x[ix])
-            mean_y = np.mean(beam.y[ix])
-            sigma_x = np.std(beam.x[ix])
-            sigma_y = np.std(beam.y[ix])
-
-            if self.gas_ion_flag == 1:
-                Np_bunch = MP_p.N_mp * beam.particlenumber_per_mp
-                dz_bunch = dz
-                lambda_bunch = Np_bunch
-                dt_bunch = 1 / c
-                MP_e = self.gas_ionization.generate(MP_e=MP_e, lambda_t=lambda_bunch, Dt=dt_bunch, sigmax=sigma_x,
-                                                    sigmay=sigma_y, x_beam_pos=mean_x, y_beam_pos=mean_y)
-                if self.ionize_only_first_bunch:
-                    self.gas_ion_flag = 0
-
-            # scatter fields
-            MP_e_state.scatter(MP_e.x_mp[0:MP_e.N_mp],MP_e.y_mp[0:MP_e.N_mp],MP_e.nel_mp[0:MP_e.N_mp], charge = MP_e.charge)
-            MP_p_state.scatter(MP_p.x_mp[0:MP_p.N_mp],MP_p.y_mp[0:MP_p.N_mp],MP_p.nel_mp[0:MP_p.N_mp], charge = MP_p.charge)
-
-            # solve fields
-            spacech_ele.PyPICobj.solve_states([MP_e_state, MP_p_state])
-
-            # gather fields
-            Ex_sc_p, Ey_sc_p = MP_e_state.gather(MP_p.x_mp[0:MP_p.N_mp],MP_p.y_mp[0:MP_p.N_mp])
-            Ex_n_beam, Ey_n_beam = MP_p_state.gather(MP_e.x_mp[0:MP_e.N_mp],MP_e.y_mp[0:MP_e.N_mp])
-
-            # kick cloud particles
-            MP_e.vx_mp[:MP_e.N_mp] += Ex_n_beam * MP_e.charge / MP_e.mass / c
-            MP_e.vy_mp[:MP_e.N_mp] += Ey_n_beam * MP_e.charge / MP_e.mass / c
-
-            # kick beam particles
-            fact_kick = beam.charge / (beam.mass * beam.beta * beam.beta * beam.gamma * c * c) * self.L_ecloud
-            beam.xp[ix] += fact_kick * Ex_sc_p
-            beam.yp[ix] += fact_kick * Ey_sc_p
-
-
-            # Total electric field on electrons
-            if self.include_cloud_sc:
-                Ex_sc_n, Ey_sc_n = MP_e_state.gather(MP_e.x_mp[0:MP_e.N_mp],MP_e.y_mp[0:MP_e.N_mp])
-                Ex_n = Ex_sc_n
-                Ey_n = Ey_sc_n
-            else:
-                Ex_n = MP_e.vx_mp[:MP_e.N_mp] * 0.
-                Ey_n = Ex_n
-
-            # save position before motion step
-            old_pos = MP_e.get_positions()
-
-            # motion electrons
-            MP_e = dynamics.stepcustomDt(MP_e, Ex_n,Ey_n, Dt_substep=Dt_substep, N_sub_steps=N_sub_steps)
-
-            # impacts: backtracking and secondary emission
-            MP_e = impact_man.backtrack_and_second_emiss(old_pos, MP_e)
-
-
-            if self.save_ele_distributions_last_track:
-                self.rho_ele_last_track.append(spacech_ele.rho.copy())
-                #print 'Here'
-
-            if self.save_ele_potential_and_field:
-                self.phi_ele_last_track.append(spacech_ele.phi.copy())
-                self.Ex_ele_last_track.append(spacech_ele.efx.copy())
-                self.Ey_ele_last_track.append(spacech_ele.efy.copy())
-
-            if self.save_ele_MP_position:
-                self.x_MP_last_track.append(MP_e.x_mp.copy())
-                self.y_MP_last_track.append(MP_e.y_mp.copy())
-
-            if self.save_ele_MP_velocity:
-                self.vx_MP_last_track.append(MP_e.vx_mp.copy())
-                self.vy_MP_last_track.append(MP_e.vy_mp.copy())
-
-            if self.save_ele_MP_size:
-                self.nel_MP_last_track.append(MP_e.nel_mp.copy())
-
-            if self.save_ele_MP_position or self.save_ele_MP_velocity or self.save_ele_MP_size:
-                self.N_MP_last_track.append(MP_e.N_mp)
+        MP_e = self.MP_e
+        dynamics = self.dynamics
+        impact_man = self.impact_man
+        spacech_ele = self.spacech_ele
+        MP_e_state = self.MP_e_field_state
+        MP_p_state = self.MP_p_field_state
+
+        dt = dz / (beam.beta * c)
+
+        # define substep
+        if dt > self.Dt_ref:
+            N_sub_steps = int(np.round(dt / self.Dt_ref))
+        else:
+            N_sub_steps = 1
+
+        Dt_substep = dt / N_sub_steps
+        # print Dt_substep, N_sub_steps, dt
+
+        # beam particles
+        MP_p = MP_light()
+        MP_p.x_mp = beam.x[ix]
+        MP_p.y_mp = beam.y[ix]
+        MP_p.nel_mp = beam.x[ix] * 0. + beam.particlenumber_per_mp
+        MP_p.N_mp = len(beam.x[ix])
+        MP_p.charge = beam.charge
+
+        mean_x = np.mean(beam.x[ix])
+        mean_y = np.mean(beam.y[ix])
+        sigma_x = np.std(beam.x[ix])
+        sigma_y = np.std(beam.y[ix])
 
+        if self.gas_ion_flag == 1:
+            Np_bunch = MP_p.N_mp * beam.particlenumber_per_mp
+            dz_bunch = dz
+            lambda_bunch = Np_bunch
+            dt_bunch = 1 / c
+            MP_e = self.gas_ionization.generate(MP_e=MP_e, lambda_t=lambda_bunch, Dt=dt_bunch, sigmax=sigma_x,
+                                                sigmay=sigma_y, x_beam_pos=mean_x, y_beam_pos=mean_y)
+            if self.ionize_only_first_bunch:
+                self.gas_ion_flag = 0
+
+        # scatter fields
+        MP_e_state.scatter(MP_e.x_mp[0:MP_e.N_mp],MP_e.y_mp[0:MP_e.N_mp],MP_e.nel_mp[0:MP_e.N_mp], charge = MP_e.charge)
+        MP_p_state.scatter(MP_p.x_mp[0:MP_p.N_mp],MP_p.y_mp[0:MP_p.N_mp],MP_p.nel_mp[0:MP_p.N_mp], charge = MP_p.charge)
+
+        # solve fields
+        spacech_ele.PyPICobj.solve_states([MP_e_state, MP_p_state])
+
+        # gather fields
+        Ex_sc_p, Ey_sc_p = MP_e_state.gather(MP_p.x_mp[0:MP_p.N_mp],MP_p.y_mp[0:MP_p.N_mp])
+        Ex_n_beam, Ey_n_beam = MP_p_state.gather(MP_e.x_mp[0:MP_e.N_mp],MP_e.y_mp[0:MP_e.N_mp])
+
+        # kick cloud particles
+        MP_e.vx_mp[:MP_e.N_mp] += Ex_n_beam * MP_e.charge / MP_e.mass / c
+        MP_e.vy_mp[:MP_e.N_mp] += Ey_n_beam * MP_e.charge / MP_e.mass / c
+
+        # kick beam particles
+        fact_kick = beam.charge / (beam.mass * beam.beta * beam.beta * beam.gamma * c * c) * self.L_ecloud
+        beam.xp[ix] += fact_kick * Ex_sc_p
+        beam.yp[ix] += fact_kick * Ey_sc_p
+
+
+        # Total electric field on electrons
+        if self.include_cloud_sc:
+            Ex_sc_n, Ey_sc_n = MP_e_state.gather(MP_e.x_mp[0:MP_e.N_mp],MP_e.y_mp[0:MP_e.N_mp])
+            Ex_n = Ex_sc_n
+            Ey_n = Ey_sc_n
         else:
-            pass
+            Ex_n = MP_e.vx_mp[:MP_e.N_mp] * 0.
+            Ey_n = Ex_n
+
+        # save position before motion step
+        old_pos = MP_e.get_positions()
+
+        # motion electrons
+        MP_e = dynamics.stepcustomDt(MP_e, Ex_n,Ey_n, Dt_substep=Dt_substep, N_sub_steps=N_sub_steps)
+
+        # impacts: backtracking and secondary emission
+        MP_e = impact_man.backtrack_and_second_emiss(old_pos, MP_e)
+
+
+        if self.save_ele_distributions_last_track:
+            self.rho_ele_last_track.append(spacech_ele.rho.copy())
+            #print 'Here'
+
+        if self.save_ele_potential_and_field:
+            self.phi_ele_last_track.append(spacech_ele.phi.copy())
+            self.Ex_ele_last_track.append(spacech_ele.efx.copy())
+            self.Ey_ele_last_track.append(spacech_ele.efy.copy())
+
+        if self.save_ele_MP_position:
+            self.x_MP_last_track.append(MP_e.x_mp.copy())
+            self.y_MP_last_track.append(MP_e.y_mp.copy())
+
+        if self.save_ele_MP_velocity:
+            self.vx_MP_last_track.append(MP_e.vx_mp.copy())
+            self.vy_MP_last_track.append(MP_e.vy_mp.copy())
+
+        if self.save_ele_MP_size:
+            self.nel_MP_last_track.append(MP_e.nel_mp.copy())
+
+        if self.save_ele_MP_position or self.save_ele_MP_velocity or self.save_ele_MP_size:
+            self.N_MP_last_track.append(MP_e.N_mp)
+