calphy 1.3.6__tar.gz → 1.3.8__tar.gz

{calphy-1.3.6/calphy.egg-info → calphy-1.3.8}/PKG-INFO

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

{calphy-1.3.6 → calphy-1.3.8}/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.6"
+__version__ = "1.3.8"
 
 def addtest(a,b):
     return a+b

{calphy-1.3.6 → calphy-1.3.8}/calphy/input.py

@@ -40,7 +40,7 @@ from pyscal3.core import structure_dict, element_dict, _make_crystal
 from ase.io import read, write
 import shutil
 
-__version__ = "1.3.6"
+__version__ = "1.3.8"
 
 def read_report(folder):
     """

{calphy-1.3.6 → calphy-1.3.8}/calphy/phase_diagram.py

@@ -4,47 +4,58 @@ import pandas as pd
 import matplotlib.pyplot as plt
 import warnings
 import itertools
+import math
 
 from calphy.integrators import kb
 
 from scipy.spatial import ConvexHull
 from scipy.interpolate import splrep, splev
 
-colors = ['#a6cee3','#1f78b4','#b2df8a','#33a02c','#fb9a99','#e31a1c','#fdbf6f','#ff7f00','#cab2d6','#6a3d9a','#ffff99','#b15928']
+colors = ['#a6cee3','#1f78b4','#b2df8a',
+'#33a02c','#fb9a99','#e31a1c',
+'#fdbf6f','#ff7f00','#cab2d6',
+'#6a3d9a','#ffff99','#b15928']
 
-def get_free_energy_at(d, phase, comp, temp, threshold=1E-1):
-    """
-    Extract free energy at given temperature
-    """
-    tarr = np.array(d[phase]["%.2f"%comp]["temperature"])
+
+def _get_temp_arg(tarr, temp, threshold=1E-1):
+    if tarr is None:
+        return None
     arg = np.argsort(np.abs(tarr-temp))[0]
+
     th = np.abs(tarr-temp)[arg] 
     if th > threshold:
-        val = None
+        arg = None
+    return arg
+
+def _is_val_ok(val):
+    if val is None:
+        return False
+    elif math.isnan(val):
+        return False
     else:
-        val = d[phase]["%.2f"%comp]["free_energy"][arg] 
-    return val
-    
-def calculate_configurational_entropy(x, correction=0):
-    """
-    Calculate configurational entropy
-    """
+        return True
+
+def _get_fe_at_args(arr, args):
+    fes = []
+    for count, x in enumerate(args):
+        if _is_val_ok(x):
+            fes.append(arr[count][int(x)])
+        else:
+            fes.append(None)
+    return fes
+
+def _calculate_configurational_entropy(x, correction=0):
     if correction == 0:
         s = np.array([(c*np.log(c) + (1-c)*np.log(1-c)) if 1 > c > 0 else 0 for c in x])
     else:
         arg = np.argsort(np.abs(x-correction))[0]
         left_side = x[:arg+1]
         right_side = x[arg:]
-        #print(len(left_side))
-        #print(left_side)
-        #print(len(right_side))
-        #print(right_side)
 
         if len(left_side)>0:
             left_side = left_side/left_side[-1]
             s_left = np.array([(c*np.log(c) + (1-c)*np.log(1-c)) if 1 > c > 0 else 0 for c in left_side])
-            
-        #correct to zero
+        
         if len(right_side)>0:
             right_side = right_side - right_side[0]
             right_side = right_side/right_side[-1]
@@ -56,81 +67,122 @@ def calculate_configurational_entropy(x, correction=0):
             return s_left
         else:
             return np.concatenate((s_left, s_right[1:]))
-        
-        
     return -s
 
-#def get_free_energy_splines(composition, free_energy, k=3):
-#    """
-#    Create splines for free energy, and return them
-#    """
-#    return splrep(comp, fes, k=3)
-
-def get_free_energy_fit(composition, free_energy, fit_order=5):
+def _get_free_energy_fit(composition, 
+                        free_energy, 
+                        fit_order=5,
+                        end_weight=3,
+                        end_indices=4):
     """
     Create splines for free energy, and return them
     """
     weights = np.ones_like(free_energy)
