diff --git a/AutoREACTER.py b/AutoREACTER.py
new file mode 100644
index 0000000..71b24ef
--- /dev/null
+++ b/AutoREACTER.py
@@ -0,0 +1,300 @@
+import shutil
+import sys
+import os
+import json
+from pathlib import Path
+import time
+
+from PIL import Image
+
+from AutoREACTER.initialization import Initialization
+from AutoREACTER.input_parser import InputParser
+from AutoREACTER.cache import GetCacheDir, RunDirectoryManager, RetentionCleanup
+from AutoREACTER.detectors.functional_groups_detector import FunctionalGroupsDetector
+from AutoREACTER.detectors.reaction_detector import ReactionDetector
+from AutoREACTER.detectors.non_monomer_detector import NonReactantsDetector
+from AutoREACTER.reaction_preparation.reaction_processor.prepare_reactions import PrepareReactions
+from AutoREACTER.reaction_preparation.lunar_client.molecule_3d_preparation import Molecule3DPreparation
+from AutoREACTER.reaction_preparation.lunar_client.lunar_api_wrapper import LunarAPIWrapper
+from AutoREACTER.reaction_preparation.lunar_client.REACTER_files_builder import REACTERFilesBuilder
+
+def _move_image(src: Path, dest: Path) -> None:
+    """
+    Move image files from source to a dedicated 'images' subdirectory in the destination.
+    
+    Creates the images directory if it doesn't exist and moves all PNG/JPG files.
+    
+    Args:
+        src: Source directory containing images
+        dest: Destination run directory
+    """
+    images_dir = dest / "images"
+    images_dir.mkdir(parents=True, exist_ok=True)
+
+    for p in src.iterdir():
+        if p.is_file() and p.suffix.lower() in [".png", ".jpg", ".jpeg"]:
+            try:
+                shutil.move(str(p), str(images_dir))
+                print(f"[OK] Moved image: {p.name} → {images_dir}")
+            except Exception as e:
+                print(f"[ERROR] Failed to move image {p.name}: {e}")
+
+
+def loading_message(message, duration=3, interval=0.5):
+    print(f"[INFO] {message}", end="", flush=True)
+    steps = int(duration / interval)
+
+    for _ in range(steps):
+        print(".", end="", flush=True)
+        time.sleep(interval)
+
+    print()  # newline
+
+
+def save_image(img: Image.Image, path: str, label: str = "Image") -> None:
+    """
+    Save a PIL Image to the specified path with error handling and user feedback.
+    
+    Args:
+        img: PIL Image object to save
+        path: Destination file path
+        label: Human-readable label for logging messages
+    """
+    if img is None:
+        print(f"[WARN] {label}: Image is None, skipping save.")
+        return
+
+    try:
+        if hasattr(img, "save"):
+            img.save(path)
+            print(f"[OK] {label} saved → {path}\n")
+        else:
+            print(f"[ERROR] {label}: Object has no .save() method")
+    except Exception as e:
+        print(f"[ERROR] Failed to save {label} to {path}: {e}")
+
+def run_cleanup(mode: str = "skip") -> None:
+    """Run cache cleanup based on the specified mode."""
+    cache_manager = GetCacheDir()
+    cleanup = RetentionCleanup(cache_manager.cache_base_dir)
+    cleanup.run(mode=mode)
+
+def help_message() -> None:
+    print("Usage:")
+    print("  python AutoREACTER.py -i <input.json>")
+    print("  python AutoREACTER.py -c <days|all|skip>")
+    print()
+    print("Options:")
+    print("  -i, --input        Input JSON file")
+    print("  -c, --cleanup      Cleanup cache")
+    print()
+    print("Cleanup modes:")
+    print("  <days>   → delete runs older than given number of days (e.g., 7, 30)")
+    print("  all      → delete all cached runs")
+    print("  skip     → no cleanup")
+
+def AutoREACTER(input_file: str) -> None:
+    """
+    Main workflow orchestrator for the AutoREACTER pipeline.
+    
+    This function coordinates the entire automated reaction discovery and preparation
+    workflow for polymer chemistry, including:
+      - Input validation and visualization
+      - Functional group detection
+      - Reaction discovery and selection
+      - Non-monomer (additive) detection
+      - 3D geometry preparation
+      - Integration with the Lunar API
+      - Generation of REACTER input files
+    
+    Args:
+        input_file: Path to a JSON file containing monomer definitions and parameters.
+    
+    The function creates a dated output directory, generates multiple diagnostic images,
+    and guides the user through an interactive review step before proceeding with
+    computationally intensive 3D preparation and simulation file generation.
+    """
+    # Initialize the AutoREACTER environment and logging
+    Initialization()
+
+    # Parse and validate user input
+    input_parser = InputParser()
+    cache_manager = GetCacheDir()
+    cache_dir = cache_manager.staging_dir
+
+    # Set up run-specific output directory
+    run_manager = RunDirectoryManager(cache_manager.cache_base_dir)
+    output_dir = run_manager.make_dated_run_dir()
+
+    print(f"[INFO] Staging directory: {cache_dir}")
+
+    # Create directory for storing visualization images
+    images_dir = cache_dir / "images"
+    os.makedirs(images_dir, exist_ok=True)
+
+    # Load and validate input data
+    with open(input_file, "r") as f:
+        input_data = json.load(f)
+
+    validated_inputs = input_parser.validate_inputs(input_data)
+
+    # Generate and save initial monomers visualization
+    try:
+        img = input_parser.initial_molecules_image_grid(validated_inputs)
+        save_image(img, os.path.join(images_dir, "monomers.png"), "Monomers Grid")
+    except Exception:
+        print("[WARN] Failed to generate initial molecules image grid")
+
+    # === Functional Group Detection ===
+    fg_detector = FunctionalGroupsDetector()
+    functional_groups, functional_groups_imgs = fg_detector.functional_groups_detector(
+        validated_inputs.monomers
+    )
+
+    try:
+        img = fg_detector.functional_group_highlighted_molecules_image_grid(functional_groups_imgs)
+        save_image(img, os.path.join(images_dir, "functional_groups.png"), "Functional Groups")
+    except Exception:
+        pass
+
+    # === Reaction Discovery ===
+    reaction_detector = ReactionDetector()
+    reaction_instances = reaction_detector.reaction_detector(functional_groups)
+
+    try:
+        img = reaction_detector.available_reaction_image_grid(reaction_instances)
+        save_image(img, os.path.join(images_dir, "reactions.png"), "Available Reactions")
+    except Exception:
+        pass
+
+    selected_reactions = reaction_detector.reaction_selection(reaction_instances)
+
+    # === Non-monomer (Additive) Detection ===
+    non_monomer_detector = NonReactantsDetector()
+    non_reactants = non_monomer_detector.non_monomer_detector(
+        validated_inputs, selected_reactions
+    )
+
+    try:
+        img = non_monomer_detector.non_reactants_to_visualization(non_reactants)
+        save_image(img, os.path.join(images_dir, "non_reactants.png"), "Non-Reactants")
+    except Exception:
+        pass
+
+    updated_inputs = non_monomer_detector.non_reactant_selection(
+        validated_inputs, non_reactants
+    )
+
+    # === Reaction Template Preparation ===
+    prepare_reactions = PrepareReactions(cache_dir)
+    prepared_reactions = prepare_reactions.prepare_reactions(selected_reactions)
+
+    try:
+        for highlight_type, filename in [
+            (None, "templates_all.png"),
+            ("edge", "templates_edge.png"),
+            ("initiators", "templates_initiators.png"),
+            ("delete", "templates_delete.png")
+        ]:
+            img = prepare_reactions.reaction_templates_highlighted_image_grid(
+                prepared_reactions, highlight_type=highlight_type
+            )
+            save_image(img, os.path.join(images_dir, filename))
+    except Exception:
+        print("[WARN] Failed to generate one or more reaction template visualizations")
+
+    print(
+        f"\n[INFO] Reaction preparation completed.\n"
+        f"All generated images have been saved in the {images_dir} directory.\n"
+        f"Please review the reaction templates before proceeding.\n"
+    )
+
+    # Interactive user confirmation
+    ok_pass = input("Type 'ok' to continue: ").strip().lower()
+    if ok_pass != "ok":
+        print("[EXIT] Workflow stopped by user.")
+        sys.exit(0)
+
+    # === 3D Geometry Preparation ===
+    molecule_3d = Molecule3DPreparation(cache_dir)
+    updated_inputs_3d, prepared_reactions_3d = molecule_3d.prepare_molecule_3d_geometry(
+        updated_inputs, prepared_reactions
+    )
+
+    # === Lunar API Workflow ===
+    lunar_api = LunarAPIWrapper(cache_dir)
+    lunar_results = lunar_api.lunar_workflow(
+        updated_inputs_3d, prepared_reactions_3d
+    )
+
+    print("\n")
+    loading_message("Lunar API workflow completed. Proceeding to build REACTER files")
+    time.sleep(1.5)
+    print("\n")
+
+    # === Build final REACTER files ===
+    builder = REACTERFilesBuilder(
+        cache_dir=cache_dir,
+        updated_inputs_with_3d_mols=updated_inputs_3d
+    )
+
+    reacter_files = builder.molecule_template_preparation(
+        lunar_files=lunar_results,
+        prepared_reactions_with_3d_mols=prepared_reactions_3d
+    )
+
+    # Move final files to output directory
+    reacter_files = run_manager.move_reacter_files(
+        reacter_files,
+        staging_dir=cache_dir,
+        final_dir=output_dir
+    )
+
+    _move_image(images_dir, output_dir)
+
+    print("\n[INFO] AutoREACTER workflow completed successfully.\n")
+    print(f"Final REACTER files are located in: {output_dir}")
+
+
+if __name__ == "__main__":
+    args = sys.argv[1:]
+
+    if not args:
+        help_message()
+        sys.exit(1)
+
+    # INPUT MODE 
+    if "-i" in args or "--input" in args:
+        if "-i" in args:
+            idx = args.index("-i")
+        else:
+            idx = args.index("--input")
+
+        if idx + 1 >= len(args):
+            print("Error: Missing input file.")
+            sys.exit(1)
+
+        input_file = args[idx + 1]
+
+        if not os.path.isfile(input_file):
+            print(f"Error: Input file '{input_file}' does not exist.")
+            sys.exit(1)
+
+        AutoREACTER(input_file)
+
+    # CLEANUP MODE 
+    elif "-c" in args or "--cleanup" in args:
+        if "-c" in args:
+            idx = args.index("-c")
+        else:
+            idx = args.index("--cleanup")
+
+        if idx + 1 >= len(args):
+            print("Error: Missing cleanup mode.")
+            sys.exit(1)
+
+        mode = args[idx + 1]
+        run_cleanup(mode)
+
+    else:
+        help_message()
\ No newline at end of file
diff --git a/AutoREACTER/cache.py b/AutoREACTER/cache.py
index 9d44987..a95d7f1 100644
--- a/AutoREACTER/cache.py
+++ b/AutoREACTER/cache.py
@@ -1,301 +1,266 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-import datetime as dt
-import logging
+from pathlib import Path
 import os
+import re
 import shutil
 import subprocess
-from pathlib import Path
-from typing import Literal
-from venv import logger
-
-logger = logging.getLogger(__name__)
+import datetime as dt
+from AutoREACTER.reaction_preparation.lunar_client.REACTER_files_builder import REACTERFiles
 
-@dataclass(slots=True)
 class GetCacheDir:
-    """Repocontext provides methods to get paths relative to the git repository root, such as cache directories."""
+    """
+    Manages the base cache directory for the AutoREACTER workflow.
+    
+    This class determines the root of the git repository (or falls back to a
+    path relative to the script) and creates a standardized cache directory
+    structure with a staging area.
+    """
 
-    # Note: For simplicity, this implementation does not actually change the working directory.
-    # Instead, it provides methods to get paths relative to the repo root. This avoids issues
-    # with changing the global working directory in a multi-threaded or complex application.
+    def __init__(self):
+        """Initialize cache directory structure."""
+        self.git_root = self.get_git_root()
+        self.cache_base_dir = self.git_root / "cache"
+        self.cache_base_dir.mkdir(parents=True, exist_ok=True)
 
-    @staticmethod
-    def get_git_root() -> Path:
+        # Staging directory for temporary files before moving to dated run folders
+        self.staging_dir = self.cache_base_dir / "00_cache"
+        os.makedirs(self.staging_dir, exist_ok=True)
+
+    def get_git_root(self) -> Path:
         """
-        Return the root directory of the current git repo.
-        Raises subprocess.CalledProcessError if not in a git repo.
+        Return the root directory of the current git repository.
+        
+        Falls back to a path derived from this script's location if git
+        command fails (e.g., when running outside a git repository).
+        
+        Returns:
+            Path: Root directory path
         """
-        out = subprocess.check_output(["git", "rev-parse", "--show-toplevel"], text=True).strip()
-        if not out:
+        try:
+            out = subprocess.check_output(
+                ["git", "rev-parse", "--show-toplevel"],
+                text=True
+            ).strip()
+            return Path(out)
+        except Exception:
             script_dir = Path(__file__).resolve().parent
-            out = script_dir.parent.parent.parent  # Fallback: <git_root>/src/reaction_lammps_mupt/cache.py
-            logger.warning(f"Warning: 'git rev-parse' returned empty. Falling back to {out} as git root based on script location.")
-        return Path(out)
         
-    @property
-    def cache_base_dir(self) -> Path:
-        """
-        <git_root>/cache (created if missing)
-        """
-        base = self.get_git_root() / "cache"
-        base.mkdir(parents=True, exist_ok=True)
-        return base
-    
-    @property
-    def staging_dir(self) -> Path:
-        """
-        <git_root>/cache/00_cache (created if missing)
+            for parent in [script_dir] + list(script_dir.parents):
+                if (parent / ".git").exists() or (parent / "pyproject.toml").exists():
+                    return parent
+        
+            return script_dir.parent
 
-        NOTE: This does NOT auto-delete files. Call clear_staging_dir() explicitly.
-        """
-        d = self.cache_base_dir / "00_cache"
-        shutil.rmtree(d, ignore_errors=True)
-        os.makedirs(d, exist_ok=True)
-        return d
 
-@dataclass(slots=True, frozen=True)
 class RunDirectoryManager:
     """
-    Creates dated run folders and copies artifacts into an existing run folder.
-
-    Key behavior:
-    - You create a run folder ONCE (make_dated_run_dir).
-    - You can copy into that same run folder unlimited times (copy_into_run).
-    - Copy semantics are REPLACE:
-        * files overwrite
-        * directories are deleted then copied fresh
-        * symlinks are replaced
+    Handles creation and management of dated run directories for simulations.
+    
+    Organizes output into a structure like: cache/YYYY-MM-DD/1/, cache/YYYY-MM-DD/2/, etc.
+    Provides utilities for moving files and updating REACTER file references.
     """
 
-    @staticmethod
-    def make_dated_run_dir(
-        base_dir: Path,
-        *,
-        date: dt.date | None = None,
-        chdir_to: Literal["run", "date", "none"] = "none",
-    ) -> Path:
+    def __init__(self, base_dir: Path):
+        """
+        Initialize with a base directory for storing run folders.
+        
+        Args:
+            base_dir: Base path where dated run directories will be created
         """
-        Create:
-            base_dir/YYYY-MM-DD/<N>/
+        self.base_dir = Path(base_dir)
+        self.base_dir.mkdir(parents=True, exist_ok=True)
 
-        Where <N> is the next integer run folder (1, 2, 3, ...).
+    def _is_empty(self, path: Path) -> bool:
+        """Check if a directory contains no files or subdirectories."""
+        return not any(path.iterdir())
 
-        chdir_to:
-          - "run":  chdir into the new run folder
-          - "date": chdir into the date folder
-          - "none": do not change cwd
+    def make_dated_run_dir(self) -> Path:
         """
-        base_dir = Path(base_dir)
-        base_dir.mkdir(parents=True, exist_ok=True)
-
-        target_date = date or dt.date.today()
-        date_dir = base_dir / target_date.isoformat()
+        Create and return a dated run directory following the pattern: {base}/{today}/{run_number}.
+        
+        Reuses the latest run directory if it is empty. Otherwise, increments the run number.
+        
+        Returns:
+            Path: Path to the final run directory
+        """
+        today = dt.date.today().isoformat()
+        date_dir = self.base_dir / today
         date_dir.mkdir(parents=True, exist_ok=True)
 
-        max_run_number = 0
-        for p in date_dir.iterdir():
-            if p.is_dir() and p.name.isdigit():
-                max_run_number = max(max_run_number, int(p.name))
+        # Find existing run numbers (directories named with integers)
+        existing_runs = [
+            int(p.name) for p in date_dir.iterdir()
+            if p.is_dir() and p.name.isdigit()
+        ]
 
-        next_run_number = max_run_number + 1
-        while True:
-            run_dir = date_dir / str(next_run_number)
-            try:
-                run_dir.mkdir()
-                break
-            except FileExistsError:
-                next_run_number += 1
+        if existing_runs:
+            latest_run = date_dir / str(max(existing_runs))
+            if self._is_empty(latest_run):
+                print(f"[INFO] Final directory: {latest_run}")
+                return latest_run
 
-        if chdir_to == "run":
-            os.chdir(run_dir)
-        elif chdir_to == "date":
-            os.chdir(date_dir)
+        # Create new run directory with incremented number
+        run_number = max(existing_runs, default=0) + 1
+        run_dir = date_dir / str(run_number)
+        run_dir.mkdir()
 
+        print(f"[INFO] Final directory: {run_dir}")
         return run_dir
 
-    @staticmethod
-    def _remove_path(path: Path) -> None:
-        """Remove file/dir/symlink at path if it exists."""
-        if not path.exists() and not path.is_symlink():
-            return
-
-        # symlink must be checked before is_dir() in some cases
-        if path.is_symlink():
-            path.unlink()
-            return
-
-        if path.is_file():
+    def remove_path(self, path: Path) -> None:
+        """
+        Remove a file, symlink, or directory recursively.
+        
+        Args:
+            path: Path to remove
+        """
+        if path.is_symlink() or path.is_file():
             path.unlink()
-            return
-
-        if path.is_dir():
+        elif path.is_dir():
             shutil.rmtree(path)
-            return
 
-        # Fallback for odd filesystem types
-        try:
-            path.unlink()
-        except Exception:
-            shutil.rmtree(path, ignore_errors=True)
-
-    @staticmethod
-    def copy_into_run(
-        source_dir: Path,
-        dest_run_dir: Path,
-        *,
-        overwrite: bool = True,
-        preserve_symlinks: bool = True,
-        preserve_metadata: bool = True,
-    ) -> Path:
+    def move_into_run(self, source_dir: Path, dest_dir: Path) -> Path:
         """
-        Copy everything from source_dir into an EXISTING dest_run_dir.
+        Move all contents from source_dir into dest_dir, overwriting if necessary.
+        
+        Args:
+            source_dir: Directory containing files to move
+            dest_dir: Destination run directory
+            
+        Returns:
+            Path: The destination directory
+        """
+        for item in source_dir.iterdir():
+            target = dest_dir / item.name
 
-        overwrite=True means:
-          - if target exists, it is deleted first (dirs removed entirely),
-            then copied fresh.
+            if target.exists():
+                self.remove_path(target)
 
-        Returns dest_run_dir for convenience.
+            shutil.move(str(item), str(target))
+
+        print(f"[OK] Moved files → {dest_dir}")
+        return dest_dir
+
+    def move_reacter_files(
+        self, 
+        reacter_files: REACTERFiles, 
+        staging_dir: Path, 
+        final_dir: Path
+    ) -> REACTERFiles:
         """
-        source_dir = Path(source_dir)
-        dest_run_dir = Path(dest_run_dir)
+        Move REACTER-related files from staging area into the final run directory
+        and update all internal Path references in the REACTERFiles object.
+        
+        Args:
+            reacter_files: REACTERFiles object containing various file paths
+            staging_dir: Current staging directory (usually .../00_cache)
+            final_dir: Target run directory
+            
+        Returns:
+            REACTERFiles: Updated object with remapped paths
+            
+        Raises:
+            FileNotFoundError: If the expected REACTER files directory doesn't exist
+        """
+        old_base = staging_dir / "lunar" / "REACTER_files"
 
-        if not source_dir.is_dir():
-            raise NotADirectoryError(f"source_dir is not a directory: {source_dir}")
+        if not old_base.exists():
+            raise FileNotFoundError(f"REACTER files not found: {old_base}")
 
-        dest_run_dir.mkdir(parents=True, exist_ok=True)
+        new_base = self.move_into_run(old_base, final_dir)
 
-        for item in source_dir.iterdir():
-            target = dest_run_dir / item.name
-
-            if overwrite and (target.exists() or target.is_symlink()):
-                RunDirectoryManager._remove_path(target)
-
-            if item.is_symlink():
-                if not preserve_symlinks:
-                    # If you don't want symlinks, copy the linked contents instead
-                    resolved = item.resolve()
-                    if resolved.is_dir():
-                        shutil.copytree(resolved, target)
-                    else:
-                        shutil.copy2(resolved, target) if preserve_metadata else shutil.copy(resolved, target)
-                else:
-                    target.symlink_to(item.readlink())
-
-            elif item.is_file():
-                if preserve_metadata:
-                    shutil.copy2(item, target)
-                else:
-                    shutil.copy(item, target)
-
-            elif item.is_dir():
-                # copytree requires target not exist (we already removed it if overwrite)
-                shutil.copytree(
-                    item,
-                    target,
-                    symlinks=preserve_symlinks,
-                    copy_function=shutil.copy2 if preserve_metadata else shutil.copy,
-                )
-
-            else:
-                # Ignore special files (sockets, devices, etc.)
-                # If you want, raise here instead.
-                continue
+        def remap(p: Path) -> Path:
+            """Remap a path from old_base to new_base while preserving relative structure."""
+            try:
+                return new_base / p.relative_to(old_base)
+            except ValueError:
+                return p
+
+        # Update all file references to point to the new location
+        reacter_files.force_field_data = remap(reacter_files.force_field_data)
+        reacter_files.in_file = remap(reacter_files.in_file)
+
+        for mol in reacter_files.molecule_files:
+            mol.molecule_files.lmp_molecule_file = remap(
+                mol.molecule_files.lmp_molecule_file
+            )
+
+        for tpl in reacter_files.template_files:
+            tpl.map_file = remap(tpl.map_file)
+            tpl.pre_reaction_file.lmp_molecule_file = remap(
+                tpl.pre_reaction_file.lmp_molecule_file
+            )
+            tpl.post_reaction_file.lmp_molecule_file = remap(
+                tpl.post_reaction_file.lmp_molecule_file
+            )
+
+        print(f"[OK] REACTER files moved → {new_base}")
+        return reacter_files
 
-        return dest_run_dir
 
-@dataclass(slots=True)
 class RetentionCleanup:
-    @staticmethod
-    def run(base_dir: Path | None = None) -> None:
+    """
+    Provides interactive cleanup functionality for old cache directories.
+    
+    Allows users to delete simulation run folders older than a chosen retention
+    period (1 week, 1 month, 3 months) or delete everything.
+    """
+
+    def __init__(self, base_dir: Path):
+        """
+        Initialize cleanup manager with target base directory.
+        
+        Args:
+            base_dir: Cache base directory to clean up
         """
-        Interactive cleanup of dated cache folders under base_dir (default: <git_root>/cache).
+        self.base_dir = Path(base_dir)
 
-        Deletes folders whose names match YYYY-MM-DD and are older than chosen retention.
+    def run(self, mode="skip"):
         """
-        base_dir = Path(base_dir) if base_dir is not None else ()
-
-        print(
-            f"\nNOTE: Cached files are stored in {base_dir}, organized by date. "
-            "You can clear old folders here to save space."
-        )
-
-        while True:
-            choice = input(
-                "\nDo you want to clear old files?\n"
-                "1. 1 week\n"
-                "2. 1 month\n"
-                "3. 3 months\n"
-                "4. 6 months\n"
-                "5. Custom (enter number of days)\n"
-                "6. Delete ALL cache folders\n"
-                "7. No cleanup\n"
-                "Enter choice (1-7): "
-            ).strip()
-            if choice in {"1", "2", "3", "4", "5", "6", "7"}:
-                break
-            print("Invalid choice. Please enter a number between 1 and 7.")
-
-        retention_map: dict[str, dt.timedelta | str | None] = {
-            "1": dt.timedelta(weeks=1),
-            "2": dt.timedelta(days=30),
-            "3": dt.timedelta(days=90),
-            "4": dt.timedelta(days=180),
-            "5": "custom",
-            "6": "all",
-            "7": None,
-        }
-        retention = retention_map[choice]
-
-        if retention is None:
-            print("Skipping cleanup.")
+        Run the cleanup process based on the specified mode.
+        Modes are:
+            - "skip": Do not perform any cleanup
+            - "all": Delete all dated run directories
+            - int (number of days): Delete directories older than this many days
+        Args:
+            mode: Cleanup mode - "skip", int(number of days), or "all"
+        Returns:
+            None
+        """
+        print(f"\n[INFO] Cache directory: {self.base_dir}")
+
+        if mode == "skip":
+            print("[INFO] Cache cleanup skipped.")
+            return
+
+        pattern = re.compile(r"\d{4}-\d{2}-\d{2}")
+        protected = {"00_cache"}
+        
+        if mode == "all":
+            for folder in self.base_dir.iterdir():
+                if (
+                    folder.is_dir()
+                    and folder.name not in protected
+                    and pattern.match(folder.name)
+                ):
+                    shutil.rmtree(folder)
+
+        try:
+            days = int(mode)
+        except Exception:
+            print(f"[WARN] Invalid cleanup mode: {mode}")
             return
 
-        if retention == "custom":
-            while True:
-                try:
-                    days = int(input("Enter number of days to retain: ").strip())
-                    if days < 0:
-                        print("Days must be >= 0.")
-                        continue
-                    retention = dt.timedelta(days=days)
-                    break
-                except ValueError:
-                    print("Invalid number. Please enter an integer.")
-
-        today = dt.date.today()
-
-        for folder in base_dir.iterdir():
-            if not folder.is_dir():
+        cutoff = dt.date.today() - dt.timedelta(days=days)
+
+        for folder in self.base_dir.iterdir():
+            if not folder.is_dir() or folder.name == "00_cache":
                 continue
 
-            # Only operate on folders named like YYYY-MM-DD
             try:
                 folder_date = dt.datetime.strptime(folder.name, "%Y-%m-%d").date()
             except ValueError:
                 continue
 
-            should_delete = (retention == "all") or (today - folder_date > retention)
-            if should_delete:
+            if folder_date < cutoff:
                 shutil.rmtree(folder)
-                print(f"Deleted old folder: {folder}")
-
-
-
-if __name__ == "__main__":
-    # Staging cache directory where your code dumps temporary outputs
-    get_cache_dir = GetCacheDir()
-    cache_dir = get_cache_dir.staging_dir
-    print(f"Default cache directory: {cache_dir}")
-    dated_cache_dir = RunDirectoryManager.make_dated_run_dir(get_cache_dir.cache_base_dir, chdir_to="none")
-    print(f"Created dated run directory: {dated_cache_dir}")
-
-    # # Example: create some test files in staging
-    for i in range(5):
-        (cache_dir / f"test_file_{i}.txt").write_text(f"This is test file {i}\n")
-    run_dir = RunDirectoryManager.copy_into_run(cache_dir, dated_cache_dir)
-    print(f"Created run directory: {run_dir}")
-
-    RetentionCleanup.run(get_cache_dir.cache_base_dir)
-
-
+                print(f"[OK] Deleted: {folder}")
diff --git a/AutoREACTER/input_parser.py b/AutoREACTER/input_parser.py
index a7072c9..48415e5 100644
--- a/AutoREACTER/input_parser.py
+++ b/AutoREACTER/input_parser.py
@@ -161,7 +161,11 @@ def validate_inputs(self, inputs: dict) -> SimulationSetup:
         validated_replicas = self._validate_replicas(
             replicas_dict, composition_method
         )
