calphy 2.1.1__tar.gz → 2.1.2__tar.gz

{calphy-2.1.1 → calphy-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calphy
-Version: 2.1.1
+Version: 2.1.2
 Summary: free energy calculation for python
 Author: Yury Lysogorskiy, Ralf Drautz
 Author-email: Sarath Menon <sarath.menon@ruhr-uni-bochum.de>

{calphy-2.1.1 → calphy-2.1.2}/calphy/__init__.py

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

{calphy-2.1.1 → calphy-2.1.2}/calphy/alchemy.py

@@ -58,6 +58,91 @@ class Alchemy(cph.Phase):
             calculation=calculation, simfolder=simfolder, log_to_screen=log_to_screen,
         )
 
+    def _end_states(self):
+        """
+        The initial and final potential of the alchemical switch.
+
+        The pair lists hold both end states back to back: the first half
+        describes the initial potential, the second half the final one. Each
+        half is one physical potential made of one component (a plain pair
+        style) or several (``pair_mode: overlay``, or the component-wise
+        rewrite done by composition scaling). A component is the tuple
+        (style with options, style name, pair_coeff).
+        """
+        styles = self.calc._pair_style_with_options
+        names = self.calc._pair_style_names
+        coeffs = self.calc.pair_coeff
+        if len(styles) % 2 or len(styles) != len(coeffs):
+            raise ValueError(
+                "alchemical switching needs pair_style and pair_coeff lists of "
+                "equal, even length (initial components followed by final "
+                "components); got %d pair styles and %d pair coeffs"
+                % (len(styles), len(coeffs))
+            )
+        half = len(styles) // 2
+        components = list(zip(styles, names, coeffs))
+        return components[:half], components[half:]
+
+    @staticmethod
+    def _pure_pair_style_command(components):
+        """``pair_style`` for one potential on its own: the plain style for a
+        single component, ``hybrid/overlay`` of the components otherwise."""
+        if len(components) == 1:
+            return "pair_style       %s" % components[0][0]
+        return "pair_style       hybrid/overlay %s" % " ".join(
+            style for style, _, _ in components
+        )
+
+    @staticmethod
+    def _pure_pair_coeff_commands(components):
+        """``pair_coeff`` lines matching :meth:`_pure_pair_style_command`."""
+        if len(components) == 1:
+            return ["pair_coeff       %s" % components[0][2]]
+        return ph.hybrid_pair_coeff_commands_for(
+            [name for _, name, _ in components], [coeff for _, _, coeff in components]
+        )
+
+    def _scaled_pair_commands(self, initial, final, initial_scale, final_scale):
+        """
+        Install ``hybrid/scaled`` with every initial component scaled by
+        ``initial_scale`` and every final component by ``final_scale``,
+        then define computes ``c1``/``c2`` (or ``c1_1, c1_2, ...`` for
+        multi-component ends) holding the two potential energies and the
+        per-atom variables ``dU1``/``dU2`` recorded during switching.
+
+        Returns the commands and the compute ids to release afterwards.
+        """
+        terms = ["%s %s" % (initial_scale, style) for style, _, _ in initial]
+        terms += ["%s %s" % (final_scale, style) for style, _, _ in final]
+        commands = ["pair_style       hybrid/scaled %s" % " ".join(terms)]
+
+        components = initial + final
+        names = [name for _, name, _ in components]
+        commands += ph.hybrid_pair_coeff_commands_for(
+            names, [coeff for _, _, coeff in components]
+        )
+
+        tags = ph.hybrid_component_tags(names)
+        compute_ids, energies = [], []
+        for label, part, part_tags in (
+            ("c1", initial, tags[: len(initial)]),
+            ("c2", final, tags[len(initial) :]),
+        ):
+            ids = (
+                [label]
+                if len(part) == 1
+                else ["%s_%d" % (label, i) for i in range(1, len(part) + 1)]
+            )
+            compute_commands, energy = ph.hybrid_pair_compute_commands(ids, part_tags)
+            commands += compute_commands
+            compute_ids += ids
+            energies.append(energy if len(ids) == 1 else "(%s)" % energy)
+
+        commands.append("variable        step equal step")
+        commands.append("variable        dU1 equal %s/atoms" % energies[0])
+        commands.append("variable        dU2 equal %s/atoms" % energies[1])
+        return commands, compute_ids
+
     def _coupling_pair(self, lmp, ramp="0.0", tag=None):
         """Coupling mode: base components (all but last) at constant scale
         1.0, the LAST component scaled by `ramp` (a constant or v_name).
@@ -180,13 +265,16 @@ class Alchemy(cph.Phase):
             lmp = ph.create_structure(lmp, self.calc)
             self._coupling_pair(lmp, ramp="0.0")
         else:
-            lmp.command(f"pair_style {self.calc._pair_style_with_options[0]}")
+            # equilibrate with the initial potential on its own
+            initial, _ = self._end_states()
+            lmp.command(self._pure_pair_style_command(initial))
 
             # set up structure
             lmp = ph.create_structure(lmp, self.calc)
 
             # set up potential
-            lmp.command(f"pair_coeff {self.calc.pair_coeff[0]}")
+            for command in self._pure_pair_coeff_commands(initial):
+                lmp.command(command)
         lmp = ph.set_mass(lmp, self.calc)
 
         # add some computes
@@ -254,6 +342,8 @@ class Alchemy(cph.Phase):
         if self.calc.alchemy_coupling:
             return self._run_integration_coupling(iteration=iteration)
 
+        initial, final = self._end_states()
+
         # create lammps object
         lmp = ph.create_object(self.calc, self.simfolder)
 
@@ -261,22 +351,16 @@ class Alchemy(cph.Phase):
         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")
+        # the equilibrated configuration is read in with the initial potential
+        lmp.command(self._pure_pair_style_command(initial))
         conf = os.path.join(self.simfolder, "conf.equilibration.data")
         lmp = ph.read_data(lmp, conf)
-
-        # set up hybrid potential
-        # here we only need to set one potential
-        lmp.command(f"pair_coeff {self.calc.pair_coeff[0]}")
+        for command in self._pure_pair_coeff_commands(initial):
+            lmp.command(command)
         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
         lmp = ph.remap_box(lmp, self.lx, self.ly, self.lz)
@@ -316,143 +400,20 @@ class Alchemy(cph.Phase):
         # equilibration run is over
 
         # ---------------------------------------------------------------
-        # FWD cycle
+        # FWD cycle: initial potential scaled 1 -> 0, final potential 0 -> 1
         # ---------------------------------------------------------------
         lmp.command("variable         flambda equal ramp(${li},${lf})")
         lmp.command("variable         blambda equal ramp(${lf},${li})")
 
-        # lmp.command("pair_style       hybrid/scaled v_flambda %s v_blambda ufm 7.5"%self.options["md"]["pair_style"])
-
-        # Compute pair definitions
-        if self.calc.pair_style[0] == self.calc.pair_style[1]:
-            pc = self.calc.pair_coeff[0]
-            pcraw = pc.split()
-            pc1 = " ".join(
-                [
-                    *pcraw[:2],
-                    *[
-                        self.calc._pair_style_names[0],
-                    ],
-                    "1",
-                    *pcraw[2:],
-                ]
-            )
-            pc = self.calc.pair_coeff[1]
-            pcraw = pc.split()
-            pc2 = " ".join(
-                [
-                    *pcraw[:2],
-                    *[
-                        self.calc._pair_style_names[1],
-                    ],
-                    "2",
-                    *pcraw[2:],
-                ]
-            )
-        else:
-            pc = self.calc.pair_coeff[0]
-            pcraw = pc.split()
-            pc1 = " ".join(
-                [
-                    *pcraw[:2],
-                    *[
-                        self.calc._pair_style_names[0],
-                    ],
-                    *pcraw[2:],
-                ]
-            )
-            pc = self.calc.pair_coeff[1]
-            pcraw = pc.split()
-            pc2 = " ".join(
-                [
-                    *pcraw[:2],
-                    *[
-                        self.calc._pair_style_names[1],
-                    ],
-                    *pcraw[2:],
-                ]
-            )
-
-        lmp.command(
-            "pair_style       hybrid/scaled v_flambda %s v_blambda %s"
-            % (
-                self.calc._pair_style_with_options[0],
-                self.calc._pair_style_with_options[1],
-            )
+        commands, compute_ids = self._scaled_pair_commands(
+            initial, final, "v_flambda", "v_blambda"
         )
-        lmp.command("pair_coeff       %s" % pc1)
-        lmp.command("pair_coeff       %s" % pc2)
-
-        # apply pair force commands
-        if self.calc._pair_style_names[0] == self.calc._pair_style_names[1]:
-            lmp.command(
-                "compute         c1 all pair %s 1" % self.calc._pair_style_names[0]
-            )
-            lmp.command(
-                "compute         c2 all pair %s 2" % self.calc._pair_style_names[1]
-            )
-        else:
-            lmp.command(
-                "compute         c1 all pair %s" % self.calc._pair_style_names[0]
-            )
-            lmp.command(
-                "compute         c2 all pair %s" % self.calc._pair_style_names[1]
-            )
+        for command in commands:
+            lmp.command(command)
 
-        # Output variables.
-        lmp.command("variable        step equal step")
-        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 - forward pass
-        if (
-            self.calc.monte_carlo.n_swaps > 0
-            and len(self.calc.monte_carlo.forward_swap_types) >= 2
-        ):
-            swap_types = self.calc.monte_carlo.forward_swap_types
-            swap_combos = list(itertools.combinations(swap_types, 2))
-            self.logger.info(
-                f"Forward pass: {self.calc.monte_carlo.n_swaps} swap moves per combo, {len(swap_combos)} combinations every {self.calc.monte_carlo.n_steps}"
-            )
-            for combo in swap_combos:
-                self.logger.info(f"  Swapping types: {combo[0]} <-> {combo[1]}")
-
-            for idx, (type1, type2) in enumerate(swap_combos):
-                swap_str = f"{type1} {type2}"
-                if self.calc.monte_carlo.use_custom_lammps:
-                    lmp.command(
-                        "fix  swap%d all atom/swap %d %d %d %f ke no types %s noforce yes localE yes"
-                        % (
-                            idx,
-                            self.calc.monte_carlo.n_steps,
-                            self.calc.monte_carlo.n_swaps,
-                            np.random.randint(1, 10000),
-                            self.calc._temperature,
-                            swap_str,
-                        )
-                    )
-                else:
-                    lmp.command(
-                        "fix  swap%d all atom/swap %d %d %d %f ke no types %s"
-                        % (
-                            idx,
-                            self.calc.monte_carlo.n_steps,
-                            self.calc.monte_carlo.n_swaps,
-                            np.random.randint(1, 10000),
-                            self.calc._temperature,
-                            swap_str,
-                        )
-                    )
-
-            # Use the first swap fix for output tracking
-            # lmp.command("variable a equal f_swap0[1]")
-            # lmp.command("variable b equal f_swap0[2]")
-            # lmp.command(
-            #    'fix             swap_print all print 1 "${a} ${b} ${flambda}" screen no file swap.forward_%d.dat'
-            #    % iteration
-            # )
+        swap_fixes = self._add_swap_fixes(
+            lmp, self.calc.monte_carlo.forward_swap_types, "Forward"
+        )
 
         # Thermo output.
         lmp.command("thermo_style    custom step v_dU1 v_dU2")
@@ -467,21 +428,16 @@ class Alchemy(cph.Phase):
         )
         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:
-            swap_types = self.calc.monte_carlo.forward_swap_types
-            swap_combos = list(itertools.combinations(swap_types, 2))
-            for idx in range(len(swap_combos)):
-                lmp.command(f"unfix swap{idx}")
-            # lmp.command("unfix swap_print")
+        for compute_id in compute_ids:
+            lmp.command("uncompute       %s" % compute_id)
+        for swap_fix in swap_fixes:
+            lmp.command("unfix %s" % swap_fix)
 
-        lmp.command("pair_style      %s" % self.calc._pair_style_with_options[1])
-        lmp.command("pair_coeff      %s" % self.calc.pair_coeff[1])
+        # now equilibrate with the final potential on its own
+        lmp.command(self._pure_pair_style_command(final))
+        for command in self._pure_pair_coeff_commands(final):
+            lmp.command(command)
 
         # Thermo output.
         lmp.command("thermo_style    custom step pe")
@@ -490,90 +446,21 @@ class Alchemy(cph.Phase):
         # run eqbrm run
         lmp.command("run             %d" % self.calc.n_equilibration_steps)
 
-        # reverse switching
+        # ---------------------------------------------------------------
+        # BKD cycle: initial potential scaled 0 -> 1, final potential 1 -> 0
+        # ---------------------------------------------------------------
         lmp.command("variable         flambda equal ramp(${lf},${li})")
         lmp.command("variable         blambda equal ramp(${li},${lf})")
 
-        lmp.command(
-            "pair_style       hybrid/scaled v_flambda %s v_blambda %s"
-            % (
-                self.calc._pair_style_with_options[0],
-                self.calc._pair_style_with_options[1],
-            )
+        commands, compute_ids = self._scaled_pair_commands(
+            initial, final, "v_flambda", "v_blambda"
         )
-        lmp.command("pair_coeff       %s" % pc1)
-        lmp.command("pair_coeff       %s" % pc2)
-
-        # apply pair force commands
-        if self.calc._pair_style_names[0] == self.calc._pair_style_names[1]:
-            lmp.command(
-                "compute         c1 all pair %s 1" % self.calc._pair_style_names[0]
-            )
-            lmp.command(
-                "compute         c2 all pair %s 2" % self.calc._pair_style_names[1]
-            )
-        else:
-            lmp.command(
-                "compute         c1 all pair %s" % self.calc._pair_style_names[0]
-            )
-            lmp.command(
-                "compute         c2 all pair %s" % self.calc._pair_style_names[1]
-            )
+        for command in commands:
+            lmp.command(command)
 
-        # Output variables.
-        lmp.command("variable        step equal step")
-        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 - reverse pass
-        if (
-            self.calc.monte_carlo.n_swaps > 0
-            and len(self.calc.monte_carlo.reverse_swap_types) >= 2
-        ):
-            swap_types = self.calc.monte_carlo.reverse_swap_types
-            swap_combos = list(itertools.combinations(swap_types, 2))
-            self.logger.info(
-                f"Reverse pass: {self.calc.monte_carlo.n_swaps} swap moves per combo, {len(swap_combos)} combinations every {self.calc.monte_carlo.n_steps}"
-            )
-            for combo in swap_combos:
-                self.logger.info(f"  Swapping types: {combo[0]} <-> {combo[1]}")
-
-            for idx, (type1, type2) in enumerate(swap_combos):
-                swap_str = f"{type1} {type2}"
-                if self.calc.monte_carlo.use_custom_lammps:
-                    lmp.command(
-                        "fix  swap%d all atom/swap %d %d %d %f ke no types %s noforce yes localE yes"
-                        % (
-                            idx,
-                            self.calc.monte_carlo.n_steps,
-                            self.calc.monte_carlo.n_swaps,
-                            np.random.randint(1, 10000),
-                            self.calc._temperature,
-                            swap_str,
-                        )
-                    )
-                else:
-                    lmp.command(
-                        "fix  swap%d all atom/swap %d %d %d %f ke no types %s"
-                        % (
-                            idx,
-                            self.calc.monte_carlo.n_steps,
-                            self.calc.monte_carlo.n_swaps,
-                            np.random.randint(1, 10000),
-                            self.calc._temperature,
-                            swap_str,
-                        )
-                    )
-
-            # Use the first swap fix for output tracking
-            # lmp.command("variable a equal f_swap0[1]")
-            # lmp.command("variable b equal f_swap0[2]")
-            # lmp.command(
-            #'fix             swap_print all print 1 "${a} ${b} ${blambda}" screen no file swap.backward_%d.dat'
-            #    % iteration
-            # )
+        swap_fixes = self._add_swap_fixes(
+            lmp, self.calc.monte_carlo.reverse_swap_types, "Reverse"
+        )
 
         # Thermo output.
         lmp.command("thermo_style    custom step v_dU1 v_dU2")
@@ -588,21 +475,52 @@ class Alchemy(cph.Phase):
         )
         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")
-
-        if self.calc.monte_carlo.n_swaps > 0:
-            swap_types = self.calc.monte_carlo.reverse_swap_types
-            swap_combos = list(itertools.combinations(swap_types, 2))
-            for idx in range(len(swap_combos)):
-                lmp.command(f"unfix swap{idx}")
-            # lmp.command("unfix swap_print")
+        for compute_id in compute_ids:
+            lmp.command("uncompute       %s" % compute_id)
+        for swap_fix in swap_fixes:
+            lmp.command("unfix %s" % swap_fix)
 
         self.lammps_close(lmp=lmp)
         lmp.rotate_logs("integration")
 
+    def _add_swap_fixes(self, lmp, swap_types, pass_name):
+        """
+        Add ``fix atom/swap`` moves between every pair of ``swap_types`` when
+        Monte Carlo swaps are requested; returns the fix ids that were added.
+        """
+        mc = self.calc.monte_carlo
+        if not (mc.n_swaps > 0 and len(swap_types) >= 2):
+            return []
+
+        swap_combos = list(itertools.combinations(swap_types, 2))
+        self.logger.info(
+            f"{pass_name} pass: {mc.n_swaps} swap moves per combo, "
+            f"{len(swap_combos)} combinations every {mc.n_steps}"
+        )
+        for combo in swap_combos:
+            self.logger.info(f"  Swapping types: {combo[0]} <-> {combo[1]}")
+
+        fix_ids = []
+        for idx, (type1, type2) in enumerate(swap_combos):
+            fix_id = "swap%d" % idx
+            extra = " noforce yes localE yes" if mc.use_custom_lammps else ""
+            lmp.command(
+                "fix  %s all atom/swap %d %d %d %f ke no types %s %s%s"
+                % (
+                    fix_id,
+                    mc.n_steps,
+                    mc.n_swaps,
+                    np.random.randint(1, 10000),
+                    self.calc._temperature,
+                    type1,
+                    type2,
+                    extra,
+                )
+            )
+            fix_ids.append(fix_id)
+        return fix_ids
+
     def thermodynamic_integration(self):
         """
         Calculate free energy after integration step

