calphy 1.3.10__py3-none-any.whl → 1.3.13__py3-none-any.whl

calphy/__init__.py

@@ -4,7 +4,7 @@ from calphy.solid import Solid
 from calphy.alchemy import Alchemy
 from calphy.routines import MeltingTemp
 
-__version__ = "1.3.10"
+__version__ = "1.3.13"
 
 def addtest(a,b):
     return a+b

calphy/input.py

@@ -40,19 +40,7 @@ from pyscal3.core import structure_dict, element_dict, _make_crystal
 from ase.io import read, write
 import shutil
 
-__version__ = "1.3.10"
-
-def read_report(folder):
-    """
-    Read the finished calculation report
-    """
-    repfile = os.path.join(folder, "report.yaml")
-    if not os.path.exists(repfile):
-        raise FileNotFoundError(f"file {repfile} not found")
-
-    with open(repfile, 'r') as fin:
-        data = yaml.safe_load(fin)
-    return data
+__version__ = "1.3.13"
 
 def _check_equal(val):
     if not (val[0]==val[1]==val[2]):

calphy/integrators.py

@@ -38,12 +38,13 @@ from ase.io import read
 
 #Constants
 h = const.physical_constants["Planck constant in eV/Hz"][0]
+hJ = const.physical_constants["Planck constant"][0]
 hbar = h/(2*np.pi)
 kb = const.physical_constants["Boltzmann constant in eV/K"][0]
 kbJ = const.physical_constants["Boltzmann constant"][0]
 Na = const.physical_constants["Avogadro constant"][0]
 eV2J = const.eV
-
+J2eV = 6.242E18
 
 #--------------------------------------------------------------------
 #             TI PATH INTEGRATION ROUTINES
@@ -469,23 +470,18 @@ def get_einstein_crystal_fe(
     calc,
     vol, 
     k, 
-    cm_correction=True):
+    cm_correction=True,
+    return_contributions=False):
     """
     Get the free energy of einstein crystal
 
     Parameters
     ----------
-    temp : temperature, float
-        units - K
-
-    natoms : int
-        no of atoms in the system
-
-    mass : float
-        units - g/mol
+    calc : Calculation object
+        contains all input parameters
 
-    a : lattice constant, float
-        units - Angstrom
+    vol : float
+        converged volume per atom
 
     k : spring constant, float
         units - eV/Angstrom^2
@@ -493,40 +489,77 @@ def get_einstein_crystal_fe(
     cm_correction : bool, optional, default - True
         add the centre of mass correction to free energy
 
+    return_contributions: bool, optional, default - True
+        If True, return individual contributions to the reference free energy.
+
     Returns
     -------
-    fe : float
-        free energy of Einstein crystal
+    F_tot : float
+        total free energy of reference crystal
+
+    F_e : float
+        Free energy of Einstein crystal without centre of mass correction. Only if `return_contributions` is True.
+
+    F_cm : float
+        centre of mass correction. Only if `return_contributions` is True.
+
+    Notes
+    -----
+    The equations for free energy of Einstein crystal and centre of mass correction are from https://doi.org/10.1063/5.0044833.
 
     """
-    #convert mass first for single particle in kg
-    mass = np.array([calc._element_dict[x]['mass'] for x in calc.element])
-    mass = (mass/Na)*1E-3
-    natoms = np.sum([calc._element_dict[x]['count'] for x in calc.element])
-    concentration = np.array([calc._element_dict[x]['composition'] for x in calc.element])
+    #temperature
+    temp = calc._temperature
 
-    #convert k from ev/A2 to J/m2
-    k = np.array(k)*(eV2J/1E-20)
-    omega = np.sqrt(k/mass)
+    #natoms
+    natoms = np.sum([calc._element_dict[x]['count'] for x in calc.element])
 
     #convert a to m3
     vol = vol*1E-30
 
-    F_harm = 0
-    F_cm = 0
+    #whats the beta
+    beta = (1/(kbJ*temp))   
 
