FT-inversion-tools 0.0.1__py3-none-any.whl

FTI_analysis_tools.py

@@ -0,0 +1,83 @@
+import os.path 
+import numpy as np 
+import scipy as sp 
+### Functions for ZT system
+def getZTFilePaths(system=str, direction=str):
+    """
+    Reads data for the FT system
+    """
+    default_path = os.path.join('~','ft_inversion_paper', 'ZT_data', system)
+    dens_path = os.path.expanduser(os.path.join(default_path, direction, 'static', 'density.y=0,z=0'))
+    vks_path = os.path.expanduser(os.path.join(default_path, direction, 'static', 'vks.y=0,z=0'))
+    vxc_path = os.path.expanduser(os.path.join(default_path, direction, 'static', 'vxc.y=0,z=0'))
+    vh_path = os.path.expanduser(os.path.join(default_path, direction, 'static', 'vh.y=0,z=0'))
+    return dens_path, vks_path, vxc_path, vh_path
+
+def getZTData(system=str, direction=str): 
+    """
+    Reads data for the FT system
+    """
+    dens_path, vks_path, vxc_path, vh_path = getZTFilePaths(system, direction)
+    x_grid = np.loadtxt(dens_path)[:,0]  # 1D grid
+    dens = np.loadtxt(dens_path)[:,1]
+    vks = np.loadtxt(vks_path)[:,1]
+    vxc = np.loadtxt(vxc_path)[:,1]
+    vh = np.loadtxt(vh_path)[:,1]
+    return x_grid, dens, vks, vxc, vh
+
+### Functions for FT system
+def getFTFilePaths(system=str, temp=str, direction=str):
+    """
+    Reads data for the FT system
+    """
+    default_path = os.path.join('~','ft_inversion_paper', 'ft_inversions', system)
+    dens_path = os.path.expanduser(os.path.join(default_path, temp, direction, 'static', 'density.y=0,z=0'))
+    vks_path = os.path.expanduser(os.path.join(default_path, temp, direction, 'static', 'vks.y=0,z=0'))
+    vxc_path = os.path.expanduser(os.path.join(default_path, temp, direction, 'static', 'vxc.y=0,z=0'))
+    vh_path = os.path.expanduser(os.path.join(default_path, temp, direction, 'static', 'vh.y=0,z=0'))
+    return dens_path, vks_path, vxc_path, vh_path
+
+def getFTData(temp=str, system=str, direction=str): 
+    """
+    Reads data for the FT system
+    """
+    dens_path, vks_path, vxc_path, vh_path = getFTFilePaths(temp, system, direction)
+    x_grid = np.loadtxt(dens_path)[:,0]  # 1D grid
+    dens = np.loadtxt(dens_path)[:,1]
+    vks = np.loadtxt(vks_path)[:,1]
+    vxc = np.loadtxt(vxc_path)[:,1]
+    vh = np.loadtxt(vh_path)[:,1]
+    return x_grid, dens, vks, vxc, vh
+
+
+def shifter(temps, vks_list_FWD, vks_list_INV, vxc_list_INV, Fermi_energy_list): 
+    shifted_ks = []
+    shifted_xc = []
+    shifted_fermi = []
+    for i in range(len(temps)): 
+        # print(temps[i])
+        timpFWDKS = vks_list_FWD[i] 
+        timpINVKS = vks_list_INV[i]
+        shift = np.mean(timpINVKS- timpFWDKS)
+        shifted_ks.append(vks_list_INV[i] + shift)
+        shifted_xc.append(vxc_list_INV[i] + shift)
+        shifted_fermi.append(Fermi_energy_list[i] + shift)
+    return shifted_ks, shifted_xc, shifted_fermi
+
+def energy_calculator(temps, vxc_list, dens_list, grid_list):
+    Exc_list = []
+    for i in range(len(temps)):
+        Exc = -sp.integrate.simpson((np.diff(vxc_list[0])) * (dens_list[i][1:]*grid_list[i][1:]), grid_list[i][1:])
+        Exc_list.append(Exc)
+    return Exc_list
+
+def diffs_calculator(temps, vxc_list, dens_list): 
+    potential_diffs = []
+    density_diffs = []
+    for i in range(len(temps)):
+        xc_diff = vxc_list[i] - vxc_list[0]
+        potential_diffs.append(xc_diff)
+        dens_diff = dens_list[i] - dens_list[0]
+        density_diffs.append(dens_diff)
+    return potential_diffs, density_diffs
+    

