def __init__(self, element_subshell, GOS=None):
# Declare the parameters
Component.__init__(self, ["intensity", "fine_structure_coeff", "effective_angle", "onset_energy"])
self.name = element_subshell
self.element, self.subshell = element_subshell.split("_")
self.energy_scale = None
self.effective_angle.free = False
self.fine_structure_active = preferences.EELS.fine_structure_active
self.fine_structure_width = preferences.EELS.fine_structure_width
self.fine_structure_coeff.ext_force_positive = False
self.GOS = None
# Set initial actions
if GOS is None:
try:
self.GOS = HartreeSlaterGOS(element_subshell)
GOS = "Hartree-Slater"
except IOError:
GOS = "hydrogenic"
messages.information("Hartree-Slater GOS not available" "Using hydrogenic GOS")
if self.GOS is None:
if GOS == "Hartree-Slater":
self.GOS = HartreeSlaterGOS(element_subshell)
elif GOS == "hydrogenic":
self.GOS = HydrogenicGOS(element_subshell)
else:
raise ValueError("gos must be one of: None, 'hydrogenic'" " or 'Hartree-Slater'")
self.onset_energy.value = self.GOS.onset_energy
self.onset_energy.free = False
self._position = self.onset_energy
self.free_onset_energy = False
self.intensity.grad = self.grad_intensity
self.intensity.value = 1
self.intensity.bmin = 0.0
self.intensity.bmax = None
def __init__(
self,
electron_diffraction_calculator,
structure,
calibration,
reciprocal_radius,
d11=1.0,
d12=0.0,
d13=0.0,
d21=0.0,
d22=1.0,
d23=0.0,
d31=0.0,
d32=0.0,
d33=1.0,
):
Component.__init__(
self,
["d11", "d12", "d13", "d21", "d22", "d23", "d31", "d32", "d33"])
self.electron_diffraction_calculator = electron_diffraction_calculator
self.structure = structure
self.reciprocal_radius = reciprocal_radius
self.calibration = calibration
self.d11.value = d11
self.d12.value = d12
self.d13.value = d13
self.d21.value = d21
self.d22.value = d22
self.d23.value = d23
self.d31.value = d31
self.d32.value = d32
self.d33.value = d33
def __init__(self, A=1., FWHM=1., origin=0.):
Component.__init__(self, ['A', 'FWHM', 'origin', 'ab', 'shirley'])
self.shirley.free = False
self.ab.value = 0
self.ab.free = False
self.A.value = A
self.FWHM.value = FWHM
self.origin.value = origin
self._position = self.origin
# Boundaries
self.A.bmin = 0.
self.A.bmax = None
self.FWHM.bmin = None
self.FWHM.bmax = None
self.isbackground = False
self.convolved = True
# Gradients
self.A.grad = self.grad_A
self.FWHM.grad = self.grad_FWHM
self.origin.grad = self.grad_origin
self.ab.grad = self.grad_ab
# Options
self.factor = 1.
self.Shirley = False
def __init__(
self,
A=10e5,
r=3.,
origin=0.,
):
Component.__init__(self, ('A', 'r', 'origin', 'shift', 'ratio'))
self.name = 'Double power law'
self.A.value = 1E-5
self.r.value = 3.
self.origin.value = 0.
self.origin.free = False
self.shift.value = 20.
self.shift.free = False
self.ratio.value = 1.E-2
self.left_cutoff = 20. # in x-units
# Boundaries
self.A.bmin = 0.
self.A.bmax = None
self.r.bmin = 1.
self.r.bmax = 5.
self.isbackground = True
self.convolved = False
def __init__(self):
Component.__init__(
self,
(
"area",
"centre",
"FWHM",
"gamma",
"resolution",
"shirley_background",
"non_isochromaticity",
"transmission_function",
),
)
self._position = self.centre
self.FWHM.value = 1
self.gamma.value = 0
self.area.value = 1
self.resolution.value = 0
self.resolution.free = False
self.shirley_background.free = False
self.non_isochromaticity.value = 0
self.non_isochromaticity.free = False
self.transmission_function.value = 1
self.transmission_function.free = False
# Options
self.shirley_background.active = False
self.spin_orbit_splitting = False
self.spin_orbit_branching_ratio = 0.5
self.spin_orbit_splitting_energy = 0.61
self.isbackground = False
self.convolved = True
def __init__(self):
Component.__init__(self, (
'area',
'centre',
'FWHM',
'gamma',
'resolution',
'shirley_background',
'non_isochromaticity',
'transmission_function'))
self._position = self.centre
self.FWHM.value = 1
self.gamma.value = 0
self.area.value = 1
self.resolution.value = 0
self.resolution.free = False
self.shirley_background.free = False
self.non_isochromaticity.value = 0
self.non_isochromaticity.free = False
self.transmission_function.value = 1
self.transmission_function.free = False
# Options
self.shirley_background.active = False
self.spin_orbit_splitting = False
self.spin_orbit_branching_ratio = 0.5
self.spin_orbit_splitting_energy = 0.61
self.isbackground = False
self.convolved = True
def __init__(self, A=1., FWHM=1.,origin = 0.):
Component.__init__(self, ['A', 'FWHM', 'origin', 'ab', 'shirley'])
self.name = 'Gaussian for PE'
self.shirley.free = False
self.ab.value = 0
self.ab.free = False
self.A.value = A
self.FWHM.value = FWHM
self.origin.value = origin
# Boundaries
self.A.bmin = 0.
self.A.bmax = None
self.FWHM.bmin = None
self.FWHM.bmax = None
self.isbackground = False
self.convolved = True
# Gradients
self.A.grad = self.grad_A
self.FWHM.grad = self.grad_FWHM
self.origin.grad = self.grad_origin
self.ab.grad = self.grad_ab
# Options
self.factor = 1.
self.Shirley = False
def __init__(self, order=2):
Component.__init__(self, [
'coefficients',
])
self.coefficients._number_of_elements = order + 1
self.coefficients.value = np.zeros((order + 1, ))
self.coefficients.grad = self.grad_coefficients
def __init__(self, order=2, legacy=True, module="numexpr", **kwargs):
"""Polynomial component (DEPRECATED)
This API is deprecated and will be replaced by
:py:class:`hyperspy._components.polynomial.Polynomial` in HyperSpy v2.0.
To use the new API, set `legacy` to `False`.
Parameters
----------
order: int
Order of the polynomial.
legacy: bool, default True
If `False`, use the new API.
module: str
See the docstring
of :py:class:`hyperspy._components.polynomial.Polynomial`
for details.
"""
if legacy:
from hyperspy.misc.utils import deprecation_warning
msg = (
"The API of the `Polynomial` component will change in v2.0."
"To use the new API set `legacy=False`.")
deprecation_warning(msg)
Component.__init__(self, ['coefficients', ])
self._whitelist['order'] = ('init', order)
self.coefficients._number_of_elements = order + 1
self.coefficients.value = np.zeros((order + 1,))
self.coefficients.grad = self.grad_coefficients
else:
from hyperspy._components.polynomial import Polynomial
self.__class__ = Polynomial
self.__init__(order=order, module=module, **kwargs)
def test_load_dictionary(self):
c = self.comp
c.par1.twin_function_expr = "x + 2"
c.par2.twin_function_expr = "x - 2"
d = c.as_dictionary(True)
n = Component(self.parameter_names)
n._id_name = 'dummy names yay!'
_ = n._load_dictionary(d)
assert c.name == n.name
assert c.active == n.active
assert (
c.active_is_multidimensional ==
n.active_is_multidimensional)
for pn, pc in zip(n.parameters, c.parameters):
rn = np.random.random()
assert pn.twin_function(rn) == pc.twin_function(rn)
assert (
pn.twin_inverse_function(rn) ==
pc.twin_inverse_function(rn))
dn = pn.as_dictionary()
del dn['self']
dc = pc.as_dictionary()
del dc['self']
print(list(dn.keys()))
print(list(dc.keys()))
assert dn == dc
def test_invalid_parameter_name(self):
c = self.comp
d = c.as_dictionary()
n = Component([a + 's' for a in self.parameter_names])
n._id_name = 'dummy names yay!'
with pytest.raises(ValueError):
id_dict = n._load_dictionary(d)
def __init__(self, parameter_1=1, parameter_2=2):
# Define the parameters
Component.__init__(self, ('parameter_1', 'parameter_2'))
# Optionally we can set the initial values
self.parameter_1.value = parameter_1
self.parameter_1.value = parameter_1
# The units (optional)
self.parameter_1.units = 'Tesla'
self.parameter_2.units = 'Kociak'
# Once defined we can give default values to the attribute
# For example we fix the attribure_1 (optional)
self.parameter_1.free = False
# And we set the boundaries (optional)
self.parameter_1.bmin = 0.
self.parameter_1.bmax = None
# Optionally, to boost the optimization speed we can also define
# the gradients of the function we the syntax:
# self.parameter.grad = function
self.parameter_1.grad = self.grad_parameter_1
self.parameter_2.grad = self.grad_parameter_2
def __init__(self, A=1., FWHM=1., origin=0., ab=0.0, shirley=0.0):
Component.__init__(self, ['A', 'FWHM', 'origin', 'ab', 'shirley'])
self.ab.value = 0
self.ab.free = False
self.A.value = A
self.FWHM.value = FWHM
self.origin.value = origin
self._position = self.origin
# Boundaries
self.A.bmin = 0.
self.A.bmax = None
self.FWHM.bmin = None
self.FWHM.bmax = None
self.isbackground = False
self.convolved = True
# Gradients
self.A.grad = self.grad_A
self.FWHM.grad = self.grad_FWHM
self.origin.grad = self.grad_origin
self.ab.grad = self.grad_ab
# Options
self.Shirley = False
self._whitelist['Shirley'] = None
def test_load_dictionary(self):
c = self.comp
d = c.as_dictionary(True)
n = Component(self.parameter_names)
n._id_name = 'dummy names yay!'
_ = n._load_dictionary(d)
nt.assert_equal(c.name, n.name)
nt.assert_equal(c.active, n.active)
nt.assert_equal(
c.active_is_multidimensional,
n.active_is_multidimensional)
for pn, pc in zip(n.parameters, c.parameters):
rn = np.random.random()
nt.assert_equal(pn.twin_function(rn), pc.twin_function(rn))
nt.assert_equal(
pn.twin_inverse_function(rn),
pc.twin_inverse_function(rn))
dn = pn.as_dictionary()
del dn['self']
del dn['twin_function']
del dn['twin_inverse_function']
dc = pc.as_dictionary()
del dc['self']
del dc['twin_function']
del dc['twin_inverse_function']
print(list(dn.keys()))
print(list(dc.keys()))
nt.assert_dict_equal(dn, dc)
def test_load_dictionary(self):
c = self.comp
d = c.as_dictionary(True)
n = Component(self.parameter_names)
n._id_name = 'dummy names yay!'
_ = n._load_dictionary(d)
nt.assert_equal(c.name, n.name)
nt.assert_equal(c.active, n.active)
nt.assert_equal(c.active_is_multidimensional,
n.active_is_multidimensional)
for pn, pc in zip(n.parameters, c.parameters):
rn = np.random.random()
nt.assert_equal(pn.twin_function(rn), pc.twin_function(rn))
nt.assert_equal(pn.twin_inverse_function(rn),
pc.twin_inverse_function(rn))
dn = pn.as_dictionary()
del dn['self']
del dn['twin_function']
del dn['twin_inverse_function']
dc = pc.as_dictionary()
del dc['self']
del dc['twin_function']
del dc['twin_inverse_function']
print(list(dn.keys()))
print(list(dc.keys()))
nt.assert_dict_equal(dn, dc)
def test_invalid_parameter_name(self):
c = self.comp
d = c.as_dictionary()
n = Component([a + 's' for a in self.parameter_names])
n._id_name = 'dummy names yay!'
with pytest.raises(ValueError):
id_dict = n._load_dictionary(d)
def test_load_dictionary(self):
c = self.comp
c.par1.twin_function_expr = "x + 2"
c.par2.twin_function_expr = "x - 2"
d = c.as_dictionary(True)
n = Component(self.parameter_names)
n._id_name = 'dummy names yay!'
_ = n._load_dictionary(d)
assert c.name == n.name
assert c.active == n.active
assert (c.active_is_multidimensional == n.active_is_multidimensional)
for pn, pc in zip(n.parameters, c.parameters):
rn = np.random.random()
assert pn.twin_function(rn) == pc.twin_function(rn)
assert (
pn.twin_inverse_function(rn) == pc.twin_inverse_function(rn))
dn = pn.as_dictionary()
del dn['self']
dc = pc.as_dictionary()
del dc['self']
print(list(dn.keys()))
print(list(dc.keys()))
assert dn == dc
def __init__(self):
Component.__init__(self, (
'area',
'centre',
'FWHM',
'gamma',
'resolution',
'shirley_background',
'non_isochromaticity',
'transmission_function'))
self._position = self.centre
self.FWHM.value = 1
self.gamma.value = 0
self.area.value = 1
self.resolution.value = 0
self.resolution.free = False
self.shirley_background.free = False
self.non_isochromaticity.value = 0
self.non_isochromaticity.free = False
self.transmission_function.value = 1
self.transmission_function.free = False
# Options
self.shirley_background.active = False
self.spin_orbit_splitting = False
self.spin_orbit_branching_ratio = 0.5
self.spin_orbit_splitting_energy = 0.61
self.isbackground = False
self.convolved = True
def __init__(self, element_subshell, GOS=None):
# Declare the parameters
Component.__init__(self, [
'intensity', 'fine_structure_coeff', 'effective_angle',
'onset_energy'
],
linear_parameter_list=['intensity'])
if isinstance(element_subshell, dict):
self.element = element_subshell['element']
self.subshell = element_subshell['subshell']
else:
self.element, self.subshell = element_subshell.split('_')
self.name = "_".join([self.element, self.subshell])
self.energy_scale = None
self.effective_angle.free = False
self.fine_structure_active = False
self.fine_structure_width = 30.
self.fine_structure_coeff.ext_force_positive = False
self.GOS = None
# Set initial actions
if GOS is None:
try:
self.GOS = HartreeSlaterGOS(element_subshell)
GOS = 'Hartree-Slater'
except IOError:
GOS = 'hydrogenic'
_logger.info('Hartree-Slater GOS not available. '
'Using hydrogenic GOS')
if self.GOS is None:
if GOS == 'Hartree-Slater':
self.GOS = HartreeSlaterGOS(element_subshell)
elif GOS == 'hydrogenic':
self.GOS = HydrogenicGOS(element_subshell)
else:
raise ValueError('gos must be one of: None, \'hydrogenic\''
' or \'Hartree-Slater\'')
self.onset_energy.value = self.GOS.onset_energy
self.onset_energy.free = False
self._position = self.onset_energy
self.free_onset_energy = False
self.intensity.grad = self.grad_intensity
self.intensity.value = 1
self.intensity.bmin = 0.
self.intensity.bmax = None
self._whitelist['GOS'] = ('init', GOS)
if GOS == 'Hartree-Slater':
self._whitelist['element_subshell'] = (
'init', self.GOS.as_dictionary(True))
elif GOS == 'hydrogenic':
self._whitelist['element_subshell'] = ('init', element_subshell)
self._whitelist['fine_structure_active'] = None
self._whitelist['fine_structure_width'] = None
self._whitelist['fine_structure_smoothing'] = None
self.effective_angle.events.value_changed.connect(
self._integrate_GOS, [])
self.onset_energy.events.value_changed.connect(self._integrate_GOS, [])
self.onset_energy.events.value_changed.connect(self._calculate_knots,
[])
def __init__(self):
# Define the parameters
Component.__init__(self, ('a', 'b', 'c', 'origin'))
# Define the name of the component
self.a.grad = self.grad_a
self.b.grad = self.grad_b
self.c.grad = self.grad_c
self.origin.grad = self.grad_origin
def __init__(self):
Component.__init__(self, ['intensity', 'plasmon_energy', 'fwhm'])
self._position = self.plasmon_energy
self.intensity.value = 1
self.plasmon_energy.value = 7.1
self.fwhm.value = 2.3
self.plasmon_energy.grad = self.grad_plasmon_energy
self.fwhm.grad = self.grad_fwhm
self.intensity.grad = self.grad_intensity
def __init__(self):
# Define the parameters
Component.__init__(self, ('a', 'b', 'c', 'origin'))
# Define the name of the component
self.a.grad = self.grad_a
self.b.grad = self.grad_b
self.c.grad = self.grad_c
self.origin.grad = self.grad_origin
self._position = self.origin
def __init__(self, element_subshell, GOS=None):
# Declare the parameters
Component.__init__(self,
['intensity',
'fine_structure_coeff',
'effective_angle',
'onset_energy'])
if isinstance(element_subshell, dict):
self.element = element_subshell['element']
self.subshell = element_subshell['subshell']
else:
self.element, self.subshell = element_subshell.split('_')
self.name = "_".join([self.element, self.subshell])
self.energy_scale = None
self.effective_angle.free = False
self.fine_structure_active = preferences.EELS.fine_structure_active
self.fine_structure_width = preferences.EELS.fine_structure_width
self.fine_structure_coeff.ext_force_positive = False
self.GOS = None
# Set initial actions
if GOS is None:
try:
self.GOS = HartreeSlaterGOS(element_subshell)
GOS = 'Hartree-Slater'
except IOError:
GOS = 'hydrogenic'
messages.information(
'Hartree-Slater GOS not available. '
'Using hydrogenic GOS')
if self.GOS is None:
if GOS == 'Hartree-Slater':
self.GOS = HartreeSlaterGOS(element_subshell)
elif GOS == 'hydrogenic':
self.GOS = HydrogenicGOS(element_subshell)
else:
raise ValueError(
'gos must be one of: None, \'hydrogenic\''
' or \'Hartree-Slater\'')
self.onset_energy.value = self.GOS.onset_energy
self.onset_energy.free = False
self._position = self.onset_energy
self.free_onset_energy = False
self.intensity.grad = self.grad_intensity
self.intensity.value = 1
self.intensity.bmin = 0.
self.intensity.bmax = None
self._whitelist['GOS'] = ('init', GOS)
if GOS == 'Hartree-Slater':
self._whitelist['element_subshell'] = (
'init',
self.GOS.as_dictionary(True))
elif GOS == 'hydrogenic':
self._whitelist['element_subshell'] = ('init', element_subshell)
self._whitelist['fine_structure_active'] = None
self._whitelist['fine_structure_width'] = None
self._whitelist['fine_structure_smoothing'] = None
def __init__(self):
# Define the parameters
Component.__init__(self, ("a", "b", "c", "origin"))
# Define the name of the component
self.a.grad = self.grad_a
self.b.grad = self.grad_b
self.c.grad = self.grad_c
self.origin.grad = self.grad_origin
self._position = self.origin
def __init__(self, intensity=1., plasmon_energy=15., fwhm=1.5):
Component.__init__(self, ['intensity', 'plasmon_energy', 'fwhm'])
self._position = self.plasmon_energy
self.intensity.value = intensity
self.plasmon_energy.value = plasmon_energy
self.fwhm.value = fwhm
self.plasmon_energy.grad = self.grad_plasmon_energy
self.fwhm.grad = self.grad_fwhm
self.intensity.grad = self.grad_intensity
def __init__(self, origin=0, A=1, sigma=1):
# Define the parameters
Component.__init__(self, ('origin', 'A', 'sigma'))
#self.name = 'Erf'
# Optionally we can set the initial values
self.origin.value = origin
self.A.value = A
self.sigma.value = sigma
def __init__(self, A=1, n=0):
Component.__init__(self, ("n", "A"))
self.A.value = A
self.n.value = n
self.isbackground = True
self.convolved = False
# Gradients
self.A.grad = self.grad_A
self.n.grad = self.grad_n
def __init__(self):
Component.__init__(self, ('offset', 'step'))
self.isbackground = True
self.convolved = False
# Options
self.interfase = 0
# Gradients
self.offset.grad = self.grad_offset
self.step.grad = self.grad_step
def __init__(self):
Component.__init__(self, ['intensity', 'plasmon_energy',
'plasmon_linewidth'])
self._position = self.plasmon_energy
self.intensity.value = 1
self.plasmon_energy.value = 7.1
self.plasmon_linewidth.value = 2.3
self.plasmon_energy.grad = self.grad_plasmon_energy
self.plasmon_linewidth.grad = self.grad_plasmon_linewidth
self.intensity.grad = self.grad_intensity
def __init__(self, a=0, b=1., c=1., origin=0):
Component.__init__(self, ['a', 'b', 'c', 'origin'])
self.name = 'Parabole'
self.a.value, self.b.value, self.c.value, self.origin.value = \
a, b, c, origin
self.isbackground = False
self.convolved = True
self.a.grad = self.grad_a
self.b.grad = self.grad_b
self.origin.grad = self.grad_origin
def __init__( self, offset = 0. ):
Component.__init__(self, ('offset',))
self.offset.free = True
self.offset.value = offset
self.isbackground = True
self.convolved = False
# Gradients
self.offset.grad = self.grad_offset
def __init__(self, A=1, n=0):
Component.__init__(self, ('n', 'A'))
self.A.value = A
self.n.value = n
self.isbackground = True
self.convolved = False
# Gradients
self.A.grad = self.grad_A
self.n.grad = self.grad_n
def __init__(self, offset=0.):
Component.__init__(self, ('offset',))
self.offset.free = True
self.offset.value = offset
self.isbackground = True
self.convolved = False
# Gradients
self.offset.grad = self.grad_offset
def __init__(self):
Component.__init__(self, ['intensity', 'plasmon_energy',
'fwhm'])
self._position = self.plasmon_energy
self.intensity.value = 1
self.plasmon_energy.value = 7.1
self.fwhm.value = 2.3
self.plasmon_energy.grad = self.grad_plasmon_energy
self.fwhm.grad = self.grad_fwhm
self.intensity.grad = self.grad_intensity
def __init__(self, intensity=1., plasmon_energy=15., fwhm=1.5):
Component.__init__(self, ['intensity', 'plasmon_energy',
'fwhm'])
self._position = self.plasmon_energy
self.intensity.value = intensity
self.plasmon_energy.value = plasmon_energy
self.fwhm.value = fwhm
self.plasmon_energy.grad = self.grad_plasmon_energy
self.fwhm.grad = self.grad_fwhm
self.intensity.grad = self.grad_intensity
def __init__(self):
Component.__init__(self, ('offset', 'step'))
self.isbackground = True
self.convolved = False
# Options
self.interfase = 0
# Gradients
self.offset.grad = self.grad_offset
self.step.grad = self.grad_step
def __init__(self):
Component.__init__(
self, ['intensity', 'plasmon_energy', 'plasmon_linewidth'])
self._position = self.plasmon_energy
self.intensity.value = 1
self.plasmon_energy.value = 7.1
self.plasmon_linewidth.value = 2.3
self.plasmon_energy.grad = self.grad_plasmon_energy
self.plasmon_linewidth.grad = self.grad_plasmon_linewidth
self.intensity.grad = self.grad_intensity
def __init__( self, a = 0, b = 1 ):
Component.__init__(self, ['a','b'])
self.name = 'Line'
self.a.free, self.b.free = True, True
self.a.value, self.b.value = a, b
self.isbackground = True
self.convolved = False
self.a.grad = self.grad_a
self.b.grad = self.grad_b
self.start_from = None
def setup_method(self, method):
self.parameter_names = ['par1', 'par2']
self.comp = Component(self.parameter_names)
self.comp.name = 'newname!'
self.comp._id_name = 'dummy names yay!'
self.comp._axes_manager = DummyAxesManager()
self.comp._create_arrays()
self.comp.par1.value = 2.
self.comp.par2.value = 5.
self.comp.par1.std = 0.2
self.comp.par2.std = 0.5
self.comp.store_current_parameters_in_map()
def __init__(self):
Component.__init__(self, ['optical_center', 'height', 'period',
'left_slope', 'right_slope', 'left', 'right', 'sigma'])
self.left.value = np.nan
self.right.value = np.nan
self.side_vignetting = False
self.fix_side_vignetting()
self.gaussian = Gaussian()
self.gaussian.origin.free, self.gaussian.A.free = False, False
self.sigma.value = 1.
self.gaussian.A.value = 1.
self.extension_nch = 100
def __init__(self):
Component.__init__(self, ['optical_center', 'height', 'period',
'left_slope', 'right_slope', 'left', 'right', 'sigma'])
self.left.value = np.nan
self.right.value = np.nan
self.side_vignetting = False
self.fix_side_vignetting()
self.gaussian = Gaussian()
self.gaussian.origin.free, self.gaussian.A.free = False, False
self.sigma.value = 1.
self.gaussian.A.value = 1.
self.extension_nch = 100
self._position = self.optical_center
def __init__( self, array=None ):
Component.__init__(self, ['intensity', 'origin'])
self.name = 'Fixed pattern'
self.array = array
self.intensity.free = True
self.intensity.value = 1.
self.origin.value = 0
self.origin.free = False
self.isbackground = True
self.convolved = False
self.intensity.grad = self.grad_intensity
self.interpolate = False
self._interpolation_ready = False
def __init__(self, array=None):
Component.__init__(self, ['intensity', 'origin'])
self.name = 'Fixed pattern'
self.array = array
self.intensity.free = True
self.intensity.value = 1.
self.origin.value = 0
self.origin.free = False
self.isbackground = True
self.convolved = False
self.intensity.grad = self.grad_intensity
self.interpolate = False
self._interpolation_ready = False
def test_update_number_free_parameters():
c = Component(['one', 'two', 'three'])
c.one.free = False
c.two.free = True
c.three.free = True
c.two._number_of_elements = 2
c.three._number_of_elements = 3
c._nfree_param = 0
c._update_free_parameters()
assert c._nfree_param == 5
# check that only the correct parameters are in the list _AND_ the list is
# name-ordered
assert [c.three, c.two] == c.free_parameters
def test_update_number_free_parameters():
c = Component(['one', 'two', 'three'])
c.one.free = False
c.two.free = True
c.three.free = True
c.two._number_of_elements = 2
c.three._number_of_elements = 3
c._nfree_param = 0
c._update_free_parameters()
nt.assert_equal(c._nfree_param, 5)
# check that only the correct parameters are in the list _AND_ the list is
# name-ordered
nt.assert_equal([c.three, c.two], c.free_parameters)
def __init__(self, A=1. , k=1. , x0=1.):
Component.__init__(self, ['A', 'k', 'x0'])
self.A.value = A
self.A.grad = self.grad_A
self.k.value = k
self.k.grad = self.grad_k
self.x0.value = x0
self.x0.grad = self.grad_x0
self.isbackground = False
self.isconvolved = False
self._position = self.x0
def __init__(self, elements, fracs, N=1.0, C=0.0):
"""
A scattering component to fit background atomic scattering.
Calculates the sum of the squares sum_squares = sum (ci * fi**2 )
and the square of the sum square_sum = (sum(ci * fi))**2
for atomic fraction ci with electron scattering factor fi.
The latter is used for normalisation.
N and C are fitting parameters for the Component class.
The fitted function f is of the form:
f = sum(fi), fi = ai(2 + bi*g^2) / (1 + bi*g^2)^2
where 1 < i < 5, ai, and bi are tabulated constants, and
g = 1/d = 2sin(theta)/lambda is the scattering vector magnitude.
The factors are tabulated in ATOMIC_SCATTERING_PARAMS_LOBATO.
The parametrisation is detailed in [1].
Parameters
----------
elements: list of str
A list of elements present (by symbol).
fracs: list of float
A list of fraction of the respective elements. Should sum to 1.
N : float
The "slope" of the fit.
C : float
An additive constant to the fit.
References
----------
[1] Lobato, I., & Van Dyck, D. (2014). An accurate parameterization for
scattering factors, electron densities and electrostatic potentials for
neutral atoms that obey all physical constraints. Acta Crystallographica
Section A: Foundations and Advances, 70(6), 636-649.
"""
Component.__init__(self, ["N", "C"])
self._whitelist["elements"] = ("init,sig", elements)
self._whitelist["fracs"] = ("init,sig", fracs)
self.elements = elements
self.fracs = fracs
params = []
for e in elements:
params.append(ATOMIC_SCATTERING_PARAMS_LOBATO[e])
self.params = params
self.N.value = N
self.C.value = C
def __init__(self, element_subshell, GOS=None):
# Declare the parameters
Component.__init__(self, ["intensity", "fine_structure_coeff", "effective_angle", "onset_energy"])
if isinstance(element_subshell, dict):
self.element = element_subshell["element"]
self.subshell = element_subshell["subshell"]
else:
self.element, self.subshell = element_subshell.split("_")
self.name = "_".join([self.element, self.subshell])
self.energy_scale = None
self.effective_angle.free = False
self.fine_structure_active = preferences.EELS.fine_structure_active
self.fine_structure_width = preferences.EELS.fine_structure_width
self.fine_structure_coeff.ext_force_positive = False
self.GOS = None
# Set initial actions
if GOS is None:
try:
self.GOS = HartreeSlaterGOS(element_subshell)
GOS = "Hartree-Slater"
except IOError:
GOS = "hydrogenic"
messages.information("Hartree-Slater GOS not available. " "Using hydrogenic GOS")
if self.GOS is None:
if GOS == "Hartree-Slater":
self.GOS = HartreeSlaterGOS(element_subshell)
elif GOS == "hydrogenic":
self.GOS = HydrogenicGOS(element_subshell)
else:
raise ValueError("gos must be one of: None, 'hydrogenic'" " or 'Hartree-Slater'")
self.onset_energy.value = self.GOS.onset_energy
self.onset_energy.free = False
self._position = self.onset_energy
self.free_onset_energy = False
self.intensity.grad = self.grad_intensity
self.intensity.value = 1
self.intensity.bmin = 0.0
self.intensity.bmax = None
self._whitelist["GOS"] = ("init", GOS)
if GOS == "Hartree-Slater":
self._whitelist["element_subshell"] = ("init", self.GOS.as_dictionary(True))
elif GOS == "hydrogenic":
self._whitelist["element_subshell"] = ("init", element_subshell)
self._whitelist["fine_structure_active"] = None
self._whitelist["fine_structure_width"] = None
self._whitelist["fine_structure_smoothing"] = None
self.effective_angle.events.value_changed.connect(self._integrate_GOS, [])
self.onset_energy.events.value_changed.connect(self._integrate_GOS, [])
self.onset_energy.events.value_changed.connect(self._calculate_knots, [])
def test_component():
c = Component(["a", "b"])
c.a.value = 3
c.b.value = 2
c.active = False
wd = c.gui(**KWARGS)["ipywidgets"]["wdict"]
assert wd["active"].value == c.active
assert wd["parameter_a"]["value"].value == c.a.value
assert wd["parameter_b"]["value"].value == c.b.value
wd["active"].value = True
wd["parameter_b"]["value"].value = 34
wd["parameter_a"]["value"].value = 31
assert wd["active"].value == c.active
assert wd["parameter_a"]["value"].value == c.a.value
assert wd["parameter_b"]["value"].value == c.b.value
def __init__(self, zl):
Component.__init__(self, ['intensity', 'xscale', 'origin', 'offset'])
self.name = 'ResizebleFixedPattern'
self.zl = zl
self.intensity.free = True
self.intensity.value = 1.
self.xscale.value = 1.
self.offset.value = 0.
self.origin.value = 0.
# Options
self.isbackground = True
self.convolved = False
# self.intensity.grad = self.grad_intensity
self.f = interp1d(zl.energy_axis, zl.data_cube.squeeze(),
bounds_error = False, fill_value = 0.)
def __init__(self, spectrum):
Component.__init__(self, ['yscale', 'xscale', 'shift', 'offset'])
self.spectrum = spectrum
self.yscale.free = True
self.yscale.value = 1.
self.xscale.value = 1.
self.offset.value = 0.
self.shift.value = 0.
self.prepare_interpolator()
# Options
self.isbackground = True
self.convolved = False
self.interpolate = True
def __init__(self, A=10e5, r=3.0, origin=0.0):
Component.__init__(self, ("A", "r", "origin"))
self.A.value = A
self.r.value = r
self.origin.value = origin
self.origin.free = False
self.left_cutoff = 0.0
# Boundaries
self.A.bmin = 0.0
self.A.bmax = None
self.r.bmin = 1.0
self.r.bmax = 5.0
self.isbackground = True
self.convolved = False
def __init__(self, A=10e5, r=3., origin=0.):
Component.__init__(self, ('A', 'r', 'origin'))
self.A.value = A
self.r.value = r
self.origin.value = origin
self.origin.free = False
self.left_cutoff = 0.
# Boundaries
self.A.bmin = 0.
self.A.bmax = None
self.r.bmin = 1.
self.r.bmax = 5.
self.isbackground = True
self.convolved = False
def __init__(self, A=1., k=1., x0=1., minimum_at_zero=False):
Component.__init__(self, ['A', 'k', 'x0'])
self.A.value = A
self.A.grad = self.grad_A
self.k.value = k
self.k.grad = self.grad_k
self.x0.value = x0
self.x0.grad = self.grad_x0
self.minimum_at_zero = minimum_at_zero
self.isbackground = False
self.isconvolved = False
self._position = self.x0
def __init__(self, A=10e5, r=3., origin=0.):
Component.__init__(self, ('A', 'r', 'origin'))
self.A.value = A
self.r.value = r
self.origin.value = origin
self.origin.free = False
self.left_cutoff = 0.
# Boundaries
self.A.bmin = 0.
self.A.bmax = None
self.r.bmin = 1.
self.r.bmax = 5.
self.isbackground = True
self.convolved = False
def __init__(self, spectrum):
Component.__init__(self, ['yscale', 'xscale', 'shift'])
self._position = self.shift
self._whitelist['spectrum'] = ('init,sig', spectrum)
self.spectrum = spectrum
self.yscale.free = True
self.yscale.value = 1.
self.xscale.value = 1.
self.shift.value = 0.
self.prepare_interpolator()
# Options
self.isbackground = True
self.convolved = False
self.interpolate = True
def __init__(self, A=1., k=1., x0=1., minimum_at_zero=False):
Component.__init__(self, ['A', 'k', 'x0'])
self.A.value = A
self.A.grad = self.grad_A
self.k.value = k
self.k.grad = self.grad_k
self.x0.value = x0
self.x0.grad = self.grad_x0
self.minimum_at_zero = minimum_at_zero
self._whitelist['minimum_at_zero'] = ('init', minimum_at_zero)
self.isbackground = False
self.isconvolved = False
self._position = self.x0
def __init__(self):
Component.__init__(self, ['A','sigma','origin'])
# Boundaries
self.A.bmin = 0.
self.A.bmax = None
self.sigma.bmin = None
self.sigma.bmax = None
self.isbackground = False
self.convolved = True
# Gradients
self.A.grad = self.grad_A
self.sigma.grad = self.grad_sigma
self.origin.grad = self.grad_origin
def __init__(self):
Component.__init__(self, ["A", "sigma", "origin"])
# Boundaries
self.A.bmin = 0.0
self.A.bmax = None
self.sigma.bmin = None
self.sigma.bmax = None
self.isbackground = False
self.convolved = True
# Gradients
self.A.grad = self.grad_A
self.sigma.grad = self.grad_sigma
self.origin.grad = self.grad_origin
self._position = self.origin
