calphy 1.3.11__py3-none-any.whl → 1.4.2__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.11"
+__version__ = "1.4.2"
 
 def addtest(a,b):
     return a+b

calphy/alchemy.py

@@ -19,6 +19,10 @@ DOI: 10.1103/PhysRevMaterials.5.103801
 
 For more information contact:
 sarath.menon@ruhr-uni-bochum.de/yury.lysogorskiy@icams.rub.de
+
+Notes
+-----
+- swapping is strictly only performed between types 1 and 2 at the moment; this needs to be refined further
 """
 
 import numpy as np
@@ -159,6 +163,9 @@ class Alchemy(cph.Phase):
         lmp.command(f'pair_coeff {self.calc.pair_coeff[0]}')
         lmp = ph.set_mass(lmp, self.calc)
 
+        #NEW ADDED
+        lmp.command("group g1 type 1")
+        lmp.command("group g2 type 2")
         #lmp = ph.set_double_hybrid_potential(lmp, self.options, self.calc._pressureair_style, self.calc._pressureair_coeff)
 
         #remap the box to get the correct pressure
@@ -173,9 +180,12 @@ class Alchemy(cph.Phase):
             lmp.command("fix             f1 all nvt temp %f %f %f"%(self.calc._temperature, self.calc._temperature, 
                 self.calc.md.thermostat_damping[1]))
 
+        
         lmp.command("thermo_style    custom step pe")
         lmp.command("thermo          1000")
         lmp.command("run             %d"%self.calc.n_equilibration_steps)
+        
+
         #equilibration run is over
         
         #---------------------------------------------------------------
@@ -226,21 +236,41 @@ class Alchemy(cph.Phase):
         lmp.command("variable        dU1 equal c_c1/atoms")             # Driving-force obtained from NEHI procedure.
         lmp.command("variable        dU2 equal c_c2/atoms")
 
+        #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 {self.calc.monte_carlo.swap_types[0]} and {self.calc.monte_carlo.swap_types[1]} every {self.calc.monte_carlo.n_steps}')
+            lmp.command("fix  swap all atom/swap %d %d %d %f ke no types %d %d"%(self.calc.monte_carlo.n_steps,
+                                                                                self.calc.monte_carlo.n_swaps,
+                                                                                np.random.randint(1, 10000),
+                                                                                self.calc._temperature,
+                                                                                self.calc.monte_carlo.swap_types[0],
+                                                                                self.calc.monte_carlo.swap_types[1]))
+            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} ${flambda}\" screen no file swap.forward_%d.dat"%iteration)
+
         # Thermo output.
-        lmp.command("thermo_style    custom step v_dU1 v_dU2")
+        if self.calc.monte_carlo.n_swaps > 0:
+            lmp.command("thermo_style    custom step v_dU1 v_dU2 v_a v_b")
+        else:
+            lmp.command("thermo_style    custom step v_dU1 v_dU2")
         lmp.command("thermo          1000")
 
-
+        
         #save the necessary items to a file: first step
         lmp.command("fix             f2 all print 1 \"${dU1} ${dU2} ${flambda}\" screen no file forward_%d.dat"%iteration)
-        lmp.command("run             %d"%self.calc._n_switching_steps)
-
+        lmp.command("run             %d"%self.calc._n_switching_steps)            
 
         #now equilibrate at the second potential
         lmp.command("unfix           f2")
         lmp.command("uncompute       c1")
         lmp.command("uncompute       c2")
 
+        #NEW SWAP
+        if self.calc.monte_carlo.n_swaps > 0:
+            lmp.command("unfix swap")
+            lmp.command("unfix swap2")
+
 
         lmp.command("pair_style      %s"%self.calc._pair_style_with_options[1])
         lmp.command("pair_coeff      %s"%self.calc.pair_coeff[1])
@@ -248,7 +278,7 @@ class Alchemy(cph.Phase):
         # Thermo output.
         lmp.command("thermo_style    custom step pe")
         lmp.command("thermo          1000")
-
+        
         #run eqbrm run
         lmp.command("run             %d"%self.calc.n_equilibration_steps)
         
@@ -278,11 +308,39 @@ class Alchemy(cph.Phase):
         lmp.command("variable        dU1 equal c_c1/atoms")             # Driving-force obtained from NEHI procedure.
         lmp.command("variable        dU2 equal c_c2/atoms")
 
+        #add swaps if n_swap is > 0
+        if self.calc.monte_carlo.n_swaps > 0:
+            if self.calc.monte_carlo.reverse_swap:
+                self.logger.info(f'{self.calc.monte_carlo.n_swaps} swap moves are performed between {self.calc.monte_carlo.swap_types[1]} and {self.calc.monte_carlo.swap_types[0]} every {self.calc.monte_carlo.n_steps}')
+                lmp.command("fix  swap all atom/swap %d %d %d %f ke no types %d %d"%(self.calc.monte_carlo.n_steps,
+                                                                                    self.calc.monte_carlo.n_swaps,
+                                                                                    np.random.randint(1, 10000),
+                                                                                    self.calc._temperature,
+                                                                                    self.calc.monte_carlo.swap_types[1],
+                                                                                    self.calc.monte_carlo.swap_types[0]))
+            else:
+                self.logger.info(f'{self.calc.monte_carlo.n_swaps} swap moves are performed between {self.calc.monte_carlo.swap_types[0]} and {self.calc.monte_carlo.swap_types[1]} every {self.calc.monte_carlo.n_steps}')
+                self.logger.info('note that swaps are not reversed')
+                lmp.command("fix  swap all atom/swap %d %d %d %f ke no types %d %d"%(self.calc.monte_carlo.n_steps,
+                                                                                    self.calc.monte_carlo.n_swaps,
+                                                                                    np.random.randint(1, 10000),
+                                                                                    self.calc._temperature,
+                                                                                    self.calc.monte_carlo.swap_types[0],
+                                                                                    self.calc.monte_carlo.swap_types[1]))
+
+            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} ${blambda}\" screen no file swap.backward_%d.dat"%iteration)
+
         # Thermo output.
-        lmp.command("thermo_style    custom step v_dU1 v_dU2")
+        if self.calc.monte_carlo.n_swaps > 0:
+            lmp.command("thermo_style    custom step v_dU1 v_dU2 v_a v_b")
+        else:        
+            lmp.command("thermo_style    custom step v_dU1 v_dU2")
         lmp.command("thermo          1000")
 
 
+        
         #save the necessary items to a file: first step
         lmp.command("fix             f2 all print 1 \"${dU1} ${dU2} ${flambda}\" screen no file backward_%d.dat"%iteration)
         lmp.command("run             %d"%self.calc._n_switching_steps)
@@ -293,6 +351,8 @@ class Alchemy(cph.Phase):
         lmp.command("uncompute       c1")
         lmp.command("uncompute       c2")
 
+        if self.calc.monte_carlo.n_swaps > 0:
+            lmp.command("unfix  swap")
         lmp.close()
 
 
@@ -329,8 +389,6 @@ class Alchemy(cph.Phase):
             return flambda_arr, w_arr, q_arr, qerr_arr
 
 
-
-
     def mass_integration(self, flambda, ref_mass, target_masses, target_counts):
         mcorarr, mcorsum = integrate_mass(flambda, ref_mass, target_masses, target_counts,
     self.calc._temperature, self.natoms)

calphy/clitools.py

@@ -11,6 +11,7 @@ from calphy.input import read_inputfile, load_job, save_job, _convert_legacy_inp
 from calphy.liquid import Liquid
 from calphy.solid import Solid
 from calphy.alchemy import Alchemy
+from calphy.phase_diagram import prepare_inputs_for_phase_diagram
 
 def _generate_job(calc, simfolder):
     if calc.mode == "alchemy" or calc.mode == "composition_scaling":
@@ -120,3 +121,8 @@ def convert_legacy_inputfile():
             yaml.safe_dump(data, fout)
 
 
+def phase_diagram():
+    arg = ap.ArgumentParser()
+    arg.add_argument("-i", "--input", required=True, type=str,
+    help="name of the input file")
+    prepare_inputs_for_phase_diagram(args['input'])

calphy/composition_transformation.py

@@ -30,6 +30,7 @@ from mendeleev import element
 from ase.io import read, write
 from ase.atoms import Atoms
 from pyscal3.core import element_dict
+from calphy.integrators import kb
 
 class CompositionTransformation:
     """
