def test_get_component_wrong(self):
m = self.model
g1 = Gaussian()
g2 = Gaussian()
g2.name = "test"
m.extend((g1, g2))
m._get_component(1.2)
def test_component_name_when_append(self):
m = self.model
gs = [Gaussian(), Gaussian(), Gaussian()]
m.extend(gs)
nose.tools.assert_is(m['Gaussian'], gs[0])
nose.tools.assert_is(m['Gaussian_0'], gs[1])
nose.tools.assert_is(m['Gaussian_1'], gs[2])
def test_access_component_by_index(self):
m = self.model
g1 = Gaussian()
g2 = Gaussian()
g2.name = "test"
m.extend((g1, g2))
nose.tools.assert_is(m[1], g2)
def test_get_component_by_name(self):
m = self.model
g1 = Gaussian()
g2 = Gaussian()
g2.name = "test"
m.extend((g1, g2))
nose.tools.assert_is(m._get_component("test"), g2)
def test_several_component_with_same_name(self):
m = self.model
gs = [Gaussian(), Gaussian(), Gaussian()]
m.extend(gs)
m[0]._name = "Gaussian"
m[1]._name = "Gaussian"
m[2]._name = "Gaussian"
m['Gaussian']
def test_dof_with_fit(self):
m = self.model
g = Gaussian()
g1 = Gaussian()
m.extend((g, g1))
g1.set_parameters_not_free('A')
m.fit()
assert_true(np.equal(m.dof(), 5))
def test_chisq_with_inactive_components(self):
m = self.model
ga = Gaussian()
gin = Gaussian()
m.append(ga)
m.append(gin)
gin.active = False
m.fit()
assert_true(np.allclose(m.chisq(), 7.78966223))
def test_dof_with_p0(self):
m = self.model
g = Gaussian()
g1 = Gaussian()
m.extend((g, g1))
g1.set_parameters_not_free('A')
m._set_p0()
m._set_current_degrees_of_freedom()
assert_true(np.equal(m.dof(), 5))
def test_dof_with_inactive_components(self):
m = self.model
ga = Gaussian()
gin = Gaussian()
m.append(ga)
m.append(gin)
gin.active = False
m.fit()
assert_true(np.equal(m.dof(), 3))
def setUp(self):
s = Spectrum(np.array([1.0, 2, 4, 7, 12, 7, 4, 2, 1]))
m = s.create_model()
m._low_loss = (s + 3.0).deepcopy()
self.model = m
self.s = s
m.append(Gaussian())
m.append(Gaussian())
m.append(ScalableFixedPattern(s * 0.3))
m[0].A.twin = m[1].A
m.fit()
def setUp(self):
g1 = Gaussian()
g2 = Gaussian()
g3 = Gaussian()
s = Spectrum(np.arange(10))
m = create_model(s)
m.append(g1)
m.append(g2)
m.append(g3)
self.g1 = g1
self.g2 = g2
self.g3 = g3
self.model = m
def setUp(self):
gaussian = Gaussian()
gaussian.A.value = 20
gaussian.sigma.value = 10
gaussian.centre.value = 50
self.signal = Signal(gaussian.function(np.arange(0, 100, 0.01)))
self.signal.axes_manager[0].scale = 0.01
def setUp(self):
s = EDSTEMSpectrum(np.ones([2, 1024]))
energy_axis = s.axes_manager.signal_axes[0]
energy_axis.scale = 1e-2
energy_axis.units = 'keV'
energy_axis.name = "Energy"
s.set_microscope_parameters(beam_energy=200,
live_time=3.1,
tilt_stage=0.0,
azimuth_angle=None,
elevation_angle=35,
energy_resolution_MnKa=130)
elements = ['Al', 'Zn']
xray_lines = ['Al_Ka', 'Zn_Ka']
intensities = [300, 500]
for i, xray_line in enumerate(xray_lines):
gauss = Gaussian()
line_energy, FWHM = s._get_line_energy(xray_line, FWHM_MnKa='auto')
gauss.centre.value = line_energy
gauss.A.value = intensities[i]
gauss.sigma.value = FWHM
s.data[:] += gauss.function(energy_axis.axis)
s.set_elements(elements)
s.add_lines(xray_lines)
self.signal = s
def test_chisq_in_range(self):
m = self.model
g = Gaussian()
m.append(g)
m.set_signal_range(1, 7)
m.fit()
assert_true(np.allclose(m.red_chisq(), 2.87544335))
def setUp(self):
s = Spectrum(range(100))
m = s.create_model()
m.append(Gaussian())
m.components.Gaussian.A.value = 13
m.components.Gaussian.name = 'something'
self.m = m
def test_chisq(self):
m = self.model
g = Gaussian()
g.A.value = self.A
g.sigma.value = self.sigma
g.centre.value = self.centre
m.append(g)
m._calculate_chisq()
assert_true(np.allclose(m.chisq(), 7.78966223))
def test_fit_component(self):
m = self.model
axis = self.axis
g1 = Gaussian()
m.append(g1)
m.fit_component(g1, signal_range=(4000, 6000))
assert_true(
np.allclose(self.g.function(axis),
g1.function(axis),
rtol=self.rtol))
def test_red_chisq(self):
m = self.model
g = Gaussian()
g.A.value = self.A
g.sigma.value = self.sigma
g.centre.value = self.centre
m.append(g)
m._set_p0()
m._set_current_degrees_of_freedom()
m._calculate_chisq()
assert_true(np.allclose(m.red_chisq(), 1.55793245))
def setUp(self):
# Create an empty spectrum
s = EELSSpectrumSimulation(np.zeros((3, 2, 1024)))
energy_axis = s.axes_manager.signal_axes[0]
energy_axis.scale = 0.02
energy_axis.offset = -5
gauss = Gaussian()
gauss.centre.value = 0
gauss.A.value = 5000
gauss.sigma.value = 0.5
gauss2 = Gaussian()
gauss2.sigma.value = 0.5
# Inflexion point 1.5
gauss2.A.value = 5000
gauss2.centre.value = 5
s.data[:] = (gauss.function(energy_axis.axis) +
gauss2.function(energy_axis.axis))
# s.add_poissonian_noise()
self.signal = s
def setUp(self):
g = Gaussian()
g.A.value = 10000.0
g.centre.value = 5000.0
g.sigma.value = 500.0
axis = np.arange(10000)
s = Spectrum(g.function(axis))
m = s.create_model()
self.model = m
self.g = g
self.axis = axis
self.rtol = 0.00
def setUp(self):
np.random.seed(1)
axes = np.array([[
100 * np.random.random() + np.arange(0., 600, 1) for i in range(3)
] for j in range(4)])
g = Gaussian()
g.A.value = 30000.
g.centre.value = 300.
g.sigma.value = 150.
data = g.function(axes)
s = SpectrumSimulation(data)
s.axes_manager[-1].offset = -150.
s.axes_manager[-1].scale = 0.5
s.add_gaussian_noise(2.0)
m = s.create_model()
g = Gaussian()
g.A.ext_force_positive = True
g.A.ext_bounded = True
m.append(g)
g.active_is_multidimensional = True
for index in m.axes_manager:
m.fit()
self.model = m
def setUp(self):
# Create an empty spectrum
s = EDSSEMSpectrum(np.zeros((2, 2, 3, 100)))
energy_axis = s.axes_manager.signal_axes[0]
energy_axis.scale = 0.04
energy_axis.units = 'keV'
energy_axis.name = "Energy"
g = Gaussian()
g.sigma.value = 0.05
g.centre.value = 1.487
s.data[:] = g.function(energy_axis.axis)
s.metadata.Acquisition_instrument.SEM.Detector.EDS.live_time = 3.1
s.metadata.Acquisition_instrument.SEM.beam_energy = 15.0
self.signal = s
def setUp(self):
data = np.random.random((10, 10, 600))
s = EELSSpectrum(data)
s.axes_manager[-1].offset = -150.
s.axes_manager[-1].scale = 0.5
s.metadata.set_item(
'Acquisition_instrument.TEM.Detector.EELS.collection_angle', 3.0)
s.metadata.set_item('Acquisition_instrument.TEM.beam_energy', 1.0)
s.metadata.set_item('Acquisition_instrument.TEM.convergence_angle',
2.0)
m = s.create_model(ll=s + 1,
auto_background=False,
auto_add_edges=False)
g = Gaussian()
m.append(g)
self.model = m
def setUp(self):
gs1 = Gaussian()
gs1.A.value = 10000.0
gs1.centre.value = 5000.0
gs1.sigma.value = 500.0
gs2 = Gaussian()
gs2.A.value = 60000.0
gs2.centre.value = 2000.0
gs2.sigma.value = 300.0
gs3 = Gaussian()
gs3.A.value = 20000.0
gs3.centre.value = 6000.0
gs3.sigma.value = 100.0
axis = np.arange(10000)
total_signal = (gs1.function(axis) + gs2.function(axis) +
gs3.function(axis))
s = Spectrum(total_signal)
m = s.create_model()
g1 = Gaussian()
g2 = Gaussian()
g3 = Gaussian()
m.append(g1)
m.append(g2)
m.append(g3)
self.model = m
self.gs1 = gs1
self.gs2 = gs2
self.gs3 = gs3
self.g1 = g1
self.g2 = g2
self.g3 = g3
self.axis = axis
self.rtol = 0.01
def setUp(self):
self.gaussian = Gaussian()
self.gaussian._axes_manager = Signal(np.zeros((3, 3, 1))).axes_manager
def test_remove_component_by_name(self):
m = self.model
g1 = Gaussian()
m.append(g1)
m.remove(g1.name)
nose.tools.assert_equal(len(m), 0)
def test_component_already_in_model(self):
m = self.model
g1 = Gaussian()
m.extend((g1, g1))
def fourier_ratio_deconvolution(self,
ll,
fwhm=None,
threshold=None,
extrapolate_lowloss=True,
extrapolate_coreloss=True):
"""Performs Fourier-ratio deconvolution.
The core-loss should have the background removed. To reduce
the noise amplication the result is convolved with a
Gaussian function.
Parameters
----------
ll: EELSSpectrum
The corresponding low-loss (ll) EELSSpectrum.
fwhm : float or None
Full-width half-maximum of the Gaussian function by which
the result of the deconvolution is convolved. It can be
used to select the final SNR and spectral resolution. If
None, the FWHM of the zero-loss peak of the low-loss is
estimated and used.
threshold : {None, float}
Truncation energy to estimate the intensity of the
elastic scattering. If None the threshold is taken as the
first minimum after the ZLP centre.
extrapolate_lowloss, extrapolate_coreloss : bool
If True the signals are extrapolated using a power law,
Notes
-----
For details see: Egerton, R. Electron Energy-Loss
Spectroscopy in the Electron Microscope. Springer-Verlag, 2011.
"""
self._check_signal_dimension_equals_one()
orig_cl_size = self.axes_manager.signal_axes[0].size
if threshold is None:
threshold = ll.estimate_elastic_scattering_threshold()
if extrapolate_coreloss is True:
cl = self.power_law_extrapolation(window_size=20,
extrapolation_size=100)
else:
cl = self.deepcopy()
if extrapolate_lowloss is True:
ll = ll.power_law_extrapolation(window_size=100,
extrapolation_size=100)
else:
ll = ll.deepcopy()
ll.hanning_taper()
cl.hanning_taper()
ll_size = ll.axes_manager.signal_axes[0].size
cl_size = self.axes_manager.signal_axes[0].size
# Conservative new size to solve the wrap-around problem
size = ll_size + cl_size - 1
# Increase to the closest multiple of two to enhance the FFT
# performance
size = int(2**np.ceil(np.log2(size)))
axis = ll.axes_manager.signal_axes[0]
if fwhm is None:
fwhm = float(ll.get_current_signal().estimate_peak_width()())
print("FWHM = %1.2f" % fwhm)
I0 = ll.estimate_elastic_scattering_intensity(threshold=threshold)
if ll.axes_manager.navigation_size > 0:
I0 = I0.data
I0_shape = list(I0.shape)
I0_shape.insert(axis.index_in_array, 1)
I0 = I0.reshape(I0_shape)
from hyperspy.components import Gaussian
g = Gaussian()
g.sigma.value = fwhm / 2.3548
g.A.value = 1
g.centre.value = 0
zl = g.function(
np.linspace(axis.offset, axis.offset + axis.scale * (size - 1),
size))
z = np.fft.rfft(zl)
jk = np.fft.rfft(cl.data, n=size, axis=axis.index_in_array)
jl = np.fft.rfft(ll.data, n=size, axis=axis.index_in_array)
zshape = [
1,
] * len(cl.data.shape)
zshape[axis.index_in_array] = jk.shape[axis.index_in_array]
cl.data = np.fft.irfft(z.reshape(zshape) * jk / jl,
axis=axis.index_in_array)
cl.data *= I0.data
cl.crop(-1, None, int(orig_cl_size))
cl.metadata.General.title = (self.metadata.General.title +
' after Fourier-ratio deconvolution')
if cl.tmp_parameters.has_item('filename'):
cl.tmp_parameters.filename = (self.tmp_parameters.filename +
'after_fourier_ratio_deconvolution')
return cl
def setUp(self):
self.gaussian = Gaussian()
def setUp(self):
s = Spectrum(range(100))
m = s.create_model()
m.append(Gaussian())
m.fit()
self.m = m
