Exemple #1
0
    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
        self.signal = s
Exemple #2
0
 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 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
Exemple #4
0
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)
Exemple #5
0
    def setUp(self):
        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=3.1,
            tilt_stage=0.0,
            azimuth_angle=None,
            elevation_angle=35,
            energy_resolution_MnKa=130,
        )
        s.metadata.Acquisition_instrument.TEM.Detector.EDS.real_time = 2.5
        s.metadata.Acquisition_instrument.TEM.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
        self.signal = s
Exemple #6
0
    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
Exemple #7
0
 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)
Exemple #8
0
 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)
Exemple #9
0
 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
Exemple #10
0
 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)
Exemple #11
0
 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 np.allclose(m.chisq(), 7.78966223)
Exemple #12
0
 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)
Exemple #13
0
 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)
Exemple #14
0
 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)
Exemple #15
0
 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 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
Exemple #17
0
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
Exemple #18
0
    def test_fit_component(self):
        m = self.model
        axis = self.axis

        g1 = Gaussian()
        m.append(g1)
        m.fit_component(g1, signal_range=(4000, 6000))
        np.testing.assert_allclose(self.g.function(axis),
                                   g1.function(axis),
                                   rtol=self.rtol,
                                   atol=10e-3)
 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
Exemple #20
0
    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()
Exemple #21
0
 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
     self.rtol = 0.00
Exemple #22
0
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
Exemple #23
0
 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
Exemple #24
0
    def test_multifit_ridge(self, weighted):
        pytest.importorskip("sklearn")
        m = self.m
        L = Gaussian(centre=15.)
        L.set_parameters_not_free(['centre', 'sigma'])
        m.append(L)

        if m.signal._lazy:
            with pytest.raises(ValueError):
                m.multifit(optimizer='ridge_regression')
            return
        else:
            m.multifit(optimizer='ridge_regression')
 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
Exemple #26
0
 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
Exemple #27
0
 def setup_method(self, method):
     # 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_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_fit_component(self, signal_range):
        m = self.model
        axis = self.axis
        g = self.g

        g1 = Gaussian()
        m.append(g1)
        cf = ComponentFit(m, g1, signal_range=signal_range)
        if signal_range == 'interactive':
            cf.ss_left_value, cf.ss_right_value = (4000, 6000)
        cf._fit_fired()
        np.testing.assert_allclose(g.function(axis),
                                   g1.function(axis),
                                   rtol=0.0,
                                   atol=10e-3)
Exemple #30
0
 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)
Exemple #31
0
 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
Exemple #32
0
 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
Exemple #33
0
    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)
Exemple #34
0
 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):
        s = Signal1D(np.random.random((2, 2, 8)))
        m = s.create_model()
        G = Gaussian()
        m.append(G)

        self.model = m
        self.G = G
Exemple #36
0
 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):
     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
Exemple #38
0
    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
Exemple #39
0
 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()
     np.testing.assert_allclose(m.red_chisq(), 1.55793245)
Exemple #40
0
    def setup_method(self, method):
        # TODO: actually finish setup+ tests
        self.shape = (5, 7)
        self.s = GlobalStrategy('test segmenter 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):
     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 = Signal1D(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
Exemple #42
0
    def setup_method(self, method):
        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 = Signal1D(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
Exemple #43
0
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