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

calphy/postprocessing.py

@@ -3,6 +3,7 @@ import numpy as np
 import yaml
 import matplotlib.pyplot as plt
 import warnings
+import pandas as pd
 
 def read_report(folder):
     """
@@ -40,7 +41,8 @@ def _extract_error(errfile):
                 pass
     return error_code
     
-def gather_results(mainfolder):
+def gather_results(mainfolder, reduce_composition=True, 
+    extract_phase_prefix=False):
     """
     Gather results from all subfolders in a given folder into a Pandas DataFrame
 
@@ -49,6 +51,14 @@ def gather_results(mainfolder):
     mainfolder: string
         folder where calculations are stored
     
+    reduce_composition: bool
+        If True, per species composition arrays are added.
+        Might be redundant.
+    
+    extract_phase_prefix: bool
+        Should be used in conjuction with phase diagram mode. 
+        Extracts the prefix and add it as a phase_name column.
+    
     Returns
     -------
     df: pandas DataFrame
@@ -58,9 +68,10 @@ def gather_results(mainfolder):
         import pandas as pd
     except ImportError:
         raise ImportError('Please install pandas to use this function')
-     
+
+    unique_elements = []
     datadict = {}
-    datadict['mode'] = []
+    datadict['calculation_mode'] = []
     datadict['status'] = []
     datadict['temperature'] = []
     datadict['pressure'] = []
@@ -69,6 +80,9 @@ def gather_results(mainfolder):
     datadict['error_code'] = []
     datadict['composition'] = []
     datadict['calculation'] = []
+    datadict['ideal_entropy'] = []
+    datadict['phase_name'] = []
+    datadict['reference_composition'] = []
     
     folders = next(os.walk(mainfolder))[1]
     for folder in folders:
@@ -90,11 +104,14 @@ def gather_results(mainfolder):
         inp = inp['calculations'][0]
         #mode
         mode = inp['mode']
-        datadict['mode'].append(mode)
+        datadict['calculation_mode'].append(mode)
         datadict['temperature'].append(inp['temperature'])
         datadict['pressure'].append(inp['pressure'])
         datadict['reference_phase'].append(inp['reference_phase'])
+        datadict['phase_name'].append(inp['phase_name'])
+        datadict['reference_composition'].append(inp['reference_composition'])
         datadict['composition'].append(None)
+        datadict['ideal_entropy'].append(0)
         datadict['calculation'].append(folder)
     
         #check output file
@@ -132,6 +149,15 @@ def gather_results(mainfolder):
             for key, val in compdict.items():
                 compdict[key] = val/maxatoms
             datadict['composition'][-1] = compdict
+            el_arr = list(compdict.keys())
+
+            #we also need to update entropy
+            if 'entropy_contribution' in out['results'].keys():
+                datadict['ideal_entropy'][-1] = -1*out['results']['entropy_contribution']
+
+        for el in el_arr:
+            if el not in unique_elements:
+                unique_elements.append(el)
 
         #parse extra info
         if mode in ['ts', 'tscale']:
@@ -146,9 +172,171 @@ def gather_results(mainfolder):
                 errfile = os.path.join(os.getcwd(), mainfolder, folder+'.sub.err')
                 datadict['error_code'][-1] = _extract_error(errfile)
 
+    if reduce_composition:
+        unique_element_dict = {x: [] for x in unique_elements}
+        for x in datadict['composition']:
+            if x is None:
+                for key in unique_element_dict.keys():
+                    unique_element_dict[key].append(0)
+            else:
+                for el in unique_elements:
+                    if el in x.keys():
+                        unique_element_dict[el].append(x[el])
+                    else:
+                        unique_element_dict[el].append(0)
+        #add the keys to datadict
+        for key, val in unique_element_dict.items():
+            datadict[key] = val
+    
+    if not extract_phase_prefix:
+        del datadict['phase_name']
+
     df = pd.DataFrame(data=datadict)
     return df
 
