#######################
kwargs = dict() # create dictionnary
try:
kwargs['nb_pixel_x'] = nb_pixel_x # fix to declare a known detector but with less pixels (e.g. one tile HS)
except NameError: # nb_pixel_x not declared
pass
try:
kwargs['nb_pixel_y'] = nb_pixel_y # fix to declare a known detector but with less pixels (e.g. one tile HS)
except NameError: # nb_pixel_y not declared
pass
try:
kwargs['is_series'] = is_series
except NameError: # is_series not declared
pass
detector = exp.Detector(name=detector, datadir='', template_imagefile=template_imagefile, roi=roi_detector,
binning=binning, **kwargs)
####################
# Initialize setup #
####################
setup = exp.SetupPreprocessing(beamline=beamline, energy=energy, rocking_angle=rocking_angle, distance=sdd,
beam_direction=beam_direction, sample_inplane=sample_inplane,
sample_outofplane=sample_outofplane, offset_inplane=offset_inplane,
custom_scan=custom_scan, custom_images=custom_images, sample_offsets=sample_offsets,
custom_monitor=custom_monitor, custom_motors=custom_motors)
#############################################
# Initialize geometry for orthogonalization #
#############################################
if rocking_angle == "energy":
use_rawdata = False # you need to interpolate the data in QxQyQz for energy scans
debug = False # True to show more plots
save = True # True to save the prtf figure
##########################
# end of user parameters #
##########################
#################################################
# Initialize paths, detector, setup and logfile #
#################################################
kwargs = dict() # create dictionnary
try:
kwargs['is_series'] = is_series
except NameError: # is_series not declared
pass
detector = exp.Detector(name=detector, datadir='', template_imagefile=template_imagefile, binning=pre_binning, **kwargs)
setup = exp.SetupPreprocessing(beamline=beamline, rocking_angle=rocking_angle, distance=sdd, energy=energy,
beam_direction=beam_direction, sample_inplane=sample_inplane,
sample_outofplane=sample_outofplane,
offset_inplane=0) # no need to worry about offsets, work relatively to the Bragg peak
print('\nScan', scan)
print('Setup: ', setup.beamline)
print('Detector: ', detector.name)
print('Pixel sizes after pre_binning (vertical, horizontal): ', detector.pixelsize_y, detector.pixelsize_x, '(m)')
print('Scan type: ', setup.rocking_angle)
print('Sample to detector distance: ', setup.distance, 'm')
print('Energy:', setup.energy, 'ev')
if simulation:
]
# [Vstart, Vstop, Hstart, Hstop]
binning = [4, 4, 4] # binning of the detector
###########
# options #
###########
kernel_length = 21 # width of the 3D gaussian window
debug = False # True to see more plots
##################################
# end of user-defined parameters #
##################################
#######################
# Initialize detector #
#######################
detector = exp.Detector(name=detector, binning=binning, roi=roi_detector)
nbz, nby, nbx = int(np.floor((detector.roi[3] - detector.roi[2]) / detector.binning[2])), \
int(np.floor((detector.roi[1] - detector.roi[0]) / detector.binning[1])), \
int(np.floor((detector.roi[3] - detector.roi[2]) / detector.binning[2]))
# for P10 data the rotation is around y vertical, hence gridded data range & binning in z and x are identical
###################
# define colormap #
###################
bad_color = '1.0' # white background
colormap = gu.Colormap(bad_color=bad_color)
my_cmap = colormap.cmap
plt.ion()
######################
directbeam_x = 476 # x horizontal, cch2 in xrayutilities
directbeam_y = 1375 # y vertical, cch1 in xrayutilities
direct_inplane = -2.0 # outer angle in xrayutilities
direct_outofplane = 0.8
sdd = 1.839 # sample to detector distance in m
energy = 10300 # in eV, offset of 6eV at ID01
##########################################################
# end of user parameters
##########################################################
plt.ion()
#######################
# Initialize detector #
#######################
detector = exp.Detector(name=detector,
datadir='',
template_imagefile=template_imagefile,
roi=roi_detector)
####################
# Initialize setup #
####################
setup_pre = exp.SetupPreprocessing(beamline=beamline,
rocking_angle=rocking_angle,
distance=sdd,
energy=energy,
beam_direction=beam_direction)
if setup_pre.beamline != 'P10':
homedir = root_folder + sample_name + str(scan) + '/'
detector.datadir = homedir + "data/"
else:
roi = [] # plot the integrated intensity in this region of interest. Leave it to [] to use the full detector
# [Vstart, Vstop, Hstart, Hstop]
high_threshold = 9 # data points where log10(data) > high_threshold will be masked
# if data is a series, the condition becomes log10(data.sum(axis=0)) > high_threshold
savedir = '/mxn/visitors/dzhigd/NanoMAX_beamtimes/24062020/data_processing/'+str('{:04d}'.format(scan)) # images will be saved here, leave it to '' otherwise (default to data directory's parent)
is_scan = True # set to True is the measurement is a scan or a time series, False for a single image
compare_ends = True # set to True to plot the difference between the last frame and the first frame
save_mask = False # True to save the mask as 'hotpixels.npz'
##########################
# end of user parameters #
##########################
#######################
# Initialize detector #
#######################
detector = exp.Detector(name=detector)
nb_pixel_y, nb_pixel_x = detector.nb_pixel_y, detector.nb_pixel_x
####################
# Initialize paths #
####################
datadir = rootdir + sample_name
if savedir == '':
savedir = os.path.abspath(os.path.join(datadir, os.pardir)) + '/'
#############
# Load data #
#############
plt.ion() # interactive graphics
mask = np.zeros((nb_pixel_y, nb_pixel_x))
def main(parameters):
"""
Protection for multiprocessing.
:param parameters: dictionnary containing input parameters
"""
def collect_result(result):
"""
Callback processing the result after asynchronous multiprocessing. Update the global arrays.
:param result: the output of load_p10_file, containing the 2d data, 2d mask, counter for each frame, and the
file index
"""
nonlocal sumdata, mask, counter, nb_files, current_point
# result is a tuple: data, mask, counter, file_index
current_point += 1
sumdata = sumdata + result[0]
mask[np.nonzero(result[1])] = 1
counter.append(result[2])
sys.stdout.write('\rFile {:d} / {:d}'.format(current_point, nb_files))
sys.stdout.flush()
######################################
# load the dictionnary of parameters #
######################################
scan = parameters['scan']
samplename = parameters['sample_name']
rootdir = parameters['rootdir']
image_nb = parameters['file_list']
counterroi = parameters['counter_roi']
savedir = parameters['savedir']
load_scan = parameters['is_scan']
compare_end = parameters['compare_ends']
savemask = parameters['save_mask']
multiproc = parameters['multiprocessing']
threshold = parameters['threshold']
cb_min = parameters['cb_min']
cb_max = parameters['cb_max']
grey_bckg = parameters['grey_bckg']
###################
# define colormap #
###################
if grey_bckg:
bad_color = '0.7'
else:
bad_color = '1.0' # white background
colormap = gu.Colormap(bad_color=bad_color)
my_cmap = colormap.cmap
#######################
# Initialize detector #
#######################
detector = exp.Detector(name=parameters['detector'])
nb_pixel_y, nb_pixel_x = detector.nb_pixel_y, detector.nb_pixel_x
sumdata = np.zeros((nb_pixel_y, nb_pixel_x))
mask = np.zeros((nb_pixel_y, nb_pixel_x))
counter = []
####################
# Initialize paths #
####################
if type(image_nb) == int:
image_nb = [image_nb]
if len(counterroi) == 0:
counterroi = [0, nb_pixel_y, 0, nb_pixel_x]
assert (counterroi[0] >= 0
and counterroi[1] <= nb_pixel_y
and counterroi[2] >= 0
and counterroi[3] <= nb_pixel_x), 'counter_roi setting does not match the detector size'
nb_files = len(image_nb)
if nb_files == 1:
multiproc = False
if load_scan: # scan or time series
detector.datadir = rootdir + samplename + '_' + str('{:05d}'.format(scan)) + '/e4m/'
template_file = detector.datadir + samplename + '_' + str('{:05d}'.format(scan)) + "_data_"
else: # single image
detector.datadir = rootdir + samplename + '/e4m/'
template_file = detector.datadir + samplename + '_take_' + str('{:05d}'.format(scan)) + "_data_"
compare_end = False
detector.savedir = savedir or os.path.abspath(os.path.join(detector.datadir, os.pardir)) + '/'
print(f'datadir: {detector.datadir}')
print(f'savedir: {detector.savedir}')
#############
# Load data #
#############
plt.ion()
filenames = [template_file + '{:06d}.h5'.format(image_nb[idx]) for idx in range(nb_files)]
roi_counter = None
current_point = 0
start = time.time()
if multiproc:
print("\nNumber of processors used: ", min(mp.cpu_count(), len(filenames)))
mp.freeze_support()
pool = mp.Pool(processes=min(mp.cpu_count(), len(filenames))) # use this number of processes
for file in range(nb_files):
pool.apply_async(load_p10_file, args=(detector, filenames[file], file, counterroi, threshold),
callback=collect_result, error_callback=util.catch_error)
pool.close()
pool.join() # postpones the execution of next line of code until all processes in the queue are done.
# sort out counter values (we are using asynchronous multiprocessing, order is not preserved)
roi_counter = sorted(counter, key=lambda x: x[1])
else:
for idx in range(nb_files):
sys.stdout.write('\rLoading file {:d}'.format(idx + 1) + ' / {:d}'.format(nb_files))
sys.stdout.flush()
h5file = h5py.File(filenames[idx], 'r')
data = h5file['entry']['data']['data'][:]
data[data <= threshold] = 0
nbz, nby, nbx = data.shape
[counter.append(data[index, counterroi[0]:counterroi[1], counterroi[2]:counterroi[3]].sum())
for index in range(nbz)]
if compare_end and nb_files == 1:
data_start, _ = detector.mask_detector(data=data[0, :, :], mask=mask)
data_start = data_start.astype(float)
data_stop, _ = detector.mask_detector(data=data[-1, :, :], mask=mask)
data_stop = data_stop.astype(float)
fig, _, _ = gu.imshow_plot(data_stop - data_start, plot_colorbar=True, scale='log',
title='difference between the last frame and the first frame of the series')
nb_frames = data.shape[0] # collect the number of frames in the eventual series
data, mask = detector.mask_detector(data=data.sum(axis=0), mask=mask, nb_img=nb_frames)
sumdata = sumdata + data
roi_counter = [[counter, idx]]
end = time.time()
print('\nTime ellapsed for loading data:', str(datetime.timedelta(seconds=int(end - start))))
frame_per_series = int(len(counter) / nb_files)
print('')
if load_scan:
if nb_files > 1:
plot_title = 'masked data - sum of ' + str(nb_files)\
+ ' points with {:d} frames each'.format(frame_per_series)
else:
plot_title = 'masked data - sum of ' + str(frame_per_series) + ' frames'
filename = 'S' + str(scan) + '_scan.png'
else: # single image
plot_title = 'masked data'
filename = 'S' + str(scan) + '_image_' + str(image_nb[0]) + '.png'
if savemask:
fig, _, _ = gu.imshow_plot(mask, plot_colorbar=False, title='mask')
np.savez_compressed(detector.savedir+'hotpixels.npz', mask=mask)
fig.savefig(detector.savedir + 'mask.png')
y0, x0 = np.unravel_index(abs(sumdata).argmax(), sumdata.shape)
print("Max at (y, x): ", y0, x0, ' Max = ', int(sumdata[y0, x0]))
np.savez_compressed(detector.savedir + f'{sample_name}_{scan_nb:05d}_sumdata.npz', data=sumdata)
if save_to_mat:
savemat(detector.savedir + f'{sample_name}_{scan_nb:05d}_sumdata.mat', {'data': sumdata})
if len(roi_counter[0][0]) > 1: # roi_counter[0][0] is the list of counter intensities in a series
int_roi = []
[int_roi.append(val[0][idx]) for val in roi_counter for idx in range(frame_per_series)]
plt.figure()
plt.plot(np.asarray(int_roi))
plt.title('Integrated intensity in counter_roi')
plt.pause(0.1)
cb_min = cb_min or sumdata.min()
cb_max = cb_max or sumdata.max()
fig, _, _ = gu.imshow_plot(sumdata, plot_colorbar=True, title=plot_title, vmin=cb_min, vmax=cb_max, scale='log',
cmap=my_cmap)
np.savez_compressed(detector.savedir + 'hotpixels.npz', mask=mask)
fig.savefig(detector.savedir + filename)
plt.show()
# define colormap #
###################
colormap = gu.Colormap()
my_cmap = colormap.cmap
plt.rcParams["keymap.fullscreen"] = [""]
#######################
# Initialize detector #
#######################
kwargs = dict() # create dictionnary
kwargs['is_series'] = is_series
kwargs['preprocessing_binning'] = preprocessing_binning
kwargs['nb_pixel_x'] = nb_pixel_x # fix to declare a known detector but with less pixels (e.g. one tile HS)
kwargs['nb_pixel_y'] = nb_pixel_y # fix to declare a known detector but with less pixels (e.g. one tile HS)
detector = exp.Detector(name=detector, roi=roi_detector, sum_roi=normalize_roi, binning=binning, **kwargs)
####################
# Initialize setup #
####################
setup = exp.Setup(beamline=beamline, energy=energy, rocking_angle=rocking_angle, distance=sdd, direct_beam=direct_beam,
custom_scan=custom_scan, custom_images=custom_images, custom_monitor=custom_monitor,
custom_motors=custom_motors)
########################################
# print the current setup and detector #
########################################
print('\n##############\nSetup instance\n##############')
print(setup)
print('\n#################\nDetector instance\n#################')
print(detector)
my_cmap = colormap.cmap
#######################
# Initialize detector #
#######################
kwargs = dict() # create dictionnary
kwargs['preprocessing_binning'] = preprocessing_binning
if nb_pixel_x:
kwargs[
'nb_pixel_x'] = nb_pixel_x # fix to declare a known detector but with less pixels (e.g. one tile HS)
if nb_pixel_y:
kwargs[
'nb_pixel_y'] = nb_pixel_y # fix to declare a known detector but with less pixels (e.g. one tile HS)
detector = exp.Detector(name=detector,
template_imagefile=template_imagefile,
binning=phasing_binning,
**kwargs)
####################################
# define the experimental geometry #
####################################
# correct the tilt_angle for binning
tilt_angle = tilt_angle * preprocessing_binning[0] * phasing_binning[0]
setup = exp.Setup(beamline=beamline,
energy=energy,
outofplane_angle=outofplane_angle,
inplane_angle=inplane_angle,
tilt_angle=tilt_angle,
rocking_angle=rocking_angle,
distance=sdd,
pixel_x=detector.pixelsize_x,
# options #
###########
normalize_prtf = True # set to True when the solution is the first mode - then the intensity needs to be normalized
debug = False # True to show more plots
##########################
# end of user parameters #
##########################
#######################
# Initialize detector #
#######################
kwargs = dict() # create dictionnary
kwargs['is_series'] = is_series
detector = exp.Detector(name=detector,
template_imagefile=template_imagefile,
binning=(1, 1, 1),
preprocessing_binning=pre_binning)
####################
# Initialize setup #
####################
setup = exp.Setup(beamline=beamline,
energy=energy,
rocking_angle=rocking_angle,
distance=sdd,
beam_direction=beam_direction,
sample_inplane=sample_inplane,
sample_outofplane=sample_outofplane,
sample_offsets=sample_offsets,
actuators=actuators)
###################
# define colormap #
###################
bad_color = '1.0' # white background
colormap = gu.Colormap(bad_color=bad_color)
my_cmap = colormap.cmap
plt.ion()
#################################################
# initialize detector, setup, paths and logfile #
#################################################
kwargs = dict() # create dictionnary
kwargs['is_series'] = is_series
detector = exp.Detector(name=detector,
datadir='',
template_imagefile=template_imagefile,
sum_roi=sum_roi,
binning=[1, binning[0], binning[1]],
**kwargs)
setup = exp.SetupPreprocessing(beamline=beamline)
if setup.beamline == 'P10':
specfile_name = sample_name + '_{:05d}'.format(scan)
homedir = root_folder + specfile_name + '/'
detector.datadir = homedir + 'e4m/'
template_imagefile = specfile_name + template_imagefile
detector.template_imagefile = template_imagefile
elif setup.beamline == 'SIXS_2018' or setup.beamline == 'SIXS_2019':
homedir = root_folder
detector.datadir = homedir + "align/"
else:
# end of user-defined parameters #
##################################
###################
# define colormap #
###################
bad_color = '1.0' # white background
colormap = gu.Colormap(bad_color=bad_color)
my_cmap = colormap.cmap
plt.ion()
#################################################
# Initialize detector, setup, paths and logfile #
#################################################
detector = exp.Detector(name=detector,
datadir='',
template_imagefile=template_imagefile,
is_series=is_series)
setup = exp.SetupPreprocessing(beamline=beamline,
rocking_angle=rocking_angle,
custom_scan=custom_scan,
custom_images=custom_images,
custom_monitor=custom_monitor,
custom_motors=custom_motors)
if setup.beamline == 'P10':
specfile_name = specfile_name % scan
homedir = root_folder + specfile_name + '/'
detector.datadir = homedir + 'e4m/'
template_imagefile = specfile_name + template_imagefile
detector.template_imagefile = template_imagefile
q_com = [] # q value of the center of mass
check_roi = [
] # a small ROI around the Bragg peak will be stored for each scan, to see if the peak is indeed
# captured by the rocking curve
#######################
# Initialize detector #
#######################
kwargs = dict() # create dictionnary
kwargs['is_series'] = is_series
kwargs[
'nb_pixel_x'] = nb_pixel_x # fix to declare a known detector but with less pixels (e.g. one tile HS)
kwargs[
'nb_pixel_y'] = nb_pixel_y # fix to declare a known detector but with less pixels (e.g. one tile HS)
detector = exp.Detector(name=detector,
template_imagefile=template_imagefile,
roi=roi_detector,
**kwargs)
####################
# Initialize setup #
####################
setup = exp.Setup(beamline=beamline,
energy=energy,
rocking_angle=rocking_angle,
distance=sdd,
beam_direction=beam_direction,
custom_scan=custom_scan,
custom_images=custom_images,
custom_monitor=custom_monitor,
custom_motors=custom_motors,
pixel_x=detector.pixelsize_x,
