calphy 1.4.6__py3-none-any.whl → 1.4.12__py3-none-any.whl

calphy/composition_transformation.py

@@ -172,7 +172,17 @@ class CompositionTransformation:
         """
         Convert a given system to pyscal and give a dict of type mappings
         """
-        aseobj = read(self.calc.lattice, format="lammps-data", style="atomic")
+        # Create Z_of_type mapping to properly read LAMMPS data files
+        # This ensures atoms are correctly identified by their element
+        Z_of_type = dict(
+            [
+                (count + 1, element(el).atomic_number)
+                for count, el in enumerate(self.calc.element)
+            ]
+        )
+        aseobj = read(
+            self.calc.lattice, format="lammps-data", style="atomic", Z_of_type=Z_of_type
+        )
         pstruct = pc.System(aseobj, format="ase")
 
         # here we have to validate the input composition dict; and map it
@@ -188,10 +198,17 @@ class CompositionTransformation:
         self.reversetypedict = dict(zip(atomtypes, atomsymbols))
         self.natoms = self.pyscal_structure.natoms
 
-        self.actual_species = len(self.typedict)
-        self.new_species = len(self.output_chemical_composition) - len(self.typedict)
+        # Count of actual unique atom types present in the structure
+        # This matches what's declared in the LAMMPS data file header
+        self.actual_species_in_structure = len(types)
+        # Count from calc.element (may include types with 0 atoms)
+        self.calc_element_count = len(self.calc.element)
+
+        # Use actual structure types for pair_coeff consistency
+        # pair_coeff must match the number declared in the data file header
+        self.actual_species = self.actual_species_in_structure
+        self.new_species = len(self.output_chemical_composition) - len(types)
         self.maxtype = self.actual_species + 1  # + self.new_species
-        # print(self.typedict)
 
     def get_composition_transformation(self):
         """
@@ -215,26 +232,28 @@ class CompositionTransformation:
         self.to_remove = to_remove
         self.to_add = to_add
 
-    def get_random_index_of_species(self, species):
+    def get_random_index_of_species(self, species_name):
         """
