def photonStatistics(stack):
""" """
number_of_images = stack.shape[0]
photons = numpy.sum(stack, axis=(1, 2))
avg_photons = numpy.mean(photons)
rms_photons = numpy.std(photons)
print("*************************")
print("avg = %6.5e" % (avg_photons))
print("std = %6.5e" % (rms_photons))
print("*************************")
# Plot histogram.
plt.figure()
max_photon_number = int(numpy.max(photons))
min_photon_number = int(numpy.min(photons))
if max_photon_number == min_photon_number:
max_photon_number += 1
binwidth = max_photon_number - min_photon_number
number_of_bins = min(20, number_of_images)
binwidth = int(binwidth / number_of_bins)
plt.hist(photons,
bins=range(min_photon_number, max_photon_number, binwidth),
facecolor='red',
alpha=0.75)
plt.xlim([min_photon_number, max_photon_number])
plt.xlabel("Photons")
plt.ylabel("Histogram")
plt.title("Photon number histogram")
def plotImage(pattern, logscale=False, offset=1e-1):
""" Workhorse function to plot an image
:param logscale: Whether to show the data on logarithmic scale (z axis) (default False).
:type logscale: bool
:param offset: Offset to apply if logarithmic scaling is on.
:type offset: float
"""
plt.figure()
# Get limits.
mn, mx = pattern.min(), pattern.max()
x_range, y_range = pattern.shape
if logscale:
if mn <= 0.0:
mn += pattern.min() + offset
pattern = pattern.astype(float) + mn
plt.imshow(pattern,
norm=mpl.colors.LogNorm(vmin=mn, vmax=mx),
cmap="viridis")
else:
plt.imshow(pattern, norm=Normalize(vmin=mn, vmax=mx), cmap='viridis')
plt.xlabel(r'$x$ (pixel)')
plt.ylabel(r'$y$ (pixel)')
plt.xlim([0, x_range - 1])
plt.ylim([0, y_range - 1])
plt.tight_layout()
plt.colorbar()
def plotImage(pattern,
logscale=False,
offset=1e-1,
symlog=False,
*argv,
**kwargs):
""" Workhorse function to plot an image
:param logscale: Whether to show the data on logarithmic scale (z axis) (default False).
:type logscale: bool
:param offset: Offset to apply if logarithmic scaling is on.
:type offset: float
:param symlog: If logscale is True, to show the data on symlogarithmic scale (z axis) (default False).
:type symlog: bool
:return: the handles of figure and axis
:rtype: figure,axis
"""
fig, ax = plt.subplots()
# Get limits.
mn, mx = pattern.min(), pattern.max()
x_range, y_range = pattern.shape
if logscale:
if mn <= 0.0:
mn = pattern.min() + offset
mx = pattern.max() + offset
pattern = pattern.astype(float) + offset
# default plot setup
kwargs['cmap'] = kwargs.pop('cmap', "viridis")
if symlog:
kwargs['norm'] = kwargs.pop(
'norm', mpl.colors.SymLogNorm(0.015, vmin=mn, vmax=mx))
else:
kwargs['norm'] = kwargs.pop('norm',
mpl.colors.LogNorm(vmin=mn, vmax=mx))
axes = kwargs.pop('axes', None)
plt.imshow(pattern, *argv, **kwargs)
else:
kwargs['norm'] = kwargs.pop('norm', Normalize(vmin=mn, vmax=mx))
kwargs['cmap'] = kwargs.pop('cmap', "viridis")
plt.imshow(pattern, *argv, **kwargs)
plt.xlabel(r'$x$ (pixel)')
plt.ylabel(r'$y$ (pixel)')
plt.xlim([0, x_range - 1])
plt.ylim([0, y_range - 1])
plt.tight_layout()
plt.colorbar()
return fig, ax
def plotResolutionRings(parameters):
"""
Show resolution rings on current plot.
:param parameters: Parameters needed to construct the resolution rings.
:type parameters: dict
"""
# Extract parameters.
beam = parameters['beam']
geom = parameters['geom']
# Photon energy and wavelength
E0 = beam['photonEnergy']
lmd = 1239.8 / E0
# Pixel dimension
apix = geom['pixelWidth']
# Sample-detector distance
Ddet = geom['detectorDist']
# Number of pixels in each dimension
Npix = geom['mask'].shape[0]
# Find center.
center = 0.5 * (Npix - 1)
# Max. scattering angle.
theta_max = math.atan(center * apix / Ddet)
# Min resolution.
d_min = 0.5 * lmd / math.sin(theta_max)
# Next integer resolution.
d0 = 0.1 * math.ceil(d_min * 10.0) # 10 powers to get Angstrom
# Array of resolution rings to plot.
ds = numpy.array([1.0, 0.5, .3])
# Pixel numbers corresponding to resolution rings.
Ns = Ddet / apix * numpy.arctan(numpy.arcsin(lmd / 2. / ds))
# Plot each ring and attach a label.
for i, N in enumerate(Ns):
x0 = center
X = numpy.linspace(x0 - N, x0 + N, 512)
Y_up = x0 + numpy.sqrt(N**2 - (X - x0)**2)
Y_dn = x0 - numpy.sqrt(N**2 - (X - x0)**2)
plt.plot(X, Y_up, color='k')
plt.plot(X, Y_dn, color='k')
plt.text(x0 + 0.75 * N, x0 + 0.75 * N, "%2.1f" % (ds[i] * 10.))
plt.xlim(0, Npix - 1)
plt.ylim(0, Npix - 1)
def plotImage(pattern,
logscale=False,
offset=None,
symlog=False,
*argv,
**kwargs):
""" Workhorse function to plot an image
:param logscale: Whether to show the data on logarithmic scale (z axis) (default False).
:type logscale: bool
:param offset: Offset to apply to the pattern.
:type offset: float
:param symlog: To show the data on symlogarithmic scale (z axis) (default False).
:type symlog: bool
"""
fig, ax = plt.subplots()
# Get limits.
mn, mx = pattern.min(), pattern.max()
x_range, y_range = pattern.shape
if offset:
mn = pattern.min() + offset
mx = pattern.max() + offset
pattern = pattern.astype(float) + offset
if (logscale and symlog):
print('logscale and symlog are both true.\noverrided by logscale')
# default plot setup
if (logscale or symlog):
kwargs['cmap'] = kwargs.pop('cmap', "viridis")
if logscale:
kwargs['norm'] = kwargs.pop('norm', mpl.colors.LogNorm())
elif symlog:
kwargs['norm'] = kwargs.pop('norm', mpl.colors.SymLogNorm(0.015))
axes = kwargs.pop('axes', None)
plt.imshow(pattern, *argv, **kwargs)
else:
kwargs['norm'] = kwargs.pop('norm', Normalize(vmin=mn, vmax=mx))
kwargs['cmap'] = kwargs.pop('cmap', "viridis")
plt.imshow(pattern, *argv, **kwargs)
plt.xlabel(r'$x$ (pixel)')
plt.ylabel(r'$y$ (pixel)')
plt.xlim([0, x_range - 1])
plt.ylim([0, y_range - 1])
plt.tight_layout()
plt.colorbar()
def photonStatistics(stack):
""" """
number_of_images = stack.shape[0]
photons = numpy.sum(stack, axis=(1, 2))
avg_photons = numpy.mean(photons)
rms_photons = numpy.std(photons)
meanPerPattern = numpy.mean(stack, axis=(1, 2))
# average over the mean nphotons of each pattern in the stack
avg_mean = numpy.mean(meanPerPattern)
maxPerPattern = numpy.max(stack, axis=(1, 2))
# average over the max nphotons of each pattern in the stack
avg_max = numpy.mean(maxPerPattern)
minPerPattern = numpy.min(stack, axis=(1, 2))
# average over the min nphotons of each pattern in the stack
avg_min = numpy.mean(minPerPattern)
print("*************************")
print("Photon number statistics per pattern")
print("avg = %6.5e" % (avg_photons))
print("std = %6.5e" % (rms_photons))
print("Photon number statistics per pixel")
print("avg_mean_pixel = %6.5e" % (avg_mean))
print("avg_max_pixel = %6.5e" % (avg_max))
print("avg_min_pixel = %6.5e" % (avg_min))
print("*************************")
# Plot histogram.
plt.figure()
max_photon_number = int(numpy.max(photons))
min_photon_number = int(numpy.min(photons))
if max_photon_number == min_photon_number:
max_photon_number += 1
binwidth = max_photon_number - min_photon_number
number_of_bins = min(20, number_of_images)
binwidth = int(binwidth / number_of_bins)
plt.hist(photons,
bins=range(min_photon_number, max_photon_number, binwidth),
facecolor='red',
alpha=0.75)
plt.xlim([min_photon_number, max_photon_number])
plt.xlabel("Photons")
plt.ylabel("Histogram")
plt.title("Photon number histogram")
def plotResolutionRings(parameters, rings=(10, 5.0, 3.5), half=True):
"""
Show resolution rings on current plot.
:param parameters: Parameters needed to construct the resolution rings.
:type parameters: dict
:param rings: the rings shown on the figure
:type rings: list
:param half: show half period resolution (True, default) or full period resolution (False)
:type half: bool
"""
# Extract parameters.
beam = parameters['beam']
geom = parameters['geom']
# Photon energy and wavelength
E0 = beam['photonEnergy']
lmd = 1239.8 / E0
# Pixel dimension
apix = geom['pixelWidth']
# Sample-detector distance
Ddet = geom['detectorDist']
# Number of pixels in each dimension
Npix = geom['mask'].shape[0]
# Find center.
center = 0.5 * (Npix - 1)
# Max. scattering angle.
theta_max = math.atan(center * apix / Ddet)
# Min resolution.
if (half):
d_min = 0.5 * lmd / math.sin(theta_max / 2.0) / 2.0
else:
d_min = 0.5 * lmd / math.sin(theta_max / 2.0)
# Next integer resolution.
d0 = 0.1 * math.ceil(d_min * 10.0) # 10 powers to get Angstrom
# Array of resolution rings to plot.
ds = numpy.array(rings) / 10 # nm
# Pixel numbers corresponding to resolution rings.
if (half):
Ns = Ddet / apix * numpy.tan(numpy.arcsin(lmd / 2. / ds / 2.) * 2)
else:
Ns = Ddet / apix * numpy.tan(numpy.arcsin(lmd / 2. / ds) * 2)
# Plot each ring and attach a label.
for i, N in enumerate(Ns):
x0 = center
X = numpy.linspace(x0 - N, x0 + N, 512)
Y_up = x0 + numpy.sqrt(N**2 - (X - x0)**2)
Y_dn = x0 - numpy.sqrt(N**2 - (X - x0)**2)
plt.plot(X, Y_up, color='k')
plt.plot(X, Y_dn, color='k')
plt.text(x0 + 0.75 * N,
x0 + 0.75 * N,
"%2.1f" % (ds[i] * 10.),
color='red')
plt.xlim(0, Npix - 1)
plt.ylim(0, Npix - 1)