{calphy-2.1.1 → calphy-2.1.2}/calphy/helpers.py

@@ -208,26 +208,78 @@ def _component_pair_coeffs(options):
     return components
 
 
-def hybrid_pair_coeff_commands(options, repeat_index=0, total_repeats=1):
-    components = _component_pair_coeffs(options)
-    active_style_names = []
-    for _ in range(total_repeats):
-        active_style_names.extend([style_name for style_name, _ in components])
-    total_counts = Counter(active_style_names)
+def hybrid_component_tags(style_names):
+    """
+    Sub-style tags of the components of a hybrid pair_style.
+
+    LAMMPS addresses a sub-style of a hybrid pair_style by its name, followed
+    by a 1-based occurrence index when the same style appears more than once
+    (``pair_coeff * * eam/alloy 2 ...``, ``compute c all pair eam/alloy 2``).
+
+    Parameters
+    ----------
+    style_names : list of str
+        Style names in the order they appear in the hybrid pair_style.
+
+    Returns
+    -------
+    list of (str, int or None)
+        One (name, index) tag per component; the index is None for a style
+        that occurs once.
+    """
+    counts = Counter(style_names)
     seen = defaultdict(int)
-    for _ in range(repeat_index):
-        for style_name, _ in components:
-            seen[style_name] += 1
+    tags = []
+    for name in style_names:
+        seen[name] += 1
+        tags.append((name, seen[name] if counts[name] > 1 else None))
+    return tags
+
+
+def hybrid_pair_coeff_commands_for(style_names, pair_coeffs):
+    """
+    ``pair_coeff`` commands for the components of a hybrid pair_style.
+
+    Parameters
+    ----------
+    style_names : list of str
+        Style names in hybrid order, one per pair_coeff.
+    pair_coeffs : list of str
+        The pair_coeff arguments, with or without the style name already
+        included after the type pair.
+    """
+    return [
+        "pair_coeff       %s" % _with_hybrid_pair_coeff_style(pair_coeff, name, index)
+        for (name, index), pair_coeff in zip(hybrid_component_tags(style_names), pair_coeffs)
+    ]
+
+
+def hybrid_pair_compute_commands(compute_ids, tags):
+    """
+    ``compute pair`` commands, one per hybrid sub-style tag.
 
+    Returns the commands and the LAMMPS expression summing the computes.
+    """
     commands = []