-        Get a random index of a given species
+        Get a random index of a given species by element name
         """
-        ids = [count for count, x in enumerate(self.atom_type) if x == species]
+        ids = [count for count, x in enumerate(self.atom_species) if x == species_name]
         return ids[np.random.randint(0, len(ids))]
 
     def mark_atoms(self):
         for i in range(self.natoms):
             self.atom_mark.append(False)
 
+        # Use species (element symbols) instead of numeric types
+        self.atom_species = self.pyscal_structure.atoms.species
         self.atom_type = self.pyscal_structure.atoms.types
-        self.mappings = [f"{x}-{x}" for x in self.atom_type]
+        self.mappings = [f"{x}-{x}" for x in self.atom_species]
 
     def update_mark_atoms(self):
         self.marked_atoms = []
         for key, val in self.to_remove.items():
-            # print(f"Element {key}, count {val}")
+            # key is the element name (e.g., "Mg")
             for i in range(100000):
-                rint = self.get_random_index_of_species(self.typedict[key])
+                rint = self.get_random_index_of_species(key)
                 if rint not in self.marked_atoms:
                     self.atom_mark[rint] = True
                     self.marked_atoms.append(rint)
@@ -257,14 +276,12 @@ class CompositionTransformation:
 
     def compute_possible_mappings(self):
         self.possible_mappings = []
-        # Now make a list of possible mappings
+        # Now make a list of possible mappings using element names
         for key1, val1 in self.to_remove.items():
             for key2, val2 in self.to_add.items():
                 mapping = f"{key1}-{key2}"
                 if mapping not in self.restrictions:
-                    self.possible_mappings.append(
-                        f"{self.typedict[key1]}-{self.typedict[key2]}"
-                    )
+                    self.possible_mappings.append(mapping)
 
     def update_mappings(self):
         marked_atoms = self.marked_atoms.copy()
@@ -272,7 +289,7 @@ class CompositionTransformation:
             # now get all
 
             # we to see if we can get val number of atoms from marked ones
-            if val < len(marked_atoms):
+            if val > len(marked_atoms):
                 raise ValueError(
                     f"Not enough atoms to choose {val} from {len(marked_atoms)} not possible"
                 )
@@ -284,8 +301,8 @@ class CompositionTransformation:
                 to_del = []
                 for x in range(len(self.marked_atoms)):
                     random_choice = np.random.choice(marked_atoms)
-                    # find corresponding mappiong
-                    mapping = f"{self.atom_type[random_choice]}-{self.typedict[key]}"
+                    # find corresponding mapping using species name
+                    mapping = f"{self.atom_species[random_choice]}-{key}"
                     if mapping in self.possible_mappings:
                         # this is a valid choice
                         self.mappings[random_choice] = mapping
@@ -314,12 +331,8 @@ class CompositionTransformation:
             mapsplit = mapping.split("-")
             if not mapsplit[0] == mapsplit[1]:
                 transformation_dict = {}
-                transformation_dict["primary_element"] = self.reversetypedict[
-                    int(mapsplit[0])
-                ]
-                transformation_dict["secondary_element"] = self.reversetypedict[
-                    int(mapsplit[1])
-                ]
+                transformation_dict["primary_element"] = mapsplit[0]
+                transformation_dict["secondary_element"] = mapsplit[1]
                 transformation_dict["count"] = self.unique_mapping_counts[count]
                 self.transformation_list.append(transformation_dict)
 
@@ -333,25 +346,45 @@ class CompositionTransformation:
         self.pair_list_new = []
         for mapping in self.unique_mappings:
             map_split = mapping.split("-")
-            # conserved atom
+            # conserved atom - mappings now use element names directly
             if map_split[0] == map_split[1]:
-                self.pair_list_old.append(self.reversetypedict[int(map_split[0])])
-                self.pair_list_new.append(self.reversetypedict[int(map_split[0])])
+                self.pair_list_old.append(map_split[0])
+                self.pair_list_new.append(map_split[0])
             else:
-                self.pair_list_old.append(self.reversetypedict[int(map_split[0])])
-                self.pair_list_new.append(self.reversetypedict[int(map_split[1])])
-        self.new_atomtype = np.array(range(len(self.unique_mappings))) + 1
-        self.mappingdict = dict(zip(self.unique_mappings, self.new_atomtype))
+                self.pair_list_old.append(map_split[0])
+                self.pair_list_new.append(map_split[1])
+
+        # Special case: 100% transformation with only 1 mapping
+        # LAMMPS requires pair_coeff to map ALL atom types declared in data file
+        # Example: Pure Al→Mg with 2 types declared → need ['Al', 'Al'] and ['Mg', 'Mg']
+        # This ensures consistency between data file type count and pair_coeff mappings
+        if len(self.unique_mappings) == 1 and self.actual_species > 1:
+            # Duplicate the single mapping to match number of declared atom types
+            for _ in range(self.actual_species - 1):
+                self.pair_list_old.append(self.pair_list_old[0])
+                self.pair_list_new.append(self.pair_list_new[0])
+
+        # Create mapping from transformation strings to UNIQUE type numbers
+        # Each unique transformation mapping needs its own type for LAMMPS swapping
+        # Example: Al-Al, Mg-Al, Mg-Mg should map to types 1, 2, 3 respectively
+        self.mappingdict = {}
+        for idx, mapping in enumerate(self.unique_mappings, start=1):
+            self.mappingdict[mapping] = idx
+
+        # Update reversetypedict - map each type to its source element
+        # We'll handle species naming in write_structure to keep types separate
+        self.reversetypedict = {}
+        for mapping, type_num in self.mappingdict.items():
+            source_element = mapping.split("-")[0]
+            self.reversetypedict[type_num] = source_element
 
     def update_types(self):
+        # Update atom_type based on mapping to new types
         for x in range(len(self.atom_type)):
             self.atom_type[x] = self.mappingdict[self.mappings[x]]
 
-        # smartify these loops
-        # npyscal = len(self.pyscal_structure.atoms.types)
+        # Update pyscal structure 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:
@@ -392,7 +425,7 @@ class CompositionTransformation:
                 # If element_group matches our pair_list_old, replace with pair_list_new
                 # Otherwise replace with pair_list_old (for the old/reference command)
                 if element_group == self.pair_list_old or set(element_group) == set(
-                    self.element
+                    self.calc.element
                 ):
                     # This needs special handling - we'll mark position for later
                     result_parts.append("__ELEMENTS__")
@@ -432,12 +465,22 @@ class CompositionTransformation:
 
     def get_swap_types(self):
         """