ZTA_analysis_tools.py

@@ -0,0 +1,268 @@
+import os.path 
+import numpy as np 
+import scipy as sp 
+import pickle 
+## Root finding functions 
+def secant_method(function, guess1:float, print_opt:bool, criterion:float=1e-6, error_track:bool=False):
+    """
+    INPUT: 
+        function : function, function of which to find the roots 
+        guess1 : float, lower guess for the root
+        criterion : float, convergence criterion for the root finding method
+        max_iter : float, maximum number of iterations for the root finding method
+    Returns: 
+        root : float, The root of the function 
+    Raises: 
+        Excpetion: Divide by zero warning if guess1 and guess2 are equal
+    """
+
+    x2 = guess1 
+    x1 = guess1 - 5
+    
+    error = 1
+    iteration = 0
+    
+    error = -(function(x2)*(x2 - x1))/(function(x2)-function(x1))
+    
+    if print_opt ==True:
+        with open("secant_error.txt", "a") as f:  
+            print("Iteration, x1, x2, f(x1), f(x2), error", file=f)
+
+    while (abs(error) > criterion and iteration < 1000):
+        if print_opt == True:
+            with open("secant_error.txt", "a") as f:  
+                print(iteration, x1, x2, function(x1), function(x2), error, file=f)
+        x1 = x2
+        x2 += error 
+        iteration += 1
+        error = -function(x2)*(x2 - x1)/(function(x2)-function(x1))
+    if print_opt == True: 
+        with open("secant_error.txt", "a") as f:  
+            print(iteration, x1, x2, function(x1), function(x2), error, file=f)
+    
+    if error_track == False:
+        return x2, function(x2), iteration, error
+    return x2, function(x2)
+
+## Boltzman functions 2+ electron systems
+
+def boltzman_weights(energy, chem_pot, tau, part_num): 
+    """Calculates the Boltzman weights for the interacting densities
+    to approximate a thermal interacting density
+
+    Args:
+        energy (ndarray): _description_
+        chem_pot (float): _description_
+        tau (float): _description_
+        part_num (float): _description_
+
+    Returns:
+        occupation: boltzman weight for given temperature
+    """    
+    kb = 1 # Boltzman constant in atomic units
+    beta = 1/(kb*tau) # beta 
+    partition_function = 0 
+    nstates = len(energy)
+    w = np.empty((nstates))
+    for i in range(part_num):
+        for j in range(nstates):
+            w[j] = np.exp(-beta*(energy[j]-(chem_pot*(i))))
+            partition_function += w[j]
+    w = w/partition_function
+    occupation = w
+    return occupation
+
+def boltz_num_func_func(x, tau, vals, densities, ne, target_ne):
+    '''
+    Description: Determine the Unshifted particle number
+    INPUT:
+        mu: Scalar (float)
+            chemical potential
+        tau: Scalar (float)
+            Electronic temperature
+        vecs: ndarray
+            Eigenvectors
+        vals: ndarray
+            Eigenvalues 
+        x: ndarray
+            Grid
+    OUTPUT
+        Ne: Scalar (float)
+            The unshifted particle number
+    '''
+
+    def boltz_num_func(mu):
+        
+        nx = len(x)
+        nk = vals.shape[0]
+    
+        kb = 1 #3.166811563e-6 # Ha K^-1
+        T = tau/kb
+
+        # obtain boltzman weights 
+        w = boltzman_weights(vals,mu,T,ne)
+        dens = np.zeros(nx)
+        for i in range(ne):
+            for j in range(nk):
+                dens += w[j]*densities[j,:]
+        Ne = np.trapezoid(dens,x)
+        
+        return Ne - target_ne
+    
+    return boltz_num_func
+## Fermi Functions for 1 electron systems 
+def fermi_weights(energy, chem_pot, tau): 
+    F_occs = 1/(1+np.exp((energy-chem_pot)/tau))
+    return F_occs
+def fermi_num_func_func(x, tau, vals, densities, ne, target_ne):
+    '''
+    Description: Determine the Unshifted particle number
+    INPUT:
+        mu: Scalar (float)
+            chemical potential
+        tau: Scalar (float)
+            Electronic temperature
+        vecs: ndarray
+            Eigenvectors
+        vals: ndarray
+            Eigenvalues 
+        x: ndarray
+            Grid
+    OUTPUT
+        Ne: Scalar (float)
+            The unshifted particle number
+    '''
+
+    def fermi_num_func(mu):
+        
+        nx = len(x)
+        nk = vals.shape[0]
+    
+        # convert temp in units of Ha into K
+        kb = 1 #3.166811563e-6 # Ha K^-1
+        T = tau/kb
+
+        # obtain boltzman weights 
+        w = fermi_weights(vals,mu,T)
+        dens = np.zeros(nx)
+        for i in range(ne):
+            for j in range(nk):
+                # print(w.shape)
+                # print(densities.shape)
+                dens += w[j]*densities[j,:]
+        Ne = np.trapezoid(dens,x)
+        
+        return Ne - target_ne
+    
+    return fermi_num_func
+
+## Shifting function
+
+def shifter(vks_FWD, vks_INV, vxc_INV): 
+    """_summary_
+
+    Args:
+        vks_FWD (ndarray): Kohn-Sham potential from forward calculation
+        vks_INV (ndarray): Exact Kohn-Sham potential from inverse calculation
+        vxc_INV (ndarray): Exact exchange-correlation potential from inverse calculation
+
+    Returns:
+        _type_: _description_
+    """    
+    # shifted_ks = []
+    # shifted_xc = []
+    timpFWDKS = vks_FWD 
+    timpINVKS = vks_INV
+    shift = np.mean(timpINVKS- timpFWDKS)
+    shifted_ks = (vks_INV + shift)
+    shifted_xc = (vxc_INV + shift)
+    return shifted_ks, shifted_xc
+
+
+def energy_calculators(temps, vxc_ZTA_list, vxc_LDAZTA_list, dens_list, grid_list):
+    """_summary_
+
+    Args:
+        temps (list): list of temperatures
+        vxc_ZTA_list (list): list of exact ZTA vxc arrays
+        vxc_LDAZTA_list (list): list of approximate ZTA vxc arrays
+        dens_list (list): list of theramlized density arrays 
+        grid_list (list): list of numerical grids (these should be identical but this set up allows for non identical grids)
+
+    Returns:
+        _type_: _description_
+    """    
+    Exc_ZTA_list = []
+    Exc_LDAZTA_list = []
+    for i in range(len(temps)):
+        Exc_ZTA = -sp.integrate.simpson((np.diff(vxc_ZTA_list[0])) * (dens_list[i][1:]*grid_list[i][1:]), grid_list[i][1:])
+        compA = np.diff(vxc_LDAZTA_list[i])
+        compB = grid_list[i]
+        compC = dens_list[i]
+        compD =  grid_list[i]
+        Exc_LDAZTA = -sp.integrate.simpson((compA)* (compB*compC)[1:],compD[1:])
+        Exc_ZTA_list.append(Exc_ZTA)
+        Exc_LDAZTA_list.append(Exc_LDAZTA)
+    return Exc_ZTA_list, Exc_LDAZTA_list
+
+def energy_diffs(temps, Exc_ZTA_list, Exc_LDAZTA_list, print_opt:bool = False):
+    """Calculates the difference between the Exact ZTA Exc and the LDAZTA Exc
+    This could really be abstracted to work with any functional but I will always default to saying LDA
+
+    Args:
+        temps (list): list of temperatures
+        Exc_ZTA_list (list): list of exact ZTA Exc values
+        Exc_LDAZTA_list (_type_): list of approximate ZTA Exc values
+
+    Returns:
+        _type_: _description_
+    """     
+    LDA_diffs = []
+    for i in range(len(temps)):
+        xc_diff = Exc_LDAZTA_list[i] - Exc_ZTA_list[i]
+        LDA_diffs.append(xc_diff)
+        if print_opt: 
+            print(f"for tau = {temps[i]}")
+            print(f"Exact ZTA E_xc = {Exc_ZTA_list[i]}")
+            print(f"LDA ZTA E_xc = {Exc_LDAZTA_list[i]}")
+            print(f"Difference due to use of LDA approximation = {LDA_diffs[i]}\n")
+    return LDA_diffs
+
+
+### Defining reader functions 
+def get_octo_FilePaths(molecule=str, temp=str, direction=str):
+    """
+    Reads data for the FT molecule
+    """
+    default_preMethod_path = os.path.join('~', 'ft_inversion_paper', 'LDAZTA', molecule, 'LDA')
+    dens_path = os.path.expanduser(os.path.join(default_preMethod_path, temp, direction, 'static', 'density.y=0,z=0'))
+    vks_path = os.path.expanduser(os.path.join(default_preMethod_path, temp, direction, 'static', 'vks.y=0,z=0'))
+    vxc_path = os.path.expanduser(os.path.join(default_preMethod_path, temp, direction, 'static', 'vxc.y=0,z=0'))
+    return dens_path, vks_path, vxc_path
+def get_octo_Data(molecule=str, temp=str, direction=str): 
+    """
+    Reads data for the FT molecule
+    """
+    dens_path, vks_path, vxc_path = get_octo_FilePaths(molecule, temp, direction)
+    x_grid = np.loadtxt(dens_path)[:,0]  # 1D grid
+    dens = np.loadtxt(dens_path)[:,1]
+    vks = np.loadtxt(vks_path)[:,1]
+    vxc = np.loadtxt(vxc_path)[:,1]
+    return x_grid, dens, vks, vxc
+
+def get_exact_file_paths(molecule=str): 
+    default_preMethod_path = os.path.join('~', 'ft_inversion_paper', 'LDAZTA', molecule, 'exact')
+    vxc_path = os.path.expanduser(os.path.join(default_preMethod_path, 'xc_potential.pkl' ))
+    vs_path = os.path.expanduser(os.path.join(default_preMethod_path, 'ks_potential.pkl' ))
+    
+    return vxc_path, vs_path
+
+
+def get_exact_data(molecule=str): 
+    vxc_path, vs_path = get_exact_file_paths(molecule)
+    with open(vxc_path, 'rb') as xc_file:
+        v_xc = pickle.load(xc_file)
+    with open(vs_path, 'rb') as vs_file:
+        v_s = pickle.load(vs_file)
+
+    return v_xc, v_s 

ft_inversion_tools-0.0.1.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: FT_inversion_tools
+Version: 0.0.1
+Summary: A small package containing tools needed to perform analysis for the FT inversions paper. Packaged for consistency.
+Author-email: "Anthony R. Osborne" <anthony.r.osborne019@pm.me>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9

ft_inversion_tools-0.0.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+FTI_analysis_tools.py,sha256=W2P2c3qCXpaF1TDTfb8xHFK3etNQHVMaZKtvvFsvzq8,3378
+ZTA_analysis_tools.py,sha256=LWqrmEn6qKNFB4jmL-SMOo10C8W-f_b4Pme7J4iDW6A,8851
+ft_inversion_tools-0.0.1.dist-info/METADATA,sha256=0amettqwXKvn5iCvQYW4k_g5tqQ4VmMI0tgkoBuCm5M,392
+ft_inversion_tools-0.0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+ft_inversion_tools-0.0.1.dist-info/top_level.txt,sha256=f0XBkiC6NINUESHV8UzHgRPj3MftHbcog-PvX9-BHhg,38
+ft_inversion_tools-0.0.1.dist-info/RECORD,,

ft_inversion_tools-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ft_inversion_tools-0.0.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+FTI_analysis_tools
+ZTA_analysis_tools