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

calphy/helpers.py

@@ -3,14 +3,14 @@ calphy: a Python library and command line interface for automated free
 energy calculations.
 
 Copyright 2021  (c) Sarath Menon^1, Yury Lysogorskiy^2, Ralf Drautz^2
-^1: Max Planck Institut für Eisenforschung, Dusseldorf, Germany 
+^1: Max Planck Institut für Eisenforschung, Dusseldorf, Germany
 ^2: Ruhr-University Bochum, Bochum, Germany
 
-calphy is published and distributed under the Academic Software License v1.0 (ASL). 
-calphy is distributed in the hope that it will be useful for non-commercial academic research, 
-but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+calphy is published and distributed under the Academic Software License v1.0 (ASL).
+calphy is distributed in the hope that it will be useful for non-commercial academic research,
+but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 calphy API is published and distributed under the BSD 3-Clause "New" or "Revised" License
-See the LICENSE FILE for more details. 
+See the LICENSE FILE for more details.
 
 More information about the program can be found in:
 Menon, Sarath, Yury Lysogorskiy, Jutta Rogal, and Ralf Drautz.
@@ -34,6 +34,7 @@ from ase.io import read, write
 import pyscal3.core as pc
 from pyscal3.trajectory import Trajectory
 
+
 class LammpsScript:
     def __init__(self):
         self.script = []
@@ -42,12 +43,14 @@ class LammpsScript:
         self.script.append(command_str)
 
     def write(self, infile):
-        with open(infile, 'w') as fout:
+        with open(infile, "w") as fout:
             for line in self.script:
-                fout.write(f'{line}\n')
+                fout.write(f"{line}\n")
+
 
-def create_object(cores, directory, timestep, cmdargs="", 
-    init_commands=(), script_mode=False):
+def create_object(
+    cores, directory, timestep, cmdargs="", init_commands=(), script_mode=False
+):
     """
     Create LAMMPS object
 
@@ -71,28 +74,30 @@ def create_object(cores, directory, timestep, cmdargs="",
     else:
         if cmdargs == "":
             cmdargs = None
-        lmp = LammpsLibrary(
-            cores=cores, working_directory=directory, cmdargs=cmdargs
-        )
-
-    commands = [["units", "metal"], 
-    ["boundary", "p p p"],
-    ["atom_style", "atomic"],
-    ["timestep", str(timestep)],
-    ["box", "tilt large"]]
+        elif isinstance(cmdargs, str):
+            cmdargs = cmdargs.split()
+        lmp = LammpsLibrary(cores=cores, working_directory=directory, cmdargs=cmdargs)
+
+    commands = [
+        ["units", "metal"],
+        ["boundary", "p p p"],
+        ["atom_style", "atomic"],
+        ["timestep", str(timestep)],
+        ["box", "tilt large"],
+    ]
 
     if len(init_commands) > 0:
-        #we need to replace some initial commands
+        # we need to replace some initial commands
         for rc in init_commands:
-            #split the command
+            # split the command
             raw = rc.split()
             for x in range(len(commands)):
                 if raw[0] == commands[x][0]:
-                    #we found a matching command
+                    # we found a matching command
                     commands[x] = [rc]
                     break
             else:
-                #its a new command, add it to the list
+                # its a new command, add it to the list
                 commands.append([rc])
 
     for command in commands:
@@ -121,12 +126,12 @@ def create_structure(lmp, calc):
 
 
 def set_mass(lmp, options):
-    if options.mode == 'composition_scaling':
-        lmp.command(f'mass * {options.mass[-1]}')
+    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]}')
+            lmp.command(f"mass {i + 1} {options.mass[i]}")
     return lmp
 
 
@@ -144,19 +149,21 @@ def set_potential(lmp, options):
     -------
     lmp : LammpsLibrary object
     """
-    #lmp.pair_style(options.pair_style_with_options[0])
-    #lmp.pair_coeff(options.pair_coeff[0])
-    lmp.command(f'pair_style {options._pair_style_with_options[0]}')
-    lmp.command(f'pair_coeff {options.pair_coeff[0]}')
+    # lmp.pair_style(options.pair_style_with_options[0])
+    # lmp.pair_coeff(options.pair_coeff[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)
 
     return lmp
 
+
 def read_data(lmp, file):
     lmp.command(f"read_data {file}")
     return lmp
 
+
 def get_structures(file, species, index=None):
     traj = Trajectory(file)
     if index is None:
@@ -165,6 +172,7 @@ def get_structures(file, species, index=None):
         aseobjs = traj[index].to_ase(species=species)
     return aseobjs
 