-
+        self._validate_system_monomer_keys(
+            inputs, 
+            validated_replicas["systems"], 
+            composition_method
+        )
         monomers = self._validate_monomer_entry(
             inputs,
             composition_method,
@@ -274,26 +278,21 @@ def _validate_temperature(self, temp: Any) -> list[float]:
         Accepts a single number or a list of numbers. Ensures all values are positive.
 
         Args:
-            temp: Temperature input (int, float, or list).
-
+            temp: Temperature input (int or float).
+            
         Returns:
-            A list of float temperature values.
+            A float temperature value.
 
         Raises:
             NumericFieldError: If the format is invalid or values are non-positive.
         """
-        if isinstance(temp, (int, float)):
-            temp_list = [temp]
-        elif isinstance(temp, list) and all(isinstance(t, (int, float)) for t in temp):
-            temp_list = temp
-        else:
-            raise NumericFieldError(f"'temperature' must be a number or a list of numbers. Got: {temp!r}")
-        
-        for t in temp_list:
-            if t <= 0:
-                raise NumericFieldError(f"Temperature values must be positive. Got: {t!r}")
-        
-        return temp_list
+        if not isinstance(temp, (int, float)):
+            raise NumericFieldError(f"'temperature' must be a number. Got: {temp!r}")
+
+        if temp <= 0:
+            raise NumericFieldError(f"Temperature values must be positive. Got: {temp!r}")
+
+        return float(temp)
 
     def _validate_density(self, density: Any) -> float:
         """
@@ -308,24 +307,19 @@ def _validate_density(self, density: Any) -> float:
         Raises:
             NumericFieldError: If density is not a positive number.
         """
-        if isinstance(density, (int, float)):
-            density_list = [float(density)]
+        if not isinstance(density, (int, float)):
+            raise NumericFieldError(
+                f"'density' must be a number. Got: {density!r}"
+            )
 
-        elif isinstance(density, list) and all(isinstance(d, (int, float)) for d in density):
-            density_list = [float(d) for d in density]
+        density_value = float(density)
 
-        else:
+        if density_value <= 0:
             raise NumericFieldError(
-                f"'density' must be a number or list of numbers. Got: {density!r}"
+                f"Density values must be positive. Got: {density!r}"
             )
 
-        for d in density_list:
-            if d <= 0:
-                raise NumericFieldError(
-                    f"Density values must be positive. Got: {d!r}"
-                )
-
-        return density_list
+        return density_value
     
     def _validate_force_field(self, force_field: Any) -> str:
         """
@@ -418,6 +412,51 @@ def _validate_composition(
 
         return composition_dict
     
+    def _validate_system_monomer_keys(self, inputs: dict, systems: list[dict], method: str) -> None:
+        """Ensures that monomer keys in each system match the defined monomers in the inputs.
+            This method checks that the monomer names used in the 'monomer_counts' or 'monomer_ratios' fields of each system
+            correspond to the monomer names defined in the top-level 'monomers' list. It raises errors if there are
+            missing or extra monomer keys in any system compared to the defined monomers.
+        Args:
+            inputs: The raw input dictionary containing the 'monomers' list.
+            systems: List of system dictionaries from the replicas section.
+            method: The composition method ("counts" or "stoichiometric_ratio").
+        Raises:
+            InputSchemaError: If there are missing or extra monomer keys in any system compared to the defined monomers.
+        """
+        
+        monomers = inputs.get("monomers", [])
+        allowed_names = set()
+
+        for monomer in monomers:
+            name = monomer.get("name")
+            if not isinstance(name, str) or not name.strip():
+                raise InputSchemaError("Each monomer must include a non-empty 'name'.")
+            allowed_names.add(name)
+
+        for system in systems:
+            tag = system["tag"]
+
+            if method == "counts":
+                field_name = "monomer_counts"
+            else:
+                field_name = "monomer_ratios"
+
+            provided_names = set(system.get(field_name, {}).keys())
+
+            extra = provided_names - allowed_names
+            missing = allowed_names - provided_names
+
+            if extra:
+                raise InputSchemaError(
+                    f"System '{tag}' has unknown monomer(s) in '{field_name}': {sorted(extra)}"
+                )
+
+            if missing:
+                raise InputSchemaError(
+                    f"System '{tag}' is missing monomer(s) in '{field_name}': {sorted(missing)}"
+                )
+        
     
     def _validate_monomer_entry(self, 
                                 inputs: dict, 
@@ -642,13 +681,15 @@ def _validate_replicas(self, replicas_dict: dict, method: CompositionMethodType)
             Normalized replicas dictionary.
         """
 
-        temperatures = self._validate_temperature(
-            replicas_dict.get("temperatures")
-        )
+        if "temperatures" in replicas_dict:
+            raise InputSchemaError(
+                "'replicas.temperatures' is no longer supported. Define 'temperature' inside each system."
+            )
 
-        density = self._validate_density(
-            replicas_dict.get("density")
-        )
+        if "density" in replicas_dict:
+            raise InputSchemaError(
+                "'replicas.density' is no longer supported. Define 'density' inside each system."
+            )
 
         systems = replicas_dict.get("systems")
 
@@ -658,6 +699,8 @@ def _validate_replicas(self, replicas_dict: dict, method: CompositionMethodType)
             )
 
         seen_tags: set[str] = set()
+        temperatures: list[float] = []
+        density: list[float] = []
 
         # used for ratio consistency check
         reference_ratios: dict | None = None
@@ -683,6 +726,16 @@ def _validate_replicas(self, replicas_dict: dict, method: CompositionMethodType)
 
             seen_tags.add(tag)
 
+            system["temperature"] = self._validate_temperature(
+                system.get("temperature")
+            )
+            system["density"] = self._validate_density(
+                system.get("density")
+            )
+
+            temperatures.append(system["temperature"])
+            density.append(system["density"])
+
             # -------- ratio mode --------
             if method == "stoichiometric_ratio":
 
@@ -753,12 +806,12 @@ def _validate_replicas(self, replicas_dict: dict, method: CompositionMethodType)
         "simulation_name": "Example_Count_Mode",
 
         "replicas": {
-            "temperatures": [300, 400, 500],
-            "density": 0.8,
             "method": "counts",
             "systems": [
                 {
                     "tag": "10k",
+                    "temperature": 300,
+                    "density": 0.8,
                     "monomer_counts": {
                         "tmc": 220,
                         "mpd": 220,
@@ -767,6 +820,8 @@ def _validate_replicas(self, replicas_dict: dict, method: CompositionMethodType)
                 },
                 {
                     "tag": "100k",
+                    "temperature": 400,
+                    "density": 0.8,
                     "monomer_counts": {
                         "tmc": 2200,
                         "mpd": 2200,
@@ -798,14 +853,14 @@ def _validate_replicas(self, replicas_dict: dict, method: CompositionMethodType)
         "simulation_name": "Example_Ratio_Mode",
 
         "replicas": {
-            "temperatures": [300, 400],
-            "density": [0.8],
             "method": "ratio",
 
             "systems": [
 
                 {
                     "tag": "10k_base",
+                    "temperature": 300,
+                    "density": 0.8,
                     "total_atoms": 10000,
 
                     "monomer_ratios": {
@@ -817,6 +872,8 @@ def _validate_replicas(self, replicas_dict: dict, method: CompositionMethodType)
 
                 {
                     "tag": "100k_base",
+                    "temperature": 400,
+                    "density": 0.8,
                     "total_atoms": 100000,
 
                     "monomer_ratios": {
@@ -850,15 +907,15 @@ def _validate_replicas(self, replicas_dict: dict, method: CompositionMethodType)
     }
     input_ff = {
         "simulation_name": "Example_Count_Mode",
-
+        "force_field": "PCFF",
         "replicas": {
-            "temperatures": [300, 400, 500],
-            "density": 0.8,
             "method": "counts",
 
             "systems": [
             {
                 "tag": "10k",
+                "temperature": 300,
+                "density": 0.8,
                 "monomer_counts": {
                 "tmc": 220,
                 "mpd": 220,
@@ -867,6 +924,8 @@ def _validate_replicas(self, replicas_dict: dict, method: CompositionMethodType)
             },
             {
                 "tag": "100k",
+                "temperature": 400,
+                "density": 0.8,
                 "monomer_counts": {
                 "tmc": 2200,
                 "mpd": 2200,
@@ -875,9 +934,6 @@ def _validate_replicas(self, replicas_dict: dict, method: CompositionMethodType)
             }
             ]
         },
-
-        "force_field": "PCFF",
-
         "monomers": [
             {
             "name": "tmc",
@@ -902,5 +958,3 @@ def _validate_replicas(self, replicas_dict: dict, method: CompositionMethodType)
 
     print("\nValidating Force Field Input:")
     print(parser.validate_inputs(input_ff))
-
-
diff --git a/AutoREACTER/main.py b/AutoREACTER/main.py
deleted file mode 100644
index cb296de..0000000
--- a/AutoREACTER/main.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import json
-from pathlib import Path
-from initialization import Initialization
-from input_parser import InputParser
-from cache import GetCacheDir, RunDirectoryManager, RetentionCleanup
-from detectors.detector import Detector
-
-"""
-Main script for initializing the reaction LAMMPS MUPT pipeline.
-"""
-Initialization()
-get_cache_dir = GetCacheDir()
-cache_dir = get_cache_dir.staging_dir
-print(f"Base cache directory: {cache_dir}")
-dated_cache_dir = RunDirectoryManager.make_dated_run_dir(get_cache_dir.cache_base_dir, chdir_to="none")
-print(f"Staging directory created at: {dated_cache_dir}")
-
-# optional use
-"""
-TODO: Use this in CMD line interface and in the future when we want to support both ways
-    of running the code (with a json file or with cmd line arguments)"""
-
-# RunDirectoryManager.copy_into_run(cache_dir, dated_cache_dir)
-
-
-
-if __name__ == "__main__":
-    current_dir = Path(__file__).resolve().parents[2]  # same as parent.parent.parent, but clearer
-    input_file = Path( current_dir / "examples" / "example_1_inputs.json")
-
-    # Read and validate inputs
-    with input_file.open("r", encoding="utf-8") as f:
-        inputs = json.load(f)
-
-    # modify this to a cmd line argument later and to support this way as well
-    parser = InputParser()
-    validated_inputs = parser.validate_inputs(inputs)
-    print(validated_inputs)
-    # RetentionCleanup.run(GetCacheDir().cache_base_dir)  # Optional: Clean up old cache files based on retention policy.
-    detector = Detector(inputs)
-    detected_reactions = detector.reactions_dict
-    non_monomers = detector.non_reactants_list
-    RunDirectoryManager.copy_into_run(cache_dir, dated_cache_dir)
\ No newline at end of file
diff --git a/AutoREACTER/sim_setup/system_property_calculations.py b/AutoREACTER/sim_setup/system_property_calculations.py
new file mode 100644
index 0000000..3325d1d
--- /dev/null
+++ b/AutoREACTER/sim_setup/system_property_calculations.py
@@ -0,0 +1,29 @@
+from AutoREACTER.input_parser import SimulationSetup
+
+
+class SystemPropertyCalculations:
+    def __init__(self):
+        pass
+
+    def calculate_properties(self):
+        # Placeholder for property calculations
+        # Implement actual calculations based on the system's structure and composition
+        properties = {
+            "density": self.calculate_density(),
+            "glass_transition_temperature": self.calculate_glass_transition_temperature(),
+            "molecular_weight": self.calculate_molecular_weight(),
+            # Add more properties as needed
+        }
+        return properties
+
+    def calculate_density(self):
+        # Implement density calculation logic
+        return 1.0  # Placeholder value
+
+    def calculate_glass_transition_temperature(self):
+        # Implement glass transition temperature calculation logic
+        return 100.0  # Placeholder value
+
+    def calculate_molecular_weight(self):
+        # Implement molecular weight calculation logic
+        return 50000.0  # Placeholder value
diff --git a/AutoREACTER/system_property_calculations.py b/AutoREACTER/system_property_calculations.py
deleted file mode 100644
index f3b0d32..0000000
--- a/AutoREACTER/system_property_calculations.py
+++ /dev/null
@@ -1 +0,0 @@
-""""""
diff --git a/examples/example_1.ipynb b/examples/example_1.ipynb
index 0dbff92..7091916 100644
--- a/examples/example_1.ipynb
+++ b/examples/example_1.ipynb
@@ -7,62 +7,42 @@
    "source": [
     "### Initialization and Environment Setup\n",
     "\n",
-    "This cell initializes the AutoREACTER environment and prepares the working directory for the current run.\n",
-    "\n",
-    "- `Initialization()` sets up the AutoREACTER runtime environment.\n",
-    "- `InputParser()` prepares the parser for validating and normalizing user input files.\n",
-    "- `GetCacheDir()` retrieves the staging cache directory used for intermediate data.\n",
-    "- `RunDirectoryManager.make_dated_run_dir()` creates a timestamped run directory to store outputs for this session."
+    "This cell initializes the AutoREACTER environment and prepares the working directory for the current run."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "2dccf25a",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "All required modules are successfully imported.\n",
-      "                                                                                                                                                                                                                                                       \n",
-      "      .o.                       .                  ooooooooo.   oooooooooooo       .o.         .oooooo.   ooooooooooooo oooooooooooo ooooooooo.   \n",
-      "     .888.                    .o8                  `888   `Y88. `888'     `8      .888.       d8P'  `Y8b  8'   888   `8 `888'     `8 `888   `Y88. \n",
-      "    .8\"888.     oooo  oooo  .o888oo  .ooooo.        888   .d88'  888             .8\"888.     888               888       888          888   .d88' \n",
-      "   .8' `888.    `888  `888    888   d88' `88b       888ooo88P'   888oooo8       .8' `888.    888               888       888oooo8     888ooo88P'  \n",
-      "  .88ooo8888.    888   888    888   888   888       888`88b.     888    \"      .88ooo8888.   888               888       888    \"     888`88b.    \n",
-      " .8'     `888.   888   888    888 . 888   888       888  `88b.   888       o  .8'     `888.  `88b    ooo       888       888       o  888  `88b.  \n",
-      "o88o     o8888o  `V88V\"V8P'   \"888\" `Y8bod8P'      o888o  o888o o888ooooood8 o88o     o8888o  `Y8bood8P'      o888o     o888ooooood8 o888o  o888o \n",
-      "\n",
-      "AutoREACTER version: v0.2-beta.0\n",
-      "Cache directory: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from AutoREACTER.initialization import Initialization\n",
     "from AutoREACTER.input_parser import InputParser\n",
-    "from AutoREACTER.cache import GetCacheDir, RunDirectoryManager, RetentionCleanup\n",
+    "from AutoREACTER.cache import GetCacheDir, RunDirectoryManager\n",
     "from AutoREACTER.detectors.functional_groups_detector import FunctionalGroupsDetector\n",
     "from AutoREACTER.detectors.reaction_detector import ReactionDetector\n",
     "from AutoREACTER.detectors.non_monomer_detector import NonReactantsDetector\n",
     "from AutoREACTER.reaction_preparation.reaction_processor.prepare_reactions import PrepareReactions\n",
     "from AutoREACTER.reaction_preparation.lunar_client.molecule_3d_preparation import Molecule3DPreparation\n",
     "from AutoREACTER.reaction_preparation.lunar_client.lunar_api_wrapper import LunarAPIWrapper\n",
-    "from rdkit import Chem\n",
-    "from rdkit.Chem import Draw\n",
+    "from AutoREACTER.reaction_preparation.lunar_client.REACTER_files_builder import REACTERFilesBuilder\n",
+    "\n",
     "import json\n",
     "\n",
+    "\n",
     "Initialization()\n",
+    "\n",
     "input_parser = InputParser()\n",
-    "cache_dir = GetCacheDir().staging_dir\n",
-    "dated_cache_dir = RunDirectoryManager.make_dated_run_dir(cache_dir, chdir_to=\"none\")\n",
-    "# #future use\n",
-    "# RunDirectoryManager.copy_into_run(cache_dir, dated_cache_dir)\n",
-    "print(f\"Cache directory: {cache_dir}\")\n",
     "\n",
-    "\n"
+    "cache_manager = GetCacheDir()\n",
+    "cache_dir = cache_manager.staging_dir\n",
+    "\n",
+    "run_manager = RunDirectoryManager(cache_manager.cache_base_dir)\n",
+    "output_dir = run_manager.make_dated_run_dir()\n",
+    "\n",
+    "print(f\"[INFO] Staging directory: {cache_dir}\")\n",
+    "print(f\"[INFO] Final output directory: {output_dir}\")"
    ]
   },
   {
@@ -77,15 +57,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "67a1b385",
    "metadata": {},
    "outputs": [],
    "source": [
+    "# Clean up cached data from the AutoREACTER cache directory.\n",
+    "# Useful for freeing disk space or resetting the cache state.\n",
     "\n",
-    "# `RetentionCleanup.run()` removes cached directories from the AutoREACTER cache base directory.\n",
-    "#  Useful for freeing disk space or resetting the cache state.\n",
-    "\n",
+    "# from AutoREACTER.cache import RetentionCleanup\n",
     "# RetentionCleanup.run(GetCacheDir().cache_base_dir)"
    ]
   },
@@ -102,15 +82,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "32ab0cba",
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
-    "# validate_inputs() checks the schema and normalizes the data.\n",
-    "# molecule_representation_of_initial_molecules() extracts RDKit molecule objects.\n",
-    "# Draw.MolsToGridImage() displays the monomers in a grid with their labels.\n",
+    "# Load input data and validate structure.\n",
+    "# The validation step normalizes inputs and prepares molecular representations.\n",
     "\n",
     "with open(\"example_1_inputs_count_mode.json\", \"r\") as f:\n",
     "    input_data = json.load(f)\n",
@@ -128,56 +106,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "63c6e279",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
+    "# Generate and display the initial monomer structures.\n",
+    "\n",
     "initial_molecules = input_parser.initial_molecules_image_grid(validated_inputs)\n",
     "initial_molecules"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "d6595d1e",
-   "metadata": {},
-   "source": [
-    "### Cache Directory Information\n",
-    "\n",
-    "This cell prints the default AutoREACTER cache directory."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "3bcaf515",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Default cache directory: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache\n"
-     ]
-    }
-   ],
-   "source": [
-    "default_cache_dir = GetCacheDir().cache_base_dir\n",
-    "print(f\"Default cache directory: {default_cache_dir}\")"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "65725a29",
@@ -190,30 +129,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "04b6e642",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "O=C(Cl)c1c(Cl)c(C(=O)Cl)c(Br)c(C(=O)Cl)c1Cl has functionality: di_carboxylic_acid_halide\n",
-      "Nc1cccc(N)c1 has functionality: di_amine\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# FunctionalGroupsDetector() initializes the detector.\n",
-    "# functional_groups_detector() analyzes the validated monomers.\n",
-    "# It identifies functional groups present in each molecule and generates corresponding visualization images.\n",
+    "# Detect functional groups to get valid monomers\n",
     "\n",
-    "# Run the detector only after the inputs have been validated, as it consumes validated_inputs.monomers to execute the detection workflow.\n",
     "functional_groups_detector = FunctionalGroupsDetector()\n",
-    "functional_groups, functional_groups_imgs = \\\n",
+    "\n",
+    "functional_groups, functional_groups_imgs = (\n",
     "    functional_groups_detector.functional_groups_detector(\n",
     "        validated_inputs.monomers\n",
-    "    )"
+    "    )\n",
+    ")"
    ]
   },
   {
@@ -228,28 +157,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "id": "e295e3b3",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# molecules_to_visualization() highlights the functional groups identified in the previous step.\n",
     "# The resulting image shows each molecule with the detected functional groups marked.\n",
     "\n",
     "img = functional_groups_detector.functional_group_highlighted_molecules_image_grid(functional_groups_imgs)\n",
-    "img\n"
+    "img"
    ]
   },
   {
@@ -264,18 +180,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "76817cd8",
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
-    "# ReactionDetector() initializes the reaction detection module.\n",
-    "# reaction_detector() analyzes the detected functional groups and generates possible reaction instances.\n",
-    "# create_reaction_image_grid() visualizes the detected reactions in a grid format.\n",
+    "# Detect possible reactions based on identified functional groups.\n",
     "\n",
     "reaction_detector = ReactionDetector()\n",
-    "reaction_instances = reaction_detector.reaction_detector(functional_groups)\n"
+    "reaction_instances = reaction_detector.reaction_detector(functional_groups)"
    ]
   },
   {
@@ -288,24 +201,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "id": "b443f92e",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/jpeg": "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",
-      "image/png": "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",
-      "text/plain": [
-       "<PIL.Image.Image image mode=RGB size=2080x400>"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
+    "# Visualize detected reactions.\n",
+    "\n",
     "img = reaction_detector.available_reaction_image_grid(reaction_instances)\n",
     "img"
    ]
@@ -322,43 +224,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "id": "26d581e2",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Only one reaction detected. Automatically selecting it.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# reaction_selection() processes the detected reactions.\n",
-    "# It removes user selected reactions from the list of detected reactions and returns the final set of reactions to be used for template generation.\n",
+    "# Select relevant reactions for template generation as user intened.\n",
     "\n",
     "selected_reactions = reaction_detector.reaction_selection(reaction_instances)"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "ee4e5c22",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[ReactionInstance(reaction_name='Di-Amine and Di-Carboxylic Acid Halide Polycondensation (Polyamidation)', reaction_smarts='[CX3:1](=[O:3])[Cl,Br,I:4].[N;H2,H1;!$(NC=*):2][H:5]>>[CX3:1](=[O:3])[NX3;!$(NC=*):2].[Cl,Br,I:4]([H:5])', delete_atom=True, references={'smarts': ['https://pubs.acs.org/doi/10.1021/acs.jcim.3c00329'], 'reaction_and_mechanism': ['https://pubs.acs.org/doi/10.1021/ed048pA734']}, same_reactants=False, monomer_1=MonomerRole(smiles='Nc1cccc(N)c1', name='mpd', functionalities=(FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_amine', fg_smarts_1='[N&X3;H2,H1;!$(NC=*):3]', fg_count_1=2, fg_smarts_2=None, fg_count_2=None),)), functional_group_1=FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_amine', fg_smarts_1='[N&X3;H2,H1;!$(NC=*):3]', fg_count_1=2, fg_smarts_2=None, fg_count_2=None), monomer_2=MonomerRole(smiles='O=C(Cl)c1c(Cl)c(C(=O)Cl)c(Br)c(C(=O)Cl)c1Cl', name='tmc', functionalities=(FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_carboxylic_acid_halide', fg_smarts_1='[CX3:2](=[O])[Cl,Br,I:1]', fg_count_1=3, fg_smarts_2=None, fg_count_2=None),)), functional_group_2=FunctionalGroupInfo(functionality_type='di_identical', fg_name='di_carboxylic_acid_halide', fg_smarts_1='[CX3:2](=[O])[Cl,Br,I:1]', fg_count_1=3, fg_smarts_2=None, fg_count_2=None))]\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(selected_reactions)"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "09b1cb36",
@@ -372,17 +247,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "id": "c811c031",
    "metadata": {},
    "outputs": [],
    "source": [
-    "# NonReactantsDetector() initializes the detector.\n",
-    "# non_monomer_detector() to determine which molecules are non-reactive.\n",
-    "\n",
+    "# Identify non-reactive molecules based on the selected reactions.\n",
     "\n",
     "non_monomer_detector = NonReactantsDetector()\n",
-    "non_reactants_list = non_monomer_detector.non_monomer_detector(validated_inputs, selected_reactions)\n"
+    "non_reactants_list = non_monomer_detector.non_monomer_detector(\n",
+    "    validated_inputs,\n",
+    "    selected_reactions\n",
+    ")\n"
    ]
   },
   {
@@ -390,38 +266,17 @@
    "id": "2e03f325",
    "metadata": {},
    "source": [
-    "### non_reactants_to_visualization"
+    "### Non reactants molecules visualization"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "id": "5040c430",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "ID: 3, Name: ethanol, SMILES: CCO\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# `()` grid to non reactive molecules\n",
-    "\n",
-    "# If no non-reactant molecules are detected, this stage is **automatically skipped**, and the workflow continues without generating any visualization.\n",
+    "# Visualize non-reactive molecules (if any are detected).\n",
     "\n",
     "img_non_reactants = non_monomer_detector.non_reactants_to_visualization(non_reactants_list)\n",
     "img_non_reactants"
@@ -439,3740 +294,150 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "id": "00d75b1a",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Selection Guide for Non-Reactant Monomers:\n",
-      "- N: Discard all non-reactant monomers from the simulation.\n",
-      "- A: Retain all non-reactant monomers in the simulation.\n",
-      "- S: Select specific non-reactant monomers to retain. You will be prompted \n",
-      "to enter the IDs of the monomers you wish to keep, separated by commas.\n",
-      "Example: If you want to keep monomers with IDs 1 and 3, you would enter: 1,3\n",
-      "              \n",
-      "The following monomers do not participate in any detected reactions:\n",
-      "ID: 3, Name: ethanol, SMILES: CCO\n",
-      "Only one non-reactant monomer detected\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# non_reactant_selection() removes or marks molecules that do not participate in any reactions.\n",
-    "# The resulting `updated_inputs` contains the filtered set of monomers that will be used in the next stages of the workflow.\n",
-    "# If no non-reactants were detected in the previous step, the inputs remain unchanged.\n",
+    "# Update inputs by filtering out non-reactive molecules.\n",
     "\n",
-    "updated_inputs = non_monomer_detector.non_reactant_selection(validated_inputs, non_reactants_list)"
+    "updated_inputs = non_monomer_detector.non_reactant_selection(\n",
+    "    validated_inputs,\n",
+    "    non_reactants_list\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6746d472",
+   "metadata": {},
+   "source": [
+    "### Prepare reaction templates from the selected reactions for downstream processing."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "id": "d62efe2a",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "template_indexes: {1: [1, 0, 18, 2, 26], 2: [3, 19, 27], 3: [4, 16, 20, 25], 4: [5, 6, 12, 17, 21, 28, 23, 33]}\n",
-      "Edge atoms at max distance shell: [5, 6, 12, 17, 21, 28, 23, 33]\n",
-      "template_indexes: {1: [7, 8, 18, 9, 26], 2: [6, 19, 27], 3: [4, 10, 20, 25], 4: [3, 5, 11, 12, 21, 28, 23, 33]}\n",
-      "Edge atoms at max distance shell: [3, 5, 11, 12, 21, 28, 23, 33]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "prepare_reactions = PrepareReactions(cache_dir)\n",
     "prepared_reactions = prepare_reactions.prepare_reactions(selected_reactions)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "1b031c97",
+   "metadata": {},
+   "source": [
+    "### Reaction Template Visualization\n",
+    "\n",
+    "Visualize reaction templates with different highlighting options.\n",
+    "\n",
+    "- **Default** or **template**: Highlights all structural changes in the reaction templates  \n",
+    "- **edge**: Highlights edge atoms of the templates  \n",
+    "- **delete**: Highlights removed components (if applicable)  \n",
+    "- **initiators**: Highlights reaction initiator atoms  "
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "id": "a7c134e5",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# You can select different highlight types to visualize different aspects of the reactions, by highlight tag\n",
-    "# such as \"edge\" for egde atoms of the templates,\n",
-    "# \"delete\" for removed components (optional based on the reaction), \n",
-    "# or \"initiators\" for reaction initiator atoms. \n",
-    "# By default, it highlights all changes in the reaction templates.\n",
-    "img = prepare_reactions.reaction_templates_highlighted_image_grid(prepared_reactions, \"delete\")\n",
+    "img = prepare_reactions.reaction_templates_highlighted_image_grid(prepared_reactions)\n",
     "img"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "30207664",
+   "metadata": {},
+   "source": [
+    "### 3D Geometry Preparation\n",
+    "\n",
+    "Prepare 3D molecular geometries for both inputs molecules and reaction templates.  \n",
+    "This step generates the structures required for the Lunar atom typing."
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "id": "6603c504",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Saving optimized tmc to /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/molecules_3Dmol/tmc.mol\n",
-      "Saving optimized mpd to /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/molecules_3Dmol/mpd.mol\n",
-      "Saving optimized ethanol to /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/molecules_3Dmol/ethanol.mol\n",
-      "Saving optimized pre1 to /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/full_templates_3Dmol/pre1.mol\n",
-      "MMFF optimization failed for post1.\n",
-      "Saving optimized post1 to /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/full_templates_3Dmol/post1.mol\n",
-      "Saving optimized pre5 to /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/full_templates_3Dmol/pre5.mol\n",
-      "MMFF optimization failed for post5.\n",
-      "Saving optimized post5 to /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/full_templates_3Dmol/post5.mol\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "\n",
     "molecule3dpreparation = Molecule3DPreparation(cache_dir)\n",
-    "updated_inputs_with_3d_mols, prepared_reactions_with_3d_mols = molecule3dpreparation.prepare_molecule_3d_geometry(updated_inputs, prepared_reactions)\n",
     "\n",
-    "        "
+    "updated_inputs_with_3d_mols, prepared_reactions_with_3d_mols = (\n",
+    "    molecule3dpreparation.prepare_molecule_3d_geometry(\n",
+    "        updated_inputs,\n",
+    "        prepared_reactions\n",
+    "    )\n",
+    ")  "
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "c6a74035",
+   "cell_type": "markdown",
+   "id": "be30857a",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Using saved LUNAR root directory: /mnt/c/Users/Janitha/Documents/GitHub/LUNAR\n",
-      "\n",
-      "        █████       █████  █████ ██████   █████   █████████   ███████████  \n",
-      "        ░░███       ░░███  ░░███ ░░██████ ░░███   ███░░░░░███ ░░███░░░░░███ \n",
-      "        ░███        ░███   ░███  ░███░███ ░███  ░███    ░███  ░███    ░███ \n",
-      "        ░███        ░███   ░███  ░███░░███░███  ░███████████  ░██████████  \n",
-      "        ░███        ░███   ░███  ░███ ░░██████  ░███░░░░░███  ░███░░░░░███ \n",
-      "        ░███      █ ░███   ░███  ░███  ░░█████  ░███    ░███  ░███    ░███ \n",
-      "        ███████████ ░░████████   █████  ░░█████ █████   █████ █████   █████\n",
-      "        ░░░░░░░░░░░   ░░░░░░░░   ░░░░░    ░░░░░ ░░░░░   ░░░░░ ░░░░░   ░░░░░ \n",
-      "        \n",
-      "Loading LUNAR API Wrapper Initialization\\\n",
-      "Ready!\n",
-      "\n",
-      "\n",
-      "Command line run option override checks (will warn if command line run option is used but not all options are provided at the command line):\n",
-      "WARNING override option   -bond              not provided at the command line. Hard coded input being enforced: n.u.\n",
-      "WARNING override option   -newfile           not provided at the command line. Hard coded input being enforced: :_typed\n",
-      "WARNING override option   -reset-charges     not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -vdw-scale         not provided at the command line. Hard coded input being enforced: 1.1\n",
-      "WARNING override option   -pdb               not provided at the command line. Hard coded input being enforced: skip\n",
-      "WARNING override option   -charge-file       not provided at the command line. Hard coded input being enforced: frc_files/Gasteiger_parameters.txt\n",
-      "WARNING override option   -nta-comments      not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -boundary          not provided at the command line. Hard coded input being enforced: p p p\n",
-      "WARNING override option   -bond-reset        not provided at the command line. Hard coded input being enforced: False\n",
-      "\n",
-      "\n",
-      "Command line run option override inputs confirmation (will confirm to user that the command line override does override the hard coded inputs):\n",
-      "Override confirmation for -topo              Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/molecules_3Dmol/tmc.mol\n",
-      "Override confirmation for -dir               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing\n",
-      "Override confirmation for -ff                Hard codeded input is being overridden with this input: PCFF\n",
-      "Override confirmation for -del-method        Hard codeded input is being overridden with this input: mass\n",
-      "Override confirmation for -del-crit          Hard codeded input is being overridden with this input: 0.0\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Running atom_typing: v1.11 / 14 April 2025\n",
-      "Using Python version: 3.13.12 | packaged by conda-forge | (main, Feb  5 2026, 05:53:46) [GCC 14.3.0]\n",
-      "Using Python executable: /home/janitha/miniconda3/envs/autoRX/bin/python\n",
-      "Assigning PCFF atom-types\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/molecules_3Dmol/tmc.mol chemdraw .mol or .sdf file\n",
-      "Finding molecules ...\n",
-      "Finding rings ...\n",
-      "Finding fused-ring clusters ...\n",
-      "Finding atoms hybridization ...\n",
-      "\n",
-      "\n",
-      "Elements found in system:\n",
-      "- Br\n",
-      "- C\n",
-      "- Cl\n",
-      "- O\n",
-      "\n",
-      "\n",
-      "Total system mass: 413.151\n",
-      "--------------------------------------------Cluster Analysis-------------------------------------\n",
-      "  molID     Molecule Size          Mass              %Mass           %Size      Molecule Formula\n",
-      "-------------------------------------------------------------------------------------------------\n",
-      "    1              18             413.15            100.00          100.00       Br1-C9-Cl5-O3 \n",
-      "\n",
-      "\n",
-      "By-products criteria: {'method': 'mass', 'criteria': 0.0}\n",
-      "------By Products Tally------\n",
-      "Type                    Count\n",
-      "-----------------------------\n",
-      "\n",
-      "\n",
-      "----Inputs used for find_rings----\n",
-      "Walked along elements  :  ['Br', 'C', 'Cl', 'O']\n",
-      "Checked for ring sizes :  [3, 4, 5, 6, 7]\n",
-      "Total rings found      :  1\n",
-      "0 atoms along a ring seam had to be partitioned amoung the ring\n",
-      "types (To find accurate %Mass of ring type to entire system).\n",
-      "Giving preference of partionioning in this order:\n",
-      "- 6 member ring\n",
-      "- 5 member ring\n",
-      "- 7 member ring\n",
-      "- 4 member ring\n",
-      "- 3 member ring\n",
-      "- 8 member ring\n",
-      "- minimum ring size\n",
-      "*NOTE: If count of rings exists, but no atoms exist for that ring, this means the\n",
-      "atoms for that ring were partionted to other rings that the atoms belong to.*\n",
-      "\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|          Ring            |           Count           |             %Ring count            |\n",
-      "|          Type            |         of Rings          |            per all rings           |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|            6             |             1             |               100.00               |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|    Element      |     natoms      |       Mass       |      %Mass       |     %natoms     |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|       Br        |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       C         |        6        |      72.00       |      17.43       |      33.33      |\n",
-      "|       Cl        |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       O         |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|      all        |        6        |      72.00       |      17.43       |      33.33      |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "----------------------------------Ringed Clusters------------------------------------\n",
-      "Ring-Formula    Ring-Size     Ring-count    Ring-Mass-tally     natoms-tally\n",
-      "-------------------------------------------------------------------------------------\n",
-      "C6                    6              1              72.00                6\n",
-      "\n",
-      "\n",
-      "--------------------------------------------------Fused Ring Clusters-----------------------------------------------------\n",
-      "FusedID         Size         Mass        %Mass        %Size       Nrings       %Rings                   FusedRing Formula\n",
-      "--------------------------------------------------------------------------------------------------------------------------\n",
-      "Sum percent mass: 0\n",
-      "\n",
-      "\n",
-      "\n",
-      "-----------------------------Hybridization Information-------------------------------\n",
-      "     Atom-Type            natoms            Mass            %Mass           %natoms     \n",
-      "-------------------------------------------------------------------------------------\n",
-      "       all-Br               1              79.90            19.34             5.56      \n",
-      "    Terminal-Br             1              79.90            19.34             5.56      \n",
-      "       Sp2-C                9              108.00           26.14            50.00      \n",
-      "       all-C                9              108.00           26.14            50.00      \n",
-      "       all-Cl               5              177.25           42.90            27.78      \n",
-      "    Terminal-Cl             5              177.25           42.90            27.78      \n",
-      "       Sp2-O                3              48.00            11.62            16.67      \n",
-      "       all-O                3              48.00            11.62            16.67      \n",
-      "\n",
-      "\n",
-      "---------------------------------------\n",
-      "System Unit cell, volume, mass, density\n",
-      "---------------------------------------\n",
-      "lx:         7.341500  angstrom  \n",
-      "ly:         7.835700  angstrom  \n",
-      "lz:         6.408900  angstrom  \n",
-      "volume:    368.677045 angstrom^3\n",
-      "mass:      413.151000 amu       \n",
-      "density:    1.860852  g/cm^3    \n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "| Currently supported atom types (If you know your system has an atom type that is not  |\n",
-      "| listed the force field specifc typing module needs to be added onto for that type).   |\n",
-      "| If the atom type has a trailing (T) or (F) it means that atom type has flag settings  |\n",
-      "| in the force field specifc typing module and lets you know the status of those flags. |\n",
-      "| If the atom type has a trailing (Q) it means that the written datafile has the charge |\n",
-      "| set for that atom type already (Mainly for PCFF-IFF or Metal/Mineral based FFs). For  |\n",
-      "| most atom types with the trailing (Q) there will a flag in the specific atom typing   |\n",
-      "| module to turn on or off this functionality (to give a more control of the code).     |\n",
-      "|-------------------------------------   Carbon   --------------------------------------|\n",
-      "|         ct             c+             cr             c-             c5                |\n",
-      "|         cs             cp             c_0            c_1            c_2               |\n",
-      "|         cz             ci             c=             c=1            c=2               |\n",
-      "|         c3h            c3m            c4h            c4m            c_a               |\n",
-      "|         cg             coh            c1             c2             c3                |\n",
-      "|-------------------------------------  Hydrogen  --------------------------------------|\n",
-      "|         hi             hc             hw             hos            ho2               |\n",
-      "|         ho             hn2            hn             h*             hsi               |\n",
-      "|         hs             h                                                              |\n",
-      "|-------------------------------------   Oxygen   --------------------------------------|\n",
-      "|         o_1            oo             o=             o-             o*                |\n",
-      "|         oz             o_2            oc             o3e            o4e               |\n",
-      "|         op             osh            osi            oh             ob                |\n",
-      "|-------------------------------------  Nitrogen  --------------------------------------|\n",
-      "|         nt             np             n=             n=1            n=2               |\n",
-      "|         n1             n2             n_2            nn             na                |\n",
-      "|         nho            ni             npc            nh             n3n               |\n",
-      "|         n3m            n4n            n4m            n              nh+               |\n",
-      "|         n4                                                                            |\n",
-      "|-------------------------------------   Sulfer   --------------------------------------|\n",
-      "|         s'             s-             s3e            s4e            sp                |\n",
-      "|         sc             sh             s1             s              sf                |\n",
-      "|-------------------------------------  Silicone  --------------------------------------|\n",
-      "|         sio            si                                                             |\n",
-      "|-------------------------------------  Fluorine  --------------------------------------|\n",
-      "|         f                                                                             |\n",
-      "|-------------------------------------   Xenon    --------------------------------------|\n",
-      "|         xe                                                                            |\n",
-      "|-------------------------------------    Neon    --------------------------------------|\n",
-      "|         ne                                                                            |\n",
-      "|-------------------------------------  Krypton   --------------------------------------|\n",
-      "|         kr                                                                            |\n",
-      "|-------------------------------------   Helium   --------------------------------------|\n",
-      "|         he                                                                            |\n",
-      "|------------------------------------- Deuterium  --------------------------------------|\n",
-      "|         dw                                                                            |\n",
-      "|-------------------------------------  Chlorine  --------------------------------------|\n",
-      "|         cl                                                                            |\n",
-      "|-------------------------------------  Calcium   --------------------------------------|\n",
-      "|         ca                                                                            |\n",
-      "|-------------------------------------  Bromine   --------------------------------------|\n",
-      "|         br                                                                            |\n",
-      "|-------------------------------------   Argon    --------------------------------------|\n",
-      "|         ar                                                                            |\n",
-      "|-------------------------------------Phosphorous --------------------------------------|\n",
-      "|         p              p=                                                             |\n",
-      "|------------------------------------- Molybdenum --------------------------------------|\n",
-      "|         Mo                                                                            |\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "|                        Total count of supported atom types: 98                        |\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "\n",
-      "Final outcome of found atom types:\n",
-      "Total atom count                   : 18\n",
-      "Total Parameterized atom count     : 18\n",
-      "Assumed Parameterized atom count   : 0\n",
-      "Failed Parameterized atom count    : 0\n",
-      "Total Parameterized atom perentage : 100.00\n",
-      "\n",
-      "------Atom types Tally------\n",
-      "Type                   Count\n",
-      "----------------------------\n",
-      "br                         1\n",
-      "c=                         3\n",
-      "cl                         5\n",
-      "cp                         6\n",
-      "o_1                        3\n",
-      "pdb_file = skip, so skipping writing of optional .pdb file\n",
-      "\n",
-      "\n",
-      "All outputs can be found in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing directory\n",
-      "\n",
-      "\n",
-      "Normal program termination\n",
-      "\n",
-      "\n",
-      "Execution time in seconds: 0.06239724159240723\n",
-      "\n",
-      "\n",
-      "Number of WARNING(s) and ERROR(s)\n",
-      "  0 WARNING(s)\n",
-      "  0 ERROR(s)\n",
-      "\n",
-      "\n",
-      "Command line run option override checks (will warn if command line run option is used but not all options are provided at the command line):\n",
-      "WARNING override option   -bond              not provided at the command line. Hard coded input being enforced: n.u.\n",
-      "WARNING override option   -newfile           not provided at the command line. Hard coded input being enforced: :_typed\n",
-      "WARNING override option   -reset-charges     not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -vdw-scale         not provided at the command line. Hard coded input being enforced: 1.1\n",
-      "WARNING override option   -pdb               not provided at the command line. Hard coded input being enforced: skip\n",
-      "WARNING override option   -charge-file       not provided at the command line. Hard coded input being enforced: frc_files/Gasteiger_parameters.txt\n",
-      "WARNING override option   -nta-comments      not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -boundary          not provided at the command line. Hard coded input being enforced: p p p\n",
-      "WARNING override option   -bond-reset        not provided at the command line. Hard coded input being enforced: False\n",
-      "\n",
-      "\n",
-      "Command line run option override inputs confirmation (will confirm to user that the command line override does override the hard coded inputs):\n",
-      "Override confirmation for -topo              Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/molecules_3Dmol/mpd.mol\n",
-      "Override confirmation for -dir               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing\n",
-      "Override confirmation for -ff                Hard codeded input is being overridden with this input: PCFF\n",
-      "Override confirmation for -del-method        Hard codeded input is being overridden with this input: mass\n",
-      "Override confirmation for -del-crit          Hard codeded input is being overridden with this input: 0.0\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Running atom_typing: v1.11 / 14 April 2025\n",
-      "Using Python version: 3.13.12 | packaged by conda-forge | (main, Feb  5 2026, 05:53:46) [GCC 14.3.0]\n",
-      "Using Python executable: /home/janitha/miniconda3/envs/autoRX/bin/python\n",
-      "Assigning PCFF atom-types\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/molecules_3Dmol/mpd.mol chemdraw .mol or .sdf file\n",
-      "Finding molecules ...\n",
-      "Finding rings ...\n",
-      "Finding fused-ring clusters ...\n",
-      "Finding atoms hybridization ...\n",
-      "\n",
-      "\n",
-      "Elements found in system:\n",
-      "- C\n",
-      "- H\n",
-      "- N\n",
-      "\n",
-      "\n",
-      "Total system mass: 108.064\n",
-      "--------------------------------------------Cluster Analysis-------------------------------------\n",
-      "  molID     Molecule Size          Mass              %Mass           %Size      Molecule Formula\n",
-      "-------------------------------------------------------------------------------------------------\n",
-      "    1              16             108.06            100.00          100.00         C6-H8-N2    \n",
-      "\n",
-      "\n",
-      "By-products criteria: {'method': 'mass', 'criteria': 0.0}\n",
-      "------By Products Tally------\n",
-      "Type                    Count\n",
-      "-----------------------------\n",
-      "\n",
-      "\n",
-      "----Inputs used for find_rings----\n",
-      "Walked along elements  :  ['C', 'H', 'N']\n",
-      "Checked for ring sizes :  [3, 4, 5, 6, 7]\n",
-      "Total rings found      :  1\n",
-      "0 atoms along a ring seam had to be partitioned amoung the ring\n",
-      "types (To find accurate %Mass of ring type to entire system).\n",
-      "Giving preference of partionioning in this order:\n",
-      "- 6 member ring\n",
-      "- 5 member ring\n",
-      "- 7 member ring\n",
-      "- 4 member ring\n",
-      "- 3 member ring\n",
-      "- 8 member ring\n",
-      "- minimum ring size\n",
-      "*NOTE: If count of rings exists, but no atoms exist for that ring, this means the\n",
-      "atoms for that ring were partionted to other rings that the atoms belong to.*\n",
-      "\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|          Ring            |           Count           |             %Ring count            |\n",
-      "|          Type            |         of Rings          |            per all rings           |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|            6             |             1             |               100.00               |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|    Element      |     natoms      |       Mass       |      %Mass       |     %natoms     |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|       C         |        6        |      72.00       |      66.63       |      37.50      |\n",
-      "|       H         |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       N         |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|      all        |        6        |      72.00       |      66.63       |      37.50      |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "----------------------------------Ringed Clusters------------------------------------\n",
-      "Ring-Formula    Ring-Size     Ring-count    Ring-Mass-tally     natoms-tally\n",
-      "-------------------------------------------------------------------------------------\n",
-      "C6                    6              1              72.00                6\n",
-      "\n",
-      "\n",
-      "--------------------------------------------------Fused Ring Clusters-----------------------------------------------------\n",
-      "FusedID         Size         Mass        %Mass        %Size       Nrings       %Rings                   FusedRing Formula\n",
-      "--------------------------------------------------------------------------------------------------------------------------\n",
-      "Sum percent mass: 0\n",
-      "\n",
-      "\n",
-      "\n",
-      "-----------------------------Hybridization Information-------------------------------\n",
-      "     Atom-Type            natoms            Mass            %Mass           %natoms     \n",
-      "-------------------------------------------------------------------------------------\n",
-      "       Sp2-C                6              72.00            66.63            37.50      \n",
-      "       all-C                6              72.00            66.63            37.50      \n",
-      "       all-H                8               8.06             7.46            50.00      \n",
-      "       Sp3-N                2              28.00            25.91            12.50      \n",
-      "       all-N                2              28.00            25.91            12.50      \n",
-      "\n",
-      "\n",
-      "---------------------------------------\n",
-      "System Unit cell, volume, mass, density\n",
-      "---------------------------------------\n",
-      "lx:         7.384800  angstrom  \n",
-      "ly:         5.950600  angstrom  \n",
-      "lz:         2.528800  angstrom  \n",
-      "volume:    111.125564 angstrom^3\n",
-      "mass:      108.064000 amu       \n",
-      "density:    1.614790  g/cm^3    \n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "| Currently supported atom types (If you know your system has an atom type that is not  |\n",
-      "| listed the force field specifc typing module needs to be added onto for that type).   |\n",
-      "| If the atom type has a trailing (T) or (F) it means that atom type has flag settings  |\n",
-      "| in the force field specifc typing module and lets you know the status of those flags. |\n",
-      "| If the atom type has a trailing (Q) it means that the written datafile has the charge |\n",
-      "| set for that atom type already (Mainly for PCFF-IFF or Metal/Mineral based FFs). For  |\n",
-      "| most atom types with the trailing (Q) there will a flag in the specific atom typing   |\n",
-      "| module to turn on or off this functionality (to give a more control of the code).     |\n",
-      "|-------------------------------------   Carbon   --------------------------------------|\n",
-      "|         ct             c+             cr             c-             c5                |\n",
-      "|         cs             cp             c_0            c_1            c_2               |\n",
-      "|         cz             ci             c=             c=1            c=2               |\n",
-      "|         c3h            c3m            c4h            c4m            c_a               |\n",
-      "|         cg             coh            c1             c2             c3                |\n",
-      "|-------------------------------------  Hydrogen  --------------------------------------|\n",
-      "|         hi             hc             hw             hos            ho2               |\n",
-      "|         ho             hn2            hn             h*             hsi               |\n",
-      "|         hs             h                                                              |\n",
-      "|-------------------------------------   Oxygen   --------------------------------------|\n",
-      "|         o_1            oo             o=             o-             o*                |\n",
-      "|         oz             o_2            oc             o3e            o4e               |\n",
-      "|         op             osh            osi            oh             ob                |\n",
-      "|-------------------------------------  Nitrogen  --------------------------------------|\n",
-      "|         nt             np             n=             n=1            n=2               |\n",
-      "|         n1             n2             n_2            nn             na                |\n",
-      "|         nho            ni             npc            nh             n3n               |\n",
-      "|         n3m            n4n            n4m            n              nh+               |\n",
-      "|         n4                                                                            |\n",
-      "|-------------------------------------   Sulfer   --------------------------------------|\n",
-      "|         s'             s-             s3e            s4e            sp                |\n",
-      "|         sc             sh             s1             s              sf                |\n",
-      "|-------------------------------------  Silicone  --------------------------------------|\n",
-      "|         sio            si                                                             |\n",
-      "|-------------------------------------  Fluorine  --------------------------------------|\n",
-      "|         f                                                                             |\n",
-      "|-------------------------------------   Xenon    --------------------------------------|\n",
-      "|         xe                                                                            |\n",
-      "|-------------------------------------    Neon    --------------------------------------|\n",
-      "|         ne                                                                            |\n",
-      "|-------------------------------------  Krypton   --------------------------------------|\n",
-      "|         kr                                                                            |\n",
-      "|-------------------------------------   Helium   --------------------------------------|\n",
-      "|         he                                                                            |\n",
-      "|------------------------------------- Deuterium  --------------------------------------|\n",
-      "|         dw                                                                            |\n",
-      "|-------------------------------------  Chlorine  --------------------------------------|\n",
-      "|         cl                                                                            |\n",
-      "|-------------------------------------  Calcium   --------------------------------------|\n",
-      "|         ca                                                                            |\n",
-      "|-------------------------------------  Bromine   --------------------------------------|\n",
-      "|         br                                                                            |\n",
-      "|-------------------------------------   Argon    --------------------------------------|\n",
-      "|         ar                                                                            |\n",
-      "|-------------------------------------Phosphorous --------------------------------------|\n",
-      "|         p              p=                                                             |\n",
-      "|------------------------------------- Molybdenum --------------------------------------|\n",
-      "|         Mo                                                                            |\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "|                        Total count of supported atom types: 98                        |\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "\n",
-      "Final outcome of found atom types:\n",
-      "Total atom count                   : 16\n",
-      "Total Parameterized atom count     : 16\n",
-      "Assumed Parameterized atom count   : 0\n",
-      "Failed Parameterized atom count    : 0\n",
-      "Total Parameterized atom perentage : 100.00\n",
-      "\n",
-      "------Atom types Tally------\n",
-      "Type                   Count\n",
-      "----------------------------\n",
-      "cp                         6\n",
-      "hc                         4\n",
-      "hn                         4\n",
-      "nn                         2\n",
-      "pdb_file = skip, so skipping writing of optional .pdb file\n",
-      "\n",
-      "\n",
-      "All outputs can be found in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing directory\n",
-      "\n",
-      "\n",
-      "Normal program termination\n",
-      "\n",
-      "\n",
-      "Execution time in seconds: 0.0622103214263916\n",
-      "\n",
-      "\n",
-      "Number of WARNING(s) and ERROR(s)\n",
-      "  0 WARNING(s)\n",
-      "  0 ERROR(s)\n",
-      "\n",
-      "\n",
-      "Command line run option override checks (will warn if command line run option is used but not all options are provided at the command line):\n",
-      "WARNING override option   -bond              not provided at the command line. Hard coded input being enforced: n.u.\n",
-      "WARNING override option   -newfile           not provided at the command line. Hard coded input being enforced: :_typed\n",
-      "WARNING override option   -reset-charges     not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -vdw-scale         not provided at the command line. Hard coded input being enforced: 1.1\n",
-      "WARNING override option   -pdb               not provided at the command line. Hard coded input being enforced: skip\n",
-      "WARNING override option   -charge-file       not provided at the command line. Hard coded input being enforced: frc_files/Gasteiger_parameters.txt\n",
-      "WARNING override option   -nta-comments      not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -boundary          not provided at the command line. Hard coded input being enforced: p p p\n",
-      "WARNING override option   -bond-reset        not provided at the command line. Hard coded input being enforced: False\n",
-      "\n",
-      "\n",
-      "Command line run option override inputs confirmation (will confirm to user that the command line override does override the hard coded inputs):\n",
-      "Override confirmation for -topo              Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/molecules_3Dmol/ethanol.mol\n",
-      "Override confirmation for -dir               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing\n",
-      "Override confirmation for -ff                Hard codeded input is being overridden with this input: PCFF\n",
-      "Override confirmation for -del-method        Hard codeded input is being overridden with this input: mass\n",
-      "Override confirmation for -del-crit          Hard codeded input is being overridden with this input: 0.0\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Running atom_typing: v1.11 / 14 April 2025\n",
-      "Using Python version: 3.13.12 | packaged by conda-forge | (main, Feb  5 2026, 05:53:46) [GCC 14.3.0]\n",
-      "Using Python executable: /home/janitha/miniconda3/envs/autoRX/bin/python\n",
-      "Assigning PCFF atom-types\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/molecules_3Dmol/ethanol.mol chemdraw .mol or .sdf file\n",
-      "Finding molecules ...\n",
-      "Finding rings ...\n",
-      "Finding fused-ring clusters ...\n",
-      "Finding atoms hybridization ...\n",
-      "\n",
-      "\n",
-      "Elements found in system:\n",
-      "- C\n",
-      "- H\n",
-      "- O\n",
-      "\n",
-      "\n",
-      "Total system mass: 46.047\n",
-      "--------------------------------------------Cluster Analysis-------------------------------------\n",
-      "  molID     Molecule Size          Mass              %Mass           %Size      Molecule Formula\n",
-      "-------------------------------------------------------------------------------------------------\n",
-      "    1               9             46.05             100.00          100.00         C2-H6-O1    \n",
-      "\n",
-      "\n",
-      "By-products criteria: {'method': 'mass', 'criteria': 0.0}\n",
-      "------By Products Tally------\n",
-      "Type                    Count\n",
-      "-----------------------------\n",
-      "\n",
-      "\n",
-      "----Inputs used for find_rings----\n",
-      "Walked along elements  :  ['C', 'H', 'O']\n",
-      "Checked for ring sizes :  [3, 4, 5, 6, 7]\n",
-      "Total rings found      :  0\n",
-      "0 atoms along a ring seam had to be partitioned amoung the ring\n",
-      "types (To find accurate %Mass of ring type to entire system).\n",
-      "Giving preference of partionioning in this order:\n",
-      "- 6 member ring\n",
-      "- 5 member ring\n",
-      "- 7 member ring\n",
-      "- 4 member ring\n",
-      "- 3 member ring\n",
-      "- 8 member ring\n",
-      "- minimum ring size\n",
-      "*NOTE: If count of rings exists, but no atoms exist for that ring, this means the\n",
-      "atoms for that ring were partionted to other rings that the atoms belong to.*\n",
-      "\n",
-      "\n",
-      "\n",
-      "--------------------------------------------------Fused Ring Clusters-----------------------------------------------------\n",
-      "FusedID         Size         Mass        %Mass        %Size       Nrings       %Rings                   FusedRing Formula\n",
-      "--------------------------------------------------------------------------------------------------------------------------\n",
-      "Sum percent mass: 0\n",
-      "\n",
-      "\n",
-      "\n",
-      "-----------------------------Hybridization Information-------------------------------\n",
-      "     Atom-Type            natoms            Mass            %Mass           %natoms     \n",
-      "-------------------------------------------------------------------------------------\n",
-      "       Sp3-C                2              24.00            52.12            22.22      \n",
-      "       all-C                2              24.00            52.12            22.22      \n",
-      "       all-H                6               6.05            13.13            66.67      \n",
-      "       Sp3-O                1              16.00            34.74            11.11      \n",
-      "       all-O                1              16.00            34.74            11.11      \n",
-      "\n",
-      "\n",
-      "---------------------------------------\n",
-      "System Unit cell, volume, mass, density\n",
-      "---------------------------------------\n",
-      "lx:         4.073500  angstrom  \n",
-      "ly:         3.212000  angstrom  \n",
-      "lz:         2.963900  angstrom  \n",
-      "volume:    38.779911  angstrom^3\n",
-      "mass:      46.047000  amu       \n",
-      "density:    1.971713  g/cm^3    \n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "| Currently supported atom types (If you know your system has an atom type that is not  |\n",
-      "| listed the force field specifc typing module needs to be added onto for that type).   |\n",
-      "| If the atom type has a trailing (T) or (F) it means that atom type has flag settings  |\n",
-      "| in the force field specifc typing module and lets you know the status of those flags. |\n",
-      "| If the atom type has a trailing (Q) it means that the written datafile has the charge |\n",
-      "| set for that atom type already (Mainly for PCFF-IFF or Metal/Mineral based FFs). For  |\n",
-      "| most atom types with the trailing (Q) there will a flag in the specific atom typing   |\n",
-      "| module to turn on or off this functionality (to give a more control of the code).     |\n",
-      "|-------------------------------------   Carbon   --------------------------------------|\n",
-      "|         ct             c+             cr             c-             c5                |\n",
-      "|         cs             cp             c_0            c_1            c_2               |\n",
-      "|         cz             ci             c=             c=1            c=2               |\n",
-      "|         c3h            c3m            c4h            c4m            c_a               |\n",
-      "|         cg             coh            c1             c2             c3                |\n",
-      "|-------------------------------------  Hydrogen  --------------------------------------|\n",
-      "|         hi             hc             hw             hos            ho2               |\n",
-      "|         ho             hn2            hn             h*             hsi               |\n",
-      "|         hs             h                                                              |\n",
-      "|-------------------------------------   Oxygen   --------------------------------------|\n",
-      "|         o_1            oo             o=             o-             o*                |\n",
-      "|         oz             o_2            oc             o3e            o4e               |\n",
-      "|         op             osh            osi            oh             ob                |\n",
-      "|-------------------------------------  Nitrogen  --------------------------------------|\n",
-      "|         nt             np             n=             n=1            n=2               |\n",
-      "|         n1             n2             n_2            nn             na                |\n",
-      "|         nho            ni             npc            nh             n3n               |\n",
-      "|         n3m            n4n            n4m            n              nh+               |\n",
-      "|         n4                                                                            |\n",
-      "|-------------------------------------   Sulfer   --------------------------------------|\n",
-      "|         s'             s-             s3e            s4e            sp                |\n",
-      "|         sc             sh             s1             s              sf                |\n",
-      "|-------------------------------------  Silicone  --------------------------------------|\n",
-      "|         sio            si                                                             |\n",
-      "|-------------------------------------  Fluorine  --------------------------------------|\n",
-      "|         f                                                                             |\n",
-      "|-------------------------------------   Xenon    --------------------------------------|\n",
-      "|         xe                                                                            |\n",
-      "|-------------------------------------    Neon    --------------------------------------|\n",
-      "|         ne                                                                            |\n",
-      "|-------------------------------------  Krypton   --------------------------------------|\n",
-      "|         kr                                                                            |\n",
-      "|-------------------------------------   Helium   --------------------------------------|\n",
-      "|         he                                                                            |\n",
-      "|------------------------------------- Deuterium  --------------------------------------|\n",
-      "|         dw                                                                            |\n",
-      "|-------------------------------------  Chlorine  --------------------------------------|\n",
-      "|         cl                                                                            |\n",
-      "|-------------------------------------  Calcium   --------------------------------------|\n",
-      "|         ca                                                                            |\n",
-      "|-------------------------------------  Bromine   --------------------------------------|\n",
-      "|         br                                                                            |\n",
-      "|-------------------------------------   Argon    --------------------------------------|\n",
-      "|         ar                                                                            |\n",
-      "|-------------------------------------Phosphorous --------------------------------------|\n",
-      "|         p              p=                                                             |\n",
-      "|------------------------------------- Molybdenum --------------------------------------|\n",
-      "|         Mo                                                                            |\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "|                        Total count of supported atom types: 98                        |\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "\n",
-      "Final outcome of found atom types:\n",
-      "Total atom count                   : 9\n",
-      "Total Parameterized atom count     : 9\n",
-      "Assumed Parameterized atom count   : 0\n",
-      "Failed Parameterized atom count    : 0\n",
-      "Total Parameterized atom perentage : 100.00\n",
-      "\n",
-      "------Atom types Tally------\n",
-      "Type                   Count\n",
-      "----------------------------\n",
-      "c2                         1\n",
-      "c3                         1\n",
-      "hc                         5\n",
-      "ho2                        1\n",
-      "oh                         1\n",
-      "pdb_file = skip, so skipping writing of optional .pdb file\n",
-      "\n",
-      "\n",
-      "All outputs can be found in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing directory\n",
-      "\n",
-      "\n",
-      "Normal program termination\n",
-      "\n",
-      "\n",
-      "Execution time in seconds: 0.06228327751159668\n",
-      "\n",
-      "\n",
-      "Number of WARNING(s) and ERROR(s)\n",
-      "  0 WARNING(s)\n",
-      "  0 ERROR(s)\n",
-      "\n",
-      "\n",
-      "Command line run option override checks (will warn if command line run option is used but not all options are provided at the command line):\n",
-      "WARNING override option   -bond              not provided at the command line. Hard coded input being enforced: n.u.\n",
-      "WARNING override option   -newfile           not provided at the command line. Hard coded input being enforced: :_typed\n",
-      "WARNING override option   -reset-charges     not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -vdw-scale         not provided at the command line. Hard coded input being enforced: 1.1\n",
-      "WARNING override option   -pdb               not provided at the command line. Hard coded input being enforced: skip\n",
-      "WARNING override option   -charge-file       not provided at the command line. Hard coded input being enforced: frc_files/Gasteiger_parameters.txt\n",
-      "WARNING override option   -nta-comments      not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -boundary          not provided at the command line. Hard coded input being enforced: p p p\n",
-      "WARNING override option   -bond-reset        not provided at the command line. Hard coded input being enforced: False\n",
-      "\n",
-      "\n",
-      "Command line run option override inputs confirmation (will confirm to user that the command line override does override the hard coded inputs):\n",
-      "Override confirmation for -topo              Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/full_templates_3Dmol/pre1.mol\n",
-      "Override confirmation for -dir               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre1\n",
-      "Override confirmation for -ff                Hard codeded input is being overridden with this input: PCFF\n",
-      "Override confirmation for -del-method        Hard codeded input is being overridden with this input: mass\n",
-      "Override confirmation for -del-crit          Hard codeded input is being overridden with this input: 0.0\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Running atom_typing: v1.11 / 14 April 2025\n",
-      "Using Python version: 3.13.12 | packaged by conda-forge | (main, Feb  5 2026, 05:53:46) [GCC 14.3.0]\n",
-      "Using Python executable: /home/janitha/miniconda3/envs/autoRX/bin/python\n",
-      "Assigning PCFF atom-types\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/full_templates_3Dmol/pre1.mol chemdraw .mol or .sdf file\n",
-      "Finding molecules ...\n",
-      "Finding rings ...\n",
-      "Finding fused-ring clusters ...\n",
-      "Finding atoms hybridization ...\n",
-      "\n",
-      "\n",
-      "Elements found in system:\n",
-      "- Br\n",
-      "- C\n",
-      "- Cl\n",
-      "- H\n",
-      "- N\n",
-      "- O\n",
-      "\n",
-      "\n",
-      "Total system mass: 521.215\n",
-      "--------------------------------------------Cluster Analysis-------------------------------------\n",
-      "  molID     Molecule Size          Mass              %Mass           %Size      Molecule Formula\n",
-      "-------------------------------------------------------------------------------------------------\n",
-      "    1              18             413.15             79.27           52.94       Br1-C9-Cl5-O3 \n",
-      "    2              16             108.06             20.73           47.06         C6-H8-N2    \n",
-      "\n",
-      "\n",
-      "By-products criteria: {'method': 'mass', 'criteria': 0.0}\n",
-      "------By Products Tally------\n",
-      "Type                    Count\n",
-      "-----------------------------\n",
-      "\n",
-      "\n",
-      "----Inputs used for find_rings----\n",
-      "Walked along elements  :  ['Br', 'C', 'Cl', 'H', 'N', 'O']\n",
-      "Checked for ring sizes :  [3, 4, 5, 6, 7]\n",
-      "Total rings found      :  2\n",
-      "0 atoms along a ring seam had to be partitioned amoung the ring\n",
-      "types (To find accurate %Mass of ring type to entire system).\n",
-      "Giving preference of partionioning in this order:\n",
-      "- 6 member ring\n",
-      "- 5 member ring\n",
-      "- 7 member ring\n",
-      "- 4 member ring\n",
-      "- 3 member ring\n",
-      "- 8 member ring\n",
-      "- minimum ring size\n",
-      "*NOTE: If count of rings exists, but no atoms exist for that ring, this means the\n",
-      "atoms for that ring were partionted to other rings that the atoms belong to.*\n",
-      "\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|          Ring            |           Count           |             %Ring count            |\n",
-      "|          Type            |         of Rings          |            per all rings           |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|            6             |             2             |               100.00               |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|    Element      |     natoms      |       Mass       |      %Mass       |     %natoms     |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|       Br        |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       C         |       12        |      144.00      |      27.63       |      35.29      |\n",
-      "|       Cl        |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       H         |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       N         |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       O         |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|      all        |       12        |      144.00      |      27.63       |      35.29      |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "----------------------------------Ringed Clusters------------------------------------\n",
-      "Ring-Formula    Ring-Size     Ring-count    Ring-Mass-tally     natoms-tally\n",
-      "-------------------------------------------------------------------------------------\n",
-      "C6                    6              2             144.00               12\n",
-      "\n",
-      "\n",
-      "--------------------------------------------------Fused Ring Clusters-----------------------------------------------------\n",
-      "FusedID         Size         Mass        %Mass        %Size       Nrings       %Rings                   FusedRing Formula\n",
-      "--------------------------------------------------------------------------------------------------------------------------\n",
-      "Sum percent mass: 0\n",
-      "\n",
-      "\n",
-      "\n",
-      "-----------------------------Hybridization Information-------------------------------\n",
-      "     Atom-Type            natoms            Mass            %Mass           %natoms     \n",
-      "-------------------------------------------------------------------------------------\n",
-      "       all-Br               1              79.90            15.33             2.94      \n",
-      "    Terminal-Br             1              79.90            15.33             2.94      \n",
-      "       Sp2-C                15             180.00           34.53            44.12      \n",
-      "       all-C                15             180.00           34.53            44.12      \n",
-      "       all-Cl               5              177.25           34.01            14.71      \n",
-      "    Terminal-Cl             5              177.25           34.01            14.71      \n",
-      "       all-H                8               8.06             1.55            23.53      \n",
-      "       Sp3-N                2              28.00             5.37             5.88      \n",
-      "       all-N                2              28.00             5.37             5.88      \n",
-      "       Sp2-O                3              48.00             9.21             8.82      \n",
-      "       all-O                3              48.00             9.21             8.82      \n",
-      "\n",
-      "\n",
-      "---------------------------------------\n",
-      "System Unit cell, volume, mass, density\n",
-      "---------------------------------------\n",
-      "lx:        31.195800  angstrom  \n",
-      "ly:         7.912400  angstrom  \n",
-      "lz:         5.084300  angstrom  \n",
-      "volume:    1254.976316 angstrom^3\n",
-      "mass:      521.215000 amu       \n",
-      "density:    0.689653  g/cm^3    \n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "| Currently supported atom types (If you know your system has an atom type that is not  |\n",
-      "| listed the force field specifc typing module needs to be added onto for that type).   |\n",
-      "| If the atom type has a trailing (T) or (F) it means that atom type has flag settings  |\n",
-      "| in the force field specifc typing module and lets you know the status of those flags. |\n",
-      "| If the atom type has a trailing (Q) it means that the written datafile has the charge |\n",
-      "| set for that atom type already (Mainly for PCFF-IFF or Metal/Mineral based FFs). For  |\n",
-      "| most atom types with the trailing (Q) there will a flag in the specific atom typing   |\n",
-      "| module to turn on or off this functionality (to give a more control of the code).     |\n",
-      "|-------------------------------------   Carbon   --------------------------------------|\n",
-      "|         ct             c+             cr             c-             c5                |\n",
-      "|         cs             cp             c_0            c_1            c_2               |\n",
-      "|         cz             ci             c=             c=1            c=2               |\n",
-      "|         c3h            c3m            c4h            c4m            c_a               |\n",
-      "|         cg             coh            c1             c2             c3                |\n",
-      "|-------------------------------------  Hydrogen  --------------------------------------|\n",
-      "|         hi             hc             hw             hos            ho2               |\n",
-      "|         ho             hn2            hn             h*             hsi               |\n",
-      "|         hs             h                                                              |\n",
-      "|-------------------------------------   Oxygen   --------------------------------------|\n",
-      "|         o_1            oo             o=             o-             o*                |\n",
-      "|         oz             o_2            oc             o3e            o4e               |\n",
-      "|         op             osh            osi            oh             ob                |\n",
-      "|-------------------------------------  Nitrogen  --------------------------------------|\n",
-      "|         nt             np             n=             n=1            n=2               |\n",
-      "|         n1             n2             n_2            nn             na                |\n",
-      "|         nho            ni             npc            nh             n3n               |\n",
-      "|         n3m            n4n            n4m            n              nh+               |\n",
-      "|         n4                                                                            |\n",
-      "|-------------------------------------   Sulfer   --------------------------------------|\n",
-      "|         s'             s-             s3e            s4e            sp                |\n",
-      "|         sc             sh             s1             s              sf                |\n",
-      "|-------------------------------------  Silicone  --------------------------------------|\n",
-      "|         sio            si                                                             |\n",
-      "|-------------------------------------  Fluorine  --------------------------------------|\n",
-      "|         f                                                                             |\n",
-      "|-------------------------------------   Xenon    --------------------------------------|\n",
-      "|         xe                                                                            |\n",
-      "|-------------------------------------    Neon    --------------------------------------|\n",
-      "|         ne                                                                            |\n",
-      "|-------------------------------------  Krypton   --------------------------------------|\n",
-      "|         kr                                                                            |\n",
-      "|-------------------------------------   Helium   --------------------------------------|\n",
-      "|         he                                                                            |\n",
-      "|------------------------------------- Deuterium  --------------------------------------|\n",
-      "|         dw                                                                            |\n",
-      "|-------------------------------------  Chlorine  --------------------------------------|\n",
-      "|         cl                                                                            |\n",
-      "|-------------------------------------  Calcium   --------------------------------------|\n",
-      "|         ca                                                                            |\n",
-      "|-------------------------------------  Bromine   --------------------------------------|\n",
-      "|         br                                                                            |\n",
-      "|-------------------------------------   Argon    --------------------------------------|\n",
-      "|         ar                                                                            |\n",
-      "|-------------------------------------Phosphorous --------------------------------------|\n",
-      "|         p              p=                                                             |\n",
-      "|------------------------------------- Molybdenum --------------------------------------|\n",
-      "|         Mo                                                                            |\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "|                        Total count of supported atom types: 98                        |\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "\n",
-      "Final outcome of found atom types:\n",
-      "Total atom count                   : 34\n",
-      "Total Parameterized atom count     : 34\n",
-      "Assumed Parameterized atom count   : 0\n",
-      "Failed Parameterized atom count    : 0\n",
-      "Total Parameterized atom perentage : 100.00\n",
-      "\n",
-      "------Atom types Tally------\n",
-      "Type                   Count\n",
-      "----------------------------\n",
-      "br                         1\n",
-      "c=                         3\n",
-      "cl                         5\n",
-      "cp                        12\n",
-      "hc                         4\n",
-      "hn                         4\n",
-      "nn                         2\n",
-      "o_1                        3\n",
-      "pdb_file = skip, so skipping writing of optional .pdb file\n",
-      "\n",
-      "\n",
-      "All outputs can be found in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre1 directory\n",
-      "\n",
-      "\n",
-      "Normal program termination\n",
-      "\n",
-      "\n",
-      "Execution time in seconds: 0.06482601165771484\n",
-      "\n",
-      "\n",
-      "Number of WARNING(s) and ERROR(s)\n",
-      "  0 WARNING(s)\n",
-      "  0 ERROR(s)\n",
-      "\n",
-      "\n",
-      "Command line run option override checks (will warn if command line run option is used but not all options are provided at the command line):\n",
-      "WARNING override option   -bond              not provided at the command line. Hard coded input being enforced: n.u.\n",
-      "WARNING override option   -newfile           not provided at the command line. Hard coded input being enforced: :_typed\n",
-      "WARNING override option   -reset-charges     not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -vdw-scale         not provided at the command line. Hard coded input being enforced: 1.1\n",
-      "WARNING override option   -pdb               not provided at the command line. Hard coded input being enforced: skip\n",
-      "WARNING override option   -charge-file       not provided at the command line. Hard coded input being enforced: frc_files/Gasteiger_parameters.txt\n",
-      "WARNING override option   -nta-comments      not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -boundary          not provided at the command line. Hard coded input being enforced: p p p\n",
-      "WARNING override option   -bond-reset        not provided at the command line. Hard coded input being enforced: False\n",
-      "\n",
-      "\n",
-      "Command line run option override inputs confirmation (will confirm to user that the command line override does override the hard coded inputs):\n",
-      "Override confirmation for -topo              Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/full_templates_3Dmol/post1.mol\n",
-      "Override confirmation for -dir               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post1\n",
-      "Override confirmation for -ff                Hard codeded input is being overridden with this input: PCFF\n",
-      "Override confirmation for -del-method        Hard codeded input is being overridden with this input: mass\n",
-      "Override confirmation for -del-crit          Hard codeded input is being overridden with this input: 0.0\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Running atom_typing: v1.11 / 14 April 2025\n",
-      "Using Python version: 3.13.12 | packaged by conda-forge | (main, Feb  5 2026, 05:53:46) [GCC 14.3.0]\n",
-      "Using Python executable: /home/janitha/miniconda3/envs/autoRX/bin/python\n",
-      "Assigning PCFF atom-types\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/full_templates_3Dmol/post1.mol chemdraw .mol or .sdf file\n",
-      "Finding molecules ...\n",
-      "Finding rings ...\n",
-      "Finding fused-ring clusters ...\n",
-      "Finding atoms hybridization ...\n",
-      "\n",
-      "\n",
-      "Elements found in system:\n",
-      "- Br\n",
-      "- C\n",
-      "- Cl\n",
-      "- H\n",
-      "- N\n",
-      "- O\n",
-      "\n",
-      "\n",
-      "Total system mass: 521.215\n",
-      "--------------------------------------------Cluster Analysis-------------------------------------\n",
-      "  molID     Molecule Size          Mass              %Mass           %Size      Molecule Formula\n",
-      "-------------------------------------------------------------------------------------------------\n",
-      "    1              32             484.76             93.01           94.12      Br1-C15-Cl4-H7-N2-O3\n",
-      "    2               2             36.46              6.99            5.88           Cl1-H1     \n",
-      "\n",
-      "\n",
-      "By-products criteria: {'method': 'mass', 'criteria': 0.0}\n",
-      "------By Products Tally------\n",
-      "Type                    Count\n",
-      "-----------------------------\n",
-      "\n",
-      "\n",
-      "----Inputs used for find_rings----\n",
-      "Walked along elements  :  ['Br', 'C', 'Cl', 'H', 'N', 'O']\n",
-      "Checked for ring sizes :  [3, 4, 5, 6, 7]\n",
-      "Total rings found      :  2\n",
-      "0 atoms along a ring seam had to be partitioned amoung the ring\n",
-      "types (To find accurate %Mass of ring type to entire system).\n",
-      "Giving preference of partionioning in this order:\n",
-      "- 6 member ring\n",
-      "- 5 member ring\n",
-      "- 7 member ring\n",
-      "- 4 member ring\n",
-      "- 3 member ring\n",
-      "- 8 member ring\n",
-      "- minimum ring size\n",
-      "*NOTE: If count of rings exists, but no atoms exist for that ring, this means the\n",
-      "atoms for that ring were partionted to other rings that the atoms belong to.*\n",
-      "\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|          Ring            |           Count           |             %Ring count            |\n",
-      "|          Type            |         of Rings          |            per all rings           |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|            6             |             2             |               100.00               |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|    Element      |     natoms      |       Mass       |      %Mass       |     %natoms     |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|       Br        |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       C         |       12        |      144.00      |      27.63       |      35.29      |\n",
-      "|       Cl        |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       H         |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       N         |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       O         |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|      all        |       12        |      144.00      |      27.63       |      35.29      |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "----------------------------------Ringed Clusters------------------------------------\n",
-      "Ring-Formula    Ring-Size     Ring-count    Ring-Mass-tally     natoms-tally\n",
-      "-------------------------------------------------------------------------------------\n",
-      "C6                    6              2             144.00               12\n",
-      "\n",
-      "\n",
-      "--------------------------------------------------Fused Ring Clusters-----------------------------------------------------\n",
-      "FusedID         Size         Mass        %Mass        %Size       Nrings       %Rings                   FusedRing Formula\n",
-      "--------------------------------------------------------------------------------------------------------------------------\n",
-      "Sum percent mass: 0\n",
-      "\n",
-      "\n",
-      "\n",
-      "-----------------------------Hybridization Information-------------------------------\n",
-      "     Atom-Type            natoms            Mass            %Mass           %natoms     \n",
-      "-------------------------------------------------------------------------------------\n",
-      "       all-Br               1              79.90            15.33             2.94      \n",
-      "    Terminal-Br             1              79.90            15.33             2.94      \n",
-      "       Sp2-C                15             180.00           34.53            44.12      \n",
-      "       all-C                15             180.00           34.53            44.12      \n",
-      "     unknown-Cl             1              35.45             6.80             2.94      \n",
-      "       all-Cl               5              177.25           34.01            14.71      \n",
-      "    Terminal-Cl             4              141.80           27.21            11.76      \n",
-      "       all-H                8               8.06             1.55            23.53      \n",
-      "       Sp2-N                2              28.00             5.37             5.88      \n",
-      "       all-N                2              28.00             5.37             5.88      \n",
-      "       Sp2-O                3              48.00             9.21             8.82      \n",
-      "       all-O                3              48.00             9.21             8.82      \n",
-      "\n",
-      "\n",
-      "---------------------------------------\n",
-      "System Unit cell, volume, mass, density\n",
-      "---------------------------------------\n",
-      "lx:        32.275900  angstrom  \n",
-      "ly:         7.858600  angstrom  \n",
-      "lz:         4.784700  angstrom  \n",
-      "volume:    1213.607517 angstrom^3\n",
-      "mass:      521.215000 amu       \n",
-      "density:    0.713161  g/cm^3    \n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "| Currently supported atom types (If you know your system has an atom type that is not  |\n",
-      "| listed the force field specifc typing module needs to be added onto for that type).   |\n",
-      "| If the atom type has a trailing (T) or (F) it means that atom type has flag settings  |\n",
-      "| in the force field specifc typing module and lets you know the status of those flags. |\n",
-      "| If the atom type has a trailing (Q) it means that the written datafile has the charge |\n",
-      "| set for that atom type already (Mainly for PCFF-IFF or Metal/Mineral based FFs). For  |\n",
-      "| most atom types with the trailing (Q) there will a flag in the specific atom typing   |\n",
-      "| module to turn on or off this functionality (to give a more control of the code).     |\n",
-      "|-------------------------------------   Carbon   --------------------------------------|\n",
-      "|         ct             c+             cr             c-             c5                |\n",
-      "|         cs             cp             c_0            c_1            c_2               |\n",
-      "|         cz             ci             c=             c=1            c=2               |\n",
-      "|         c3h            c3m            c4h            c4m            c_a               |\n",
-      "|         cg             coh            c1             c2             c3                |\n",
-      "|-------------------------------------  Hydrogen  --------------------------------------|\n",
-      "|         hi             hc             hw             hos            ho2               |\n",
-      "|         ho             hn2            hn             h*             hsi               |\n",
-      "|         hs             h                                                              |\n",
-      "|-------------------------------------   Oxygen   --------------------------------------|\n",
-      "|         o_1            oo             o=             o-             o*                |\n",
-      "|         oz             o_2            oc             o3e            o4e               |\n",
-      "|         op             osh            osi            oh             ob                |\n",
-      "|-------------------------------------  Nitrogen  --------------------------------------|\n",
-      "|         nt             np             n=             n=1            n=2               |\n",
-      "|         n1             n2             n_2            nn             na                |\n",
-      "|         nho            ni             npc            nh             n3n               |\n",
-      "|         n3m            n4n            n4m            n              nh+               |\n",
-      "|         n4                                                                            |\n",
-      "|-------------------------------------   Sulfer   --------------------------------------|\n",
-      "|         s'             s-             s3e            s4e            sp                |\n",
-      "|         sc             sh             s1             s              sf                |\n",
-      "|-------------------------------------  Silicone  --------------------------------------|\n",
-      "|         sio            si                                                             |\n",
-      "|-------------------------------------  Fluorine  --------------------------------------|\n",
-      "|         f                                                                             |\n",
-      "|-------------------------------------   Xenon    --------------------------------------|\n",
-      "|         xe                                                                            |\n",
-      "|-------------------------------------    Neon    --------------------------------------|\n",
-      "|         ne                                                                            |\n",
-      "|-------------------------------------  Krypton   --------------------------------------|\n",
-      "|         kr                                                                            |\n",
-      "|-------------------------------------   Helium   --------------------------------------|\n",
-      "|         he                                                                            |\n",
-      "|------------------------------------- Deuterium  --------------------------------------|\n",
-      "|         dw                                                                            |\n",
-      "|-------------------------------------  Chlorine  --------------------------------------|\n",
-      "|         cl                                                                            |\n",
-      "|-------------------------------------  Calcium   --------------------------------------|\n",
-      "|         ca                                                                            |\n",
-      "|-------------------------------------  Bromine   --------------------------------------|\n",
-      "|         br                                                                            |\n",
-      "|-------------------------------------   Argon    --------------------------------------|\n",
-      "|         ar                                                                            |\n",
-      "|-------------------------------------Phosphorous --------------------------------------|\n",
-      "|         p              p=                                                             |\n",
-      "|------------------------------------- Molybdenum --------------------------------------|\n",
-      "|         Mo                                                                            |\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "|                        Total count of supported atom types: 98                        |\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "\n",
-      "Final outcome of found atom types:\n",
-      "Total atom count                   : 34\n",
-      "Total Parameterized atom count     : 33\n",
-      "Assumed Parameterized atom count   : 1\n",
-      "Failed Parameterized atom count    : 0\n",
-      "Total Parameterized atom perentage : 97.06\n",
-      "\n",
-      "------Atom types Tally------\n",
-      "Type                   Count\n",
-      "----------------------------\n",
-      "br                         1\n",
-      "c=                         2\n",
-      "c_1                        1\n",
-      "cl                         5\n",
-      "cp                        12\n",
-      "h                          1\n",
-      "hc                         4\n",
-      "hn                         3\n",
-      "nn                         2\n",
-      "o_1                        3\n",
-      "pdb_file = skip, so skipping writing of optional .pdb file\n",
-      "\n",
-      "\n",
-      "All outputs can be found in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post1 directory\n",
-      "\n",
-      "\n",
-      "Normal program termination\n",
-      "\n",
-      "\n",
-      "Execution time in seconds: 0.06320548057556152\n",
-      "\n",
-      "\n",
-      "Number of WARNING(s) and ERROR(s)\n",
-      "  0 WARNING(s)\n",
-      "  0 ERROR(s)\n",
-      "\n",
-      "\n",
-      "Command line run option override checks (will warn if command line run option is used but not all options are provided at the command line):\n",
-      "WARNING override option   -bond              not provided at the command line. Hard coded input being enforced: n.u.\n",
-      "WARNING override option   -newfile           not provided at the command line. Hard coded input being enforced: :_typed\n",
-      "WARNING override option   -reset-charges     not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -vdw-scale         not provided at the command line. Hard coded input being enforced: 1.1\n",
-      "WARNING override option   -pdb               not provided at the command line. Hard coded input being enforced: skip\n",
-      "WARNING override option   -charge-file       not provided at the command line. Hard coded input being enforced: frc_files/Gasteiger_parameters.txt\n",
-      "WARNING override option   -nta-comments      not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -boundary          not provided at the command line. Hard coded input being enforced: p p p\n",
-      "WARNING override option   -bond-reset        not provided at the command line. Hard coded input being enforced: False\n",
-      "\n",
-      "\n",
-      "Command line run option override inputs confirmation (will confirm to user that the command line override does override the hard coded inputs):\n",
-      "Override confirmation for -topo              Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/full_templates_3Dmol/pre5.mol\n",
-      "Override confirmation for -dir               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre5\n",
-      "Override confirmation for -ff                Hard codeded input is being overridden with this input: PCFF\n",
-      "Override confirmation for -del-method        Hard codeded input is being overridden with this input: mass\n",
-      "Override confirmation for -del-crit          Hard codeded input is being overridden with this input: 0.0\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Running atom_typing: v1.11 / 14 April 2025\n",
-      "Using Python version: 3.13.12 | packaged by conda-forge | (main, Feb  5 2026, 05:53:46) [GCC 14.3.0]\n",
-      "Using Python executable: /home/janitha/miniconda3/envs/autoRX/bin/python\n",
-      "Assigning PCFF atom-types\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/full_templates_3Dmol/pre5.mol chemdraw .mol or .sdf file\n",
-      "Finding molecules ...\n",
-      "Finding rings ...\n",
-      "Finding fused-ring clusters ...\n",
-      "Finding atoms hybridization ...\n",
-      "\n",
-      "\n",
-      "Elements found in system:\n",
-      "- Br\n",
-      "- C\n",
-      "- Cl\n",
-      "- H\n",
-      "- N\n",
-      "- O\n",
-      "\n",
-      "\n",
-      "Total system mass: 521.215\n",
-      "--------------------------------------------Cluster Analysis-------------------------------------\n",
-      "  molID     Molecule Size          Mass              %Mass           %Size      Molecule Formula\n",
-      "-------------------------------------------------------------------------------------------------\n",
-      "    1              18             413.15             79.27           52.94       Br1-C9-Cl5-O3 \n",
-      "    2              16             108.06             20.73           47.06         C6-H8-N2    \n",
-      "\n",
-      "\n",
-      "By-products criteria: {'method': 'mass', 'criteria': 0.0}\n",
-      "------By Products Tally------\n",
-      "Type                    Count\n",
-      "-----------------------------\n",
-      "\n",
-      "\n",
-      "----Inputs used for find_rings----\n",
-      "Walked along elements  :  ['Br', 'C', 'Cl', 'H', 'N', 'O']\n",
-      "Checked for ring sizes :  [3, 4, 5, 6, 7]\n",
-      "Total rings found      :  2\n",
-      "0 atoms along a ring seam had to be partitioned amoung the ring\n",
-      "types (To find accurate %Mass of ring type to entire system).\n",
-      "Giving preference of partionioning in this order:\n",
-      "- 6 member ring\n",
-      "- 5 member ring\n",
-      "- 7 member ring\n",
-      "- 4 member ring\n",
-      "- 3 member ring\n",
-      "- 8 member ring\n",
-      "- minimum ring size\n",
-      "*NOTE: If count of rings exists, but no atoms exist for that ring, this means the\n",
-      "atoms for that ring were partionted to other rings that the atoms belong to.*\n",
-      "\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|          Ring            |           Count           |             %Ring count            |\n",
-      "|          Type            |         of Rings          |            per all rings           |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|            6             |             2             |               100.00               |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|    Element      |     natoms      |       Mass       |      %Mass       |     %natoms     |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|       Br        |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       C         |       12        |      144.00      |      27.63       |      35.29      |\n",
-      "|       Cl        |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       H         |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       N         |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       O         |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|      all        |       12        |      144.00      |      27.63       |      35.29      |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "----------------------------------Ringed Clusters------------------------------------\n",
-      "Ring-Formula    Ring-Size     Ring-count    Ring-Mass-tally     natoms-tally\n",
-      "-------------------------------------------------------------------------------------\n",
-      "C6                    6              2             144.00               12\n",
-      "\n",
-      "\n",
-      "--------------------------------------------------Fused Ring Clusters-----------------------------------------------------\n",
-      "FusedID         Size         Mass        %Mass        %Size       Nrings       %Rings                   FusedRing Formula\n",
-      "--------------------------------------------------------------------------------------------------------------------------\n",
-      "Sum percent mass: 0\n",
-      "\n",
-      "\n",
-      "\n",
-      "-----------------------------Hybridization Information-------------------------------\n",
-      "     Atom-Type            natoms            Mass            %Mass           %natoms     \n",
-      "-------------------------------------------------------------------------------------\n",
-      "       all-Br               1              79.90            15.33             2.94      \n",
-      "    Terminal-Br             1              79.90            15.33             2.94      \n",
-      "       Sp2-C                15             180.00           34.53            44.12      \n",
-      "       all-C                15             180.00           34.53            44.12      \n",
-      "       all-Cl               5              177.25           34.01            14.71      \n",
-      "    Terminal-Cl             5              177.25           34.01            14.71      \n",
-      "       all-H                8               8.06             1.55            23.53      \n",
-      "       Sp3-N                2              28.00             5.37             5.88      \n",
-      "       all-N                2              28.00             5.37             5.88      \n",
-      "       Sp2-O                3              48.00             9.21             8.82      \n",
-      "       all-O                3              48.00             9.21             8.82      \n",
-      "\n",
-      "\n",
-      "---------------------------------------\n",
-      "System Unit cell, volume, mass, density\n",
-      "---------------------------------------\n",
-      "lx:        31.103600  angstrom  \n",
-      "ly:         7.612300  angstrom  \n",
-      "lz:         6.588800  angstrom  \n",
-      "volume:    1560.029743 angstrom^3\n",
-      "mass:      521.215000 amu       \n",
-      "density:    0.554796  g/cm^3    \n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "| Currently supported atom types (If you know your system has an atom type that is not  |\n",
-      "| listed the force field specifc typing module needs to be added onto for that type).   |\n",
-      "| If the atom type has a trailing (T) or (F) it means that atom type has flag settings  |\n",
-      "| in the force field specifc typing module and lets you know the status of those flags. |\n",
-      "| If the atom type has a trailing (Q) it means that the written datafile has the charge |\n",
-      "| set for that atom type already (Mainly for PCFF-IFF or Metal/Mineral based FFs). For  |\n",
-      "| most atom types with the trailing (Q) there will a flag in the specific atom typing   |\n",
-      "| module to turn on or off this functionality (to give a more control of the code).     |\n",
-      "|-------------------------------------   Carbon   --------------------------------------|\n",
-      "|         ct             c+             cr             c-             c5                |\n",
-      "|         cs             cp             c_0            c_1            c_2               |\n",
-      "|         cz             ci             c=             c=1            c=2               |\n",
-      "|         c3h            c3m            c4h            c4m            c_a               |\n",
-      "|         cg             coh            c1             c2             c3                |\n",
-      "|-------------------------------------  Hydrogen  --------------------------------------|\n",
-      "|         hi             hc             hw             hos            ho2               |\n",
-      "|         ho             hn2            hn             h*             hsi               |\n",
-      "|         hs             h                                                              |\n",
-      "|-------------------------------------   Oxygen   --------------------------------------|\n",
-      "|         o_1            oo             o=             o-             o*                |\n",
-      "|         oz             o_2            oc             o3e            o4e               |\n",
-      "|         op             osh            osi            oh             ob                |\n",
-      "|-------------------------------------  Nitrogen  --------------------------------------|\n",
-      "|         nt             np             n=             n=1            n=2               |\n",
-      "|         n1             n2             n_2            nn             na                |\n",
-      "|         nho            ni             npc            nh             n3n               |\n",
-      "|         n3m            n4n            n4m            n              nh+               |\n",
-      "|         n4                                                                            |\n",
-      "|-------------------------------------   Sulfer   --------------------------------------|\n",
-      "|         s'             s-             s3e            s4e            sp                |\n",
-      "|         sc             sh             s1             s              sf                |\n",
-      "|-------------------------------------  Silicone  --------------------------------------|\n",
-      "|         sio            si                                                             |\n",
-      "|-------------------------------------  Fluorine  --------------------------------------|\n",
-      "|         f                                                                             |\n",
-      "|-------------------------------------   Xenon    --------------------------------------|\n",
-      "|         xe                                                                            |\n",
-      "|-------------------------------------    Neon    --------------------------------------|\n",
-      "|         ne                                                                            |\n",
-      "|-------------------------------------  Krypton   --------------------------------------|\n",
-      "|         kr                                                                            |\n",
-      "|-------------------------------------   Helium   --------------------------------------|\n",
-      "|         he                                                                            |\n",
-      "|------------------------------------- Deuterium  --------------------------------------|\n",
-      "|         dw                                                                            |\n",
-      "|-------------------------------------  Chlorine  --------------------------------------|\n",
-      "|         cl                                                                            |\n",
-      "|-------------------------------------  Calcium   --------------------------------------|\n",
-      "|         ca                                                                            |\n",
-      "|-------------------------------------  Bromine   --------------------------------------|\n",
-      "|         br                                                                            |\n",
-      "|-------------------------------------   Argon    --------------------------------------|\n",
-      "|         ar                                                                            |\n",
-      "|-------------------------------------Phosphorous --------------------------------------|\n",
-      "|         p              p=                                                             |\n",
-      "|------------------------------------- Molybdenum --------------------------------------|\n",
-      "|         Mo                                                                            |\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "|                        Total count of supported atom types: 98                        |\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "\n",
-      "Final outcome of found atom types:\n",
-      "Total atom count                   : 34\n",
-      "Total Parameterized atom count     : 34\n",
-      "Assumed Parameterized atom count   : 0\n",
-      "Failed Parameterized atom count    : 0\n",
-      "Total Parameterized atom perentage : 100.00\n",
-      "\n",
-      "------Atom types Tally------\n",
-      "Type                   Count\n",
-      "----------------------------\n",
-      "br                         1\n",
-      "c=                         3\n",
-      "cl                         5\n",
-      "cp                        12\n",
-      "hc                         4\n",
-      "hn                         4\n",
-      "nn                         2\n",
-      "o_1                        3\n",
-      "pdb_file = skip, so skipping writing of optional .pdb file\n",
-      "\n",
-      "\n",
-      "All outputs can be found in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre5 directory\n",
-      "\n",
-      "\n",
-      "Normal program termination\n",
-      "\n",
-      "\n",
-      "Execution time in seconds: 0.06308770179748535\n",
-      "\n",
-      "\n",
-      "Number of WARNING(s) and ERROR(s)\n",
-      "  0 WARNING(s)\n",
-      "  0 ERROR(s)\n",
-      "\n",
-      "\n",
-      "Command line run option override checks (will warn if command line run option is used but not all options are provided at the command line):\n",
-      "WARNING override option   -bond              not provided at the command line. Hard coded input being enforced: n.u.\n",
-      "WARNING override option   -newfile           not provided at the command line. Hard coded input being enforced: :_typed\n",
-      "WARNING override option   -reset-charges     not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -vdw-scale         not provided at the command line. Hard coded input being enforced: 1.1\n",
-      "WARNING override option   -pdb               not provided at the command line. Hard coded input being enforced: skip\n",
-      "WARNING override option   -charge-file       not provided at the command line. Hard coded input being enforced: frc_files/Gasteiger_parameters.txt\n",
-      "WARNING override option   -nta-comments      not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -boundary          not provided at the command line. Hard coded input being enforced: p p p\n",
-      "WARNING override option   -bond-reset        not provided at the command line. Hard coded input being enforced: False\n",
-      "\n",
-      "\n",
-      "Command line run option override inputs confirmation (will confirm to user that the command line override does override the hard coded inputs):\n",
-      "Override confirmation for -topo              Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/full_templates_3Dmol/post5.mol\n",
-      "Override confirmation for -dir               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post5\n",
-      "Override confirmation for -ff                Hard codeded input is being overridden with this input: PCFF\n",
-      "Override confirmation for -del-method        Hard codeded input is being overridden with this input: mass\n",
-      "Override confirmation for -del-crit          Hard codeded input is being overridden with this input: 0.0\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Running atom_typing: v1.11 / 14 April 2025\n",
-      "Using Python version: 3.13.12 | packaged by conda-forge | (main, Feb  5 2026, 05:53:46) [GCC 14.3.0]\n",
-      "Using Python executable: /home/janitha/miniconda3/envs/autoRX/bin/python\n",
-      "Assigning PCFF atom-types\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/3D_molecules/full_templates_3Dmol/post5.mol chemdraw .mol or .sdf file\n",
-      "Finding molecules ...\n",
-      "Finding rings ...\n",
-      "Finding fused-ring clusters ...\n",
-      "Finding atoms hybridization ...\n",
-      "\n",
-      "\n",
-      "Elements found in system:\n",
-      "- Br\n",
-      "- C\n",
-      "- Cl\n",
-      "- H\n",
-      "- N\n",
-      "- O\n",
-      "\n",
-      "\n",
-      "Total system mass: 521.215\n",
-      "--------------------------------------------Cluster Analysis-------------------------------------\n",
-      "  molID     Molecule Size          Mass              %Mass           %Size      Molecule Formula\n",
-      "-------------------------------------------------------------------------------------------------\n",
-      "    1              32             484.76             93.01           94.12      Br1-C15-Cl4-H7-N2-O3\n",
-      "    2               2             36.46              6.99            5.88           Cl1-H1     \n",
-      "\n",
-      "\n",
-      "By-products criteria: {'method': 'mass', 'criteria': 0.0}\n",
-      "------By Products Tally------\n",
-      "Type                    Count\n",
-      "-----------------------------\n",
-      "\n",
-      "\n",
-      "----Inputs used for find_rings----\n",
-      "Walked along elements  :  ['Br', 'C', 'Cl', 'H', 'N', 'O']\n",
-      "Checked for ring sizes :  [3, 4, 5, 6, 7]\n",
-      "Total rings found      :  2\n",
-      "0 atoms along a ring seam had to be partitioned amoung the ring\n",
-      "types (To find accurate %Mass of ring type to entire system).\n",
-      "Giving preference of partionioning in this order:\n",
-      "- 6 member ring\n",
-      "- 5 member ring\n",
-      "- 7 member ring\n",
-      "- 4 member ring\n",
-      "- 3 member ring\n",
-      "- 8 member ring\n",
-      "- minimum ring size\n",
-      "*NOTE: If count of rings exists, but no atoms exist for that ring, this means the\n",
-      "atoms for that ring were partionted to other rings that the atoms belong to.*\n",
-      "\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|          Ring            |           Count           |             %Ring count            |\n",
-      "|          Type            |         of Rings          |            per all rings           |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|            6             |             2             |               100.00               |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|    Element      |     natoms      |       Mass       |      %Mass       |     %natoms     |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|       Br        |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       C         |       12        |      144.00      |      27.63       |      35.29      |\n",
-      "|       Cl        |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       H         |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       N         |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|       O         |        0        |       0.00       |       0.00       |       0.00      |\n",
-      "|      all        |       12        |      144.00      |      27.63       |      35.29      |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "----------------------------------Ringed Clusters------------------------------------\n",
-      "Ring-Formula    Ring-Size     Ring-count    Ring-Mass-tally     natoms-tally\n",
-      "-------------------------------------------------------------------------------------\n",
-      "C6                    6              2             144.00               12\n",
-      "\n",
-      "\n",
-      "--------------------------------------------------Fused Ring Clusters-----------------------------------------------------\n",
-      "FusedID         Size         Mass        %Mass        %Size       Nrings       %Rings                   FusedRing Formula\n",
-      "--------------------------------------------------------------------------------------------------------------------------\n",
-      "Sum percent mass: 0\n",
-      "\n",
-      "\n",
-      "\n",
-      "-----------------------------Hybridization Information-------------------------------\n",
-      "     Atom-Type            natoms            Mass            %Mass           %natoms     \n",
-      "-------------------------------------------------------------------------------------\n",
-      "       all-Br               1              79.90            15.33             2.94      \n",
-      "    Terminal-Br             1              79.90            15.33             2.94      \n",
-      "       Sp2-C                15             180.00           34.53            44.12      \n",
-      "       all-C                15             180.00           34.53            44.12      \n",
-      "     unknown-Cl             1              35.45             6.80             2.94      \n",
-      "       all-Cl               5              177.25           34.01            14.71      \n",
-      "    Terminal-Cl             4              141.80           27.21            11.76      \n",
-      "       all-H                8               8.06             1.55            23.53      \n",
-      "       Sp2-N                2              28.00             5.37             5.88      \n",
-      "       all-N                2              28.00             5.37             5.88      \n",
-      "       Sp2-O                3              48.00             9.21             8.82      \n",
-      "       all-O                3              48.00             9.21             8.82      \n",
-      "\n",
-      "\n",
-      "---------------------------------------\n",
-      "System Unit cell, volume, mass, density\n",
-      "---------------------------------------\n",
-      "lx:        31.790400  angstrom  \n",
-      "ly:         6.140900  angstrom  \n",
-      "lz:         7.531200  angstrom  \n",
-      "volume:    1470.253421 angstrom^3\n",
-      "mass:      521.215000 amu       \n",
-      "density:    0.588673  g/cm^3    \n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "| Currently supported atom types (If you know your system has an atom type that is not  |\n",
-      "| listed the force field specifc typing module needs to be added onto for that type).   |\n",
-      "| If the atom type has a trailing (T) or (F) it means that atom type has flag settings  |\n",
-      "| in the force field specifc typing module and lets you know the status of those flags. |\n",
-      "| If the atom type has a trailing (Q) it means that the written datafile has the charge |\n",
-      "| set for that atom type already (Mainly for PCFF-IFF or Metal/Mineral based FFs). For  |\n",
-      "| most atom types with the trailing (Q) there will a flag in the specific atom typing   |\n",
-      "| module to turn on or off this functionality (to give a more control of the code).     |\n",
-      "|-------------------------------------   Carbon   --------------------------------------|\n",
-      "|         ct             c+             cr             c-             c5                |\n",
-      "|         cs             cp             c_0            c_1            c_2               |\n",
-      "|         cz             ci             c=             c=1            c=2               |\n",
-      "|         c3h            c3m            c4h            c4m            c_a               |\n",
-      "|         cg             coh            c1             c2             c3                |\n",
-      "|-------------------------------------  Hydrogen  --------------------------------------|\n",
-      "|         hi             hc             hw             hos            ho2               |\n",
-      "|         ho             hn2            hn             h*             hsi               |\n",
-      "|         hs             h                                                              |\n",
-      "|-------------------------------------   Oxygen   --------------------------------------|\n",
-      "|         o_1            oo             o=             o-             o*                |\n",
-      "|         oz             o_2            oc             o3e            o4e               |\n",
-      "|         op             osh            osi            oh             ob                |\n",
-      "|-------------------------------------  Nitrogen  --------------------------------------|\n",
-      "|         nt             np             n=             n=1            n=2               |\n",
-      "|         n1             n2             n_2            nn             na                |\n",
-      "|         nho            ni             npc            nh             n3n               |\n",
-      "|         n3m            n4n            n4m            n              nh+               |\n",
-      "|         n4                                                                            |\n",
-      "|-------------------------------------   Sulfer   --------------------------------------|\n",
-      "|         s'             s-             s3e            s4e            sp                |\n",
-      "|         sc             sh             s1             s              sf                |\n",
-      "|-------------------------------------  Silicone  --------------------------------------|\n",
-      "|         sio            si                                                             |\n",
-      "|-------------------------------------  Fluorine  --------------------------------------|\n",
-      "|         f                                                                             |\n",
-      "|-------------------------------------   Xenon    --------------------------------------|\n",
-      "|         xe                                                                            |\n",
-      "|-------------------------------------    Neon    --------------------------------------|\n",
-      "|         ne                                                                            |\n",
-      "|-------------------------------------  Krypton   --------------------------------------|\n",
-      "|         kr                                                                            |\n",
-      "|-------------------------------------   Helium   --------------------------------------|\n",
-      "|         he                                                                            |\n",
-      "|------------------------------------- Deuterium  --------------------------------------|\n",
-      "|         dw                                                                            |\n",
-      "|-------------------------------------  Chlorine  --------------------------------------|\n",
-      "|         cl                                                                            |\n",
-      "|-------------------------------------  Calcium   --------------------------------------|\n",
-      "|         ca                                                                            |\n",
-      "|-------------------------------------  Bromine   --------------------------------------|\n",
-      "|         br                                                                            |\n",
-      "|-------------------------------------   Argon    --------------------------------------|\n",
-      "|         ar                                                                            |\n",
-      "|-------------------------------------Phosphorous --------------------------------------|\n",
-      "|         p              p=                                                             |\n",
-      "|------------------------------------- Molybdenum --------------------------------------|\n",
-      "|         Mo                                                                            |\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "|                        Total count of supported atom types: 98                        |\n",
-      "-----------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "\n",
-      "Final outcome of found atom types:\n",
-      "Total atom count                   : 34\n",
-      "Total Parameterized atom count     : 33\n",
-      "Assumed Parameterized atom count   : 1\n",
-      "Failed Parameterized atom count    : 0\n",
-      "Total Parameterized atom perentage : 97.06\n",
-      "\n",
-      "------Atom types Tally------\n",
-      "Type                   Count\n",
-      "----------------------------\n",
-      "br                         1\n",
-      "c=                         2\n",
-      "c_1                        1\n",
-      "cl                         5\n",
-      "cp                        12\n",
-      "h                          1\n",
-      "hc                         4\n",
-      "hn                         3\n",
-      "nn                         2\n",
-      "o_1                        3\n",
-      "pdb_file = skip, so skipping writing of optional .pdb file\n",
-      "\n",
-      "\n",
-      "All outputs can be found in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post5 directory\n",
-      "\n",
-      "\n",
-      "Normal program termination\n",
-      "\n",
-      "\n",
-      "Execution time in seconds: 0.06414937973022461\n",
-      "\n",
-      "\n",
-      "Number of WARNING(s) and ERROR(s)\n",
-      "  0 WARNING(s)\n",
-      "  0 ERROR(s)\n",
-      "[LUNAR atom_typing] Generated file for tmc at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/tmc_typed.data\n",
-      "[LUNAR atom_typing] Generated file for tmc at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/tmc_typed.nta\n",
-      "[LUNAR atom_typing] Generated file for mpd at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/mpd_typed.data\n",
-      "[LUNAR atom_typing] Generated file for mpd at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/mpd_typed.nta\n",
-      "[LUNAR atom_typing] Generated file for ethanol at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/ethanol_typed.data\n",
-      "[LUNAR atom_typing] Generated file for ethanol at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/ethanol_typed.nta\n",
-      "[LUNAR atom_typing] Generated file for pre1 at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre1/pre1_typed.data\n",
-      "[LUNAR atom_typing] Generated file for pre1 at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre1/pre1_typed.nta\n",
-      "[LUNAR atom_typing] Generated file for post1 at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post1/post1_typed.data\n",
-      "[LUNAR atom_typing] Generated file for post1 at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post1/post1_typed.nta\n",
-      "[LUNAR atom_typing] Generated file for pre5 at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre5/pre5_typed.data\n",
-      "[LUNAR atom_typing] Generated file for pre5 at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre5/pre5_typed.nta\n",
-      "[LUNAR atom_typing] Generated file for post5 at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post5/post5_typed.data\n",
-      "[LUNAR atom_typing] Generated file for post5 at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post5/post5_typed.nta\n",
-      "\n",
-      "\n",
-      "Command line run option override checks (will warn if command line run option is used but not all options are provided at the command line):\n",
-      "WARNING override option   -asm               not provided at the command line. Hard coded input being enforced: frc_files/general_assumed_equivs.coeffs\n",
-      "WARNING override option   -newfile           not provided at the command line. Hard coded input being enforced: :_IFF\n",
-      "WARNING override option   -atomstyle         not provided at the command line. Hard coded input being enforced: full\n",
-      "WARNING override option   -class             not provided at the command line. Hard coded input being enforced: 2\n",
-      "WARNING override option   -auto-equivs       not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -assumed-equivs    not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -reset-molids      not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -reset-charges     not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -write-comments    not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -write-bond-react  not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -morse-bond        not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -type-labels       not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -add2box           not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -ignore            not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -rx                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -ry                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -rz                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sx                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sy                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sz                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "\n",
-      "\n",
-      "Command line run option override inputs confirmation (will confirm to user that the command line override does override the hard coded inputs):\n",
-      "Override confirmation for -topo              Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/tmc_typed.data\n",
-      "Override confirmation for -nta               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/tmc_typed.nta\n",
-      "Override confirmation for -frc               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc\n",
-      "Override confirmation for -dir               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Running all2lmp: v1.22 / 14 April 2025\n",
-      "Using Python version: 3.13.12 | packaged by conda-forge | (main, Feb  5 2026, 05:53:46) [GCC 14.3.0]\n",
-      "Using Python executable: /home/janitha/miniconda3/envs/autoRX/bin/python\n",
-      "Trying Atom Equivalences if needed\n",
-      "Trying Atom Auto-Equivalences if needed\n",
-      "Trying to find atom charge based on bond-incs\n",
-      "Resetting molecule-ids based on cluster analysis\n",
-      "\n",
-      "\n",
-      "Using higher version of parameters for #equivalences N a version: 2.10 \n",
-      "Using higher version of parameters for #bond_increments si si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments h si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments c_1 cp version: 2.10 \n",
-      "Using higher version of parameters for #bond_increments cp si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments c si version: 2.20 \n",
-      "Using higher version of parameters for #quartic_bonds c h version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c c version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c= c=1 version: 3.10 \n",
-      "Using higher version of parameters for #quartic_bonds cp h version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds cp cp version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c_1 o_1 version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c o_2 version: 2.20 \n",
-      "Using higher version of parameters for #torsion_3 c c c h version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 c c c c version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 h c c h version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 h c cp cp version: 2.00 \n",
-      "Using higher version of parameters for #wilson_out_of_plane cp cp cp h version: 3.10 \n",
-      "Using higher version of parameters for #wilson_out_of_plane c cp cp cp version: 2.00 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 n z version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 o _ 1 version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 s ' version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 c = version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 h o 2 version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 n = version: 3.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 s i version: 2.20 \n",
-      "Using higher version of parameters for #bondbond13 cp cp cp cp version: 2.10 \n",
-      "Using higher version of parameters for #middlebondtorsion o_1 c_1 o_2 c version: 2.10 \n",
-      "\n",
-      "Read in /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc forcefeild file\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/tmc_typed.data LAMMPS datafile\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/tmc_typed.nta new-type-assignment file\n",
-      "\n",
-      "\n",
-      "\n",
-      "Getting force field parameters for the read in system\n",
-      "\n",
-      "Checking for atom-type assignment consistency with atom-types in .frc file\n",
-      "\n",
-      "\n",
-      "Finding molecules to reset molids....\n",
-      "-----------------Cluster Analysis-----------------\n",
-      "  molID    Size of Fragment     %Size of Fragment    \n",
-      "--------------------------------------------------\n",
-      "    1              18               100.00          \n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Atoms information has been found\n",
-      "  /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/tmc_typed.data has all image flags set to zero\n",
-      "  There are 18 atoms in 1 molecules in this file\n",
-      "  The total charge in the system is -0.0000\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 1 br cp cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 2 c= cp cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 3 cl c= cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 4 cl c= o_1\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 5 cl cp cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 6 cp c= o_1\n",
-      "\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 1 br cp cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 2 c= cp cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 3 cl c= cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 4 cl c= o_1\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 5 cl cp cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 6 cp c= o_1\n",
-      "\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 2 o_1 c= cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 3 br cp cp c=\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 4 c= cp cp cl\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 6 br cp cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 7 cl cp cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 8 c= cp cp cp\n",
-      "\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 2 o_1 c= cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 3 br cp cp c=\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 4 c= cp cp cl\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 6 br cp cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 7 cl cp cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 8 c= cp cp cp\n",
-      "\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 2 o_1 c= cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 3 br cp cp c=\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 4 c= cp cp cl\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 6 br cp cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 7 cl cp cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 8 c= cp cp cp\n",
-      "\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 2 o_1 c= cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 3 br cp cp c=\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 4 c= cp cp cl\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 6 br cp cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 7 cl cp cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 8 c= cp cp cp\n",
-      "\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 2 o_1 c= cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 3 br cp cp c=\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 4 c= cp cp cl\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 6 br cp cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 7 cl cp cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 8 c= cp cp cp\n",
-      "\n",
-      "\n",
-      "---------------------------------------\n",
-      "System Unit cell, volume, mass, density\n",
-      "---------------------------------------\n",
-      "Lx:         7.34150   angstrom  \n",
-      "Ly:         7.83570   angstrom  \n",
-      "Lz:         6.40890   angstrom  \n",
-      "volume:    3.6868E-22 cm^3      \n",
-      "mass:      6.8626E-22 grams     \n",
-      "density:    1.86140   g/cm^3    \n",
-      "\n",
-      "\n",
-      "\n",
-      "--------------------------------------\n",
-      "Atoms/Bonds/Angles/Dihedrals/Impropers\n",
-      "--------------------------------------\n",
-      "natoms:             18  \n",
-      "nbonds:             18  \n",
-      "nangles:            27  \n",
-      "ndihedrals:         36  \n",
-      "nimpropers:          9  \n",
-      "- oop:               9  \n",
-      "- angleangle:        0  \n",
-      "\n",
-      "--------------------------------------------\n",
-      "Atoms/Bonds/Angles/Dihedrals/Impropers Types\n",
-      "--------------------------------------------\n",
-      "natomtypes:          5  \n",
-      "nbondtypes:          6  \n",
-      "nangletypes:         7  \n",
-      "ndihedraltypes:      8  \n",
-      "nimpropertypes:      4  \n",
-      "- oop:               4  \n",
-      "- angleangle:        0  \n",
-      "\n",
-      "-------------------------------------\n",
-      "Parameterization percentage breakdown\n",
-      "-------------------------------------\n",
-      "Masses:                      100.00 %\n",
-      "Pair Coeffs:                 100.00 %\n",
-      "Bond Coeffs:                 100.00 %\n",
-      "Angle Coeffs:                100.00 %\n",
-      "Dihedral Coeffs:             100.00 %\n",
-      "Improper Coeffs:             100.00 %\n",
-      "Average MPBADI Coeffs:       100.00 %\n",
-      "BondBond Coeffs:             14.29  %\n",
-      "BondAngle Coeffs:            14.29  %\n",
-      "AngleAngleTorsion Coeffs:    12.50  %\n",
-      "EndBondTorsion Coeffs:       12.50  %\n",
-      "MiddleBondTorsion Coeffs:    12.50  %\n",
-      "BondBond13 Coeffs:           12.50  %\n",
-      "AngleTorsion Coeffs:         12.50  %\n",
-      "AngleAngle Coeffs:           100.00 %\n",
-      "Average (without Bond-incs): 59.40  %\n",
-      "Bond-incs:                   100.00 %\n",
-      "\n",
-      "User is acknowledging that all2lmp.py can not supply a fully parameterized datafile as\n",
-      "the /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc doesnt contain all parameters\n",
-      "to parameterize every interaction. The user is responsible for deciding on how to handle\n",
-      "missing parameters in the written datafile. Please note that it is possible that the inputs\n",
-      "to all2lmp.py are incorrect causing this message and that a certain atom type maybe wrong, \n",
-      "where it might be easier to correct the inputs to all2lmp.py rather then correct the outputs\n",
-      "of all2lmp.py. Alternativley missing parameters are set to ZEROs, by all2lmp.py and it is\n",
-      "possible that interaction doesnt require parameters. For instance not all systems require\n",
-      "dihedral interactions.\n",
-      "\n",
-      "\n",
-      "Writing LAMMPS datafile\n",
-      "Writing verbose comment file\n",
-      "\n",
-      "\n",
-      "All outputs can be found in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp directory\n",
-      "\n",
-      "\n",
-      "Each energy coeff Header in the written datafile contains style hint flags for\n",
-      "applying proper settings in LAMMPS to be consistent with the energy definitions\n",
-      "and ordering of the energy parameters.\n",
-      "\n",
-      "\n",
-      "Normal program termination\n",
-      "\n",
-      "\n",
-      "Execution time in seconds: 0.05456662178039551\n",
-      "\n",
-      "\n",
-      "Number of WARNING(s) and ERROR(s)\n",
-      "  47 WARNING(s)\n",
-      "  0 ERROR(s)\n",
-      "\n",
-      "\n",
-      "Command line run option override checks (will warn if command line run option is used but not all options are provided at the command line):\n",
-      "WARNING override option   -asm               not provided at the command line. Hard coded input being enforced: frc_files/general_assumed_equivs.coeffs\n",
-      "WARNING override option   -newfile           not provided at the command line. Hard coded input being enforced: :_IFF\n",
-      "WARNING override option   -atomstyle         not provided at the command line. Hard coded input being enforced: full\n",
-      "WARNING override option   -class             not provided at the command line. Hard coded input being enforced: 2\n",
-      "WARNING override option   -auto-equivs       not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -assumed-equivs    not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -reset-molids      not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -reset-charges     not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -write-comments    not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -write-bond-react  not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -morse-bond        not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -type-labels       not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -add2box           not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -ignore            not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -rx                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -ry                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -rz                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sx                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sy                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sz                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "\n",
-      "\n",
-      "Command line run option override inputs confirmation (will confirm to user that the command line override does override the hard coded inputs):\n",
-      "Override confirmation for -topo              Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/mpd_typed.data\n",
-      "Override confirmation for -nta               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/mpd_typed.nta\n",
-      "Override confirmation for -frc               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc\n",
-      "Override confirmation for -dir               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Running all2lmp: v1.22 / 14 April 2025\n",
-      "Using Python version: 3.13.12 | packaged by conda-forge | (main, Feb  5 2026, 05:53:46) [GCC 14.3.0]\n",
-      "Using Python executable: /home/janitha/miniconda3/envs/autoRX/bin/python\n",
-      "Trying Atom Equivalences if needed\n",
-      "Trying Atom Auto-Equivalences if needed\n",
-      "Trying to find atom charge based on bond-incs\n",
-      "Resetting molecule-ids based on cluster analysis\n",
-      "\n",
-      "\n",
-      "Using higher version of parameters for #equivalences N a version: 2.10 \n",
-      "Using higher version of parameters for #bond_increments h si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments cp si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments si si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments c si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments c_1 cp version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c o_2 version: 2.20 \n",
-      "Using higher version of parameters for #quartic_bonds c c version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c= c=1 version: 3.10 \n",
-      "Using higher version of parameters for #quartic_bonds cp h version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c_1 o_1 version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c h version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds cp cp version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 c c c c version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 h c cp cp version: 2.00 \n",
-      "Using higher version of parameters for #torsion_3 h c c h version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 c c c h version: 2.10 \n",
-      "Using higher version of parameters for #wilson_out_of_plane c cp cp cp version: 2.00 \n",
-      "Using higher version of parameters for #wilson_out_of_plane cp cp cp h version: 3.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 o _ 1 version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 s ' version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 h o 2 version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 s i version: 2.20 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 c = version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 n = version: 3.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 n z version: 2.10 \n",
-      "Using higher version of parameters for #bondbond13 cp cp cp cp version: 2.10 \n",
-      "Using higher version of parameters for #middlebondtorsion o_1 c_1 o_2 c version: 2.10 \n",
-      "\n",
-      "Read in /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc forcefeild file\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/mpd_typed.data LAMMPS datafile\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/mpd_typed.nta new-type-assignment file\n",
-      "\n",
-      "\n",
-      "\n",
-      "Getting force field parameters for the read in system\n",
-      "\n",
-      "Checking for atom-type assignment consistency with atom-types in .frc file\n",
-      "\n",
-      "\n",
-      "Finding molecules to reset molids....\n",
-      "-----------------Cluster Analysis-----------------\n",
-      "  molID    Size of Fragment     %Size of Fragment    \n",
-      "--------------------------------------------------\n",
-      "    1              16               100.00          \n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Atoms information has been found\n",
-      "  /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/mpd_typed.data has all image flags set to zero\n",
-      "  There are 16 atoms in 1 molecules in this file\n",
-      "  The total charge in the system is -0.0000\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "---------------------------------------\n",
-      "System Unit cell, volume, mass, density\n",
-      "---------------------------------------\n",
-      "Lx:         7.38480   angstrom  \n",
-      "Ly:         5.95060   angstrom  \n",
-      "Lz:         2.52880   angstrom  \n",
-      "volume:    1.1113E-22 cm^3      \n",
-      "mass:      1.7958E-22 grams     \n",
-      "density:    1.61599   g/cm^3    \n",
-      "\n",
-      "\n",
-      "\n",
-      "--------------------------------------\n",
-      "Atoms/Bonds/Angles/Dihedrals/Impropers\n",
-      "--------------------------------------\n",
-      "natoms:             16  \n",
-      "nbonds:             16  \n",
-      "nangles:            24  \n",
-      "ndihedrals:         32  \n",
-      "nimpropers:          8  \n",
-      "- oop:               8  \n",
-      "- angleangle:        0  \n",
-      "\n",
-      "--------------------------------------------\n",
-      "Atoms/Bonds/Angles/Dihedrals/Impropers Types\n",
-      "--------------------------------------------\n",
-      "natomtypes:          4  \n",
-      "nbondtypes:          4  \n",
-      "nangletypes:         5  \n",
-      "ndihedraltypes:      6  \n",
-      "nimpropertypes:      3  \n",
-      "- oop:               3  \n",
-      "- angleangle:        0  \n",
-      "\n",
-      "-------------------------------------\n",
-      "Parameterization percentage breakdown\n",
-      "-------------------------------------\n",
-      "Masses:                      100.00 %\n",
-      "Pair Coeffs:                 100.00 %\n",
-      "Bond Coeffs:                 100.00 %\n",
-      "Angle Coeffs:                100.00 %\n",
-      "Dihedral Coeffs:             100.00 %\n",
-      "Improper Coeffs:             100.00 %\n",
-      "Average MPBADI Coeffs:       100.00 %\n",
-      "BondBond Coeffs:             100.00 %\n",
-      "BondAngle Coeffs:            100.00 %\n",
-      "AngleAngleTorsion Coeffs:    100.00 %\n",
-      "EndBondTorsion Coeffs:       100.00 %\n",
-      "MiddleBondTorsion Coeffs:    100.00 %\n",
-      "BondBond13 Coeffs:           100.00 %\n",
-      "AngleTorsion Coeffs:         100.00 %\n",
-      "AngleAngle Coeffs:           100.00 %\n",
-      "Average (without Bond-incs): 100.00 %\n",
-      "Bond-incs:                   100.00 %\n",
-      "\n",
-      "\n",
-      "Writing LAMMPS datafile\n",
-      "Writing verbose comment file\n",
-      "\n",
-      "\n",
-      "All outputs can be found in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp directory\n",
-      "\n",
-      "\n",
-      "Each energy coeff Header in the written datafile contains style hint flags for\n",
-      "applying proper settings in LAMMPS to be consistent with the energy definitions\n",
-      "and ordering of the energy parameters.\n",
-      "\n",
-      "\n",
-      "Normal program termination\n",
-      "\n",
-      "\n",
-      "Execution time in seconds: 0.048662662506103516\n",
-      "\n",
-      "\n",
-      "Number of WARNING(s) and ERROR(s)\n",
-      "  0 WARNING(s)\n",
-      "  0 ERROR(s)\n",
-      "\n",
-      "\n",
-      "Command line run option override checks (will warn if command line run option is used but not all options are provided at the command line):\n",
-      "WARNING override option   -asm               not provided at the command line. Hard coded input being enforced: frc_files/general_assumed_equivs.coeffs\n",
-      "WARNING override option   -newfile           not provided at the command line. Hard coded input being enforced: :_IFF\n",
-      "WARNING override option   -atomstyle         not provided at the command line. Hard coded input being enforced: full\n",
-      "WARNING override option   -class             not provided at the command line. Hard coded input being enforced: 2\n",
-      "WARNING override option   -auto-equivs       not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -assumed-equivs    not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -reset-molids      not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -reset-charges     not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -write-comments    not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -write-bond-react  not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -morse-bond        not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -type-labels       not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -add2box           not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -ignore            not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -rx                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -ry                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -rz                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sx                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sy                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sz                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "\n",
-      "\n",
-      "Command line run option override inputs confirmation (will confirm to user that the command line override does override the hard coded inputs):\n",
-      "Override confirmation for -topo              Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/ethanol_typed.data\n",
-      "Override confirmation for -nta               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/ethanol_typed.nta\n",
-      "Override confirmation for -frc               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc\n",
-      "Override confirmation for -dir               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Running all2lmp: v1.22 / 14 April 2025\n",
-      "Using Python version: 3.13.12 | packaged by conda-forge | (main, Feb  5 2026, 05:53:46) [GCC 14.3.0]\n",
-      "Using Python executable: /home/janitha/miniconda3/envs/autoRX/bin/python\n",
-      "Trying Atom Equivalences if needed\n",
-      "Trying Atom Auto-Equivalences if needed\n",
-      "Trying to find atom charge based on bond-incs\n",
-      "Resetting molecule-ids based on cluster analysis\n",
-      "\n",
-      "\n",
-      "Using higher version of parameters for #equivalences N a version: 2.10 \n",
-      "Using higher version of parameters for #bond_increments c si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments c_1 cp version: 2.10 \n",
-      "Using higher version of parameters for #bond_increments si si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments h si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments cp si version: 2.20 \n",
-      "Using higher version of parameters for #quartic_bonds c c version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c_1 o_1 version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c= c=1 version: 3.10 \n",
-      "Using higher version of parameters for #quartic_bonds cp cp version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds cp h version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c o_2 version: 2.20 \n",
-      "Using higher version of parameters for #quartic_bonds c h version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 h c cp cp version: 2.00 \n",
-      "Using higher version of parameters for #torsion_3 c c c h version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 h c c h version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 c c c c version: 2.10 \n",
-      "Using higher version of parameters for #wilson_out_of_plane cp cp cp h version: 3.10 \n",
-      "Using higher version of parameters for #wilson_out_of_plane c cp cp cp version: 2.00 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 h o 2 version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 n z version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 s ' version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 n = version: 3.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 o _ 1 version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 c = version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 s i version: 2.20 \n",
-      "Using higher version of parameters for #bondbond13 cp cp cp cp version: 2.10 \n",
-      "Using higher version of parameters for #middlebondtorsion o_1 c_1 o_2 c version: 2.10 \n",
-      "\n",
-      "Read in /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc forcefeild file\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/ethanol_typed.data LAMMPS datafile\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/ethanol_typed.nta new-type-assignment file\n",
-      "\n",
-      "\n",
-      "\n",
-      "Getting force field parameters for the read in system\n",
-      "\n",
-      "Checking for atom-type assignment consistency with atom-types in .frc file\n",
-      "\n",
-      "\n",
-      "Finding molecules to reset molids....\n",
-      "-----------------Cluster Analysis-----------------\n",
-      "  molID    Size of Fragment     %Size of Fragment    \n",
-      "--------------------------------------------------\n",
-      "    1               9               100.00          \n",
-      "\n",
-      "\n",
-      "WARNING No Bond Increment for atom 3 and atom 9, bond pair oh ho2 \n",
-      "WARNING No Bond Increment for atom 9 and atom 3, bond pair ho2 oh \n",
-      "\n",
-      "\n",
-      "Atoms information has been found\n",
-      "  /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/ethanol_typed.data has all image flags set to zero\n",
-      "  There are 9 atoms in 1 molecules in this file\n",
-      "  The total charge in the system is -0.0000\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 2 c2 oh ho2\n",
-      "\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 2 c2 oh ho2\n",
-      "\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 2 c3 c2 oh ho2\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 3 hc c2 oh ho2\n",
-      "\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 2 c3 c2 oh ho2\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 3 hc c2 oh ho2\n",
-      "\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 2 c3 c2 oh ho2\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 3 hc c2 oh ho2\n",
-      "\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 1 hc c2 c3 hc\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 2 c3 c2 oh ho2\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 3 hc c2 oh ho2\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 4 hc c3 c2 oh\n",
-      "\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 2 c3 c2 oh ho2\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 3 hc c2 oh ho2\n",
-      "\n",
-      "\n",
-      "---------------------------------------\n",
-      "System Unit cell, volume, mass, density\n",
-      "---------------------------------------\n",
-      "Lx:         4.07350   angstrom  \n",
-      "Ly:         3.21200   angstrom  \n",
-      "Lz:         2.96390   angstrom  \n",
-      "volume:    3.8780E-23 cm^3      \n",
-      "mass:      7.6500E-23 grams     \n",
-      "density:    1.97268   g/cm^3    \n",
-      "\n",
-      "\n",
-      "\n",
-      "--------------------------------------\n",
-      "Atoms/Bonds/Angles/Dihedrals/Impropers\n",
-      "--------------------------------------\n",
-      "natoms:              9  \n",
-      "nbonds:              8  \n",
-      "nangles:            13  \n",
-      "ndihedrals:         12  \n",
-      "nimpropers:          8  \n",
-      "- oop:               0  \n",
-      "- angleangle:        8  \n",
-      "\n",
-      "--------------------------------------------\n",
-      "Atoms/Bonds/Angles/Dihedrals/Impropers Types\n",
-      "--------------------------------------------\n",
-      "natomtypes:          5  \n",
-      "nbondtypes:          5  \n",
-      "nangletypes:         7  \n",
-      "ndihedraltypes:      4  \n",
-      "nimpropertypes:      5  \n",
-      "- oop:               0  \n",
-      "- angleangle:        5  \n",
-      "\n",
-      "-------------------------------------\n",
-      "Parameterization percentage breakdown\n",
-      "-------------------------------------\n",
-      "Masses:                      100.00 %\n",
-      "Pair Coeffs:                 100.00 %\n",
-      "Bond Coeffs:                 100.00 %\n",
-      "Angle Coeffs:                100.00 %\n",
-      "Dihedral Coeffs:             100.00 %\n",
-      "Improper Coeffs:             100.00 %\n",
-      "Average MPBADI Coeffs:       100.00 %\n",
-      "BondBond Coeffs:             85.71  %\n",
-      "BondAngle Coeffs:            85.71  %\n",
-      "AngleAngleTorsion Coeffs:    50.00  %\n",
-      "EndBondTorsion Coeffs:       50.00  %\n",
-      "MiddleBondTorsion Coeffs:    50.00  %\n",
-      "BondBond13 Coeffs:            0.00  %\n",
-      "AngleTorsion Coeffs:         50.00  %\n",
-      "AngleAngle Coeffs:           100.00 %\n",
-      "Average (without Bond-incs): 78.10  %\n",
-      "Bond-incs:                   87.50  %\n",
-      "\n",
-      "User is acknowledging that all2lmp.py can not supply a fully parameterized datafile as\n",
-      "the /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc doesnt contain all parameters\n",
-      "to parameterize every interaction. The user is responsible for deciding on how to handle\n",
-      "missing parameters in the written datafile. Please note that it is possible that the inputs\n",
-      "to all2lmp.py are incorrect causing this message and that a certain atom type maybe wrong, \n",
-      "where it might be easier to correct the inputs to all2lmp.py rather then correct the outputs\n",
-      "of all2lmp.py. Alternativley missing parameters are set to ZEROs, by all2lmp.py and it is\n",
-      "possible that interaction doesnt require parameters. For instance not all systems require\n",
-      "dihedral interactions.\n",
-      "\n",
-      "\n",
-      "Writing LAMMPS datafile\n",
-      "Writing verbose comment file\n",
-      "\n",
-      "\n",
-      "All outputs can be found in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp directory\n",
-      "\n",
-      "\n",
-      "Each energy coeff Header in the written datafile contains style hint flags for\n",
-      "applying proper settings in LAMMPS to be consistent with the energy definitions\n",
-      "and ordering of the energy parameters.\n",
-      "\n",
-      "\n",
-      "Normal program termination\n",
-      "\n",
-      "\n",
-      "Execution time in seconds: 0.04845619201660156\n",
-      "\n",
-      "\n",
-      "Number of WARNING(s) and ERROR(s)\n",
-      "  16 WARNING(s)\n",
-      "  0 ERROR(s)\n",
-      "\n",
-      "\n",
-      "Command line run option override checks (will warn if command line run option is used but not all options are provided at the command line):\n",
-      "WARNING override option   -asm               not provided at the command line. Hard coded input being enforced: frc_files/general_assumed_equivs.coeffs\n",
-      "WARNING override option   -newfile           not provided at the command line. Hard coded input being enforced: :_IFF\n",
-      "WARNING override option   -atomstyle         not provided at the command line. Hard coded input being enforced: full\n",
-      "WARNING override option   -class             not provided at the command line. Hard coded input being enforced: 2\n",
-      "WARNING override option   -auto-equivs       not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -assumed-equivs    not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -reset-molids      not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -reset-charges     not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -write-comments    not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -write-bond-react  not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -morse-bond        not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -type-labels       not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -add2box           not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -ignore            not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -rx                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -ry                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -rz                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sx                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sy                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sz                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "\n",
-      "\n",
-      "Command line run option override inputs confirmation (will confirm to user that the command line override does override the hard coded inputs):\n",
-      "Override confirmation for -topo              Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre1/pre1_typed.data\n",
-      "Override confirmation for -nta               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre1/pre1_typed.nta\n",
-      "Override confirmation for -frc               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc\n",
-      "Override confirmation for -dir               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Running all2lmp: v1.22 / 14 April 2025\n",
-      "Using Python version: 3.13.12 | packaged by conda-forge | (main, Feb  5 2026, 05:53:46) [GCC 14.3.0]\n",
-      "Using Python executable: /home/janitha/miniconda3/envs/autoRX/bin/python\n",
-      "Trying Atom Equivalences if needed\n",
-      "Trying Atom Auto-Equivalences if needed\n",
-      "Trying to find atom charge based on bond-incs\n",
-      "Resetting molecule-ids based on cluster analysis\n",
-      "\n",
-      "\n",
-      "Using higher version of parameters for #equivalences N a version: 2.10 \n",
-      "Using higher version of parameters for #bond_increments cp si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments si si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments c_1 cp version: 2.10 \n",
-      "Using higher version of parameters for #bond_increments c si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments h si version: 2.20 \n",
-      "Using higher version of parameters for #quartic_bonds c c version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c o_2 version: 2.20 \n",
-      "Using higher version of parameters for #quartic_bonds cp cp version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds cp h version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c_1 o_1 version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c= c=1 version: 3.10 \n",
-      "Using higher version of parameters for #quartic_bonds c h version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 c c c c version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 c c c h version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 h c cp cp version: 2.00 \n",
-      "Using higher version of parameters for #torsion_3 h c c h version: 2.10 \n",
-      "Using higher version of parameters for #wilson_out_of_plane cp cp cp h version: 3.10 \n",
-      "Using higher version of parameters for #wilson_out_of_plane c cp cp cp version: 2.00 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 n = version: 3.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 n z version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 s i version: 2.20 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 c = version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 o _ 1 version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 s ' version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 h o 2 version: 2.10 \n",
-      "Using higher version of parameters for #bondbond13 cp cp cp cp version: 2.10 \n",
-      "Using higher version of parameters for #middlebondtorsion o_1 c_1 o_2 c version: 2.10 \n",
-      "\n",
-      "Read in /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc forcefeild file\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre1/pre1_typed.data LAMMPS datafile\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre1/pre1_typed.nta new-type-assignment file\n",
-      "\n",
-      "\n",
-      "\n",
-      "Getting force field parameters for the read in system\n",
-      "\n",
-      "Checking for atom-type assignment consistency with atom-types in .frc file\n",
-      "\n",
-      "\n",
-      "Finding molecules to reset molids....\n",
-      "-----------------Cluster Analysis-----------------\n",
-      "  molID    Size of Fragment     %Size of Fragment    \n",
-      "--------------------------------------------------\n",
-      "    1              18                52.94          \n",
-      "    2              16                47.06          \n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Atoms information has been found\n",
-      "  /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre1/pre1_typed.data has all image flags set to zero\n",
-      "  There are 34 atoms in 2 molecules in this file\n",
-      "  The total charge in the system is -0.0000\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 1 br cp cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 2 c= cp cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 3 cl c= cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 4 cl c= o_1\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 5 cl cp cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 6 cp c= o_1\n",
-      "\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 1 br cp cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 2 c= cp cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 3 cl c= cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 4 cl c= o_1\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 5 cl cp cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 6 cp c= o_1\n",
-      "\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 2 o_1 c= cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 3 br cp cp c=\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 4 c= cp cp cl\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 5 c= cp cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 6 br cp cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 8 cl cp cp cp\n",
-      "\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 2 o_1 c= cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 3 br cp cp c=\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 4 c= cp cp cl\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 5 c= cp cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 6 br cp cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 8 cl cp cp cp\n",
-      "\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 2 o_1 c= cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 3 br cp cp c=\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 4 c= cp cp cl\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 5 c= cp cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 6 br cp cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 8 cl cp cp cp\n",
-      "\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 2 o_1 c= cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 3 br cp cp c=\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 4 c= cp cp cl\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 5 c= cp cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 6 br cp cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 8 cl cp cp cp\n",
-      "\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 2 o_1 c= cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 3 br cp cp c=\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 4 c= cp cp cl\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 5 c= cp cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 6 br cp cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 8 cl cp cp cp\n",
-      "\n",
-      "\n",
-      "---------------------------------------\n",
-      "System Unit cell, volume, mass, density\n",
-      "---------------------------------------\n",
-      "Lx:         31.19580  angstrom  \n",
-      "Ly:         7.91240   angstrom  \n",
-      "Lz:         5.08430   angstrom  \n",
-      "volume:    1.2550E-21 cm^3      \n",
-      "mass:      8.6583E-22 grams     \n",
-      "density:    0.68992   g/cm^3    \n",
-      "\n",
-      "\n",
-      "\n",
-      "--------------------------------------\n",
-      "Atoms/Bonds/Angles/Dihedrals/Impropers\n",
-      "--------------------------------------\n",
-      "natoms:             34  \n",
-      "nbonds:             34  \n",
-      "nangles:            51  \n",
-      "ndihedrals:         68  \n",
-      "nimpropers:         17  \n",
-      "- oop:              17  \n",
-      "- angleangle:        0  \n",
-      "\n",
-      "--------------------------------------------\n",
-      "Atoms/Bonds/Angles/Dihedrals/Impropers Types\n",
-      "--------------------------------------------\n",
-      "natomtypes:          8  \n",
-      "nbondtypes:          9  \n",
-      "nangletypes:        11  \n",
-      "ndihedraltypes:     13  \n",
-      "nimpropertypes:      7  \n",
-      "- oop:               7  \n",
-      "- angleangle:        0  \n",
-      "\n",
-      "-------------------------------------\n",
-      "Parameterization percentage breakdown\n",
-      "-------------------------------------\n",
-      "Masses:                      100.00 %\n",
-      "Pair Coeffs:                 100.00 %\n",
-      "Bond Coeffs:                 100.00 %\n",
-      "Angle Coeffs:                100.00 %\n",
-      "Dihedral Coeffs:             100.00 %\n",
-      "Improper Coeffs:             100.00 %\n",
-      "Average MPBADI Coeffs:       100.00 %\n",
-      "BondBond Coeffs:             45.45  %\n",
-      "BondAngle Coeffs:            45.45  %\n",
-      "AngleAngleTorsion Coeffs:    46.15  %\n",
-      "EndBondTorsion Coeffs:       46.15  %\n",
-      "MiddleBondTorsion Coeffs:    46.15  %\n",
-      "BondBond13 Coeffs:           46.15  %\n",
-      "AngleTorsion Coeffs:         46.15  %\n",
-      "AngleAngle Coeffs:           100.00 %\n",
-      "Average (without Bond-incs): 74.78  %\n",
-      "Bond-incs:                   100.00 %\n",
-      "\n",
-      "User is acknowledging that all2lmp.py can not supply a fully parameterized datafile as\n",
-      "the /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc doesnt contain all parameters\n",
-      "to parameterize every interaction. The user is responsible for deciding on how to handle\n",
-      "missing parameters in the written datafile. Please note that it is possible that the inputs\n",
-      "to all2lmp.py are incorrect causing this message and that a certain atom type maybe wrong, \n",
-      "where it might be easier to correct the inputs to all2lmp.py rather then correct the outputs\n",
-      "of all2lmp.py. Alternativley missing parameters are set to ZEROs, by all2lmp.py and it is\n",
-      "possible that interaction doesnt require parameters. For instance not all systems require\n",
-      "dihedral interactions.\n",
-      "\n",
-      "\n",
-      "Writing LAMMPS datafile\n",
-      "Writing verbose comment file\n",
-      "\n",
-      "\n",
-      "All outputs can be found in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp directory\n",
-      "\n",
-      "\n",
-      "Each energy coeff Header in the written datafile contains style hint flags for\n",
-      "applying proper settings in LAMMPS to be consistent with the energy definitions\n",
-      "and ordering of the energy parameters.\n",
-      "\n",
-      "\n",
-      "Normal program termination\n",
-      "\n",
-      "\n",
-      "Execution time in seconds: 0.058083295822143555\n",
-      "\n",
-      "\n",
-      "Number of WARNING(s) and ERROR(s)\n",
-      "  47 WARNING(s)\n",
-      "  0 ERROR(s)\n",
-      "\n",
-      "\n",
-      "Command line run option override checks (will warn if command line run option is used but not all options are provided at the command line):\n",
-      "WARNING override option   -asm               not provided at the command line. Hard coded input being enforced: frc_files/general_assumed_equivs.coeffs\n",
-      "WARNING override option   -newfile           not provided at the command line. Hard coded input being enforced: :_IFF\n",
-      "WARNING override option   -atomstyle         not provided at the command line. Hard coded input being enforced: full\n",
-      "WARNING override option   -class             not provided at the command line. Hard coded input being enforced: 2\n",
-      "WARNING override option   -auto-equivs       not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -assumed-equivs    not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -reset-molids      not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -reset-charges     not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -write-comments    not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -write-bond-react  not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -morse-bond        not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -type-labels       not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -add2box           not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -ignore            not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -rx                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -ry                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -rz                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sx                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sy                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sz                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "\n",
-      "\n",
-      "Command line run option override inputs confirmation (will confirm to user that the command line override does override the hard coded inputs):\n",
-      "Override confirmation for -topo              Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post1/post1_typed.data\n",
-      "Override confirmation for -nta               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post1/post1_typed.nta\n",
-      "Override confirmation for -frc               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc\n",
-      "Override confirmation for -dir               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Running all2lmp: v1.22 / 14 April 2025\n",
-      "Using Python version: 3.13.12 | packaged by conda-forge | (main, Feb  5 2026, 05:53:46) [GCC 14.3.0]\n",
-      "Using Python executable: /home/janitha/miniconda3/envs/autoRX/bin/python\n",
-      "Trying Atom Equivalences if needed\n",
-      "Trying Atom Auto-Equivalences if needed\n",
-      "Trying to find atom charge based on bond-incs\n",
-      "Resetting molecule-ids based on cluster analysis\n",
-      "\n",
-      "\n",
-      "Using higher version of parameters for #equivalences N a version: 2.10 \n",
-      "Using higher version of parameters for #bond_increments h si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments si si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments cp si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments c_1 cp version: 2.10 \n",
-      "Using higher version of parameters for #bond_increments c si version: 2.20 \n",
-      "Using higher version of parameters for #quartic_bonds c c version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c= c=1 version: 3.10 \n",
-      "Using higher version of parameters for #quartic_bonds cp cp version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c h version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds cp h version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c o_2 version: 2.20 \n",
-      "Using higher version of parameters for #quartic_bonds c_1 o_1 version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 c c c h version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 h c c h version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 c c c c version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 h c cp cp version: 2.00 \n",
-      "Using higher version of parameters for #wilson_out_of_plane c cp cp cp version: 2.00 \n",
-      "Using higher version of parameters for #wilson_out_of_plane cp cp cp h version: 3.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 s ' version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 n = version: 3.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 o _ 1 version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 h o 2 version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 c = version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 s i version: 2.20 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 n z version: 2.10 \n",
-      "Using higher version of parameters for #bondbond13 cp cp cp cp version: 2.10 \n",
-      "Using higher version of parameters for #middlebondtorsion o_1 c_1 o_2 c version: 2.10 \n",
-      "\n",
-      "Read in /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc forcefeild file\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post1/post1_typed.data LAMMPS datafile\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post1/post1_typed.nta new-type-assignment file\n",
-      "\n",
-      "\n",
-      "\n",
-      "Getting force field parameters for the read in system\n",
-      "\n",
-      "Checking for atom-type assignment consistency with atom-types in .frc file\n",
-      "\n",
-      "\n",
-      "Finding molecules to reset molids....\n",
-      "-----------------Cluster Analysis-----------------\n",
-      "  molID    Size of Fragment     %Size of Fragment    \n",
-      "--------------------------------------------------\n",
-      "    1              32                94.12          \n",
-      "    2               2                5.88           \n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Atoms information has been found\n",
-      "  /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post1/post1_typed.data has all image flags set to zero\n",
-      "  There are 34 atoms in 2 molecules in this file\n",
-      "  The total charge in the system is 0.0000\n",
-      "\n",
-      "\n",
-      "WARNING unable to find bond info for Bond Coeff 6 c_1 nn\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 1 br cp cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 2 c= cp cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 4 c_1 nn cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 5 c_1 nn hn\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 6 cl c= cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 7 cl c= o_1\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 8 cl cp cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 9 cp c= o_1\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 10 cp c_1 nn\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 17 nn c_1 o_1\n",
-      "\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 1 br cp cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 2 c= cp cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 4 c_1 nn cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 5 c_1 nn hn\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 6 cl c= cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 7 cl c= o_1\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 8 cl cp cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 9 cp c= o_1\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 10 cp c_1 nn\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 17 nn c_1 o_1\n",
-      "\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 2 cp c_1 nn cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 3 cp c_1 nn hn\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 4 o_1 c= cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 5 nn c_1 cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 6 o_1 c_1 cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 7 br cp cp c=\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 8 c_1 cp cp cl\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 9 c= cp cp cl\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 10 cl cp cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 12 br cp cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 13 c_1 cp cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 14 c= cp cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 20 o_1 c_1 nn hn\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 21 o_1 c_1 nn cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 22 cp cp nn c_1\n",
-      "\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 2 cp c_1 nn cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 3 cp c_1 nn hn\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 4 o_1 c= cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 5 nn c_1 cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 6 o_1 c_1 cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 7 br cp cp c=\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 8 c_1 cp cp cl\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 9 c= cp cp cl\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 10 cl cp cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 12 br cp cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 13 c_1 cp cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 14 c= cp cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 20 o_1 c_1 nn hn\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 21 o_1 c_1 nn cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 22 cp cp nn c_1\n",
-      "\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 2 cp c_1 nn cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 3 cp c_1 nn hn\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 4 o_1 c= cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 5 nn c_1 cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 7 br cp cp c=\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 8 c_1 cp cp cl\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 9 c= cp cp cl\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 10 cl cp cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 12 br cp cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 14 c= cp cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 20 o_1 c_1 nn hn\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 21 o_1 c_1 nn cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 22 cp cp nn c_1\n",
-      "\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 2 cp c_1 nn cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 3 cp c_1 nn hn\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 4 o_1 c= cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 5 nn c_1 cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 6 o_1 c_1 cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 7 br cp cp c=\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 8 c_1 cp cp cl\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 9 c= cp cp cl\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 10 cl cp cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 12 br cp cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 13 c_1 cp cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 14 c= cp cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 20 o_1 c_1 nn hn\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 21 o_1 c_1 nn cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 22 cp cp nn c_1\n",
-      "\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 2 cp c_1 nn cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 3 cp c_1 nn hn\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 4 o_1 c= cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 5 nn c_1 cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 6 o_1 c_1 cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 7 br cp cp c=\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 8 c_1 cp cp cl\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 9 c= cp cp cl\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 10 cl cp cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 12 br cp cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 13 c_1 cp cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 14 c= cp cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 20 o_1 c_1 nn hn\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 21 o_1 c_1 nn cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 22 cp cp nn c_1\n",
-      "\n",
-      "\n",
-      "---------------------------------------\n",
-      "System Unit cell, volume, mass, density\n",
-      "---------------------------------------\n",
-      "Lx:         32.27590  angstrom  \n",
-      "Ly:         7.85860   angstrom  \n",
-      "Lz:         4.78470   angstrom  \n",
-      "volume:    1.2136E-21 cm^3      \n",
-      "mass:      8.6583E-22 grams     \n",
-      "density:    0.71344   g/cm^3    \n",
-      "\n",
-      "\n",
-      "\n",
-      "--------------------------------------\n",
-      "Atoms/Bonds/Angles/Dihedrals/Impropers\n",
-      "--------------------------------------\n",
-      "natoms:             34  \n",
-      "nbonds:             34  \n",
-      "nangles:            51  \n",
-      "ndihedrals:         72  \n",
-      "nimpropers:         17  \n",
-      "- oop:              17  \n",
-      "- angleangle:        0  \n",
-      "\n",
-      "--------------------------------------------\n",
-      "Atoms/Bonds/Angles/Dihedrals/Impropers Types\n",
-      "--------------------------------------------\n",
-      "natomtypes:         10  \n",
-      "nbondtypes:         13  \n",
-      "nangletypes:        17  \n",
-      "ndihedraltypes:     22  \n",
-      "nimpropertypes:     10  \n",
-      "- oop:              10  \n",
-      "- angleangle:        0  \n",
-      "\n",
-      "-------------------------------------\n",
-      "Parameterization percentage breakdown\n",
-      "-------------------------------------\n",
-      "Masses:                      100.00 %\n",
-      "Pair Coeffs:                 100.00 %\n",
-      "Bond Coeffs:                 92.31  %\n",
-      "Angle Coeffs:                100.00 %\n",
-      "Dihedral Coeffs:             100.00 %\n",
-      "Improper Coeffs:             100.00 %\n",
-      "Average MPBADI Coeffs:       98.72  %\n",
-      "BondBond Coeffs:             41.18  %\n",
-      "BondAngle Coeffs:            41.18  %\n",
-      "AngleAngleTorsion Coeffs:    27.27  %\n",
-      "EndBondTorsion Coeffs:       27.27  %\n",
-      "MiddleBondTorsion Coeffs:    36.36  %\n",
-      "BondBond13 Coeffs:           27.27  %\n",
-      "AngleTorsion Coeffs:         27.27  %\n",
-      "AngleAngle Coeffs:           100.00 %\n",
-      "Average (without Bond-incs): 67.92  %\n",
-      "Bond-incs:                   100.00 %\n",
-      "\n",
-      "User is acknowledging that all2lmp.py can not supply a fully parameterized datafile as\n",
-      "the /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc doesnt contain all parameters\n",
-      "to parameterize every interaction. The user is responsible for deciding on how to handle\n",
-      "missing parameters in the written datafile. Please note that it is possible that the inputs\n",
-      "to all2lmp.py are incorrect causing this message and that a certain atom type maybe wrong, \n",
-      "where it might be easier to correct the inputs to all2lmp.py rather then correct the outputs\n",
-      "of all2lmp.py. Alternativley missing parameters are set to ZEROs, by all2lmp.py and it is\n",
-      "possible that interaction doesnt require parameters. For instance not all systems require\n",
-      "dihedral interactions.\n",
-      "\n",
-      "\n",
-      "Writing LAMMPS datafile\n",
-      "Writing verbose comment file\n",
-      "\n",
-      "\n",
-      "All outputs can be found in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp directory\n",
-      "\n",
-      "\n",
-      "Each energy coeff Header in the written datafile contains style hint flags for\n",
-      "applying proper settings in LAMMPS to be consistent with the energy definitions\n",
-      "and ordering of the energy parameters.\n",
-      "\n",
-      "\n",
-      "Normal program termination\n",
-      "\n",
-      "\n",
-      "Execution time in seconds: 0.05606555938720703\n",
-      "\n",
-      "\n",
-      "Number of WARNING(s) and ERROR(s)\n",
-      "  99 WARNING(s)\n",
-      "  0 ERROR(s)\n",
-      "\n",
-      "\n",
-      "Command line run option override checks (will warn if command line run option is used but not all options are provided at the command line):\n",
-      "WARNING override option   -asm               not provided at the command line. Hard coded input being enforced: frc_files/general_assumed_equivs.coeffs\n",
-      "WARNING override option   -newfile           not provided at the command line. Hard coded input being enforced: :_IFF\n",
-      "WARNING override option   -atomstyle         not provided at the command line. Hard coded input being enforced: full\n",
-      "WARNING override option   -class             not provided at the command line. Hard coded input being enforced: 2\n",
-      "WARNING override option   -auto-equivs       not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -assumed-equivs    not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -reset-molids      not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -reset-charges     not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -write-comments    not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -write-bond-react  not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -morse-bond        not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -type-labels       not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -add2box           not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -ignore            not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -rx                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -ry                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -rz                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sx                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sy                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sz                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "\n",
-      "\n",
-      "Command line run option override inputs confirmation (will confirm to user that the command line override does override the hard coded inputs):\n",
-      "Override confirmation for -topo              Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre5/pre5_typed.data\n",
-      "Override confirmation for -nta               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre5/pre5_typed.nta\n",
-      "Override confirmation for -frc               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc\n",
-      "Override confirmation for -dir               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Running all2lmp: v1.22 / 14 April 2025\n",
-      "Using Python version: 3.13.12 | packaged by conda-forge | (main, Feb  5 2026, 05:53:46) [GCC 14.3.0]\n",
-      "Using Python executable: /home/janitha/miniconda3/envs/autoRX/bin/python\n",
-      "Trying Atom Equivalences if needed\n",
-      "Trying Atom Auto-Equivalences if needed\n",
-      "Trying to find atom charge based on bond-incs\n",
-      "Resetting molecule-ids based on cluster analysis\n",
-      "\n",
-      "\n",
-      "Using higher version of parameters for #equivalences N a version: 2.10 \n",
-      "Using higher version of parameters for #bond_increments cp si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments h si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments c si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments c_1 cp version: 2.10 \n",
-      "Using higher version of parameters for #bond_increments si si version: 2.20 \n",
-      "Using higher version of parameters for #quartic_bonds c c version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds cp h version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c h version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c_1 o_1 version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c o_2 version: 2.20 \n",
-      "Using higher version of parameters for #quartic_bonds cp cp version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c= c=1 version: 3.10 \n",
-      "Using higher version of parameters for #torsion_3 h c cp cp version: 2.00 \n",
-      "Using higher version of parameters for #torsion_3 c c c c version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 c c c h version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 h c c h version: 2.10 \n",
-      "Using higher version of parameters for #wilson_out_of_plane cp cp cp h version: 3.10 \n",
-      "Using higher version of parameters for #wilson_out_of_plane c cp cp cp version: 2.00 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 s i version: 2.20 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 h o 2 version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 n z version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 c = version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 o _ 1 version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 n = version: 3.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 s ' version: 2.10 \n",
-      "Using higher version of parameters for #bondbond13 cp cp cp cp version: 2.10 \n",
-      "Using higher version of parameters for #middlebondtorsion o_1 c_1 o_2 c version: 2.10 \n",
-      "\n",
-      "Read in /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc forcefeild file\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre5/pre5_typed.data LAMMPS datafile\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre5/pre5_typed.nta new-type-assignment file\n",
-      "\n",
-      "\n",
-      "\n",
-      "Getting force field parameters for the read in system\n",
-      "\n",
-      "Checking for atom-type assignment consistency with atom-types in .frc file\n",
-      "\n",
-      "\n",
-      "Finding molecules to reset molids....\n",
-      "-----------------Cluster Analysis-----------------\n",
-      "  molID    Size of Fragment     %Size of Fragment    \n",
-      "--------------------------------------------------\n",
-      "    1              18                52.94          \n",
-      "    2              16                47.06          \n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Atoms information has been found\n",
-      "  /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/pre5/pre5_typed.data has all image flags set to zero\n",
-      "  There are 34 atoms in 2 molecules in this file\n",
-      "  The total charge in the system is -0.0000\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 1 br cp cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 2 c= cp cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 3 cl c= cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 4 cl c= o_1\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 5 cl cp cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 6 cp c= o_1\n",
-      "\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 1 br cp cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 2 c= cp cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 3 cl c= cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 4 cl c= o_1\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 5 cl cp cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 6 cp c= o_1\n",
-      "\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 2 o_1 c= cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 3 br cp cp c=\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 4 c= cp cp cl\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 6 br cp cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 7 c= cp cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 8 cl cp cp cp\n",
-      "\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 2 o_1 c= cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 3 br cp cp c=\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 4 c= cp cp cl\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 6 br cp cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 7 c= cp cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 8 cl cp cp cp\n",
-      "\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 2 o_1 c= cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 3 br cp cp c=\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 4 c= cp cp cl\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 6 br cp cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 7 c= cp cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 8 cl cp cp cp\n",
-      "\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 2 o_1 c= cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 3 br cp cp c=\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 4 c= cp cp cl\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 6 br cp cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 7 c= cp cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 8 cl cp cp cp\n",
-      "\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 2 o_1 c= cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 3 br cp cp c=\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 4 c= cp cp cl\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 6 br cp cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 7 c= cp cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 8 cl cp cp cp\n",
-      "\n",
-      "\n",
-      "---------------------------------------\n",
-      "System Unit cell, volume, mass, density\n",
-      "---------------------------------------\n",
-      "Lx:         31.10360  angstrom  \n",
-      "Ly:         7.61230   angstrom  \n",
-      "Lz:         6.58880   angstrom  \n",
-      "volume:    1.5600E-21 cm^3      \n",
-      "mass:      8.6583E-22 grams     \n",
-      "density:    0.55501   g/cm^3    \n",
-      "\n",
-      "\n",
-      "\n",
-      "--------------------------------------\n",
-      "Atoms/Bonds/Angles/Dihedrals/Impropers\n",
-      "--------------------------------------\n",
-      "natoms:             34  \n",
-      "nbonds:             34  \n",
-      "nangles:            51  \n",
-      "ndihedrals:         68  \n",
-      "nimpropers:         17  \n",
-      "- oop:              17  \n",
-      "- angleangle:        0  \n",
-      "\n",
-      "--------------------------------------------\n",
-      "Atoms/Bonds/Angles/Dihedrals/Impropers Types\n",
-      "--------------------------------------------\n",
-      "natomtypes:          8  \n",
-      "nbondtypes:          9  \n",
-      "nangletypes:        11  \n",
-      "ndihedraltypes:     13  \n",
-      "nimpropertypes:      7  \n",
-      "- oop:               7  \n",
-      "- angleangle:        0  \n",
-      "\n",
-      "-------------------------------------\n",
-      "Parameterization percentage breakdown\n",
-      "-------------------------------------\n",
-      "Masses:                      100.00 %\n",
-      "Pair Coeffs:                 100.00 %\n",
-      "Bond Coeffs:                 100.00 %\n",
-      "Angle Coeffs:                100.00 %\n",
-      "Dihedral Coeffs:             100.00 %\n",
-      "Improper Coeffs:             100.00 %\n",
-      "Average MPBADI Coeffs:       100.00 %\n",
-      "BondBond Coeffs:             45.45  %\n",
-      "BondAngle Coeffs:            45.45  %\n",
-      "AngleAngleTorsion Coeffs:    46.15  %\n",
-      "EndBondTorsion Coeffs:       46.15  %\n",
-      "MiddleBondTorsion Coeffs:    46.15  %\n",
-      "BondBond13 Coeffs:           46.15  %\n",
-      "AngleTorsion Coeffs:         46.15  %\n",
-      "AngleAngle Coeffs:           100.00 %\n",
-      "Average (without Bond-incs): 74.78  %\n",
-      "Bond-incs:                   100.00 %\n",
-      "\n",
-      "User is acknowledging that all2lmp.py can not supply a fully parameterized datafile as\n",
-      "the /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc doesnt contain all parameters\n",
-      "to parameterize every interaction. The user is responsible for deciding on how to handle\n",
-      "missing parameters in the written datafile. Please note that it is possible that the inputs\n",
-      "to all2lmp.py are incorrect causing this message and that a certain atom type maybe wrong, \n",
-      "where it might be easier to correct the inputs to all2lmp.py rather then correct the outputs\n",
-      "of all2lmp.py. Alternativley missing parameters are set to ZEROs, by all2lmp.py and it is\n",
-      "possible that interaction doesnt require parameters. For instance not all systems require\n",
-      "dihedral interactions.\n",
-      "\n",
-      "\n",
-      "Writing LAMMPS datafile\n",
-      "Writing verbose comment file\n",
-      "\n",
-      "\n",
-      "All outputs can be found in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp directory\n",
-      "\n",
-      "\n",
-      "Each energy coeff Header in the written datafile contains style hint flags for\n",
-      "applying proper settings in LAMMPS to be consistent with the energy definitions\n",
-      "and ordering of the energy parameters.\n",
-      "\n",
-      "\n",
-      "Normal program termination\n",
-      "\n",
-      "\n",
-      "Execution time in seconds: 0.057900428771972656\n",
-      "\n",
-      "\n",
-      "Number of WARNING(s) and ERROR(s)\n",
-      "  47 WARNING(s)\n",
-      "  0 ERROR(s)\n",
-      "\n",
-      "\n",
-      "Command line run option override checks (will warn if command line run option is used but not all options are provided at the command line):\n",
-      "WARNING override option   -asm               not provided at the command line. Hard coded input being enforced: frc_files/general_assumed_equivs.coeffs\n",
-      "WARNING override option   -newfile           not provided at the command line. Hard coded input being enforced: :_IFF\n",
-      "WARNING override option   -atomstyle         not provided at the command line. Hard coded input being enforced: full\n",
-      "WARNING override option   -class             not provided at the command line. Hard coded input being enforced: 2\n",
-      "WARNING override option   -auto-equivs       not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -assumed-equivs    not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -reset-molids      not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -reset-charges     not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -write-comments    not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -write-bond-react  not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -morse-bond        not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -type-labels       not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -add2box           not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -ignore            not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -rx                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -ry                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -rz                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sx                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sy                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "WARNING override option   -sz                not provided at the command line. Hard coded input being enforced: 0.0\n",
-      "\n",
-      "\n",
-      "Command line run option override inputs confirmation (will confirm to user that the command line override does override the hard coded inputs):\n",
-      "Override confirmation for -topo              Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post5/post5_typed.data\n",
-      "Override confirmation for -nta               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post5/post5_typed.nta\n",
-      "Override confirmation for -frc               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc\n",
-      "Override confirmation for -dir               Hard codeded input is being overridden with this input: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Running all2lmp: v1.22 / 14 April 2025\n",
-      "Using Python version: 3.13.12 | packaged by conda-forge | (main, Feb  5 2026, 05:53:46) [GCC 14.3.0]\n",
-      "Using Python executable: /home/janitha/miniconda3/envs/autoRX/bin/python\n",
-      "Trying Atom Equivalences if needed\n",
-      "Trying Atom Auto-Equivalences if needed\n",
-      "Trying to find atom charge based on bond-incs\n",
-      "Resetting molecule-ids based on cluster analysis\n",
-      "\n",
-      "\n",
-      "Using higher version of parameters for #equivalences N a version: 2.10 \n",
-      "Using higher version of parameters for #bond_increments si si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments c si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments c_1 cp version: 2.10 \n",
-      "Using higher version of parameters for #bond_increments cp si version: 2.20 \n",
-      "Using higher version of parameters for #bond_increments h si version: 2.20 \n",
-      "Using higher version of parameters for #quartic_bonds c o_2 version: 2.20 \n",
-      "Using higher version of parameters for #quartic_bonds c c version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c= c=1 version: 3.10 \n",
-      "Using higher version of parameters for #quartic_bonds c h version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds c_1 o_1 version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds cp h version: 2.10 \n",
-      "Using higher version of parameters for #quartic_bonds cp cp version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 h c c h version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 h c cp cp version: 2.00 \n",
-      "Using higher version of parameters for #torsion_3 c c c h version: 2.10 \n",
-      "Using higher version of parameters for #torsion_3 c c c c version: 2.10 \n",
-      "Using higher version of parameters for #wilson_out_of_plane c cp cp cp version: 2.00 \n",
-      "Using higher version of parameters for #wilson_out_of_plane cp cp cp h version: 3.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 n = version: 3.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 s ' version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 c = version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 s i version: 2.20 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 o _ 1 version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 n z version: 2.10 \n",
-      "Using higher version of parameters for #pair_coeffs_9_6 h o 2 version: 2.10 \n",
-      "Using higher version of parameters for #bondbond13 cp cp cp cp version: 2.10 \n",
-      "Using higher version of parameters for #middlebondtorsion o_1 c_1 o_2 c version: 2.10 \n",
-      "\n",
-      "Read in /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc forcefeild file\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post5/post5_typed.data LAMMPS datafile\n",
-      "Read in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post5/post5_typed.nta new-type-assignment file\n",
-      "\n",
-      "\n",
-      "\n",
-      "Getting force field parameters for the read in system\n",
-      "\n",
-      "Checking for atom-type assignment consistency with atom-types in .frc file\n",
-      "\n",
-      "\n",
-      "Finding molecules to reset molids....\n",
-      "-----------------Cluster Analysis-----------------\n",
-      "  molID    Size of Fragment     %Size of Fragment    \n",
-      "--------------------------------------------------\n",
-      "    1              32                94.12          \n",
-      "    2               2                5.88           \n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "Atoms information has been found\n",
-      "  /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/atom_typing/post5/post5_typed.data has all image flags set to zero\n",
-      "  There are 34 atoms in 2 molecules in this file\n",
-      "  The total charge in the system is -0.0000\n",
-      "\n",
-      "\n",
-      "WARNING unable to find bond info for Bond Coeff 6 c_1 nn\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 1 br cp cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 2 c= cp cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 4 c_1 nn cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 5 c_1 nn hn\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 6 cl c= cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 7 cl c= o_1\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 8 cl cp cp\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 9 cp c= o_1\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 10 cp c_1 nn\n",
-      "WARNING unable to find bondbond info for Bondbond Coeff 17 nn c_1 o_1\n",
-      "\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 1 br cp cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 2 c= cp cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 4 c_1 nn cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 5 c_1 nn hn\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 6 cl c= cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 7 cl c= o_1\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 8 cl cp cp\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 9 cp c= o_1\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 10 cp c_1 nn\n",
-      "WARNING unable to find bondangle info for Bondangle Coeff 17 nn c_1 o_1\n",
-      "\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 2 cp c_1 nn cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 3 cp c_1 nn hn\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 4 o_1 c= cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 5 nn c_1 cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 6 o_1 c_1 cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 7 br cp cp c=\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 8 br cp cp c_1\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 9 c_1 cp cp cl\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 10 c= cp cp cl\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 11 br cp cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 12 cl cp cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 13 c_1 cp cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 15 c= cp cp cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 21 o_1 c_1 nn hn\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 22 o_1 c_1 nn cp\n",
-      "WARNING unable to find angleangletorsion info for Angleangletorsion Coeff 23 cp cp nn c_1\n",
-      "\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 2 cp c_1 nn cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 3 cp c_1 nn hn\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 4 o_1 c= cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 5 nn c_1 cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 6 o_1 c_1 cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 7 br cp cp c=\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 8 br cp cp c_1\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 9 c_1 cp cp cl\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 10 c= cp cp cl\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 11 br cp cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 12 cl cp cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 13 c_1 cp cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 15 c= cp cp cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 21 o_1 c_1 nn hn\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 22 o_1 c_1 nn cp\n",
-      "WARNING unable to find endbondtorsion info for Endbondtorsion Coeff 23 cp cp nn c_1\n",
-      "\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 2 cp c_1 nn cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 3 cp c_1 nn hn\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 4 o_1 c= cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 5 nn c_1 cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 7 br cp cp c=\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 8 br cp cp c_1\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 9 c_1 cp cp cl\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 10 c= cp cp cl\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 11 br cp cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 12 cl cp cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 15 c= cp cp cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 21 o_1 c_1 nn hn\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 22 o_1 c_1 nn cp\n",
-      "WARNING unable to find middlebondtorsion info for Middlebondtorsion Coeff 23 cp cp nn c_1\n",
-      "\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 2 cp c_1 nn cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 3 cp c_1 nn hn\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 4 o_1 c= cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 5 nn c_1 cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 6 o_1 c_1 cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 7 br cp cp c=\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 8 br cp cp c_1\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 9 c_1 cp cp cl\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 10 c= cp cp cl\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 11 br cp cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 12 cl cp cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 13 c_1 cp cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 15 c= cp cp cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 21 o_1 c_1 nn hn\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 22 o_1 c_1 nn cp\n",
-      "WARNING unable to find bondbond13 info for Bondbond13 Coeff 23 cp cp nn c_1\n",
-      "\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 1 cl c= cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 2 cp c_1 nn cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 3 cp c_1 nn hn\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 4 o_1 c= cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 5 nn c_1 cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 6 o_1 c_1 cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 7 br cp cp c=\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 8 br cp cp c_1\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 9 c_1 cp cp cl\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 10 c= cp cp cl\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 11 br cp cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 12 cl cp cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 13 c_1 cp cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 15 c= cp cp cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 21 o_1 c_1 nn hn\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 22 o_1 c_1 nn cp\n",
-      "WARNING unable to find angletorsion info for Angletorsion Coeff 23 cp cp nn c_1\n",
-      "\n",
-      "\n",
-      "---------------------------------------\n",
-      "System Unit cell, volume, mass, density\n",
-      "---------------------------------------\n",
-      "Lx:         31.79040  angstrom  \n",
-      "Ly:         6.14090   angstrom  \n",
-      "Lz:         7.53120   angstrom  \n",
-      "volume:    1.4703E-21 cm^3      \n",
-      "mass:      8.6583E-22 grams     \n",
-      "density:    0.58890   g/cm^3    \n",
-      "\n",
-      "\n",
-      "\n",
-      "--------------------------------------\n",
-      "Atoms/Bonds/Angles/Dihedrals/Impropers\n",
-      "--------------------------------------\n",
-      "natoms:             34  \n",
-      "nbonds:             34  \n",
-      "nangles:            51  \n",
-      "ndihedrals:         72  \n",
-      "nimpropers:         17  \n",
-      "- oop:              17  \n",
-      "- angleangle:        0  \n",
-      "\n",
-      "--------------------------------------------\n",
-      "Atoms/Bonds/Angles/Dihedrals/Impropers Types\n",
-      "--------------------------------------------\n",
-      "natomtypes:         10  \n",
-      "nbondtypes:         13  \n",
-      "nangletypes:        17  \n",
-      "ndihedraltypes:     23  \n",
-      "nimpropertypes:     10  \n",
-      "- oop:              10  \n",
-      "- angleangle:        0  \n",
-      "\n",
-      "-------------------------------------\n",
-      "Parameterization percentage breakdown\n",
-      "-------------------------------------\n",
-      "Masses:                      100.00 %\n",
-      "Pair Coeffs:                 100.00 %\n",
-      "Bond Coeffs:                 92.31  %\n",
-      "Angle Coeffs:                100.00 %\n",
-      "Dihedral Coeffs:             100.00 %\n",
-      "Improper Coeffs:             100.00 %\n",
-      "Average MPBADI Coeffs:       98.72  %\n",
-      "BondBond Coeffs:             41.18  %\n",
-      "BondAngle Coeffs:            41.18  %\n",
-      "AngleAngleTorsion Coeffs:    26.09  %\n",
-      "EndBondTorsion Coeffs:       26.09  %\n",
-      "MiddleBondTorsion Coeffs:    34.78  %\n",
-      "BondBond13 Coeffs:           26.09  %\n",
-      "AngleTorsion Coeffs:         26.09  %\n",
-      "AngleAngle Coeffs:           100.00 %\n",
-      "Average (without Bond-incs): 67.50  %\n",
-      "Bond-incs:                   100.00 %\n",
-      "\n",
-      "User is acknowledging that all2lmp.py can not supply a fully parameterized datafile as\n",
-      "the /mnt/c/Users/Janitha/Documents/GitHub/LUNAR/frc_files/pcff.frc doesnt contain all parameters\n",
-      "to parameterize every interaction. The user is responsible for deciding on how to handle\n",
-      "missing parameters in the written datafile. Please note that it is possible that the inputs\n",
-      "to all2lmp.py are incorrect causing this message and that a certain atom type maybe wrong, \n",
-      "where it might be easier to correct the inputs to all2lmp.py rather then correct the outputs\n",
-      "of all2lmp.py. Alternativley missing parameters are set to ZEROs, by all2lmp.py and it is\n",
-      "possible that interaction doesnt require parameters. For instance not all systems require\n",
-      "dihedral interactions.\n",
-      "\n",
-      "\n",
-      "Writing LAMMPS datafile\n",
-      "Writing verbose comment file\n",
-      "\n",
-      "\n",
-      "All outputs can be found in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp directory\n",
-      "\n",
-      "\n",
-      "Each energy coeff Header in the written datafile contains style hint flags for\n",
-      "applying proper settings in LAMMPS to be consistent with the energy definitions\n",
-      "and ordering of the energy parameters.\n",
-      "\n",
-      "\n",
-      "Normal program termination\n",
-      "\n",
-      "\n",
-      "Execution time in seconds: 0.06306314468383789\n",
-      "\n",
-      "\n",
-      "Number of WARNING(s) and ERROR(s)\n",
-      "  104 WARNING(s)\n",
-      "  0 ERROR(s)\n",
-      "[LUNAR all2lmp] Generated file for tmc at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp/tmc_typed_IFF.data\n",
-      "[LUNAR all2lmp] Generated file for mpd at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp/mpd_typed_IFF.data\n",
-      "[LUNAR all2lmp] Generated file for ethanol at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp/ethanol_typed_IFF.data\n",
-      "[LUNAR all2lmp] Generated file for pre1 at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp/pre1_typed_IFF.data\n",
-      "[LUNAR all2lmp] Generated file for post1 at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp/post1_typed_IFF.data\n",
-      "[LUNAR all2lmp] Generated file for pre5 at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp/pre5_typed_IFF.data\n",
-      "[LUNAR all2lmp] Generated file for post5 at: /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp/post5_typed_IFF.data\n",
-      "\n",
-      "\n",
-      "Running bond_react_merge: v1.18 / 9 February 2026\n",
-      "Using Python version: 3.13.12 | packaged by conda-forge | (main, Feb  5 2026, 05:53:46) [GCC 14.3.0]\n",
-      "Using Python executable: /home/janitha/miniconda3/envs/autoRX/bin/python\n",
-      "\n",
-      "\n",
-      "Command line run option override checks (will warn if command line run option is used but not all options are provided at the command line):\n",
-      "WARNING override option   -dir                     not provided at the command line. Hard coded input being enforced: topofile\n",
-      "WARNING override option   -map                     not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -write-rxn-mol2files     not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -write-moleculefiles     not provided at the command line. Hard coded input being enforced: True\n",
-      "WARNING override option   -edge                    not provided at the command line. Hard coded input being enforced: False\n",
-      "WARNING override option   -molecule                not provided at the command line. Hard coded input being enforced: ['']\n",
-      "WARNING override option   -newfile                 not provided at the command line. Hard coded input being enforced: :_merged\n",
-      "\n",
-      "\n",
-      "Command line run option override inputs confirmation (will confirm to user that the command line override does override the hard coded inputs):\n",
-      "Override confirmation for -files                 Hard codeded input is being overridden with this input: {'infile': 'merge_input.txt'}\n",
-      "Override confirmation for -atomstyle             Hard codeded input is being overridden with this input: full\n",
-      "Override confirmation for -write-rxn-datafiles   Hard codeded input is being overridden with this input: True\n",
-      "Override confirmation for -type-labels           Hard codeded input is being overridden with this input: True\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "The following files and their corresponding filetags have been read in from merge_input.txt:\n",
-      " data1   /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp/tmc_typed_IFF.data\n",
-      " data2   /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp/mpd_typed_IFF.data\n",
-      " data3   /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp/ethanol_typed_IFF.data\n",
-      "  pre1   /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp/pre1_typed_IFF.data\n",
-      " post1   /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp/post1_typed_IFF.data\n",
-      "  pre2   /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp/pre5_typed_IFF.data\n",
-      " post2   /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp/post5_typed_IFF.data\n",
-      "\n",
-      "\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|                read in files key to value dictionary map to organize files                |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|      key to      |                          value to dictionary                           |\n",
-      "|    dictionary    |                                filename                                |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "|      data1       |                           tmc_typed_IFF.data                           |\n",
-      "|      data2       |                           mpd_typed_IFF.data                           |\n",
-      "|      data3       |                         ethanol_typed_IFF.data                         |\n",
-      "|       pre1       |                          pre1_typed_IFF.data                           |\n",
-      "|      post1       |                          post1_typed_IFF.data                          |\n",
-      "|       pre2       |                          pre5_typed_IFF.data                           |\n",
-      "|      post2       |                          post5_typed_IFF.data                          |\n",
-      "---------------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "-------------------------------------------------------------------------------------------------------------------------------------------\n",
-      "|                                filename                                |   natom    |   nbond    |   nangle   | ndihedral  |  improper  |\n",
-      "|                      (Truncated to 70 characters)                      |   types    |   types    |   types    |   types    |   types    |\n",
-      "-------------------------------------------------------------------------------------------------------------------------------------------\n",
-      "|                           tmc_typed_IFF.data                           |     5      |     6      |     7      |     8      |     4      |\n",
-      "|                           mpd_typed_IFF.data                           |     4      |     4      |     5      |     6      |     3      |\n",
-      "|                         ethanol_typed_IFF.data                         |     5      |     5      |     7      |     4      |     5      |\n",
-      "|                          pre1_typed_IFF.data                           |     8      |     9      |     11     |     13     |     7      |\n",
-      "|                          post1_typed_IFF.data                          |     10     |     13     |     17     |     22     |     10     |\n",
-      "|                          pre5_typed_IFF.data                           |     8      |     9      |     11     |     13     |     7      |\n",
-      "|                          post5_typed_IFF.data                          |     10     |     13     |     17     |     23     |     10     |\n",
-      "-------------------------------------------------------------------------------------------------------------------------------------------\n",
-      "|                          Total possible sum:                           |     50     |     59     |     75     |     89     |     46     |\n",
-      "-------------------------------------------------------------------------------------------------------------------------------------------\n",
-      "|                           Total unique sum:                            |     14     |     18     |     24     |     27     |     15     |\n",
-      "-------------------------------------------------------------------------------------------------------------------------------------------\n",
-      "Internally determined force field is class2\n",
-      "Using path from 1st file in files dictionary to set parent_directory ...\n",
-      "\n",
-      "\n",
-      "************************************************************************************************************\n",
-      "************************************************************************************************************\n",
-      "************************************************************************************************************\n",
-      "***  Using generate_map_file, which auto-generates the map file based on tag-ID for preN/postN pairings. ***\n",
-      "***  PLEASE CONFIRM preN tagged file is consistent with postN tagged file. Each section is set by the    ***\n",
-      "***  following methods:                                                                                  ***\n",
-      "***      InitiatorIDs                                                                                    ***\n",
-      "***          Will be initialized as \"ID1\" and \"ID2\", then if two molecues are found in the preN tagged   ***\n",
-      "***          file and edgeIDs were found, a 1st attempt at setting the InitiatorIDs is to search 4-6     ***\n",
-      "***          neighbors away from all edgeIDs and select to most unique atom-type in each molecule. If    ***\n",
-      "***          the code can find all equivalences (which are assumed to be correct), a 2nd attempt is then ***\n",
-      "***          tried where the code applies a backwards map of all atomIDs in the postN tagged file to the ***\n",
-      "***          preN tagged file. After the backwards mapping the code tries to find the bond responsible   ***\n",
-      "***          that links the preN tagged-file two molecules together in the postN tagged-file. If this    ***\n",
-      "***          \"linking\" bond can be found, the InitiatorIDs are updated with to the new \"linking\" atomIDs.***\n",
-      "***      EdgeIDs                                                                                         ***\n",
-      "***          Set by searching for the number of bonded atoms to each atom type in the dataN tagged files ***\n",
-      "***          and comparing them to the preN/postN tagged files, if the number of bonded atoms for each   ***\n",
-      "***          atom type is found to be different IT MUST BE AN EDGE ATOM (assumes correct atom-typing,    ***\n",
-      "***          thus if no edge atoms are found it is an indication that atom types are not consistent      ***\n",
-      "***          between the dataN tagged files and the preN tagged files).                                  ***\n",
-      "***      DeleteIDs                                                                                       ***\n",
-      "***           Will automatically be found by the code if the code can find all equivalences (which are   ***\n",
-      "***           assumed to be correct). The code will warn the user that deleteIDs were detected which are ***\n",
-      "***           determined by if the postN tagged files has more then one molecular fragment, the largest  ***\n",
-      "***           frament is kept and the smaller ones are are assumed to be deleteIDs. Once the smaller     ***\n",
-      "***           fragments are found the atomIDs are mapped backwards onto the preN tagged atomIDs. Thus if ***\n",
-      "***           the Equivalences are found to be wrong its possible that the DeleteIDs are wrong, however  ***\n",
-      "***           in the *_commented.txt map file there will be a comment on the atomID it is in the postN   ***\n",
-      "***           tagged file which can be used to help reset the DeleteIDs if needed during checking of the ***\n",
-      "***           generated map file.                                                                        ***\n",
-      "***      Equivalences                                                                                    ***\n",
-      "***           Set by a pseudo-graph-theory/cost-based algorithm were each preN/postN tagged pair are     ***\n",
-      "***           converted to graphs. The atom-types, number of bonded neighbors (nb), elements, atomIDs,   ***\n",
-      "***           molID (reset by code), molecule formula, and relative location of atom in the template is  ***\n",
-      "***           used to assign a map cost. Then an incremented approach of slowly increase an acceptable   ***\n",
-      "***           cost is then used where the lower cost mappings are assigned first (best matches) and the  ***\n",
-      "***           atomIDs that have the worst map are set last (due to creation of new topologies).          ***\n",
-      "***  In general, it is up to the user to check all information in the generated map files is correct.    ***\n",
-      "***  NOTE: terminating atoms like H do NOT require perfect mapping since nothing is bonded \"through\"     ***\n",
-      "***  them. The code is designed to try getting everything correct, but there are scenerios where the     ***\n",
-      "***  code may not be able to due to the complexity present in the generation of the map files.           ***\n",
-      "************************************************************************************************************\n",
-      "************************************************************************************************************\n",
-      "************************************************************************************************************\n",
-      "\n",
-      "\n",
-      "Writing in.fix_bond_react.script\n",
-      "\n",
-      "\n",
-      "\n",
-      "****************************************************\n",
-      "* Finding rxn map/super-impose file for rxnid:  1  *\n",
-      "****************************************************\n",
-      "\n",
-      "  ----------------------Pre  rxn Cluster Analysis-----------------------\n",
-      "    molID     Molecule Size   %Size of Molecule         formula       \n",
-      "  ----------------------------------------------------------------------\n",
-      "      1              18             52.94            Br1-C9-Cl5-O3    \n",
-      "      2              16             47.06               C6-H8-N2      \n",
-      "\n",
-      "\n",
-      "  ----------------------Post rxn Cluster Analysis-----------------------\n",
-      "    molID     Molecule Size   %Size of Molecule         formula       \n",
-      "  ----------------------------------------------------------------------\n",
-      "      1              32             94.12         Br1-C15-Cl4-H7-N2-O3\n",
-      "      2               2              5.88                Cl1-H1       \n",
-      "\n",
-      "    WARNING It was detected that post1_typed_IFF.data post-rxn has more then one molecule. This engaged the\n",
-      "    auto-deleteIDs detection and the written pre1-post1_rxn-map contains deleteIDs for the following pre-rxn-ids:\n",
-      "    Pre-rxn-atomID:   3   has a Post-rxn-atomID:  33   that belongs to a Post-molID:   2   and has been tagged for deletion\n",
-      "    Pre-rxn-atomID:  34   has a Post-rxn-atomID:  34   that belongs to a Post-molID:   2   and has been tagged for deletion\n",
-      "  pre1 -> post1 rxn map equivalences converged in 281 iterations with a max cost of 141\n",
-      "\n",
-      "\n",
-      "\n",
-      "\n",
-      "****************************************************\n",
-      "* Finding rxn map/super-impose file for rxnid:  2  *\n",
-      "****************************************************\n",
-      "\n",
-      "  ----------------------Pre  rxn Cluster Analysis-----------------------\n",
-      "    molID     Molecule Size   %Size of Molecule         formula       \n",
-      "  ----------------------------------------------------------------------\n",
-      "      1              18             52.94            Br1-C9-Cl5-O3    \n",
-      "      2              16             47.06               C6-H8-N2      \n",
-      "\n",
-      "\n",
-      "  ----------------------Post rxn Cluster Analysis-----------------------\n",
-      "    molID     Molecule Size   %Size of Molecule         formula       \n",
-      "  ----------------------------------------------------------------------\n",
-      "      1              32             94.12         Br1-C15-Cl4-H7-N2-O3\n",
-      "      2               2              5.88                Cl1-H1       \n",
-      "\n",
-      "    WARNING It was detected that post5_typed_IFF.data post-rxn has more then one molecule. This engaged the\n",
-      "    auto-deleteIDs detection and the written pre2-post2_rxn-map contains deleteIDs for the following pre-rxn-ids:\n",
-      "    Pre-rxn-atomID:  16   has a Post-rxn-atomID:  33   that belongs to a Post-molID:   2   and has been tagged for deletion\n",
-      "    Pre-rxn-atomID:  34   has a Post-rxn-atomID:  34   that belongs to a Post-molID:   2   and has been tagged for deletion\n",
-      "  pre2 -> post2 rxn map equivalences converged in 281 iterations with a max cost of 141\n",
-      "\n",
-      "\n",
-      "\n",
-      "Writing in.create_atoms.script\n",
-      "\n",
-      "\n",
-      "************************************************************************************************  \n",
-      "*** Only modification to molecule template is to update charges on edge atoms if not updated *** \n",
-      "************************************************************************************************ \n",
-      "\n",
-      "\n",
-      "All outputs can be found in /mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp directory\n",
-      "\n",
-      "\n",
-      "Normal program termination\n",
-      "\n",
-      "\n",
-      "Execution time in seconds: 0.9023401737213135\n",
-      "\n",
-      "\n",
-      "Number of WARNING(s) and ERROR(s)\n",
-      "  2 WARNING(s)\n",
-      "  0 ERROR(s)\n",
-      "[LUNAR bond_react_merge] Generated molecule files for tmc\n",
-      "[LUNAR bond_react_merge] Generated molecule files for mpd\n",
-      "[LUNAR bond_react_merge] Generated molecule files for ethanol\n",
-      "[LUNAR bond_react_merge] Generated template files for reaction 1\n",
-      "[LUNAR bond_react_merge] Generated template files for reaction 5\n"
-     ]
-    }
-   ],
    "source": [
+    "### Lunar Workflow\n",
     "\n",
-    "lunar_api_wrapper = LunarAPIWrapper(cache_dir)\n",
-    "lunar_results = lunar_api_wrapper.lunar_workflow(updated_inputs_with_3d_mols, prepared_reactions_with_3d_mols)"
+    "Run the Lunar workflow to generate simulation-ready files from prepared 3D structures."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
-   "id": "9b9c37b0",
+   "execution_count": null,
+   "id": "c6a74035",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "LunarFiles(force_field_data=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/bond_react_merge/force_field.data'), in_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/all2lmp/in.create_atoms.script'), molecule_files=[MoleculeFile(id='tmc', molecule_files=DataFiles(data_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/bond_react_merge/tmc_typed_IFF_merged.data'), lmp_molecule_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/bond_react_merge/tmc_typed_IFF_merged.lmpmol'))), MoleculeFile(id='mpd', molecule_files=DataFiles(data_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/bond_react_merge/mpd_typed_IFF_merged.data'), lmp_molecule_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/bond_react_merge/mpd_typed_IFF_merged.lmpmol'))), MoleculeFile(id='ethanol', molecule_files=DataFiles(data_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/bond_react_merge/ethanol_typed_IFF_merged.data'), lmp_molecule_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/bond_react_merge/ethanol_typed_IFF_merged.lmpmol')))], template_files=[TemplateFile(reaction_id=1, pre_reaction_file=DataFiles(data_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/bond_react_merge/pre1_typed_IFF_merged.data'), lmp_molecule_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/bond_react_merge/pre1_typed_IFF_merged.lmpmol')), post_reaction_file=DataFiles(data_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/bond_react_merge/post1_typed_IFF_merged.data'), lmp_molecule_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/bond_react_merge/post1_typed_IFF_merged.lmpmol'))), TemplateFile(reaction_id=5, pre_reaction_file=DataFiles(data_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/bond_react_merge/pre5_typed_IFF_merged.data'), lmp_molecule_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/bond_react_merge/pre5_typed_IFF_merged.lmpmol')), post_reaction_file=DataFiles(data_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/bond_react_merge/post5_typed_IFF_merged.data'), lmp_molecule_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/bond_react_merge/post5_typed_IFF_merged.lmpmol')))])\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "print(lunar_results)"
+    "lunar_api_wrapper = LunarAPIWrapper(cache_dir)\n",
+    "\n",
+    "lunar_results = lunar_api_wrapper.lunar_workflow(\n",
+    "    updated_inputs_with_3d_mols,\n",
+    "    prepared_reactions_with_3d_mols\n",
+    ")"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "52d28045",
+   "cell_type": "markdown",
+   "id": "fff1fc61",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Preparing templates and map file for reaction ID: 1\n",
-      "Preparing templates and map file for reaction ID: 5\n"
-     ]
-    }
-   ],
    "source": [
-    "from AutoREACTER.reaction_preparation.lunar_client.REACTER_files_builder import REACTERFilesBuilder\n",
-    "REACTER_files_builder = REACTERFilesBuilder(cache_dir=cache_dir, updated_inputs_with_3d_mols=updated_inputs_with_3d_mols)\n",
-    "reacter_files = REACTER_files_builder.molecule_template_preparation(lunar_files=lunar_results,\n",
-    "    prepared_reactions_with_3d_mols=prepared_reactions_with_3d_mols\n",
-    ")"
+    "### REACTER File Generation and Finalization\n",
+    "\n",
+    "Generate REACTER-compatible files from the Lunar results and prepared reactions.  \n",
+    "The generated files are then moved to the final run directory, and all internal paths are updated accordingly."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
-   "id": "e613b076",
+   "execution_count": null,
+   "id": "52d28045",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "REACTERFiles(force_field_data=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/REACTER_files/force_field.data'), in_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/REACTER_files/in.create_atoms.script'), molecule_files=[MoleculeFile(id='tmc', molecule_files=DataFiles(lmp_molecule_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/REACTER_files/tmc.molecule'))), MoleculeFile(id='mpd', molecule_files=DataFiles(lmp_molecule_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/REACTER_files/mpd.molecule'))), MoleculeFile(id='ethanol', molecule_files=DataFiles(lmp_molecule_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/REACTER_files/ethanol.molecule')))], template_files=[TemplateFile(reaction_id=1, map_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/REACTER_files/RXN_1.map'), pre_reaction_file=DataFiles(lmp_molecule_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/REACTER_files/template_pre_1.molecule')), post_reaction_file=DataFiles(lmp_molecule_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/REACTER_files/template_post_1.molecule'))), TemplateFile(reaction_id=5, map_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/REACTER_files/RXN_5.map'), pre_reaction_file=DataFiles(lmp_molecule_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/REACTER_files/template_pre_5.molecule')), post_reaction_file=DataFiles(lmp_molecule_file=PosixPath('/mnt/c/Users/Janitha/Documents/AutoREACTER/cache/00_cache/lunar/REACTER_files/template_post_5.molecule')))])\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "print(reacter_files)"
+    "REACTER_files_builder = REACTERFilesBuilder(\n",
+    "    cache_dir=cache_dir,\n",
+    "    updated_inputs_with_3d_mols=updated_inputs_with_3d_mols\n",
+    ")\n",
+    "\n",
+    "reacter_files = REACTER_files_builder.molecule_template_preparation(\n",
+    "    lunar_files=lunar_results,\n",
+    "    prepared_reactions_with_3d_mols=prepared_reactions_with_3d_mols\n",
+    ")\n",
+    "\n",
+    "reacter_files = run_manager.move_reacter_files(\n",
+    "    reacter_files,\n",
+    "    staging_dir=cache_dir,\n",
+    "    final_dir=output_dir\n",
+    ")"
    ]
   }
  ],
diff --git a/examples/example_1_inputs_count_mode.json b/examples/example_1_inputs_count_mode.json
index bcbaa2e..872981e 100644
--- a/examples/example_1_inputs_count_mode.json
+++ b/examples/example_1_inputs_count_mode.json
@@ -1,59 +1,52 @@
 {
-
     "simulation_name": "Example_Count_Mode",
-
     "replicas": {
-        "temperatures": [300, 400, 500],
-        "density": [0.8],
         "method": "counts",
-
         "systems": [
-
             {
                 "tag": "10k",
-
+                "temperature": 300,
+                "density": 0.8,
                 "monomer_counts": {
-                    "tmc": 220,
-                    "mpd": 220,
-                    "ethanol": 110,
-                    "data_4": 55
+                "tmc": 220,
+                "mpd": 220,
+                "data_3": 110
                 }
             },
-
             {
                 "tag": "100k",
-
+                "temperature": 400,
+                "density": 0.8,
                 "monomer_counts": {
-                    "tmc": 2200,
-                    "mpd": 2200,
-                    "ethanol": 1100,
-                    "data_4": 550
+                "tmc": 2200,
+                "mpd": 2200,
+                "data_3": 1100
+                }
+            },
+            {
+                "tag": "100k_high_temp",
+                "temperature": 500,
+                "density": 0.8,
+                "monomer_counts": {
+                "tmc": 2200,
+                "mpd": 2200,
+                "data_3": 1100
                 }
             }
-
         ]
     },
-
     "monomers": [
-
-        {
-            "name": "tmc",
-            "smiles": "CC(O)C(O)CCCCc1c(C(=O)Cl)cc(C(=O)Cl)cc1C(=O)Cl"
-        },
-
         {
-            "name": "mpd",
-            "smiles": "C1=CC(=CC(=C1)N)N"
+        "name": "tmc",
+        "smiles": "ClC(=O)c1cc(cc(c1)C(Cl)=O)C(Cl)=O"
         },
-
         {
-            "name": "ethanol",
-            "smiles": "CCO"
+        "name": "mpd",
+        "smiles": "C1=CC(=CC(=C1)N)N"
         },
         {
-            "name": "data_4",
-            "smiles": "CCN"
+        "name": "data_3",
+        "smiles": "CCO"
         }
-
     ]
-}
+}
\ No newline at end of file
diff --git a/examples/example_1_inputs_count_mode_FF.json b/examples/example_1_inputs_count_mode_FF.json
index e9c3755..f8b4634 100644
--- a/examples/example_1_inputs_count_mode_FF.json
+++ b/examples/example_1_inputs_count_mode_FF.json
@@ -1,45 +1,43 @@
 {
-  "simulation_name": "Example_Count_Mode",
-
-  "replicas": {
-    "temperatures": [300, 400, 500],
-    "density": [0.8],
-    "method": "counts",
-
-    "systems": [
-      {
-        "tag": "10k",
-        "monomer_counts": {
-          "tmc": 220,
-          "mpd": 220,
-          "data_3": 110
-        }
-      },
-      {
-        "tag": "100k",
-        "monomer_counts": {
-          "tmc": 2200,
-          "mpd": 2200,
-          "data_3": 1100
+    "simulation_name": "Example_Count_Mode",
+    "force_field": "PCFF",
+    "replicas": {
+        "method": "counts",
+        "systems": [
+            {
+                "tag": "10k",
+                "temperature": 300,
+                "density": 0.8,
+                "monomer_counts": {
+                "tmc": 220,
+                "mpd": 220,
+                "ethanol": 110
+                }
+            },
+            {
+                "tag": "100k",
+                "temperature": 400,
+                "density": 0.8,
+                "monomer_counts": {
+                "tmc": 2200,
+                "mpd": 2200,
+                "ethanol": 1100
+                }
+            }
+        ]
+    },
+    "monomers": [
+        {
+        "name": "tmc",
+        "smiles": "ClC(=O)c1cc(cc(c1)C(Cl)=O)C(Cl)=O"
+        },
+        {
+        "name": "mpd",
+        "smiles": "C1=CC(=CC(=C1)N)N"
+        },
+        {
+        "name": "ethanol",
+        "smiles": "CCO"
         }
-      }
     ]
-  },
-
-  "force_field": "PCFF",
-
-  "monomers": [
-    {
-      "name": "tmc",
-      "smiles": "ClC(=O)c1cc(cc(c1)C(Cl)=O)C(Cl)=O"
-    },
-    {
-      "name": "mpd",
-      "smiles": "C1=CC(=CC(=C1)N)N"
-    },
-    {
-      "name": "data_3",
-      "smiles": "CCO"
-    }
-  ]
 }
\ No newline at end of file
diff --git a/examples/example_1_inputs_count_mode_with_non_monomers.json b/examples/example_1_inputs_count_mode_with_non_monomers.json
deleted file mode 100644
index 27f800a..0000000
--- a/examples/example_1_inputs_count_mode_with_non_monomers.json
+++ /dev/null
@@ -1,46 +0,0 @@
-{
-
-    "simulation_name": "Example_Count_Mode",
-
-    "replicas": {
-        "temperatures": [300, 400, 500],
-        "density": [0.8],
-        "method": "counts",
-
-        "systems": [
-
-            {
-                "tag": "10k",
-
-                "monomer_counts": {
-                    "tmc": 220,
-                    "mpd": 220
-                }
-            },
-
-            {
-                "tag": "100k",
-
-                "monomer_counts": {
-                    "tmc": 2200,
-                    "mpd": 2200
-                }
-            }
-
-        ]
-    },
-
-    "monomers": [
-
-        {
-            "name": "tmc",
-            "smiles": "ClC(=O)c1cc(cc(c1)C(Cl)=O)C(Cl)=O"
-        },
-
-        {
-            "name": "mpd",
-            "smiles": "C1=CC(=CC(=C1)N)N"
-        }
-        
-    ]
-}
diff --git a/examples/example_1_inputs_ratio_mode.json b/examples/example_1_inputs_ratio_mode.json
index b46ede2..26edd37 100644
--- a/examples/example_1_inputs_ratio_mode.json
+++ b/examples/example_1_inputs_ratio_mode.json
@@ -1,56 +1,44 @@
 {
-
-        "simulation_name": "Example_Ratio_Mode",
-
-        "replicas": {
-            "temperatures": [300, 400],
-            "density": [0.8],
-            "method": "ratio",
-
-            "systems": [
-
-                {
-                    "tag": "10k_base",
-                    "total_atoms": 10000,
-
-                    "monomer_ratios": {
-                        "tmc": 1.0,
-                        "mpd": 1.0,
-                        "ethanol": 0.5
-                    }
-                },
-
-                {
-                    "tag": "100k_base",
-                    "total_atoms": 100000,
-
-                    "monomer_ratios": {
-                        "tmc": 1.0,
-                        "mpd": 1.0,
-                        "ethanol": 0.5
-                    }
-                }
-
-            ]
-        },
-
-        "monomers": [
-
-            {
-                "name": "tmc",
-                "smiles": "ClC(=O)c1cc(cc(c1)C(Cl)=O)C(Cl)=O"
-            },
-
+    "simulation_name": "Example_Ratio_Mode",
+    "replicas": {
+        "method": "ratio",
+        "systems": [
             {
-                "name": "mpd",
-                "smiles": "C1=CC(=CC(=C1)N)N"
+                "tag": "10k_base",
+                "temperature": 300,
+                "density": 0.8,
+                "total_atoms": 10000,
+                "monomer_ratios": {
+                    "tmc": 1.0,
+                    "mpd": 1.0,
+                    "ethanol": 0.5
+                }
             },
-
             {
-                "name": "ethanol",
-                "smiles": "CCO"
+                "tag": "100k_base",
+                "temperature": 400,
+                "density": 0.8,
+                "total_atoms": 100000,
+                "monomer_ratios": {
+                    "tmc": 1.0,
+                    "mpd": 1.0,
+                    "ethanol": 0.5
+                }
             }
-
         ]
-    }
-    
+    },
+    "monomers": [
+        {
+            "name": "tmc",
+            "smiles": "ClC(=O)c1cc(cc(c1)C(Cl)=O)C(Cl)=O"
+        },
+        {
+            "name": "mpd",
+            "smiles": "C1=CC(=CC(=C1)N)N"
+        },
+        {
+            "name": "ethanol",
+            "smiles": "CCO"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/reaction.png b/reaction.png
deleted file mode 100644
index bfd9423..0000000
Binary files a/reaction.png and /dev/null differ