+def _entropy(compC, comp_init=[1, 0]):
+    """
+    l1: initial concentration [Au, Cu]
+    l2: final concentration [Au, Cu]
+    """
+    compA = 1 - compC
+    def _log(val):
+        if val == 0:
+            return 0
+        else:
+            return np.log(val)
+    dA = compA*_log(compA) - comp_init[0]*_log(comp_init[0])
+    dC = compC*_log(compC) - comp_init[1]*_log(comp_init[1])
+    return kb*(dA+dC)
+    
+def clean_df(df, reference_element, combine_direct_calculations=False, fit_order=0):
+    """
+    Clean a parsed dataframe and drop unnecessary columns. This gets it ready for further processing
+    Note that `gather_results` should be run with `reduce_composition` and `extract_phase_name` for this to work.
+
+
+    Parameters
+    ----------
+    df: DataFrame
+        dataframe parsed by `gather_results` with `reduce_composition=True`.
+    
+    reference_element: str
+        reference element from the compositions, which will be renamed to `composition`
+    
+    combine_direct_calculations: bool, optional
+        If True, combine direct calculations by fitting to produce temperature and free energy arrays
+        If used, an extra column `error` with mean square error of the fitting is also created
+    
+    fit_order: int, optional
+        If `combine_direct_calculations` is used, this argument is used for fitting order.
+
+    Returns
+    -------
+    df: DataFrame
+        combined, finished DataFrame
+    """
+
+    if "phase_name" not in df.keys():
+        raise ValueError("phase_name key is not found, maybe add it?")
+
+    df = df.loc[df.status=='True']
+    df = df.drop(labels=['status', 'pressure', 'reference_phase', 
+                 'error_code', 'composition', 'calculation'], axis='columns')
+
+    phases = df.groupby(df.phase_name)
+    phases = [phases.get_group(x) for x in phases.groups]
+
+    df_dict = {}
+    
+    for phase in phases:
+        if combine_direct_calculations:
+            gb = phase.groupby(by=reference_element)
+            gbs = [gb.get_group(x) for x in gb.groups]
+
+            fes = []
+            tes = []
+            errors = []
+            comps = []
+            mode_list = []
+            entropies = []
+            is_refs = []
+
+            for exdf in gbs:
+                temps = np.array(exdf.temperature.values)
+                fe = np.array(exdf.free_energy.values)
+                modes = np.array(exdf.calculation_mode.values)
+                entropy = np.array(exdf.ideal_entropy.values)
+                comp_ref = np.array(exdf.reference_composition.values)
+
+                unique_modes = np.unique(modes)
+                if len(unique_modes)>1:
+                    warnings.warn("mixing calculations from more than one mode!")
+                unique_mode = unique_modes[0]
+
+                #REMEMBER TO SORT EVERYTHING
+                args = np.argsort(temps)
+                temps = temps[args]
+                fe = fe[args] 
+                #entropy = entropy[args]        
+                #print(fe, entropy)
+                #print(len(fe), len(entropy))    
+                
+                if fit_order > 0:
+                    fit = np.polyfit(temps, fe, fit_order)
+                    temp_arr = np.arange(temps.min(), temps.max()+1, 1)
+                
+                    #estimate error
+                    fe_eval = np.polyval(fit, temps)
+                    error = np.sum((fe_eval-fe)**2)
+                
+                    fe_arr = np.polyval(fit, temp_arr)
+                else:
+                    fe_arr = fe
+                    temp_arr = temps
+                    error = 0
+
+                fes.append(fe_arr)
+                tes.append(temp_arr)
+                errors.append(error)
+                entropies.append(entropy[0])
+                comps.append(float(exdf[reference_element].values[0]))
+                is_refs.append(np.abs(float(exdf[reference_element].values[0])-comp_ref[0])<1E-5)
+
+                mode_list.append(unique_mode)
+            
+            #replace df
+            df = pd.DataFrame(data={'temperature':tes, 'free_energy': fes, 
+                'error':errors, reference_element:comps, 'ideal_entropy': entropies,
+                'calculation_mode': mode_list, "is_reference":is_refs})
+        
+        df = df.rename(columns={reference_element:'composition'})
+        df_dict[phase.phase_name.values[0]] = df
+    return df_dict
+
+def fix_composition_scaling(dfdict, fit_order=4, correct_entropy=True, add_ideal_entropy=False):
+    #NOTE: at the moment, the temperature ranges have to be same! but that should be fixed with fitting
+    #there could be calculations that failed, no?
+    #lets just fit, maybe a 2d?
+    for key, val in dfdict.items():
+        x=val
+        ref_fe = x.loc[x.is_reference==True].free_energy.values[0]
+        ref_temp = x.loc[x.is_reference==True].temperature.values[0]
+        ref_fe_fit = np.polyfit(ref_temp, ref_fe, fit_order)
+
+        for index, row in x.iterrows():
+            if (not row.is_reference) and (row.calculation_mode == 'composition_scaling'):
+                if correct_entropy:
+                    #note that we need a factor of 2, because the first one is directly coming in from the equations
+                    if add_ideal_entropy:
+                        x.at[index, 'free_energy'] =  row.free_energy - row.temperature*row.ideal_entropy + np.polyval(ref_fe_fit, row.temperature)
+                    else:
+                        x.at[index, 'free_energy'] =  row.free_energy - row.temperature*row.ideal_entropy + np.polyval(ref_fe_fit, row.temperature)
+                else:
+                    x.at[index, 'free_energy'] = row.free_energy + np.polyval(ref_fe_fit, row.temperature)
+                #x.at[index, 'free_energy'] = row.free_energy + np.polyval(ref_fe_fit, row.temperature)
+        dfdict[key] = x
+    return dfdict        
+
 def find_transition_temperature(folder1, folder2, fit_order=4, plot=True):
     """
     Find transition temperature where free energy of two phases are equal.

calphy/routines.py

@@ -338,6 +338,7 @@ def routine_fe(job):
 
     job.thermodynamic_integration()
     job.submit_report()
+    job.clean_up()
     return job
 
 def routine_ts(job):
@@ -354,6 +355,7 @@ def routine_ts(job):
         job.logger.info("TS integration cycle %d finished in %f s"%(i+1, te))
     
     job.integrate_reversible_scaling(scale_energy=True)
+    job.clean_up()
     return job
 
 
@@ -387,6 +389,7 @@ def routine_tscale(job):
         job.logger.info("Temperature scaling cycle %d finished in %f s"%(i+1, te))
     
     job.integrate_reversible_scaling(scale_energy=False)
+    job.clean_up()
     return job
 
 def routine_pscale(job):
@@ -403,6 +406,7 @@ def routine_pscale(job):
         job.logger.info("Pressure scaling cycle %d finished in %f s"%(i+1, te))
     
     job.integrate_pressure_scaling()
+    job.clean_up()
     return job
 
 def routine_alchemy(job):
@@ -423,6 +427,7 @@ def routine_alchemy(job):
 
     job.thermodynamic_integration()
     job.submit_report()
+    job.clean_up()
     return job 
 
 
@@ -433,6 +438,8 @@ def routine_composition_scaling(job):
     #we set up comp scaling first
     job.logger.info("Calculating composition scaling")
     comp = CompositionTransformation(job.calc)
+    swap_list = comp.get_swap_types()
+    job.calc.monte_carlo.swap_types = swap_list
 
     #update pair styles
     res = comp.update_pair_coeff(job.calc.pair_coeff[0])
@@ -453,7 +460,7 @@ def routine_composition_scaling(job):
     #job.calc._ghost_element_count = len(comp.new_atomtype) - len()
 
     #write new file out and update lattice
-    outfilename = ".".join([job.calc.lattice, "comp", "dump"])
+    outfilename = ".".join([job.calc.lattice, "comp", "data"])
     comp.write_structure(outfilename)
     job.calc.lattice = outfilename
     job.logger.info(f"Modified lattice written to {outfilename}")
@@ -487,6 +494,8 @@ def routine_composition_scaling(job):
     job.calc.mass = [ref_mass for x in range(len(job.calc.element))] 
     job.logger.info(f"Temporarily replacing mass: {job.calc.mass}")
 
+    #update fict elements if needed
+    #job.calc._totalelements = comp.maxtype
 
     #now start cycle
     ts = time.time()
@@ -512,10 +521,12 @@ def routine_composition_scaling(job):
     netfe = w_arr - mcorrarr
 
     job.fe = job.fe - mcorsum
-    job.submit_report(extra_dict = {"results":{"mass_correction": float(mcorsum)}})
+    job.submit_report(extra_dict = {"results":{"mass_correction": float(mcorsum),
+                                               "entropy_contribution": float(comp.entropy_contribution)}})
 
     outfile = os.path.join(job.simfolder, "composition_sweep.dat")
     np.savetxt(outfile, np.column_stack((flambda_arr, netfe, w_arr, mcorrarr)))
 
     job.logger.info('Composition scaling does not include free energy of mixing!')
+    job.clean_up()
     return job

calphy/scheduler.py

@@ -154,6 +154,8 @@ class SLURM:
         """
         cmd = ['sbatch', self.script]
         proc = sub.Popen(cmd, stdin=sub.PIPE,stdout=sub.PIPE,stderr=sub.PIPE)
+        print(f'submitting {self.queueoptions["jobname"]}')
+        proc.communicate()
         return proc
 
 

calphy/solid.py

@@ -299,7 +299,7 @@ class Solid(cph.Phase):
             lmp.command(f'pair_style {self.calc._pair_style_with_options[0]}')
 
         #set up structure
-        lmp = ph.create_structure(lmp, self.calc, species=self.calc.n_elements+self.calc._ghost_element_count)
+        lmp = ph.create_structure(lmp, self.calc)
 
         if self.calc.potential_file is None:
             lmp.command(f'pair_coeff {self.calc.pair_coeff[0]}')
@@ -458,6 +458,19 @@ class Solid(cph.Phase):
             lmp.command("dump              d1 all custom %d traj.fe.forward_%d.dat id type mass x y z fx fy fz"%(self.calc.n_print_steps,
                 iteration))
 
+        #turn on swap moves
+        #if self.calc.monte_carlo.n_swaps > 0:
+        #    self.logger.info(f'{self.calc.monte_carlo.n_swaps} swap moves are performed between 1 and 2 every {self.calc.monte_carlo.n_steps}')
+        #    lmp.command("fix  swap all atom/swap %d %d %d %d ke yes types 1 2"%(self.calc.monte_carlo.n_steps,
+        #                                                                        self.calc.monte_carlo.n_swaps,
+        #                                                                        np.random.randint(1, 10000),
+        #                                                                        self.calc._temperature))
+        #
+        #    lmp.command("variable a equal f_swap[1]")
+        #    lmp.command("variable b equal f_swap[2]")
+        #    lmp.command("fix             swap2 all print 1 \"${a} ${b}\" screen no file swap.fe.forward_%d.dat"%iteration)
+
+
         #Forward switching over ts steps
         lmp.command("run               %d"%self.calc._n_switching_steps)
         lmp.command("unfix             f4")