@@ -124,6 +125,7 @@ class CompositionTransformation:
         self.atom_species = None
         self.mappings = None
         self.unique_mappings = None
+        self.mappingdict = None
         self.prepare_mappings()
     
     def dict_to_string(self, inputdict):
@@ -132,8 +134,32 @@ class CompositionTransformation:
             strlst.append(str(key))
             strlst.append(str(val))
         return "".join(strlst)
-    
-    
+
+    @property
+    def entropy_contribution(self):
+        """
+        Find the entropy entribution of the transformation. To get
+        free energies, multiply by -T.
+        """
+        def _log(val):
+            if val == 0:
+                return 0
+            else:
+                return np.log(val)
+        ents = []
+        for key, val in self.output_chemical_composition.items():
+            if key in self.input_chemical_composition.keys():
+                t1 = self.input_chemical_composition[key]/self.natoms
+                t2 = self.output_chemical_composition[key]/self.natoms
+                cont = t2*_log(t2) - t1*_log(t1)
+            else:
+                t1 = 0
+                t2 = self.output_chemical_composition[key]/self.natoms
+                cont =  t2*_log(t2) - 0
+            ents.append(cont)
+        entropy_term = kb*np.sum(ents)
+        return entropy_term
+        
     def convert_to_pyscal(self):
         """
         Convert a given system to pyscal and give a dict of type mappings
@@ -159,7 +185,6 @@ class CompositionTransformation:
         self.maxtype = self.actual_species + 1 #+ self.new_species
         #print(self.typedict)            
 
-
     def get_composition_transformation(self):
         """
         From the two given composition transformation, find the transformation dict