-    for style_name, pair_coeff in components:
-        seen[style_name] += 1
-        style_index = seen[style_name] if total_counts[style_name] > 1 else None
-        commands.append(
-            "pair_coeff       %s"
-            % _with_hybrid_pair_coeff_style(pair_coeff, style_name, style_index)
-        )
-    return commands
+    for compute_id, (name, index) in zip(compute_ids, tags):
+        if index is None:
+            commands.append("compute          %s all pair %s" % (compute_id, name))
+        else:
+            commands.append(
+                "compute          %s all pair %s %d" % (compute_id, name, index)
+            )
+    return commands, "+".join("c_%s" % compute_id for compute_id in compute_ids)
+
+
+def hybrid_pair_coeff_commands(options, repeat_index=0, total_repeats=1):
+    components = _component_pair_coeffs(options)
+    n = len(components)
+    style_names = [style_name for style_name, _ in components] * total_repeats
+    tags = hybrid_component_tags(style_names)[repeat_index * n : (repeat_index + 1) * n]
+    return [
+        "pair_coeff       %s" % _with_hybrid_pair_coeff_style(pair_coeff, name, index)
+        for (name, index), (_, pair_coeff) in zip(tags, components)
+    ]
 
 
 def set_pair_coeff(lmp, options):
@@ -253,35 +305,12 @@ def real_pair_compute_commands(
     options, prefix="c_real", total_repeats=1, repeat_index=0
 ):
     components = _component_pair_coeffs(options)