-    for count, om in enumerate(omega):
-        if concentration[count] > 0:
-            F_harm += concentration[count]*np.log((hbar*om)/(kb*calc._temperature))
-            if cm_correction:
-                F_cm += np.log((natoms*concentration[count]/vol)*(2*np.pi*kbJ*calc._temperature/(natoms*concentration[count]*k[count]))**1.5)
-            #F_cm = 0
-    F_harm = 3*kb*calc._temperature*F_harm
-    F_cm = (kb*calc._temperature/natoms)*F_cm
-
-    F_harm = F_harm + F_cm
+    #create an array of mass
+    mass = []
+    for x in calc.element:
+        for count in range(calc._element_dict[x]['count']):
+            mass.append(calc._element_dict[x]['mass'])
+    mass = np.array(mass)
+    
+    #convert mass to kg
+    mass = (mass/Na)*1E-3
 
-    return F_harm
+    #create an array of k as well
+    karr = []
+    for c, x in enumerate(calc.element):
+        for count in range(calc._element_dict[x]['count']):
+            karr.append(k[c])
+    k = np.array(karr)
+    #convert k from ev/A2 to J/m2
+    k = k*(eV2J/1E-20)
+
+    #fe of Einstein crystal
+    Z_e = ((beta**2*k*hJ**2)/(4*np.pi**2*mass))**1.5
+    F_e = np.log(Z_e)
+    F_e = kb*temp*np.sum(F_e)/natoms #*J2eV #convert back to eV
+
+    #now get the cm correction
+    if cm_correction:
+        mass_sum = np.sum(mass)
+        mu = mass/mass_sum
+        mu2_over_k = mu**2/k
+        mu2_over_k_sum = np.sum(mu2_over_k) 
+        prefactor = vol
+        F_cm = np.log(prefactor*(beta/(2*np.pi*mu2_over_k_sum))**1.5)
+        F_cm = kb*temp*F_cm/natoms #convert to eV
+    else:
+        F_cm = 0
+    
+    F_tot = F_e - F_cm
+    if return_contributions:
+        return F_e, -F_cm
+    return F_tot
 
 #--------------------------------------------------------------------
 #             REF. STATE ROUTINES: LIQUID

calphy/phase.py

@@ -163,6 +163,8 @@ class Phase:
 
         self.ferr = 0
         self.fref = 0
+        self.feinstein = 0
+        self.fcm = 0
         self.fideal = 0
         
         self.w = 0
@@ -596,8 +598,12 @@ class Phase:
         
         #now we can check if it converted
         file = os.path.join(self.simfolder, "avg.dat")
-        lx, ly, lz, ipress = np.loadtxt(file, usecols=(1, 2, 3, 4), unpack=True)
-        lxpc = ipress
+        #we have to clean the data, so as just the last block is selected
+        lx, ly, lz, lxpc = np.loadtxt(file, usecols=(1, 2, 3, 4), unpack=True)
+        lx = lx[-ncount+1:]
+        ly = ly[-ncount+1:]
+        lz = lx[-ncount+1:]
+        lxpc = lxpc[-ncount+1:]
         mean = np.mean(lxpc)
         std = np.std(lxpc)
         volatom = np.mean((lx*ly*lz)/self.natoms)
@@ -610,16 +616,20 @@ class Phase:
             ncount = int(self.calc.md.n_small_steps)//int(self.calc.md.n_every_steps*self.calc.md.n_repeat_steps)
 
         file = os.path.join(self.simfolder, "avg.dat")
-        lx, ly, lz, ipress = np.loadtxt(file, usecols=(1, 2, 3, 4), unpack=True)        
-        lxpc = ipress
+        lx, ly, lz, lxpc = np.loadtxt(file, usecols=(1, 2, 3, 4), unpack=True)        
+        lx = lx[-ncount+1:]
+        ly = ly[-ncount+1:]
+        lz = lx[-ncount+1:]
+        lxpc = lxpc[-ncount+1:]
+
         mean = np.mean(lxpc)
         std = np.std(lxpc)
         volatom = np.mean((lx*ly*lz)/self.natoms)
 
         self.calc._pressure = mean
