Merge branch 'develop'

Author: giadarol

.gitignore

@@ -1,3 +1,5 @@
+*.swp
+
 # specific of PyParaSlice
 pyparislog.txt
 test_pickle.pkl

communication_helpers.py

@@ -37,7 +37,7 @@ def list_of_strings_2_buffer(strlist):
 
 def buffer_2_list_of_strings(buf):
 	str_received = ''.join(map(unichr, list(buf)))
-	strlist = map(str, str_received.split('\n')[0].split(';'))[:-1]
+	strlist = list(map(str, str_received.split('\n')[0].split(';')))[:-1]
 	return strlist
 
 

gen_multibunch_beam.py

@@ -21,6 +21,7 @@ def gen_matched_multibunch_beam(machine, n_macroparticles_per_bunch, filling_pat
     list_genbunches = []
     for i_slot, inten_slot in enumerate(filling_pattern):
         if inten_slot>0:
+            print('Generating bunch at slot %d/%d'%(i_slot, len(filling_pattern)))
             bunch = generate_bunch(n_macroparticles_per_bunch, inten_slot*bunch_intensity, epsn_x, epsn_y, sigma_z=sigma_z)
             bunch.z -= b_spac_buckets*bucket_length_m*i_slot
             list_genbunches.append(bunch)
@@ -51,9 +52,6 @@ def gen_matched_multibunch_beam(machine, n_macroparticles_per_bunch, filling_pat
         bb.slice_info['interact_with_EC'] = slice4EC
         bb.slice_info['N_bunches_tot_beam'] = len(list_bunches)
         bb.slice_info['i_bunch'] = i_bb
-	bb.slice_info['i_turn'] = 0
-        
-
-       
+        bb.slice_info['i_turn'] = 0
 
     return list_bunches

generate_python3

@@ -0,0 +1,6 @@
+mkdir ../python3
+rm -rf ../python3/PyPARIS
+cp -r ../PyPARIS ../python3/PyPARIS
+rm ../python3/PyPARIS/*.so
+2to3 --output-dir=../python3/PyPARIS -W -n ../PyPARIS
+rm -rf ../python3/PyPARIS/.git

multiprocexec.py

@@ -3,6 +3,8 @@
 import multiprocessing as mp
 import numpy as np
 import os, sys
+import importlib
+
 
 class mpComm(object):
     def __init__(self, pid, N_proc, queue_list,
@@ -68,22 +70,21 @@ def todo(sim_module_string, pid, N_proc, queue_list,
     sys.path.append(BIN)
 
     sim_module_strings = sim_module_string.split('.')
-    if len(sim_module_strings)!=2:
-        raise(ValueError('\n\nsim_class must be given in the form: module.class.\nNested referencing not implemented.\n\n'))
-    module_name = sim_module_strings[0]
-    class_name = sim_module_strings[1]
+    # if len(sim_module_strings)!=2:
+    #     raise(ValueError('\n\nsim_class must be given in the form: module.class.\nNested referencing not implemented.\n\n'))
+    module_name = '.'.join(sim_module_strings[:-1])
+    class_name = sim_module_strings[-1]
 
-    
-    SimModule = __import__(module_name)
+    SimModule = importlib.import_module(module_name)
     SimClass = getattr(SimModule, class_name)
 
     if multiturn:
-        from ring_of_CPUs_multiturn import RingOfCPUs_multiturn
+        from PyPARIS.ring_of_CPUs_multiturn import RingOfCPUs_multiturn
         simulation_content = SimClass()
         myCPUring = RingOfCPUs_multiturn(simulation_content, comm=comm)
         myCPUring.run()
     else:
-        from ring_of_CPUs import RingOfCPUs
+        from PyPARIS.ring_of_CPUs import RingOfCPUs
         simulation_content = SimClass()
         myCPUring = RingOfCPUs(simulation_content, comm=comm)
         myCPUring.run()

myfilemanager.py

@@ -2,70 +2,91 @@
 
 
 class obj_from_dict:
-	def __init__(self, dictto):
-		for kk in dictto.keys():
-			exec 'self.'+kk +'= dictto[kk]'
-			
-			
+    def __init__(self, dictto):
+        for kk in dictto.keys():
+            setattr(self, kk, dictto[kk])
+            
+            
 def obj_to_dict(obj):
-	dict_out={}
-	members = dir(obj)
-	for member in members:
-		exec "dict_out['%s'] = obj.%s"%(member,member)
-	return dict_out
-			
+    dict_out={}
+    members = dir(obj)
+    for member in members:
+        dict_out[member] = getattr(obj, member)
+    return dict_out
+    
+
 def myloadmat(filename, squeeze = True):
-	import scipy.io as sio
-	dict_var=sio.loadmat(filename)
-	if squeeze:
-		for kk in dict_var.keys():
-			try:
-				dict_var[kk]=np.squeeze(dict_var[kk])
-			except:
-				pass
-	return dict_var
-	
-			
-			
+    import scipy.io as sio
+    dict_var=sio.loadmat(filename)
+    if squeeze:
+        for kk in dict_var.keys():
+            try:
+                dict_var[kk]=np.squeeze(dict_var[kk])
+            except:
+                pass
+    return dict_var
+            
+            
 def myloadmat_to_obj(filename, squeeze = True):
-	return  obj_from_dict(myloadmat(filename, squeeze=squeeze))			
-	
-	
-	
+    return  obj_from_dict(myloadmat(filename, squeeze=squeeze))
+    
+    
 def dict_of_arrays_and_scalar_from_h5(filename):
-	import h5py
-	with h5py.File(filename) as fid:
-		f_dict = {}
-		for kk in fid.keys():
-			f_dict[kk] = np.array(fid[kk]).copy()
-			if f_dict[kk].shape == ():
-				f_dict[kk] = f_dict[kk].tolist()
-	return  f_dict
-	
+    import h5py
+    with h5py.File(filename, 'r') as fid:
+        f_dict = {}
+        for kk in fid.keys():
+            f_dict[kk] = np.array(fid[kk]).copy()
+            if f_dict[kk].shape == ():
+                f_dict[kk] = f_dict[kk].tolist()
+    return  f_dict
+    
 def object_with_arrays_and_scalar_from_h5(filename):
-	return  obj_from_dict(dict_of_arrays_and_scalar_from_h5(filename))
-	
-def bunchh5_to_dict(filename):
-	import h5py
-	with h5py.File(filename, 'r') as bunch_ev:
-		bunch = bunch_ev['Bunch']
-		bunch_dict = {}
-		for kk in bunch.keys():
-			bunch_dict[kk] = np.array(bunch[kk]).copy()
-		
-	return bunch_dict
-			
-def bunchh5_to_obj(filename):
-	return  obj_from_dict(bunchh5_to_dict(filename))
-	
-def bunchh5list_to_dict(filename_list):
-	bunch_dict = bunchh5_to_dict(filename_list[0])
-	for i_file in xrange(1,len(filename_list)):
-		bunch_dict_curr = bunchh5_to_dict(filename_list[i_file])
-		for kk in bunch_dict.keys():
-			bunch_dict[kk] = np.array(list(bunch_dict[kk])+list(bunch_dict_curr[kk]))
-	
-	return bunch_dict
-	
-def bunchh5list_to_obj(filename_list):
-	return  obj_from_dict(bunchh5list_to_dict(filename_list))
+    return  obj_from_dict(dict_of_arrays_and_scalar_from_h5(filename))
+
+
+def monitorh5_to_dict(filename, key= 'Bunch'):
+    import h5py
+    with h5py.File(filename, 'r') as monitor_ev:
+        monitor = monitor_ev[key]
+        monitor_dict = {}
+        for kk in monitor.keys():
+            monitor_dict[kk] = np.array(monitor[kk]).copy()
+        
+    return monitor_dict
+    
+
+def monitorh5_to_obj(filename, key= 'Bunch'):
+    return  obj_from_dict(monitorh5_to_dict(filename, key))
+    
+def monitorh5list_to_dict(filename_list, key='Bunch', permissive=False):
+    monitor_dict = monitorh5_to_dict(filename_list[0], key=key)
+    for i_file in xrange(1,len(filename_list)):
+        print('Loading '+filename_list[i_file])
+        try:
+            monitor_dict_curr = monitorh5_to_dict(filename_list[i_file])
+            for kk in monitor_dict.keys():
+                monitor_dict[kk] = np.array(list(monitor_dict[kk])+list(monitor_dict_curr[kk]))
+        except IOError as err:
+            print('Got:')
+            print(err)
+            if not permissive:
+                raise err
+    
+    return monitor_dict   
+
+def monitorh5list_to_obj(filename_list, key= 'Bunch', permissive=False):
+    return  obj_from_dict(monitorh5list_to_dict(filename_list, key, permissive))
+
+
+def dict_to_h5(dict_save, filename):
+    import h5py
+    with h5py.File(filename, 'w') as fid:
+        for kk in dict_save.keys():
+                fid[kk] = dict_save[kk]
+
+
+
+
+
+

serialexec.py

@@ -2,12 +2,11 @@
 
 import numpy as np
 import os, sys
+import importlib
 
 BIN = os.path.expanduser("./")
 sys.path.append(BIN)
 
-import sys
-	
 if len(sys.argv)!=2:
     raise ValueError('\n\nSyntax must be:\n\t serialexec.py sim_class=module.class\n\n')
 if 'sim_class' not in sys.argv[1]:
@@ -16,16 +15,16 @@
 sim_module_string = sys.argv[1].split('=')[-1]
 
 sim_module_strings = sim_module_string.split('.')
-if len(sim_module_strings)!=2:
-    raise(ValueError('\n\nsim_class must be given in the form: module.class.\nNested referencing not implemented.\n\n'))
-module_name = sim_module_strings[0]
-class_name = sim_module_strings[1]
-    
 
-SimModule = __import__(module_name)
-SimClass = getattr(SimModule, class_name)
+# if len(sim_module_strings)!=2:
+#     raise(ValueError('\n\nsim_class must be given in the form: module.class.\nNested referencing not implemented.\n\n'))
+module_name = '.'.join(sim_module_strings[:-1])
+class_name = sim_module_strings[-1]
+    
+SimModule = importlib.import_module(module_name)
+SimClass = getattr(SimModule, class_name)    
 
-from ring_of_CPUs import RingOfCPUs
+from PyPARIS.ring_of_CPUs import RingOfCPUs
 simulation_content = SimClass()
 myCPUring = RingOfCPUs(simulation_content, force_serial=True)
 myCPUring.run()

test_instability/000_instability_simulation/002_fully_serial_sim.py

@@ -80,7 +80,8 @@
 
 # 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)
+apt_xy = aperture.EllipticalApertureXY(x_aper=ecloud.cloudsim.cloud_list[0].impact_man.chamb.x_aper, 
+                                       y_aper=ecloud.cloudsim.cloud_list[0].impact_man.chamb.y_aper)
 machine.one_turn_map.append(apt_xy)
 
 # generate a bunch 

test_instability/000_instability_simulation/003_plot_results.py

@@ -1,13 +1,15 @@
+import sys
+sys.path.append('../../../')
+
 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
 
+import PyPARIS.myfilemanager as mfm
 
 pl.close('all')
-ob = mfm.bunchh5_to_obj('bunch_evolution.h5')
+ob = mfm.monitorh5_to_obj('bunch_evolution.h5')
 
 pl.figure(1)
 pl.subplot(2,3,1)

test_instability/000_instability_simulation/004_run_with_python_multiprocess_nolounchscript.py

@@ -1,8 +1,6 @@
 import sys, os
 BIN = os.path.expanduser("../../../")
 sys.path.append(BIN)
-BIN = os.path.expanduser("../../")
-sys.path.append(BIN)
 
 import multiprocessing as mp
 import numpy as np
@@ -67,7 +65,7 @@ def todo(pid, N_proc, queue_list,
 	comm = mpComm(pid, N_proc, queue_list,
 					mutex, barriex, turnstile, turnstile2, cnt)
 
-	from ring_of_CPUs import RingOfCPUs
+	from PyPARIS.ring_of_CPUs import RingOfCPUs
 	from Simulation_with_eclouds import Simulation
 	simulation_content = Simulation()