pyTEMlib 0.2020.11.0__py3-none-any.whl → 0.2024.8.4__py3-none-any.whl

pyTEMlib/sidpy_tools.py

@@ -1,129 +1,153 @@
-
-import numpy as np
-import sidpy
-
-from PyQt5 import QtWidgets, QtCore
-
-class ProgressDialog(QtWidgets.QDialog):
-    """
-    Simple dialog that consists of a Progress Bar and a Button.
-    Clicking on the button results in the start of a timer and
-    updates the progress bar.
-    """
-
-    def __init__(self, title='Progress', number_of_counts=100):
-        super().__init__()
-        self.setWindowTitle(title)
-        self.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
-
-        self.progress = QtWidgets.QProgressBar(self)
-        self.progress.setGeometry(10, 10, 500, 50)
-        self.progress.setMaximum(number_of_counts)
-        self.show()
-
-    def set_value(self, count):
-        self.progress.setValue(count)
-        QtWidgets.QApplication.processEvents()
-
-class ChooseDataset(object):
-    def __init__(self, input_object):
-        if isinstance(input_object, sidpy.Dataset):
-            if isinstance(input_object.h5_dataset, h5py.Dataset):
-                self.current_channel = input_object.h5_dataset.parent
-        elif isinstance(input_object, h5py.Group):
-            self.current_channel = input_object
-        elif isinstance(input_object, h5py.Dataset):
-            self.current_channel = input_object.parent
-        else:
-            raise ValueError('Need hdf5 group or sidpy Dataset to determine image choices')
-        self.dataset_names = []
-        self.dataset_list = []
-        self.dataset_type = None
-        self.dataset = None
-        self.reader = NSIDReader(self.current_channel)
-
-        self.get_dataset_list()
-        self.select_image = widgets.Dropdown(options=self.dataset_names,
-                                             value=self.dataset_names[0],
-                                             description='Select image:',
-                                             disabled=False,
-                                             button_style='')
-        display(self.select_image)
-
-        self.select_image.observe(self.set_dataset, names='value')
-        self.set_dataset(0)
-        self.select_image.index = (len(self.dataset_names) - 1)
-
-    def get_dataset_list(self):
-        datasets = self.reader.read()
-        for dset in datasets[::-1]:
-            if self.dataset_type is None:
-                self.dataset_names.append('/'.join(dset.title.replace('-', '_').split('/')[-2:]))
-                self.dataset_list.append(dset)
-            else:
-                if dset.data_type == self.data_type:
-                    self.dataset_names.append('/'.join(dset.title.replace('-', '_').split('/')[-2:]))
-                    self.dataset_list.append(dset)
-
-    def set_dataset(self, b):
-        index = self.select_image.index
-        self.dataset = self.dataset_list[index]
-
-
-
-def get_dimensions_by_order(dims_in, dataset):
-    if isinstance(dims_in, int):
-        dims_in = [dims_in]
-    dims_out = []
-    for item in dims_in:
-        if isinstance(item, int):
-            if item in dataset._axes:
-                dims_out.append([item, dataset._axes[item]])
-    return dims_out
-
-
-def get_dimensions_by_type(dims_in, dataset):
-    if isinstance(dims_in, (str, sidpy.DimensionTypes)):
-        dims_in = [dims_in]
-    for i in range(len(dims_in)):
-        if isinstance(dims_in[i], str):
-            dims_in[i] = sidpy.DimensionTypes[dims_in[i].upper()]
-    dims_out = []
-    for dim, axis in dataset._axes.items():
-        if axis.dimension_type in dims_in:
-            dims_out.append([dim, dataset._axes[dim]])
-    return dims_out
-
-
-def make_dummy_dataset(value_type):
-    assert isinstance(value_type, sidpy.DataTypes)
-    if type == sidpy.DataTypes.SPECTRUM:
-        dataset = sidpy.Dataset.from_array(np.arange(100))
-        dataset.data_type = 'spectrum'
-        dataset.units = 'counts'
-        dataset.quantity = 'intensity'
-
-        dataset.set_dimension(0, sidpy.Dimension(np.arange(dataset.shape[0]) + 70, name='energy_scale'))
-        dataset.dim_0.dimension_type = 'spectral'
-        dataset.dim_0.units = 'eV'
-        dataset.dim_0.quantity = 'energy loss'
-    else:
-        raise NotImplementedError('not implemented')
-    return dataset
-
-
-def plot(dataset):
-    dataset.plot()
-
-
-def get_image_dims(dataset):
-    image_dims = []
-    for dim, axis in dataset._axes.items():
-        if axis.dimension_type == sidpy.DimensionTypes.SPATIAL:
-            image_dims.append(dim)
-    return image_dims
-
-
-def get_extent(dataset):
-    image_dims = get_image_dims(dataset)
-    return dataset.get_extent(image_dims)
+"""utility functions for sidpy; will move to sidpy"""
+import numpy as np
+import sidpy
+import h5py
+import pyNSID
+import os
+import ipywidgets as widgets
+from IPython.display import display
+import json
+
+
+class ChooseDataset(object):
+    """Widget to select dataset object """
+
+    def __init__(self, input_object, show_dialog=True):
+        if isinstance(input_object, sidpy.Dataset):
+            if isinstance(input_object.h5_dataset, h5py.Dataset):
+                self.current_channel = input_object.h5_dataset.parent
+        elif isinstance(input_object, h5py.Group):
+            self.current_channel = input_object
+        elif isinstance(input_object, h5py.Dataset):
+            self.current_channel = input_object.parent
+        else:
+            raise ValueError('Need hdf5 group or sidpy Dataset to determine image choices')
+        self.dataset_names = []
+        self.dataset_list = []
+        self.dataset_type = None
+        self.dataset = None
+        self.reader = pyNSID.NSIDReader(self.current_channel.file.filename)
+
+        self.get_dataset_list()
+        self.select_image = widgets.Dropdown(options=self.dataset_names,
+                                             value=self.dataset_names[0],
+                                             description='select dataset:',
+                                             disabled=False,
+                                             button_style='')
+        if show_dialog:
+            display(self.select_image)
+
+        self.select_image.observe(self.set_dataset, names='value')
+        self.set_dataset(0)
+        self.select_image.index = (len(self.dataset_names) - 1)
+
+    def get_dataset_list(self):
+        """ Get by Log number sorted list of datasets"""
+        datasets = self.reader.read()
+        order = []
+        for dset in datasets:
+            if self.dataset_type is None or dset.data_type == self.data_type:
+                if 'Log' in dset.title:
+                    position = dset.title.find('Log_') + 4
+                    order.append(int(dset.title[position:position + 3])+1)
+                else:
+                    order.append(0)
+        for index in np.argsort(order):
+            dset = datasets[index]
+            self.dataset_names.append('/'.join(dset.title.replace('-', '_').split('/')[-1:]))
+            self.dataset_list.append(dset)
+
+    def set_dataset(self, b):
+        index = self.select_image.index
+        self.dataset = self.dataset_list[index]
+        # Find
+        self.dataset.title = self.dataset.title.split('/')[-1]
+
+
+def get_dimensions_by_order(dims_in, dataset):
+    """get dimension
+
+    Parameters
+    ----------
+    dims_in: int or list of int
+        the dimensions by numerical order
+    dataset: sidpy.Dataset
+
+    Returns
+    -------
+    dims_out: list of dimensions
+    """
+
+    if isinstance(dims_in, int):
+        dims_in = [dims_in]
+    dims_out = []
+    for item in dims_in:
+        if isinstance(item, int):
+            if item in dataset._axes:
+                dims_out.append([item, dataset._axes[item]])
+    return dims_out
+
+
+def get_dimensions_by_type(dims_in, dataset):
+    """ get dimension by dimension_type name
+
+    Parameters
+    ----------
+    dims_in: dimension_type or list of dimension_types
+        the dimensions by numerical order
+    dataset: sidpy.Dataset
+
+    Returns
+    -------
+    dims_out: list of dimensions
+    """
+
+    if isinstance(dims_in, (str, sidpy.DimensionType)):
+        dims_in = [dims_in]
+    for i in range(len(dims_in)):
+        if isinstance(dims_in[i], str):
+            dims_in[i] = sidpy.DimensionType[dims_in[i].upper()]
+    dims_out = []
+    for dim, axis in dataset._axes.items():
+        if axis.dimension_type in dims_in:
+            dims_out.append([dim, dataset._axes[dim]])
+    return dims_out
+
+
+def make_dummy_dataset(value_type):
+    """Make a dummy sidpy.Dataset """
+
+    assert isinstance(value_type, sidpy.DataType)
+    if type == sidpy.DataType.SPECTRUM:
+        dataset = sidpy.Dataset.from_array(np.arange(100))
+        dataset.data_type = 'spectrum'
+        dataset.units = 'counts'
+        dataset.quantity = 'intensity'
+
+        dataset.set_dimension(0, sidpy.Dimension(np.arange(dataset.shape[0]) + 70, name='energy_scale'))
+        dataset.dim_0.dimension_type = 'spectral'
+        dataset.dim_0.units = 'eV'
+        dataset.dim_0.quantity = 'energy loss'
+    else:
+        raise NotImplementedError('not implemented')
+    return dataset
+
+
+def plot(dataset):
+    dataset.plot()
+
+
+def get_image_dims(dataset):
+    """Get all spatial dimensions"""
+
+    image_dims = []
+    for dim, axis in dataset._axes.items():
+        if axis.dimension_type == sidpy.DimensionType.SPATIAL:
+            image_dims.append(dim)
+    return image_dims
+
+
+def get_extent(dataset):
+    """get extent to plot with matplotlib"""
+    image_dims = get_image_dims(dataset)
+    return dataset.get_extent(image_dims)

