allomorph 0.1.0__py3-none-any.whl

allomorph/__init__.py

@@ -0,0 +1,58 @@
+"""Nanoparticle structure generation toolkit.
+
+A package for generating monometallic to trimetallic nanoparticle structural
+datasets for machine learning applications.
+"""
+
+__version__ = "0.1.0"
+
+from allomorph.constants import (
+    BNP_DIR,
+    BNP_DISTRIB_LIST,
+    DIAMETER_LIST,
+    ELE_DICT,
+    GOLDEN_RATIO,
+    LMP_DATA_DIR,
+    MNP_DIR,
+    RANDOM_DISTRIB_NO,
+    RATIO_LIST,
+    SHAPE_LIST,
+    TNP_DIR,
+    TNP_DISTRIB_LIST,
+    VACUUM_THICKNESS,
+    load_ele_dict_from_file,
+    parse_ele_comb,
+    validate_ele_dict,
+)
+from allomorph.init_struct.gen_bnp_al import gen_bnp, write_bnp
+from allomorph.init_struct.gen_bnp_cs import gen_hard_core_shell, write_hard_core_shell
+from allomorph.init_struct.gen_mnp import gen_mnp, write_mnp
+from allomorph.init_struct.gen_tnp_al import gen_tnp, write_tnp
+
+__all__ = [
+    "__version__",
+    "LMP_DATA_DIR",
+    "MNP_DIR",
+    "BNP_DIR",
+    "TNP_DIR",
+    "GOLDEN_RATIO",
+    "VACUUM_THICKNESS",
+    "RANDOM_DISTRIB_NO",
+    "ELE_DICT",
+    "DIAMETER_LIST",
+    "SHAPE_LIST",
+    "BNP_DISTRIB_LIST",
+    "TNP_DISTRIB_LIST",
+    "RATIO_LIST",
+    "validate_ele_dict",
+    "load_ele_dict_from_file",
+    "parse_ele_comb",
+    "gen_mnp",
+    "write_mnp",
+    "gen_bnp",
+    "write_bnp",
+    "gen_tnp",
+    "write_tnp",
+    "gen_hard_core_shell",
+    "write_hard_core_shell",
+]

allomorph/__main__.py

@@ -0,0 +1,4 @@
+from allomorph.cli import main
+
+if __name__ == "__main__":
+    main()

allomorph/cli.py

@@ -0,0 +1,85 @@
+"""Command-line interface for AlloMorph."""
+
+import argparse
+import sys
+
+from allomorph.constants import load_config, update_constants
+
+
+def main(argv=None):
+    """Entry point for the AlloMorph CLI."""
+    parser = argparse.ArgumentParser(
+        prog="allomorph",
+        description="Toolkit for generating monometallic to trimetallic nanoparticle structural datasets.",
+    )
+    parser.add_argument(
+        "--config",
+        help="Path to a configuration file (JSON, YAML, or TOML) to override default constants.",
+    )
+    
+    # Subcommands
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # init-struct subcommand (Main functionality)
+    init_parser = subparsers.add_parser(
+        "init-struct",
+        help="Generate initial nanoparticle structures.",
+    )
+    init_parser.add_argument(
+        "--stage",
+        choices=["mnp", "bnp", "tnp", "cs", "all"],
+        default="all",
+        help="Which structure generation stage to run (default: all)",
+    )
+    init_parser.add_argument(
+        "--replace",
+        action="store_true",
+        help="Overwrite existing files.",
+    )
+    init_parser.add_argument(
+        "--vis",
+        action="store_true",
+        help="Visualise generated structures (opens ASE GUI).",
+    )
+    init_parser.set_defaults(func=_init_struct_cmd)
+
+    args = parser.parse_args(argv)
+
+    if args.config:
+        config = load_config(args.config)
+        update_constants(config)
+
+    if args.vis:
+        print("Warning: --vis flag enabled. Visualization will run serially to prevent system hang.")
+        print("Many windows may be opened sequentially. Close one to see the next.")
+
+    if args.command is None:
+        parser.print_help()
+        sys.exit(1)
+
+    args.func(args)
+
+
+def _init_struct_cmd(args):
+    """Run the initial structure generation command."""
+    from allomorph.init_struct.gen_bnp_al import main as gen_bnp_main
+    from allomorph.init_struct.gen_bnp_cs import write_hard_core_shell as gen_bnp_cs_main
+    from allomorph.init_struct.gen_mnp import main as gen_mnp_main
+    from allomorph.init_struct.gen_tnp_al import main as gen_tnp_main
+
+    if args.stage in ("mnp", "all"):
+        print("=== Generating monometallic nanoparticles (MNP) ===")
+        gen_mnp_main(replace=args.replace, vis=args.vis)
+    if args.stage in ("bnp", "all"):
+        print("=== Generating bimetallic nanoparticles (BNP) ===")
+        gen_bnp_main(replace=args.replace, vis=args.vis)
+    if args.stage in ("cs", "all"):
+        print("=== Generating hard core-shell nanoparticles (CS) ===")
+        gen_bnp_cs_main(replace=args.replace, vis=args.vis)
+    if args.stage in ("tnp", "all"):
+        print("=== Generating trimetallic nanoparticles (TNP) ===")
+        gen_tnp_main(replace=args.replace, vis=args.vis)
+
+
+if __name__ == "__main__":
+    main()

