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