pyTEMlib/simulation_tools.py

@@ -1,87 +1,104 @@
-###################################################################
-# Part of pyTEMlib
-# by Gerd Duscher
-# created 10/29/2020
-####################################################################
-
-####################################################################
-# Supports the conversion of DFT data to simulated EELS spectra
-#
-# - exciting_get_spectra:  importing dielectric function from the exciting program
-# - final_state_broadening: apply final state broadening to loss-spectra
-#
-####################################################################
-
-import numpy as np
-from lxml import etree
-
-
-def exciting_get_spectra(file):
-    
-    tags = {'data': {}}
-
-    tree = etree.ElementTree(file=file)
-    root = tree.getroot()
-    
-    data = tags['data'] 
-
-    if root.tag in ['loss', 'dielectric']:  
-        print(' reading ', root.tag, ' function from file ', file)
-        # print(root[0].tag, root[0].text)
-        map_def = root[0]
-        i = 0
-        v = {}
-        for child_of_root in map_def:
-            data[child_of_root.tag] = child_of_root.attrib
-            v[child_of_root.tag] = []
-            i += 1
-        
-        for elem in tree.iter(tag='map'):
-            m_dict = elem.attrib
-            for key in m_dict:
-                v[key].append(float(m_dict[key]))
-        
-        for key in data:
-            data[key]['data'] = np.array(v[key])
-        data['type'] = root.tag+' function'
-    
-        return tags
-
-
-def final_state_broadening(x, y, start, instrument):
-    # Getting the smearing
-    a_i = 107.25*5
-    b_i = 0.04688*2.
-    x = np.array(x)-start
-    zero = int(-x[0]/(x[1]-x[0]))+1
-    smear_i = x*0.0
-    smear_i[zero:-1] = (a_i/x[zero:-1]**2)+b_i*np.sqrt(x[zero:-1])
-    h_bar = 6.58e-16  # h/2pi
-    pre = 1.0
-    m = 6.58e-31
-    smear = x*0.0
-    smear[zero:-1] = pre*(h_bar/(smear_i[zero:-1]*0.000000001))*np.sqrt((2*x[zero:-1]*1.6E-19)/m)
-
-    def lorentzian(xx, pp):
-        yy = ((0.5 * pp[1]/3.14)/((xx-pp[0])**2 + ((pp[1]/2)**2)))
-        return yy/sum(yy)
-
-    p = [0, instrument]
-    in_data = y.copy()
-    out_data = np.array(y)*0.0
-    for i in range(zero+5, len(x)):
-        p[0] = x[i]
-        p[1] = smear[i]/1.0
-        lor = lorentzian(x+1e-9, p)
-        out_data[i] = sum(in_data*lor)
-        if np.isnan(out_data[i]):
-            out_data[i] = 0.0
-        
-    p[1] = instrument
-    in_data = out_data.copy()   
-    for i in range(zero-5, len(x)):
-        p[0] = x[i]
-        lor = lorentzian(x+1e-9, p)
-        out_data[i] = sum(in_data*lor)
-        # print(out_data[i],in_data[i], lor[i],in_data[i-1], lor[i-1], )
-    return out_data
+""" dft simulations tools
+
+Part of pyTEMlib
+by Gerd Duscher
+created 10/29/2020
+
+Supports the conversion of DFT data to simulated EELS spectra
+
+- exciting_get_spectra:  importing dielectric function from the exciting program
+- final_state_broadening: apply final state broadening to loss-spectra
+"""
+
+import numpy as np
+from lxml import etree
+
+
+def exciting_get_spectra(file):
+    """get EELS spectra from exciting calculation"""
+
+    tags = {'data': {}}
+
+    tree = etree.ElementTree(file=file)
+    root = tree.getroot()
+
+    data = tags['data']
+
+    if root.tag in ['loss', 'dielectric']:
+        print(' reading ', root.tag, ' function from file ', file)
+        # print(root[0].tag, root[0].text)
+        map_def = root[0]
+        i = 0
+        v = {}
+        for child_of_root in map_def:
+            data[child_of_root.tag] = child_of_root.attrib
+            v[child_of_root.tag] = []
+            i += 1
+
+        for elem in tree.iter(tag='map'):
+            m_dict = elem.attrib
+            for key in m_dict:
+                v[key].append(float(m_dict[key]))
+
+        for key in data:
+            data[key]['data'] = np.array(v[key])
+        data['type'] = root.tag+' function'
+        return tags
+
+
+def final_state_broadening(x, y, start, instrument):
+    """Final state smearing of ELNES edges
+
+    Parameters
+    ----------
+    x: numpy array
+        x or energy loss axis of density of states
+    y: numpy array
+        y or intensity axis of density of states
+    start: float
+        start energy of edge
+    instrument: float
+        instrument broadening
+
+    Return
+    ------
+    out_data: numpy array
+        smeared intensity according to final state and instrument broadening
+    """
+
+    # Getting the smearing
+    a_i = 107.25*5
+    b_i = 0.04688*2.
+    x = np.array(x)-start
+    zero = int(-x[0]/(x[1]-x[0]))+1
+    smear_i = x*0.0
+    smear_i[zero:-1] = (a_i/x[zero:-1]**2)+b_i*np.sqrt(x[zero:-1])
+    h_bar = 6.58e-16  # h/2pi
+    pre = 1.0
+    m = 6.58e-31
+    smear = x*0.0
+    smear[zero:-1] = pre*(h_bar/(smear_i[zero:-1]*0.000000001))*np.sqrt((2*x[zero:-1]*1.6E-19)/m)
+
+    def lorentzian(xx, pp):
+        yy = ((0.5 * pp[1]/3.14)/((xx-pp[0])**2 + ((pp[1]/2)**2)))
+        return yy/sum(yy)
+
+    p = [0, instrument]
+    in_data = y.copy()
+    out_data = np.array(y)*0.0
+    for i in range(zero+5, len(x)):
+        p[0] = x[i]
+        p[1] = smear[i]/1.0
+        lor = lorentzian(x+1e-9, p)
+        out_data[i] = sum(in_data*lor)
+        if np.isnan(out_data[i]):
+            out_data[i] = 0.0
+
+    p[1] = instrument
+    in_data = out_data.copy()
+    for i in range(zero-5, len(x)):
+        p[0] = x[i]
+        lor = lorentzian(x+1e-9, p)
+        out_data[i] = sum(in_data*lor)
+        # print(out_data[i],in_data[i], lor[i],in_data[i-1], lor[i-1], )
+    return out_data

pyTEMlib/version.py

@@ -1,3 +1,6 @@
-_version = '0.2020.11.0'
-__version__ = _version
-_time = '2020-11-03 20:20:26'
+"""
+version
+"""
+_version = '0.2024.08.4'
+__version__ = _version
+_time = '2024-08-28 19:58:26'