allomorph/constants.py

@@ -0,0 +1,267 @@
+# Purpose: Store variables for generation of NPs using ASE
+# Author: Jonathan Yik Chang Ting
+# Date: 19/20/2020
+
+from math import sqrt
+
+import numpy as np
+
+LMP_DATA_DIR = "."
+MNP_DIR = "MNP"
+BNP_DIR = "BNP"
+TNP_DIR = "TNP"
+CS_DIR = "CS"
+GOLDEN_RATIO = (1 + sqrt(5)) / 2
+VACUUM_THICKNESS = 40.0
+RANDOM_DISTRIB_NO = 3
+
+# Elements of interest, their lattice parameters, metallic radii, and physical properties.
+# - Pd, Pt, Au values were obtained from N. W. Ashcroft and N. D. Mermin,
+#   Solid State Physics (Holt, Rinehart, and Winston, New York, 1976.
+# - The lattice constants are 3.859, 3.912, and 4.065 Angstroms, for the
+#   respective FCC metals at 300 K according to W. P. Davey,
+#   "Precision Measurements of the Lattice Constants of Twelve Common Metals,"
+#   Physical Review, vol. 25, (6), pp. 753-761, 1925.
+# - Metallic radii taken from Greenwood, Norman N.; Earnshaw, Alan (1997).
+#   Chemistry of the Elements (2nd ed.).
+# - Density (rho) in kg/m^3, molar mass (m) in kg/mol, and bulk cohesive
+#   energy (bulkE) in eV/atom are used by the feature-extraction pipeline.
+ELE_DICT = {
+    "Pd": {"lc": {"FCC": 3.89}, "radius": 1.37, "mass": 106.42,
+           "rho": 12020, "m": 0.10642, "bulkE": 3.89},
+    "Pt": {"lc": {"FCC": 3.92}, "radius": 1.39, "mass": 195.08,
+           "rho": 21450, "m": 0.195084, "bulkE": 5.84},
+    "Au": {"lc": {"FCC": 4.09}, "radius": 1.44, "mass": 196.97,
+           "rho": 19320, "m": 0.196967, "bulkE": 3.81},
+    "Cu": {"lc": {"FCC": 3.61}, "radius": 1.28, "mass": 63.55,
+           "rho": 8960, "m": 0.063546, "bulkE": 3.49},
+    "Ni": {"lc": {"FCC": 3.52}, "radius": 1.25, "mass": 58.69,
+           "rho": 8908, "m": 0.058693, "bulkE": 4.44},
+    "Ag": {"lc": {"FCC": 4.09}, "radius": 1.44, "mass": 107.87,
+           "rho": 10490, "m": 0.107868, "bulkE": 2.95},
+}
+
+DIAMETER_LIST = [10, 15, 20]  # NP diameters of interest (Angstrom)
+SHAPE_LIST = ["OT", "SP", "IC", "CU", "DH", "TH", "RD", "TO", "CO"]  # Shapes of interest
+BNP_DISTRIB_LIST = ["L10", "RAL", "RCS"]  # BNP distributions of interest
+TNP_DISTRIB_LIST = [
+    "L10R", "CS", "CL10S", "CRALS", "RRAL", "CSRAL", "CSL10", "CRSR", "LL10"
+]  # TNP distributions of interest
+RATIO_LIST = [20, 40]  # Ratios of interest
+CUSTOM_SHAPES = {}  # User-defined custom shapes
+
+
+def update_constants(config):
+    """Update global constants from a dictionary.
+
+    Args:
+        config: Dictionary containing constant names and their new values.
+    """
+    global VACUUM_THICKNESS, RANDOM_DISTRIB_NO
+    if "VACUUM_THICKNESS" in config:
+        VACUUM_THICKNESS = config["VACUUM_THICKNESS"]
+    if "RANDOM_DISTRIB_NO" in config:
+        RANDOM_DISTRIB_NO = config["RANDOM_DISTRIB_NO"]
+
+    # For lists and dicts, we update in-place to preserve references in other modules
+    if "ELE_DICT" in config:
+        ELE_DICT.clear()
+        ELE_DICT.update(validate_ele_dict(config["ELE_DICT"]))
+    if "DIAMETER_LIST" in config:
+        DIAMETER_LIST[:] = config["DIAMETER_LIST"]
+    if "SHAPE_LIST" in config:
+        SHAPE_LIST[:] = config["SHAPE_LIST"]
+    if "BNP_DISTRIB_LIST" in config:
+        BNP_DISTRIB_LIST[:] = config["BNP_DISTRIB_LIST"]
+    if "TNP_DISTRIB_LIST" in config:
+        TNP_DISTRIB_LIST[:] = config["TNP_DISTRIB_LIST"]
+    if "RATIO_LIST" in config:
+        RATIO_LIST[:] = config["RATIO_LIST"]
+    if "CUSTOM_SHAPES" in config:
+        CUSTOM_SHAPES.clear()
+        CUSTOM_SHAPES.update(config["CUSTOM_SHAPES"])
+
+
+def load_config(path):
+    """Load configuration from a JSON, YAML, or TOML file.
+
+    Args:
+        path: Path to the configuration file.
+
+    Returns:
+        The loaded configuration dictionary.
+    """
+    import json
+    from pathlib import Path
+
+    suffix = Path(path).suffix.lower()
+    if suffix == ".json":
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    elif suffix in (".yaml", ".yml"):
+        try:
+            import yaml
+            with open(path, "r", encoding="utf-8") as f:
+                return yaml.safe_load(f)
+        except ImportError as e:
+            raise ImportError("PyYAML is required to load YAML config files.") from e
+    elif suffix == ".toml":
+        try:
+            import tomllib  # Python 3.11+
+        except ImportError:
+            try:
+                import tomli as tomllib
+            except ImportError as e:
+                raise ImportError(
+                    "tomllib (Python 3.11+) or tomli is required to load TOML config files."
+                ) from e
+        with open(path, "rb") as f:
+            return tomllib.load(f)
+    else:
+        raise ValueError(f"Unsupported config file format: {suffix}")
+
+
+def validate_ele_dict(ele_dict):
+    """Validate a user-supplied element dictionary.
+
+    Args:
+        ele_dict: Dictionary mapping element symbols to property dicts.
+
+    Returns:
+        The validated dictionary.
+
+    Raises:
+        ValueError: If required keys are missing or invalid.
+    """
+    required_keys = {"lc", "radius", "mass"}
+    for element, props in ele_dict.items():
+        missing = required_keys - set(props.keys())
+        if missing:
+            raise ValueError(
+                f"Element '{element}' is missing required keys: {missing}"
+            )
+        if "FCC" not in props.get("lc", {}):
+            raise ValueError(
+                f"Element '{element}' must have lattice constant 'lc' with an 'FCC' entry"
+            )
+    return ele_dict
+
+
+def load_ele_dict_from_file(path):
+    """Load an element dictionary from a JSON file.
+
+    Args:
+        path: Path to a JSON file containing the element dictionary.
+
+    Returns:
+        Validated element dictionary.
+    """
+    import json
+
+    with open(path, "r", encoding="utf-8") as f:
+        ele_dict = json.load(f)
+    return validate_ele_dict(ele_dict)
+
+
+def dist_1d(coord1, coord2, dim):
+    """Compute distance between 2 points in one of their real space coordinates."""
+    return round(np.sqrt(np.sum((coord2[dim] - coord1[dim]) ** 2)), 3)
+
+
+def dist_3d(coord1, coord2):
+    """Compute real space distance between 2 points."""
+    return round(np.sqrt(np.sum((coord2 - coord1) ** 2)), 3)
+
+
+def calc_rcs_prob(obj, shape):
+    """Compute the core-shell probability for each atom in *obj*.
+
+    Returns a list where higher values correspond to surface-like positions.
+
+    Args:
+        obj: ASE Atoms object.
+        shape: Nanoparticle shape string (e.g. 'IC', 'DH', 'OT').
+
+    Returns:
+        List of probabilities, one per atom.
+    """
+    prob_list = []
+    if shape == 'IC':
+        mass_center = obj.get_center_of_mass()
+        radius = (obj.cell[0][0] - VACUUM_THICKNESS) / 2
+        for atom in obj:
+            prob_list.append(dist_3d(mass_center, atom.position) / radius)
+    else:
+        x_slices = {round(atom.position[0], 3) for atom in obj}
+        y_slices = {round(atom.position[1], 3) for atom in obj}
+        z_slices = {round(atom.position[2], 3) for atom in obj}
+
+        z_thread = {(x, y): {'max': 0, 'min': 0, 'mid': []} for x in x_slices for y in y_slices}
+        x_thread = {(y, z): {'max': 0, 'min': 0, 'mid': []} for y in y_slices for z in z_slices}
+        y_thread = {(z, x): {'max': 0, 'min': 0, 'mid': []} for z in z_slices for x in x_slices}
+        for atom in obj:
+            x, y, z = round(atom.position[0], 3), round(atom.position[1], 3), round(atom.position[2], 3)
+            z_thread[(x, y)]['mid'].append(z)
+            x_thread[(y, z)]['mid'].append(x)
+            y_thread[(z, x)]['mid'].append(y)
+        for d in (z_thread, x_thread, y_thread):
+            empty = [k for k, v in d.items() if len(v['mid']) == 0]
+            for k in empty:
+                del d[k]
+            for k, v in d.items():
+                v['max'] = max(v['mid'])
+                v['min'] = min(v['mid'])
+                v['mid'] = (v['max'] + v['min']) / 2
+
+        for atom in obj:
+            x, y, z = round(atom.position[0], 3), round(atom.position[1], 3), round(atom.position[2], 3)
+            z_half = (z_thread[(x, y)]['max'] - z_thread[(x, y)]['min']) / 2
+            x_half = (x_thread[(y, z)]['max'] - x_thread[(y, z)]['min']) / 2
+            y_half = (y_thread[(z, x)]['max'] - y_thread[(z, x)]['min']) / 2
+            z_rel = abs(z - z_thread[(x, y)]['mid']) / z_half if round(z_half, 3) != 0.0 else abs(z - z_thread[(x, y)]['mid'])
+            x_rel = abs(x - x_thread[(y, z)]['mid']) / x_half if round(x_half, 3) != 0.0 else abs(x - x_thread[(y, z)]['mid'])
+            y_rel = abs(y - y_thread[(z, x)]['mid']) / y_half if round(y_half, 3) != 0.0 else abs(y - y_thread[(z, x)]['mid'])
+            if shape == 'DH':
+                prob = 1.0 if (round(z_rel, 3) == 1.0) or (round(z_half, 3) == 0.0) else z_rel
+            else:
+                if (round(z_rel, 3) == 1.0) or (round(x_rel, 3) == 1.0) or (round(y_rel, 3) == 1.0) or (round(z_half, 3) == 0.0) or (round(x_half, 3) == 0.0) or (round(y_half, 3) == 0.0):
+                    prob = 1.0
+                else:
+                    prob = (z_rel + x_rel + y_rel) / 3
+            prob_list.append(prob)
+    return prob_list
+
+
+def parse_ele_comb(ele_comb, ele_dict=None):
+    """Parse a concatenated element combination string into individual symbols.
+
+    Args:
+        ele_comb: String like 'AuPtPd' or 'CuAgAu'.
+        ele_dict: Optional element dictionary to use for matching. If None,
+            the built-in ELE_DICT is used.
+
+    Returns:
+        List of element symbols, e.g. ['Au', 'Pt', 'Pd'].
+
+    Raises:
+        ValueError: If the string cannot be parsed.
+    """
+    if ele_dict is None:
+        ele_dict = ELE_DICT
+    symbols = sorted(ele_dict.keys(), key=len, reverse=True)
+    elements = []
+    i = 0
+    while i < len(ele_comb):
+        matched = False
+        for sym in symbols:
+            if ele_comb[i:].startswith(sym):
+                elements.append(sym)
+                i += len(sym)
+                matched = True
+                break
+        if not matched:
+            raise ValueError(
+                f"Could not parse element combination '{ele_comb}' at position {i}. "
+                f"Known symbols: {list(ele_dict.keys())}"
+            )
+    return elements

