"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 [264]:
from pyCHX.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 pyCHX.chx_xpcs_xsvs_jupyter_V1 import *
In [265]:
from skimage.draw import line_aa, line, polygon, ellipse
In [266]:
%matplotlib notebook
In [267]:
#%matplotlib inline
In [268]:
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 = False #True #if True, do q-phi analysis in case of SAXS
force_compress = False
single_image = True #take one image for make ROI
In [352]:
CYCLE= '2019_1' #change clycle here
username = getpass.getuser()
#username = 'commissioning'
username = 'petrash'
path = '/XF11ID/analysis/%s/masks/'%CYCLE
data_dir0 = create_user_folder(CYCLE, username)
print( data_dir0 )
In [353]:
uid = '37fc521f' #(scan num: 3566 (Measurement: single image for 500k mask CoralPor
#uid = '764cf803' #(scan num: 3568) (Measurement: single image for 4M mask CoralPor )
In [354]:
get_last_uids( -1 )
Out[354]:
In [355]:
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 [356]:
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 [357]:
#%run /home/yuzhang/pyCHX_link/pyCHX/chx_generic_functions.py
In [358]:
md = get_meta_data( uid )
if md['detector'] =='eiger4m_single_image' or md['detector'] == 'image':
reverse= True
rot90= False
elif md['detector'] =='eiger500K_single_image':
reverse= True
rot90=True
elif md['detector'] =='eiger1m_single_image':
reverse= True
rot90=False
In [359]:
imgs = load_data( uid, md['detector'], reverse= reverse, rot90=rot90 )
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']
mdn = md.copy()
In [360]:
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 [361]:
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 = 1000 #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:
if md['detector'] =='eiger4m_single_image' or md['detector'] == 'image' or md['detector']=='eiger1m_single_image':
inc_x0 = imgs[0].shape[0] - md['beam_center_y']
inc_y0= md['beam_center_x']
elif md['detector'] =='eiger500K_single_image':
inc_y0 = imgs[0].shape[1] - md['beam_center_y']
inc_x0 = imgs[0].shape[0] - md['beam_center_x']
print(inc_x0, inc_y0)
###for this particular uid, manually give x0/y0
#inc_x0 = 1041
#inc_y0 = 1085
In [362]:
dpix, lambda_, Ldet, exposuretime, timeperframe, center = check_lost_metadata(
md, Nimg, inc_x0 = inc_x0, inc_y0= inc_y0, pixelsize = 7.5*10*(-5) )
if scat_geometry =='gi_saxs':center=center[::-1]
setup_pargs=dict(uid=uidstr, dpix= dpix, Ldet=Ldet, lambda_= lambda_, exposuretime=exposuretime,
timeperframe=timeperframe, center=center, path= data_dir)
print_dict( setup_pargs )
mdn['beam_center_x'], mdn['beam_center_y'] = center[::-1]
In [363]:
if scat_geometry == 'gi_saxs':
mask_path = '/XF11ID/analysis/2019_1/masks/'
mask_name = 'Feb5_2018_4M.npy'
elif scat_geometry == 'saxs':
mask_path = '/XF11ID/analysis/2019_1/masks/'
if md['detector'] =='eiger4m_single_image' or md['detector'] == 'image':
mask_name = 'Feb6_2019_4M_SAXS.npy'
elif md['detector'] =='eiger500K_single_image':
mask_name = 'Feb6_2019_500K_SAXS.npy'
elif scat_geometry == 'gi_waxs':
mask_path = '/XF11ID/analysis/2019_1/masks/'
mask_name = 'July20_2018_1M_WAXS.npy'
In [364]:
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)
BadPix = np.load('/XF11ID/analysis/2018_1/BadPix_4M.npy' )
Chip_Mask.ravel()[BadPix] = 0
elif md['detector'] =='eiger500K_single_image':
Chip_Mask= np.load( '/XF11ID/analysis/2017_1/masks/Eiger500K_Chip_Mask.npy') #to be defined the chip mask
Chip_Mask = np.rot90(Chip_Mask)
pixel_mask = np.rot90( 1- np.int_( np.array( imgs.md['pixel_mask'], dtype= bool)) )
else:
Chip_Mask = 1
#show_img(Chip_Mask)
In [365]:
mask = load_mask(mask_path, mask_name, plot_ = False, image_name = uidstr + '_mask', reverse= reverse, rot90=rot90 )
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 [366]:
#%run /home/yuzhang/chxanalys_link/chxanalys/chx_generic_functions.py
In [367]:
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 [368]:
good_start =0 #Usually we discard the first 5 files. The good_start could, however be 0 (no files discarded)
In [369]:
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 [370]:
single_image=True
In [371]:
if not single_image:
force_compress=0
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)
else:
avg_img = imgsa[0]
mask = mask * pixel_mask * Chip_Mask
mask_copy = mask.copy()
In [372]:
show_img( avg_img * Chip_Mask , vmin=1e-3, vmax= 1e5, logs=True, aspect=1, #save_format='tif',
image_name= uidstr + '_img_avg_with Chip Mask', save=True, path=data_dir, center=center[::-1], cmap = cmap_albula )
In [373]:
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 [374]:
setup_pargs
Out[374]:
In [375]:
#np.where(hmask.ravel()==0)
In [376]:
if scat_geometry =='saxs':
mask = mask_copy.copy()
## Get circular average| * Do plot and save q~iq
hmask = create_hot_pixel_mask( avg_img, threshold = 1e9, center=center, center_radius=10)
qp_saxs, iq_saxs, q_saxs = get_circular_average( avg_img*mask, mask * hmask, pargs=setup_pargs )
plot_circular_average( qp_saxs, iq_saxs, q_saxs, pargs=setup_pargs, show_pixel=True,
xlim=[qp_saxs.min(), qp_saxs.max()*1.0], ylim = [iq_saxs.min(), iq_saxs.max()*2] )
mask = np.array( mask * hmask, dtype=bool)
In [377]:
if scat_geometry =='saxs':
plot_circular_average( qp_saxs, iq_saxs, q_saxs, pargs=setup_pargs, show_pixel=False,
xlim=[q_saxs.min(), q_saxs.max()*1.0], ylim = [iq_saxs.min(), iq_saxs.max()*2] )
In [407]:
if scat_geometry =='saxs':
uniformq = 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.002, 0.00326, 0.00395, 0.00524, 0.0058, 0.0072, 0.0077, 0.00896, 0.0096, 0.0108,
0.0114, 0.0128, 0.0134, 0.0148, 0.0166, 0.0184 ]
width = 0.0005
qcenters = [ 0.00125, 0.00176, 0.00228, 0.00304, 0.0038, 0.00432, 0.0051, 0.00562, 0.0064, 0.00692, 0.0077,
0.00822, 0.0090, 0.00952, 0.0104, 0.0116, ]
width = 0.0005
#width = [ i for i in np.diff( np.array(qcenters) ) *.9] + [ 0.0011]
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.0015 #0.0015 #0.002 #0.0018
outer_radius = 0.05 # 0.024 #0.05 # 0.0274 #0.05
num_rings = 16 #18
gap_ring_number = 1#40 #40 #1
width = ( outer_radius - inner_radius)/(num_rings + gap_ring_number)
edges = None
if (inner_radius<=q_saxs.min()) or (outer_radius>=q_saxs.max()):
print('Warning:\nThe inner_radius is smaller than the min of Q.Or the outer_radius is larger than the max of Q. Please Check!')
print('However, our code will remove the bad qs.')
In [ ]:
In [408]:
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)
qr = qr[(qr+np.diff(qr_edge)[0]>=q_saxs.min()) & (qr-np.diff(qr_edge)[-1]<=q_saxs.max())]
noqs = len(np.unique(qind))
nopr = np.bincount(qind, minlength=(noqs+1))[1:]
if md['detector'] =='eiger500K_single_image':
qmax = 0.0285
qr = qr[qr < qmax]
print(len(qr))
show_ROI_on_image( avg_img, roi_mask, center[::-1], label_on = False,
rwidth = 1240, alpha=.4,
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 [409]:
show_img(roi_mask, aspect=1)
In [410]:
#show_img( roi_mask, vmin=-1, vmax= 12, image_name= uidstr + '_roi_mask')
In [411]:
if scat_geometry =='saxs':
plot_qIq_with_ROI( q_saxs, iq_saxs, qr, logs=True, uid=uidstr,
xlim= [q_saxs.min(), q_saxs.max()],
ylim = [iq_saxs.min(), iq_saxs.max()*2], save=True, path=data_dir)
In [436]:
qphi_analysis = True#False #True
print( qphi_analysis)
In [437]:
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 = np.array([10,10,10,10]) * 4
#ang_centers = np.array([0,30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330 ])-180
#ang_width = 30 -.1
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 = 840, 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 [438]:
show_img(roi_mask, aspect=1)
In [ ]:
In [439]:
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 [440]:
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:
#define donut shapes here
roi_mask = np.zeros_like( avg_img , dtype = np.int32)
#wx1,wy1 = [109, 791] #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]]
wx_inner, wy_inner = 40, 20
CY = 800
Nmax=0
for CYI in [180, 120, 60, 0, -60, -120, -180]:
cx, cy = [ [70 + 90 *i for i in range(11)] , [ CY + CYI +i*0 for i in range(11)]]
for i, [x,y] in enumerate(list( zip( cx,cy ))): #create ellipse
rr, cc = ellipse( y,x, wy_inner, wx_inner )
roi_mask[rr,cc] = i +1+Nmax
Nmax = np.max( np.unique( roi_mask ) )
#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 [ ]:
In [441]:
show_img(roi_mask, aspect=1)
In [442]:
#%run ~/pyCHX_link/pyCHX/chx_generic_functions.py
In [ ]:
In [443]:
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, show_roi_edge=True,
save=True, path=data_dir, uid=uidstr, vmin=0.1, vmax=1e4, cmap = cmap_albula)
In [444]:
setup_pargs
Out[444]:
In [ ]:
In [445]:
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 [446]:
if scat_geometry =='gi_saxs':
# For diffuse near Yoneda wing
qz_start = 0.03 # was 0.046
qz_end = 0.05
qz_num= 1
qz_width = 0.001
qr_start = 0.001
qr_end = 0.03
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 [447]:
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.03 # was 0.046
qz_end = 0.04
qz_num= 3
qz_width = 0.0025
qr_start = 0.001
qr_end = 0.02
qr_num = 6
qr_width = 0.003
print('qr_end = ', qr_end)
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 [448]:
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 = True #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.06
qz_num2= 1
qz_width2 = 0.002
qz_end2 = qz_start2 + qz_num2*qz_width2
qr_start2 = 0.00
qr_width2 = 0.001
qr_num2 = 1
qr_end2 = qr_start2 + qr_num2*qr_width2
print(qr_end2)
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 )
### Third ROI
define_third_roi = False #if True to define another line; else: make it False
if define_third_roi:
qval_dict2 = qval_dict.copy()
roi_mask2 = roi_mask.copy()
del qval_dict, roi_mask
## The Third ROI
if define_third_roi:
qz_start3 = 0.06
qz_num3= 1
qz_width3 = 0.008
qz_end3 = qz_start3 + qz_num3*qz_width3
qr_start3 = 0.0001
qr_end3 = 0.001
qr_num3 = 1
gap_qr_num3 = 1
qr_width3 = 0.001 #( qr_end2- qr_start2)/(qr_num2+gap_qr_num2)
Qr3 = [qr_start3 , qr_end3, qr_width3, qr_num3]
Qz3= [qz_start3, qz_end3, qz_width3 , qz_num3 ]
roi_mask3, qval_dict3 = get_gisaxs_roi( Qr3, Qz3, qr_map, qz_map, mask= mask )
qval_dict = update_qval_dict( qval_dict2, qval_dict3 )
roi_mask = update_roi_mask( roi_mask2, roi_mask3 )
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, setup_pargs=setup_pargs )
plot_qr_1d_with_ROI( qr_1d_pds, qr_center=np.unique( np.array(list( qval_dict.values() ) )[:,0] ),
loglog=True, save=True, uid=uidstr, path = data_dir)
In [449]:
roi_mask_copy = roi_mask.copy()
qint = 4 #starting from 1
roi_inten = check_ROI_intensity( avg_img, roi_mask, ring_number= qint, uid =uidstr )
In [450]:
refine_roi = False
In [451]:
Nq = len( np.unique(roi_mask))-1
In [452]:
if refine_roi:
#if scat_geometry =='saxs':
roi_mask = roi_mask_copy
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 [453]:
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 [459]:
path
Out[459]:
In [455]:
#show_img(roi_mask )
In [456]:
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 False:
date = 'Feb6'
#fp=path + 'roi_mask_%s_4M_wide.pkl'%date
#fp=path + 'roi_mask_%s_4M_norm.pkl'%date
#fp=path + 'roi_mask_%s_4M_phi_4x_20deg.pkl'%date
#fp=path + 'roi_mask_%s_500K_wide.pkl'%date
#fp=path + 'roi_mask_%s_500K_norm.pkl'%date
fp=path + 'roi_mask_%s_500K_phi_4x_20deg.pkl'%date
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 [457]:
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 [458]:
username
Out[458]:
In [ ]:
In [ ]:
In [ ]:
In [ ]: