calphy 1.2.17__tar.gz → 1.3.0__tar.gz

{calphy-1.2.17/calphy.egg-info → calphy-1.3.0}/PKG-INFO

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

{calphy-1.2.17 → calphy-1.3.0}/calphy/__init__.py

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

{calphy-1.2.17 → calphy-1.3.0}/calphy/alchemy.py

@@ -84,7 +84,7 @@ class Alchemy(cph.Phase):
 
         #set up potential
         lmp.command(f'pair_coeff {self.calc.pair_coeff[0]}')
-        lmp = ph.set_mass(lmp, self.calc, ghost_elements=self.calc._ghost_element_count)
+        lmp = ph.set_mass(lmp, self.calc)
 
         #add some computes
         lmp.command("variable         mvol equal vol")
@@ -157,7 +157,7 @@ class Alchemy(cph.Phase):
         #set up hybrid potential
         #here we only need to set one potential
         lmp.command(f'pair_coeff {self.calc.pair_coeff[0]}')
-        lmp = ph.set_mass(lmp, self.calc, ghost_elements=self.calc._ghost_element_count)
+        lmp = ph.set_mass(lmp, self.calc)
 
         #lmp = ph.set_double_hybrid_potential(lmp, self.options, self.calc._pressureair_style, self.calc._pressureair_coeff)
 

{calphy-1.2.17 → calphy-1.3.0}/calphy/helpers.py

@@ -118,19 +118,13 @@ def create_structure(lmp, calc):
     return lmp
 
 
-def set_mass(lmp, options, ghost_elements=0):
-    count = 1
+def set_mass(lmp, options):
     for i in range(options.n_elements):
         lmp.command(f'mass {i+1} {options.mass[i]}')
-        count += 1
-
-    for i in range(ghost_elements):
-        lmp.command(f'mass {count+i} 1.00')
-
     return lmp
 
 