allomorph/init_struct/__init__.py

@@ -0,0 +1,45 @@
+"""Initial nanoparticle structure generation."""
+
+from allomorph.constants import (
+    BNP_DIR,
+    BNP_DISTRIB_LIST,
+    DIAMETER_LIST,
+    ELE_DICT,
+    GOLDEN_RATIO,
+    LMP_DATA_DIR,
+    MNP_DIR,
+    RANDOM_DISTRIB_NO,
+    RATIO_LIST,
+    SHAPE_LIST,
+    TNP_DIR,
+    TNP_DISTRIB_LIST,
+    VACUUM_THICKNESS,
+)
+from allomorph.init_struct.gen_bnp_al import gen_bnp, write_bnp
+from allomorph.init_struct.gen_bnp_cs import gen_hard_core_shell, write_hard_core_shell
+from allomorph.init_struct.gen_mnp import gen_mnp, write_mnp
+from allomorph.init_struct.gen_tnp_al import gen_tnp, write_tnp
+
+__all__ = [
+    "LMP_DATA_DIR",
+    "MNP_DIR",
+    "BNP_DIR",
+    "TNP_DIR",
+    "GOLDEN_RATIO",
+    "VACUUM_THICKNESS",
+    "RANDOM_DISTRIB_NO",
+    "ELE_DICT",
+    "DIAMETER_LIST",
+    "SHAPE_LIST",
+    "BNP_DISTRIB_LIST",
+    "TNP_DISTRIB_LIST",
+    "RATIO_LIST",
+    "gen_mnp",
+    "write_mnp",
+    "gen_bnp",
+    "write_bnp",
+    "gen_tnp",
+    "write_tnp",
+    "gen_hard_core_shell",
+    "write_hard_core_shell",
+]