+
 def remap_box(lmp, x, y, z):
     lmp.command("run 0")
     lmp.command(
@@ -222,8 +230,15 @@ def write_data(lmp, file):
     lmp.command(f"write_data {file}")
     return lmp
 
+
 def prepare_log(file, screen=False):
     logger = logging.getLogger(__name__)
+
+    # Remove all existing handlers to prevent duplicate logging
+    for handler in logger.handlers[:]:
+        handler.close()
+        logger.removeHandler(handler)
+
     handler = logging.FileHandler(file)
     formatter = logging.Formatter("%(asctime)s %(name)-12s %(levelname)-8s %(message)s")
     handler.setFormatter(formatter)
@@ -238,6 +253,7 @@ def prepare_log(file, screen=False):
         logger.addHandler(scr)
     return logger
 
+
 def check_if_any_is_none(data):
     """
     Check if any elements of a list is None, if so return True

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.5"
+__version__ = "1.4.12"
 
 
 def _check_equal(val):
@@ -92,6 +92,49 @@ def _to_float(val):
         return [float(x) for x in val]
 
 
+def _extract_elements_from_pair_coeff(pair_coeff_string):
+    """
+    Extract element symbols from pair_coeff string.
+    Returns None if pair_coeff doesn't contain element specifications.
+
+    Parameters
+    ----------
+    pair_coeff_string : str
+        The pair_coeff command string (e.g., "* * potential.eam.fs Cu Zr")
+
+    Returns
+    -------
+    list or None
+        List of element symbols in order, or None if no elements found
+    """
+    if pair_coeff_string is None:
+        return None
+
+    pcsplit = pair_coeff_string.strip().split()
+    elements = []
+
+    # Start collecting after we find element symbols
+    # Elements are typically after the potential filename
+    started = False
+
+    for p in pcsplit:
+        # Check if this looks like an element symbol
+        # Element symbols are 1-2 characters, start with uppercase
+        if len(p) <= 2 and p[0].isupper():
+            try:
+                # Verify it's a valid element using mendeleev
+                _ = mendeleev.element(p)
+                elements.append(p)
+                started = True
+            except:
+                # Not a valid element, might be done collecting
+                if started:
+                    # We already started collecting elements and hit a non-element
+                    break
+
+    return elements if len(elements) > 0 else None
+
+
 class UFMP(BaseModel, title="UFM potential input options"):
     p: Annotated[float, Field(default=50.0)]
     sigma: Annotated[float, Field(default=1.5)]
@@ -165,7 +208,6 @@ class Queue(BaseModel, title="Options for configuring queue"):
     memory: Annotated[str, Field(default="3GB")]
     commands: Annotated[List, Field(default=[])]
     options: Annotated[List, Field(default=[])]
-    modules: Annotated[List, Field(default=[])]
 
 
 class Tolerance(BaseModel, title="Tolerance settings for convergence"):
@@ -308,12 +350,48 @@ 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")
 
         self.n_elements = len(self.element)
 
+        # Validate element/mass/pair_coeff ordering consistency
+        # This is critical for multi-element systems where LAMMPS type numbers
+        # are assigned based on element order: element[0]=Type1, element[1]=Type2, etc.
+        if (
+            len(self.element) > 1
+            and self.pair_coeff is not None
+            and len(self.pair_coeff) > 0
+        ):
+            extracted_elements = _extract_elements_from_pair_coeff(self.pair_coeff[0])
+
+            if extracted_elements is not None:
+                # pair_coeff specifies elements - check ordering
+                if set(extracted_elements) != set(self.element):
+                    raise ValueError(
+                        f"Element mismatch between 'element' and 'pair_coeff'!\n"
+                        f"  element:    {self.element}\n"
+                        f"  pair_coeff: {extracted_elements}\n"
+                        f"The elements specified must be the same."
+                    )
+
+                if list(extracted_elements) != list(self.element):
+                    raise ValueError(
+                        f"Element ordering mismatch detected!\n\n"
+                        f"  element:    {self.element}\n"
+                        f"  pair_coeff: {extracted_elements}\n"
+                        f"  mass:       {self.mass}\n\n"
+                        f"For multi-element systems, all three must be in the SAME order.\n\n"
+                        f"Why this matters:\n"
+                        f"  - Element order determines LAMMPS type numbers:\n"
+                        f"      element[0] → Type 1, element[1] → Type 2, etc.\n"
+                        f"  - The pair_coeff elements must match this type order\n"
+                        f"  - The mass values must correspond to the same order\n"
+                        f"  - Composition transformations depend on this ordering\n\n"
+                        f"Please reorder your input so element, mass, and pair_coeff\n"
+                        f"all use the same element ordering."
+                    )
+
         self._pressure_input = copy.copy(self.pressure)
         if self.pressure is None:
             self._iso = True

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")