@@ -465,6 +478,10 @@ class Solid(cph.Phase):
         if self.calc.n_print_steps > 0:
             lmp.command("undump           d1")
 
+        #if self.calc.monte_carlo.n_swaps > 0:
+        #    lmp.command("unfix swap")
+        #    lmp.command("unfix swap2")
+
         #Equilibriate
         lmp.command("run               %d"%self.calc.n_equilibration_steps)
 
@@ -484,6 +501,20 @@ class Solid(cph.Phase):
             lmp.command("dump              d1 all custom %d traj.fe.backward_%d.dat id type mass x y z fx fy fz"%(self.calc.n_print_steps,
                 iteration))
 
+        #add swaps if n_swap is > 0
+        #if self.calc.monte_carlo.n_swaps > 0:
+        #    self.logger.info(f'{self.calc.monte_carlo.n_swaps} swap moves are performed between 1 and 2 every {self.calc.monte_carlo.n_steps}')
+        #    lmp.command("fix  swap all atom/swap %d %d %d %d ke yes types 2 1"%(self.calc.monte_carlo.n_steps,
+        #                                                                        self.calc.monte_carlo.n_swaps,
+        #                                                                        np.random.randint(1, 10000),
+        #                                                                        self.calc._temperature))
+        #
+        #    lmp.command("variable a equal f_swap[1]")
+        #    lmp.command("variable b equal f_swap[2]")
+        #    lmp.command("fix             swap2 all print 1 \"${a} ${b}\" screen no file swap.fe.backward_%d.dat"%iteration)
+
+
+
         #Reverse switching over ts steps
         lmp.command("run               %d"%self.calc._n_switching_steps)
         lmp.command("unfix             f4")
@@ -491,6 +522,10 @@ class Solid(cph.Phase):
         if self.calc.n_print_steps > 0:
             lmp.command("undump           d1")
 
+        #if self.calc.monte_carlo.n_swaps > 0:
+        #    lmp.command("unfix swap")
+        #    lmp.command("unfix swap2")
+
         #close object
         if not self.calc.script_mode:
             lmp.close()

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: calphy
-Version: 1.3.13
+Version: 1.4.3
 Summary: free energy calculation for python
 Home-page: https://github.com/ICAMS/calphy
 Author: Sarath Menon, Yury Lysogorskiy, Ralf Drautz
@@ -22,6 +22,18 @@ Requires-Dist: tqdm
 Requires-Dist: scipy
 Requires-Dist: pydantic
 Requires-Dist: pyscal3
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # calphy
 

calphy-1.4.3.dist-info/RECORD