-        Get swapping types
+        Get swapping types for configurational entropy calculation.
+
+        Returns types that share the same initial element but have different
+        transformation paths (e.g., Al→Al vs Al→Mg).
+
+        The order matters for reversibility:
+        - Forward pass (e.g., Mg→Al enrichment): swap between Mg types
+        - Backward pass (e.g., Al→Mg depletion): swap between Al types
+
+        Returns list ordered as: [conserved_type, transforming_type]
+        where conserved_type is X→X and transforming_type is X→Y
         """
         swap_list = []
         for mapping in self.unique_mappings:
             map_split = mapping.split("-")
-            # conserved atom
+            # conserved atom - skip
             if map_split[0] == map_split[1]:
                 pass
             else:
@@ -446,26 +489,77 @@ class CompositionTransformation:
                 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]
+                # Check if conserved mapping exists
+                if first_map in self.mappingdict:
+                    # get the numbers from dict
+                    first_swap_type = self.mappingdict[first_map]
+                    second_swap_type = self.mappingdict[second_map]
+                    # Order: [transforming_type, conserved_type]
+                    # This represents: atoms that transform vs atoms that don't
+                    swap_list.append([second_swap_type, first_swap_type])
+                else:
+                    # 100% transformation case - no conserved atoms of this type
+                    # Only the transforming type exists
+                    second_swap_type = self.mappingdict[second_map]
+                    swap_list.append([second_swap_type])
 
-                swap_list.append([first_swap_type, second_swap_type])
-        return swap_list[0]
+        return swap_list[0] if swap_list else []
 
     def write_structure(self, outfilename):
-        # create some species dict
-        # just to trick ase to write
-        utypes = np.unique(self.pyscal_structure.atoms["types"])
-        element_list = list(element_dict.keys())
-        element_type_dict = {
-            str(u): element_list[count] for count, u in enumerate(utypes)
-        }
-        species = [
-            element_type_dict[str(x)] for x in self.pyscal_structure.atoms["types"]
-        ]
-        self.pyscal_structure.atoms["species"] = species
-        self.pyscal_structure.write.file(outfilename, format="lammps-data")
+        """Write structure to LAMMPS data file with proper type declarations.
+
+        Writes using ASE directly with custom atom types to preserve distinct
+        type numbers for each transformation mapping.
+        """
+        from ase.io import write as ase_write
+        from ase import Atoms as ASEAtoms
+
+        # Get positions and cell from pyscal structure
+        positions = self.pyscal_structure.atoms.positions
+        cell = self.pyscal_structure.box
+
+        # Create ASE Atoms object with chemical symbols from reversetypedict
+        # All atoms get their source element symbol
+        symbols = [self.reversetypedict[t] for t in self.pyscal_structure.atoms.types]
+
+        ase_atoms = ASEAtoms(symbols=symbols, positions=positions, cell=cell, pbc=True)
+
+        # Write using ASE with atom_style
+        ase_write(outfilename, ase_atoms, format="lammps-data", atom_style="atomic")
+
+        # Post-process to fix the type column with our custom types
+        with open(outfilename, "r") as f:
+            lines = f.readlines()
+
+        # Find the Atoms section and replace type numbers
+        in_atoms_section = False
+        atom_idx = 0
+        for i, line in enumerate(lines):
+            if "Atoms" in line and "#" in line:
+                in_atoms_section = True
+                continue
+
+            if in_atoms_section and line.strip():
+                parts = line.split()
+                if len(parts) >= 5:  # atom_id type x y z
+                    # Replace the type (column 1, 0-indexed) with our custom type
+                    custom_type = self.pyscal_structure.atoms.types[atom_idx]
+                    parts[1] = str(custom_type)
+                    lines[i] = "  " + "  ".join(parts) + "\n"
+                    atom_idx += 1
+                    if atom_idx >= len(self.pyscal_structure.atoms.types):
+                        break
+
+        # Update the number of atom types in the header
+        required_ntypes = len(self.pair_list_old)
+        for i, line in enumerate(lines):
+            if "atom types" in line:
+                lines[i] = f"{required_ntypes} atom types\n"
+                break
+
+        # Write the corrected file
+        with open(outfilename, "w") as f:
+            f.writelines(lines)
 
     def prepare_mappings(self):
         self.atom_mark = []

calphy/helpers.py

@@ -74,6 +74,8 @@ def create_object(
     else:
         if cmdargs == "":
             cmdargs = None
+        elif isinstance(cmdargs, str):
+            cmdargs = cmdargs.split()
         lmp = LammpsLibrary(cores=cores, working_directory=directory, cmdargs=cmdargs)
 
     commands = [
@@ -129,7 +131,7 @@ def set_mass(lmp, options):
 
     else:
         for i in range(options.n_elements):
-            lmp.command(f"mass {i+1} {options.mass[i]}")
+            lmp.command(f"mass {i + 1} {options.mass[i]}")
     return lmp
 
 

calphy/input.py

@@ -49,7 +49,7 @@ from pyscal3.core import structure_dict, element_dict, _make_crystal
 from ase.io import read, write
 import shutil
 
-__version__ = "1.4.6"
+__version__ = "1.4.12"
 
 
 def _check_equal(val):
@@ -350,7 +350,6 @@ class Calculation(BaseModel, title="Main input class"):
 
     @model_validator(mode="after")
     def _validate_all(self) -> "Input":
-
         if not (len(self.element) == len(self.mass)):
             raise ValueError("mass and elements should have same length")
 

calphy/liquid.py

@@ -23,6 +23,7 @@ sarath.menon@ruhr-uni-bochum.de/yury.lysogorskiy@icams.rub.de
 
 import numpy as np
 import yaml
+import os
 
 from calphy.integrators import *
 import calphy.helpers as ph
@@ -100,6 +101,10 @@ class Liquid(cph.Phase):
         # if melting cycle is over and still not melted, raise error
         if not melted:
             lmp.close()
+            # Preserve log file
+            logfile = os.path.join(self.simfolder, "log.lammps")
+            if os.path.exists(logfile):
+                os.rename(logfile, os.path.join(self.simfolder, "melting.log.lammps"))
             raise SolidifiedError(
                 "Liquid system did not melt, maybe try a higher thigh temperature."
             )
@@ -175,6 +180,10 @@ class Liquid(cph.Phase):
         self.dump_current_snapshot(lmp, "traj.equilibration_stage2.dat")
         lmp = ph.write_data(lmp, "conf.equilibration.data")
         lmp.close()
+        # Preserve log file
+        logfile = os.path.join(self.simfolder, "log.lammps")
+        if os.path.exists(logfile):
+            os.rename(logfile, os.path.join(self.simfolder, "averaging.log.lammps"))
 
     def run_integration(self, iteration=1):
         """