-def set_potential(lmp, options, ghost_elements=0):
+def set_potential(lmp, options):
     """
     Set the interatomic potential
 
@@ -149,7 +143,7 @@ def set_potential(lmp, options, ghost_elements=0):
     lmp.command(f'pair_style {options._pair_style_with_options[0]}')
     lmp.command(f'pair_coeff {options.pair_coeff[0]}')
 
-    lmp = set_mass(lmp, options, ghost_elements=ghost_elements)
+    lmp = set_mass(lmp, options)
 
     return lmp
 

{calphy-1.2.17 → calphy-1.3.0}/calphy/input.py

@@ -202,7 +202,6 @@ class Calculation(BaseModel, title='Main input class'):
 
     #add second level options; for example spring constants
     spring_constants: Annotated[List[float], Field(default = None)]
-    _ghost_element_count: int = PrivateAttr(default=0)
 
     #structure items
     _structure: Any = PrivateAttr(default=None)
@@ -329,6 +328,7 @@ class Calculation(BaseModel, title='Main input class'):
             self._element_dict[element]['mass'] = self.mass[count]
             self._element_dict[element]['count'] = 0
             self._element_dict[element]['composition'] = 0.0
+            self._element_dict[element]['atomic_number'] = mendeleev.element(element).atomic_number
 
         #generate temporary filename if needed
         write_structure_file = False
@@ -336,7 +336,7 @@ class Calculation(BaseModel, title='Main input class'):
         if self.lattice == "":
             #fetch from dict
             if len(self.element) > 1:
-                raise ValueError("Cannot create lattice for more than one element")
+                raise ValueError("Cannot create lattice for more than one element, provide a lammps-data file explicitly")
             if self.element[0] in element_dict.keys():
                 self.lattice = element_dict[self.element[0]]['structure']
                 self.lattice_constant = element_dict[self.element[0]]['lattice_constant']
@@ -350,20 +350,23 @@ class Calculation(BaseModel, title='Main input class'):
                 lattice_constant=self.lattice_constant,
                 repetitions=self.repeat,
                 element=self.element)
+            structure = structure.write.ase()
             
             #extract composition
-            typelist = structure.atoms.species
-            types, typecounts = np.unique(typelist, return_counts=True)
+            types, typecounts = np.unique(structure.get_chemical_symbols(), return_counts=True)
 
             for c, t in enumerate(types):
                 self._element_dict[t]['count'] = typecounts[c]
                 self._element_dict[t]['composition'] = typecounts[c]/np.sum(typecounts)
 
-            self._natoms = structure.natoms
+            self._natoms = len(structure)
             self._original_lattice = self.lattice.lower()
             write_structure_file = True
 
         elif self.lattice.lower() in structure_dict.keys():
+            if len(self.element) > 1:
+                raise ValueError("Cannot create lattice for more than one element, provide a lammps-data file explicitly")
+
             #this is a valid structure
             if self.lattice_constant == 0:
                 #we try try to get lattice_constant
@@ -376,10 +379,10 @@ class Calculation(BaseModel, title='Main input class'):
                 lattice_constant=self.lattice_constant,
                 repetitions=self.repeat,
                 element=self.element)
+            structure = structure.write.ase()
             
             #extract composition
-            typelist = structure.atoms.species
-            types, typecounts = np.unique(typelist, return_counts=True)
+            types, typecounts = np.unique(structure.get_chemical_symbols(), return_counts=True)
 
             for c, t in enumerate(types):
                 self._element_dict[t]['count'] = typecounts[c]
@@ -389,7 +392,7 @@ class Calculation(BaseModel, title='Main input class'):
             #concdict_frac = {str(t): typecounts[c]/np.sum(typecounts) for c, t in enumerate(types)}
             #self._composition = concdict_frac
             #self._composition_counts = concdict_counts
-            self._natoms = structure.natoms
+            self._natoms = len(structure)
             self._original_lattice = self.lattice.lower()
             write_structure_file = True
             
@@ -398,20 +401,21 @@ class Calculation(BaseModel, title='Main input class'):
             if not os.path.exists(self.lattice):
                 raise ValueError(f'File {self.lattice} could not be found')
             if self.file_format == 'lammps-data':
-                aseobj = read(self.lattice, format='lammps-data', style='atomic')
-                structure = System(aseobj, format='ase')
+                #create atomic numbers for proper reading
+                Z_of_type = dict([(count+1, self._element_dict[element]['atomic_number']) for count, element in enumerate(self.element)])
+                structure = read(self.lattice, format='lammps-data', style='atomic', Z_of_type=Z_of_type)
+                #structure = System(aseobj, format='ase')
             else:
                 raise TypeError('Only lammps-data files are supported!')                
 
             #extract composition
-            typelist = structure.atoms.types
-            #convert to species
-            typelist = [self.element[x-1] for x in typelist]
-            types, typecounts = np.unique(typelist, return_counts=True)
+            #this is the types read in from the file
+            types, typecounts = np.unique(structure.get_chemical_symbols(), return_counts=True)
             for c, t in enumerate(types):
                 self._element_dict[t]['count'] = typecounts[c]
                 self._element_dict[t]['composition'] = typecounts[c]/np.sum(typecounts)
-            self._natoms = structure.natoms
+            
+            self._natoms = len(structure)
             self._original_lattice = os.path.basename(self.lattice)
             self.lattice = os.path.abspath(self.lattice)
 
@@ -419,13 +423,10 @@ class Calculation(BaseModel, title='Main input class'):
         if write_structure_file:
             structure_filename = ".".join([self.create_identifier(), str(self.kernel), "data"])
             structure_filename = os.path.join(os.getcwd(), structure_filename)
-            structure.write.file(structure_filename, format='lammps-data')
+            write(structure_filename, structure, format='lammps-data')
             self.lattice = structure_filename
         
         if self.mode == 'composition_scaling':
-            aseobj = read(self.lattice, format='lammps-data', style='atomic')
-            structure = System(aseobj, format='ase')
-
             #we also should check if actual contents are present
             input_chem_comp = {}
             for key, val in self._element_dict.items():
@@ -439,7 +440,7 @@ class Calculation(BaseModel, title='Main input class'):
 
             natoms1 = np.sum([val for key, val in self.composition_scaling._input_chemical_composition.items()])
             natoms2 = np.sum([val for key, val in self.composition_scaling.output_chemical_composition.items()])
-            if not (natoms1==natoms2==structure.natoms):
+            if not (natoms1==natoms2):
                 raise ValueError(f"Input and output number of atoms are not conserved! Input {self.dict_to_string(self.input_chemical_composition)}, output {self.dict_to_string(self.output_chemical_composition)}, total atoms in structure {structure.natoms}")
         return self
 

{calphy-1.2.17 → calphy-1.3.0}/calphy/integrators.py

@@ -46,10 +46,12 @@ eV2J = const.eV
 #             TI PATH INTEGRATION ROUTINES
 #--------------------------------------------------------------------
 
-def integrate_path(fwdfilename, bkdfilename, 
-    nelements=1, concentration=[1,], 
-    usecols=(0, 1, 2), solid=True,
-    alchemy=False, composition_integration=False):
+def integrate_path(calc,
+    fwdfilename, 
+    bkdfilename,  
+    solid=True,
+    alchemy=False, 
+    composition_integration=False):
     """
     Get a filename with columns du and dlambda and integrate
 
