nanonis-reader 0.0.1__tar.gz

nanonis_reader-0.0.1/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: nanonis_reader
+Version: 0.0.1
+Summary: A Python package for reading STM experimental data files obtained from Nanonis, based on nanonispy
+Home-page: https://github.com/D-gitt/nanonis_reader
+Author: Dowook Kim
+Author-email: dw.kim@postech.ac.kr
+Keywords: nanonis,reader,nanonispy,STM data,scientific data analysis
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: nanonispy
+Requires-Dist: scipy
+Requires-Dist: warning
+Requires-Dist: math

nanonis_reader-0.0.1/nanonis_reader/__init__.py

@@ -0,0 +1,7 @@
+__version__ = '0.0.1'
+
+# import nanonis_reader 실행 시 자동으로 하위 module 들을 사용할수 있도록 미리 import.
+from nanonis_reader import nanonis_sxm, nanonis_dat, nanonis_3ds, cmap_custom, find_value, schematic, spectral_analysis, atom_analysis
+
+# from nanonis_reader import *에서 *에 포함되는 것들. (* : "__all__에 포함된 것을 전부" import)
+__all__ = ['nanonis_sxm', 'nanonis_dat', 'nanonis_3ds', 'cmap_custom', 'find_value', 'schematic', 'spectral_analysis', 'atom_analysis']

nanonis_reader-0.0.1/nanonis_reader/atom_analysis.py

@@ -0,0 +1,37 @@
+# Drift correction of STM images obtained on monoclinic Ta2NiSe5.
+def Ta2NiSe5_driftcorr(z, a_image_nm, c_image_nm, scansize_nm, origin_line=0, origin_pixel=0):
+    import numpy as np
+    lines, pixels = np.shape(z)
+    a, c = 0.34916, 1.565 # lattice constants (nm)
+    lines_corr = int(round(lines * (a_image_nm / a)))
+    pixels_corr = int(round(pixels * (c_image_nm / c)))
+    # print (lines_corr, pixels_corr)
+    z_corr = np.copy(z)[origin_line:origin_line+lines_corr, origin_pixel:origin_pixel+pixels_corr]
+    
+    # length of scansize must be 2.
+    # unitpx in \AA unit.
+    a_unitpx = (10*scansize_nm[0])/lines_corr
+    c_unitpx = (10*scansize_nm[1])/pixels_corr
+
+    return z_corr, a_unitpx, c_unitpx
+
+
+# Extract topograph from a ASCII XYZ file of WSxM.
+def Extract_Z (Path, Search = 'X[nm]'):
+    import numpy as np
+    # Search = 'X[nm]' # X[nm]가 포함된 줄 찾기
+    with open(Path, 'r', encoding = 'ISO-8859-1') as f: # encoding='ISO-8859-1'
+        for line_number, line in enumerate(f):  # enumerate: 대상의 원소와 index를 묶은 tuple을 반환. / start=1 : index가 1부터 시작. (default==0)
+            if Search in line:
+                print(f"Word '{Search}' found on line {line_number+1}")
+                break # line_number == 2
+        XYZ_data = f.readlines() # line_number + 1 번째부터 한줄씩 모든 줄을 읽어들임.
+        # print(XYZ_data) # 읽어들인 결과값 출력.
+
+#     Extract z data and do 3sigma
+        Result = []
+        for Z in XYZ_data[1:]:
+            Result.append(Z.split('\t')[2].strip('\n')) # z data만 추출
+        Z_data = np.array([float(Z) for Z in Result]) # String array to float array in pm.
+    print ('Finished.')
+    return Z_data

nanonis_reader-0.0.1/nanonis_reader/cmap_custom.py