@@ -390,6 +399,10 @@ class Liquid(cph.Phase):
 
         # close object
         lmp.close()
+        # Preserve log file
+        logfile = os.path.join(self.simfolder, "log.lammps")
+        if os.path.exists(logfile):
+            os.rename(logfile, os.path.join(self.simfolder, "integration.log.lammps"))
 
     def thermodynamic_integration(self):
         """

calphy/phase.py

@@ -278,6 +278,12 @@ class Phase:
         solids = ph.find_solid_fraction(os.path.join(self.simfolder, filename))
         if solids / lmp.natoms < self.calc.tolerance.solid_fraction:
             lmp.close()
+            # Preserve log file on error
+            logfile = os.path.join(self.simfolder, "log.lammps")
+            if os.path.exists(logfile):
+                os.rename(
+                    logfile, os.path.join(self.simfolder, "melted_error.log.lammps")
+                )
             raise MeltedError(
                 "System melted, increase size or reduce temp!\n Solid detection algorithm only works with BCC/FCC/HCP/SC/DIA. Detection algorithm can be turned off by setting:\n tolerance.solid_fraction: 0"
             )
@@ -287,6 +293,12 @@ class Phase:
         solids = ph.find_solid_fraction(os.path.join(self.simfolder, filename))
         if solids / lmp.natoms > self.calc.tolerance.liquid_fraction:
             lmp.close()
+            # Preserve log file on error
+            logfile = os.path.join(self.simfolder, "log.lammps")
+            if os.path.exists(logfile):
+                os.rename(
+                    logfile, os.path.join(self.simfolder, "solidified_error.log.lammps")
+                )
             raise SolidifiedError("System solidified, increase temperature")
 
     def fix_nose_hoover(
@@ -594,6 +606,15 @@ class Phase:
 
         if not converged:
             lmp.close()
+            # Preserve log file on error
+            logfile = os.path.join(self.simfolder, "log.lammps")
+            if os.path.exists(logfile):
+                os.rename(
+                    logfile,
+                    os.path.join(
+                        self.simfolder, "pressure_convergence_error.log.lammps"
+                    ),
+                )
             raise ValueError(
                 "Pressure did not converge after MD runs, maybe change lattice_constant and try?"
             )
@@ -708,6 +729,15 @@ class Phase:
 
         if not converged:
             lmp.close()
+            # Preserve log file on error
+            logfile = os.path.join(self.simfolder, "log.lammps")
+            if os.path.exists(logfile):
+                os.rename(
+                    logfile,
+                    os.path.join(
+                        self.simfolder, "constrained_pressure_error.log.lammps"
+                    ),
+                )
             raise ValueError("pressure did not converge")
 
     def process_pressure(
@@ -1180,6 +1210,12 @@ class Phase:
 
         # close the object
         lmp.close()
+        # Preserve log file
+        logfile = os.path.join(self.simfolder, "log.lammps")
+        if os.path.exists(logfile):
+            os.rename(
+                logfile, os.path.join(self.simfolder, "reversible_scaling.log.lammps")
+            )
 
         self.logger.info("Please cite the following publications:")
         if self.calc.mode == "mts":
@@ -1217,10 +1253,13 @@ class Phase:
             return_values=return_values,
         )
 
-        self.logger.info(f'Maximum energy dissipation along the temperature scaling part: {ediss} eV/atom')
-        if np.abs(ediss) > 1E-4:
-            self.logger.warning(f'Found max energy dissipation of {ediss} along the temperature scaling path. Please ensure there are no structural changes!')
-
+        self.logger.info(
+            f"Maximum energy dissipation along the temperature scaling part: {ediss} eV/atom"
+        )
+        if np.abs(ediss) > 1e-4:
+            self.logger.warning(
+                f"Found max energy dissipation of {ediss} along the temperature scaling path. Please ensure there are no structural changes!"
+            )
 
         if return_values:
             return res
@@ -1369,6 +1408,12 @@ class Phase:
         lmp.command("run               %d" % self.calc._n_sweep_steps)
 
         lmp.close()
+        # Preserve log file
+        logfile = os.path.join(self.simfolder, "log.lammps")
+        if os.path.exists(logfile):
+            os.rename(
+                logfile, os.path.join(self.simfolder, "temperature_scaling.log.lammps")
+            )
 
     def pressure_scaling(self, iteration=1):
         """