@@ -0,0 +1,25 @@
+calphy/__init__.py,sha256=0kafBUoGTV6xYpg_eCXGg42xa8W1ge6tDoJz6sS2Y38,233
+calphy/alchemy.py,sha256=IEYLfsJRsjfB0zFfApmxGbYXif7IE6mUY_vjTZoXdII,17236
+calphy/clitools.py,sha256=CjADSz3nc8CLYhAmw2Os7aT-Iu_0LLIF6tdAmUMJErw,4398
+calphy/composition_transformation.py,sha256=z3X4fFVoym6QgRDpLBYZ_fM9V0IgJvBq-wITu1nwVmw,17247
+calphy/errors.py,sha256=KN47RWTLbg1H_NZMrhCiJCbqjqJScJ1pgQAuzj1-l84,1268
+calphy/helpers.py,sha256=goN_n5kceSaevjBilQDgHD5-QZxsQsOwTiWsY00jMcM,8411
+calphy/input.py,sha256=sDMbnyjyUs3al0kdHpMYBKzBbe4iug2426YPLnVxhl0,33169
+calphy/integrators.py,sha256=hJYmbznsgY-x-eZm7ng8gW0qsGbopERl5gGDnw5uLms,21719
+calphy/kernel.py,sha256=wjSpQ59PN-aqHQ1kvOxTYnP2d3wE1Zx4A9ZhqQFqGlI,6311
+calphy/liquid.py,sha256=ECF3DxPZv7XHnmQzk_yz1fol-Vsd98lRojTMAR1YS3M,15025
+calphy/phase.py,sha256=rmOb_T2IsSR48HNvpACnlw9USYagzWT5zqZXymnVVA4,53231
+calphy/phase_diagram.py,sha256=Yu192y7bhWsj-xQL7ITSBdMHKXJ6I_4gV0cLfdXTOa4,27791
+calphy/postprocessing.py,sha256=WmCVj_xyCOU3pO5hycj8Qmfrx-bhIWcVnSfjx_yZkwQ,15164
+calphy/queuekernel.py,sha256=4GMIYnjMiAPipoLNKP5noYcfeEOI_vCqm84zgokk7Xw,5321
+calphy/routines.py,sha256=YaVoAbeAbZ3ytAP_A0o5ngkpPiXpc_lk2I0bN3nqhPs,17858
+calphy/scheduler.py,sha256=nIxlKKGj8ol_FuYMMtXrQinPGhPlYs2h-JsEGHC7_wY,8666
+calphy/solid.py,sha256=zHSqri8roW23hIQ21huxHHJqq3P5EklSj6Z0z9ywfbc,21911
+calphy/splines.py,sha256=BGwUVz_qXQxUzpUCuZo6CsELcd5JVNWzI-Ttcz22G_E,61627
+calphy/utils.py,sha256=0UpsYoxjS5N-iGs-cdm0YDMkLF8IHvKO3smXDHrj3eg,3818
+calphy-1.4.3.dist-info/licenses/LICENSE,sha256=XIHGB5RZLIhOjjoO1bPf0II-qDbjhP5Cv5HJMRE9v1g,16651
+calphy-1.4.3.dist-info/METADATA,sha256=ldKbDFVDC_C1qk1jzLw7lCV3-S558UunR2wNfZ16cbA,4469
+calphy-1.4.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+calphy-1.4.3.dist-info/entry_points.txt,sha256=KX5dP2iYy9GB4Mo0lbCPAz6jo-8b1Gt9GDmsDFzt9pQ,439
+calphy-1.4.3.dist-info/top_level.txt,sha256=w871dhMqPwgjjbifBWdkT9_aOnK1ek4Odrh8UnSG3PE,7
+calphy-1.4.3.dist-info/RECORD,,

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

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

{calphy-1.3.13.dist-info → calphy-1.4.3.dist-info}/entry_points.txt

@@ -2,6 +2,7 @@
 calphy = calphy.kernel:main
 calphy_convert_input = calphy.clitools:convert_legacy_inputfile
 calphy_kernel = calphy.queuekernel:main
+calphy_phase_diagram = calphy.clitools:phase_diagram
 calphy_process_averaging = calphy.clitools:process_averaging
 calphy_process_integration = calphy.clitools:process_integration
 calphy_run_averaging = calphy.clitools:run_averaging

calphy-1.3.13.dist-info/RECORD

@@ -1,25 +0,0 @@
-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=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=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=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.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,,