-    active_style_names = []
-    for _ in range(total_repeats):
-        active_style_names.extend([style_name for style_name, _ in components])
-    total_counts = Counter(active_style_names)
-    seen = defaultdict(int)
-    for _ in range(repeat_index):
-        for style_name, _ in components:
-            seen[style_name] += 1
-
-    commands = []
-    terms = []
-    for idx, (style_name, _) in enumerate(components, start=1):
-        seen[style_name] += 1
-        compute_id = "%s%d" % (prefix, idx)
-        if total_counts[style_name] > 1:
-            commands.append(
-                "compute          %s all pair %s %d"
-                % (compute_id, style_name, seen[style_name])
-            )
-        else:
-            commands.append(
-                "compute          %s all pair %s" % (compute_id, style_name)
-            )
-        terms.append("c_%s" % compute_id)
-    return (
-        commands,
-        "+".join(terms),
-        ["%s%d" % (prefix, idx) for idx in range(1, len(components) + 1)],
-    )
+    n = len(components)
+    style_names = [style_name for style_name, _ in components] * total_repeats
+    tags = hybrid_component_tags(style_names)[repeat_index * n : (repeat_index + 1) * n]
+    compute_ids = ["%s%d" % (prefix, idx) for idx in range(1, n + 1)]
+    commands, energy = hybrid_pair_compute_commands(compute_ids, tags)
+    return commands, energy, compute_ids
 
 
 def set_potential(lmp, options):