@@ -1499,6 +1544,12 @@ class Phase:
         lmp.command("run               %d" % self.calc._n_sweep_steps)
 
         lmp.close()
+        # Preserve log file
+        logfile = os.path.join(self.simfolder, "log.lammps")
+        if os.path.exists(logfile):
+            os.rename(
+                logfile, os.path.join(self.simfolder, "pressure_scaling.log.lammps")
+            )
 
         self.logger.info("Please cite the following publications:")
         self.logger.info("- 10.1016/j.commatsci.2022.111275")

calphy/phase_diagram.py

@@ -332,7 +332,8 @@ def _create_composition_array(comp_range, interval, reference):
         is_reference = np.abs(comp_arr - reference) < COMPOSITION_TOLERANCE
     elif len(comp_range) == 1:
         comp_arr = [comp_range[0]]
-        is_reference = [True]
+        # Check if this single composition equals the reference
+        is_reference = [np.abs(comp_range[0] - reference) < COMPOSITION_TOLERANCE]
     else:
         raise ValueError("Composition range should be scalar or list of two values!")
     

calphy/routines.py

@@ -94,6 +94,9 @@ class MeltingTemp:
         calc["mode"] = "ts"
         calc["temperature"] = [int(self.tmin), int(self.tmax)]
         calc["reference_phase"] = 'solid'
+        # Preserve n_iterations from the original melting_temperature calculation
+        if "n_iterations" in data["calculations"][int(self.calc.kernel)]:
+            calc["n_iterations"] = data["calculations"][int(self.calc.kernel)]["n_iterations"]
         calculations["calculations"].append(calc)
 
         with open(self.calc.inputfile, 'r') as fin:
@@ -103,6 +106,9 @@ class MeltingTemp:
         calc["mode"] = "ts"
         calc["temperature"] = [int(self.tmin), int(self.tmax)]
         calc["reference_phase"] = 'liquid'
+        # Preserve n_iterations from the original melting_temperature calculation
+        if "n_iterations" in data["calculations"][int(self.calc.kernel)]:
+            calc["n_iterations"] = data["calculations"][int(self.calc.kernel)]["n_iterations"]
         calculations["calculations"].append(calc)
 
         outfile = f'{self.calc.create_identifier()}.{self.attempts}.yaml'