allomorph/init_struct/gen_bnp_al.py

@@ -0,0 +1,165 @@
+# Goal: Generate initial alloy BNP structures for MD simulations
+# Author: Jonathan Yik Chang Ting
+# Date: 22/10/2020
+"""
+Note:
+- Abbreviations:
+    - RAL = randomly distributed alloy
+    - RCS = randomly distributed core-shell-like alloy
+    - (R)L10 = L1_0 intermetallic alloy (with/without random component)
+    - (R)L12 = L1_2 intermetallic alloy (with/without random component)
+- To do:
+    - FCC is currently being hard-coded for lattice constant retrieval, might need to be flexible
+    - Perhaps could add a parameter to control core thickness
+"""
+
+from multiprocessing import Pool
+from pathlib import Path
+
+import numpy as np
+from ase.io.lammpsdata import read_lammps_data, write_lammps_data
+from ase.visualize import view
+from numpy.random import RandomState
+
+from allomorph.constants import (
+    BNP_DIR,
+    BNP_DISTRIB_LIST,
+    DIAMETER_LIST,
+    ELE_DICT,
+    LMP_DATA_DIR,
+    MNP_DIR,
+    RANDOM_DISTRIB_NO,
+    RATIO_LIST,
+    SHAPE_LIST,
+    VACUUM_THICKNESS,
+    calc_rcs_prob,
+)
+
+
+def rand_conv(obj, element1, element2, ele2Ratio, rseed, prob):
+    """Randomly convert elements of atoms until specified ratio is reached"""
+    ele1Arr, ele2Arr = obj.symbols.search(element1), obj.symbols.search(element2)
+    ele2IdealNum = round(ele2Ratio / 100 * len(obj))
+    diff = len(ele2Arr) - ele2IdealNum
+    (convEleArr, targetEle) = (ele1Arr, element2) if diff < 0 else (ele2Arr, element1)
+    randGen = RandomState(rseed)
+    probArr = None
+    if len(prob) > 0:
+        weights = np.array(prob)[convEleArr]
+        total_weight = weights.sum()
+        if total_weight > 0:
+            probArr = weights / total_weight
+    idxArr = randGen.choice(a=convEleArr, size=abs(diff), replace=False, p=probArr)
+    for idx in idxArr:
+        obj[idx].symbol = targetEle
+    return obj
+
+
+def gen_bnp(obj, element1, element2, shape, ratio2, distrib, rseed, ele_dict=None):
+    """Generates a BNP alloy structure based on specified distribution type."""
+    if ele_dict is None:
+        ele_dict = ELE_DICT
+    probList = []
+    if distrib == 'RAL':
+        # Handled by rand_conv if 'R' in distrib
+        pass
+
+    elif distrib == 'RCS':
+        probList = calc_rcs_prob(obj, shape)
+        # Handled by rand_conv if 'R' in distrib
+
+    elif distrib in ['L10', 'L12', 'RL10', 'RL12']:
+        lc = ele_dict[element1]['lc']['FCC']
+        vacOffset = VACUUM_THICKNESS / 2
+        for (i, atom) in enumerate(obj):
+            yModulo = round((round(obj.positions[i][1], 3) - vacOffset) % lc, 3)
+            if (yModulo == 0.0) | (yModulo == lc):
+                atom.symbol = element2
+            if distrib == 'L12':
+                xModulo = round((round(obj.positions[i][0], 3) - vacOffset) % lc, 3)
+                if (xModulo == 0.0) | (xModulo == lc):
+                    atom.symbol = element2
+
+    else:
+        raise Exception('Specified distribution type unrecognised!')
+
+    if 'R' in distrib:
+        obj = rand_conv(obj=obj, element1=element1, element2=element2, ele2Ratio=ratio2, rseed=rseed, prob=probList)
+    return obj
+
+
+def write_bnp(element1, element2, diameter, shape, ratio2, distrib, replace=False, vis=False, ele_dict=None):
+    """Generates and writes a specific BNP alloy structure."""
+    if ele_dict is None:
+        ele_dict = ELE_DICT
+    output_base_dir = Path(LMP_DATA_DIR) / BNP_DIR
+    mnp_dir = Path(LMP_DATA_DIR) / MNP_DIR
+
+    file_name_mnp = f"{element1}{diameter}{shape}.lmp"
+    mnp_path = mnp_dir / file_name_mnp
+
+    if not mnp_path.exists():
+        # print(f"      MNP file {mnp_path} not found, skipping...")
+        return
+
+    mnp = read_lammps_data(str(mnp_path), atom_style='atomic', units='metal')
+    mnp.set_chemical_symbols(symbols=[element1] * len(mnp))
+    ratio1 = 100 - ratio2
+
+    distrib_dir = output_base_dir / distrib
+    distrib_dir.mkdir(parents=True, exist_ok=True)
+
+    for rep in range(RANDOM_DISTRIB_NO):
+        if 'R' not in distrib:
+            r1, r2, rep_suffix = 50, 50, ''
+        else:
+            r1, r2, rep_suffix = ratio1, ratio2, str(rep)
+
+        file_name_bnp = f"{element1}{element2}{diameter}{shape}{r1}{r2}{distrib}{rep_suffix}.lmp"
+        output_path = distrib_dir / file_name_bnp
+
+        if not replace and output_path.exists():
+            continue
+
+        bnp = gen_bnp(obj=mnp.copy(), element1=element1, element2=element2, shape=shape, ratio2=ratio2, distrib=distrib, rseed=rep if 'R' in distrib else 0, ele_dict=ele_dict)
+        write_lammps_data(str(output_path), atoms=bnp, units='metal', atom_style='atomic')
+        print(f"      Generated {file_name_bnp}, formula: {bnp.get_chemical_formula()}")
+
+        if vis:
+            view(bnp, block=True)
+        if 'R' not in distrib:
+            break
+
+
+def main(replace=False, vis=False, ele_dict=None):
+    """Main entry point for BNP generation."""
+    if ele_dict is None:
+        ele_dict = ELE_DICT
+    print('Generating BNP alloys:')
+
+    work_items = []
+    for diameter in DIAMETER_LIST:
+        for element in ele_dict:
+            for element2 in ele_dict:
+                if element == element2:
+                    continue
+                for shape in SHAPE_LIST:
+                    for ratio2 in RATIO_LIST:
+                        for distrib in BNP_DISTRIB_LIST:
+                            work_items.append((element, element2, diameter, shape, ratio2, distrib, replace, vis, ele_dict))
+
+    # Run in parallel unless visualization is requested
+    if vis:
+        print("  Visualization enabled: running serially...")
+        for item in work_items:
+            write_bnp(*item)
+    elif len(work_items) > 1:
+        with Pool() as p:
+            p.starmap(write_bnp, work_items)
+    elif work_items:
+        write_bnp(*work_items[0])
+
+
+if __name__ == '__main__':
+    main(replace=False, vis=False)
+    print('ALL DONE!')