def __init__(self,
signal1D,
auto_background=True,
auto_add_edges=True,
ll=None,
GOS=None,
dictionary=None):
Model1D.__init__(self, signal1D)
# When automatically setting the fine structure energy regions,
# the fine structure of an EELS edge component is automatically
# disable if the next ionisation edge onset distance to the
# higher energy side of the fine structure region is lower that
# the value of this parameter
self._min_distance_between_edges_for_fine_structure = 0
self._preedge_safe_window_width = 2
self.signal1D = signal1D
self._suspend_auto_fine_structure_width = False
self.convolved = False
self.low_loss = ll
self.GOS = GOS
self.edges = []
self._background_components = []
if dictionary is not None:
auto_background = False
auto_add_edges = False
self._load_dictionary(dictionary)
if auto_background is True:
background = PowerLaw()
self.append(background)
if self.signal.subshells and auto_add_edges is True:
self._add_edges_from_subshells_names()
def __init__(self,
signal1D,
auto_background=True,
auto_add_edges=True,
ll=None,
GOS=None,
dictionary=None):
Model1D.__init__(self, signal1D)
self._suspend_auto_fine_structure_width = False
self.convolved = False
self.low_loss = ll
self.GOS = GOS
self.edges = []
self._background_components = []
if dictionary is not None:
auto_background = False
auto_add_edges = False
self._load_dictionary(dictionary)
if auto_background is True:
background = PowerLaw()
self.append(background)
if self.signal.subshells and auto_add_edges is True:
self._add_edges_from_subshells_names()
def __init__(self,
spectrum,
auto_background=True,
auto_add_lines=True,
*args,
**kwargs):
Model1D.__init__(self, spectrum, *args, **kwargs)
self.xray_lines = list()
self.family_lines = list()
end_energy = self.axes_manager.signal_axes[0].high_value
self.end_energy = min(end_energy, self.signal._get_beam_energy())
self.start_energy = self.axes_manager.signal_axes[0].low_value
self.background_components = list()
if 'dictionary' in kwargs or len(args) > 1:
auto_add_lines = False
auto_background = False
d = args[1] if len(args) > 1 else kwargs['dictionary']
if len(d['xray_lines']) > 0:
self.xray_lines.extend(
[self[name] for name in d['xray_lines']])
if len(d['background_components']) > 0:
self.background_components.extend(
[self[name] for name in d['background_components']])
if auto_background is True:
self.add_polynomial_background()
if auto_add_lines is True:
# Will raise an error if no elements are specified, so check:
if 'Sample.elements' in self.signal.metadata:
self.add_family_lines()
def __init__(self,
spectrum,
auto_background=True,
auto_add_lines=True,
*args,
**kwargs):
Model1D.__init__(self, spectrum, *args, **kwargs)
self.xray_lines = list()
end_energy = self.axes_manager.signal_axes[0].high_value
self.end_energy = min(end_energy, self.signal._get_beam_energy())
self.start_energy = self.axes_manager.signal_axes[0].low_value
self.background_components = list()
if 'dictionary' in kwargs or len(args) > 1:
d = args[1] if len(args) > 1 else kwargs['dictionary']
if len(d['xray_lines']) > 0:
self.xray_lines.extend(
[self[name] for name in d['xray_lines']])
auto_add_lines = False
if len(d['background_components']) > 0:
self.background_components.extend(
[self[name] for name in d['background_components']])
auto_background = False
if auto_background is True:
self.add_polynomial_background()
if auto_add_lines is True:
self.add_family_lines()
def __init__(self, signal1D, auto_background=True,
auto_add_edges=True, ll=None,
GOS=None, dictionary=None):
Model1D.__init__(self, signal1D)
# When automatically setting the fine structure energy regions,
# the fine structure of an EELS edge component is automatically
# disable if the next ionisation edge onset distance to the
# higher energy side of the fine structure region is lower that
# the value of this parameter
self._min_distance_between_edges_for_fine_structure = 0
self._preedge_safe_window_width = 2
self.signal1D = signal1D
self._suspend_auto_fine_structure_width = False
self.convolved = False
self.low_loss = ll
self.GOS = GOS
self.edges = []
self._background_components = []
if dictionary is not None:
auto_background = False
auto_add_edges = False
self._load_dictionary(dictionary)
if auto_background is True:
background = PowerLaw()
self.append(background)
if self.signal.subshells and auto_add_edges is True:
self._add_edges_from_subshells_names()
def __init__(self, spectrum,
auto_background=True,
auto_add_lines=True,
*args, **kwargs):
Model1D.__init__(self, spectrum, *args, **kwargs)
self.xray_lines = list()
self.family_lines = list()
end_energy = self.axes_manager.signal_axes[0].high_value
self.end_energy = min(end_energy, self.signal._get_beam_energy())
self.start_energy = self.axes_manager.signal_axes[0].low_value
self.background_components = list()
if 'dictionary' in kwargs or len(args) > 1:
d = args[1] if len(args) > 1 else kwargs['dictionary']
if len(d['xray_lines']) > 0:
self.xray_lines.extend(
[self[name] for name in d['xray_lines']])
auto_add_lines = False
if len(d['background_components']) > 0:
self.background_components.extend(
[self[name] for name in d['background_components']])
auto_background = False
if auto_background is True:
self.add_polynomial_background()
if auto_add_lines is True:
# Will raise an error if no elements are specified, so check:
if 'Sample.elements' in self.signal.metadata:
self.add_family_lines()
def __init__(self, spectrum,
auto_background=True,
auto_add_lines=True,
*args, **kwargs):
Model1D.__init__(self, spectrum, *args, **kwargs)
self.xray_lines = list()
self.family_lines = list()
# energy bounds on the spectra and model
#end_energy = self.axes_manager.signal_axes[0].high_value
#self.end_energy = min(end_energy, self.signal._get_beam_energy())
self.end_energy = self.axes_manager.signal_axes[0].high_value
def fit(self, kind="std", **kwargs):
"""Fits the model to the experimental data.
Read more in the :ref:`User Guide <model.fitting>`.
Parameters
----------
kind : {"std", "smart"}, default "std"
If "std", performs standard fit. If "smart",
performs a smart_fit - for more details see
the :ref:`User Guide <eels.fitting>`.
%s
Returns
-------
None
See Also
--------
* :py:meth:`~hyperspy.model.BaseModel.fit`
* :py:meth:`~hyperspy.model.BaseModel.multifit`
* :py:meth:`~hyperspy.model.EELSModel.smart_fit`
"""
if kind not in ["smart", "std"]:
raise ValueError(
f"kind must be either 'std' or 'smart', not '{kind}'")
elif kind == "smart":
return self.smart_fit(**kwargs)
elif kind == "std":
return Model1D.fit(self, **kwargs)
def _estimate_gain(ns, cs,
weighted=False,
higher_than=None,
plot_results=False,
binning=0,
pol_order=1):
if binning > 0:
factor = 2 ** binning
remainder = np.mod(ns.shape[1], factor)
if remainder != 0:
ns = ns[:, remainder:]
cs = cs[:, remainder:]
new_shape = (ns.shape[0], ns.shape[1] / factor)
ns = rebin(ns, new_shape)
cs = rebin(cs, new_shape)
noise = ns - cs
variance = np.var(noise, 0)
average = np.mean(cs, 0).squeeze()
# Select only the values higher_than for the calculation
if higher_than is not None:
sorting_index_array = np.argsort(average)
average_sorted = average[sorting_index_array]
average_higher_than = average_sorted > higher_than
variance_sorted = variance.squeeze()[sorting_index_array]
variance2fit = variance_sorted[average_higher_than]
average2fit = average_sorted[average_higher_than]
else:
variance2fit = variance
average2fit = average
fit = np.polyfit(average2fit, variance2fit, pol_order)
if weighted is True:
from hyperspy._signals.signal1D import Signal1D
from hyperspy.models.model1d import Model1D
from hyperspy.components1d import Line
s = Signal1D(variance2fit)
s.axes_manager.signal_axes[0].axis = average2fit
m = Model1D(s)
l = Line()
l.a.value = fit[1]
l.b.value = fit[0]
m.append(l)
m.fit(weights=True)
fit[0] = l.b.value
fit[1] = l.a.value
if plot_results is True:
plt.figure()
plt.scatter(average.squeeze(), variance.squeeze())
plt.xlabel('Counts')
plt.ylabel('Variance')
plt.plot(average2fit, np.polyval(fit, average2fit), color='red')
results = {'fit': fit, 'variance': variance.squeeze(),
'counts': average.squeeze()}
return results
def test_3d_signal(self):
# This code should run smoothly, any exceptions should trigger failure
s = self.m_3d.as_signal()
model = Model1D(s)
p = hs.model.components1D.Polynomial(order=2)
model.append(p)
p.estimate_parameters(s, 0, 100, only_current=False)
np.testing.assert_allclose(p.coefficients.map['values'],
np.tile([0.5, 2, 3], (2, 5, 1)))
def test_3d_signal(self):
# This code should run smoothly, any exceptions should trigger failure
s = self.m_3d.as_signal()
model = Model1D(s)
p = hs.model.components1D.Polynomial(order=2, legacy=False)
model.append(p)
p.estimate_parameters(s, 0, 100, only_current=False)
np.testing.assert_allclose(p.a2.map['values'], 0.5)
np.testing.assert_allclose(p.a1.map['values'], 2)
np.testing.assert_allclose(p.a0.map['values'], 3)
def __init__(self, spectrum, auto_background=True, auto_add_lines=True, *args, **kwargs):
Model1D.__init__(self, spectrum, *args, **kwargs)
self.xray_lines = list()
end_energy = self.axes_manager.signal_axes[0].high_value
self.end_energy = min(end_energy, self.signal._get_beam_energy())
self.start_energy = self.axes_manager.signal_axes[0].low_value
self.background_components = list()
if "dictionary" in kwargs or len(args) > 1:
d = args[1] if len(args) > 1 else kwargs["dictionary"]
if len(d["xray_lines"]) > 0:
self.xray_lines.extend([self[name] for name in d["xray_lines"]])
auto_add_lines = False
if len(d["background_components"]) > 0:
self.background_components.extend([self[name] for name in d["background_components"]])
auto_background = False
if auto_background is True:
self.add_polynomial_background()
if auto_add_lines is True:
self.add_family_lines()
def create_model(self, dictionary=None):
"""Create a model for the current data.
Returns
-------
model : `Model1D` instance.
"""
from hyperspy.models.model1d import Model1D
model = Model1D(self, dictionary=dictionary)
return model
def __init__(self, signal1D, auto_background=True,
auto_add_edges=True, ll=None,
GOS=None, dictionary=None):
Model1D.__init__(self, signal1D)
self._suspend_auto_fine_structure_width = False
self.convolved = False
self.low_loss = ll
self.GOS = GOS
self.edges = []
self._background_components = []
if dictionary is not None:
auto_background = False
auto_add_edges = False
self._load_dictionary(dictionary)
if auto_background is True:
background = PowerLaw()
self.append(background)
if self.signal.subshells and auto_add_edges is True:
self._add_edges_from_subshells_names()
def _remove_background_cli(self,
signal_range,
background_estimator,
fast=True,
show_progressbar=None):
from hyperspy.models.model1d import Model1D
model = Model1D(self)
model.append(background_estimator)
background_estimator.estimate_parameters(self,
signal_range[0],
signal_range[1],
only_current=False)
if not fast:
model.set_signal_range(signal_range[0], signal_range[1])
model.multifit(show_progressbar=show_progressbar)
return self - model.as_signal(show_progressbar=show_progressbar)
def fit(self, fitter=None, method='ls', grad=False,
bounded=False, ext_bounding=False, update_plot=False,
kind='std', **kwargs):
"""Fits the model to the experimental data
Parameters
----------
fitter : {None, "leastsq", "odr", "mpfit", "fmin"}
The optimizer to perform the fitting. If None the fitter
defined in the Preferences is used. leastsq is the most
stable but it does not support bounding. mpfit supports
bounding. fmin is the only one that supports
maximum likelihood estimation, but it is less robust than
the Levenberg–Marquardt based leastsq and mpfit, and it is
better to use it after one of them to refine the estimation.
method : {'ls', 'ml'}
Choose 'ls' (default) for least squares and 'ml' for
maximum-likelihood estimation. The latter only works with
fitter = 'fmin'.
grad : bool
If True, the analytical gradient is used if defined to
speed up the estimation.
ext_bounding : bool
If True, enforce bounding by keeping the value of the
parameters constant out of the defined bounding area.
bounded : bool
If True performs bounded optimization if the fitter
supports it. Currently only mpfit support bounding.
update_plot : bool
If True, the plot is updated during the optimization
process. It slows down the optimization but it permits
to visualize the optimization evolution.
kind : {'std', 'smart'}
If 'std' (default) performs standard fit. If 'smart'
performs smart_fit
**kwargs : key word arguments
Any extra key word argument will be passed to the chosen
fitter
See Also
--------
multifit, smart_fit
"""
if kind == 'smart':
self.smart_fit(fitter=fitter,
method=method,
grad=grad,
bounded=bounded,
ext_bounding=ext_bounding,
update_plot=update_plot,
**kwargs)
elif kind == 'std':
Model1D.fit(self,
fitter=fitter,
method=method,
grad=grad,
bounded=bounded,
ext_bounding=ext_bounding,
update_plot=update_plot,
**kwargs)
else:
raise ValueError('kind must be either \'std\' or \'smart\'.'
'\'%s\' provided.' % kind)
def fit(self,
fitter=None,
method='ls',
grad=False,
bounded=False,
ext_bounding=False,
update_plot=False,
kind='std',
**kwargs):
"""Fits the model to the experimental data
Parameters
----------
fitter : {None, "leastsq", "odr", "mpfit", "fmin"}
The optimizer to perform the fitting. If None the fitter
defined in the Preferences is used. leastsq is the most
stable but it does not support bounding. mpfit supports
bounding. fmin is the only one that supports
maximum likelihood estimation, but it is less robust than
the Levenberg–Marquardt based leastsq and mpfit, and it is
better to use it after one of them to refine the estimation.
method : {'ls', 'ml'}
Choose 'ls' (default) for least squares and 'ml' for
maximum-likelihood estimation. The latter only works with
fitter = 'fmin'.
grad : bool
If True, the analytical gradient is used if defined to
speed up the estimation.
ext_bounding : bool
If True, enforce bounding by keeping the value of the
parameters constant out of the defined bounding area.
bounded : bool
If True performs bounded optimization if the fitter
supports it. Currently only mpfit support bounding.
update_plot : bool
If True, the plot is updated during the optimization
process. It slows down the optimization but it permits
to visualize the optimization evolution.
kind : {'std', 'smart'}
If 'std' (default) performs standard fit. If 'smart'
performs smart_fit
**kwargs : key word arguments
Any extra key word argument will be passed to the chosen
fitter
See Also
--------
multifit, smart_fit
"""
if kind == 'smart':
self.smart_fit(fitter=fitter,
method=method,
grad=grad,
bounded=bounded,
ext_bounding=ext_bounding,
update_plot=update_plot,
**kwargs)
elif kind == 'std':
Model1D.fit(self,
fitter=fitter,
method=method,
grad=grad,
bounded=bounded,
ext_bounding=ext_bounding,
update_plot=update_plot,
**kwargs)
else:
raise ValueError('kind must be either \'std\' or \'smart\'.'
'\'%s\' provided.' % kind)
