"This notebook corresponds to version {{ version }} of the pipeline tool: https://github.com/NSLS-II/pipelines"
This notebook begins with a raw time-series of images and ends with $g_2(t)$ for a range of $q$, fit to an exponential or stretched exponential, and a two-time correlation functoin.
The important scientific code is imported from the chxanalys and scikit-beam project. Refer to chxanalys and scikit-beam for additional documentation and citation information.
CHX Olog (https://logbook.nsls2.bnl.gov/11-ID/)
Import packages for I/O, visualization, and analysis.
In [1]:
from chxanalys.chx_packages import *
%matplotlib notebook
plt.rcParams.update({'figure.max_open_warning': 0})
plt.rcParams.update({ 'image.origin': 'lower' })
plt.rcParams.update({ 'image.interpolation': 'none' })
import pickle as cpk
from skimage.draw import line_aa, line, polygon, ellipse
In [2]:
scat_geometry = 'saxs' #suport 'saxs', 'gi_saxs', 'ang_saxs' (for anisotropics saxs or flow-xpcs)
#scat_geometry = 'gi_saxs' #suport 'saxs', 'gi_saxs', 'ang_saxs' (for anisotropics saxs or flow-xpcs)
#scat_geometry = 'gi_waxs' #suport 'saxs', 'gi_saxs', 'ang_saxs' (for anisotropics saxs or flow-xpcs)
# gi_waxs define a simple box-shaped ROI
qphi_analysis = True #if True, do q-phi analysis in case of SAXS
force_compress = False
In [3]:
CYCLE= '2017_3' #change clycle here
#username = 'zhangz'
username = 'commissioning'
username='lwiegart'
path = '/XF11ID/analysis/%s/masks/'%CYCLE
data_dir0 = create_user_folder(CYCLE, username)
print( data_dir0 )
In [4]:
uid = '89ac4a' # (scan num: 7822) (Measurement: 750Hz 2k CoralPor )
In [ ]:
In [5]:
data_dir = os.path.join(data_dir0, '%s/'%uid)
os.makedirs(data_dir, exist_ok=True)
print('Results from this analysis will be stashed in the directory %s' % data_dir)
uidstr = 'uid=%s'%uid
In [6]:
sud = get_sid_filenames(db[uid])
print ('scan_id, full-uid, data path are: %s--%s--%s'%(sud[0], sud[1], sud[2][0] ))
In [7]:
md = get_meta_data( uid )
imgs = load_data( uid, md['detector'], reverse= True )
md.update( imgs.md );Nimg = len(imgs);
#if 'number of images' not in list(md.keys()):
md['number of images'] = Nimg
pixel_mask = 1- np.int_( np.array( imgs.md['pixel_mask'], dtype= bool) )
print( 'The data are: %s' %imgs )
md['acquire period' ] = md['cam_acquire_period']
md['exposure time'] = md['cam_acquire_time']
In [8]:
print_dict( md, ['suid', 'number of images', 'uid', 'scan_id', 'start_time', 'stop_time', 'sample', 'Measurement',
'acquire period', 'exposure time',
'det_distance', 'beam_center_x', 'beam_center_y', ] )
In [9]:
if scat_geometry =='gi_saxs':
inc_x0 = md['beam_center_x']
inc_y0 = imgs[0].shape[0] - md['beam_center_y']
refl_x0 = md['beam_center_x']
refl_y0 = imgs[0].shape[0] - 1758
print( "inc_x0, inc_y0, ref_x0,ref_y0 are: %s %s %s %s."%(inc_x0, inc_y0, refl_x0, refl_y0) )
else:
inc_x0 = imgs[0].shape[0] - md['beam_center_y']
inc_y0= md['beam_center_x']
In [10]:
dpix, lambda_, Ldet, exposuretime, timeperframe, center = check_lost_metadata(
md, Nimg, inc_x0 = inc_x0, inc_y0= inc_y0, pixelsize = 7.5*10*(-5) )
setup_pargs=dict(uid=uidstr, dpix= dpix, Ldet=Ldet, lambda_= lambda_, exposuretime=exposuretime,
timeperframe=timeperframe, center=center, path= data_dir)
print_dict( setup_pargs )
In [11]:
if scat_geometry == 'gi_saxs':
mask_path = '/XF11ID/analysis/2017_3/masks/'
#mask_name = 'Nov16_4M-GiSAXS_mask.npy'
mask_name = 'Sept22_GISAXS.npy'
elif scat_geometry == 'saxs':
mask_path = '/XF11ID/analysis/2017_3/masks/'
mask_name = 'Octo13_SAXS.npy'
#mask_path = '/XF11ID/analysis/2017_2/masks/'
#mask_name = 'Jul26_SAXS.npy'
In [12]:
if md['detector'] =='eiger1m_single_image':
Chip_Mask=np.load( '/XF11ID/analysis/2017_1/masks/Eiger1M_Chip_Mask.npy')
elif md['detector'] =='eiger4m_single_image' or md['detector'] == 'image':
Chip_Mask= np.array(np.load( '/XF11ID/analysis/2017_1/masks/Eiger4M_chip_mask.npy'), dtype=bool)
if imgs[0][938,1159] == 2**16-1: #Deal with bad pixels
Chip_Mask= np.array(np.load('/XF11ID/analysis/2017_1/masks/Eiger4M_chip_mask_DmgPts.npy'), dtype=bool)
elif md['detector'] =='eiger500K_single_image':
Chip_Mask= 1 #to be defined the chip mask
else:
Chip_Mask = 1
#show_img(Chip_Mask)
In [13]:
mask = load_mask(mask_path, mask_name, plot_ = False, image_name = uidstr + '_mask', reverse= True )
mask = mask * pixel_mask * Chip_Mask
show_img(mask,image_name = uidstr + '_mask', save=True, path=data_dir, aspect=1, center=center[::-1])
mask_load=mask.copy()
imgsa = apply_mask( imgs, mask )
In [15]:
#%run /home/yuzhang/chxanalys_link/chxanalys/chx_generic_functions.py
In [16]:
show_img( imgsa[0] , vmin=.0001, vmax= 1e2, logs=True, aspect=1, #save_format='tif',
image_name= uidstr + '_img_avg', save=True, path=data_dir, cmap = cmap_albula, center=center[::-1] )
In [18]:
good_start =5 #Usually we discard the first 5 files. The good_start could, however be 0 (no files discarded)
In [19]:
bin_frame = False #True # False # True #generally make bin_frame as False
if bin_frame:
bin_frame_number= 4
timeperframe = acquisition_period * bin_frame_number
else:
bin_frame_number =1
In [20]:
import time
t0= time.time()
if bin_frame_number==1:
filename = '/XF11ID/analysis/Compressed_Data' +'/uid_%s.cmp'%md['uid']
else:
filename = '/XF11ID/analysis/Compressed_Data' +'/uid_%s_bined--%s.cmp'%(md['uid'],bin_frame_number)
mask, avg_img, imgsum, bad_frame_list = compress_eigerdata(imgs, mask, md, filename,
force_compress= force_compress, para_compress= True, bad_pixel_threshold = 1e14,
bins=bin_frame_number, num_sub= 100, num_max_para_process= 500, with_pickle=True )
min_inten = 10
good_start = max(good_start, np.where( np.array(imgsum) > min_inten )[0][0] )
print ('The good_start frame number is: %s '%good_start)
FD = Multifile(filename, good_start, len(imgs)//bin_frame_number)
#FD = Multifile(filename, good_start, 100)
uid_ = uidstr + '_fra_%s_%s'%(FD.beg, FD.end)
print( uid_ )
plot1D( y = imgsum[ np.array( [i for i in np.arange(good_start, len(imgsum)) if i not in bad_frame_list])],
title =uidstr + '_imgsum', xlabel='Frame', ylabel='Total_Intensity', legend='imgsum' )
Nimg = Nimg/bin_frame_number
run_time(t0)
In [21]:
show_img( avg_img, vmin=1e-3, vmax= 1e3, logs=True, aspect=1, #save_format='tif',
image_name= uidstr + '_img_avg', save=True, path=data_dir, center=center[::-1], cmap = cmap_albula )
In [22]:
setup_pargs
Out[22]:
In [ ]:
In [23]:
if scat_geometry =='saxs':
## Get circular average| * Do plot and save q~iq
hmask = create_hot_pixel_mask( avg_img, threshold = 1e6, center=center, center_radius= 100)
qp_saxs, iq_saxs, q_saxs = get_circular_average( avg_img, mask * hmask, pargs=setup_pargs )
plot_circular_average( qp_saxs, iq_saxs, q_saxs, pargs=setup_pargs,
xlim=[q_saxs.min(), q_saxs.max()*1.0], ylim = [iq_saxs.min(), iq_saxs.max()*2] )
mask =np.array( mask * hmask, dtype=bool)
In [27]:
if scat_geometry =='saxs':
uniformq = True #True # False
## Define ROI
#* Create ring mask defined by inner_radius, outer_radius, width, num_rings (all in pixel unit)
#* Create ring mask defined by edges (all in pixel unit)
### Define a non-uniform distributed rings by giving edges
if not uniformq:
qcenters = [ 0.0023, 0.00365, 0.0050, ]#0.00621, 0.00754, 0.00880 ] #in A-1
#width = 0.0001 # in A-1
#width = [0.0001, 0.00012, 0.00014, 0.00016, 0.00018, 0.0002, 0.00022 ]
width = np.array( [0.0001, 0.00012, 0.00014, 0.00016, 0.00018, 0.0002, 0.00022 ] ) * 3.5
edges = get_non_uniform_edges( qcenters, width, number_rings =1 )
inner_radius= None
outer_radius = None
width = None
num_rings = None
# Define a uniform distributed rings by giving inner_radius, outer_radius, width, num_rings (all in pixel unit)
if uniformq:
inner_radius= 0.002 #0.006 #16
outer_radius = 0.045 #0.05 #112
num_rings = 24 #18
gap_ring_number = 20
width = ( outer_radius - inner_radius)/(num_rings + gap_ring_number)
edges = None
In [28]:
if scat_geometry =='saxs':
roi_mask, qr, qr_edge = get_ring_mask( mask, inner_radius=inner_radius,
outer_radius = outer_radius , width = width, num_rings = num_rings, edges=edges,
unit='A', pargs=setup_pargs )
qind, pixelist = roi.extract_label_indices( roi_mask )
qr = np.round( qr, 5)
print(len(qr))
show_ROI_on_image( avg_img, roi_mask, center[::-1], label_on = False, rwidth = 840, alpha=.9,
save=True, path=data_dir, uid=uidstr, vmin= np.min(avg_img), vmax= np.max(avg_img),
aspect=1)
qval_dict = get_qval_dict( np.round(qr, 5) )
In [29]:
if scat_geometry =='saxs':
plot_qIq_with_ROI( q_saxs, iq_saxs, qr, logs=True, uid=uidstr, xlim=[0.0001,0.1],
ylim = [iq_saxs.min(), iq_saxs.max()*2], save=True, path=data_dir)
In [30]:
if scat_geometry =='saxs':
if qphi_analysis:
roi_mask, qr, qr_edge = get_ring_mask( mask, inner_radius=inner_radius,
outer_radius = outer_radius , width = width, num_rings = num_rings, edges=edges,
unit='A', pargs=setup_pargs )
# define q-mask
if False:#if True, redefine qcenters
qcenters = [ 0.0023, 0.00365, 0.0050, 0.00621, 0.00754, 0.00880 ] #in A-1
#width = 0.0001 # in A-1
#width = [0.0001, 0.00012, 0.00014, 0.00016, 0.00018, 0.0002, 0.00022 ]
width = np.array( [0.0001, 0.00012, 0.00014, 0.00016, 0.00018, 0.0002, 0.00022 ] ) * 3.5
edges = get_non_uniform_edges( qcenters, width, number_rings=1 )
inner_radius= None
outer_radius = None
width = None
num_rings = None
roi_mask_qr, qr, qr_edge = get_ring_mask( mask, inner_radius=inner_radius,
outer_radius = outer_radius , width = width, num_rings = num_rings, edges=edges,
unit='A', pargs=setup_pargs )
else:#use the pre-defined qr mask
roi_mask_qr = roi_mask
# define angle-mask
ang_centers = np.array([0,90,180,270])-180
ang_width = 20*1.5
#ang_centers = np.array( [ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
# 110, 120, 130, 140, 150, 160, 170, 180, 190, 200,
# 210, 220, 230, 240, 250, 260, 270, 280, 290, 300,
# 310, 320, 330, 340, 350,]) -180 #in degree
#ang_width = np.array([ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
# 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
# 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
# 5, 5, 5, 5, 5 ])*1.5 #in degree
ang_edges = get_non_uniform_edges( ang_centers, ang_width, number_rings=1 )
inner_angle= None
outer_angle = None
ang_width = None
num_angles = None
if False: #For Dhiraj's flow geometry
inner_angle= 0
outer_angle = 60
ang_width = 5
num_angles = 10
ang_edges = None
roi_mask_ang, ang_center, ang_edge = get_angular_mask( mask, inner_angle= inner_angle,
outer_angle = outer_angle, width = ang_width, edges = ang_edges,
num_angles = num_angles, center = center, flow_geometry= False )
roi_mask, good_ind = combine_two_roi_mask( roi_mask_qr, roi_mask_ang,pixel_num_thres=100)
qval_dict_ = get_qval_dict( qr_center = qr, qz_center = ang_center,one_qz_multi_qr=False)
qval_dict = { i:qval_dict_[k] for (i,k) in enumerate( good_ind) }
show_ROI_on_image( avg_img, roi_mask, center, label_on = True, rwidth = 340, alpha=.9,
save=True, path=data_dir, uid=uidstr, vmin= 1e-3,
vmax= 1e3, #np.max(avg_img),
aspect=1,
show_roi_edge=True,
show_ang_cor = True)
In [31]:
def create_ellipse_donut( cx, cy , wx_inner, wy_inner, wx_outer, wy_outer, roi_mask, gap=0):
Nmax = np.max( np.unique( roi_mask ) )
rr1, cc1 = ellipse( cy,cx, wy_inner, wx_inner )
rr2, cc2 = ellipse( cy, cx, wy_inner + gap, wx_inner +gap )
rr3, cc3 = ellipse( cy, cx, wy_outer,wx_outer )
roi_mask[rr3,cc3] = 2 + Nmax
roi_mask[rr2,cc2] = 0
roi_mask[rr1,cc1] = 1 + Nmax
return roi_mask
def create_box( cx, cy, wx, wy, roi_mask):
Nmax = np.max( np.unique( roi_mask ) )
for i, [cx_,cy_] in enumerate(list( zip( cx,cy ))): #create boxes
x = np.array( [ cx_-wx, cx_+wx, cx_+wx, cx_-wx])
y = np.array( [ cy_-wy, cy_-wy, cy_+wy, cy_+wy])
rr, cc = polygon( y,x)
roi_mask[rr,cc] = i +1 + Nmax
return roi_mask
In [32]:
if scat_geometry =='gi_waxs':
box_roi = True
single_box = False #True, if True, the roi is one box, else, roi is multi-boxes
ellipse_roi = True
if box_roi:
if not single_box:
roi_mask = np.zeros_like( avg_img , dtype = np.int32)
wx,wy = [20,10] #each box width and height
cx = np.int_(np.linspace( 55, 955, 10)) #box center-x
nx = len(cx)//2
y1 = 760-8
y2= 780-8
cy1 = np.linspace( y1, y2, nx)
cy2 = np.linspace( y2, y1, nx)
cy = np.int_( np.concatenate( [cy1, cy2] ) ) #box-center y
for i, [cx_,cy_] in enumerate(list( zip( cx,cy ))): #create boxes
x = np.array( [ cx_-wx, cx_+wx, cx_+wx, cx_-wx])
y = np.array( [ cy_-wy, cy_-wy, cy_+wy, cy_+wy])
rr, cc = polygon( y,x)
#print( i + 1 )
roi_mask[rr,cc] = i +1
roi_mask = roi_mask * mask
else:
roi_mask = np.zeros_like( avg_img , dtype = np.int32)
wx,wy = [40,20] #each box width and height
cx, cy = [[ 184, 817, 200, 800], [ 637, 637,200, 200]]
cx, cy = [[ 160, 817, 200, 800], [ 650, 637,200, 200]]
for i, [cx_,cy_] in enumerate(list( zip( cx,cy ))): #create boxes
x = np.array( [ cx_-wx, cx_+wx, cx_+wx, cx_-wx])
y = np.array( [ cy_-wy, cy_-wy, cy_+wy, cy_+wy])
rr, cc = polygon( y,x)
#print( i + 1 )
roi_mask[rr,cc] = i +1
if False:
Nmax = np.max( np.unique( roi_mask ) )
print( Nmax)
wx,wy = [30,10] #each box width and height
cx, cy = [[ 44, 80], [ 725, 725]]
for i, [cx_,cy_] in enumerate(list( zip( cx,cy ))): #create boxes
x = np.array( [ cx_-wx, cx_+wx, cx_+wx, cx_-wx])
y = np.array( [ cy_-wy, cy_-wy, cy_+wy, cy_+wy])
rr, cc = polygon( y,x)
#print( i + 1 )
roi_mask[rr,cc] = i +1 + Nmax
if ellipse_roi ==True:
#define donut shapes here
roi_mask = np.zeros_like( avg_img , dtype = np.int32)
wx1,wy1 = [30,15] #inner ellipse width and height
wx2,wy2 = [80,40] #outer ellipse width and height
gap=5 #gap between two ellipse
#cx, cy = [[ 184, 817, 200, 800], [ 637, 637,200, 200]]
cx, cy = [[ 140, 886, 93, 920], [ 700, 700, 75, 75]]
for i, [x,y] in enumerate(list( zip( cx,cy ))): #create ellipse
roi_mask = create_ellipse_donut( x, y , wx1, wy1,
wx2, wy2, roi_mask, gap=gap)
#define one box here
wx,wy = [40,15] #each box width and height
cx, cy = [[ 510], [ 880]]
roi_mask = create_box( cx, cy, wx, wy, roi_mask)
roi_mask = roi_mask * mask
qind, pixelist = roi.extract_label_indices(roi_mask)
noqs = len(np.unique(qind))
qval_dict = get_qval_dict( 1 + np.arange(noqs) )
In [33]:
if scat_geometry =='gi_waxs':
badpixel = np.where( avg_img[:600,:] >=300 )
roi_mask[badpixel] = 0
show_ROI_on_image( avg_img, roi_mask, label_on = True, alpha=.1,
save=True, path=data_dir, uid=uidstr, vmin=0.01, vmax=100, cmap = cmap_albula)
In [34]:
if scat_geometry =='gi_saxs':
# Get Q-Map (Qz and Qr)
### Users defined incident-Beam and Reflection_Beam Centers at the begining!!!
alphaf,thetaf, alphai, phi = get_reflected_angles( inc_x0, inc_y0,refl_x0 , refl_y0, Lsd=Ldet )
qx_map, qy_map, qr_map, qz_map = convert_gisaxs_pixel_to_q( inc_x0, inc_y0,refl_x0,refl_y0, lamda=lambda_, Lsd=Ldet )
ticks_ = get_qzr_map( qr_map, qz_map, inc_x0, Nzline=10, Nrline=10 )
ticks = ticks_[:4]
plot_qzr_map( qr_map, qz_map, inc_x0, ticks = ticks_, data= avg_img, uid= uidstr, path = data_dir )
In [35]:
if scat_geometry =='gi_saxs':
# For diffuse near Yoneda wing
qz_start = 0.025 # was 0.046
qz_end = 0.03
qz_num= 1
qz_width = 0.005
qr_start = 0.005
qr_end = 0.1
qr_num = 1
qr_width = 0.08
Qrs = [qr_start , qr_end, qr_width, qr_num]
Qzs= [qz_start, qz_end, qz_width , qz_num ]
# Don't Change these lines below here
roi_masks, qval_dicts = get_gisaxs_roi( Qrs, Qzs, qr_map, qz_map, mask= mask )
show_qzr_roi( avg_img, roi_masks, inc_x0, ticks, alpha=0.5, save=True, path=data_dir, uid=uidstr )
In [36]:
if scat_geometry =='gi_saxs':
# Define Q-ROI
#* Users provide the interested Qz and Qr here for XPCS analysis, e.g., qr start/end/number/width et.al
# Change these lines
qz_start = 0.025 #0.028 # was 0.046
qz_end = 0.04
qz_num= 3
qz_width = 0.003
qr_start = 0.006
qr_end = 0.04
qr_num = 6
qr_width = 0.002
Qr = [qr_start , qr_end, qr_width, qr_num]
Qz= [qz_start, qz_end, qz_width , qz_num ]
# Don't Change these lines below here
roi_mask, qval_dict = get_gisaxs_roi( Qr, Qz, qr_map, qz_map, mask= mask )
In [37]:
if scat_geometry =='gi_saxs':
### Change the below lines to if define another ROI, if define even more, just repeat this process
define_second_roi = False #if True to define another line; else: make it False
if define_second_roi:
qval_dict1 = qval_dict.copy()
roi_mask1 = roi_mask.copy()
del qval_dict, roi_mask
## The Second ROI
if define_second_roi:
qz_start2 = 0.038
qz_end2 = 0.05
qz_num2= 1
qz_width2 = 0.004 #(qz_end2 - qz_start2)/(qz_num2 +gap_qz_num2)
qr_start2 = 0.006
qr_end2 = 0.05
qr_num2 = 8
qr_width2 = 0.003 #( qr_end2- qr_start2)/(qr_num2+gap_qr_num2)
Qr2 = [qr_start2 , qr_end2, qr_width2, qr_num2]
Qz2= [qz_start2, qz_end2, qz_width2 , qz_num2 ]
roi_mask2, qval_dict2 = get_gisaxs_roi( Qr2, Qz2, qr_map, qz_map, mask= mask )
qval_dict = update_qval_dict( qval_dict1, qval_dict2 )
roi_mask = update_roi_mask( roi_mask1, roi_mask2 )
show_qzr_roi( avg_img, roi_mask, inc_x0, ticks, alpha=0.5, save=True, path=data_dir, uid=uidstr )
## Get 1D Curve (Q||-intensity¶)
qr_1d_pds = cal_1d_qr( avg_img, Qr, Qz, qr_map, qz_map, inc_x0= None, mask= mask, setup_pargs=setup_pargs )
plot_qr_1d_with_ROI( qr_1d_pds, qr_center=np.unique( np.array(list( qval_dict.values() ) )[:,0] ),
loglog=False, save=True, uid=uidstr, path = data_dir)
In [38]:
qint = 1 #starting from 1
roi_inten = check_ROI_intensity( avg_img, roi_mask, ring_number= qint, uid =uidstr )
In [39]:
refine_roi = False
In [40]:
Nq = len( np.unique(roi_mask))-1
In [41]:
if refine_roi:
#if scat_geometry =='saxs':
filter_badpix_dict ={}
for k in range(1, Nq +1 ):
roi_inten = check_ROI_intensity( avg_img, roi_mask, ring_number=k, uid =uidstr, plot=False )
bad_pix_list= get_bad_frame_list( roi_inten, fit=True, polyfit_order = 30,
scale= 3.5, good_start = None, good_end= None, uid= uidstr, path=data_dir, plot=False)
print( 'The bad frame list length is: %s'%len(bad_pix_list ) )
filter_badpix_dict[k] = bad_pix_list
In [42]:
if refine_roi:
#if scat_geometry =='saxs':
roi_mask = filter_roi_mask( filter_badpix_dict, roi_mask, avg_img, filter_type = 'badpix' )
roi_inten = check_ROI_intensity( avg_img, roi_mask, ring_number= qint, uid =uidstr )
In [43]:
path
Out[43]:
In [44]:
fp = path + 'uid=%s_roi_mask.pkl'%uid
cpk.dump( [roi_mask,qval_dict], open(fp, 'wb' ) )
print(fp)
if scat_geometry == 'saxs':
if qphi_analysis:
cpk.dump( [roi_mask_qr,qval_dict], open( fp[:-4] +'_qr.pkl' , 'wb' ) )
print('The Qr-ROI is also saved as %s due to doing phi-analysis.'%(fp[:-4] +'_qr.pkl'))
##save with a meaningful filename, make False after excute to avoid over-write
#if True:
if True:
fp = path + 'roi_mask_Octo13_Coralpor_wide_phi.pkl'
cpk.dump( [roi_mask,qval_dict], open(fp, 'wb' ) )
print(fp)
#roi_mask,qval_dict = cpk.load( open(fp, 'rb' ) ) #for load the saved roi data
In [ ]:
In [45]:
if scat_geometry == 'gi_saxs':
fp = path + 'uid=%s_roi_masks.pkl'%uid
cpk.dump( [roi_masks,qval_dicts], open(fp, 'wb' ) )
print(fp)
##save with a meaningful filename, make False after excute to avoid over-write
fp = path + 'uid=%s_qmap.pkl'%uid #dump qr_map, qz_map, ticks_, Qrs, Qzs, Qr, Qz, inc_x0
print(fp)
cpk.dump( [qr_map, qz_map, ticks_, Qrs, Qzs, Qr, Qz, inc_x0, refl_x0, refl_y0 ], open(fp, 'wb' ) )
In [46]:
uid
Out[46]:
In [ ]:
In [ ]:
In [ ]: