def test_estimate_parameters_binned(only_current, binned, lazy, uniform):
s = Signal1D(np.empty((100, )))
s.axes_manager.signal_axes[0].is_binned = binned
axis = s.axes_manager.signal_axes[0]
axis.scale = 1
axis.offset = -20
g1 = Gaussian(50015.156, 10 / sigma2fwhm, 10)
s.data = g1.function(axis.axis)
if not uniform:
axis.convert_to_non_uniform_axis()
if lazy:
s = s.as_lazy()
g2 = Gaussian()
if binned and uniform:
factor = axis.scale
elif binned:
factor = np.gradient(axis.axis)
else:
factor = 1
assert g2.estimate_parameters(s,
axis.low_value,
axis.high_value,
only_current=only_current)
assert g2._axes_manager[-1].is_binned == binned
np.testing.assert_allclose(g1.A.value, g2.A.value * factor)
assert abs(g2.centre.value - g1.centre.value) <= 1e-3
assert abs(g2.sigma.value - g1.sigma.value) <= 0.1
def create_sum_of_gaussians(convolved=False):
param1 = {
'A': A_value_gaussian[0],
'centre': centre_value_gaussian[0] / scale,
'sigma': sigma_value_gaussian[0] / scale
}
gs1 = Gaussian(**param1)
param2 = {
'A': A_value_gaussian[1],
'centre': centre_value_gaussian[1] / scale,
'sigma': sigma_value_gaussian[1] / scale
}
gs2 = Gaussian(**param2)
param3 = {
'A': A_value_gaussian[2],
'centre': centre_value_gaussian[2] / scale,
'sigma': sigma_value_gaussian[2] / scale
}
gs3 = Gaussian(**param3)
axis = np.arange(1000)
data = gs1.function(axis) + gs2.function(axis) + gs3.function(axis)
if convolved:
to_convolved = create_ll_signal(data.shape[0]).data
data = np.convolve(data, to_convolved) / sum(to_convolved)
s = Signal1D(data[:1000])
s.axes_manager[-1].scale = scale
return s
def setup_method(self, method):
np.random.seed(1)
c1, c2 = 10, 12
A1, A2 = -50, 20
G1 = Gaussian(centre=c1, A=A1, sigma=1)
G2 = Gaussian(centre=c2, A=A2, sigma=1)
x = np.linspace(0, 20, 1000)
y = G1.function(x) + G2.function(x) + 5
error = np.random.normal(size=y.shape)
y = y + error
s = Signal1D(y)
s.axes_manager[-1].scale = x[1] - x[0]
self.m = s.create_model()
g1 = Gaussian(centre=c1, A=1, sigma=1)
g2 = Gaussian(centre=c2, A=1, sigma=1)
offset = Offset()
self.m.extend([g1, g2, offset])
g1.centre.free = False
g1.sigma.free = False
g2.centre.free = False
g2.sigma.free = False
self.g1, self.g2 = g1, g2
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 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 np.equal(m.dof(), 3)
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()
np.testing.assert_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 np.equal(m.dof(), 5)
def setup_method(self, method):
s = Signal1D(range(100))
m = s.create_model()
m.append(Gaussian())
m[-1].A.value = 13
m[-1].name = 'something'
m.append(Gaussian())
m[-1].A.value = 3
self.m = m
def test_plot_gaussian_eelsmodel(convolved, plot_component, binned):
s = create_sum_of_gaussians(convolved)
s.set_signal_type('EELS')
s.axes_manager[-1].is_binned == binned
s.metadata.General.title = 'Convolved: {}, plot_component: {}, binned: {}'.format(
convolved, plot_component, binned)
ll = create_ll_signal(1000) if convolved else None
s.set_microscope_parameters(200, 20, 50)
s.axes_manager[-1].is_binned = binned
m = s.create_model(auto_background=False, ll=ll)
m.extend([Gaussian(), Gaussian(), Gaussian()])
def set_gaussian(gaussian, centre, sigma):
gaussian.centre.value = centre
gaussian.centre.free = False
gaussian.sigma.value = sigma
gaussian.sigma.free = False
for gaussian, centre, sigma in zip(m, centre_value_gaussian,
sigma_value_gaussian):
set_gaussian(gaussian, centre, sigma)
m.fit()
m.plot(plot_components=plot_component)
def A_value(s, component, binned):
if binned:
return component.A.value * scale
else:
return component.A.value
if convolved:
np.testing.assert_almost_equal(A_value(s, m[0], binned),
0.014034,
decimal=5)
np.testing.assert_almost_equal(A_value(s, m[1], binned),
0.008420,
decimal=5)
np.testing.assert_almost_equal(A_value(s, m[2], binned),
0.028068,
decimal=5)
else:
np.testing.assert_almost_equal(A_value(s, m[0], binned),
100.0,
decimal=5)
np.testing.assert_almost_equal(A_value(s, m[1], binned),
60.0,
decimal=5)
np.testing.assert_almost_equal(A_value(s, m[2], binned),
200.0,
decimal=5)
return m._plot.signal_plot.figure
def create_ll_signal(signal_shape=1000):
offset = 0
zlp_param = {'A': 10000.0, 'centre': 0.0 + offset, 'sigma': 15.0}
zlp = Gaussian(**zlp_param)
plasmon_param = {'A': 2000.0, 'centre': 200.0 + offset, 'sigma': 75.0}
plasmon = Gaussian(**plasmon_param)
axis = np.arange(signal_shape)
data = zlp.function(axis) + plasmon.function(axis)
ll = EELSSpectrum(data)
ll.axes_manager[-1].offset = -offset
ll.axes_manager[-1].scale = 0.1
return ll
def setup_method(self, method):
s = Signal1D(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 = Signal1D(np.arange(1000).reshape(10, 10, 10))
m = s.create_model()
m.append(g1)
m.append(g2)
m.append(g3)
self.g1 = g1
self.g2 = g2
self.g3 = g3
self.model = m
def setup_method(self, method):
g1 = Gaussian()
g2 = Gaussian()
g3 = Gaussian()
s = Signal1D(np.arange(10))
m = s.create_model()
m.append(g1)
m.append(g2)
m.append(g3)
self.g1 = g1
self.g2 = g2
self.g3 = g3
self.model = m
def test_function_nd(binned):
s = Signal1D(np.empty((100,)))
axis = s.axes_manager.signal_axes[0]
axis.scale = 1
axis.offset = -20
g1 = Gaussian(50015.156, 10/sigma2fwhm, 10)
s.data = g1.function(axis.axis)
s.metadata.Signal.binned = binned
s2 = stack([s] * 2)
g2 = Gaussian()
factor = axis.scale if binned else 1
g2.estimate_parameters(s2, axis.low_value, axis.high_value, False)
assert g2.binned == binned
assert_allclose(g2.function_nd(axis.axis) * factor, s2.data)
def get_holz_heterostructure_test_signal(lazy=False):
"""Get HyperSpy 2D signal with 2D navigation dimensions for HOLZ testing.
The centre, radius and intensity of the ring varies as a function of probe
position. The disk centre position varies as a function of probe position.
Parameters
----------
lazy : bool, default False
Returns
-------
holz_signal : HyperSpy 2D signal
Example
-------
>>> s = pxm.dummy_data.get_holz_heterostructure_test_signal()
>>> s.plot()
Load as lazy
>>> s = pxm.dummy_data.get_holz_heterostructure_test_signal(lazy=True)
"""
probe_size_x, probe_size_y = 40, 40
px, py = np.mgrid[0:probe_size_x:1, 0:probe_size_y:1]
x, y = np.mgrid[36:38:40j, 41:43:40j]
disk_r = 10
disk_I = np.ones_like(x) * 100 + np.random.random() * 20
g_r = Gaussian(A=20, centre=25, sigma=5)
ring_r = np.ones_like(x) * 30 + g_r.function(py)
g_I = Gaussian(A=30, centre=25, sigma=3)
ring_I = np.ones_like(x) * 20 + g_I.function(py)
s = mdtd.generate_4d_data(
probe_size_x=probe_size_x,
probe_size_y=probe_size_y,
image_size_x=80,
image_size_y=80,
disk_x=x,
disk_y=y,
disk_r=disk_r,
disk_I=disk_I,
ring_x=x,
ring_y=y,
ring_r=ring_r,
ring_I=ring_I,
add_noise=True,
lazy=lazy,
)
return s
def test_estimate_parameters_negative_scale():
s = Signal1D(np.empty((100,)))
axis = s.axes_manager.signal_axes[0]
axis.scale = -1
axis.offset = 100
g1 = Gaussian(50015.156, 15/sigma2fwhm, 50)
s.data = g1.function(axis.axis)
g2 = Gaussian()
with pytest.raises(ValueError):
g2.estimate_parameters(s, 40, 60)
assert g2.estimate_parameters(s, 90, 10)
np.testing.assert_allclose(g1.A.value, g2.A.value)
assert abs(g2.centre.value - g1.centre.value) <= 1e-3
assert abs(g2.sigma.value - g1.sigma.value) <= 0.1
def setup_method(self, method):
np.random.seed(1)
s = Signal1D(np.random.normal(scale=2, size=10000)).get_histogram()
self.g = Gaussian()
m = s.create_model()
m.append(self.g)
self.m = m
def setUp(self):
s = Signal1D(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_in_range(self):
m = self.model
g = Gaussian()
m.append(g)
m.set_signal_range(1, 7)
m.fit()
assert np.allclose(m.red_chisq(), 2.87544335)
def setup_method(self, method):
gaussian = Gaussian()
gaussian.A.value = 20
gaussian.sigma.value = 10
gaussian.centre.value = 50
self.signal = Signal1D(gaussian.function(np.arange(0, 100, 0.01)))
self.signal.axes_manager[0].scale = 0.01
def test_map_values_std_isset(self, weighted):
self._post_setup_method(weighted)
m = self.m
L = Gaussian(centre=15.)
L.centre.free = L.sigma.free = False
m.append(L)
m.multifit(iterpath="serpentine")
nonlinear = L.A.map.copy()
L.A.map['is_set'] = False
cm = pytest.warns(UserWarning) if weighted and not self.s._lazy else \
dummy_context_manager()
with cm:
m.multifit(optimizer='lstsq', calculate_errors=True)
linear = L.A.map.copy()
np.testing.assert_allclose(nonlinear['values'], linear['values'])
np.testing.assert_allclose(nonlinear['std'], linear['std'])
np.testing.assert_allclose(nonlinear['is_set'], linear['is_set'])
cm = pytest.warns(UserWarning) if weighted and not self.s._lazy else \
dummy_context_manager()
with cm:
m.multifit(optimizer='lstsq', calculate_errors=False)
np.testing.assert_equal(L.A.map['std'], np.nan)
def test_estimate_parameters_binned(only_current, binned):
s = Signal1D(np.empty((100,)))
s.metadata.Signal.binned = binned
axis = s.axes_manager.signal_axes[0]
axis.scale = 1
axis.offset = -20
g1 = Gaussian(50015.156, 10/sigma2fwhm, 10)
s.data = g1.function(axis.axis)
g2 = Gaussian()
factor = axis.scale if binned else 1
assert g2.estimate_parameters(s, axis.low_value, axis.high_value,
only_current=only_current)
assert g2.binned == binned
assert_allclose(g1.A.value, g2.A.value * factor)
assert abs(g2.centre.value - g1.centre.value) <= 1e-3
assert abs(g2.sigma.value - g1.sigma.value) <= 0.1
def setup_method(self, method):
s = EDSTEMSpectrum(np.ones([2, 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=2.5,
tilt_stage=0.0,
azimuth_angle=0,
elevation_angle=35,
energy_resolution_MnKa=130,
beam_current=0.05)
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)
s.axes_manager[0].scale = 0.5
s.axes_manager[1].scale = 0.5
s.axes_manager[0].units = 'nm'
s.axes_manager[1].units = 'nm'
self.signal = s
def test_function():
g = Gaussian()
g.centre.value = 1
g.sigma.value = 2 / sigma2fwhm
g.A.value = 3 * sqrt2pi * g.sigma.value
assert_allclose(g.function(2), 1.5)
assert_allclose(g.function(1), 3)
def test_chisq_in_range(self):
m = self.model
g = Gaussian()
m.append(g)
m.set_signal_range(1, 7)
m.fit()
np.testing.assert_allclose(m.red_chisq(), 2.20961562)
def setup_method(self, method):
s = Signal1D(np.random.random((2, 2, 8)))
m = s.create_model()
G = Gaussian()
m.append(G)
self.model = m
self.G = G
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()
np.testing.assert_allclose(m.chisq(), 7.78966223)
def setup_method(self, method):
self.shape = (5, 7)
self.s = LocalStrategy('test diffusion strategy')
self.samf = create_artificial_samfire(self.shape)
m = Signal1D(np.empty(self.shape + (100,))).create_model()
m.extend([Gaussian() for _ in range(3)])
m.chisq.data.fill(5.)
self.samf.model = m
def setup_method(self, method):
s = Signal1D(range(10))
m1 = s.create_model()
m2 = s.create_model()
m1.append(Gaussian())
m2.append(Lorentzian())
m1.fit()
m2.fit()
self.m1 = m1
self.m2 = m2
def setup_method(self, method):
g = Gaussian()
g.A.value = 10000.0
g.centre.value = 5000.0
g.sigma.value = 500.0
axis = np.arange(10000)
s = Signal1D(g.function(axis))
m = s.create_model()
self.model = m
self.g = g
self.axis = axis