-    weights[0:4] = 3
-    weights[-4:] = 3
+    weights[0:end_indices] = end_weight
+    weights[-end_indices:] = end_weight
     fit = np.polyfit(composition, free_energy, fit_order, w=weights)
     return fit
 
-
-def get_phase_free_energy(data, phase, temp, 
+def get_phase_free_energy(df, phase, temp, 
+                          composition_interval=(0, 1),
                           ideal_configurational_entropy=False,
                           entropy_correction=0.0,
-                          composition_grid=10000,
                           fit_order=5,
-                          plot=False,
-                          composition_interval=(0, 1),
+                          composition_grid=10000,
                           composition_cutoff=None,
-                          reset_value=1):
+                          reset_value=1,
+                          plot=False):
     """
-    Extract free energy for given phase
+    Get the free energy of a phase as a function of composition.
+
+    Parameters
+    ----------
+    df: Pandas dataframe
+        Dataframe consisting of values from simulation. Should contain at least columns composition, phase, `free_energy` and `temperature`.
+        `energy_free` and `temperature` should be arrays of equal length, generally an output from reversible scaling calculation.
+
+    phase: str
+        phase for which calculation is to be done. Should be present in `df`.
+
+    temp: float
+        temperature at which the free energy curves are to be calculated.
+
+    composition_interval: tuple, optional
+        If provided, this composition interval is considered. Default (0, 1)
+
+    ideal_configuration_entropy: bool, optional\
+        If True, add the ideal configurational entropy. See Notes. Default False.
+
+    entropy_correction: float, optional.
+        The composition of the ordered phase. See Notes. Default None.
+
+    fit_order: int, optional
+        Order of the polynomial fit used for fitting free energy as a function of composition. Default 5.
+
+    composition_grid: int, optional
+        Number of composition points to be used for fitting. Default 10000.
+
+    composition_cutoff: float, optional
+        term for correcting incomplete data. If two consecutive composition values are separated by more than `composition_cutoff`,
+        it is reset to `reset_value`. Default None.
+
+    reset_value: float, optional
+        see above. Default 1.
+
+    plot: bool, optional
+        If True, plot the calculated free energy curves.
+
+    Returns
+    -------
+    result_dict: dict
+        contains keys: "phase", "temperature", "composition", "free_energy", and "entropy".
+
+    Notes
+    -----
+    To be added
     """
-    comporg = list(data[phase]["composition"])
-    fes = []
-    comp = []
-    
-    for c in comporg:
-        if (composition_interval[0] <= c <= composition_interval[1]):
-            f = get_free_energy_at(data, phase, float(c), temp)
-            if f is not None:
-                fes.append(f)
-                comp.append(c)
+    df_phase = df.loc[df['phase']==phase]
+    #drop Nones
+    df_phase = df_phase.sort_values(by="composition")
+    df_phase = df_phase[(df_phase['composition'] >= composition_interval[0]) & (df_phase['composition'] <= composition_interval[1])]
     
-    fes = np.array(fes)
-    comp = np.array(comp)
+    composition = df_phase['composition'].values
+    args = df_phase["temperature"].apply(_get_temp_arg, args=(temp,))
+    fes = _get_fe_at_args(df_phase["free_energy"].values, args)
     
+    #print(fes)
+    #filter out None values
+    composition = np.array([composition[count] for count, x in enumerate(fes) if x is not None])
+    fes = np.array([x for x in fes if x is not None])
+
     if (len(fes)==0) or (fes is None):
         warnings.warn("Some temperatures could not be found!")
-    else:  
+    else:
         if ideal_configurational_entropy:
-            entropy_term = kb*temp*calculate_configurational_entropy(comp, correction=entropy_correction) 
+            entropy_term = kb*temp*_calculate_configurational_entropy(composition, 
+                                                                     correction=entropy_correction) 
             fes = fes - entropy_term
         else:
             entropy_term = []
 