{calphy-2.1.1 → calphy-2.1.2}/calphy/input.py

@@ -53,7 +53,7 @@ from pyscal3.core import structure_dict, element_dict, _make_crystal
 from ase.io import read, write
 import shutil
 
-__version__ = "2.1.1"
+__version__ = "2.1.2"
 
 
 def _check_equal(val):
@@ -669,16 +669,38 @@ class Calculation(_StrictInput, title="Main input class"):
                     raise ValueError(
                         "pair_mode overlay expects component pair styles, not a hybrid pair_style"
                     )
+            if self.mode == "alchemy" and not self.alchemy_coupling:
+                raise ValueError(
+                    "pair_mode overlay is not supported for mode alchemy: the two "
+                    "pair_style/pair_coeff entries are the potential switched from "
+                    "and the potential switched to. To change the composition of an "
+                    "overlay potential use mode composition_scaling."
+                )
+
+        # the components that make up the physical potential: every entry for
+        # an overlay, otherwise only the first one is used
+        if self.pair_coeff is not None and self.pair_mode == "overlay":
+            potential_pair_coeffs = list(self.pair_coeff)
+        elif self.pair_coeff is not None and len(self.pair_coeff) > 0:
+            potential_pair_coeffs = [self.pair_coeff[0]]
+        else:
+            potential_pair_coeffs = []
+
+        if self.mode == "composition_scaling":
+            # composition scaling renumbers the atom types, so a pair_coeff
+            # tied to explicit type numbers would address the wrong atoms
+            for pc in potential_pair_coeffs:
+                if pc.split()[:2] != ["*", "*"]:
+                    raise ValueError(
+                        "mode composition_scaling needs every pair_coeff to apply to "
+                        f"all atom types ('* * ...'); got: {pc}"
+                    )
 
         # 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])
+        for potential_pair_coeff in potential_pair_coeffs if len(self.element) > 1 else []:
+            extracted_elements = _extract_elements_from_pair_coeff(potential_pair_coeff)
 
             if extracted_elements is not None:
                 # pair_coeff specifies elements - check ordering

{calphy-2.1.1 → calphy-2.1.2}/calphy/routines.py

@@ -602,6 +602,48 @@ def routine_alchemy(job):
     return job
 
 