-        self.lx = np.round(np.mean(lx[-ncount+1:]), decimals=3)
-        self.ly = np.round(np.mean(ly[-ncount+1:]), decimals=3)
-        self.lz = np.round(np.mean(lz[-ncount+1:]), decimals=3)
+        self.lx = np.round(np.mean(lx), decimals=3)
+        self.ly = np.round(np.mean(ly), decimals=3)
+        self.lz = np.round(np.mean(lz), decimals=3)
         self.volatom = volatom
         self.vol = self.lx*self.ly*self.lz
         self.rho = self.natoms/(self.lx*self.ly*self.lz)
@@ -682,6 +692,8 @@ class Phase:
         report["results"]["free_energy"] = float(self.fe)
         report["results"]["error"] = float(self.ferr)
         report["results"]["reference_system"] = float(self.fref)
+        report["results"]["einstein_crystal"] = float(self.feinstein)
+        report["results"]["com_correction"] = float(self.fcm)
         report["results"]["work"] = float(self.w)
         report["results"]["pv"] = float(self.pv)
         report["results"]["unit"] = "eV/atom"

calphy/postprocessing.py

@@ -0,0 +1,229 @@
+import os
+import numpy as np
+import yaml
+import matplotlib.pyplot as plt
+import warnings
+
+def read_report(folder):
+    """
+    Read the finished calculation report
+
+    Parameters
+    ----------
+    folder: string
+        folder from which calculation is to be read
+    
+    Returns
+    -------
+    data: dict
+        dictionary with results
+
+    """
+    repfile = os.path.join(folder, "report.yaml")
+    if not os.path.exists(repfile):
+        raise FileNotFoundError(f"file {repfile} not found")
+
+    with open(repfile, 'r') as fin:
+        data = yaml.safe_load(fin)
+    return data
+
+def _extract_error(errfile):
+    error_code = None
+    if os.path.exists(errfile):
+        with open(errfile, 'r') as fin:
+            for line in fin:
+                if 'calphy.errors' in line:
+                    break
+            try:
+                error_code = line.split(':')[0].split('.')[-1]
+            except:
+                pass
+    return error_code
+    
+def gather_results(mainfolder):
+    """
+    Gather results from all subfolders in a given folder into a Pandas DataFrame
+
+    Parameters
+    ----------
+    mainfolder: string
+        folder where calculations are stored
+    
+    Returns
+    -------
+    df: pandas DataFrame
+        DataFrame with results
+    """
+    try:
+        import pandas as pd
+    except ImportError:
+        raise ImportError('Please install pandas to use this function')
+     
+    datadict = {}
+    datadict['mode'] = []
+    datadict['status'] = []
+    datadict['temperature'] = []
+    datadict['pressure'] = []
+    datadict['free_energy'] = []
+    datadict['reference_phase'] = []
+    datadict['error_code'] = []
+    datadict['composition'] = []
+    datadict['calculation'] = []
+    
+    folders = next(os.walk(mainfolder))[1]
+    for folder in folders:
+        #adjust for pyiron folder, see
+        if folder.split('_')[-1] == 'hdf5':
+            #this could be a pyiron calc
+            withouthdf = folder.split('_hdf5')[0]
+            folder = f'{folder}/{withouthdf}'
+            
+        inpfile = os.path.join(mainfolder, folder, 'input_file.yaml')
+        #print(inpfile)
+        if not os.path.exists(inpfile):
+            continue;
+        
+        #ok, valid calculation, try to parse input file to get info
+        with open(inpfile, 'r') as fin:
+            inp = yaml.safe_load(fin)
+        #grab the first calculation
+        inp = inp['calculations'][0]
+        #mode
+        mode = inp['mode']
+        datadict['mode'].append(mode)
+        datadict['temperature'].append(inp['temperature'])
+        datadict['pressure'].append(inp['pressure'])
+        datadict['reference_phase'].append(inp['reference_phase'])
+        datadict['composition'].append(None)
+        datadict['calculation'].append(folder)
+    
+        #check output file
+        outfile = os.path.join(mainfolder, folder, 'report.yaml')
+        datadict['error_code'].append(None)
+        
+        #print(inpfile)
+        if not os.path.exists(outfile):
+            datadict['status'].append('False')
+            datadict['free_energy'].append(np.NaN)
+            #check if error file is found
+            errfile = os.path.join(os.getcwd(), mainfolder, folder+'.sub.err')
+            datadict['error_code'][-1] = _extract_error(errfile)
+            continue;
+    
+        if mode in ['fe', 'alchemy', 'composition_scaling']:
+            datadict['status'].append('True')
+        
+        #ok, valid calculation, try to parse input file to get info
+        with open(outfile, 'r') as fin:
+            out = yaml.safe_load(fin)
+    
+        datadict['free_energy'].append(out['results']['free_energy'])
+        
+        #add normal composition
+        el_arr = np.array(out['input']['element'].split(' ')).astype(str)
+        comp_arr = np.array(out['input']['concentration'].split(' ')).astype(float)
+        composition = {x:y for x,y in zip(el_arr, comp_arr)}
+        datadict['composition'][-1] = composition
+
+        if mode == 'composition_scaling':
+            #we need to update composition
+            compdict = inp['composition_scaling']['output_chemical_composition']
+            maxatoms = np.sum([val for key, val in compdict.items()])
+            for key, val in compdict.items():
+                compdict[key] = val/maxatoms
+            datadict['composition'][-1] = compdict
+
+        #parse extra info
+        if mode in ['ts', 'tscale']:
+            datafile = os.path.join(os.getcwd(), mainfolder, folder, 'temperature_sweep.dat')
+            if os.path.exists(datafile):
+                datadict['status'].append('True')
+                t, f = np.loadtxt(datafile, unpack=True, usecols=(0,1))
+                datadict['temperature'][-1] = t
+                datadict['free_energy'][-1] = f
+            else:
+                datadict['status'].append('False')
+                errfile = os.path.join(os.getcwd(), mainfolder, folder+'.sub.err')
+                datadict['error_code'][-1] = _extract_error(errfile)
+
+    df = pd.DataFrame(data=datadict)
+    return df
+
+def find_transition_temperature(folder1, folder2, fit_order=4, plot=True):
+    """
+    Find transition temperature where free energy of two phases are equal.
+
+    Parameters
+    ----------
+    folder1: string
+        directory with temperature scale calculation
+
+    folder2: string
+        directory with temperature scale calculation
+
+    fit_order: int, optional
+        default 4. Order for polynomial fit of temperature vs free energy
+    
+    plot: bool, optional
+        default True. Plot the results.
+    """
+    file1 = os.path.join(folder1, 'temperature_sweep.dat')
+    file2 = os.path.join(folder2, 'temperature_sweep.dat')
+    if not os.path.exists(file1):
+        raise FileNotFoundError(f'{file1} does not exist')
+    if not os.path.exists(file2):
+        raise FileNotFoundError(f'{file2} does not exist')
+
+    t1, f1 = np.loadtxt(file1, unpack=True, usecols=(0,1))
+    t2, f2 = np.loadtxt(file2, unpack=True, usecols=(0,1))
+
+    #do some fitting to determine temps
+    t1min = np.min(t1)
+    t2min = np.min(t2)
+    t1max = np.max(t1)
+    t2max = np.max(t2)
+
+    tmin = np.min([t1min, t2min])
+    tmax = np.max([t1max, t2max])
+
+    #warn about extrapolation
+    if not t1min == t2min:
+        warnings.warn(f'free energy is being extrapolated!')
+    if not t1max == t2max:
+        warnings.warn(f'free energy is being extrapolated!')
+
+    #now fit
+    f1fit = np.polyfit(t1, f1, fit_order)
+    f2fit = np.polyfit(t2, f2, fit_order)
+
+    #reevaluate over the new range
+    fit_t = np.arange(tmin, tmax+1, 1)
+    fit_f1 = np.polyval(f1fit, fit_t)
+    fit_f2 = np.polyval(f2fit, fit_t)
+
+    #now evaluate the intersection temp
+    arg = np.argsort(np.abs(fit_f1-fit_f2))[0]
+    transition_temp = fit_t[arg]
+
+    #warn if the temperature is shady
+    if np.abs(transition_temp-tmin) < 1E-3:
+        warnings.warn('It is likely there is no intersection of free energies')
+    elif np.abs(transition_temp-tmax) < 1E-3:
+        warnings.warn('It is likely there is no intersection of free energies')
+
+    #plot
+    if plot:
+        c1lo = '#ef9a9a'
+        c1hi = '#b71c1c'
+        c2lo = '#90caf9'
+        c2hi = '#0d47a1'
+
+        plt.plot(fit_t, fit_f1, color=c1lo, label=f'{folder1} fit')
+        plt.plot(fit_t, fit_f2, color=c2lo, label=f'{folder2} fit')
+        plt.plot(t1, f1, color=c1hi, label=folder1, ls='dashed')
+        plt.plot(t2, f2, color=c2hi, label=folder2, ls='dashed')
+        plt.axvline(transition_temp, ls='dashed', c='#37474f')
+        plt.ylabel('Free energy (eV/atom)')
+        plt.xlabel('Temperature (K)')
+        plt.legend(frameon=False)
+    return transition_temp

