calphy 1.2.14__tar.gz → 1.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: calphy
-Version: 1.2.14
+Version: 1.3.0
 Summary: free energy calculation for python
 Home-page: https://github.com/ICAMS/calphy
 Author: Sarath Menon, Yury Lysogorskiy, Ralf Drautz
@@ -21,7 +21,6 @@ Requires-Dist: mendeleev
 Requires-Dist: tqdm
 Requires-Dist: scipy
 Requires-Dist: pydantic
-Requires-Dist: pyscal
 Requires-Dist: pyscal3
 
 # calphy

{calphy-1.2.14 → 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.14"
+__version__ = "1.3.0"
 
 def addtest(a,b):
     return a+b

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

@@ -24,9 +24,7 @@ sarath.menon@ruhr-uni-bochum.de/yury.lysogorskiy@icams.rub.de
 import numpy as np
 import yaml
 
-import pyscal.traj_process as ptp
 from calphy.integrators import *
-import calphy.lattice as pl
 import calphy.helpers as ph
 import calphy.phase as cph
 
@@ -79,11 +77,14 @@ class Alchemy(cph.Phase):
         lmp = ph.create_object(self.cores, self.simfolder, self.calc.md.timestep, 
             self.calc.md.cmdargs, self.calc.md.init_commands)
 
+        lmp.command(f'pair_style {self.calc._pair_style_with_options[0]}')
+
         #set up structure
         lmp = ph.create_structure(lmp, self.calc)
 
         #set up potential
-        lmp = ph.set_potential(lmp, self.calc, ghost_elements=self.calc._ghost_element_count)
+        lmp.command(f'pair_coeff {self.calc.pair_coeff[0]}')
+        lmp = ph.set_mass(lmp, self.calc)
 
         #add some computes
         lmp.command("variable         mvol equal vol")
@@ -145,6 +146,8 @@ class Alchemy(cph.Phase):
         # Adiabatic switching parameters.
         lmp.command("variable        li       equal   1.0")
         lmp.command("variable        lf       equal   0.0")
+
+        lmp.command(f'pair_style {self.calc._pair_style_with_options[0]}')
         
         #read dump file
         #conf = os.path.join(self.simfolder, "conf.equilibration.dump")
@@ -153,7 +156,9 @@ class Alchemy(cph.Phase):
 
         #set up hybrid potential
         #here we only need to set one potential
-        lmp = ph.set_potential(lmp, self.calc, ghost_elements=self.calc._ghost_element_count)
+        lmp.command(f'pair_coeff {self.calc.pair_coeff[0]}')
+        lmp = ph.set_mass(lmp, self.calc)
+
         #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

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

@@ -22,16 +22,17 @@ sarath.menon@ruhr-uni-bochum.de/yury.lysogorskiy@icams.rub.de
 """
 
 import os
-from pylammpsmpi import LammpsLibrary
+import shutil
+import warnings
 import logging
 import numpy as np
+
+from pylammpsmpi import LammpsLibrary
 from lammps import lammps
-import calphy.lattice as pl
-import shutil
-import pyscal.core as pc
 from ase.io import read, write
-from pyscal.trajectory import Trajectory
-import warnings
+
+import pyscal3.core as pc
+from pyscal3.trajectory import Trajectory
 
 class LammpsScript:
     def __init__(self):
@@ -117,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
 
@@ -148,50 +143,14 @@ 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)
-
-    return lmp
+    lmp = set_mass(lmp, options)
 
-
-def read_dump(lmp, file, species=1):
-    # Read atoms positions, velocities and box parameters.
-    lmp.command("lattice          fcc 4.0")
-    lmp.command("region           box block 0 2 0 2 0 2")
-    lmp.command("create_box       %d box" % species)
-    lmp.command(
-        "read_dump        %s 0 x y z vx vy vz scaled no box yes add keep" % file
-    )
-    lmp.command("change_box       all triclinic")
     return lmp
 
-
 def read_data(lmp, file):
     lmp.command(f"read_data {file}")
     return lmp
 
-
-def convert_to_data_file(inputfile, outputfile, ghost_elements=0):
-    atoms = read(inputfile, format="lammps-dump-text")
-    write(outputfile, atoms, format="lammps-data")
-
-    if ghost_elements > 0:
-        lines = []
-        with open(outputfile, "r") as fin:
-            for line in fin:
-                raw = line.strip().split()
-                if (len(raw) == 3) and (raw[2] == "types"):
-                    raw[0] = "%d" % ghost_elements
-                    raw.append("\n")
-                    rline = " ".join(raw)
-                    lines.append(rline)
-                else:
-                    lines.append(line)
-
-        with open(outputfile, "w") as fout:
-            for line in lines:
-                fout.write(line)
-
-
 def get_structures(file, species, index=None):
     traj = Trajectory(file)
     if index is None:
@@ -200,94 +159,6 @@ def get_structures(file, species, index=None):
         aseobjs = traj[index].to_ase(species=species)
     return aseobjs
 
-
-def set_hybrid_potential(lmp, options, eps, ghost_elements=0):
-    pc = options.pair_coeff[0]
-    pcraw = pc.split()
-    pcnew = " ".join(
-        [
-            *pcraw[:2],
-            *[
-                options._pair_style_names[0],
-            ],
-            *pcraw[2:],
-        ]
-    )
-
-    lmp.command(
-        "pair_style       hybrid/overlay %s ufm 7.5"
-        % options._pair_style_with_options[0]
-    )
-    lmp.command("pair_coeff       %s" % pcnew)
-    lmp.command("pair_coeff       * * ufm %f 1.5" % eps)
-
-    lmp = set_mass(lmp, options, ghost_elements=ghost_elements)
-
-    return lmp
-
-
-def set_double_hybrid_potential(lmp, options, ghost_elements=0):
-
-    pc1 = options.pair_coeff[0]
-    pcraw1 = pc1.split()
-
-    pc2 = options.pair_coeff[1]
-    pcraw2 = pc2.split()
-
-    if options.pair_style[0] == options.pair_style[1]:
-        pcnew1 = " ".join(
-            [
-                *pcraw1[:2],
-                *[
-                    options._pair_style_names[0],
-                ],
-                "1",
-                *pcraw1[2:],
-            ]
-        )
-        pcnew2 = " ".join(
-            [
-                *pcraw2[:2],
-                *[
-                    options._pair_style_names[1],
-                ],
-                "2",
-                *pcraw2[2:],
-            ]
-        )
-    else:
-        pcnew1 = " ".join(
-            [
-                *pcraw1[:2],
-                *[
-                    options._pair_style_names[0],
-                ],
-                *pcraw1[2:],
-            ]
-        )
-        pcnew2 = " ".join(
-            [
-                *pcraw2[:2],
-                *[
-                    options._pair_style_names[1],
-                ],
-                *pcraw2[2:],
-            ]
-        )
-
-    lmp.command(
-        "pair_style       hybrid/overlay %s %s"
-        % (options._pair_style_with_options[0], options._pair_style_with_options[1])
-    )
-
-    lmp.command("pair_coeff       %s" % pcnew1)
-    lmp.command("pair_coeff       %s" % pcnew2)
-
-    lmp = set_mass(lmp, options, ghost_elements=ghost_elements)
-
-    return lmp
-
-
 def remap_box(lmp, x, y, z):
     lmp.command("run 0")
     lmp.command(
@@ -329,15 +200,15 @@ PYSCAL helper routines
 
 
 def find_solid_fraction(file):
-    sys = pc.System()
-    sys.read_inputfile(file)
+    sys = pc.System(file)
     try:
-        sys.find_neighbors(method="cutoff", cutoff=0)
+        sys.find.neighbors(method="cutoff", cutoff=0)
     except RuntimeError:
-        sys.find_neighbors(
+        sys.find.neighbors(
             method="cutoff", cutoff=5.0
         )  # Maybe add value as convergence param?
-    solids = sys.find_solids()
+    sys.find.solids(cluster=False)
+    solids = np.sum(sys.atoms.solid)
     return solids
 
 
@@ -345,49 +216,6 @@ def write_data(lmp, file):
     lmp.command(f"write_data {file}")
     return lmp
 
-
-def reset_timestep(conf, file="current.data", init_commands=None):
-    lmp = create_object(
-        cores=1,
-        directory=os.path.dirname(file),
-        timestep=0,
-        cmdargs=None,
-        init_commands=init_commands,
-    )
-    lmp = read_data(lmp, file)
-    lmp = write_data(lmp, conf)
-    return lmp
-
-    # with open(file, "r") as f:
-    #    with open(conf, "w") as c:
-    #        zero = False
-    #        for l in f:
-    #            if zero:
-    #                c.write("0\n")
-    #                zero = False
-    #                continue
-    #            elif l.startswith("ITEM: TIMESTEP"):
-    #                zero = True
-    #            c.write(l)
-
-    # lmp = create_object(
-    #    cores=1,
-    #    directory = os.path.dirname(file),
-    #    timestep=0,
-    #    cmdargs=None,
-    # )
-    # lmp.command("dump              2 all custom 1 %s id type mass x y z vx vy vz"%(file))+
-    # lmp.command("reset_timestep     0")
-    # lmp.command("run               0")
-    # lmp.command("undump            2")
-
-
-"""
-NOrmal helper routines
----------------------------------------------------------------------
-"""
-
-
 def prepare_log(file, screen=False):
     logger = logging.getLogger(__name__)
     handler = logging.FileHandler(file)

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

@@ -58,10 +58,27 @@ def _check_equal(val):
         return False
     return True
 
-
 def to_list(v: Any) -> List[Any]:
     return np.atleast_1d(v)
 
+def _to_str(val):
+    if np.isscalar(val):
+        return str(val)
+    else:
+        return [str(x) for x in val] 
+
+def _to_int(val):
+    if np.isscalar(val):
+        return int(val)
+    else:
+        return [int(x) for x in val] 
+
+def _to_float(val):
+    if np.isscalar(val):
+        return float(val)
+    else:
+        return [float(x) for x in val] 
+        
 class CompositionScaling(BaseModel, title='Composition scaling input options'):
     _input_chemical_composition: PrivateAttr(default=None)
     output_chemical_composition: Annotated[dict, Field(default=None, required=False)]
@@ -185,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)
@@ -312,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
@@ -319,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']
@@ -333,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
@@ -359,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]
@@ -372,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
             
@@ -381,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)
 
@@ -402,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():
@@ -422,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
 
@@ -517,13 +535,6 @@ def load_job(filename):
     job = np.load(filename, allow_pickle=True).flatten()[0]
     return job
 
-def check_dict(indict, key, retval=None):
-    if key in indict.items():
-        return indict[key]
-    else:
-        return retval
-
-
 def read_inputfile(file):
     if not os.path.exists(file):
         raise FileNotFoundError(f'Input file {file} not found.')
@@ -645,23 +656,4 @@ def _convert_legacy_inputfile(file, return_calcs=False):
         warnings.warn(f'Old style input file calphy < v2 found. Converted input in {outfile}. Please check!')
         with open(outfile, 'w') as fout:
             yaml.safe_dump(newdata, fout)
-        return outfile
-
-
-def _to_str(val):
-    if np.isscalar(val):
-        return str(val)
-    else:
-        return [str(x) for x in val] 
-
-def _to_int(val):
-    if np.isscalar(val):
-        return int(val)
-    else:
-        return [int(x) for x in val] 
-
-def _to_float(val):
-    if np.isscalar(val):
-        return float(val)
-    else:
-        return [float(x) for x in val] 
+        return outfile