+def set_composition_scaling_potential(calc, comp):
+    """
+    Rewrite the pair lists of a composition_scaling calculation into the two
+    end states the alchemy driver switches between.
+
+    A plain potential contributes its single component; with
+    ``pair_mode: overlay`` every component of the overlay is carried along.
+    The pair_coeff of each component is mapped once onto the input types
+    (the element list before the transformation) and once onto the output
+    types, and the lists become ``[initial_1 .. initial_N, final_1 ..
+    final_N]`` with the pair styles repeated to match.
+
+    Parameters
+    ----------
+    calc : Calculation
+        the calculation, modified in place
+    comp : CompositionTransformation
+        the transformation providing ``update_pair_coeff``
+
+    Returns
+    -------
+    n_components : int
+        number of components in each end state
+    """
+    n_components = len(calc.pair_style) if ph.is_overlay_potential(calc) else 1
+    styles = list(calc.pair_style[:n_components])
+    styles_with_options = list(calc._pair_style_with_options[:n_components])
+    names = list(calc._pair_style_names[:n_components])
+
+    initial, final = [], []
+    for pair_coeff in calc.pair_coeff[:n_components]:
+        pc_initial, pc_final = comp.update_pair_coeff(pair_coeff)
+        initial.append(pc_initial)
+        final.append(pc_final)
+
+    calc.pair_style = styles + styles
+    calc._pair_style_with_options = styles_with_options + styles_with_options
+    calc._pair_style_names = names + names
+    calc.pair_coeff = initial + final
+    return n_components
+
+
 def routine_composition_scaling(job):
     """
     Perform a compositional scaling routine
@@ -617,19 +659,16 @@ def routine_composition_scaling(job):
     job.logger.info(f"Forward swap types: {forward_swap_types}")
     job.logger.info(f"Reverse swap types: {reverse_swap_types}")
 
-    # update pair styles
-    res = comp.update_pair_coeff(job.calc.pair_coeff[0])
-    job.calc.pair_style.append(job.calc.pair_style[0])
-    job.calc._pair_style_with_options.append(job.calc._pair_style_with_options[0])
-    job.calc.pair_coeff[0] = res[0]
-    job.calc.pair_coeff.append(res[1])
-    job.logger.info("Update pair coefficients")
-    job.logger.info(f"pair coeff 1: {job.calc.pair_coeff[0]}")
-    job.logger.info(f"pair coeff 2: {job.calc.pair_coeff[1]}")
-    job.calc._pair_style_names.append(job.calc._pair_style_names[0])
-    job.logger.info("Update pair styles")
-    job.logger.info(f"pair style 1: {job.calc._pair_style_names[0]}")
-    job.logger.info(f"pair style 2: {job.calc._pair_style_names[1]}")
+    # rewrite the potential into its initial and final composition
+    n_components = set_composition_scaling_potential(job.calc, comp)
+    job.logger.info("Update pair styles and coefficients")
+    for idx in range(2 * n_components):
+        end = "initial" if idx < n_components else "final"
+        job.logger.info(
+            f"{end} component {idx % n_components + 1}: "
+            f"pair_style {job.calc._pair_style_with_options[idx]} | "
+            f"pair_coeff {job.calc.pair_coeff[idx]}"
+        )
 
     backup_element = job.calc.element.copy()
     job.calc.element = comp.pair_list_old

{calphy-2.1.1 → calphy-2.1.2}/calphy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calphy
-Version: 2.1.1
+Version: 2.1.2
 Summary: free energy calculation for python
 Author: Yury Lysogorskiy, Ralf Drautz
 Author-email: Sarath Menon <sarath.menon@ruhr-uni-bochum.de>

{calphy-2.1.1 → calphy-2.1.2}/calphy.egg-info/SOURCES.txt

@@ -30,6 +30,7 @@ calphy.egg-info/entry_points.txt
 calphy.egg-info/requires.txt
 calphy.egg-info/top_level.txt
 tests/test_command_vocabulary.py
+tests/test_composition_scaling_potential.py
 tests/test_composition_transformation_bug.py
 tests/test_dissipation_check.py
 tests/test_element_ordering.py

{calphy-2.1.1 → calphy-2.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "calphy"
-version = "2.1.1"
+version = "2.1.2"
 description = "free energy calculation for python"
 readme = "README.md"
 license = "LicenseRef-ASL-1.0"

calphy-2.1.2/tests/test_composition_scaling_potential.py

@@ -0,0 +1,76 @@
+"""set_composition_scaling_potential: the pair lists of a composition_scaling
+calculation become the initial and final potential of the alchemical switch,
+component by component."""
+import os
+
+import pytest
+
+from calphy.input import Calculation
+from calphy.composition_transformation import CompositionTransformation
+from calphy.routines import set_composition_scaling_potential
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+ZRCU = os.path.join(REPO, "examples", "example_10", "ZrCu.data")
+POT = os.path.join(REPO, "examples", "potentials", "ZrCu.eam.fs")
+
+BASE = dict(
+    element=["Zr", "Cu"], mass=[91.224, 63.546], lattice=ZRCU, lattice_constant=0.0,
+    mode="composition_scaling",
+    composition_scaling={"output_chemical_composition": {"Cu": 532, "Zr": 492}},
+    temperature=800, pressure=0, reference_phase="solid",
+)
+
+
+@pytest.fixture
+def in_tmp(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+
+
+def _prepare(**extra):
+    calc = Calculation(**{**BASE, **extra})
+    comp = CompositionTransformation(calc)
+    n = set_composition_scaling_potential(calc, comp)
+    return calc, comp, n
+
+
+def test_plain_potential_becomes_two_copies(in_tmp):
+    calc, comp, n = _prepare(pair_style="eam/fs", pair_coeff="* * %s Zr Cu" % POT)
+    assert n == 1
+    assert calc.pair_style == ["eam/fs", "eam/fs"]
+    assert calc._pair_style_names == ["eam/fs", "eam/fs"]
+    old, new = comp.update_pair_coeff("* * %s Zr Cu" % POT)
+    assert calc.pair_coeff == [old, new]
+    # the elements follow the per-type mappings (Cu-Cu, Zr-Cu, Zr-Zr): the
+    # initial mapping keeps the 20 transformed atoms Zr, the final names them Cu
+    assert old.split()[3:] == comp.pair_list_old == ["Cu", "Zr", "Zr"]
+    assert new.split()[3:] == comp.pair_list_new == ["Cu", "Cu", "Zr"]
+
+
+def test_overlay_components_are_rewritten_pairwise(in_tmp):
+    calc, comp, n = _prepare(
+        pair_mode="overlay",
+        pair_style=["eam/fs", "zero 5.0"],
+        pair_coeff=["* * eam/fs %s Zr Cu" % POT, "* * zero"],
+    )
+    assert n == 2
+    assert calc.pair_style == ["eam/fs", "zero 5.0", "eam/fs", "zero 5.0"]
+    assert calc._pair_style_with_options == calc.pair_style
+    assert calc._pair_style_names == ["eam/fs", "zero", "eam/fs", "zero"]
+    assert calc.pair_coeff == [
+        "* * eam/fs %s Cu Zr Zr" % POT,
+        "* * zero",
+        "* * eam/fs %s Cu Cu Zr" % POT,
+        "* * zero",
+    ]
+
+
+def test_extra_entries_of_a_plain_potential_are_dropped(in_tmp):
+    """Without pair_mode overlay only the first pair_style/pair_coeff describe
+    the potential; a stray second entry must not leak into the end states."""
+    calc, comp, n = _prepare(
+        pair_style=["eam/fs", "eam/alloy"],
+        pair_coeff=["* * %s Zr Cu" % POT, "* * other.eam.alloy Zr Cu"],
+    )
+    assert n == 1
+    assert calc.pair_style == ["eam/fs", "eam/fs"]
+    assert len(calc.pair_coeff) == 2

{calphy-2.1.1 → calphy-2.1.2}/tests/test_golden_streams.py

@@ -284,3 +284,50 @@ def test_iterations_draw_fresh_seeds(make_calc, recorded_job, tmp_path, JobClass
     vel, therm = zip(*seen)
     assert len(set(vel)) == 3, "velocity seeds repeat across iterations: %s" % (vel,)
     assert len(set(therm)) == 3, "thermostat seeds repeat across iterations: %s" % (therm,)
+
+
+# --------------------------------------------------------------------------- #
+# composition_scaling: the potential is rewritten into an initial and a final
+# composition; with pair_mode overlay every component is carried along.
+# --------------------------------------------------------------------------- #
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+ZRCU = os.path.join(REPO, "examples", "example_10", "ZrCu.data")
+
+
+def _composition_scaling_job(make_calc, recorded_job, fixtures=(), **overrides):
+    from calphy.composition_transformation import CompositionTransformation
+    from calphy.routines import set_composition_scaling_potential
+
+    # the transformation reads the real structure, so pin the sentinel afterwards
+    calc = make_calc("B13", lattice_sentinel=None, lattice=ZRCU, **LOOSE_TOL, **overrides)
+    comp = CompositionTransformation(calc)
+    set_composition_scaling_potential(calc, comp)
+    calc.element = comp.pair_list_old
+    calc.lattice = "structure.data"
+    return recorded_job(Alchemy, calc, fixtures=fixtures)
+
+
+def test_composition_scaling_overlay_averaging(make_calc, recorded_job):
+    job, rec = _composition_scaling_job(make_calc, recorded_job, fixtures=["avg.dat"])
+    job.run_averaging()
+    assert_golden(rec.commands, "composition_scaling_overlay_averaging")
+
+
+def test_composition_scaling_overlay_integration(make_calc, recorded_job):
+    job, rec = _composition_scaling_job(make_calc, recorded_job)
+    _set_state(job)
+    job.run_integration(iteration=1)
+    assert_golden(rec.commands, "composition_scaling_overlay_integration")
+
+
+def test_composition_scaling_integration(make_calc, recorded_job):
+    """Plain (single component) potential: the pre-overlay command stream."""
+    job, rec = _composition_scaling_job(
+        make_calc, recorded_job,
+        pair_mode=None,
+        pair_style="eam/fs",
+        pair_coeff="* * examples/potentials/ZrCu.eam.fs Zr Cu",
+    )
+    _set_state(job)
+    job.run_integration(iteration=1)
+    assert_golden(rec.commands, "composition_scaling_integration")

{calphy-2.1.1 → calphy-2.1.2}/tests/test_helpers.py

@@ -84,3 +84,57 @@ def test_prepare_log_no_cross_contamination():
         assert "message from calc2" not in content1, "calc1.log must NOT contain calc2 message"
         assert "message from calc2" in content2, "calc2.log should contain calc2 message"
         assert "message from calc1" not in content2, "calc2.log must NOT contain calc1 message"
+
+
+def test_hybrid_component_tags_index_only_repeated_styles():
+    tags = ch.hybrid_component_tags(["eam/fs", "zero", "eam/fs", "zero"])
+    assert tags == [("eam/fs", 1), ("zero", 1), ("eam/fs", 2), ("zero", 2)]
+    assert ch.hybrid_component_tags(["eam/alloy", "eam/fs"]) == [
+        ("eam/alloy", None),
+        ("eam/fs", None),
+    ]
+
+
+def test_hybrid_pair_coeff_commands_for_keeps_native_style_token():
+    cmds = ch.hybrid_pair_coeff_commands_for(
+        ["eam/fs", "zero", "eam/fs", "zero"],
+        ["* * eam/fs a.eam.fs Zr Zr", "* * zero", "* * a.eam.fs Zr Cu", "* * zero"],
+    )
+    assert [" ".join(c.split()) for c in cmds] == [
+        "pair_coeff * * eam/fs 1 a.eam.fs Zr Zr",
+        "pair_coeff * * zero 1",
+        "pair_coeff * * eam/fs 2 a.eam.fs Zr Cu",
+        "pair_coeff * * zero 2",
+    ]
+
+
+def test_hybrid_pair_compute_commands_sum_expression():
+    cmds, energy = ch.hybrid_pair_compute_commands(
+        ["c1_1", "c1_2"], [("eam/fs", 1), ("zero", None)]
+    )
+    assert [" ".join(c.split()) for c in cmds] == [
+        "compute c1_1 all pair eam/fs 1",
+        "compute c1_2 all pair zero",
+    ]
+    assert energy == "c_c1_1+c_c1_2"
+
+
+def test_hybrid_pair_coeff_commands_repeat_index_matches_full_hybrid():
+    class Options:
+        _pair_style_names = ["eam/alloy", "eam/alloy"]
+        pair_coeff = ["* * potA Cu", "* * potB Cu"]
+
+    first = ch.hybrid_pair_coeff_commands(Options, repeat_index=0, total_repeats=2)
+    second = ch.hybrid_pair_coeff_commands(Options, repeat_index=1, total_repeats=2)
+    assert [" ".join(c.split()) for c in first + second] == [
+        "pair_coeff * * eam/alloy 1 potA Cu",
+        "pair_coeff * * eam/alloy 2 potB Cu",
+        "pair_coeff * * eam/alloy 3 potA Cu",
+        "pair_coeff * * eam/alloy 4 potB Cu",
+    ]
+    cmds, energy, ids = ch.real_pair_compute_commands(Options, total_repeats=2, repeat_index=1)
+    assert [" ".join(c.split()) for c in cmds] == [
+        "compute c_real1 all pair eam/alloy 3",
+        "compute c_real2 all pair eam/alloy 4",
+    ]
+    assert energy == "c_c_real1+c_c_real2" and ids == ["c_real1", "c_real2"]

{calphy-2.1.1 → calphy-2.1.2}/tests/test_input_validation.py

@@ -151,3 +151,58 @@ def test_repo_example_inputs_are_key_clean():
             if "unknown input key" in str(exc) or "removed in calphy" in str(exc):
                 bad.append((f, str(exc)))
     assert not bad, bad
+
+
+# --------------------------------------------------------------------------- #
+# overlay potentials: alchemy vs composition_scaling
+# --------------------------------------------------------------------------- #
+OVERLAY = dict(
+    pair_mode="overlay",
+    pair_style=["eam/alloy", "zero 5.0"],
+    pair_coeff=["* * eam/alloy Cu.eam.alloy Cu", "* * zero"],
+)
+
+
+def test_overlay_rejected_for_mode_alchemy():
+    msg = error_of(mode="alchemy", **OVERLAY)
+    assert "pair_mode overlay is not supported for mode alchemy" in msg
+    assert "composition_scaling" in msg
+
+
+def test_overlay_allowed_for_alchemy_coupling():
+    build(mode="alchemy", alchemy_coupling=True, **OVERLAY)
+
+
+ZRCU = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+                    "examples", "example_10", "ZrCu.data")
+CSCALE = dict(
+    element=["Zr", "Cu"], mass=[91.224, 63.546], lattice=ZRCU, lattice_constant=0.0,
+    mode="composition_scaling",
+    composition_scaling={"output_chemical_composition": {"Cu": 532, "Zr": 492}},
+    temperature=800, pressure=0, reference_phase="solid",
+)
+
+
+def test_composition_scaling_accepts_overlay(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    calc = build(**CSCALE, pair_mode="overlay", pair_style=["eam/fs", "zero 5.0"],
+                 pair_coeff=["* * eam/fs ZrCu.eam.fs Zr Cu", "* * zero"])
+    assert calc._pair_style_names == ["eam/fs", "zero"]
+
+
+def test_composition_scaling_needs_wildcard_types(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    msg = error_of(**CSCALE, pair_style="eam/fs", pair_coeff="1 2 ZrCu.eam.fs Zr Cu")
+    assert "all atom types" in msg
+    # the wildcard rule covers every overlay component, not only the first
+    msg = error_of(**CSCALE, pair_mode="overlay", pair_style=["eam/fs", "zero 5.0"],
+                   pair_coeff=["* * eam/fs ZrCu.eam.fs Zr Cu", "1 1 zero"])
+    assert "1 1 zero" in msg
+
+
+def test_overlay_element_order_checked_on_every_component(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    # elements listed only on the second component, in the wrong order
+    msg = error_of(**CSCALE, pair_mode="overlay", pair_style=["zero 5.0", "eam/fs"],
+                   pair_coeff=["* * zero", "* * eam/fs ZrCu.eam.fs Cu Zr"])
+    assert "Element ordering mismatch" in msg