calphy/solid.py

@@ -516,17 +516,20 @@ class Solid(cph.Phase):
         Calculates the final work, energy dissipation and free energy by
         matching with Einstein crystal
         """
-        f1 = get_einstein_crystal_fe(
+        fe, fcm = get_einstein_crystal_fe(
             self.calc,  
             self.vol, 
-            self.k)
+            self.k,
+            return_contributions=True)
         
         w, q, qerr = find_w(self.simfolder, 
             self.calc,
             full=True, 
             solid=True)
         
-        self.fref = f1
+        self.fref = fe + fcm
+        self.feinstein = fe
+        self.fcm = fcm
         self.w = w
         self.ferr = qerr
 

{calphy-1.3.10.dist-info → calphy-1.3.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: calphy
-Version: 1.3.10
+Version: 1.3.13
 Summary: free energy calculation for python
 Home-page: https://github.com/ICAMS/calphy
 Author: Sarath Menon, Yury Lysogorskiy, Ralf Drautz

{calphy-1.3.10.dist-info → calphy-1.3.13.dist-info}/RECORD

@@ -1,24 +1,25 @@
-calphy/__init__.py,sha256=w9XLioZKvY0Z1pvwKo_2S1s8SsILErVXJOpojhsHbA4,234
+calphy/__init__.py,sha256=O46MqskwAlD2DmoXB8prjLeuCUBlzHuKsv-SaqjTohY,234
 calphy/alchemy.py,sha256=epv_vJoAMVbj-S1TuPSbBGr4w_a9qEr4EIxKlgwdlSo,12893
 calphy/clitools.py,sha256=oDqaw0s-LJ7tAdW_Njk2SFljVx6K34Rs8sdMz48SNSI,4125
 calphy/composition_transformation.py,sha256=Hh240-iVGC8ATlJ3nQK757qVZIBrE2aw7dsF46mi3oo,15353
 calphy/errors.py,sha256=KN47RWTLbg1H_NZMrhCiJCbqjqJScJ1pgQAuzj1-l84,1268
 calphy/helpers.py,sha256=nj8g53H6ScohQtyV7Enzms8Rv_89PRrDDY1IHjFSZdQ,8292
-calphy/input.py,sha256=qI8BCx_zZ_909Jaa2sxePHQDcp4oDzychVaZKfUgAVM,29718
-calphy/integrators.py,sha256=pblWLGngLgjBbHwVsjl3K7pr3eh4z3oZ261XdLlQNOA,20774
+calphy/input.py,sha256=836ifhhVHm6Nd9jMWLjMUYKukk_pcZwvoGcLzQXIWuU,29400
+calphy/integrators.py,sha256=hJYmbznsgY-x-eZm7ng8gW0qsGbopERl5gGDnw5uLms,21719
 calphy/kernel.py,sha256=rd_-EfCiBhQjkxcVaoLtVJB2_qDgS-g-dQ0BZBTJQ_A,6190
 calphy/liquid.py,sha256=a5NTAjc3VsrPBQoEMGe9O1WXfv1vxGoB0xPguf0fOyM,13762
-calphy/phase.py,sha256=ukqad4MJ-MNGiyOsq2_jntG2s10UHbJVi2Ounpg_S2U,44787
+calphy/phase.py,sha256=NBkOGkG3U9Uo-dbupFWndOaaCiiSRoD8WHUpunYZty0,45190
 calphy/phase_diagram.py,sha256=2EwmT_qkT5BEP6Sx0_rm09kPP2RWh5JY4sogIBK_AhA,12992
+calphy/postprocessing.py,sha256=CztgekCvQ8lZPVfZ_hMAwlyvwetjSfADjTca8aVTftY,7602
 calphy/queuekernel.py,sha256=4GMIYnjMiAPipoLNKP5noYcfeEOI_vCqm84zgokk7Xw,5321
 calphy/routines.py,sha256=W6OZEPv6HEG11EYsoIbum2WVrO3Ly36i5UWsYQ4oBdQ,17473
 calphy/scheduler.py,sha256=IN8ogDedpTbZZsdpOj-hYZI05gWoD4bN7mHOb1z77Vo,8579
-calphy/solid.py,sha256=49gT0wNOP3h8lRDXarULP-bU09lIrnDCTUcyxE7X-UE,19795
+calphy/solid.py,sha256=ZU_c4LqASoLzhjXX6eQY_8k_FNO9wjmMVTiOCKNsmis,19896
 calphy/splines.py,sha256=BGwUVz_qXQxUzpUCuZo6CsELcd5JVNWzI-Ttcz22G_E,61627
 calphy/utils.py,sha256=0UpsYoxjS5N-iGs-cdm0YDMkLF8IHvKO3smXDHrj3eg,3818
-calphy-1.3.10.dist-info/LICENSE,sha256=XIHGB5RZLIhOjjoO1bPf0II-qDbjhP5Cv5HJMRE9v1g,16651
-calphy-1.3.10.dist-info/METADATA,sha256=-Pgiun1WuVVvcxqipSbOcN5TSr9AdYRJ_CQWpAE1KG4,4216
-calphy-1.3.10.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-calphy-1.3.10.dist-info/entry_points.txt,sha256=W9qq254koyWnAgo1jtfQP9bO5Q7sgZrzc8BMnfo3vf4,386
-calphy-1.3.10.dist-info/top_level.txt,sha256=w871dhMqPwgjjbifBWdkT9_aOnK1ek4Odrh8UnSG3PE,7
-calphy-1.3.10.dist-info/RECORD,,
+calphy-1.3.13.dist-info/LICENSE,sha256=XIHGB5RZLIhOjjoO1bPf0II-qDbjhP5Cv5HJMRE9v1g,16651
+calphy-1.3.13.dist-info/METADATA,sha256=JCQSN5W690zkuPLQ9vqmc8mSOr56K6GOq8EiqEaymWo,4216
+calphy-1.3.13.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+calphy-1.3.13.dist-info/entry_points.txt,sha256=W9qq254koyWnAgo1jtfQP9bO5Q7sgZrzc8BMnfo3vf4,386
+calphy-1.3.13.dist-info/top_level.txt,sha256=w871dhMqPwgjjbifBWdkT9_aOnK1ek4Odrh8UnSG3PE,7
+calphy-1.3.13.dist-info/RECORD,,

{calphy-1.3.10.dist-info → calphy-1.3.13.dist-info}/WHEEL

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