@@ -0,0 +1,20 @@
+def nanox():
+    import numpy as np
+    import matplotlib.colors as clr
+    return clr.LinearSegmentedColormap.from_list('nanox', \
+                                                 np.array([(0, 0, 0), (115, 33, 0), (180, 119, 0), (255, 255, 255)])/255, N=256)
+
+def bwr():
+    import matplotlib.colors as clr
+    return clr.LinearSegmentedColormap.from_list('bwr_custom', \
+                                                 [(0, 0, 0.4), (0, 0, 1), (1, 1, 1), (1, 0, 0), (0.4, 0, 0)], N=256)
+
+def conduction_band():
+    import numpy as np
+    # return '#2A59A0'
+    return np.array([42, 89, 160])/255
+
+def valence_band():
+    import numpy as np
+    # return '#DF2B2B'
+    return np.array([223, 43, 43])/255

nanonis_reader-0.0.1/nanonis_reader/find_value.py

@@ -0,0 +1,19 @@
+def barrier_height (kappa): # Input: kappa in 1/m unit.
+    m_eV = 0.51099895e+6 # Electron mass in eV unit. (NOT eV/c^2 unit. Use m_e instead of m_e*c**2.)
+    hbar = 6.582119569e-16 # hbar in eV*s unit.
+    c = 2.99792458e+8 # Speed of light in m/s unit.
+    return ( hbar*c*kappa )**2 / ( 2*m_eV )
+
+def kappa (workfunction): # Input: work function in eV unit.
+    m_eV = 0.51099895e+6 # Electron mass in eV unit. (NOT eV/c^2 unit. Use m_e instead of m_e*c**2.)
+    hbar = 6.582119569e-16 # hbar in eV*s unit.
+    c = 2.99792458e+8 # Speed of light.
+    import numpy as np
+    return np.sqrt(2 * m_eV * workfunction) / (hbar * c)
+
+def nearest(array, value):
+    import numpy as np
+    array = np.asarray(array)
+    # idx = (np.abs(array - value)).argmin()
+    idx = np.where((np.abs(array - value)) == np.min((np.abs(array - value))))[0]
+    return idx, array[idx]

nanonis_reader-0.0.1/nanonis_reader/nanonis_3ds.py