@@ -192,9 +217,10 @@ class CompositionTransformation:
     def mark_atoms(self):
         for i in range(self.natoms):
             self.atom_mark.append(False)
-            self.atom_type = self.pyscal_structure.atoms.types
-            self.mappings = [f"{x}-{x}" for x in self.atom_type]
-            
+        
+        self.atom_type = self.pyscal_structure.atoms.types
+        self.mappings = [f"{x}-{x}" for x in self.atom_type]
+     
     def update_mark_atoms(self):
         self.marked_atoms = []
         for key, val in self.to_remove.items():
@@ -281,7 +307,7 @@ class CompositionTransformation:
         self.update_typedicts()
         self.compute_possible_mappings()
         self.update_mappings()
-        
+    
     def prepare_pair_lists(self):
         self.pair_list_old = []
         self.pair_list_new = []
@@ -300,8 +326,12 @@ class CompositionTransformation:
     def update_types(self):
         for x in range(len(self.atom_type)):
             self.atom_type[x] = self.mappingdict[self.mappings[x]]
-        for count in range(len(self.pyscal_structure.atoms.types)):
-            self.pyscal_structure.atoms.types[count] = self.atom_type[count]
+        
+        #smartify these loops
+        #npyscal = len(self.pyscal_structure.atoms.types)
+        self.pyscal_structure.atoms.types = self.atom_type
+        #for count in range(npyscal)):
+        #    self.pyscal_structure.atoms.types[count] = self.atom_type[count]
             
     def iselement(self, symbol):
         try:
@@ -331,6 +361,30 @@ class CompositionTransformation:
         pc_old = " ".join([*pc_before, *self.pair_list_old, *pc_after])
         pc_new = " ".join([*pc_before, *self.pair_list_new, *pc_after])
         return pc_old, pc_new
+
+    def get_swap_types(self):
+        """
+        Get swapping types
+        """
+        swap_list = []
+        for mapping in self.unique_mappings:
+            map_split = mapping.split("-")
+            #conserved atom
+            if (map_split[0]==map_split[1]):
+                pass
+            else:
+                first_type = map_split[0]
+                second_type = map_split[1]
+                first_map = f'{first_type}-{first_type}'
+                second_map = mapping
+
+                #get the numbers from dict
+                first_swap_type = self.mappingdict[first_map]
+                second_swap_type = self.mappingdict[second_map]
+
+                swap_list.append([first_swap_type, second_swap_type])
+        return swap_list[0]
+            
     
     def write_structure(self, outfilename):
         #create some species dict

calphy/helpers.py

@@ -121,8 +121,12 @@ def create_structure(lmp, calc):
 
 
 def set_mass(lmp, options):
-    for i in range(options.n_elements):
-        lmp.command(f'mass {i+1} {options.mass[i]}')
+    if options.mode == 'composition_scaling':
+        lmp.command(f'mass * {options.mass[-1]}')
+
+    else:
+        for i in range(options.n_elements):
+            lmp.command(f'mass {i+1} {options.mass[i]}')
     return lmp