@@ -72,23 +74,36 @@ def integrate_path(fwdfilename, bkdfilename,
     q : float
         heat dissipation during switching of system
     """
+    natoms = np.array([calc._element_dict[x]['count'] for x in calc.element])
+    concentration = np.array([calc._element_dict[x]['composition'] for x in calc.element])
+    fdata = np.loadtxt(fwdfilename, unpack=True, comments="#")
+    bdata = np.loadtxt(bkdfilename, unpack=True, comments="#")
+
     if solid:
-        fdui = np.loadtxt(fwdfilename, unpack=True, comments="#", usecols=(0,))
-        bdui = np.loadtxt(bkdfilename, unpack=True, comments="#", usecols=(0,))
+        fdui = fdata[0]
+        bdui = bdata[0]
 
         fdur = np.zeros(len(fdui))
         bdur = np.zeros(len(bdui))
 
-        for i in range(nelements):
-            fdur += concentration[i]*np.loadtxt(fwdfilename, unpack=True, comments="#", usecols=(i+1,))
-            bdur += concentration[i]*np.loadtxt(bkdfilename, unpack=True, comments="#", usecols=(i+1,))
+        for i in range(calc.n_elements):
+            if natoms[i] > 0:
+                fdur += concentration[i]*fdata[i+1]/natoms[i]
+                bdur += concentration[i]*bdata[i+1]/natoms[i]
 
-        flambda = np.loadtxt(fwdfilename, unpack=True, comments="#", usecols=(nelements+1,))
-        blambda = np.loadtxt(bkdfilename, unpack=True, comments="#", usecols=(nelements+1,))
+        flambda = fdata[calc.n_elements+1]
+        blambda = bdata[calc.n_elements+1]
 
     else:
-        fdui, fdur, flambda = np.loadtxt(fwdfilename, unpack=True, comments="#", usecols=usecols)
-        bdui, bdur, blambda = np.loadtxt(bkdfilename, unpack=True, comments="#", usecols=usecols)
+        fdui = fdata[0]
+        bdui = bdata[0]
+
+        fdur = fdata[1]
+        bdur = bdata[1]
+
+        flambda = fdata[2]
+        blambda = bdata[2]
+
 
     fdu = fdui - fdur
     bdu = bdui - bdur
@@ -106,11 +121,12 @@ def integrate_path(fwdfilename, bkdfilename,
     return w, q, flambda
 
 
-def find_w(mainfolder, nelements=1, 
-    concentration=[1,], nsims=5, 
-    full=False, usecols=(0,1,2), 
+def find_w(mainfolder,
+    calc, 
+    full=False, 
     solid=True,
-    alchemy=False, composition_integration=False):
+    alchemy=False, 
+    composition_integration=False):
     """
     Integrate the irreversible work and dissipation for independent simulations
 
@@ -142,15 +158,20 @@ def find_w(mainfolder, nelements=1,
     ws = []
     qs = []
 
-    for i in range(nsims):
+    for i in range(calc.n_iterations):
         fwdfilestring = 'forward_%d.dat' % (i+1)
         fwdfilename = os.path.join(mainfolder,fwdfilestring)
+        
         bkdfilestring = 'backward_%d.dat' % (i+1)
         bkdfilename = os.path.join(mainfolder,bkdfilestring)
-        w, q, flambda = integrate_path(fwdfilename, bkdfilename, 
-            nelements=nelements, concentration=concentration, 
-            usecols=usecols, solid=solid,
-            alchemy=alchemy, composition_integration=composition_integration)
+        
+        w, q, flambda = integrate_path(calc,
+            fwdfilename, 
+            bkdfilename, 
+            solid=solid,
+            alchemy=alchemy, 
+            composition_integration=composition_integration)
+        
         ws.append(w)
         qs.append(q)
     
@@ -444,7 +465,11 @@ def integrate_dcc(folder1, folder2, nsims=1, scale_energy=True,
 #             REF. STATE ROUTINES: SOLID
 #--------------------------------------------------------------------
 
-def get_einstein_crystal_fe(temp, natoms, mass, vol, k, concentration, cm_correction=True):
+def get_einstein_crystal_fe(
+    calc,
+    vol, 
+    k, 
+    cm_correction=True):
     """
     Get the free energy of einstein crystal
 
@@ -475,7 +500,10 @@ def get_einstein_crystal_fe(temp, natoms, mass, vol, k, concentration, cm_correc
 
     """
     #convert mass first for single particle in kg
-    mass = (np.array(mass)/Na)*1E-3
+    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])
 
     #convert k from ev/A2 to J/m2
     k = np.array(k)*(eV2J/1E-20)
@@ -488,12 +516,13 @@ def get_einstein_crystal_fe(temp, natoms, mass, vol, k, concentration, cm_correc
     F_cm = 0
 
     for count, om in enumerate(omega):
-        F_harm += concentration[count]*np.log((hbar*om)/(kb*temp))
-        if cm_correction:
-            F_cm += np.log((natoms*concentration[count]/vol)*(2*np.pi*kbJ*temp/(natoms*concentration[count]*k[count]))**1.5)
+        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*temp*F_harm
-    F_cm = (kb*temp/natoms)*F_cm
+    F_harm = 3*kb*calc._temperature*F_harm
+    F_cm = (kb*calc._temperature/natoms)*F_cm
 
     F_harm = F_harm + F_cm
 

{calphy-1.2.17 → calphy-1.3.0}/calphy/liquid.py

@@ -120,7 +120,7 @@ class Liquid(cph.Phase):
 
         #set up potential
         lmp.command(f'pair_coeff {self.calc.pair_coeff[0]}')
-        lmp = ph.set_mass(lmp, self.calc, ghost_elements=self.calc._ghost_element_count)
+        lmp = ph.set_mass(lmp, self.calc)
 
         #Melt regime for the liquid
         lmp.velocity("all create", self.calc._temperature_high, np.random.randint(1, 10000))
@@ -189,7 +189,7 @@ class Liquid(cph.Phase):
         #set hybrid ufm and normal potential
         #lmp = ph.set_hybrid_potential(lmp, self.options, self.eps)
         lmp.command(f'pair_coeff {self.calc.pair_coeff[0]}')
-        lmp = ph.set_mass(lmp, self.calc, ghost_elements=self.calc._ghost_element_count)
+        lmp = ph.set_mass(lmp, self.calc)
 
         #remap the box to get the correct pressure
         lmp = ph.remap_box(lmp, self.lx, self.ly, self.lz)
@@ -331,7 +331,8 @@ class Liquid(cph.Phase):
             self.rho, 50, 1.5)
 
         #Get ideal gas fe
-        f2 = get_ideal_gas_fe(self.calc._temperature, self.rho, 
+        f2 = get_ideal_gas_fe(self.calc._temperature, 
+            self.rho, 
             self.natoms, 
             [val['mass'] for key, val in self.calc._element_dict.items()], 
             [val['composition'] for key, val in self.calc._element_dict.items()])

{calphy-1.2.17 → calphy-1.3.0}/calphy/phase.py

@@ -56,11 +56,6 @@ class Phase:
         logfile = os.path.join(self.simfolder, "calphy.log")
         self.logger = ph.prepare_log(logfile, screen=log_to_screen)
 
-        self.logger.info("---------------input file----------------")
-        self.logger.info("commented out as causes crash when we're expanding the T range after a fail run")
-       # self.logger.info(yaml.safe_dump(self.calc.to_dict()))
-        self.logger.info("------------end of input file------------")
-
         if self.calc._pressure is None:
             pressure_string = "None"
         else:
@@ -737,7 +732,7 @@ class Phase:
 
         #set up potential
         lmp.command(f'pair_coeff {self.calc.pair_coeff[0]}')
-        lmp = ph.set_mass(lmp, self.calc, ghost_elements=self.calc._ghost_element_count)
+        lmp = ph.set_mass(lmp, self.calc)
 
         #remap the box to get the correct pressure
         lmp = ph.remap_box(lmp, self.lx, self.ly, self.lz)
@@ -826,7 +821,7 @@ class Phase:
             else:
                 self.check_if_solidfied(lmp, "traj.temp.dat")
 
-        lmp = ph.set_potential(lmp, self.calc, ghost_elements=self.calc._ghost_element_count)
+        lmp = ph.set_potential(lmp, self.calc)
 
         #reverse scaling
         lmp.command("variable         flambda equal ramp(${li},${lf})")
@@ -928,7 +923,7 @@ class Phase:
 
         #set up potential
         lmp.command(f'pair_coeff {self.calc.pair_coeff[0]}')
-        lmp = ph.set_mass(lmp, self.calc, ghost_elements=self.calc._ghost_element_count)
+        lmp = ph.set_mass(lmp, self.calc)
 
         #remap the box to get the correct pressure
         lmp = ph.remap_box(lmp, self.lx, self.ly, self.lz)
@@ -1020,7 +1015,7 @@ class Phase:
 
         #set up potential
         lmp.command(f'pair_coeff {self.calc.pair_coeff[0]}')
-        lmp = ph.set_mass(lmp, self.calc, ghost_elements=self.calc._ghost_element_count)
+        lmp = ph.set_mass(lmp, self.calc)
 
         #remap the box to get the correct pressure
         lmp = ph.remap_box(lmp, self.lx, self.ly, self.lz)

{calphy-1.2.17 → calphy-1.3.0}/calphy/solid.py

@@ -109,9 +109,13 @@ class Solid(cph.Phase):
         k_std = []
         for i in range(self.calc.n_elements):
             quant = np.loadtxt(file, usecols=(i+1, ), unpack=True)[-ncount+1:]
-            quant = 3*kb*self.calc._temperature/quant
-            k_mean.append(np.round(np.mean(quant), decimals=2))
-            k_std.append(np.round(np.std(quant), decimals=2))
+            mean_quant = np.round(np.mean(quant), decimals=2)
+            std_quant = np.round(np.std(quant), decimals=2)
+            if mean_quant == 0:
+                mean_quant = 1.00
+            mean_quant = 3*kb*self.calc._temperature/mean_quant
+            k_mean.append(mean_quant)
+            k_std.append(std_quant)
         return k_mean, k_std
         
 
@@ -222,7 +226,7 @@ class Solid(cph.Phase):
             lmp.command(f'pair_coeff {self.calc.pair_coeff[0]}')
         else:
             lmp.command("include %s"%self.calc.potential_file)
-        lmp = ph.set_mass(lmp, self.calc, ghost_elements=self.calc._ghost_element_count)
+        lmp = ph.set_mass(lmp, self.calc)
 
         #add some computes
         lmp.command("variable         mvol equal vol")
@@ -301,7 +305,7 @@ class Solid(cph.Phase):
             lmp.command(f'pair_coeff {self.calc.pair_coeff[0]}')
         else:
             lmp.command("include %s"%self.calc.potential_file)
-        lmp = ph.set_mass(lmp, self.calc, ghost_elements=self.calc._ghost_element_count)
+        lmp = ph.set_mass(lmp, self.calc)
 
 
         #add some computes
@@ -384,7 +388,7 @@ class Solid(cph.Phase):
             lmp.command(f'pair_coeff {self.calc.pair_coeff[0]}')
         else:
             lmp.command("include %s"%self.calc.potential_file)
-        lmp = ph.set_mass(lmp, self.calc, ghost_elements=self.calc._ghost_element_count)
+        lmp = ph.set_mass(lmp, self.calc)
 
         #remap the box to get the correct pressure
         lmp = ph.remap_box(lmp, self.lx, self.ly, self.lz)
@@ -419,7 +423,7 @@ class Solid(cph.Phase):
         lmp.command("variable          step    equal step")
         lmp.command("variable          dU1      equal pe/atoms")
         for i in range(self.calc.n_elements):
-            lmp.command("variable          dU%d      equal f_ff%d/v_count%d"%(i+2, i+1, i+1))
+            lmp.command("variable          dU%d      equal f_ff%d"%(i+2, i+1))
         
         lmp.command("variable          lambda  equal f_ff1[1]")
 
@@ -443,6 +447,7 @@ class Solid(cph.Phase):
         str2 = []
         for i in range(self.calc.n_elements):
             str2.append("${dU%d}"%(i+2))
+
         str2.append("${lambda}\"")
         str2 = " ".join(str2)
         str3 = " screen no file forward_%d.dat"%iteration
@@ -468,6 +473,7 @@ class Solid(cph.Phase):
         str2 = []
         for i in range(self.calc.n_elements):
             str2.append("${dU%d}"%(i+2))
+
         str2.append("${lambda}\"")
         str2 = " ".join(str2)
         str3 = " screen no file backward_%d.dat"%iteration
@@ -510,13 +516,15 @@ class Solid(cph.Phase):
         Calculates the final work, energy dissipation and free energy by
         matching with Einstein crystal
         """
-        f1 = get_einstein_crystal_fe(self.calc._temperature, 
-            self.natoms, [val['mass'] for key, val in self.calc._element_dict.items()], 
-            self.vol, self.k, [val['composition'] for key, val in self.calc._element_dict.items()])
+        f1 = get_einstein_crystal_fe(
+            self.calc,  
+            self.vol, 
+            self.k)
+        
         w, q, qerr = find_w(self.simfolder, 
-            nelements=self.calc.n_elements, 
-            concentration=[val['composition'] for key, val in self.calc._element_dict.items()], nsims=self.calc.n_iterations, 
-            full=True, solid=True)
+            self.calc,
+            full=True, 
+            solid=True)
         
         self.fref = f1
         self.w = w

{calphy-1.2.17 → calphy-1.3.0/calphy.egg-info}/PKG-INFO

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

{calphy-1.2.17 → calphy-1.3.0}/setup.py

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

{calphy-1.2.17 → calphy-1.3.0}/tests/test_integrators.py

@@ -8,7 +8,3 @@ def test_ideal_gas():
 def test_uf():
 	a = get_uhlenbeck_ford_fe(1000, 0.07, 50, 2)
 	assert np.abs(a-5.37158083028874) < 1E-5
-
-def test_solid_ref():
-	a = get_einstein_crystal_fe(1000, 1000, [26], 200, [1.2], [1])
-	assert np.abs(a+0.4727067261423942) < 1E-5