@@ -0,0 +1,441 @@
+class Load:
+
+    def __init__(self, filepath):
+        import nanonispy as nap
+        self.fname = nap.read.Grid(filepath).fname.split('\\')[-1]
+        self.header = nap.read.Grid(filepath).header
+        self.signals = nap.read.Grid(filepath).signals
+
+        
+class Topo:
+        
+    def __init__(self, instance):
+        self.fname = instance.fname
+        self.header = instance.header
+        self.signals = instance.signals
+    
+    def get_z (self, processing = 'raw'):
+        if processing == 'raw':
+            return self.raw()
+        elif processing == 'subtract average':
+            return self.subtract_average()
+        elif processing == 'subtract linear fit':
+            return self.subtract_linear_fit()
+        elif processing == 'subtract parabolic fit':
+            return self.subtract_parabolic_fit()
+        elif processing == 'differentiate':
+            return self.differentiate()
+        
+    def raw (self):
+        import numpy as np
+        tmp = self.signals['topo']
+        z = np.where(tmp == 0, np.nan, tmp)
+        return z
+    
+    def subtract_average (self):
+        import warnings
+        import numpy as np
+        warnings.filterwarnings(action='ignore')
+        z = self.raw()
+        z_subav = np.zeros(np.shape(z))
+        lines = np.shape(z)[0]
+        for i in range(lines):
+            z_subav[i] = z[i] - np.nanmean(z[i])
+        return z_subav
+
+    def subtract_linear_fit (self):
+        import numpy as np
+        from scipy.optimize import curve_fit
+        def f_lin(x, a, b): return a*x + b
+        xrange = round(self.header['size_xy'][0] * 1e9)*1e-9
+        print (xrange)
+        z = self.raw()
+        z_sublf = np.zeros(np.shape(z))
+        lines, pixels = np.shape(z)
+        for i in range(lines):
+            if np.shape(np.where(np.isnan(z))[0])[0] != 0: # image에 nan값이 포함되어 있을 경우 (== scan을 도중에 멈추었을 경우)
+                if i < np.min(np.where(np.isnan(z))[0]):
+                    x = np.linspace(0, xrange, pixels)
+                    popt, pcov = curve_fit(f_lin, x, z[i])
+                    z_sublf[i] = z[i] - f_lin(x, *popt)
+                else:
+                    z_sublf[i] = np.nan
+            else:
+                x = np.linspace(0, xrange, pixels)
+                popt, pcov = curve_fit(f_lin, x, z[i]) # x - ith line: linear fitting
+                z_sublf[i] = z[i] - f_lin(x, *popt)
+
+        return z_sublf
+
+    def subtract_parabolic_fit (self):
+        import numpy as np
+        from scipy.optimize import curve_fit
+        def f_parab(x, a, b, c): return a*(x**2) + b*x + c
+        xrange = round(self.header['size_xy'][0] * 1e9)*1e-9
+        print (xrange)
+        z = self.raw()
+        z_subpf = np.zeros(np.shape(z))
+        lines, pixels = np.shape(z)
+        for i in range(lines):
+            if np.shape(np.where(np.isnan(z))[0])[0] != 0: # image에 nan값이 포함되어 있을 경우 (== scan을 도중에 멈추었을 경우)
+                if i < np.min(np.where(np.isnan(z))[0]):
+                    x = np.linspace(0, xrange, pixels)
+                    popt, pcov = curve_fit(f_parab, x, z[i])
+                    z_subpf[i] = z[i] - f_parab(x, *popt)
+                else:
+                    z_subpf[i] = np.nan
+            else:
+                x = np.linspace(0, xrange, pixels)
+                popt, pcov = curve_fit(f_parab, x, z[i]) # x - ith line: linear fitting
+                z_subpf[i] = z[i] - f_parab(x, *popt)
+
+        return z_subpf
+    
+    def differentiate (self):
+        import numpy as np
+        xrange, pixels = round(self.header['size_xy'][0] * 1e9)*1e-9, int(self.header['dim_px'][0])
+        dx = xrange / pixels
+        z = self.raw()
+        z_deriv = np.zeros(np.shape(z))
+        lines = np.shape(z)[0]
+        for i in range(lines):
+            z_deriv[i] = np.gradient(z[i], dx, edge_order = 2) # dI/dV curve를 직접 미분. --> d^2I/dV^2
+        
+        return z_deriv
+
+    
+class Map: # dIdV, I-z spec, apparent barrier map
+    
+    def __init__(self, instance):
+        self.fname = instance.fname
+        self.header = instance.header
+        self.signals = instance.signals
+        
+    def get_didvmap (self, sweep_idx, channel = 'LI Demod 1 X (A)'):
+        didv = self.signals[channel][:, :, sweep_idx]
+        return didv
+    
+    def get_currentmap (self, sweep_idx, sweep_direction = 'fwd'):
+        if sweep_direction == 'fwd':
+            current = self.signals['Current (A)'][:, :, sweep_idx]
+        elif sweep_direction == 'bwd':
+            current = self.signals['Current [bwd] (A)'][:, :, sweep_idx]
+        elif sweep_direction == 'AVG':
+            current = np.nanmean ( [self.signals['Current (A)'], self.signals['Current [bwd] (A)']], axis = 2 ) [:, :, sweep_idx]
+        return current
+    
+    def get_apparent_barrier_height (self, line, pixel, sweep_direction='fwd', fitting_current_range=(1e-12, 10e-12)):
+        # fitting_current_range: current range in A unit.
+        import numpy as np
+        from scipy.optimize import curve_fit
+        def linear(x, barr, b):
+            return -2*( np.sqrt(2*0.51099895e+6*barr)/(6.582119569e-16*2.99792458e+8) )*x + b
+        
+        z = self.signals['sweep_signal']
+        if sweep_direction == 'fwd':
+            I = np.abs(self.signals['Current (A)'][line, pixel])
+        elif sweep_direction == 'bwd':
+            I = np.abs(self.signals['Current [bwd] (A)'][line, pixel])
+        elif sweep_direction == 'AVG':
+            I = np.abs(np.nanmean ( [self.signals['Current (A)'][line, pixel], \
+                              self.signals['Current [bwd] (A)'][line, pixel]], \
+                           axis = 0))
+        
+        ############################## Set fitting range ##############################
+        idx = np.where( (fitting_current_range[0] <= I) & (I <= fitting_current_range[1]) ) # Filter with I
+        ############################## Set fitting range ##############################
+        popt, pcov = curve_fit (linear, z[idx], np.log(I[idx]), p0 = [1.2, 1.2])
+        apparent_barrier_height = popt[0]
+        err = np.sqrt(np.diag(pcov))[0]
+        # err = np.sqrt(np.diag(pcov))[0]
+        # slope = -2*np.sqrt(2*0.51099895e+6*apparent_barrier_height)/(6.582119569e-16*2.99792458e+8)
+        # return apparent_barrier_height, err, slope
+       
+        return apparent_barrier_height, err
+    
+    def get_apparent_barrier_height_map (self, sweep_direction='fwd', fitting_current_range=(1e-12, 10e-12)):
+        import numpy as np
+        lines, pixels = self.header['dim_px'][1], self.header['dim_px'][0]
+        arr = np.zeros((lines, pixels))
+        err = np.zeros((lines, pixels))
+        for i in range (lines):
+            for j in range (pixels):
+                try:
+                    arr[i, j] = self.get_apparent_barrier_height (i, j, sweep_direction, fitting_current_range)[0]
+                    err[i, j] = self.get_apparent_barrier_height (i, j, sweep_direction, fitting_current_range)[1]
+                except:
+                    print (f'Estimation error at: {i, j}. Investigate z-spectrum at {i, j} for detailed info.')
+                    arr[i, j] = np.nan
+                    err[i, j] = np.nan
+        return arr, err
+    
+    def get_sweepsignal (self, sweep_idx):
+        return self.signals['sweep_signal'][sweep_idx]
+
+    
+class PtSpec: # any spectrum (dIdV, Z, I, ...) vs sweep_signal at any point.
+        
+    def __init__(self, instance):
+        self.fname = instance.fname
+        self.header = instance.header
+        self.signals = instance.signals
+
+    def get_didv_raw (self, line, pixel, channel = 'none', offset = 'none'):
+        import numpy as np
+        if channel == 'none':
+            if 'LI Demod 2 X (A)' in self.signals.keys():
+                channel = 'LI Demod 2 X (A)'
+            elif 'LI Demod 1 X (A)' in self.signals.keys():
+                channel = 'LI Demod 1 X (A)'
+        else:
+            channel = channel
+        if isinstance(offset, np.ndarray):
+            didv = self.signals[channel][line, pixel] - offset
+        else:
+            didv = self.signals[channel][line, pixel]
+        return self.signals['sweep_signal'], didv
+
+    
+    def get_dzdv_numerical (self, line, pixel):
+        import numpy as np
+        z = self.signals['Z (m)'][line, pixel]
+        dzdv_numerical = np.gradient(z, edge_order=2)
+        return self.signals['sweep_signal'], dzdv_numerical
+
+    def get_apparent_barrier_height (self, line, pixel, sweep_direction='fwd', fitting_current_range=(1e-12, 10e-12)):
+        # fitting_current_range: current range in A unit.
+        import numpy as np
+        from scipy.optimize import curve_fit
+        def linear(x, barr, b):
+            return -2*( np.sqrt(2*0.51099895e+6*barr)/(6.582119569e-16*2.99792458e+8) )*x + b
+        
+        z = self.signals['sweep_signal']
+        if sweep_direction == 'fwd':
+            I = np.abs(self.signals['Current (A)'][line, pixel])
+        elif sweep_direction == 'bwd':
+            I = np.abs(self.signals['Current [bwd] (A)'][line, pixel])
+        elif sweep_direction == 'AVG':
+            I = np.abs(np.nanmean ( [self.signals['Current (A)'][line, pixel], \
+                              self.signals['Current [bwd] (A)'][line, pixel]], \
+                           axis = 0))
+        
+        ############################## Set fitting range ##############################
+        idx = np.where( (fitting_current_range[0] <= I) & (I <= fitting_current_range[1]) ) # Filter with I
+        ############################## Set fitting range ##############################
+        popt, pcov = curve_fit (linear, z[idx], np.log(I[idx]), p0 = [1.2, 1.2])
+        apparent_barrier_height = popt[0]
+        # err = np.sqrt(np.diag(pcov))[0]
+        # slope = -2*np.sqrt(2*0.51099895e+6*apparent_barrier_height)/(6.582119569e-16*2.99792458e+8)
+        # return apparent_barrier_height, err, slope
+       
+        return apparent_barrier_height
+    
+    def get_didv_scaled (self, line, pixel, channel = 'LI Demod 2 X (A)', offset = 'none'):
+        '''
+        Returns
+        -------
+        tuple
+            (Bias (V), dIdV (S))
+        '''
+        import numpy as np
+        # return self.signals['sweep_signal'], np.median(self.get_didv_numerical(line, pixel)[1]/self.signals[channel][line, pixel])*self.signals[channel][line, pixel]
+        return self.signals['sweep_signal'], \
+        np.median(self.get_didv_numerical(line, pixel)[1]/self.get_didv_raw(line, pixel, channel, offset)[1])\
+        *self.get_didv_raw(line, pixel, channel, offset)[1]
+    
+    def get_didv_normalized (self, line, pixel, channel='LI Demod 2 X (A)', factor=0.2, offset='none', delete_zero_bias=False):
+        '''
+        Returns
+        -------
+        tuple
+            (Bias (V), normalized dIdV)
+        '''        
+        import numpy as np
+        from scipy.optimize import curve_fit
+        try:
+            from scipy.integrate import cumtrapz
+        except:
+            from scipy.integrate import cumulative_trapezoid
+        
+        # dIdV, V = self.get_didv_scaled(line, pixel, channel)[1], self.signals['sweep_signal']
+        V, dIdV = self.get_didv_scaled(line, pixel, channel, offset = 'none')
+        try:
+            I_cal = cumtrapz(dIdV, V, initial = 0)
+        except:
+            I_cal = cumulative_trapezoid(dIdV, V, initial = 0)
+        zero = np.argwhere ( abs(V) == np.min(abs(V)) )[0, 0] # The index where V = 0 or nearest to 0.
+        popt, pcov = curve_fit (lambda x, a, b: a*x + b, V[zero-1:zero+2], I_cal[zero-1:zero+2])
+        I_cal -= popt[1]
+
+        # get total conductance I/V
+        with np.errstate(divide='ignore'): # Ignore the warning of 'division by zero'.
+            IV_cal = I_cal/V
+
+        # I_cal/V = 0/0으로 계산되는 경우
+        # nan으로 처리됨. 이 값 제외를 위해 nanmedian 사용.
+        delta = factor*np.nanmedian(IV_cal)
+        Normalized_dIdV = dIdV / np.sqrt(np.square(delta) + np.square(IV_cal))
+        if delete_zero_bias == False:
+            return V, Normalized_dIdV
+        else:
+            return np.delete(V, zero), np.delete(Normalized_dIdV, zero)
+
+        
+
+    
+    def get_didv_numerical (self, line, pixel):
+        '''
+        Returns
+        -------
+        tuple
+            (Bias (V), numerical dIdV (S))
+        '''        
+        import numpy as np
+        step = self.signals['sweep_signal'][1] - self.signals['sweep_signal'][0]
+        didv = np.gradient(self.signals['Current (A)'][line, pixel], step, edge_order=2) # I-V curve를 직접 미분.
+        return self.signals['sweep_signal'], didv
+    
+    def get_iv_raw (self, line, pixel):
+        '''
+        Returns
+        -------
+        tuple
+            (Bias (V), Current (A))
+        '''        
+        return self.signals['sweep_signal'], self.signals['Current (A)']
+
+
+class LineSpec: # any spectrum (dIdV, Z, I, ...) vs sweep_signal at any point.
+    def __init__(self, instance):
+        self.fname = instance.fname
+        self.header = instance.header
+        self.signals = instance.signals
+    
+    # def get (self, line, sts='scaled', channel='LI Demod 2 X (A)', factor=0.2, offset='none', delete_zero_bias=False):
+    def get (self, line, processing='scaled', **kwargs):
+        import numpy as np
+        if processing == 'scaled':
+            spec = self.get_didv_scaled
+        elif processing == 'raw':
+            spec = self.get_didv_raw
+        elif processing == 'numerical':
+            spec = self.get_didv_numerical
+        elif processing == 'normalized':
+            spec = self.get_didv_normalized
+        linespec = np.array([ spec(line, pixel, **kwargs)[1] for pixel \
+                     in range (self.header['dim_px'][0]) ]).T
+        return linespec
+
+    def get_didv_raw (self, line, pixel, channel = 'none', offset = 'none'):
+        if channel == 'none':
+            if 'LI Demod 2 X (A)' in self.signals.keys():
+                channel = 'LI Demod 2 X (A)'
+            elif 'LI Demod 1 X (A)' in self.signals.keys():
+                channel = 'LI Demod 1 X (A)'
+        else:
+            channel = channel
+        if offset != 'none':
+            didv = self.signals[channel][line, pixel] - offset
+        else:
+            didv = self.signals[channel][line, pixel]
+        return self.signals['sweep_signal'], didv
+
+    def get_didv_scaled (self, line, pixel, channel = 'LI Demod 2 X (A)', offset = 'none'):
+        '''
+        Returns
+        -------
+        tuple
+            (Bias (V), dIdV (S))
+        '''
+        import numpy as np
+        # return self.signals['sweep_signal'], np.median(self.get_didv_numerical(line, pixel)[1]/self.signals[channel][line, pixel])*self.signals[channel][line, pixel]
+        return self.signals['sweep_signal'], \
+        np.median(self.get_didv_numerical(line, pixel)[1]/self.get_didv_raw(line, pixel, channel, offset)[1])\
+        *self.get_didv_raw(line, pixel, channel, offset)[1]
+    
+    def get_didv_normalized (self, line, pixel, channel='LI Demod 2 X (A)', factor=0.2, offset='none', delete_zero_bias=False):
+        '''
+        Returns
+        -------
+        tuple
+            (Bias (V), normalized dIdV)
+        '''        
+        import numpy as np
+        from scipy.optimize import curve_fit
+        try:
+            from scipy.integrate import cumtrapz
+        except:
+            from scipy.integrate import cumulative_trapezoid
+        
+        # dIdV, V = self.get_didv_scaled(line, pixel, channel)[1], self.signals['sweep_signal']
+        V, dIdV = self.get_didv_scaled(line, pixel, channel, offset = 'none')
+        try:
+            I_cal = cumtrapz(dIdV, V, initial = 0)
+        except:
+            I_cal = cumulative_trapezoid(dIdV, V, initial = 0)
+        zero = np.argwhere ( abs(V) == np.min(abs(V)) )[0, 0] # The index where V = 0 or nearest to 0.
+        popt, pcov = curve_fit (lambda x, a, b: a*x + b, V[zero-1:zero+2], I_cal[zero-1:zero+2])
+        I_cal -= popt[1]
+
+        # get total conductance I/V
+        with np.errstate(divide='ignore'): # Ignore the warning of 'division by zero'.
+            IV_cal = I_cal/V
+
+        # I_cal/V = 0/0으로 계산되는 경우
+        # nan으로 처리됨. 이 값 제외를 위해 nanmedian 사용.
+        delta = factor*np.nanmedian(IV_cal)
+        Normalized_dIdV = dIdV / np.sqrt(np.square(delta) + np.square(IV_cal))
+        if delete_zero_bias == False:
+            return V, Normalized_dIdV
+        else:
+            return np.delete(V, zero), np.delete(Normalized_dIdV, zero)
+
+        
+
+    
+    def get_didv_numerical (self, line, pixel):
+        '''
+        Returns
+        -------
+        tuple
+            (Bias (V), numerical dIdV (S))
+        '''        
+        import numpy as np
+        step = self.signals['sweep_signal'][1] - self.signals['sweep_signal'][0]
+        didv = np.gradient(self.signals['Current (A)'][line, pixel], step, edge_order=2) # I-V curve를 직접 미분.
+        return self.signals['sweep_signal'], didv
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        
+        
+