-        fe_fit = get_free_energy_fit(comp, fes, fit_order=fit_order)
-        compfine = np.linspace(np.min(comp), np.max(comp), composition_grid)
-
-        fe = np.polyval(fe_fit, compfine)
+        fe_fit = _get_free_energy_fit(composition, fes, fit_order=fit_order)
+        compfine = np.linspace(np.min(composition), np.max(composition), composition_grid)
         
-        #fix missing values; assign +0.01 to all values which are not within vicinity
+        #now fit on the comp grid again
+        fe = np.polyval(fe_fit, compfine)
+
         if composition_cutoff is not None:
-            #so we go along composition, see if there are points with no adjacent comp values, ignore them
-            distances = [np.min(np.abs(c-comp)) for c in compfine]
+            distances = [np.min(np.abs(c-composition)) for c in compfine]
             filters = [x for x in range(len(distances)) if distances[x] > composition_cutoff]
             fe[filters] = reset_value
-            
+
         if plot:
-            plt.scatter(comp, fes, s=4, label=f'{phase}-calc.', color=colors[np.random.randint(len(colors))])
-            plt.plot(compfine, fe, label=f'{phase}-fit', color=colors[np.random.randint(len(colors))])
+            plt.scatter(composition, fes, s=4, label=f'{phase}-calc.', color="#e57373")
+            plt.plot(compfine, fe, label=f'{phase}-fit', color="#b71c1c")
             plt.xlabel("x")
             plt.ylabel("F (eV/atom)")
             plt.legend()
-            #plt.ylim(top=0.0)
+        
         return {"phase":phase, "temperature": temp, "composition": compfine, 
                 "free_energy": fe, "entropy": entropy_term}
     return None
