def compare(A: DataType, B: DataType):
A = normalize_to_spectrum(A)
attrs = A.attrs
B = normalize_to_spectrum(B)
# normalize total intensity
TOTAL_INTENSITY = 1000000
A = A / (A.sum(A.dims) / TOTAL_INTENSITY)
B = B / (B.sum(B.dims) / TOTAL_INTENSITY)
A.attrs.update(**attrs)
tool = ComparisonTool(other=B)
return tool.make_tool(A)
def estimate_prior_adjustment(data: DataType,
region: Union[dict, str] = None) -> float:
r"""
Estimates the parameters of a distribution generating the intensity
histogram of pixels in a spectrum. In a perfectly linear, single-electron
single-count detector, this would be a poisson distribution with
\lambda=mean(counts) over the window. Despite this, we can estimate \lambda
phenomenologically and verify that a Poisson distribution provides a good
prior for the data, allowing us to perform statistical bootstrapping.
You should use this with a spectrum that has uniform intensity, i.e. with a
copper reference or similar.
:param data:
:return: returns sigma / mu, adjustment factor for the Poisson distribution
"""
data = normalize_to_spectrum(data)
if region is None:
region = 'copper_prior'
region = normalize_region(region)
if 'cycle' in data.dims:
data = data.sum('cycle')
data = data.S.zero_spectrometer_edges().S.region_sel(region)
values = data.values.ravel()
values = values[np.where(values)]
return np.std(values) / np.mean(values)
def build_cycle_fermi_edge_correction(data: DataType, energy_range=None):
arr = normalize_to_spectrum(data)
if 'pixels' in arr.dims or 'phi' in arr.dims:
arr = arr.S.region_sel('wide_angular')
if energy_range is None:
energy_range = slice(-0.1, 0.1)
arr = arr.S.sum_other(['eV', 'cycle'])
return broadcast_model(GStepBModel, arr.sel(eV=energy_range), 'cycle')
def fs_gap(data: DataType, shape=None, energy_range=None):
data = normalize_to_spectrum(data)
if energy_range is None:
energy_range = slice(-0.1, None)
data.sel(eV=energy_range)
reduction = None
if shape is None:
# Just rebin the data along 'phi'
reduction = {'phi': 16}
data = rebin(data, reduction=reduction, shape=shape)
return broadcast_model(GStepBModel, data, ['phi', 'beta'])
def normalize_total(data: DataType):
data = normalize_to_spectrum(data)
return data / (data.sum(data.dims) / 1000000)