@@ -139,7 +191,14 @@ def get_phase_free_energy(data, phase, temp,
 def get_free_energy_mixing(dict_list, threshold=1E-3):
     """
     Input is a list of dictionaries
+
+    Get free energy of mixing by subtracting end member values.
+    End members are chosen automatically.
     """
+    dict_list = np.atleast_1d(dict_list)
+
+    dict_list = np.array([dct for dct in dict_list if dct is not None])
+
     #we have to get min_comp from all possible values
     min_comp = np.min([np.min(d["composition"]) for d in dict_list])
     max_comp = np.max([np.max(d["composition"]) for d in dict_list])
@@ -236,13 +295,17 @@ def get_tangent_type(dict_list, tangent, energy):
     return phase_str
             
     
-def get_common_tangents(dict_list, peak_cutoff=0.01, plot=False, 
+def get_common_tangents(dict_list, 
+                        peak_cutoff=0.01, 
+                        plot=False, 
                         remove_self_tangents_for=[],
                         color_dict=None):
     """
     Get common tangent constructions using convex hull method
     """
-    points = np.vstack([np.column_stack((d["composition"], d["free_energy_mix"])) for d in dict_list]) 
+    points = np.vstack([np.column_stack((d["composition"], 
+        d["free_energy_mix"])) for d in dict_list]) 
+    
     if color_dict is None:
         color_dict = create_color_list(dict_list) 
     
@@ -266,6 +329,7 @@ def get_common_tangents(dict_list, peak_cutoff=0.01, plot=False,
     tangents = []
     energies = []    
     tangent_colors = []
+    phases = []
     
     for d in dist:
         t = [convex_x[sargs][d], convex_x[sargs][d+1]]
@@ -276,6 +340,7 @@ def get_common_tangents(dict_list, peak_cutoff=0.01, plot=False,
             tangents.append(t)
             energies.append(e)
             tangent_colors.append(color_dict[phase_str])
+            phases.append(phase_str.split("-"))
     
     if plot:
         for d in dict_list:
@@ -283,5 +348,25 @@ def get_common_tangents(dict_list, peak_cutoff=0.01, plot=False,
         for t, e in zip(tangents, energies):
             plt.plot(t, e, color="black", ls="dashed")
         plt.ylim(top=0.0)
-    return np.array(tangents), np.array(energies), np.array(tangent_colors), color_dict
+    
+    return np.array(tangents), np.array(energies), np.array(tangent_colors), color_dict, np.array(phases)
+
+
+def plot_phase_diagram(tangents, temperature,
+    colors,
+    edgecolor="#37474f",
+    linewidth=1,
+    linestyle='-'):
+    
+    fig, ax = plt.subplots(edgecolor=edgecolor)
+
+    for count, x in enumerate(tangents):
+        for c, a in enumerate(x):
+            ax.plot(np.array(a), 
+                     [temperature[count], temperature[count]], 
+                     linestyle,
+                     lw=linewidth,
+                     c=colors[count][c],
+                     )
+    return fig
 

{calphy-1.3.6 → calphy-1.3.8}/calphy/scheduler.py

@@ -106,7 +106,7 @@ class SLURM:
         for (key, val) in options.items():
             if key in self.queueoptions.keys():
                 if val is not None:
-                    if val is not "":
+                    if val != "":
                         self.queueoptions[key] = val
         self.maincommand = ""
 

calphy-1.3.8/calphy/utils.py

@@ -0,0 +1,108 @@
+from calphy.input import read_inputfile
+import shutil
+from ase.io import read
+import numpy as np
+from tqdm.notebook import trange
+import os
+import re
+
+try:
+    from pyiron_atomistics import Project
+    from pyiron_atomistics.atomistics.structure.atoms import ase_to_pyiron
+except ImportError:
+    raise ImportError('This feature needs pyiron_atomistics installed')
+
+def create_job_from_inputfile(pr, inputfile, potential, kernel=None):
+    """
+    Create a pyiron job from calphy input file
+    
+    Parameters
+    ----------
+    pr: pyiron Project
+        project to which the job is to be added
+    
+    inputfile: string
+        calphy input file
+    
+    potential: string
+        name of the potential as present in pyiron
+    
+    kernel: int, optional
+        the index of the calculation to be read in. If None, all calculations are read in
+    """
+    calcs = read_inputfile(inputfile)
+    
+    if kernel is None:
+        kernel = [x for x in range(len(calcs))]
+    kernel = np.atleast_1d(kernel)
+    
+    for i in trange(len(kernel)):
+        calc = calcs[kernel[i]]
+        basedir = calc.create_identifier()
+        basedir_path = os.path.join(os.path.dirname(inputfile), basedir)
+        
+        if os.path.exists(basedir_path):
+            #create job and copy files
+            try:
+                #make sure that the report file exists
+                reportfile = os.path.join(basedir_path, 'report.yaml')
+                if os.path.exists(reportfile):
+                    job = pr.create.job.Calphy(basedir.replace('-', '_'))
+                    job._job_id = pr.db.add_item_dict(job.db_entry())
+                    job.refresh_job_status()
+                    shutil.copytree(basedir_path, job.working_directory, dirs_exist_ok=True)
+
+                    #read in structure, assign potential
+                    Z_of_type = dict([(count+1, calc._element_dict[element]['atomic_number']) for count, element in enumerate(calc.element)])
+                    structure = read(calc.lattice, format='lammps-data', style='atomic', Z_of_type=Z_of_type)
+                    job.structure = ase_to_pyiron(structure)
+                    job.potential = potential
+                    pr.db.item_update({"ChemicalFormula": job.structure.get_chemical_formula()}, job._job_id)
+
+                    #collect output
+                    job.input.mode = calc.mode
+                    job.status.collect = True
+                    job.collect_output()
+
+                    #populate inputs
+                    calcdict = calc.model_dump()
+                    #temporary fix for comp scaling until its introduced in pyiron
+                    del calcdict['composition_scaling']
+                    job.input.update(calcdict)
+                    job._create_calc()
+                    job.to_hdf()
+                    job.status.finished = True
+                else:
+                    print(f'parsing {basedir_path} failed, skipping')   
+            except:
+                #delete job
+                pr.remove_job(basedir.replace('-', '_'))
+                print(f'parsing {basedir_path} failed, skipping')
+        else:
+            print(f'could not find {basedir_path}, skipping')
+
+
+def get_free_energy(job):
+    return job["output/energy_free"]
+
+def get_temperature(job):
+    return job["output/temperature"]
+
+def get_phase(job):
+    raw = job.name.split('_')
+    if raw[-3] == 'liquid':
+        phase = 'liquid'
+    else:
+        phase = raw[1]
+    return phase
+
+def get_composition(job):
+    chem = job.project.db.get_item_by_id(job.id)['chemicalformula']
+    comp_split = re.split('(\d+)', chem)[:-1]
+    if len(comp_split) == 2:
+        if comp_split[0] == 'Al':
+            return 0.00
+        else:
+            return 1.00
+    else:
+        return int(comp_split[3])/(int(comp_split[1])+int(comp_split[3]))

{calphy-1.3.6 → calphy-1.3.8/calphy.egg-info}/PKG-INFO

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

{calphy-1.3.6 → calphy-1.3.8}/setup.py

@@ -53,7 +53,7 @@ setup(
     packages=find_packages(include=['calphy', 'calphy.*']),
     test_suite='tests',
     url='https://github.com/ICAMS/calphy',
-    version='1.3.6',
+    version='1.3.8',
     zip_safe=False,
     entry_points={
         'console_scripts': [

calphy-1.3.6/calphy/utils.py

@@ -1,74 +0,0 @@
-from calphy.input import read_inputfile
-import shutil
-from ase.io import read
-import numpy as np
-from tqdm.notebook import trange
-import os
-
-try:
-    from pyiron_atomistics import Project
-    from pyiron_atomistics.atomistics.structure.atoms import ase_to_pyiron
-except ImportError:
-    raise ImportError('This feature needs pyiron_atomistics installed')
-
-def create_job_from_inputfile(pr, inputfile, potential, kernel=None):
-    """
-    Create a pyiron job from calphy input file
-    
-    Parameters
-    ----------
-    pr: pyiron Project
-        project to which the job is to be added
-    
-    inputfile: string
-        calphy input file
-    
-    potential: string
-        name of the potential as present in pyiron
-    
-    kernel: int, optional
-        the index of the calculation to be read in. If None, all calculations are read in
-    """
-    calcs = read_inputfile(inputfile)
-    
-    if kernel is None:
-        kernel = [x for x in range(len(calcs))]
-    kernel = np.atleast_1d(kernel)
-    
-    for i in trange(len(kernel)):
-        calc = calcs[kernel[i]]
-        basedir = calc.create_identifier()
-        basedir_path = os.path.join(os.path.dirname(inputfile), basedir)
-        
-        if os.path.exists(basedir_path):
-            #create job and copy files
-            try:
-                job = pr.create.job.Calphy(basedir.replace('-', '_'))
-                job._job_id = pr.db.add_item_dict(job.db_entry())
-                job.refresh_job_status()
-                shutil.copytree(basedir_path, job.working_directory, dirs_exist_ok=True)
-
-                #read in structure, assign potential
-                Z_of_type = dict([(count+1, calc._element_dict[element]['atomic_number']) for count, element in enumerate(calc.element)])
-                structure = read(calc.lattice, format='lammps-data', style='atomic', Z_of_type=Z_of_type)
-                job.structure = ase_to_pyiron(structure)
-                job.potential = potential
-                pr.db.item_update({"ChemicalFormula": job.structure.get_chemical_formula()}, job._job_id)
-
-                #collect output
-                job.input.mode = calc.mode
-                job.status.collect = True
-                job.collect_output()
-
-                #populate inputs
-                calcdict = calc.model_dump()
-                #temporary fix for comp scaling until its introduced in pyiron
-                del calcdict['composition_scaling']
-                job.input.update(calcdict)
-                job._create_calc()
-                job.to_hdf()
-                job.status.finished = True    
-            except:
-                print(f'parsing {basedir_path} failed, skipping')
-        else:
-            print(f'could not find {basedir_path}, skipping')